@homie-rocks/studio 0.43.0 → 0.44.1

package/lib/worker-build.mjs

@@ -1,23 +1,56 @@
+import {createHash} from 'node:crypto';
 import {refreshWorkerConfig} from './worker-config.mjs';
 import {pathToFileURL} from 'node:url';
-import {existsSync,mkdirSync,writeFileSync,rmSync} from 'node:fs';
-import {join,relative} from 'node:path';
+import {existsSync,mkdirSync,writeFileSync,renameSync,readFileSync,mkdtempSync,rmSync} from 'node:fs';
+import {join,relative,basename,sep} from 'node:path';
 import {readConfig} from './routes.mjs';
+import {workerDir} from './studio.mjs';
 import {paidReleases} from './parts-upload.mjs';
 /** Preserve dynamic imports as real Worker modules: page startup never evaluates MCP libraries. */
 export async function buildWorker(root,esbuild) {
   const source=join(root,'site/src/worker.mjs');if(!existsSync(source))return;
   const out=join(root,'site/src/runtime');
-  refreshWorkerConfig(root);
+
   const alias={...(readConfig(root)?.alias??{})};
   const toolModule=join(root,'site/src/tools/index.mjs');
   const pricedTools=existsSync(toolModule) && (await import(pathToFileURL(toolModule).href+'?worker='+Date.now())).default.some(tool=>tool.price);
   if(paidReleases(root).length || existsSync(join(root,'shop.json')) || pricedTools)alias['@homie-rocks/studio/worker']='@homie-rocks/studio/worker/selling';
   const result=await esbuild.build({entryPoints:[source],absWorkingDir:root,alias,outdir:out,bundle:true,splitting:true,format:'esm',platform:'browser',mainFields:['module','main'],conditions:['workerd','worker','browser'],external:['node:*','cloudflare:*'],target:'es2022',write:false,minify:true,metafile:true,logLevel:'silent'});
-  rmSync(out,{recursive:true,force:true});
+  // A watcher may already have read the previous entry while this build is
+  // publishing. Keep its entire graph available. Publish immutable modules first,
+  // then switch the single entry atomically; never remove a running graph.
+  const generation=createHash('sha256');
+  for(const file of result.outputFiles)generation.update(basename(file.path)).update(file.contents);
+  const id=generation.digest('hex').slice(0,24),dir=join(out,id);
   mkdirSync(out,{recursive:true});
-  for(const file of result.outputFiles)writeFileSync(file.path,file.contents);
-  const sizes=Object.entries(result.metafile.outputs).map(([path,value])=>({path:relative(root,path),bytes:value.bytes,imports:value.imports}));
+  if(!existsSync(dir)) {
+    const stage=mkdtempSync(join(out,'.generation-'));
+    try {
+      for(const file of result.outputFiles)writeFileSync(join(stage,basename(file.path)),file.contents);
+      try {renameSync(stage,dir);} catch(error) {if(!existsSync(dir))throw error;}
+    } finally {rmSync(stage,{recursive:true,force:true});}
+  }
+  const entry=`export * from './${id}/worker.js';\nexport {default} from './${id}/worker.js';\n`;
+  const target=join(out,'worker.js');
+  if(!existsSync(target)||readFileSync(target,'utf8')!==entry) {
+    const temp=join(out,`.worker-${process.pid}.tmp`);
+    writeFileSync(temp,entry);renameSync(temp,target);
+  }
+  // Wrangler's module root is the immutable generation, so old generations are
+  // retained locally for in-flight reloads but are never added to a deployment.
+  refreshWorkerConfig(root,{main:relative(workerDir(root),join(dir,'worker.js'))});
+  // Dev sometimes watches a copy with routes/remote AI removed. Publish its
+  // entry too, keeping its local bindings and its module root at one generation.
+  const local=join(workerDir(root),'.wrangler','homie-dev.wrangler.json');
+  if(existsSync(local)) {
+    const config=JSON.parse(readFileSync(local,'utf8'));
+    if(typeof config.main==='string' && config.main.startsWith(out+sep)) {
+      config.main=join(dir,'worker.js');
+      const text=JSON.stringify(config,null,2)+'\n';
+      if(readFileSync(local,'utf8')!==text) {const temp=`${local}.${process.pid}.tmp`;writeFileSync(temp,text);renameSync(temp,local);}
+    }
+  }
+  const sizes=Object.entries(result.metafile.outputs).map(([path,value])=>({path:relative(root,join(dir,basename(path))),bytes:value.bytes,imports:value.imports}));
   writeFileSync(join(out,'modules.json'),JSON.stringify(sizes,null,2)+'\n');
   return sizes;
 }

package/lib/worker-config.mjs

@@ -1,4 +1,4 @@
-import {readFileSync,writeFileSync,existsSync} from 'node:fs';
+import {readFileSync,writeFileSync,existsSync,renameSync} from 'node:fs';
 import {join} from 'node:path';
 import {configPath,readStudio,layoutOf,listExperiences} from './studio.mjs';
 import {wranglerConfig} from './scaffold.mjs';
