@homie-rocks/studio 0.44.0 → 0.44.3

package/lib/template-history.json

@@ -2426,6 +2426,90 @@
      }
     }
    }
+  },
+  "0.44.1": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "732894273a32dc3f",
+    "site/src/worker.mjs": "34444a6ca4b14437"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
+     "## Commands (all through the pinned CLI in node_modules)": "159151b8861fc051",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "9e44559de535d842",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "d0028361fe567add",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "2e6b29afb85dcf7e",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "2cdd530e48170bfd"
+      }
+     }
+    }
+   }
+  },
+  "0.44.3": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "732894273a32dc3f",
+    "site/src/worker.mjs": "34444a6ca4b14437"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
+     "## Commands (all through the pinned CLI in node_modules)": "159151b8861fc051",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "9e44559de535d842",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "d0028361fe567add",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "2e6b29afb85dcf7e",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "2cdd530e48170bfd"
+      }
+     }
+    }
+   }
   }
  }
 }

package/lib/worker-build.mjs

@@ -1,23 +1,67 @@
+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,resolve} 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);
+  const current=join(out,'current.json'), pending=`${current}.${process.pid}.tmp`;
+  writeFileSync(pending,JSON.stringify({main:join(dir,'worker.js')})+'\n');renameSync(pending,current);
+  // 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;
 }
+
+/** Local immutable entry; the committed config always names the stable shim. */
+export function workerEntry(root) {
+  const main=readConfig(root)?.main;
+  // Explicit custom entry points remain the owner's choice.
+  if(typeof main!=='string' || resolve(workerDir(root),main)!==resolve(root,'site/src/runtime/worker.js'))return null;
+  const file=join(root,'site/src/runtime/current.json');
+  return existsSync(file)?JSON.parse(readFileSync(file,'utf8')).main:null;
+}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.44.0",
+  "version": "0.44.3",
   "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

@@ -1,3 +1,5 @@
+import { castTerrain } from './terrain.ts';
+import { nearbyMap } from './map-index.ts';
 /** Upright 3D collision. Positions are feet; a rounded box is a box plus a sphere.
  * Capsules are a vertical segment plus a sphere. No engine-specific maths or time.
  */
@@ -8,13 +10,14 @@ export interface BodyShape { shape: string; radius: number; height: number }
 export interface Solid { min: Vec3; max: Vec3; r: number }
 export interface Hit3 { t: number; nx: number; ny: number; nz: number; id?: string }
 export interface Map3 {
+  staticMap?: Map3;
   bounds: MapBox; boxes: readonly MapBox[]; circles: readonly MapCircle[];
   heightTiles?: readonly MapHeightTile[];
   spheres?: readonly MapCircle[];
   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 };
@@ -74,15 +77,17 @@ function castHeightTile(tile: MapHeightTile, p: Vec3, d: Vec3): Hit3 | null {
   const x = p.x - tile.at.x, y = p.y - tile.at.y;
   let best: Hit3 | null = null;
   for (const half of [0, 1]) {
+    const alternate = tile.diagonal === '10-01';
     const gx = half === 0 ? (h10 - h00) / sx : (h11 - h01) / sx;
-    const gy = half === 0 ? (h11 - h10) / sy : (h01 - h00) / sy;
-    const gap = p.z - tile.at.z - h00 - gx * x - gy * y;
+    const gy = alternate ? (half === 0 ? h01 - h00 : h11 - h10) / sy : (half === 0 ? h11 - h10 : h01 - h00) / sy;
+    const base = alternate && half === 1 ? h10 + h01 - h11 : h00;
+    const gap = p.z - tile.at.z - base - gx * x - gy * y;
     const closing = gx * d.x + gy * d.y - d.z;
     if (gap < -EPS || closing <= EPS) continue;
     const t = Math.max(0, gap / closing);
     if (t > 1 || best && t >= best.t) continue;
     const u = (x + d.x * t) / sx, v = (y + d.y * t) / sy;
-    if (u < -EPS || u > 1 + EPS || v < -EPS || v > 1 + EPS || (half === 0 ? v > u + EPS : u > v + EPS)) continue;
+    if (u < -EPS || u > 1 + EPS || v < -EPS || v > 1 + EPS || (alternate ? (half === 0 ? u + v > 1 + EPS : u + v < 1 - EPS) : (half === 0 ? v > u + EPS : u > v + EPS))) continue;
     const length = Math.sqrt(gx * gx + gy * gy + 1);
     best = { t, nx: -gx / length, ny: -gy / length, nz: 1 / length };
   }
@@ -90,10 +95,11 @@ function castHeightTile(tile: MapHeightTile, p: Vec3, d: Vec3): Hit3 | null {
 }
 
 export function castMap3(map: Map3, p: Vec3, d: Vec3, body: BodyShape): Hit3 | null {
+  map = nearbyMap(map, p, d, body.radius, body.height || body.radius * 2);
   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);
@@ -101,12 +107,12 @@ export function castMap3(map: Map3, p: Vec3, d: Vec3, body: BodyShape): Hit3 | n
     const n = point(0, 0, 0); n[axis] = d[axis] > 0 ? -1 : 1;
     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 tile of map.heightTiles ?? []) take(tile.base === undefined ? castHeightTile(tile, p, d) : castTerrain(tile, a, d));
