@homie-rocks/studio 0.38.0 → 0.40.0

package/starters/ember-vale/src/{main.ts → view.ts}

@@ -1,62 +1,18 @@
-/*
- * EMBER VALE — the persistent-character starter (@homie-rocks/studio/saves; the guide is saves/SAVES.md).
- *
- * Two kinds of state, kept apart on purpose:
- *
- *   THE ROOM (createRoom, netplay): tonight's hunt. Bodies, slimes, the clock, who struck what. Rounds ("nights")
- *   start the moment the first browser arrives (bots in the empty seats), arrivals take a bot's place, and a room
- *   forgets everything 60 s after its last player leaves. That is fine: nothing here has to last.
- *
- *   THE SAVE (createSaves): your hero. Name, level, experience, gold, hardcore or not. Loaded when you arrive,
- *   saved when it changes, on this device at once and in the studio's cloud when online, so it follows you to
- *   every device you sign in on. Lifetime stats (kills, gold, time played) only add up and outlive any hero.
- *
- * The host decides who killed what and sends the killer a `loot` event; only the hero's own browser changes the
- * hero and saves it. A hardcore hero who falls becomes a memorial in the Hall of the Fallen, and its save is wiped
- * in the same step (saves.fall). Canvas 2D on purpose: the point is the pattern, in a few hundred lines.
- *
- * NAMES: the room knows a person by their seat's name (their account's, else a two-word handle such as "Velvet
- * Comet"); the vale shows their HERO's name, over their head and in the night's ranking, for them and for everyone
- * else. Each hero's browser tells the host its hero's name (a `hero` event); the host keeps every seat's in the keyed
- * state `heroes`, which a new host and a late joiner have already. On a kids server nobody's typed name reaches
- * anyone else (NETPLAY.md section 17): there the others are shown by their handles, as the room has them.
- *
- * A watcher (/<game>/watch, contract revision 5) has no hero and makes none: `room.viewSeat()` is the hero it
- * follows, drawn in gold as a hero's own browser draws itself, with that hero's panel; nobody followed, the vale.
- * The host says who slew what (`slain`), so a watcher on Auto cuts to the kill.
- *
- * Servers and the skill dial (contract revision 6): the vale's bots hunt at the room's dial (`room.skillOf(body)`:
- * how soon they notice a slime, how close they stand, how often they strike), and a beginner server's AI guide seats
- * are kept as AI bodies, marked " · AI". createRoom does the seats; the bots below read the dial.
- *
- * AI GUIDES (contract revision 7, @homie-rocks/studio/agents): on a beginner server the guide seats get a brain. The
- * vale's own words for it are ../agents.json: the goals a guide may take (follow, quest, lead, guard, back), the lines
- * it may say, and the asks a new hero can tap ("Help me with King Slime", "Take me to camp", "No thanks"). The HANDS
- * below play every frame at the dial: they walk to the goal, hunt what the goal says, and tell agents.done() when it is
- * done. The BRAIN is the server's (the Table's Workers AI, the owner's key, or the owner's own Claude in the seat); with
- * none, or between its decisions, `decide` below is the floor. A guide's line is drawn as a bubble from agents.json,
- * never from a model; "Quiet AI" hides them.
- *
- * THE GAME LAB (`homie-studio lab ember-vale`): the strike is tuned in the lab. Its numbers are tunables.json (read
- * with lab.tunables: the lab's sliders move them and write kept values back), and the game tells the lab what a strike
- * is doing: its phases, the struck slime's hit points, squash and push, poses for the onion skin and arcs, and views.
- * The take "strike" (lab.json) stands a big training slime in front of the hero (lab.stage "dummy"). Outside the lab
- * every lab call is a no-op.
- */
-import { AI_MARK, BUBBLE_FONT, createBubbles, createControls, createLabels, createRoom, paintBubbles, type BubbleIn, type BubbleOut, createSaves, easeView, exposePort, fitView, jitter, q, standoff, stripAi, type BodyBase, type DecidePicks, type Fit, type LabelIn, type LabelOut, type NetEvent, type Skill } from '@homie-rocks/studio/port';
-import { useAgents, type Goal, type Vocabulary } from '@homie-rocks/studio/agents';
-import vocabulary from '../agents.json';
+/** Ember Vale: server-run hunts, with the hero save and memorials owned by its player. */
+import { AI_MARK, BUBBLE_FONT, createBubbles, createControls, createLabels, paintBubbles, type BubbleIn, type BubbleOut, createSaves, easeView, exposePort, fitView, stripAi, type BodyBase, type Fit, type LabelIn, type LabelOut, type NetEvent } from '@homie-rocks/studio/port';
 // The Game Lab: tunables, phases, tracks and overlays (no-ops outside the lab).
 import { lab } from '@homie-rocks/studio/lab';
-import tuning from '../tunables.json';
+import { openRoom, type Entity } from '@homie-rocks/studio/rules/view';
+import type rules from './rules';
+const room = openRoom<typeof rules>({ fallback: 'solo' });
+const net = room.net;
 
-/* ------------------------------------------------------------------ rules */
 const W = 1600;
 const H = 1000;
 const R = 22;
 const SPEED = 300;
 /** The strike's numbers (tunables.json): the file's values, or the Game Lab's sliders while it plays a take. */
-const T = lab.tunables(tuning);
+const T = { ...room.tune, strikeRange: room.tune.strikeRange * 50, slimePush: room.tune.slimePush * 50, lunge: room.tune.lunge * 50 };
 const DOWN_MS = 4000;
 const DOWN = 1;
 const STRIKING = 2;
@@ -129,404 +85,55 @@ async function fell(cause: string): Promise<void> {
   void ui.hall(`${h.name} has fallen`, `Level ${h.level}, ${h.kills} slimes, ${h.gold} gold, slain by ${cause}. The Hall remembers.`, true);
 }
 
-/* ------------------------------------------------------------------ the room */
-let slimes: Slime[] = [];
-let slimeSeq = 0;
-let spawnAt = 0;
-let kingAt = 0;
 const me = { x: W / 2, y: H / 2, face: 0, has: false, strikes: 0, flashAt: 0 };
-/** Where a guide can lead the party (agents.json "lead"). */
 const PLACES: Record<string, { x: number; y: number }> = { camp: { x: W / 2, y: H / 2 }, king: { x: W / 2, y: 120 }, 'east-woods': { x: W - 200, y: H / 2 + 30 } };
-/** When the last King Slime fell (host): a guide on the King's quest is done. */
-let kingSlainAt = 0;
-
-const room = createRoom<Body, SlimeRow[], { slimes: Slime[]; seq: number }>({
-  game: 'ember-vale',
-  maxPlayers: 8,
-  minBodies: 3,
-  roundSeconds: 90,
-  breakSeconds: 8,
-  botName: (slot) => BOT_NAMES[slot % BOT_NAMES.length] as string,
-  // createRoom gives every body in the room its own index (a mid-round arrival the lowest free one), so no two
-  // bodies ever spawn on one spot; SPREAD puts the first few far apart round the camp (0°, 180°, 90°, 270°…).
-  spawn: (slot, i) => {
-    const a = ((SPREAD[i % SPREAD.length] as number) / SPREAD.length) * Math.PI * 2;
-    const ring = 1 + Math.floor(i / SPREAD.length) * 0.5;
-    const lvl = slot.bot ? 1 + (slot.slot % 4) : 1;
-    const x = W / 2 + Math.cos(a) * 160 * ring; const y = H / 2 + Math.sin(a) * 120 * ring;
-    return { slot: slot.slot, seat: slot.seat, name: slot.name, bot: slot.bot, score: 0, x, y, hp: maxHpOf(lvl), maxHp: maxHpOf(lvl), level: lvl, face: a, flags: 0, downUntil: 0, atkAt: 0, strikeAt: 0, tx: x, ty: y };
-  },
-  pack: (b) => [q(b.x, 0), q(b.y, 0), Math.max(0, Math.round(b.hp)), b.maxHp, b.level, q(b.face, 2), b.flags],
-  unpack: (f, b) => { b.x = f[0] as number; b.y = f[1] as number; b.hp = f[2] as number; b.maxHp = f[3] as number; b.level = f[4] as number; b.face = f[5] as number; b.flags = f[6] as number; },
-  angles: [5],
-  discrete: [2, 3, 4, 6],
-  onRoundStart: () => { slimes = []; spawnAt = 0; kingAt = room.net.now() + 45_000; },
-  fastWorld: () => slimes.map((s) => [s.id, Math.round(s.x), Math.round(s.y), Math.max(0, Math.round(s.hp)), s.size]),
-  saveWorld: () => ({ slimes, seq: slimeSeq }),
-  loadWorld: (w, fast) => {
-    slimes = w?.slimes?.map((s) => ({ ...s })) ?? [];
-    slimeSeq = Math.max(w?.seq ?? 0, ...slimes.map((s) => s.id));
-    for (const [id, x, y, hp, size] of fast ?? []) {
-      const s = slimes.find((o) => o.id === id);
-      if (s) { s.x = x; s.y = y; s.hp = hp; } else slimes.push({ id, x, y, hp, maxHp: hp, size, hitAt: 0, lastHit: -1 });
-    }
-  },
-  adopt: (b) => { me.x = b.x; me.y = b.y; me.has = true; },
-  local: () => (me.has ? ({ ...mine(), x: me.x, y: me.y } as Body) : null),
-  onTakeover: (b) => { b.score = 0; b.flags = 0; b.hp = b.maxHp; },
-  // SEAT OR SOLO (NETPLAY.md section 28). A hero who is in the room but has no body in tonight's hunt (every body is
-  // somebody's, or every seat is taken) is not left watching: after four seconds they hunt on their own with bots,
-  // the line over the game says so, and they step into the room's hunt the moment it has a body for them.
-  fallback: 'solo',
-});
-const net = room.net;
 const myLevel = (): number => hero?.level ?? 1;