@@ -14,7 +14,7 @@ function merge(base,custom) {
 export function updateWorkerConfig(root,generated) {
   const file=configPath(root),next=merge(parse(generated),read(join(root,'wrangler.custom.json')));
   const text='// Generated by homie-studio. Edit studio.json or wrangler.custom.json, then build.\n'+JSON.stringify(next,null,2)+'\n';
-  if(!existsSync(file)||readFileSync(file,'utf8')!==text)writeFileSync(file,text);
+  if(!existsSync(file)||readFileSync(file,'utf8')!==text) {const temp=`${file}.${process.pid}.tmp`;writeFileSync(temp,text);renameSync(temp,file);}
 }
 export function refreshWorkerConfig(root,overrides={}) {
   const studio=readStudio(root),cf=studio.cloudflare;

package/netplay/netplay.ts

@@ -2628,6 +2628,9 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
       setRole(next, wasOffline && roleKnown ? 'reconnected' : String(m['why'] ?? 'welcome'), { ckpt, snap, round: roundInfo, roster: slots });
       if (next === 'host' && snap) tick = Math.max(tick, snap.k);
     }
+    // A reconnect to the same role emits no role event, but its welcome is a new
+    // connection's keyframe. Rules views must adopt it before the first delta.
+    if (rulesGame && snap && next !== 'host') emit('snapshot', snap);
     if (continuing) { rulesHost?.sync(rulesPeers()); reannounce(); catchUp(had, hadSeat); }
     if (link === 'online') paintLink(); else setLink('online', 'welcome');
     // A build older than the live one, let in to its own room (section 23).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.43.0",
+  "version": "0.44.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, big songs and videos in the studio's own R2 once it has storage (uploaded, checked by SHA-256, served at the same addresses), deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",
@@ -121,7 +121,8 @@
     "apps/",
     "app-starters/",
     "tools/",
-    "functions/"
+    "functions/",
+    "guides/"
   ],
   "engines": {
     "node": ">=22"
@@ -160,6 +161,7 @@
     "zod": "4.3.6"
   },
   "scripts": {
-    "test": "node --test --test-concurrency=2 --test-timeout=1800000 test/*.test.mjs"
+    "test": "node --test --test-concurrency=2 --test-timeout=1800000 test/*.test.mjs",
+    "prepack": "node ../../scripts/authoring-guides.mjs --check"
   }
 }

package/rules/collision.ts

@@ -14,7 +14,7 @@ export interface Map3 {
   capsules?: readonly (MapCircle & { height: number })[];
 }
 const EPS = 1e-7;
