@homie-rocks/studio 0.39.0 → 0.40.0

package/CHANGELOG.md

@@ -17,6 +17,33 @@ To bring a studio up to date, tell Claude: "Upgrade my studio to the newest Homi
 `npx -y @homie-rocks/studio@latest upgrade`, which shows what's new since the version your studio pins (from this
 file) and what the upgrade would change, and changes nothing until you agree.
 
+## [0.40.0] - 2026-10-09
+
+**Plugin 0.40.0**
+
+New 3D games keep their matches on the server and answer your controls immediately.
+
+### Added
+
+- Rules games can move and face in three dimensions, jump and land, and collide with boxes, spheres, upright capsules and sloped height tiles. Declared level data reaches the server and the browser together and is checked with the game's save and restore.
+- Prediction follows vertical movement and facing, eases corrections, and draws other players' poses and animation state smoothly. The build reports the completed local room-capacity trial separately from its generated game check.
+
+### Changed
+
+- Gem Rush 3D, Hero Rush 3D and Ember Vale now use rules plus view with the server keeping the match, including bots, companions, pickups and combat. Ember Vale keeps its saved hero. All five game starters now use the rules runtime; Ember Vale keeps its two-dimensional play.
+
+### Fixed
+
+- Predicted movement respects the server's floor and ceiling, and catch-up animation follows the pose being drawn.
+- Knockback no longer stores blocked travel and bursts around obstacles. A jump or direction change partway through a tick preserves the current drawn position before advancing.
+- Phone control checks start measuring with the first directional touch movement, so slow browser automation cannot cross the arena before measurement begins.
+- Gem Rush keeps sliding along arena walls under thumb input, and a delayed animation frame cannot give a newly arrived effect a negative radius.
+
+### Upgrade notes
+
+- Existing games keep their source and their hosting choice. The game skill is unchanged; its authoring update is the next slice.
+- Capacity measurements in this release are local. Cloudflare capacity and billing have not been measured.
+
 ## [0.39.0] - 2026-10-09
 
 **Plugin 0.39.0** · [#78](https://github.com/homie-rocks/homie/pull/78)
@@ -48,7 +75,7 @@ Your studio has its own MCP server. Connect your AI with one browser approval an
 
 ## [0.38.0] - 2026-10-09
 
-**Plugin 0.39.0**
+**Plugin 0.39.0** · [#77](https://github.com/homie-rocks/homie/pull/77)
 
 Your own character answers as soon as you press, even when the room runs on the server.
 

package/lib/build.mjs

@@ -544,6 +544,7 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
     if (seats.asked > SEAT_MAX) log(`warning: games/${g.id} asks for ${seats.asked} players; a room holds at most ${SEAT_MAX}, so its rooms have ${SEAT_MAX} seats`);
     built.push({
       id: g.id, name: g.name, mode, bytes, ms: Date.now() - started, warnings, seats: seats.max,
+      ...(rules ? { capacityTrial: rules.check.capacityTrial } : {}),
       ...(bundle ? { bundle } : {}), ...(chunks.length ? { chunks: chunks.length, chunkBytes: later } : {}),
     });
     log(`built ${g.id} (${mode}, ${Math.round(bytes / 1024)} KB${chunks.length ? ` + ${chunks.length} additional ${chunks.length === 1 ? 'chunk' : 'chunks'}, ${Math.max(1, Math.round(later / 1024))} KB` : ''})`);

package/lib/port-check.mjs

@@ -314,10 +314,10 @@ async function focusGame(h) {
 async function holdKey(h, code, ms, ready) { await h.page.keyboard.down(code); if (ready) await ready(); await sleep(ms); await h.page.keyboard.up(code); }
 
 function thumbAt(h, i) { const t = i?.thumb ?? [0.24, 0.74]; return [Math.round(h.vp.width * t[0]), Math.round(h.vp.height * t[1])]; }
-async function touchDrag(h, from, dir, reach, holdMs, ready) {
+async function touchDrag(h, from, dir, reach, holdMs, ready, steps = 8) {
   const [x0, y0] = from; const u = DIRV[dir];
   await h.touch('touchStart', [{ id: 1, x: x0, y: y0 }]);
-  for (let k = 1; k <= 8; k++) { await h.touch('touchMove', [{ id: 1, x: Math.round(x0 + (u[0] * reach * k) / 8), y: Math.round(y0 + (u[1] * reach * k) / 8) }]); await sleep(12); }
+  for (let k = 1; k <= steps; k++) { await h.touch('touchMove', [{ id: 1, x: Math.round(x0 + (u[0] * reach * k) / steps), y: Math.round(y0 + (u[1] * reach * k) / steps) }]); await sleep(12); }
   if (ready) await ready();
   const end = Date.now() + holdMs;
   let w = 0;
@@ -369,7 +369,10 @@ export async function measuredPress(h, how, code, from, dir) {
     b = await frameNow(h);
   };
   if (how === 'keys') await holdKey(h, code, 0, ready);
-  else await touchDrag(h, from, dir, 70, 0, ready);
+  // One real move establishes the measured direction. An eight-event ramp can
+  // take seconds on software Chrome and drive all the way into a wall before
+  // its final-point receipt starts the measurement. Holds still exercise ramps.
+  else await touchDrag(h, from, dir, 70, 0, ready, 1);
   return { dir, a, b };
 }
 

package/lib/rules-build.mjs

@@ -33,6 +33,10 @@ import { typecheckRules } from './typecheck.mjs';
 export { isRulesGame };
 export { stateHash } from './rules-check.mjs';
 
+// A reference workload, not a promise about every game's rules or a Cloudflare measurement.
+// Receipt and method: docs/rooms-slice-7-notes.md, "Budget measurements".
+export const RULES_CAPACITY_TRIAL = Object.freeze({ game: 'hero-rush-3d', seats: 32, tickHz: 30, minutes: 20, host: 'Node', platform: 'macOS arm64', cloudflare: false });
+
 const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
 const RULES_FILES = { [RULES_MODULE]: 'rules.ts', [GUARD_MODULE]: 'guard.ts', [`${RULES_MODULE}/view`]: 'view.ts', [`${RULES_MODULE}/host`]: 'host.ts' };
 
@@ -150,6 +154,9 @@ export async function prepareRules(esbuild, root, g, { log = () => {}, longCheck
   for (const p of checked.problems) log(`warning: games/${g.id}/game.json: ${p}`);
   for (const line of checked.information) log(`info: ${line}`);
   const { settings, schema, publicTune, rounds, stateHash } = checked;
+  const trial = RULES_CAPACITY_TRIAL;
+  log(`info: rules runtime reference trial: ${trial.game}, ${trial.seats} players at ${trial.tickHz} Hz for ${trial.minutes} minutes on ${trial.host} (${trial.platform}). Cloudflare capacity and billing are unmeasured.`);
+  if (settings.tickHz > trial.tickHz) log(`info: games/${g.id} asks for ${settings.tickHz} Hz, above the completed local reference trial's ${trial.tickHz} Hz. This game's generated check does not establish live room capacity.`);
   const { def, R, H } = await loadRules(esbuild, root, g.id, guarded.code);
   const compiled = R.compileRules(def, { tune, map: R.compileMap(map, map.name), settings, seats });
   const stats = smokeRun(H, compiled, g.id, { timer: () => 0, vocab: data.vocab });
@@ -171,7 +178,7 @@ export async function prepareRules(esbuild, root, g, { log = () => {}, longCheck
     build: createHash('sha256').update(guarded.code).update(JSON.stringify(built)).digest('hex'),
     snapshotCap, checkpointCap, snapshotBytes: stats.snapshotBytes, checkpointBytes: stats.checkpointBytes,
     units: checked.maxUnits, tickUnits: checked.maxTickUnits,
-    check: { information: checked.information, plays: checked.plays, ticks: checked.ticks, rounds: checked.roundsPlayed, restores: checked.restores, units: checked.units, largestSaveBytes: checked.largestSaveBytes },
+    check: { information: checked.information, capacityTrial: trial, plays: checked.plays, ticks: checked.ticks, rounds: checked.roundsPlayed, restores: checked.restores, units: checked.units, largestSaveBytes: checked.largestSaveBytes },
   };
 }
 

package/lib/rules-check-worker.mjs

@@ -236,7 +236,7 @@ function play(c, companions, allow) {
   const ends = (fd) => (fd.t === 'bit' || fd.t === 'press' ? [false, true] : fd.t === 'fix' ? [-1, 1] : [L.P.coerce(fd, -Infinity, c.dims), L.P.coerce(fd, Infinity, c.dims)]);
   const steering = new Map();
   let moveTick = 0;
-  const moveCtx = new Map(c.kinds.filter((k) => k.move && k.body).map((k) => [k.name, L.M.moveContext({ tick: () => moveTick, tickHz, tune: c.publicTune, map: c.map, name: c.map.name, spots: c.map.spots, radius: () => k.body.radius, dims: c.dims })]));
+  const moveCtx = new Map(c.kinds.filter((k) => k.move && k.body).map((k) => [k.name, L.M.moveContext({ tick: () => moveTick, tickHz, tune: c.publicTune, map: c.map, name: c.map.name, spots: c.map.spots, radius: () => k.body.radius, shape: () => k.body, dims: c.dims })]));
   /**
    * An owner-moved body's own browser, for one tick: the game's `move` from where the last snapshot has the body, by
    * the step a browser takes (pack.ts `stepMove`), and the claim of where that leaves it. Its units are the play's.
@@ -350,8 +350,8 @@ function play(c, companions, allow) {
       const result = L.P.stepMove(kind.move, before, input, moveCtx.get(name), Math.max(1, Math.floor(budget / 4)), kind.motion, c.dims,
         error => { fault ??= `${siteOf(name, 'move')} ${name}.move: prediction failed: ${error.message}.${when()}`; });
       units += result.used;
-      const r = kind.body.radius, bounds = c.map.bounds;
-      result.pos = L.P.vec3({ x: Math.max(bounds.min.x + r, Math.min(bounds.max.x - r, result.pos.x)), y: Math.max(bounds.min.y + r, Math.min(bounds.max.y - r, result.pos.y)), z: result.pos.z }, c.dims);
+      const r = kind.body.radius, height = kind.body.height || 2 * r, bounds = c.map.bounds;
+      result.pos = L.P.vec3({ x: Math.max(bounds.min.x + r, Math.min(bounds.max.x - r, result.pos.x)), y: Math.max(bounds.min.y + r, Math.min(bounds.max.y - r, result.pos.y)), z: c.dims === 3 ? Math.max(bounds.min.z, Math.min(bounds.max.z - height, result.pos.z)) : 0 }, c.dims);
       delete result.used;
       if (JSON.stringify(result) !== JSON.stringify(after)) fault ??= `${siteOf(name, 'move')} ${name}.move: prediction and the server produced different bodies from the same input.${when()}`;
     }

package/lib/rules-check.mjs

@@ -28,7 +28,9 @@ export const LONG_ALLOWANCE = Object.freeze({ ...ALLOWANCE, ticks: 8 * ALLOWANCE
 
 /** The ordered declarations a save depends on. Functions contribute their presence, never their implementation. */
 export function stateHash(c) {
-  const { kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map, dims, contract, seats, save } = c;
+  const { kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map: geometry, dims, contract, seats, save } = c;
+  // Keep existing 2D save compatibility hashes when the 3D map vocabulary grows.
+  const map = dims === 2 ? { name: geometry.name, bounds: geometry.bounds, boxes: geometry.boxes, circles: geometry.circles, spots: geometry.spots } : geometry;
   return createHash('sha256').update(JSON.stringify({ kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map, dims, contract, seats, tickHz: c.settings.tickHz, save }, (k, v) => typeof v === 'function' ? true : v)).digest('hex').slice(0, 32);
 }
 

package/lib/template-history.json

@@ -2197,6 +2197,47 @@
      }
     }
    }
+  },
+  "0.40.0": {
+   "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",
+     "## Layout": "c18362ed28975d81",
+     "## Apps: one screen, roles and parts": "be6f8fa45f93211a",
+     "## Commands (all through the pinned CLI in node_modules)": "a7f290579585368c",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "2da7fa74c8884834",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "98d08705087a33ec",
+     "## 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)": "7cad8fd10f62fef1"
+      }
+     }
+    }
+   }
   }
  }
 }