-
-/* ------------------------------------------------------------------ heroes' names */
-/** A hero's name as the vale shows it: one line of at most 20 characters, never ending in an AI or bot mark. */
-const heroName = (raw: unknown): string =>
-  stripAi(String(raw ?? '').replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028-\u202e\u2060-\u206f\ufeff]/g, ' ')).slice(0, 20).trim();
-/** On a kids server nobody's typed name reaches anyone else: the room's handles stay. */
-const kids = (): boolean => net.policy.kids === true;
-/** Every seat's hero name, as the host keeps it (keyed state `heroes`: seat → name). */
-const heroNames = (): Record<string, string> => net.stateOf<Record<string, string>>('heroes') ?? {};
-/** Host: one seat's hero name (null or '': none). */
-function setHeroName(seat: number, name: string | null): void {
-  const next = { ...heroNames() };
-  if (name && !kids()) next[seat] = name; else delete next[seat];
-  net.state('heroes', next);
+function viewBodies(): Body[] {
+  const bodies: Body[] = [];
+  room.each('hero', e => {
+    const row = room.status === 'offline' ? undefined : (net.slots ?? []).find(s => s.slot === e.seat);
+    const name = room.roster.find(s => s.seat === e.seat)?.name ?? `Player ${e.seat + 1}`;
+    bodies.push({ slot: e.seat, seat: e.driver === 'bot' ? null : e.seat, name, bot: e.driver !== 'person', agent: row?.agent,
+      score: e.score, x: e.pos.x * 50, y: e.pos.y * 50, hp: e.hp, maxHp: e.maxHp, level: e.level, face: Math.atan2(e.heading.y, e.heading.x),
+      flags: e.hp === 0 ? DOWN : e.striking ? STRIKING : 0,
+      downUntil: e.motion.downUntil * 50, atkAt: e.motion.attackTick * 50, strikeAt: e.motion.attackTick * 50, tx: e.target.x * 50, ty: e.target.y * 50 });
+  });
+  return bodies;
 }
-/** The name over a body and in the ranking: a person's hero's (on your own screen, yours at once), else the room's. */
+function slimeRows(): SlimeRow[] { const rows: SlimeRow[] = []; room.each('slime', e => rows.push([e.serial, e.pos.x * 50, e.pos.y * 50, e.hp, e.size])); return rows; }
+function viewBody(): Body | null { return viewBodies().find(b => b.seat === net.viewSeat && !b.bot) ?? null; }
+function guideId(slot: number): string | null { let id: string | null = null; room.each('hero', e => { if (e.seat === slot) id = e.id; }); return id; }
+const heroName = (raw: unknown): string => stripAi(String(raw ?? '').replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028-\u202e\u2060-\u206f\ufeff]/g, ' ')).slice(0, 20).trim();
+const kids = (): boolean => net.policy.kids === true;
+function heroNames(): Record<string, string> { const names: Record<string, string> = {}; room.each('hero', e => { if (e.driver === 'person' && e.name) names[e.seat] = heroName(e.name); }); return names; }
 function nameOf(b: { seat: number | null; bot: boolean; name: string; agent?: unknown }): string {
   // A bot or an AI is always the room's name for it: an AI's ends in " · AI", and no hero name may hide that.
   if (b.bot || b.agent || b.seat === null || net.isAgent(b.seat)) return b.name;
-  if (!lookOnly && hero && b.seat === room.mySeat()) return heroName(hero.name) || b.name;
+  if (!lookOnly && hero && b.seat === room.seat) return heroName(hero.name) || b.name;
   return (kids() ? '' : heroNames()[b.seat]) || b.name;
 }
-/**
- * Every frame: my hero's name goes to the host until the room has it (so a new host, a reload and a lost event all
- * heal by themselves); the host keeps only seats a person still holds.
- */
-let heroToldAt = 0;
-let heroesKeptAt = 0;
+let heroToldAt = -1e9;
 function keepNames(now: number): void {
-  const seat = room.mySeat();
-  if (!lookOnly && seat !== null) {
-    const want = hero && !kids() ? heroName(hero.name) : '';
-    if ((heroNames()[seat] ?? '') !== want) {
-      if (room.hosting) setHeroName(seat, want);
-      else if (now - heroToldAt > 1500) { heroToldAt = now; net.send('hero', { name: want }); }
-    }
-  }
-  if (!room.hosting || now - heroesKeptAt < 1000) return;
-  heroesKeptAt = now;
-  const held = new Set([...net.peers.values()].filter((p) => p.seat !== null && !p.agent && !p.watch).map((p) => String(p.seat)));
-  if (seat !== null) held.add(String(seat));
-  const names = heroNames();
-  const keep = kids() ? {} : Object.fromEntries(Object.entries(names).filter(([k]) => held.has(k)));
-  if (Object.keys(keep).length !== Object.keys(names).length) net.state('heroes', keep);
+  const own = room.me;
+  if (lookOnly || !own || now - heroToldAt < 1500) return;
+  const name = hero && !kids() ? heroName(hero.name) : '', level = Math.min(99, myLevel());
+  if (own.name !== name || own.level !== level) { heroToldAt = now; room.command('hero', { name, level }); }
 }
-
-/* ------------------------------------------------------------------ the guides' brain (agents.json) */
-type PartyRow = { seat: number; dist: number; hp: number; down: boolean };
-const greeted = new Map<number, Set<number>>();
-const warnedAt = new Map<number, number>();
-const agents = useAgents(net, vocabulary as unknown as Vocabulary, {
-  // What a guide sees (host, at most every 2 s, under 2 KB): the vale near it, never a name, an account or typed text.
-  view: (slot) => {
-    const b = room.bodies.get(slot);
-    if (!b) return {};
-    const party: PartyRow[] = [...room.bodies.values()].filter((o) => !o.bot && o.seat !== null)
-      .map((o) => ({ seat: o.seat as number, dist: Math.round(Math.hypot(o.x - b.x, o.y - b.y)), hp: Math.round((100 * o.hp) / Math.max(1, o.maxHp)), down: Boolean(o.flags & DOWN) }))
-      .filter((p) => p.dist < 900).sort((x, y) => x.dist - y.dist).slice(0, 6);
-    const king = slimes.find((o) => o.size === 3);
-    const near = slimes.filter((o) => Math.hypot(o.x - b.x, o.y - b.y) < 350).length;
-    const c = room.clock();
-    return {
-      me: { hp: Math.round((100 * b.hp) / Math.max(1, b.maxHp)), down: Boolean(b.flags & DOWN) },
-      zone: zoneOf(b.x, b.y),
-      // A brain thinks again when this changes, so it changes only for what matters: the King close, or a swarm.
-      danger: king && Math.hypot(king.x - b.x, king.y - b.y) < 450 ? 'the King Slime' : near >= 5 ? 'slimes' : null,
-      party, quests: openQuests(), slimes: { near, king: Boolean(king) }, round: { phase: c.phase, left: c.secondsLeft },
-    };
-  },
-  // The scripted floor: with no AI, over budget, and between an AI's decisions. Synchronous; it never waits.
-  decide: (v, { slot, goal }) => {
-    const a = (v['asks'] as { k: string; args: Record<string, unknown> }[] | undefined)?.[0];
-    if (a?.k === 'ask_help') return { goal: 'quest', args: { quest: a.args['quest'] }, say: 'quest_help', sayArgs: { quest: a.args['quest'] } };
-    if (a?.k === 'lead_me') return { goal: 'lead', args: { place: a.args['place'] }, say: 'follow_me', sayArgs: { place: a.args['place'] } };
-    if (a?.k === 'no_thanks') return { goal: 'back', say: 'bye' };
-    const party = (v['party'] as PartyRow[] | undefined) ?? [];
-    // What a hero asked for is carried through until it is done.
-    if (goal && goal.state === 'active' && ['quest', 'lead', 'back'].includes(goal.goal)) return null;
-    const seen = greeted.get(slot) ?? new Set<number>();
-    greeted.set(slot, seen);
-    const fresh = party.find((p) => !seen.has(p.seat) && p.dist < 420);
-    if (fresh) { seen.add(fresh.seat); return { goal: 'follow', args: { seat: fresh.seat }, say: 'hello', sayArgs: { player: fresh.seat } }; }
-    if (v['danger'] === 'the King Slime') {
-      const warn = room.net.now() - (warnedAt.get(slot) ?? 0) > 30_000;
-      if (warn) warnedAt.set(slot, room.net.now());
-      return { goal: 'guard', ...(warn ? { say: 'careful', sayArgs: { thing: 'the King Slime' } } : {}) };
-    }
-    const hurt = party.find((p) => !p.down && p.hp < 40);
-    if (hurt) return { goal: 'follow', args: { seat: hurt.seat } };
-    if (party[0]) return { goal: 'follow', args: { seat: party[0].seat } };
-    return { goal: 'lead', args: { place: 'camp' } };
-  },
-});
-/** A guide's line over its head for a few seconds: the game's own words (agents.json), never a model's. */
 const bubbles = new Map<number, { text: string; until: number }>();