-const point = (x: number, y: number, z: number): Vec3 => ({ x, y, z });
+const point = (x: number, y: number, z: number): {x: number; y: number; z: number} => ({ x, y, z });
 export function solidAt(at: Vec3, body: BodyShape): Solid {
   const r = body.radius, height = body.height || 2 * r;
   if (body.shape === 'box') return { min: point(at.x - r, at.y - r, at.z), max: point(at.x + r, at.y + r, at.z + height), r: 0 };
@@ -93,7 +93,7 @@ export function castMap3(map: Map3, p: Vec3, d: Vec3, body: BodyShape): Hit3 | n
   charge(24);
   const a = solidAt(p, body), r = body.radius, height = body.height || r * 2;
   let best: Hit3 | null = null;
-  const take = (h: Hit3 | null): void => { if (h && h.t >= 0 && h.t <= 1 && (!best || h.t < best.t)) best = h; };
+  const take = (h: Hit3 | null, id?: string): void => { if (h && h.t >= 0 && h.t <= 1 && (!best || h.t < best.t)) best = id ? {...h, id} : h; };
   for (const axis of ['x', 'y', 'z'] as const) {
     const low = map.bounds.min[axis] + (axis === 'z' ? 0 : r);
     const high = map.bounds.max[axis] - (axis === 'z' ? height : r);
@@ -102,11 +102,11 @@ export function castMap3(map: Map3, p: Vec3, d: Vec3, body: BodyShape): Hit3 | n
     take({ t: ((d[axis] > 0 ? high : low) - p[axis]) / d[axis], nx: n.x, ny: n.y, nz: n.z });
   }
   for (const tile of map.heightTiles ?? []) take(castHeightTile(tile, p, d));
-  for (const b of map.boxes) take(castSolid(a, d, { ...b, r: 0 }));
+  for (const b of map.boxes) take(castSolid(a, d, { ...b, r: 0 }), (b as any).id);
   // Legacy map circles are vertical columns in a 3D map.
-  for (const c of map.circles) take(castSolid(a, d, { min: point(c.at.x, c.at.y, map.bounds.min.z - r), max: point(c.at.x, c.at.y, map.bounds.max.z + r), r: c.r }));
-  for (const s of map.spheres ?? []) take(castSolid(a, d, { min: s.at, max: s.at, r: s.r }));
-  for (const c of map.capsules ?? []) take(castSolid(a, d, solidAt(c.at, { shape: 'capsule', radius: c.r, height: c.height })));
+  for (const c of map.circles) take(castSolid(a, d, { min: point(c.at.x, c.at.y, map.bounds.min.z - r), max: point(c.at.x, c.at.y, map.bounds.max.z + r), r: c.r }), (c as any).id);
+  for (const s of map.spheres ?? []) take(castSolid(a, d, { min: s.at, max: s.at, r: s.r }), (s as any).id);
+  for (const c of map.capsules ?? []) take(castSolid(a, d, solidAt(c.at, { shape: 'capsule', radius: c.r, height: c.height })), (c as any).id);
   return best;
 }
 export function restsOnMap(map: Map3, p: Vec3, body: BodyShape): boolean {

package/rules/core.ts

@@ -1,3 +1,4 @@
+import { colliderSolid, castCollider2, colliderRow, collisionMap, collisionQueries, type CollisionRevision } from './live.ts';
 /*
  * core.ts — one room's world, stepped a tick at a time from a compiled rules module.
  * =============================================================================
@@ -41,7 +42,7 @@
 import { castMap3, castSolid, restsOnMap, solidAt, type BodyShape, type Hit3 } from './collision.ts';
 import { argsWhy, type Vocabulary } from '../agents/agents.ts';
 import { BudgetError, G, brand, charge, deepFreeze, plainData } from './guard.ts';
-import { SKIN, castMap, exact, math, rayCircle, sweepMap } from './math.ts';
+import { SKIN, castMap, exact, math, rayCircle } from './math.ts';
 import type { Hit } from './math.ts';
 import { AHEAD, ZERO, coerce, coerceFields, dir, est, estFields, initFields, mutable, num, own, packEntity, packFields, packVec, packed, said, thaw, naming, unpackFields, unpackVec, vec3 } from './pack.ts';
 import { ENTITY_MAX, QUEUE_MAX, REACH_M, SAVE_REVISION, cellsOf } from './rules.ts';
@@ -178,7 +179,7 @@ export interface Core {
  * `noted`: told, as it happens, of a value the rules wrote that the runtime changed to make it fit, or dropped (pack.ts
  * `Adjusted`; also `effect`, `think` and `decision`): the handler, what was done, the field's name and what was written.
  */
-export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: number, input: Readonly<Record<string, unknown>>, before: import('./pack.ts').MoveBody, after: import('./pack.ts').MoveBody) => void; observe?: (kind: string, handler: string, error?: string) => void; noted?: (kind: string, handler: string, what: string, at: string, written: string) => void; seed?: number; epoch?: number; restore?: SavedCore | null; restoreEpoch?: number; stage?: string; decisions?: boolean } = {}): Core {
+export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: number, input: Readonly<Record<string, unknown>>, before: import('./pack.ts').MoveBody, after: import('./pack.ts').MoveBody, geometry: import('./math.ts').MapShapes) => void; observe?: (kind: string, handler: string, error?: string) => void; noted?: (kind: string, handler: string, what: string, at: string, written: string) => void; seed?: number; epoch?: number; restore?: SavedCore | null; restoreEpoch?: number; stage?: string; decisions?: boolean } = {}): Core {
   const dims = c.dims;
   const tickHz = c.settings.tickHz;
   const dt = 1 / tickHz;
@@ -483,7 +484,10 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     const solid = solidAt(p, shape);
     for (const other of ents.values()) {
       if (!other.kind.body || ignored.has(other.id)) continue;
-      const hit = castSolid(solid, d, solidAt(other.pos, other.kind.body));
+      if (other.kind.collider) charge(48);
+      const row = other.kind.collider ? colliderRow(other.id, other.pos, other.kind.body, other.kind.collider, other.f) : null;
+      if (other.dead || other.kind.collider && !row) continue;
+      const hit = castSolid(solid, d, row ? colliderSolid(row) : solidAt(other.pos, other.kind.body));
       if (hit && (!best || hit.t < best.t)) best = { ...hit, id: other.id };
     }
     return best;
@@ -618,7 +622,10 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
       let best: Hit | null = cast.hit;
       for (const e of ents.values()) {
         if (!e.kind.body || e === cx.ent) continue;
-        const h = rayCircle(p.x, p.y, d.x * far, d.y * far, e.pos.x, e.pos.y, e.kind.body.radius);
+        if (e.kind.collider) charge(48);
+        const row = e.kind.collider ? colliderRow(e.id, e.pos, e.kind.body, e.kind.collider, e.f) : null;
+        if (e.dead || e.kind.collider && !row) continue;
+        const h = row ? castCollider2(row, p, {x:d.x*far,y:d.y*far,z:0}, 0) : rayCircle(p.x, p.y, d.x * far, d.y * far, e.pos.x, e.pos.y, e.kind.body.radius);
         if (h && (!best || h.t < best.t)) best = { ...h, id: e.id };
       }
       if (!best) return undefined;
@@ -648,7 +655,10 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
       let best: Hit | null = cast.hit;
       for (const other of ents.values()) {
         if (other === e || !other.kind.body || ignore.has(other.id)) continue;
-        const h = rayCircle(e.pos.x, e.pos.y, d.x, d.y, other.pos.x, other.pos.y, other.kind.body.radius + radius);
+        if (other.kind.collider) charge(48);
+        const row = other.kind.collider ? colliderRow(other.id, other.pos, other.kind.body, other.kind.collider, other.f) : null;
+        if (other.dead || other.kind.collider && !row) continue;
+        const h = row ? castCollider2(row, e.pos, d, radius) : rayCircle(e.pos.x, e.pos.y, d.x, d.y, other.pos.x, other.pos.y, other.kind.body.radius + radius);
         if (h && (!best || h.t < best.t)) best = { ...h, id: other.id };
       }
       const l = Math.sqrt(d.x * d.x + d.y * d.y);
@@ -678,11 +688,19 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
   });
   Object.freeze(world);
 
-  const moveMap = brand(Object.freeze({ name: c.map.name, spot: mapApi.spot, spots: mapApi.spots, sweep: (body: unknown, delta: unknown): unknown => sweepMap(c.map, body, delta, moveRadius, dims, moveShape) }));
-  let moveRadius = 0;
+  const hasColliders = c.kinds.some(k => k.collider);
+  const collisionState = (): CollisionRevision => [tick, tick + 1, [...ents.values()].flatMap(e => {
+    if (e.dead || !e.kind.collider || !e.kind.body) return [];
+    const row = colliderRow(e.id, e.pos, e.kind.body, e.kind.collider, e.f);
+    return row ? [row] : [];
+  })];
+  let moveGeometry = c.map as import('./math.ts').MapShapes;
+  const queries = collisionQueries(() => moveGeometry, () => moveShape, dims);
+  const moveWorld = brand(Object.freeze(queries));
+  const moveMap = brand(Object.freeze({ name: c.map.name, spot: mapApi.spot, spots: mapApi.spots, ...queries }));
   let moveShape = { shape: 'sphere', radius: 0, height: 0 };
   const moveCtx = brand({} as Record<string, unknown>);
-  for (const [name, get] of Object.entries({ tick: () => tick, dt: () => dt, tune: () => c.publicTune, math: () => math, map: () => moveMap })) Object.defineProperty(moveCtx, name, { get, enumerable: true });
+  for (const [name, get] of Object.entries({ tick: () => tick, dt: () => dt, tune: () => c.publicTune, math: () => math, map: () => moveMap, world: () => moveWorld })) Object.defineProperty(moveCtx, name, { get, enumerable: true });
   Object.assign(moveCtx, { ticks: (seconds: unknown): number => { charge(1); return ticks(seconds); } });
   Object.freeze(moveCtx);
   const joinCtx = brand({} as Record<string, unknown>);