package/netplay/NETPLAY.md

@@ -2163,8 +2163,13 @@ Small errors fade as a visual offset with a nominal 100 ms blend. Overlapping sm
 queue their individual fades, so their accumulated offset is not erased all at once. A disagreement
 beyond three ticks of travel plays the corrected path from the snapshot at 1.25 times speed,
 showing the hold and slide of a knock. Offset fades are limited by progress along the drawn
-path and the body's declared maximum movement speed, so a late-input correction cannot erase more travel than the player makes or compound a fast knock's catch-up speed. Catch-up preserves the drawn pose when a snapshot replaces its history, and uses the next movement preview when its next whole-tick history entry is not yet available. When movement
-stops after catch-up, the remaining fade follows the configured blend time, still bounded by that speed. An effect on the body waits for its drawn tick. Placements, epoch changes and clock rebases
+path and by normal movement speed, so a late-input correction cannot erase more travel than
+the player makes or amplify a fast knockback. When movement stops after catch-up, the remaining
+fade uses the configured blend time with the same speed limit; large offsets can take longer.
+Catch-up preserves the drawn pose when a snapshot replaces its history and uses the next
+movement preview when its next whole-tick history entry is not yet available.
+The fade's speed limit has a 1 m/s floor so even a body with zero declared running speed can
+finish a vertical correction. An effect on the body waits for its drawn tick. Placements, epoch changes and clock rebases
 jump deliberately. Other bodies keep the helper's adaptive interpolation, with one send period
 as the default minimum delay. The `room.predict` settings customize these defaults.
 