-/** What the e2e probe reads: goal changes (with the ask that led to one), asks, lines. Never a name or an account. */
 const guideLog: Record<string, unknown>[] = [];
 const logGuide = (row: Record<string, unknown>): void => { guideLog.push({ at: Date.now(), ...row }); if (guideLog.length > 80) guideLog.shift(); };
-agents.on('say', (e) => { bubbles.set(e.slot, { text: e.text, until: performance.now() + 3600 }); logGuide({ ev: 'say', slot: e.slot, line: e.line }); });
-agents.on('goal', (e) => logGuide({ ev: 'goal', slot: e.slot, goal: e.goal.goal, args: e.goal.args, from: e.goal.from, askAt: e.askAt }));
-agents.on('ask', (e) => logGuide({ ev: 'ask', slot: e.slot, k: e.k, args: e.args, from: e.from }));
-function mine(): Body {
-  const b = room.mine();
-  return b ?? ({ slot: -1, seat: room.mySeat(), name: net.name, bot: false, score: 0, x: me.x, y: me.y, hp: maxHpOf(myLevel()), maxHp: maxHpOf(myLevel()), level: myLevel(), face: me.face, flags: 0, downUntil: 0, atkAt: 0, strikeAt: 0, tx: 0, ty: 0 } as Body);
-}
-
-/* The host tells the killer (and the fallen) by seat: only the hero's own browser changes its hero. */
-net.on('event', (e: NetEvent) => {
-  const d = (e.d ?? {}) as { xp?: number; gold?: number; cause?: string; to?: number };
-  if (e.k === 'loot' && d.to === room.mySeat()) gain(Math.max(0, Number(d.xp) || 0), Math.max(0, Number(d.gold) || 0));
-  if (e.k === 'down' && d.to === room.mySeat()) void fell(String(d.cause ?? 'a slime').slice(0, 40));
-  if (e.k === 'slain' && typeof (e.d as { seat?: unknown })?.seat === 'number') net.spotlight((e.d as { seat: number }).seat);
-  // A hero's browser names its hero (its own seat only: the relay stamps who sent it).
-  if (e.k === 'hero' && room.hosting && typeof e.from === 'number' && !net.isAgent(e.from)) setHeroName(e.from, heroName((e.d as { name?: unknown } | null)?.name));
-});
-function tell(b: Body, k: 'loot' | 'down', d: Record<string, unknown>): void {
-  if (b.bot || b.seat === null) return;
-  if (b.seat === room.mySeat()) { if (k === 'loot') gain(Number(d.xp), Number(d.gold)); else void fell(String(d.cause)); return; }
-  net.send(k, { ...d, to: b.seat }, b.seat);
-}
-
-function strike(b: Body, now: number): void {
-  b.atkAt = now; b.strikeAt = now;
-  const hits: Slime[] = [];
-  for (const s of slimes) {
-    if (s.hp <= 0 || Math.hypot(s.x - b.x, s.y - b.y) > T.strikeRange + s.size * 10) continue;
-    s.hp -= damageOf(b.level);
-    s.lastHit = b.slot;
-    // The hit lands, then pushes: the slime holds for the hit-stop, then eases back along the strike.
-    const d = Math.hypot(s.x - b.x, s.y - b.y) || 1;
-    s.kx = s.x; s.ky = s.y; s.kdx = (s.x - b.x) / d; s.kdy = (s.y - b.y) / d; s.kat = now + T.hitStopMs;
-    hits.push(s);
-    if (s.hp <= 0) {
-      const xp = s.size === 3 ? 60 : 6 * s.size;
-      const gold = s.size === 3 ? 50 : 2 + Math.floor(Math.random() * 4) * s.size;
-      b.score += xp;
-      if (s.size === 3) kingSlainAt = now;
-      tell(b, 'loot', { xp, gold });
-      // Everyone hears who slew it (a watcher on Auto cuts to them); the loot itself is the slayer's alone.
-      if (!b.bot && b.seat !== null) room.send('slain', { seat: b.seat });
-    }
-  }
-  if (lab.on && b.seat !== null && b.seat === room.mySeat()) labStrike(b, now, hits);
-  slimes = slimes.filter((s) => s.hp > 0);
-}
-
-function down(b: Body, now: number, cause: string): void {
-  b.flags = DOWN; b.hp = 0; b.downUntil = now + DOWN_MS;
-  tell(b, 'down', { cause });
-}
-
-function stepHost(dt: number): void {
-  const now = net.now();
-  const live = room.round?.phase === 'live';
-  const myS = room.mySeat();
-  for (const b of room.bodies.values()) {
-    if (b.flags & DOWN) {
-      if (now >= b.downUntil) { b.flags = 0; b.hp = b.maxHp; b.x = W / 2 + (Math.random() - 0.5) * 300; b.y = H / 2 + (Math.random() - 0.5) * 200; room.moved(b); }
-      continue;
-    }
-    let wants = false;
-    const guide = b.bot && b.agent?.role === 'guide' ? agents.goalOf(b.slot) : null;
-    if (guide) wants = stepGuide(b, guide, room.skillOf(b), dt, now);
-    else if (b.bot && lab.stage === 'dummy') wants = false; // the lab's training stage: bots stand by
-    else if (b.bot) {
-      // Bots are company, not carries: they hunt only what is near them, and strike slower than a person. At the
-      // room's dial (section 17): they notice a slime `reactionMs` late, hunt farther afield the more they lean to
-      // the front (positioning), aim a little off (aimNoise), and strike sooner the more aggressive they are.
-      const s = room.skillOf(b);
-      const near = nearestSlime(b.x, b.y);
-      const reach = standoff(s, 460, 220);
-      if (!b.seenAt || now - b.seenAt >= s.reactionMs) {
-        b.seenAt = now;
-        const t0 = near && Math.hypot(near.x - b.x, near.y - b.y) < reach ? near : null;
-        b.ax = t0 ? t0.x + jitter(s, 40) : undefined; b.ay = t0 ? t0.y + jitter(s, 40) : undefined;
-      }
-      const t = b.ax !== undefined && b.ay !== undefined ? { x: b.ax, y: b.ay } : null;
-      const tx = t ? t.x : b.tx; const ty = t ? t.y : b.ty;
-      if (!t && Math.hypot(b.tx - b.x, b.ty - b.y) < 30) { b.tx = 200 + Math.random() * (W - 400); b.ty = 150 + Math.random() * (H - 300); }
-      const dx = tx - b.x; const dy = ty - b.y; const dist = Math.hypot(dx, dy) || 1;
-      if (dist > 60) { b.x += (dx / dist) * SPEED * 0.75 * dt; b.y += (dy / dist) * SPEED * 0.75 * dt; b.face = Math.atan2(dy, dx); }
-      wants = Boolean(t && dist < T.strikeRange && now - b.atkAt > 1400 - 900 * s.aggression);
-    } else if (b.seat === myS) {
-      b.x = me.x; b.y = me.y; b.face = me.face; b.level = myLevel(); b.maxHp = maxHpOf(b.level);
-      wants = me.strikes > 0; me.strikes = 0;
-    } else {
-      const a = room.avatar(b);
-      if (a) {
-        room.bound(b, { x: Number(a[0]), y: Number(a[1]) }, SPEED, dt);
-        b.face = Number(a[2]) || 0;
-        // The hero's level comes from its own browser (it owns the save). A game with stakes would check it.
-        b.level = clamp(Math.floor(Number(a[3]) || 1), 1, 99); b.maxHp = maxHpOf(b.level);
-      }
-      wants = Boolean(room.presses(b)['strike']);
-    }
-    b.hp = Math.min(b.hp, b.maxHp);
-    b.flags = now - b.strikeAt < T.flashMs ? STRIKING : 0;
-    if (wants && live && now - b.atkAt > T.strikeMs) strike(b, now);
-  }
-  if (live) { stepDirector(now); stepSlimes(dt, now); }
-  // Every browser's ask buttons offer the quests open now (slow keyed state: sent only when it changes).
-  net.state('quests', openQuests());
-  room.update();
-}
-
-/* ------------------------------------------------------------------ the slimes' director (section 20, opt-in) */
-/**
- * Every 6 s of a live night the host asks the studio's decision model how the slimes should hunt (`net.decide`: Clef,
- * three typed questions, never text): a tactic, whether a wave comes now, how hard to push. It runs only when game.json
- * says "decide": true (the room answers "off" otherwise, and asks are spent from the studio's AI brains' day); without it,
- * over budget or slow, the floor answers: chase, no wave, steady, which is how the vale always played. On a kids server
- * the slimes never gang up on the most hurt hero and the vale never pushes past steady. The heroes' dial is untouched:
- * this is the slimes' mind, not the bots'.
- */
-type Tactic = 'chase' | 'surround' | 'weakest' | 'regroup';
-const TACTICS: Record<Tactic, string> = {
-  chase: 'Rush the nearest hero',
-  surround: 'Spread out and close in on a hero from every side',
-  weakest: 'Gang up on the most hurt hero',
-  regroup: 'Fall back to the King Slime and gather before the next push',
-};
-/** How often a slime comes, by pressure (0 a breather .. 4 fierce). 1100 ms at 2 is the vale as it always was. */
-const SPAWN_MS = [1900, 1450, 1100, 850, 700];
-const DIRECTOR_MS = 6000;
-const director = { tactic: 'chase' as Tactic, pressure: 2, waveLeft: 0, by: 'floor', at: 0, asking: false, log: [] as Record<string, unknown>[] };
-const directorFloor = (): DecidePicks => ({ tactic: 'chase', wave: false, pressure: 2 });
-function stepDirector(now: number): void {
-  if (!room.hosting || director.asking || now < director.at) return;
-  director.at = now + DIRECTOR_MS;
-  director.asking = true;
-  const kidsRoom = kids();
-  const king = slimes.find((o) => o.size === 3);
-  const heroes = [...room.bodies.values()].filter((b) => !b.bot && b.seat !== null);
-  const state = {
-    heroes: heroes.map((b) => ({ hp: Math.round((100 * b.hp) / Math.max(1, b.maxHp)), down: Boolean(b.flags & DOWN), level: b.level, nearKing: king ? Math.round(Math.hypot(king.x - b.x, king.y - b.y)) : null })),
-    slimes: { count: slimes.length, big: slimes.filter((o) => o.size === 2).length, king: king ? Math.round((100 * king.hp) / king.maxHp) : null },
-    night: { secondsLeft: room.clock().secondsLeft }, now: { tactic: director.tactic, pressure: director.pressure },
-    ...(kidsRoom ? { note: 'Young players: keep it gentle' } : {}),
-  };
-  const tactics = Object.fromEntries(Object.entries(TACTICS).filter(([k]) => !(kidsRoom && k === 'weakest')));
-  const asked = performance.now();
-  void net.decide(state, {
-    tactic: { type: 'choice', instructions: 'How should the slimes hunt the heroes for the next few seconds? A fun fight, not a massacre: hurt heroes deserve a breather.', criteria: tactics },
-    wave: { type: 'noul', instructions: 'Should a wave of extra slimes come now?', criteria: { true: 'The heroes are healthy and it has gone quiet', false: 'The heroes are hurt, down or few' } },
-    pressure: { type: 'score', instructions: 'How hard should the vale push the heroes right now?', criteria: ['A breather', 'Easy', 'Steady', 'Hard', 'Fierce'] },
-  }, { floor: directorFloor }).then((d) => {
-    director.asking = false;
-    const t = String(d.picks['tactic'] ?? 'chase') as Tactic;
-    director.tactic = t in tactics ? t : 'chase';
-    director.pressure = clamp(Math.round(Number(d.picks['pressure'] ?? 2)), 0, kidsRoom ? 2 : 4);
-    if (d.picks['wave'] === true && director.waveLeft === 0) director.waveLeft = 3;
-    director.by = d.by;
-    director.log.push({ at: Date.now(), by: d.by, why: d.why ?? null, ms: Math.round(performance.now() - asked), tactic: director.tactic, pressure: director.pressure, wave: d.picks['wave'] === true });
-    if (director.log.length > 40) director.log.shift();
-    // Every screen sees what the slimes are up to (only when a model decided; the floor is the vale as always).
-    net.state('slimes', d.by === 'floor' ? null : { tactic: director.tactic, pressure: director.pressure });
-  });
-}
-
-/* ------------------------------------------------------------------ the guides' hands */
-const bodyOfSeat = (seat: unknown): Body | null => { for (const o of room.bodies.values()) if (!o.bot && o.seat === seat) return o; return null; };
-const people = (): Body[] => [...room.bodies.values()].filter((o) => !o.bot && o.seat !== null && !(o.flags & DOWN));
-const huntFrom = new Map<number, number>();
-const arrivedAt = new Map<number, number>();
-/**
- * A guide's body, every host frame, doing its goal at the dial (`s`): where it stands (positioning), how soon it
- * notices (reactionMs), how far off it strikes (aimNoise), how eagerly (aggression). Returns whether it strikes now.
- */
-function stepGuide(b: Body, g: Goal, s: Skill, dt: number, now: number): boolean {
-  let tx = b.x; let ty = b.y; let hunt: Slime | null = null;
-  const nearTo = (x: number, y: number, r: number): Slime | null => { const n = nearestSlime(x, y); return n && Math.hypot(n.x - x, n.y - y) < r ? n : null; };
-  switch (g.goal) {
-    case 'follow': {
-      const p = bodyOfSeat(g.args['seat']);
-      if (!p) { agents.done(b.slot, false); break; }
-      // A step behind the hero (closer at a higher dial), each guide to its own side, and the slime that comes for them.
-      const back = standoff(s, 70, 150);
-      const side = (b.slot % 2 ? 1 : -1) * (0.5 + (b.slot % 3) * 0.25);
-      tx = p.x - Math.cos(p.face + side) * back; ty = p.y - Math.sin(p.face + side) * back;
-      hunt = nearTo(p.x, p.y, 200);
-      break;
-    }
-    case 'quest': {
-      const quest = g.args['quest'];
-      if (quest === 'king-slime') {
-        if (kingSlainAt > g.at) { agents.done(b.slot, true); break; }
-        hunt = slimes.find((o) => o.size === 3) ?? null;
-        if (!hunt) { tx = PLACES['king']!.x; ty = PLACES['king']!.y + 70; }
-      } else if (quest === 'big-slime') {
-        hunt = slimes.filter((o) => o.size === 2).sort((x, y) => Math.hypot(x.x - b.x, x.y - b.y) - Math.hypot(y.x - b.x, y.y - b.y))[0] ?? null;
-        if (!hunt) agents.done(b.slot, true);
-      } else {
-        // A slime hunt: the slimes near the party, three of them.
-        if (!huntFrom.has(b.slot) || huntFrom.get(b.slot)! > b.score) huntFrom.set(b.slot, b.score);
-        if (b.score - huntFrom.get(b.slot)! >= 18) { huntFrom.delete(b.slot); agents.done(b.slot, true); break; }
-        const ps = people();
-        const cx = ps.length ? ps.reduce((a, o) => a + o.x, 0) / ps.length : b.x;
-        const cy = ps.length ? ps.reduce((a, o) => a + o.y, 0) / ps.length : b.y;
-        hunt = nearTo(cx, cy, 520) ?? nearestSlime(b.x, b.y);
-      }
-      break;
-    }
-    case 'lead': {
-      const at = PLACES[String(g.args['place'])] ?? PLACES['camp']!;
-      tx = at.x; ty = at.y;
-      // Done when it is there and a hero came along; given up when nobody came within 20 s of it arriving.
-      if (Math.hypot(at.x - b.x, at.y - b.y) < 60) {
-        if (!arrivedAt.has(b.slot)) arrivedAt.set(b.slot, now);
-        if (people().some((o) => Math.hypot(o.x - at.x, o.y - at.y) < 280)) { arrivedAt.delete(b.slot); agents.done(b.slot, true); }
-        else if (now - arrivedAt.get(b.slot)! > 20_000) { arrivedAt.delete(b.slot); agents.done(b.slot, false); }
-      } else arrivedAt.delete(b.slot);
-      hunt = nearTo(b.x, b.y, 110);
-      break;
-    }
-    case 'guard': {
-      const ps = people().filter((o) => Math.hypot(o.x - b.x, o.y - b.y) < 700);
-      const cx = ps.length ? ps.reduce((a, o) => a + o.x, 0) / ps.length : b.x;
-      const cy = ps.length ? ps.reduce((a, o) => a + o.y, 0) / ps.length : b.y;
-      tx = cx + 50; ty = cy + 40;
-      hunt = nearTo(cx, cy, standoff(s, 260, 160));
-      break;
-    }
-    case 'back': {
-      const at = PLACES['camp']!;
-      tx = at.x; ty = at.y;
-      if (Math.hypot(at.x - b.x, at.y - b.y) < 50) agents.done(b.slot, true);
-      break;
-    }
-    default: break;
-  }
-  // Two guides with the same goal never stand in one spot: each keeps its own place around it.
-  if (!hunt && g.goal !== 'follow') { const k = b.slot * 2.4; tx += Math.cos(k) * 46; ty += Math.sin(k) * 46; }
-  // Reaction time: a guide re-aims only every reactionMs, a little off at a low dial.
-  if (hunt) {
-    if (!b.seenAt || now - b.seenAt >= s.reactionMs) { b.seenAt = now; b.ax = hunt.x + jitter(s, 40); b.ay = hunt.y + jitter(s, 40); }
-    tx = b.ax ?? hunt.x; ty = b.ay ?? hunt.y;
-  }
-  const dx = tx - b.x; const dy = ty - b.y; const dist = Math.hypot(dx, dy) || 1;
-  if (dist > (hunt ? 50 : 24)) { const v = Math.min(SPEED * 0.85, dist / Math.max(dt, 1e-3)); b.x = clamp(b.x + (dx / dist) * v * dt, R, W - R); b.y = clamp(b.y + (dy / dist) * v * dt, R, H - R); b.face = Math.atan2(dy, dx); }
-  return Boolean(hunt && Math.hypot(hunt.x - b.x, hunt.y - b.y) < T.strikeRange + hunt.size * 10 && now - b.atkAt > 1400 - 900 * s.aggression);
-}
-
-/** The quests open now: a slime hunt always, the King Slime when it is out or close to coming, a big slime when one is. */
-function openQuests(): string[] {
-  const now = net.now();
-  return ['slime-hunt', ...(slimes.some((o) => o.size === 3) || kingAt - now < 30_000 ? ['king-slime'] : []), ...(slimes.some((o) => o.size === 2) ? ['big-slime'] : [])];
+room.on('say', e => { if (e.slot < 0) return; bubbles.set(e.slot, { text: e.text, until: performance.now() + 3600 }); logGuide({ ev: 'say', slot: e.slot, line: e.line }); });
+room.on('goal', e => logGuide({ ev: 'goal', slot: e.slot, goal: e.goal.goal, args: e.goal.args, from: e.goal.from }));
+room.on('ask', e => logGuide({ ev: 'ask', slot: e.slot, k: e.k, args: e.args, from: e.from }));
+room.on('loot', e => { if (e.id === room.me?.id && !lookOnly) { gain(e.xp, e.gold); net.spotlight(room.seat); } });
+room.on('down', e => { if (e.id === room.me?.id && !lookOnly) void fell(e.cause); });
+const directorLog: Record<string, unknown>[] = [];
+room.on('director', e => { directorLog.push({ at: Date.now(), tactic: e.tactic, pressure: e.pressure, by: e.by }); if (directorLog.length > 40) directorLog.shift(); });
+function mine(): Body { return viewBodies().find(b => b.seat === room.seat && !b.bot) ?? { slot: -1, seat: room.seat, name: net.name, bot: false, score: 0, x: me.x, y: me.y, hp: maxHpOf(myLevel()), maxHp: maxHpOf(myLevel()), level: myLevel(), face: me.face, flags: 0, downUntil: 0, atkAt: 0, strikeAt: 0, tx: 0, ty: 0 }; }
+function nearestSlime(x: number, y: number): Slime | null {
+  let best: Slime | null = null, distance = Infinity;
+  for (const [id, sx, sy, hp, size] of slimeRows()) { const d = Math.hypot(sx - x, sy - y); if (d < distance) { distance = d; best = { id, x: sx, y: sy, hp, size, maxHp: hp, hitAt: 0, lastHit: -1 }; } }
+  return best;
 }
 const zoneOf = (x: number, y: number): string => {
   let best = 'vale'; let bd = 260;
@@ -534,98 +141,19 @@ const zoneOf = (x: number, y: number): string => {
   return best;
 };
 
-function nearestSlime(x: number, y: number): Slime | null {
-  let best: Slime | null = null; let bd = Infinity;
-  for (const s of slimes) { const d = Math.hypot(s.x - x, s.y - y); if (d < bd) { bd = d; best = s; } }
-  return best;
-}
-
-/** A struck slime: held through the hit-stop, then eased back along the strike. True while it is (it does not chase). */
-function pushed(s: Slime, now: number): boolean {
-  if (s.kat === undefined || s.kx === undefined || s.ky === undefined) return false;
-  if (now < s.kat) return true;
-  const u = Math.min(1, (now - s.kat) / Math.max(1, T.pushMs));
-  const e = 1 - (1 - u) ** 3;
-  s.x = clamp(s.kx + (s.kdx ?? 0) * T.slimePush * e, 20, W - 20); s.y = clamp(s.ky + (s.kdy ?? 0) * T.slimePush * e, 20, H - 20);
-  // The push ends exactly where it should, at any frame rate; then the slime chases again.
-  if (u >= 1) { delete s.kat; return false; }
-  return true;
-}
-function stepSlimes(dt: number, now: number): void {
-  const struck = new Set(slimes.filter((s) => pushed(s, now)).map((s) => s.id));
-  if (lab.stage === 'dummy') return; // the lab's training slime stands still and never bites
-  const bodies = [...room.bodies.values()].filter((b) => !(b.flags & DOWN));
-  const people = bodies.filter((b) => !b.bot).length;
-  // The director's pressure (0 a breather .. 4 fierce; 2 is how the vale always played) sets how fast and how many.
-  const cap = Math.max(4, 6 + people * 2 + (director.pressure - 2) * 2) + (director.waveLeft > 0 ? 3 : 0);
-  if ((now >= spawnAt || director.waveLeft > 0) && slimes.length < cap) {
-    spawnAt = now + SPAWN_MS[director.pressure]!;
-    if (director.waveLeft > 0) director.waveLeft -= 1;
-    const edge = Math.floor(Math.random() * 4);
-    const x = edge === 0 ? 30 : edge === 1 ? W - 30 : Math.random() * W;
-    const y = edge === 2 ? 30 : edge === 3 ? H - 30 : Math.random() * H;
-    const size = Math.random() < 0.25 ? 2 : 1;
-    slimes.push({ id: ++slimeSeq, x, y, hp: 18 * size, maxHp: 18 * size, size, hitAt: 0, lastHit: -1 });
-  }
-  if (now >= kingAt && !slimes.some((s) => s.size === 3)) {
-    kingAt = now + 60_000;
-    slimes.push({ id: ++slimeSeq, x: W / 2, y: 40, hp: 160, maxHp: 160, size: 3, hitAt: 0, lastHit: -1 });
-    room.send('king', {});
-  }
-  // Slimes hunt heroes: the nearest person, and a bot only when no person is up.
-  const prey = bodies.some((b) => !b.bot) ? bodies.filter((b) => !b.bot) : bodies;
-  for (const s of slimes) {
-    if (struck.has(s.id)) continue;
-    let target: Body | null = null; let bd = Infinity;
-    for (const b of prey) { const d = Math.hypot(b.x - s.x, b.y - s.y); if (d < bd) { bd = d; target = b; } }
-    // The director's tactic (section 20; chase is how the vale always played): the most hurt hero, a ring round the
-    // nearest, or back to the King to gather (a hero close by is still bitten).
-    if (director.tactic === 'weakest' && prey.length > 1) target = prey.reduce((a, b) => (b.hp / b.maxHp < a.hp / a.maxHp ? b : a));
-    const speed = s.size === 3 ? 70 : 95 - s.size * 10;
-    if (target) {
-      let gx = target.x; let gy = target.y;
-      const king = slimes.find((o) => o.size === 3);
-      if (director.tactic === 'surround' && bd > 90) { const a = s.id * 2.39996; gx += Math.cos(a) * 80; gy += Math.sin(a) * 80; }
-      if (director.tactic === 'regroup' && king && s !== king && bd > 140) { gx = king.x + Math.cos(s.id) * 70; gy = king.y + Math.sin(s.id) * 70; }
-      const dx = gx - s.x; const dy = gy - s.y; const dist = Math.hypot(target.x - s.x, target.y - s.y) || 1;
-      const step = Math.hypot(dx, dy) || 1;
-      if (step > 4) { s.x += (dx / step) * speed * dt; s.y += (dy / step) * speed * dt; }
-      if (dist < R + 10 + s.size * 10 && now - s.hitAt > 800) {
-        s.hitAt = now;
-        target.hp -= 5 * s.size + (s.size === 3 ? 10 : 0);
-        if (target.hp <= 0) down(target, now, s.size === 3 ? 'the King Slime' : s.size === 2 ? 'a big slime' : 'a slime');
-      }
-    } else { s.x += Math.sin(now / 900 + s.id) * 20 * dt; s.y += Math.cos(now / 1100 + s.id) * 20 * dt; }
-    s.x = clamp(s.x, 20, W - 20); s.y = clamp(s.y, 20, H - 20);
-  }
-}
-
-/* ------------------------------------------------------------------ input */
 const input = createControls({ actions: { strike: ['Space', 'KeyJ', 'Enter'] }, touch: { buttons: [{ id: 'strike', label: 'STRIKE' }] } });
 // A touch screen has STRIKE at the bottom right: the ask panel stands right above it (index.html, .touch).
 document.body.classList.toggle('touch', input.touch.enabled);
-/** A strike's lunge: my hero steps T.lunge along its facing over 90 ms, easing out (owner movement, under top speed). */
-const lunge = { at: -1e9, face: 0, done: 1 };
-function stepLunge(): void {
-  if (lunge.done >= 1) return;
-  const u = Math.min(1, (performance.now() - lunge.at) / 90);
-  const e = 1 - (1 - u) ** 2;
-  const d = (e - lunge.done) * T.lunge;
-  lunge.done = e;
-  me.x = clamp(me.x + Math.cos(lunge.face) * d, R, W - R); me.y = clamp(me.y + Math.sin(lunge.face) * d, R, H - R);
-}
-function stepMe(dt: number): void {
-  const b = room.hosting ? room.mine() : null;
-  const isDown = b ? Boolean(b.flags & DOWN) : Boolean(myViewBody()?.flags && (myViewBody()!.flags & DOWN));
-  const typing = !ui.idle();
-  const m = typing || isDown ? { x: 0, y: 0 } : input.move();
-  if (Math.hypot(m.x, m.y) > 0.05) { me.face = Math.atan2(m.y, m.x); me.x = clamp(me.x + m.x * SPEED * dt, R, W - R); me.y = clamp(me.y + m.y * SPEED * dt, R, H - R); me.has = true; }
-  if (!typing && input.pressed('strike')) { if (room.hosting) me.strikes += 1; else room.press('strike'); me.flashAt = performance.now(); if (!isDown) { lunge.at = performance.now(); lunge.face = me.face; lunge.done = 0; } }
-  if (!isDown) stepLunge();
-  room.input([q(me.x, 0), q(me.y, 0), q(me.face, 2), myLevel()]);
-}
-function myViewBody(): Body | null { const s = room.mySeat(); return room.view().find((b) => b.seat === s && !b.bot) ?? null; }
-
+function stepMe(): void {
+  const typing = !ui.idle(), own = room.me;
+  const m = typing || own?.hp === 0 ? { x: 0, y: 0 } : input.move();
+  const strike = !typing && input.pressed('strike');
+  room.input({ ax: Math.round(m.x * 127), ay: Math.round(m.y * 127), strike });
+  const body = room.me; me.has = Boolean(body);
+  if (body) { me.x = body.pos.x * 50; me.y = body.pos.y * 50; me.face = Math.atan2(body.heading.y, body.heading.x); }
+  if (strike) { me.flashAt = performance.now(); if (lab.on) labStrike(mine(), net.now(), []); }
+}
+function myViewBody(): Body | null { return viewBodies().find(b => b.seat === room.seat && !b.bot) ?? null; }
 /* ------------------------------------------------------------------ drawing */
 const canvas = document.getElementById('c') as HTMLCanvasElement;
 const ctx = canvas.getContext('2d', { alpha: false }) as CanvasRenderingContext2D;
@@ -662,7 +190,7 @@ let kickAt = -1e9;
 function striker(x: number, y: number, bodies: Body[]): Body | null {
   let best: Body | null = null; let bd = Infinity;
   for (const b of bodies) {
-    const mineNow = !b.bot && b.seat === room.mySeat() && performance.now() - me.flashAt < T.flashMs;
+    const mineNow = !b.bot && b.seat === room.seat && performance.now() - me.flashAt < T.flashMs;
     if (!(b.flags & STRIKING) && !mineNow) continue;
     const d = Math.hypot(b.x - x, b.y - y);
     if (d < bd && d < T.strikeRange + 60) { bd = d; best = b; }
@@ -670,18 +198,19 @@ function striker(x: number, y: number, bodies: Body[]): Body | null {
   return best;
 }
 function watchSlimes(t: number, bodies: Body[]): void {
-  const rows = room.fast() ?? [];
+  const rows = slimeRows() ?? [];
   const here = new Set<number>();
   for (const [id, x, y, hp, size] of rows) {
     here.add(id);
     const s = seen.get(id);
     if (!s) { seen.set(id, { x, y, hp, size, hitAt: -1e9, dx: 0, dy: 0 }); continue; }
     if (hp < s.hp) {
+      if (lab.on && subject.id === id) subject.hit = true;
       const by = striker(x, y, bodies);
       const d = by ? Math.hypot(x - by.x, y - by.y) || 1 : 1;
       s.hitAt = t; s.dx = by ? (x - by.x) / d : 0; s.dy = by ? (y - by.y) / d : -1;
       numbers.push({ x: x + ((numbers.length % 3) - 1) * 16, y: y - (12 + size * 10), text: `-${Math.round(s.hp - hp)}`, at: t });
-      if (by && !by.bot && by.seat === room.mySeat()) kickAt = t;
+      if (by && !by.bot && by.seat === room.seat) kickAt = t;
     }
     s.x = x; s.y = y; s.hp = hp; s.size = size;
   }
@@ -690,9 +219,10 @@ function watchSlimes(t: number, bodies: Body[]): void {
     seen.delete(id);
     const by = striker(s.x, s.y, bodies);
     if (!by) continue; // gone without a strike: the night ended
+    if (lab.on && subject.id === id) subject.hit = true;
     pops.push({ x: s.x, y: s.y, size: s.size, at: t });
     numbers.push({ x: s.x, y: s.y - (12 + s.size * 10), text: `-${Math.round(s.hp)}`, at: t });
-    if (!by.bot && by.seat === room.mySeat()) kickAt = t;
+    if (!by.bot && by.seat === room.seat) kickAt = t;
     for (let i = 0; i < 10; i += 1) { const a = lab.random() * Math.PI * 2; const v = 120 + lab.random() * 260; drops.push({ x: s.x, y: s.y, vx: Math.cos(a) * v, vy: Math.sin(a) * v - 80, at: t, life: 260 + lab.random() * 200, colour: SLIME[s.size - 1] ?? '#7ad35a' }); }
   }
   if (drops.length > 200) drops.splice(0, drops.length - 200);
@@ -791,7 +321,7 @@ net.on('unchat', (e) => { for (const id of e.ids) chatBubbles.remove(id); });
 let shownChat: BubbleOut[] = [];
 let shownLabels: LabelOut[] = [];
 function aim(): Fit {
-  const v = lookOnly ? room.viewBody() : null;
+  const v = lookOnly ? viewBody() : null;
   const focus = !lookOnly && me.has ? { x: me.x, y: me.y } : v ? { x: v.x, y: v.y } : null;
   const phone = Math.min(vw, vh) <= 540;
   // The Game Lab's views (outside the lab: the game's own camera, always).
@@ -820,8 +350,8 @@ function draw(t: number): void {
     ctx.fillStyle = i % 5 ? 'rgba(122,211,90,.10)' : 'rgba(255,170,80,.35)';
     ctx.beginPath(); ctx.arc(x, H - y, i % 5 ? 26 : 2.5, 0, Math.PI * 2); ctx.fill();
   }
-  const fast = room.fast() ?? [];
-  const everyone = room.view();
+  const fast = slimeRows() ?? [];
+  const everyone = viewBodies();
   watchSlimes(t, everyone);
   for (const [id, x, y, hp, size] of fast) {
     const r = 12 + size * 10;
@@ -839,7 +369,7 @@ function draw(t: number): void {
     ctx.fillStyle = '#ff7a59'; ctx.fillRect(x - r, y + r + 4, (r * 2 * clamp(hp, 0, max)) / max, 4);
   }
   // The hero whose view this is: my own, or the one a watcher follows (null: the vale, nobody in gold).
-  const viewS = room.viewSeat();
+  const viewS = net.viewSeat;
   const sx = (x: number): number => vw / 2 + (x - (cam as Fit).x) * s;
   const sy = (y: number): number => vh / 2 + (y - (cam as Fit).y) * s;
   // Names are drawn after the vale, on the screen, at a size that reads on any screen; they never pile up.
@@ -849,10 +379,10 @@ function draw(t: number): void {
   const said: { x: number; y: number; head: number; text: string }[] = [];
   const heads = new Map<number, { x: number; y: number; seat: number; self: boolean }>();
   const mine: ScreenBox[] = []; // your own hero and its name: no bubble covers them
-  const meAt = (() => { const v = room.view().find((b) => !b.bot && b.seat === viewS); return v ? { x: v.x, y: v.y } : null; })();
-  for (const b of room.view()) {
+  const meAt = (() => { const v = viewBodies().find((b) => !b.bot && b.seat === viewS); return v ? { x: v.x, y: v.y } : null; })();
+  for (const b of viewBodies()) {
     const self = !b.bot && b.seat === viewS;
-    const local = self && !room.hosting && !net.watching;
+    const local = self && !net.watching;
     const x = local ? me.x : b.x; const y = local ? me.y : b.y;
     const isDown = Boolean(b.flags & DOWN);
     ctx.globalAlpha = isDown ? 0.35 : 1;
@@ -862,7 +392,7 @@ function draw(t: number): void {
     if (striking && (!sw || t - sw.at > T.strikeMs * 0.9)) swings.set(b.slot, { at: self && performance.now() - me.flashAt < T.flashMs ? t - (performance.now() - me.flashAt) : t, face: self ? me.face : b.face });
     const swing = swings.get(b.slot);
     if (swing) drawSwing(x, y, swing.face, t - swing.at);
-    const isGuide = (net.slots ?? []).some((x) => x.slot === b.slot && x.agent?.role === 'guide');
+    const isGuide = b.agent?.role === 'guide';
     ctx.fillStyle = self ? '#ffcf6e' : isGuide ? '#7fd8c8' : b.bot ? '#8aa0b8' : '#f3ead2';
     ctx.beginPath(); ctx.arc(x, y, R, 0, Math.PI * 2); ctx.fill();
     ctx.fillStyle = '#0b0f0a'; ctx.beginPath(); ctx.arc(x + Math.cos(b.face) * 10, y + Math.sin(b.face) * 10, 5, 0, Math.PI * 2); ctx.fill();
@@ -964,10 +494,10 @@ function hud(t: number): void {
   const TITLE = '700 16px ui-sans-serif, system-ui, sans-serif';
   const SMALL = '600 13px ui-sans-serif, system-ui, sans-serif';
   // A watcher's panel is the followed hero's, as the room has them (their save stays in their own browser).
-  const v = lookOnly ? room.viewBody() : null;
-  const heroes = room.view().filter((b) => !b.bot).length;
+  const v = lookOnly ? viewBody() : null;
+  const heroes = viewBodies().filter((b) => !b.bot).length;
   const title = lookOnly ? (v ? `${nameOf(v)} · Lv ${v.level}` : 'Watching the vale') : hero ? `${hero.name}${hero.hardcore ? ' ☠' : ''} · Lv ${hero.level}` : heroLoaded ? 'No hero yet' : 'Loading your hero…';
-  const sub = lookOnly ? (v ? `${v.score} xp tonight${v.flags & DOWN ? ' · down' : ''}` : `${heroes} ${heroes === 1 ? 'hero' : 'heroes'} · ${(room.fast() ?? []).length} slimes`) : hero ? `${hero.gold} gold · ${hero.kills} slain` : '';
+  const sub = lookOnly ? (v ? `${v.score} xp tonight${v.flags & DOWN ? ' · down' : ''}` : `${heroes} ${heroes === 1 ? 'hero' : 'heroes'} · ${(slimeRows() ?? []).length} slimes`) : hero ? `${hero.gold} gold · ${hero.kills} slain` : '';
   const bar = v ? { colour: '#7ad35a', of: clamp(v.hp, 0, v.maxHp) / Math.max(1, v.maxHp) } : hero && !lookOnly ? { colour: '#ffcf6e', of: hero.xp / xpFor(hero.level) } : null;
   // The panel is as wide as what it says: on a phone the vale runs under it, and the clock sits beside it.
   ctx.font = TITLE; const titleW = ctx.measureText(title).width;
@@ -981,15 +511,16 @@ function hud(t: number): void {
     ctx.fillStyle = bar.colour; ctx.fillRect(x0 + 10, y0 + 32, 140 * clamp(bar.of, 0, 1), 6);
   }
   if (sub) { ctx.font = SMALL; ctx.fillStyle = '#e7d9b4'; ctx.fillText(sub, x0 + 10, y0 + (bar ? 54 : 46)); }
-  const c = room.clock();
+  const c = (room.round ?? { phase: 'live', secondsLeft: 90, n: 1 });
   ctx.font = TITLE; ctx.fillStyle = '#f3ead2';
   const cw = canvas.width / k;
-  const clock = c.phase === 'over' ? `Dawn · night ${c.n + 1} in ${c.secondsLeft}s` : `Night ${c.n} · ${Math.floor(c.secondsLeft / 60)}:${String(c.secondsLeft % 60).padStart(2, '0')}`;
+  const secondsLeft = Math.max(0, Math.ceil(c.secondsLeft));
+  const clock = c.phase === 'over' ? `Dawn · night ${c.n + 1} in ${secondsLeft}s` : `Night ${c.n} · ${Math.floor(secondsLeft / 60)}:${String(secondsLeft % 60).padStart(2, '0')}`;
   // Top centre; on a narrow screen where that would touch the panel, just under it.
   if (x0 + pw + 10 > cw / 2 - ctx.measureText(clock).width / 2) { ctx.textAlign = 'left'; ctx.fillText(clock, x0 + 10, y0 + 62 + 20); }
   else { ctx.textAlign = 'center'; ctx.fillText(clock, cw / 2, 30); }
   // What the slimes are up to, when the studio's decision model chose it (section 20; nothing shows on the floor).
-  const mind = c.phase === 'live' ? net.stateOf<{ tactic: string; pressure: number }>('slimes') : null;
+  const mind = c.phase === 'live' ? (room.shared.directorBy === 'floor' ? null : { tactic: room.shared.tactic, pressure: room.shared.pressure }) : null;
   if (mind) {
     const words: Record<string, string> = { chase: 'rushing you', surround: 'closing in from every side', weakest: 'hunting the hurt', regroup: 'gathering round the King' };
     ctx.font = SMALL; ctx.fillStyle = '#e7a86b'; ctx.textAlign = 'center';
@@ -997,7 +528,7 @@ function hud(t: number): void {
   }
   ctx.textAlign = 'center';
   if (c.phase === 'over') {
-    const rows = room.results().slice(0, 5);
+    const rows = (room.round?.results ?? []).slice(0, 5);
     // Under the page's own pills on a narrow screen (they are buttons, above the canvas), else under the clock.
     const top = vw <= 540 ? 132 * (dpr / k) : 44;
     ctx.fillStyle = 'rgba(10,14,9,.78)'; ctx.fillRect(cw / 2 - 150, top, 300, 30 + rows.length * 22);
@@ -1073,13 +604,12 @@ let asksSig = '';
 const askEls = new Map<string, HTMLButtonElement>();
 function paintAsks(): void {
   const panel = $('asks');
-  const mySeat = room.mySeat();
+  const mySeat = room.seat;
   const here = me.has && mySeat !== null && !lookOnly && ui.idle();
   let best: { slot: number; name: string; d: number } | null = null;
   if (here) {
-    for (const b of room.view()) {
-      const sl = (net.slots ?? []).find((x) => x.slot === b.slot);
-      if (!sl?.agent || sl.agent.role !== 'guide') continue;
+    for (const b of viewBodies()) {
+      if (b.agent?.role !== 'guide') continue;
       // The guide the panel is for keeps it while it is in reach, unless another is much nearer: two guides at the
       // party's side would otherwise swap it four times a second, and a thumb's tap would land on a button just redrawn.
       const d = Math.hypot(b.x - me.x, b.y - me.y);
@@ -1088,10 +618,11 @@ function paintAsks(): void {
     }
   }
   if (!best) { panel.hidden = true; asksFor = -1; asksSig = ''; return; }
-  const quests = (net.stateOf<string[]>('quests') ?? (room.hosting ? openQuests() : ['slime-hunt'])).slice(0, 3);
+  const quests = room.shared.quests.slice(0, 3);
   // Help with each open quest, one place to be led to (not the one I am in), and "No thanks"; three on a phone (either way up).
   const zone = zoneOf(me.x, me.y);
-  const all = agents.askButtons(best.slot, { quests });
+  const id = guideId(best.slot);
+  const all = id ? room.askButtons(id, { quests }) : [];
   const lead = all.filter((b) => b.k === 'lead_me' && b.args['place'] !== zone).slice(0, 1);
   const order = [...all.filter((b) => b.k === 'ask_help'), ...lead, ...all.filter((b) => b.k === 'no_thanks')];
   const buttons = order.slice(0, Math.min(innerWidth, innerHeight) < 540 ? 3 : 5);
@@ -1116,7 +647,8 @@ function paintAsks(): void {
       btn.dataset['ask'] = b.k;
       btn.addEventListener('click', () => {
         if (asksFor < 0) return;
-        if (agents.ask(asksFor, b.k, b.args)) { logGuide({ ev: 'asked', slot: asksFor, k: b.k, args: b.args }); btn.classList.add('sent'); setTimeout(() => btn.classList.remove('sent'), 900); }
+        const id = guideId(asksFor);
+        if (id) { room.ask(id, b.k, b.args); logGuide({ ev: 'asked', slot: asksFor, k: b.k, args: b.args }); btn.classList.add('sent'); setTimeout(() => btn.classList.remove('sent'), 900); }
       });
       askEls.set(key, btn);
       el = btn;
@@ -1143,7 +675,7 @@ function labStrike(b: Body, now: number, hits: Slime[]): void {
 }
 /** The subject slime as drawn (the fast world's row), or null once it is gone. */
 function subjectSlime(): { x: number; y: number; hp: number; size: number } | null {
-  const row = (room.fast() ?? []).find((r) => r[0] === subject.id);
+  const row = (slimeRows() ?? []).find((r) => r[0] === subject.id);
   return row ? { x: row[1], y: row[2], hp: row[3], size: row[4] } : null;
 }
 function labReport(): void {
@@ -1162,15 +694,6 @@ function labReport(): void {
   else lab.phase(null);
   if (sl) lab.pose('slime', { x: sl.x, y: sl.y, r: 12 + sl.size * 10 });
 }
-/** The lab's training stage: the hero at camp facing right, a big slime a step away, the bots off to the side. */
-let staged = false;
-function stageDummy(): void {
-  staged = true;
-  me.x = W / 2 - 70; me.y = H / 2; me.face = 0; me.has = true;
-  let i = 0;
-  for (const b of room.bodies.values()) if (b.bot) { b.x = 200 + (i % 2) * 1200; b.y = 160 + Math.floor(i / 2) * 680; b.tx = b.x; b.ty = b.y; i += 1; room.moved(b); }
-  slimes = [{ id: ++slimeSeq, x: W / 2 + 30, y: H / 2, hp: 36, maxHp: 36, size: 2, hitAt: 0, lastHit: -1 }];
-}
 const labView = lab.camera<{ zoom?: number; whole?: boolean } | null>({ game: null, close: { zoom: 2.2 }, whole: { whole: true } });
 lab.overlay('onion', (c, k) => {
   const g = c as CanvasRenderingContext2D; const s = Number(k) || 1;
@@ -1198,10 +721,8 @@ lab.overlay('reach', (c, k) => {
 let frames = 0;
 function frame(t: number): void {
   const dt = lab.time.dt(t, 0.05);
-  if (lab.stage === 'dummy' && !staged && room.hosting && room.round?.phase === 'live') stageDummy();
-  stepMe(dt);
+  stepMe();
   keepNames(t);
-  if (room.hosting) stepHost(dt);
   draw(t);
   if (lab.on) labReport();
   frames += 1;
@@ -1212,16 +733,11 @@ function frame(t: number): void {
 net.expose({
   // Room chat's bubbles on this screen now: whose, what, and where (an end-to-end test reads them).
   chatBubbles: () => shownChat.map((b) => ({ seat: b.key, text: b.lines.join(' '), alpha: b.alpha, left: Math.round(b.left), top: Math.round(b.top), right: Math.round(b.right), bottom: Math.round(b.bottom) })),
-  scores: () => room.view().map((b) => ({ slot: b.slot, seat: b.seat, bot: b.bot, score: b.score })),
+  scores: () => viewBodies().map((b) => ({ slot: b.slot, seat: b.seat, bot: b.bot, score: b.score })),
   // The guides, for the e2e probe: each guide's goal now, and the log of goals, asks and lines (seats and ids only).
-  guides: () => ({
-    hosting: room.hosting, talking: agents.talking, stats: agents.stats(),
-    now: agents.guides().map((g) => { const v = room.view().find((b) => b.slot === g.slot); return { slot: g.slot, seat: g.agent?.seat ?? null, name: g.name, goal: agents.goalOf(g.slot), x: v ? Math.round(v.x) : null, y: v ? Math.round(v.y) : null }; }),
-    me: me.has ? { x: Math.round(me.x), y: me.y | 0 } : null,
-    log: guideLog.slice(),
-  }),
+  guides: () => ({ now: viewBodies().filter(b => b.agent).map(b => { const e = room.get(guideId(b.slot) ?? ''); return { slot: b.slot, x: b.x, y: b.y, goal: e?.kind === 'hero' ? e.goal : null }; }), log: guideLog.slice() }),
   // The slimes' director (section 20): its tactic now, and each decision (who answered, how long it took).
-  director: () => ({ tactic: director.tactic, pressure: director.pressure, by: director.by, log: director.log.slice(), net: net.stats().decides ?? null }),
+  director: () => ({ tactic: room.shared.tactic, pressure: room.shared.pressure, by: room.shared.directorBy, log: directorLog.slice() }),
   // Where the camera looks, and the names as drawn (the e2e probe counts overlaps, checks your own, and reads them).
   camera: () => (cam ? { x: cam.x, y: cam.y, scale: cam.scale, follow: cam.follow } : null),
   labels: () => shownLabels.map((l) => ({ text: l.text, self: Boolean(l.self), alpha: l.alpha, moved: l.moved, left: Math.round(l.left), top: Math.round(l.top), right: Math.round(l.right), bottom: Math.round(l.bottom) })),
@@ -1229,14 +745,13 @@ net.expose({
 
 exposePort(net, {
   view: 'top',
-  self: () => (me.has && room.mySeat() !== null ? { x: me.x, y: me.y } : null),
+  self: () => (me.has && room.seat !== null ? { x: me.x, y: me.y } : null),
   size: R,
-  score: () => { const s = room.mySeat(); return room.view().find((b) => b.seat === s && !b.bot)?.score ?? null; },
+  score: () => { const s = room.seat; return viewBodies().find((b) => b.seat === s && !b.bot)?.score ?? null; },
   busy: () => !ui.idle(),
   // `alive` is read by name by the playtest (port/probe.ts PortExtra): a downed hero is waiting to stand up again, and a
   // press that moves nothing then is not a broken control.
   extra: { alive: () => !((myViewBody()?.flags ?? 0) & DOWN), level: () => hero?.level ?? 0, frames: () => frames, saves: () => saves.status().mode },
 });
 
-void net.ready.then(() => { const b = room.mine(); if (b) { me.x = b.x; me.y = b.y; me.has = true; } });
 requestAnimationFrame(frame);