@homie-rocks/studio 0.39.0 → 0.42.0

package/lib/template-history.json

@@ -2197,6 +2197,91 @@
      }
     }
    }
+  },
+  "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"
+      }
+     }
+    }
+   }
+  },
+  "0.42.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": [
+      "8596f2b25edda3e2",
+      "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/lib/tools-build.mjs

@@ -38,6 +38,7 @@ export async function buildTools(root,esbuild) {
     if(!['owner','signed-in','public'].includes(t.audience)&&!(t.audience&&typeof t.audience.app==='string'&&typeof t.audience.role==='string'))throw new Error(`tool ${t.name} needs an audience`);
     if(t.inputSchema?.type!=='object')throw new Error(`tool ${t.name} input schema must be an object`);
     validator.getValidator(t.inputSchema);
+    if(t.price && (t.kind==='prompt'||!Number.isSafeInteger(t.price.amount)||t.price.amount<=0||! /^[a-z]{3}$/.test(t.price.currency)))throw new Error(`tool ${t.name}: price needs a positive minor-unit amount and currency`);
     if(t.kind!==undefined&&!['tool','prompt'].includes(t.kind))throw new Error(`tool ${t.name}: invalid kind`);
     if(t.webhook&&(!/^[A-Z][A-Z0-9_]{0,63}$/.test(t.webhook.secret)||typeof t.webhook.person!=='string'||!t.webhook.person))throw new Error(`tool ${t.name}: webhook needs a named secret and account`);
     for(const [name,event] of Object.entries(t.events??{})){
@@ -51,5 +52,6 @@ export async function buildTools(root,esbuild) {
     let text=readFileSync(worker,'utf8');
     if(!text.includes('useTools(')){text += "\nimport { useTools } from '@homie-rocks/studio/worker';\nuseTools(async () => (await import('./tools/index.mjs')).default);\n";writeFileSync(worker,text);}
   }
+  writeFileSync(join(dir,'declarations.json'),JSON.stringify({paid:defs.some(t=>t.price)})+'\n');
   return defs.map(t=>t.name);
 }

package/lib/upgrade.mjs

@@ -1,3 +1,4 @@
+import {refreshWorkerConfig} from './worker-config.mjs';
 /**
  * `homie-studio upgrade [--apply] [--diff]` — an existing studio takes what this version's template adds, and
  * nothing it made its own is ever overwritten.
@@ -346,6 +347,7 @@ export function upgradeApply(root, plan) {
     }
     if (text !== null && (!existsSync(path) || readFileSync(path, 'utf8') !== text)) writeAtomic(path, text);
   }
+  refreshWorkerConfig(root);
   const pinned = done.some((c) => c.kind === 'pin');
   return {
     ...plan, applied: true, done, skipped,

package/lib/worker-build.mjs

@@ -1,34 +1,22 @@
-import {existsSync,mkdirSync,readFileSync,writeFileSync,rmSync} from 'node:fs';
-import {join,relative,dirname} from 'node:path';
+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 {readConfig} from './routes.mjs';
 import {paidReleases} from './parts-upload.mjs';
-import {configPath} from './studio.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??{})};
-  if(paidReleases(root).length)alias['@homie-rocks/studio/worker']='@homie-rocks/studio/worker/selling';
+  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});
   mkdirSync(out,{recursive:true});
   for(const file of result.outputFiles)writeFileSync(file.path,file.contents);
-  const config=configPath(root);
-  if(existsSync(config)){
-    const original=readFileSync(config,'utf8');
-    const json=JSON.parse(original.replace(/^\s*\/\/.*$/gm,''));
-    const before=JSON.stringify(json);
-    json.main=relative(dirname(config),join(out,'worker.js')).split('\\').join('/');
-    json.no_bundle=true;json.find_additional_modules=true;
-    json.rules=[...(json.rules??[]).filter(r=>!r.homieMcp),{type:'ESModule',globs:['**/*.js'],fallthrough:true}];
-    // No duplicate rule on rebuild.
-    json.rules=json.rules.filter((r,i,all)=>all.findIndex(x=>JSON.stringify(x)===JSON.stringify(r))===i);
-    json.compatibility_flags=[...new Set([...(json.compatibility_flags??[]),'nodejs_compat'])];
-    if(JSON.stringify(json)!==before) {
-      const comments=original.match(/^(?:\s*\/\/[^\n]*\n)*/)?.[0]??'';
-      writeFileSync(config,comments+JSON.stringify(json,null,2)+'\n');
-    }
-  }
   const sizes=Object.entries(result.metafile.outputs).map(([path,value])=>({path:relative(root,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

@@ -0,0 +1,28 @@
+import {readFileSync,writeFileSync,existsSync} from 'node:fs';
+import {join} from 'node:path';
+import {configPath,readStudio,layoutOf,listExperiences} from './studio.mjs';
+import {wranglerConfig} from './scaffold.mjs';
+import {paidReleases} from './parts-upload.mjs';
+const parse=t=>JSON.parse(t.replace(/^\s*\/\/.*$/gm,''));
+const read=file=>existsSync(file)?parse(readFileSync(file,'utf8')):{};
+function merge(base,custom) {
+  if(Array.isArray(custom))return custom;
+  if(custom && typeof custom==='object')return Object.fromEntries([...new Set([...Object.keys(base??{}),...Object.keys(custom)])].sort().map(k=>[k,k in custom?merge(base?.[k],custom[k]):base[k]]));
+  return custom;
+}
+/** Generated output is never an input. Studio additions belong in wrangler.custom.json. */
+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);
+}
+export function refreshWorkerConfig(root,overrides={}) {
+  const studio=readStudio(root),cf=studio.cloudflare;
+  if(!cf?.worker)return;
+  const metadata=read(join(root,'site/src/functions/declarations.json'));
+  const functions=Array.isArray(metadata)?metadata:[];
+  const tools=read(join(root,'site/src/tools/declarations.json'));
+  const ai=cf.ai??listExperiences(root).some(g=>g.decide===true || g.chat!==false && (g.chat?.mode??'text')==='text' && g.chat?.ai!==false);
+  const paid=paidReleases(root).length>0||existsSync(join(root,'shop.json'))||tools.paid===true;
+  updateWorkerConfig(root,wranglerConfig({worker:cf.worker,name:studio.name,d1:cf.d1,d1Id:cf.d1Id,r2:cf.r2,layout:layoutOf(root),ai,paidParts:paid,partsRateLimit:cf.purchaseRateLimit??null,routes:cf.routes??null,triggers:functions.length?{crons:[...new Set(['* * * * *',...functions.map(f=>f.schedule).filter(Boolean)])].sort()}:null,...overrides}));
+}

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.42.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",
@@ -88,6 +88,10 @@
     "./tools": {
       "types": "./tools/tools.ts",
       "default": "./tools/tools.ts"
+    },
+    "./functions": {
+      "types": "./functions/functions.ts",
+      "default": "./functions/functions.ts"
     }
   },
   "files": [
@@ -116,7 +120,8 @@
     "links/",
     "apps/",
     "app-starters/",
-    "tools/"
+    "tools/",
+    "functions/"
   ],
   "engines": {
     "node": ">=22"

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);
+}