@@ -2390,3 +2395,70 @@ A missing offline module leaves the connection helper alive and says the game ne
 connection. A failed offline runtime stops locally while reconnection continues. An online
 runtime failure ends the room. Snapshots never grow above 16,384 bytes, including above
 sixteen seats.
+
+### 29.8 Three dimensions, level data and animation
+
+All five shipped starters are rules games with `room.host: 'server'`. Existing games
+made with `port` keep their version 1 callbacks and browser hosting. Ember Vale keeps
+its cloud character saves; the room save holds the shared fight and companion state.
+
+A rules declaration with `space: { dims: 3 }` uses metres and seconds, with **z up**.
+`pos` is the body's feet, `vel` has three components, `heading` is a unit direction,
+and `grounded` says a supporting collision has an upward normal greater than 0.5.
+The guarded `move` gets these values and declared `motion`, input, public tuning,
+`ctx.dt`, deterministic maths and `ctx.map.sweep`. The host and prediction run the
+same function. Gravity, jump impulse, acceleration and facing are game decisions,
+not a second physics loop in the view. Camera-relative controls are converted to
+world-space input in the view before calling `room.input`.
+
+Bodies may be upright capsules (`radius`, full `height`), spheres (`radius`), or
+axis-aligned boxes (`radius` is horizontal half-width, `height` is full height).
+Sweeps are continuous: a fast body cannot skip a thin solid. `ctx.map.sweep` moves
+against the static map and returns its contact normal; a second sweep along that
+normal's tangent slides. `world.sweep` also considers entity bodies and accepts
+`ignore` ids. `world.ray`, `near`, `inBox` and areas consider height in a 3D game.
+A placement is a discontinuity, with a new spawn revision, rather than a sweep.
+
+The game's declared map directory contains `main.json`. Static data is compiled
+into both the host and view and included in the state compatibility hash. It is
+not copied into each room save. Changing geometry makes old room state incompatible,
+just as changing a field does. Named `spots` provide spawn points and other fixed
+positions. A map has finite, increasing `bounds.min`/`max` vectors and at most 4,096
+solid shapes across these lists:
+
+| List | Declaration | Meaning in 3D |
+|---|---|---|
+| `boxes` | `{ min: [x,y,z], max: [x,y,z] }` | Axis-aligned solid |
+| `circles` | `{ at: [x,y,z], r }` | Vertical column through the map, for arena obstacles |
+| `spheres` | `{ at: [x,y,z], r }` | Centre and radius |
+| `capsules` | `{ at: [x,y,z], r, height }` | Feet, radius, full upright height (at least twice the radius) |
+| `heightTiles` | `{ at: [x,y,z], size: [width,depth], heights: [h00,h10,h01,h11] }` | Relative corner heights, split on the 00–11 diagonal |
+
+Height tiles support the foot point, with open edges and no underside. They are
+terrain, not a triangle-mesh collider or a solid platform; use boxes for platforms
+and ceilings. Every tile, solid and bounded convex-cast iteration is charged to
+the handler budget. The build check uses the same map and body shape as the host
+and predictor, measures full-room steps, and restores the complete declared state.
+The two meadow starters' playable ground is flat; their rolling scenery is visual.
+
+The view interpolates remote three-axis position and velocity, and takes the shortest
+arc between unit headings, including half turns. Discrete animation fields stay at
+the earlier snapshot until their tick. Takeoff becomes airborne as the interpolated
+pose rises; landing waits for contact. Own-body reconciliation eases all three axes
+and heading. A renderer reads `room.me`/`room.each`, maps rules `(x,y,z)` to its
+renderer axes, and feeds those poses and grounded/vertical-speed values to animation.
+Effects such as strikes and hits still come from the authoritative room.
+
+Rules can read `world.kids` and `world.levelSet` (an explicitly set party dial).
+`world.level` is the party's skill dial; `world.guideLevel` is the server's own level
+for guides. `world.guideSeats` is the frozen list of guide seats, assigned by the
+host from admitted agents and reserved seats; party companions use `world.level`.
+These policy values survive saves without changing older saves' defaults.
+
+A view may opt into `openRoom({ fallback: 'solo' })` when its room allows offline
+play. After four active seconds without a body in a connected room, it plays a
+private rules round while the original connection keeps waiting for a seat. The
+private round imports no room save, match score or simulation state into the online
+room. When a body is assigned, the private round closes and the view joins the
+online match. Ember Vale retains its separate cloud hero: experience earned in
+solo play still belongs to that hero, whose level is sent through the usual command.