+  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;
@@ -244,7 +245,6 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
   let stateHeavy = false;
   const viewCost = new Map<KindTable, number>();
   for (const k of c.kinds) viewCost.set(k, VIEW + k.fields.length + k.motion.length);
-  const mapShapes = 4 + c.map.boxes.length + c.map.circles.length;
 
   const ticks = (seconds: unknown): number => { const s = num(seconds); const n = Math.round(s * tickHz); return s > 0 && Number.isFinite(n) ? Math.max(1, n) : 0; };
   const V = (v: unknown): Vec3 => vec3(v, dims);
@@ -483,7 +483,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;
@@ -607,7 +610,7 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     },
     ray: (from: unknown, direction: unknown, max: unknown): unknown => {
       // Charged before the cast, for every shape it may test: the map's, and every entity in the room.
-      charge(20 + 4 * (mapShapes + ents.size));
+      charge(20 + 4 * ents.size);
       const p = V(from); const d = dir(direction, dims); const far = reach(max, 'world.ray');
       if (dims === 3) {
         const delta = { x: d.x * far, y: d.y * far, z: d.z * far };
@@ -618,7 +621,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;
@@ -626,7 +632,7 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     },
     sweep: (self: unknown, delta: unknown, o?: unknown): unknown => {
       const e = mine(self, 'world.sweep');
-      charge(20 + 4 * (mapShapes + ents.size));
+      charge(20 + 4 * ents.size);
       const d = V(delta);
       const radius = e.kind.body?.radius ?? 0;
       // The ids to pass through: the first few of a list, read as plain texts. A longer list is not searched once for every entity.
@@ -648,7 +654,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 +687,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 +1005,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; 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 +1059,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 +1068,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 +1388,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/interest.mjs

@@ -10,7 +10,9 @@ export function interestSnapshot(snap, seat, radiusM) {
     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 : [];
-  return { ...snap, d: [round, visible], c: (snap.c ?? []).filter(row => row[0] === seat) };
+  // 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) {
@@ -33,7 +35,7 @@ export function snapshotEncoder(keyframeTicks) {
         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], changed, removed: [...rows.keys()].filter(id => !present.has(id)) } };
+      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)) } };
     },
   };
 }
@@ -73,7 +75,7 @@ export function snapshotDecoder() {
         if (j !== change[2].length) return null;
         next.set(entity[0], entity);
       }
-      return { ...snap, d: [d.round, [...next.values()]] };
+      return { ...snap, d: [d.round, [...next.values()], ...(d.collision === undefined ? [] : [d.collision])] };
     },
   };
 }

package/rules/live.ts