@@ -988,6 +1006,8 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
         }
       }
       guides?.();
+      // All movers see the same world, independent of entity iteration order.
+      if (hasColliders) { left -= 64 * ents.size + 4 * mapShapes; moveGeometry = collisionMap(c.map, collisionState()[2]); }
       // Phase 1: one input step and `move` for every body.
       for (const e of [...ents.values()]) {
         if (e.dead || !e.kind.body) continue;
@@ -1040,7 +1060,7 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
         if (!k.move) continue;
         const b = { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: e.mself };
         const beforeMove = opts.moved ? { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: { ...e.m } } : null;
-        moveRadius = body.radius; moveShape = body;
+        moveShape = body;
         run(k.name, 'move', e, 'move', () => (k.move as NonNullable<KindTable['move']>)(b, e.input, moveCtx), 'body');
         // The runtime rounds to 32-bit floats, here and in the browser, so both step from exactly the same numbers.
         // `b` is the runtime's own object: what `move` left in it is read by its own data properties and cannot throw.
@@ -1049,7 +1069,7 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
         naming('body', 'pos'); e.pos = clampIn(V(own(b, 'pos')), body.radius, body.height || 2 * body.radius); naming('body', 'vel'); e.vel = V(own(b, 'vel')); naming('body', 'heading'); e.heading = dir(own(b, 'heading'), dims); naming();
         G.note = null;
         e.grounded = own(b, 'grounded') === true;
-        if (beforeMove) opts.moved!(k.name, tick, e.input, beforeMove, { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: { ...e.m } });
+        if (beforeMove) opts.moved!(k.name, tick, e.input, beforeMove, { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: { ...e.m } }, moveGeometry);
       }
       // Phase 2: for every entity, its commands and then its tick, starting from a different entity each tick.
       const list = [...ents.values()];
@@ -1369,7 +1389,9 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
       const list = [...ents.values()].map((e) => packEntity(e.kind, e, dims));
       // Include all three components of position, velocity and heading in a 3D snapshot.
       snapCells = packed.n + (dims === 3 ? 13 : 10) * list.length;
-      return [[round.n, round.phase === 'live' ? 1 : 0, round.endsAt], list];
+      const collision = hasColliders ? collisionState() : null;
+      if (collision) snapCells += 3 + collision[2].length * 8;
+      return [[round.n, round.phase === 'live' ? 1 : 0, round.endsAt], list, ...(collision ? [collision] : [])];
     },
     shared: () => packFields(c.shared, shared, dims),
     bodies: () => playerBodies().map((e) => ({ seat: e.seat, id: e.id, kind: e.kind.name, driver: e.driver, owner: e.owner, away: e.away, score: e.kind.score ? Number(e.f[e.kind.score]) || 0 : 0, r: e.r })),

package/rules/host.ts