package/package.json

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

package/rules/collision.ts

@@ -0,0 +1,115 @@
+/** 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.
+ */
+import { charge } from './guard.ts';
+import type { Vec3, MapBox, MapCircle, MapHeightTile } from './rules.ts';
+
+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 {
+  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 });
+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 };
+  return { min: point(at.x, at.y, at.z + r), max: point(at.x, at.y, at.z + (body.shape === 'sphere' ? r : height - r)), r };
+}
+/** Closest vector between the cores of two rounded boxes. At most one core has
+ * horizontal extent, except box/box, so this represents all supported pairs exactly.
+ */
+function separation(a: Solid, b: Solid, d: Vec3, t: number): Vec3 {
+  const gap = (lo: number, hi: number, min: number, max: number): number => lo > max ? lo - max : hi < min ? hi - min : 0;
+  return point(gap(a.min.x + d.x * t, a.max.x + d.x * t, b.min.x, b.max.x), gap(a.min.y + d.y * t, a.max.y + d.y * t, b.min.y, b.max.y), gap(a.min.z + d.z * t, a.max.z + d.z * t, b.min.z, b.max.z));
+}
+/** Continuous convex cast: each separating plane gives a lower bound on impact.
+ * Every iteration is charged, and a fixed cap bounds grazing contacts as well.
+ */
+export function castSolid(a: Solid, d: Vec3, b: Solid): Hit3 | null {
+  charge(30);
+  let t = 0;
+  const r = a.r + b.r;
+  let normal = point(0, 0, 0);
+  // Sharp boxes need the slab test: their closest vector vanishes at a face.
+  if (r === 0) {
+    let enter = 0, leave = 1;
+    for (const axis of ['x', 'y', 'z'] as const) {
+      const lo = b.min[axis] - a.max[axis], hi = b.max[axis] - a.min[axis], v = d[axis];
+      if (v === 0) { if (lo >= 0 || hi <= 0) return null; continue; }
+      const near = (v > 0 ? lo : hi) / v, far = (v > 0 ? hi : lo) / v;
+      if (near >= enter) { enter = near; normal = point(0, 0, 0); normal[axis] = v > 0 ? -1 : 1; }
+      leave = Math.min(leave, far);
+      if (enter > leave) return null;
+    }
+    return enter >= 0 && enter <= 1 && normal.x + normal.y + normal.z !== 0 ? { t: enter, nx: normal.x, ny: normal.y, nz: normal.z } : null;
+  }
+  for (let i = 0; i < 32; i++) {
+    charge(24);
+    const s = separation(a, b, d, t), length = Math.sqrt(s.x * s.x + s.y * s.y + s.z * s.z);
+    const distance = length - r;
+    // Let an initially overlapping body escape. Placements are not collision moves.
+    if (i === 0 && distance < -EPS) return null;
+    if (length > 0) normal = point(s.x / length, s.y / length, s.z / length);
+    const approach = -(normal.x * d.x + normal.y * d.y + normal.z * d.z);
+    if (approach <= EPS) return null;
+    if (distance <= EPS) return { t, nx: normal.x, ny: normal.y, nz: normal.z };
+    t += distance / approach;
+    if (t > 1) return null;
+  }
+  // At the iteration cap, stop conservatively on the separating plane.
+  return { t, nx: normal.x, ny: normal.y, nz: normal.z };
+}
+/** Height tiles support a body's foot point. Each tile is split along its
+ * 00–11 diagonal; unlike bilinear sampling each half has a constant slope and
+ * the sweep has an exact intersection. Borders are open, so a body can walk off.
+ */
+function castHeightTile(tile: MapHeightTile, p: Vec3, d: Vec3): Hit3 | null {
+  charge(80);
+  const [h00, h10, h01, h11] = tile.heights, sx = tile.size.x, sy = tile.size.y;
+  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 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 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;
+    const length = Math.sqrt(gx * gx + gy * gy + 1);
+    best = { t, nx: -gx / length, ny: -gy / length, nz: 1 / length };
+  }
+  return best;
+}
+
+export function castMap3(map: Map3, p: Vec3, d: Vec3, body: BodyShape): Hit3 | null {
+  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; };
+  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);
+    if (d[axis] === 0) continue;
+    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 }));
+  // 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 })));
+  return best;
+}
+export function restsOnMap(map: Map3, p: Vec3, body: BodyShape): boolean {
+  const h = castMap3(map, p, point(0, 0, -0.002), body);
+  return Boolean(h && h.nz > 0.5);
+}