@@ -0,0 +1,75 @@
+import { overlapsTerrain } from './terrain.ts';
+import { nearbyMap } from './map-index.ts';
+/** 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: any[] = [], circles: any[] = [], spheres: any[] = [], capsules: any[] = [];
+  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 { bounds: map.bounds, staticMap: 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 p = position(body), s = shape(), a = solidAt(p, s), m = nearbyMap(map(), p, {x:0,y:0,z:0}, s.radius, s.height || 2*s.radius, dims);
+      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.heightTiles ?? []).some(t => t.base !== undefined && overlapsTerrain(t, a)) || 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/map-index.ts

@@ -0,0 +1,51 @@
+/** Immutable build-time BVH. Queries charge nodes visited and narrow-phase work,
+ * never the number of shapes in the level. Live geometry is a separate overlay. */
+import { charge } from './guard.ts';
+import type { MapShapes } from './math.ts';
+import type { Vec3 } from './rules.ts';
+type Key = 'boxes' | 'circles' | 'spheres' | 'capsules' | 'heightTiles';
+type Entry = { key: Key; value: any; min: Vec3; max: Vec3; order: number };
+type Node = { min: Vec3; max: Vec3; left?: Node; right?: Node; entries?: Entry[] };
+const indexes = new WeakMap<object, Node>();
+const axes = ['x','y','z'] as const;
+export function indexMap(map: MapShapes): void {
+  const entries: Entry[] = [];
+  for (const key of ['boxes','circles','spheres','capsules','heightTiles'] as const) for (const value of map[key] ?? []) {
+    const v:any=value; let min:Vec3,max:Vec3;
+    if(key==='boxes') { min=v.min;max=v.max; }
+    else if(key==='heightTiles') { min={...v.at,z:v.at.z+Math.min(v.base??Infinity,...v.heights)};max={x:v.at.x+v.size.x,y:v.at.y+v.size.y,z:v.at.z+Math.max(...v.heights)}; }
+    else { min={x:v.at.x-v.r,y:v.at.y-v.r,z:key==='circles'?-Infinity:key==='capsules'?v.at.z:v.at.z-v.r};max={x:v.at.x+v.r,y:v.at.y+v.r,z:key==='circles'?Infinity:key==='capsules'?v.at.z+v.height:v.at.z+v.r}; }
+    entries.push({key,value,min,max,order:entries.length});
+  }
+  function build(es:Entry[]):Node {
+    const min={x:Infinity,y:Infinity,z:Infinity},max={x:-Infinity,y:-Infinity,z:-Infinity};
+    for(const e of es)for(const k of axes){min[k]=Math.min(min[k],e.min[k]);max[k]=Math.max(max[k],e.max[k]);}
+    if(es.length<=8)return {min,max,entries:es};
+    // Choose the widest finite axis; unbounded columns still split horizontally.
+    let k: 'x' | 'y' | 'z' = max.x-min.x>=max.y-min.y?'x':'y';
+    if(Number.isFinite(max.z-min.z) && max.z-min.z>max[k]-min[k])k='z';
+    es.sort((a,b)=>(a.min[k]+a.max[k])-(b.min[k]+b.max[k])||a.order-b.order);
+    const mid=es.length>>1;return {min,max,left:build(es.slice(0,mid)),right:build(es.slice(mid))};
+  }
+  indexes.set(map,build(entries));
+}
+/** The segment of a body's reference point against bounds expanded by its extents. */
+export function nearbyMap(map: MapShapes, p:Vec3, d:Vec3, radius:number, height:number, dims=3):MapShapes {
+  const parent=map.staticMap;
+  const root=indexes.get(parent??map);
+  if(!root)return map;
+  const out:any={bounds:map.bounds,boxes:[],circles:[],spheres:[],capsules:[],heightTiles:[]};
+  function touches(n:{min:Vec3;max:Vec3}):boolean {
+    charge(12);let near=0,far=1;
+    for(const k of dims===2?['x','y'] as const:axes){const lo=n.min[k]-(k==='z'?height:radius),hi=n.max[k]+(k==='z'?0:radius);
+      if(d[k]===0){if(p[k]<lo-1e-7||p[k]>hi+1e-7)return false;}
+      else {let a=(lo-p[k])/d[k],b=(hi-p[k])/d[k];if(a>b)[a,b]=[b,a];near=Math.max(near,a);far=Math.min(far,b);if(near>far+1e-7)return false;}
+    }return true;
+  }
+  const found:Entry[]=[];
+  function visit(n:Node){if(!touches(n))return;if(n.entries){for(const e of n.entries)if(touches(e))found.push(e);}else{visit(n.left!);visit(n.right!);}}
+  visit(root);charge(found.length*Math.ceil(Math.log2(found.length+1)));
+  found.sort((a,b)=>a.order-b.order);for(const e of found)out[e.key].push(e.value);
+  if(parent)for(const key of ['boxes','circles','spheres','capsules','heightTiles'] as const)for(const v of map[key]??[]){charge(12);out[key].push(v);}
+  return out;
+}