@@ -99,6 +99,7 @@ export interface Host {
   readonly running: boolean;
   readonly paused: boolean;
   readonly people: number;
+  readonly viewRadiusM: number | null;
   frame(m: Record<string, unknown>): void;
   /** Start the tick loop (the first person has joined). */
   start(): void;
@@ -767,6 +768,7 @@ export function createHost(o: HostOptions): Host {
   }
 
   return {
+    get viewRadiusM() { return c.settings.view?.radiusM ?? null; },
     get tick() { return core.tick; },
     get epoch() { return epoch; },
     get running() { return running; },

package/rules/interest.mjs

@@ -0,0 +1,81 @@
+/** Per-connection state delivery. Pure data, shared by the relay and the view.
+ * Deltas name a keyframe, never an unacknowledged previous delta. Losing a delta
+ * therefore loses no baseline. A new keyframe bounds recovery to one second.
+ * No history grows with time: one keyframe per connection, no per-frame queue.
+ */
+export function interestSnapshot(snap, seat, radiusM) {
+  const [round, entities] = snap.d;
+  const own = seat === null ? null : entities.find(e => e[9] === seat && e[10] === 0);
+  const visible = own && radiusM !== null ? entities.filter(e => {
+    const p = e[3], q = own[3];
+    return e === own || (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2 + ((p[2] ?? 0) - (q[2] ?? 0)) ** 2 <= radiusM ** 2;
+  }) : seat === null ? entities : own ? entities : [];
+  // Collision revisions are prediction inputs, independent of visual interest.
+  // Deliver all geometry: authored sweeps/dashes need not fit inside the view radius.
+  return { ...snap, d: [round, visible, ...snap.d.slice(2)], c: (snap.c ?? []).filter(row => row[0] === seat) };
+}
+
+export function snapshotEncoder(keyframeTicks) {
+  let base = null;
+  let rows = new Map();
+  return {
+    reset() { base = null; rows.clear(); },
+    encode(snap) {
+      if (!base || snap.e !== base.e || snap.k <= base.k || snap.k - base.k >= keyframeTicks) {
+        base = snap;
+        rows = new Map(snap.d[1].map(e => [e[0], e.map(v => JSON.stringify(v))]));
+        return snap;
+      }
+      const present = new Set(), changed = [];
+      for (const entity of snap.d[1]) {
+        const id = entity[0]; present.add(id);
+        const before = rows.get(id);
+        if (!before) { changed.push(entity); continue; }
+        let mask = 0; const values = [];
+        for (let i = 1; i < entity.length; i++) if (JSON.stringify(entity[i]) !== before[i]) { mask |= 1 << i; values.push(entity[i]); }
+        if (mask) changed.push([id, mask, values]);
+      }
+      return { ...snap, d: { base: base.k, round: snap.d[0], ...(snap.d.length > 2 ? { collision: snap.d[2] } : {}), changed, removed: [...rows.keys()].filter(id => !present.has(id)) } };
+    },
+  };
+}
+
+export function snapshotDecoder() {
+  let base = null;
+  let rows = new Map();
+  return {
+    reset() { base = null; rows.clear(); },
+    decode(snap) {
+      if (!snap || typeof snap !== 'object') return null;
+      if (Array.isArray(snap.d)) {
+        if (!Array.isArray(snap.d[0]) || !Array.isArray(snap.d[1]) ||
+          !snap.d[1].every(e => Array.isArray(e) && e.length >= 9 && typeof e[0] === 'string')) return null;
+        // A late duplicate keyframe must not replace the newer baseline.
+        if (!base || snap.e !== base.e || snap.k >= base.k) {
+          base = snap; rows = new Map(snap.d[1].map(e => [e[0], e]));
+        }
+        return snap;
+      }
+      const d = snap.d;
+      if (!base || !d || d.base !== base.k || snap.e !== base.e || snap.k <= base.k) return null;
+      if (!Array.isArray(d.round) || !Array.isArray(d.removed) || !Array.isArray(d.changed)) return null;
+      const next = new Map(rows);
+      for (const id of d.removed) next.delete(id);
+      for (const change of d.changed) {
+        if (!Array.isArray(change) || typeof change[0] !== 'string') return null;
+        if (change.length !== 3) {
+          if (change.length < 9) return null;
+          next.set(change[0], change); continue;
+        }
+        if (!Number.isInteger(change[1]) || change[1] < 0 || !Array.isArray(change[2])) return null;
+        const old = rows.get(change[0]);
+        if (!old) return null;
+        const entity = old.slice(); let j = 0;
+        for (let i = 1; i < entity.length; i++) if (change[1] & (1 << i)) entity[i] = change[2][j++];
+        if (j !== change[2].length) return null;
+        next.set(entity[0], entity);
+      }
+      return { ...snap, d: [d.round, [...next.values()], ...(d.collision === undefined ? [] : [d.collision])] };
+    },
+  };
+}

package/rules/live.ts

@@ -0,0 +1,73 @@
+/** Declared collision geometry, shared by authority and prediction. Entity fields
+ * own its lifetime and dimensions; this projection contains no gameplay state. */
+import type { Vec3, ColliderDef } from './rules.ts';
+import type { MapShapes } from './math.ts';
+import { charge, own } from './guard.ts';
+import { castMap3, solidAt, type BodyShape } from './collision.ts';
+import { sweepMap, rayBox, rayCircle } from './math.ts';
+
+export type ColliderRow = [string, string, number, number, number, number, number, number];
+export type CollisionRevision = [number, number, ColliderRow[]];
+export function colliderRow(id: string, at: Vec3, body: BodyShape, def: ColliderDef, fields: Record<string, unknown>): ColliderRow | null {
+  const opts = def === true ? {} : def;
+  if (opts.enabled && fields[opts.enabled] !== true) return null;
+  const size = opts.size ? fields[opts.size] as Vec3 : null;
+  const x = size ? size.x : body.radius * 2, y = size ? size.y : body.radius * 2, z = size ? size.z : body.height || body.radius * 2;
+  if (![x, y, z].every(Number.isFinite) || x <= 0 || y <= 0 || z < 0) return null;
+  return [id, size ? 'box' : body.shape, at.x, at.y, at.z, x, y, z];
+}
+export function colliderSolid(row: ColliderRow): ReturnType<typeof solidAt> {
+  const [, shape, x, y, z, w, d, h] = row;
+  return shape === 'box' ? { min: { x: x-w/2, y: y-d/2, z }, max: { x:x+w/2, y:y+d/2, z:z+h }, r:0 }
+    : solidAt({x,y,z}, {shape, radius:w/2, height:h});
+}
+export function castCollider2(row: ColliderRow, p: Vec3, d: Vec3, radius: number) {
+  const solid = colliderSolid(row);
+  return row[1] === 'box' ? rayBox(p.x,p.y,d.x,d.y,solid.min,solid.max,radius) : rayCircle(p.x,p.y,d.x,d.y,row[2],row[3],row[5]/2+radius);
+}
+export function collisionMap(map: MapShapes, rows: readonly ColliderRow[]): MapShapes {
+  if (!rows.length) return map;
+  const boxes = [...map.boxes], circles = [...map.circles], spheres = [...(map.spheres ?? [])], capsules = [...(map.capsules ?? [])];
+  for (const [id, shape, x, y, z, w, d, h] of rows) {
+    const at = { x, y, z };
+    if (shape === 'box') boxes.push({ min: { x: x - w / 2, y: y - d / 2, z }, max: { x: x + w / 2, y: y + d / 2, z: z + h }, id } as any);
+    else if (shape === 'circle') circles.push({ at, r: w / 2, id } as any);
+    else if (shape === 'sphere') spheres.push({ at: { x, y, z: z + w / 2 }, r: w / 2, id } as any);
+    else capsules.push({ at, r: w / 2, height: h, id } as any);
+  }
+  return { ...map, boxes, circles, spheres, capsules };
+}
+/** Latest known revision at the requested tick. Unknown future edits are never
+ * guessed: a later snapshot rebases the body and replays its pending inputs. */
+export function revisionAt(history: readonly CollisionRevision[], tick: number): CollisionRevision | undefined {
+  for (let i = history.length - 1; i >= 0; i--) if (history[i][1] <= tick) return history[i];
+  return undefined;
+}
+export function collisionQueries(map: () => MapShapes, shape: () => BodyShape, dims: number): object {
+  const position = (body: unknown): Vec3 => {
+    const p = own(body, 'pos');
+    const n = (k: string): number => { const v = own(p, k); return typeof v === 'number' && Number.isFinite(v) ? Math.fround(v) : 0; };
+    return { x: n('x'), y: n('y'), z: n('z') };
+  };
+  return {
+    sweep: (body: unknown, delta: unknown) => sweepMap(map(), body, delta, shape().radius, dims, shape()),
+    support: (body: unknown, distance: unknown = 0.002) => {
+      charge(20);
+      const p = position(body), m = map();
+      const d = typeof distance === 'number' && Number.isFinite(distance) ? Math.max(0, Math.min(10000, distance)) : 0;
+      if (dims === 2) return Object.freeze({ at: Object.freeze(p), normal: Object.freeze({ x: 0, y: 0, z: 1 }), dist: 0 });
+      const h = castMap3(m, p, { x: 0, y: 0, z: -d }, shape());
+      return h && h.nz > 0.5 ? Object.freeze({ at: Object.freeze({ ...p, z: p.z - d * h.t }), normal: Object.freeze({ x: h.nx, y: h.ny, z: h.nz }), dist: d * h.t, ...(h.id ? { entity: h.id } : {}) }) : undefined;
+    },
+    overlaps: (body: unknown) => {
+      const m = map(), p = position(body), s = shape(), a = solidAt(p, s);
+      charge(20 + 8 * (m.boxes.length + m.circles.length + (m.spheres?.length ?? 0) + (m.capsules?.length ?? 0)));
+      const overlap = (b: ReturnType<typeof solidAt>): boolean => {
+        let sq = 0;
+        for (const k of dims === 2 ? ['x', 'y'] as const : ['x', 'y', 'z'] as const) { const gap = Math.max(0, a.min[k] - b.max[k], b.min[k] - a.max[k]); sq += gap * gap; }
+        return sq < (a.r + b.r) ** 2 || a.r + b.r === 0 && a.min.x < b.max.x && a.max.x > b.min.x && a.min.y < b.max.y && a.max.y > b.min.y && (dims === 2 || a.min.z < b.max.z && a.max.z > b.min.z);
+      };
+      return m.boxes.some(b => overlap({ ...b, r: 0 })) || m.circles.some(b => overlap({ min: {...b.at,z:m.bounds.min.z}, max: {...b.at,z:m.bounds.max.z}, r: b.r })) || (m.spheres ?? []).some(b => overlap({ min: b.at, max: b.at, r: b.r })) || (m.capsules ?? []).some(b => overlap(solidAt(b.at, { shape: 'capsule', radius: b.r, height: b.height })));
+    },
+  };
+}

package/rules/math.ts

@@ -1,3 +1,4 @@
+import { collisionQueries } from './live.ts';
 /*
  * math.ts — `world.math` and `ctx.math`: the maths rules may not take from `Math`, in plain arithmetic.
  * =============================================================================
@@ -204,7 +205,7 @@ export function rayCircle(px: number, py: number, dx: number, dy: number, cx: nu
   return { t, nx: hx / l, ny: hy / l };
 }
 /** The same point against a box grown by r with round corners (a circle of radius r against the box). */
-function rayBox(px: number, py: number, dx: number, dy: number, min: Vec3, max: Vec3, r: number): Hit | null {
+export function rayBox(px: number, py: number, dx: number, dy: number, min: Vec3, max: Vec3, r: number): Hit | null {
   let t0 = 0; let t1 = 1; let nx = 0; let ny = 0;
   const lo = [min.x - r, min.y - r]; const hi = [max.x + r, max.y + r];
   const p = [px, py]; const d = [dx, dy];
@@ -237,8 +238,8 @@ function rayBounds(px: number, py: number, dx: number, dy: number, b: { min: Vec
 /** A circle (or a point, r 0) moved along d against the static map: the first thing in the way, and how many shapes were tested. */
 export function castMap(map: MapShapes, px: number, py: number, dx: number, dy: number, r: number): { hit: Hit | null; tested: number } {
   let best: Hit | null = rayBounds(Math.max(map.bounds.min.x + r, Math.min(map.bounds.max.x - r, px)), Math.max(map.bounds.min.y + r, Math.min(map.bounds.max.y - r, py)), dx, dy, map.bounds, r);
-  for (const b of map.boxes) { const h = rayBox(px, py, dx, dy, b.min, b.max, r); if (h && (!best || h.t < best.t)) best = h; }
-  for (const c of map.circles) { const h = rayCircle(px, py, dx, dy, c.at.x, c.at.y, c.r + r); if (h && (!best || h.t < best.t)) best = h; }
+  for (const b of map.boxes) { const h = rayBox(px, py, dx, dy, b.min, b.max, r); if (h && (!best || h.t < best.t)) best = { ...h, id: (b as any).id }; }
+  for (const c of map.circles) { const h = rayCircle(px, py, dx, dy, c.at.x, c.at.y, c.r + r); if (h && (!best || h.t < best.t)) best = { ...h, id: (c as any).id }; }
   return { hit: best, tested: 4 + map.boxes.length + map.circles.length };
 }
 
@@ -264,7 +265,7 @@ export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius:
     const t = h ? Math.max(0, h.t - (length > 0 ? SKIN / length : 0)) : 1;
     const at = v(fr(px + dx * t), fr(py + dy * t), fr(p.z + d.z * t));
     put(body, 'pos', at); put(body, 'grounded', restsOnMap(map, at, shape));
-    return h ? Object.freeze({ at, normal: v(h.nx, h.ny, h.nz) }) : undefined;
+    return h ? Object.freeze({ at, normal: v(h.nx, h.ny, h.nz), ...(h.id ? { entity: h.id } : {}) }) : undefined;
   }
   const { hit: h } = castMap(map, px, py, dx, dy, radius);
   put(body, 'grounded', true);
@@ -273,7 +274,7 @@ export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius:
   const t = l > 0 ? Math.max(0, h.t - SKIN / l) : 0;
   const at = v(fr(px + dx * t), fr(py + dy * t), 0);
   put(body, 'pos', at);
-  return Object.freeze({ at, normal: v(h.nx, h.ny, 0) });
+  return Object.freeze({ at, normal: v(h.nx, h.ny, 0), ...(h.id ? { entity: h.id } : {}) });
 }
 
 /**
@@ -281,12 +282,14 @@ export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius:
  * map. One function, so that the browser (view.ts) and the person the build check plays hold the same one. The
  * server's own (core.ts `moveCtx`) is made beside the rest of its world, and charges as that does.
  */
-export function moveContext(o: { tick: () => number; tickHz: number; tune: unknown; map: MapShapes; name: string; spots: Readonly<Record<string, readonly unknown[]>>; radius: () => number; shape?: () => BodyShape; dims: number }): unknown {
+export function moveContext(o: { tick: () => number; tickHz: number; tune: unknown; map: MapShapes; name: string; spots: Readonly<Record<string, readonly unknown[]>>; radius: () => number; shape?: () => BodyShape; dims: number; geometry?: () => MapShapes }): unknown {
   const none = Object.freeze([]);
+  const queries = collisionQueries(() => o.geometry?.() ?? o.map, () => o.shape?.() ?? {shape: 'sphere', radius: o.radius(), height: 2 * o.radius()}, o.dims);
   return brand(Object.freeze({
     get tick() { return o.tick(); }, dt: 1 / o.tickHz, tune: o.tune, math,
     // As the server's `ctx.ticks` reads it: a plain number, or nothing.
     ticks: (seconds: unknown): number => { const s = num(seconds); const n = Math.round(s * o.tickHz); return s > 0 && Number.isFinite(n) ? Math.max(1, n) : 0; },
-    map: brand(Object.freeze({ name: o.name, spot: (name: string) => (own(o.spots, name) as readonly unknown[] | undefined)?.[0], spots: (name: string) => own(o.spots, name) ?? none, sweep: (body: unknown, delta: unknown) => sweepMap(o.map, body, delta, o.radius(), o.dims, o.shape?.()) })),
+    world: brand(Object.freeze(queries)),
+    map: brand(Object.freeze({ name: o.name, spot: (name: string) => (own(o.spots, name) as readonly unknown[] | undefined)?.[0], spots: (name: string) => own(o.spots, name) ?? none, ...queries })),
   }));
 }

package/rules/rules.ts

@@ -37,7 +37,7 @@ export const SAVE_REVISION = 2;
 export const REACH_M = 64;
 /** The most entities one room holds. A spawn past it throws in the handler that asked. */
 export const ENTITY_MAX = 2048;
-/** The most seats one room holds (worker/seats.mjs `SEAT_MAX`). */
+/** The current bot-fill ceiling; public admission lives in worker/seats.mjs. */
 export const SEATS_MAX = 32;
 /** The most values one declared field may hold when it is full (`cellsOf`), and the most all the fields of one kind of entity may. */
 export const FIELD_CELLS_MAX = 16_384;
@@ -123,6 +123,7 @@ export type Handler = (world: RuntimeWorld, self: RuntimeSelf, e?: any) => void;
 export type RoomHandler = (world: RuntimeWorld, e?: any) => void;
 export type MoveFn = (body: any, input: any, ctx: any) => void;
 
+export type ColliderDef = true | { size?: string; enabled?: string };
 export interface BodyDef { shape: 'circle' | 'sphere' | 'capsule' | 'box'; radius: number; height?: number; maxSpeed: number; sweep?: boolean; move?: 'owner' }
 export interface GuideDef { view: (world: RuntimeWorld, self: RuntimeSelf) => unknown; floor?: (world: RuntimeWorld, self: RuntimeSelf, view: any) => unknown }
 export interface EntityDef {
@@ -131,6 +132,7 @@ export interface EntityDef {
   motion?: Fields;
   input?: Fields;
   body?: BodyDef;
+  collider?: ColliderDef;
   guide?: GuideDef;
   tick?: Handler;
   think?: (world: RuntimeWorld, self: RuntimeSelf) => Record<string, unknown>;
@@ -176,6 +178,8 @@ export interface RoomSettings {
   offline: boolean;
   tickHz: number;
   inputHz: number;
+  /** Omit the radius to send the whole room. No implicit visibility or bandwidth cap. */
+  view: { radiusM: number | null };
   durability: { movementSeconds: number };
   budget: { tick: number };
   predict: { catchM: number | null; catchUp: number; snapM: number | null; blendMs: number; interpMs: number | null };
@@ -191,7 +195,7 @@ export const BUDGET_TICK = 500_000;
 export const BUDGET_SECOND = 10_000_000;
 export const budgetFor = (tickHz: number): number => Math.min(BUDGET_TICK, Math.floor(BUDGET_SECOND / tickHz));
 export const ROOM_DEFAULTS: RoomSettings = deepFreeze({
-  host: 'server', offline: true, tickHz: 20, inputHz: 20, durability: { movementSeconds: 1 }, budget: { tick: BUDGET_TICK },
+  host: 'server', offline: true, tickHz: 20, inputHz: 20, view: { radiusM: null }, durability: { movementSeconds: 1 }, budget: { tick: BUDGET_TICK },
   predict: { catchM: null, catchUp: 1.25, snapM: null, blendMs: 100, interpMs: null },
 });
 
@@ -212,18 +216,24 @@ export function roomSettings(raw: unknown): { settings: RoomSettings; problems:
     if (!Number.isFinite(n) || n < 0) { problems.push(`"room.${name}" is a number, zero or more; using its default`); return d; }
     return n;
   };
-  const known = new Set(['host', 'offline', 'tickHz', 'inputHz', 'durability', 'budget', 'predict']);
-  for (const key of Object.keys(r)) if (!known.has(key)) problems.push(`"room.${key}" is not a setting (host, offline, tickHz, inputHz, durability, budget, predict)`);
+  const known = new Set(['host', 'offline', 'tickHz', 'inputHz', 'durability', 'budget', 'predict', 'view']);
+  for (const key of Object.keys(r)) if (!known.has(key)) problems.push(`"room.${key}" is not a setting (host, offline, tickHz, inputHz, durability, budget, predict, view)`);
   let host: 'server' | 'browser' = 'server';
   if (r.host !== undefined) { if (r.host === 'server' || r.host === 'browser') host = r.host; else problems.push('"room.host" is "server" or "browser"; using "server"'); }
   let offline = true;
   if (r.offline !== undefined) { if (typeof r.offline === 'boolean') offline = r.offline; else problems.push('"room.offline" is true or false; using true'); }
   const tickHz = whole('tickHz', r.tickHz, 1, 60, 20);
   const inputHz = whole('inputHz', r.inputHz, 1, tickHz, tickHz);
+  if (host === 'browser' && r.view?.radiusM != null) problems.push('"room.view.radiusM" needs room.host "server"; browser hosting sends the whole room');
+  if (r.view !== undefined) {
+    if (!r.view || typeof r.view !== 'object' || Array.isArray(r.view)) problems.push('"room.view" is an object with an optional radiusM');
+    else for (const key of Object.keys(r.view)) if (key !== 'radiusM') problems.push(`"room.view.${key}" is not a setting; use radiusM`);
+  }
   const p = r.predict && typeof r.predict === 'object' ? r.predict : {};
   return {
     settings: {
       host, offline, tickHz, inputHz,
+      view: { radiusM: r.view?.radiusM === null ? null : num('view.radiusM', r.view?.radiusM, null) },
       durability: { movementSeconds: whole('durability.movementSeconds', r.durability?.movementSeconds, 1, 60, 1) },
       budget: { tick: Math.max(1, Math.floor(num('budget.tick', r.budget?.tick, budgetFor(tickHz)) as number)) },
       predict: { catchM: num('predict.catchM', p.catchM, null), catchUp: num('predict.catchUp', p.catchUp, 1.25) as number, snapM: num('predict.snapM', p.snapM, null), blendMs: num('predict.blendMs', p.blendMs, 100) as number, interpMs: num('predict.interpMs', p.interpMs, null) },
@@ -307,6 +317,7 @@ export interface KindTable {
   fields: FieldList;
   motion: FieldList;
   input: FieldList;
+  collider?: ColliderDef;
   body: null | { shape: string; radius: number; height: number; maxSpeed: number; sweep: boolean; owner: boolean };
   score: string | null;
   tick: Handler | null;
@@ -513,11 +524,22 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
     if (e.guide !== undefined && (typeof e.guide !== 'object' || typeof e.guide?.view !== 'function')) throw new Error(`${at}.guide needs view(world, self)`);
     const cells = cellsOfList(fields) + cellsOfList(motion);
     if (cells > KIND_CELLS_MAX) throw new Error(`${at}: its fields and motion may hold ${cells} values when they are full, and one entity holds ${KIND_CELLS_MAX} at most`);
-    const k: KindTable = { name, index: kinds.length, player, fields, motion, input, body, score: scores[0]?.[0] ?? null, tick: e.tick ?? null, think: e.think ?? null, on, commands: cmds, onRoom, guide: e.guide ?? null, move: moveFn };
+    if (e.collider !== undefined) {
+      if (!body || player || body.owner) throw new Error(`${at}.collider needs a non-player body`);
+      if (e.collider !== true) {
+        if (!e.collider || typeof e.collider !== 'object' || Object.keys(e.collider).some(k => !['size', 'enabled'].includes(k))) throw new Error(`${at}.collider is true or {size, enabled}`);
+        for (const [key, type] of [['size', 'vec3'], ['enabled', 'bit']]) {
+          const name = (e.collider as Record<string, unknown>)[key];
+          if (name !== undefined && (typeof name !== 'string' || !fields.some(([n, f]) => n === name && f.t === type))) throw new Error(`${at}.collider.${key} must name a ${type} field`);
+        }
+      }
+    }
+    const k: KindTable = { ...(e.collider ? { collider: e.collider } : {}), name, index: kinds.length, player, fields, motion, input, body, score: scores[0]?.[0] ?? null, tick: e.tick ?? null, think: e.think ?? null, on, commands: cmds, onRoom, guide: e.guide ?? null, move: moveFn };
     kinds.push(k);
     kindOf[name] = k;
   }
 
+  if (kinds.some(k => k.collider) && kinds.some(k => k.player && k.body?.owner)) throw new Error("live colliders need server movement: omit body.move: 'owner' on players");
   const room = d.room ?? {};
   const roomOn = handlers<RoomHandler>(room.on, 'room.on');
   for (const key of Object.keys(roomOn)) if (!events[key] && !ROOM_EVENTS.includes(key) && !SEAT_EVENTS.includes(key) && key !== 'answer' && key !== 'undeliverable') throw new Error(`room.on.${key}: no event "${key}" is declared in shapes.events`);
@@ -540,7 +562,7 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
     if (!a.questions || typeof a.questions !== 'object') throw new Error(`asks.${key}.questions is required; for example { advance: { type: 'noul', instructions: 'Should the party advance?' } }`);
     asks[key] = { ...a, stateFields: fieldList(a.state, `asks.${key}.state`) };
   }
-  const seats = Math.max(1, Math.min(SEATS_MAX, Math.floor(Number(env.seats)) || 8));
+  const seats = Math.max(1, Math.min(Number.MAX_SAFE_INTEGER, Math.floor(Number(env.seats)) || 8));
   return {
     contract: RULES_CONTRACT, save: SAVE_REVISION, dims, kinds, kindOf, events, commands, effects, effectNames: Object.keys(effects),
     shared: fieldList(d.shared, 'shared'), view, rounds, bots: Math.min(keep, seats), start: room.start ?? null, join: room.join ?? null, roomOn, asks,