@homie-rocks/studio 0.44.1 → 0.44.3

package/CHANGELOG.md

@@ -17,6 +17,26 @@ 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.44.3] - 2026-10-10
+
+**Plugin 0.44.3**
+
+Solid terrain and indexed map queries keep large arenas within the rules budget.
+
+### Added
+
+- Solid triangulated height tiles: explicit bases and source diagonals preserve ramp sides, roofs and underpasses across movement, support, overlap and rays.
+- Build-time spatial indexing for up to 100,000 static shapes, with query work charged by visited geometry on authority and prediction.
+
+### Fixed
+
+- Terrain-heavy rules maps spawn and move within the default tick budget, including Stormbreak's losslessly prepared 4,058 shapes.
+- Build and deployment retain the same committed Wrangler config while local rebuilds and deployment select complete immutable Worker generations.
+
+### Upgrade notes
+
+- Height tiles remain open surfaces unless `base` is declared. Solid tiles collide against the whole body, so capsule clearance on a slope differs from the old foot-point surface.
+
 ## [0.44.1] - 2026-10-10
 
 **Plugin 0.44.1**

package/guides/game/REWRITE.md

@@ -76,3 +76,19 @@ for existing movement code. Keep build/damage/door logic in entity handlers.
 Never copy collision lists into player motion or implement a second replay loop.
 Test visible prediction at 300 ms with loss, rejoin and saved-room restore.
 The installed toolkit's `guides/game/` is the version-matched source for this guide.
+
+
+### Solid terrain and query cost
+
+Preserve each source height triangle and its diagonal. Declare height tiles with
+`base` for solid ramps, terraces, roofs and underpasses; omitting it deliberately
+means an open top surface. Do not replace slopes with boxes, invisible walls or
+coarser sampling. Test both sides, tall end, ascent/descent, jump, dash, underside,
+step head clearance, overlap and weapon/camera/blast rays. A discrete reference
+mover may stop one input increment before the continuous capsule contact; report
+both numbers instead of changing its body radius to make them match.
+
+Map compilation indexes up to 100,000 shapes. Measure the default-budget guarded
+spawn, six initial bodies/eight seats and traversal/combat with live cover. Repeat
+on seeded virtual time with 300 ms/loss, rejoin and saved-room restore, then smoke
+test real browser sockets. Geometry passing alone does not complete a game rewrite.

package/guides/game/RULES.md

@@ -71,7 +71,7 @@ With `space: { dims: 3 }`, z is up and pos is the body's feet. Three.js renders
 Use continuous sweeps, then slide the remainder along the contact tangent.
 `world.sweep` includes entity bodies. Movement sees the map plus declared live colliders through `ctx.world` (also exposed on `ctx.map`).
 
-| Map list (at most 4,096 solids in all) | JSON shape |
+| Map list (at most 100,000 shapes in all) | JSON shape |
 | --- | --- |
 | boxes | `{ "min": [0,0,0], "max": [2,2,1] }` |
 | circles (vertical columns in 3D) | `{ "at": [4,0,0], "r": 1 }` |
@@ -79,8 +79,25 @@ Use continuous sweeps, then slide the remainder along the contact tangent.
 | capsules | `{ "at": [0,0,0], "r": 0.5, "height": 2 }` |
 | heightTiles | `{ "at": [0,0,0], "size": [2,2], "heights": [0,1,0,1] }` |
 
-Height tiles support the foot point, have open edges and no underside; use boxes
-for platforms and ceilings. A rendered mesh is not a collider. Draw solid geometry
+Height tiles without `base` retain their open, foot-point top surface. Add `base`
+(a height offset from `at.z`, at or below all four samples) for a closed solid:
+vertical sides, the sampled top and a flat underside. For example the relay ramp
+is `{ "at": [-2.5,5,0], "size": [5,12], "heights": [4,4,0,0], "base": 0 }`.
+Raise `at.z` or `base` for roofs and underpasses. `diagonal` defaults to `"00-11"`;
+`"10-01"` preserves meshes split the other way. Row order is 00,10,01,11.
+Noncoplanar cells are two triangular prisms, never a convex hull or bilinear patch.
+Solid tiles use the whole declared body for sweeps, support and overlap; rays hit
+sides and undersides as well as tops. Capsules sit above slopes by their rounded
+foot's clearance, rather than embedding their lower sphere in a foot-point surface.
+
+`compileMap` builds an immutable spatial index, shared in meaning by authority and
+prediction. Queries charge visited bounds and actual geometry tests, not every
+shape in the map; live colliders remain a separate overlay. A 100,000-shape map is
+supported without decimation or a larger tick budget. Dense local geometry still
+costs work. Walk slopes by projecting the remaining sweep onto a walkable contact
+normal. For a step, sweep upward for head clearance, sweep across, then support
+and sweep down; never teleport upward through a ceiling. Keep jump and snap-down
+limits in the shared move function. A rendered mesh is not a collider. Draw solid geometry
 from room.map, including spheres/capsules/heightTiles. Changing the map changes
 state compatibility; it is static build data, not a per-room saved copy.
 

package/guides/game/SKILL.md

@@ -8,7 +8,9 @@ metadata:
 
 Read the installed toolkit's `node_modules/@homie-rocks/studio/guides/game/{RULES,REWRITE}.md`
 before authoring: these match its runtime even when this plugin is older. Toolkit
-check/build report stale installed plugin copies and the update step. For live
+check/build report stale installed plugin copies and the update step. For solid slopes and terrain, use heightTiles with `base` and the source
+`diagonal`; test sides, underside, step clearance and rays. Maps are indexed at
+compile time up to 100,000 shapes; measure default-budget spawn and traversal. For live
 cover, doors and platforms, use declared entity `collider` state and movement's
 `ctx.world.sweep/support/overlaps`; test prediction, loss, rejoin and restore.
 

package/lib/cloudflare.mjs

@@ -1,3 +1,4 @@
+import {workerEntry} from './worker-build.mjs';
 import { refreshWorkerConfig } from './worker-config.mjs';
 import { paidReleases, uploadPaidParts } from './parts-upload.mjs';
 /**
@@ -381,14 +382,14 @@ async function deployLocked(root, { log = () => {}, homie, fetchFn = null, ownRo
   if(subscriptions.code!==0)return refuse('Could not register studio functions',subscriptions.out);
 
   const started = Date.now();
-  let dep = w(['deploy', ...repoVar(root)]);
+  let dep = w(['deploy', ...(workerEntry(root) ? [workerEntry(root)] : []), ...repoVar(root)]);
   if (dep.code !== 0 && explainCloudflare(dep.out, accountId)?.needs === 'workers-dev-subdomain') {
     const headers = await cloudflareAuth({ env: { ...process.env, ...projectsCloudflareEnv(root) }, bin: wranglerBin(root), cwd: root,
       exec: async (_bin, args) => { const r = w(args, { cwd: root }); return { code: r.code, stdout: r.stdout }; } });
     const address = await registerWorkersAddress({ accountId, slug: studio.slug, headers, ...(fetchFn ? { fetchFn } : {}) });
     if (!address.ok) return { ok: false, command: 'deploy', needs: 'workers-dev-subdomain', why: address.next };
     step(address.created ? 'registered the account’s workers.dev address automatically' : 'kept the account’s existing workers.dev address');
-    dep = w(['deploy', ...repoVar(root)]);
+    dep = w(['deploy', ...(workerEntry(root) ? [workerEntry(root)] : []), ...repoVar(root)]);
   }
   if (dep.code !== 0) return refuse(`wrangler deploy failed: ${dep.out.trim().split('\n').slice(-6).join(' ')}`, dep.out);
   if (paidReleases(root).length) {
@@ -607,7 +608,7 @@ export async function ciDeploy(root, { log = () => {} } = {}) {
     } catch { step('could not add the Workers AI binding to wrangler.jsonc: the guides answer from the game\'s script'); }
   }
   const started = Date.now();
-  const dep = w(['deploy', ...repoVar(root)]);
+  const dep = w(['deploy', ...(workerEntry(root) ? [workerEntry(root)] : []), ...repoVar(root)]);
   if (dep.code !== 0) return refuse(`wrangler deploy failed: ${dep.out.trim().split('\n').slice(-6).join(' ')}`, dep.out);
   step(`deployed ${names.worker ?? 'the Worker'} in ${Math.round((Date.now() - started) / 1000)} s`);
   const repo = repoOf(root);

package/lib/dev.mjs

@@ -1,3 +1,4 @@
+import {workerEntry} from './worker-build.mjs';
 import { networkInterfaces } from 'node:os';
 /**
  * `homie-studio dev` and `dev --stop`: the whole site on this computer (pages, rooms in a local Durable Object, D1),
@@ -194,10 +195,11 @@ export function devConfig(root, remoteAi) {
   const stripped = routesOf(json).map((r) => r.pattern);
   const routed = ROUTE_KEYS.some((k) => k in json);
   const aiNote = remoteAi ? 'AI guides think with Workers AI (remote, billed to the signed-in account).' : null;
-  if (Boolean(json.ai) === remoteAi && !routed) return { args: [], note: aiNote, stripped: [] };
+  const entry=workerEntry(root);
+  if (!entry && Boolean(json.ai) === remoteAi && !routed) return { args: [], note: aiNote, stripped: [] };
   const abs = (p) => (p && !p.startsWith('/') ? join(base, p) : p);
   delete json.$schema;
-  json.main = abs(json.main);
+  json.main = entry ?? abs(json.main);
   if (json.assets?.directory) json.assets.directory = abs(json.assets.directory);
   json.d1_databases = (json.d1_databases ?? []).map((d) => ({ ...d, ...(d.migrations_dir ? { migrations_dir: abs(d.migrations_dir) } : {}) }));
   for (const k of ROUTE_KEYS) delete json[k];

package/lib/template-history.json

@@ -2468,6 +2468,48 @@
      }
     }
    }
+  },
+  "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

@@ -2,7 +2,7 @@ import {createHash} from 'node:crypto';
 import {refreshWorkerConfig} from './worker-config.mjs';
 import {pathToFileURL} from 'node:url';
 import {existsSync,mkdirSync,writeFileSync,renameSync,readFileSync,mkdtempSync,rmSync} from 'node:fs';
-import {join,relative,basename,sep} from 'node:path';
+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';
@@ -38,7 +38,9 @@ export async function buildWorker(root,esbuild) {
   }
   // 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'))});
+  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');
@@ -54,3 +56,12 @@ export async function buildWorker(root,esbuild) {
   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/package.json

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

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,6 +10,7 @@ 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[];
@@ -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,6 +95,7 @@ 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;
@@ -101,7 +107,7 @@ 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 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 }), (c as any).id);

package/rules/core.ts

@@ -245,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);
@@ -611,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 };
@@ -633,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.
@@ -1007,7 +1006,7 @@ 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]); }
+      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;

package/rules/live.ts

@@ -1,3 +1,5 @@
+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';
@@ -27,7 +29,7 @@ export function castCollider2(row: ColliderRow, p: Vec3, d: Vec3, radius: number
 }
 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 ?? [])];
+  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);
@@ -35,7 +37,7 @@ export function collisionMap(map: MapShapes, rows: readonly ColliderRow[]): MapS
     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 };
+  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. */
@@ -60,14 +62,14 @@ export function collisionQueries(map: () => MapShapes, shape: () => BodyShape, d
       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);
+      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.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 })));
+      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;
+}

package/rules/math.ts

@@ -1,3 +1,4 @@
+import { nearbyMap } from './map-index.ts';
 import { collisionQueries } from './live.ts';
 /*
  * math.ts — `world.math` and `ctx.math`: the maths rules may not take from `Math`, in plain arithmetic.
@@ -183,7 +184,7 @@ export const exact = Object.freeze({ sin, cos, atan, atan2, exp, log, pow });
 /* ------------------------------------------------------------------ the ground plane: a point or a circle against the map */
 
 /** The shapes of a map the sweep reads (rules.ts `GameMap` has them). */
-export interface MapShapes { bounds: { min: Vec3; max: Vec3 }; boxes: readonly { min: Vec3; max: Vec3 }[]; circles: readonly { at: Vec3; r: number }[]; spheres?: readonly { at: Vec3; r: number }[]; capsules?: readonly { at: Vec3; r: number; height: number }[]; heightTiles?: readonly import('./rules.ts').MapHeightTile[] }
+export interface MapShapes { staticMap?: MapShapes; bounds: { min: Vec3; max: Vec3 }; boxes: readonly { min: Vec3; max: Vec3 }[]; circles: readonly { at: Vec3; r: number }[]; spheres?: readonly { at: Vec3; r: number }[]; capsules?: readonly { at: Vec3; r: number; height: number }[]; heightTiles?: readonly import('./rules.ts').MapHeightTile[] }
 /** How close a swept body stops to what it hit, in metres. */
 export const SKIN = 0.001;
 
@@ -237,6 +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 } {
+  map = nearbyMap(map, {x:px,y:py,z:0}, {x:dx,y:dy,z:0}, r, 0, 2);
+  charge(16 + 4 * (map.boxes.length + map.circles.length));
   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, 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 }; }
@@ -250,7 +253,7 @@ export function castMap(map: MapShapes, px: number, py: number, dx: number, dy:
  */
 export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius: number, dims: number, shape: BodyShape = { shape: 'sphere', radius, height: 2 * radius }): unknown {
   // Charged before the cast, for every shape of the map it may test.
-  charge(20 + 4 * (4 + map.boxes.length + map.circles.length));
+  charge(20);
   const fr = Math.fround;
   // Both are whatever `move` handed over: each is read as a plain number or as nothing, and nothing is called to convert it.
   const num = (a: unknown): number => { const x = typeof a === 'number' ? fr(a) : 0; return Number.isFinite(x) ? x : 0; };

package/rules/rules.ts

@@ -1,3 +1,5 @@
+import { prepareTile } from './terrain.ts';
+import { indexMap } from './map-index.ts';
 /*
  * rules.ts — the rules contract, version 2: what a rules module declares, and how the runtime reads it.
  * =============================================================================
@@ -246,7 +248,7 @@ export function roomSettings(raw: unknown): { settings: RoomSettings; problems:
 
 export interface MapBox { readonly min: Vec3; readonly max: Vec3 }
 export interface MapCircle { readonly at: Vec3; readonly r: number }
-export interface MapHeightTile { readonly at: Vec3; readonly size: Readonly<{ x: number; y: number }>; readonly heights: readonly [number, number, number, number] }
+export interface MapHeightTile { readonly base?: number; readonly diagonal?: '00-11' | '10-01'; readonly at: Vec3; readonly size: Readonly<{ x: number; y: number }>; readonly heights: readonly [number, number, number, number] }
 export interface GameMap { readonly name: string; readonly heightTiles: readonly MapHeightTile[]; readonly bounds: MapBox; readonly boxes: readonly MapBox[]; readonly circles: readonly MapCircle[]; readonly spheres: readonly MapCircle[]; readonly capsules: readonly (MapCircle & { height: number })[]; readonly spots: Readonly<Record<string, readonly Vec3[]>> }
 
 const vecOf = (a: unknown, what: string): Vec3 => {
@@ -280,15 +282,19 @@ export function compileMap(raw: unknown, name = 'main'): GameMap {
     return Object.freeze({ at: vecOf(c?.at, `${what}.at`), r });
   };
   if ([m.boxes, m.circles, m.spheres, m.capsules, m.heightTiles].some(list => list !== undefined && !Array.isArray(list))) throw new Error(`${where}: shapes are lists`);
-  if ([m.boxes, m.circles, m.spheres, m.capsules, m.heightTiles].reduce((n, list) => n + (list?.length ?? 0), 0) > 4096) throw new Error(`${where}: at most 4096 static shapes`);
-  return Object.freeze({
+  if ([m.boxes, m.circles, m.spheres, m.capsules, m.heightTiles].reduce((n, list) => n + (list?.length ?? 0), 0) > 100000) throw new Error(`${where}: at most 100000 static shapes`);
+  const result = Object.freeze({
     name,
     heightTiles: Object.freeze((m.heightTiles ?? []).map((t: any, i: number) => {
       const what = `${where} heightTiles[${i}]`;
       const at = vecOf(t?.at, `${what}.at`);
       if (!Array.isArray(t.size) || t.size.length !== 2 || t.size.some((v: unknown) => typeof v !== 'number' || !Number.isFinite(v) || v <= 0)) throw new Error(`${what}: size is two positive finite lengths`);
       if (!Array.isArray(t.heights) || t.heights.length !== 4 || t.heights.some((v: unknown) => typeof v !== 'number' || !Number.isFinite(v))) throw new Error(`${what}: heights are four finite offsets, in row order`);
-      return Object.freeze({ at, size: Object.freeze({ x: t.size[0], y: t.size[1] }), heights: Object.freeze([...t.heights]) as unknown as MapHeightTile['heights'] });
+      if (t.base !== undefined && (typeof t.base !== 'number' || !Number.isFinite(t.base) || t.heights.some((h:number) => h < t.base))) throw new Error(`${what}: base must be finite and at or below every top sample`);
+      if (t.diagonal !== undefined && !['00-11','10-01'].includes(t.diagonal)) throw new Error(`${what}: diagonal is 00-11 or 10-01`);
+      const tile = Object.freeze({ ...(t.base !== undefined ? {base:t.base} : {}), ...(t.diagonal ? {diagonal:t.diagonal} : {}), at, size: Object.freeze({ x: t.size[0], y: t.size[1] }), heights: Object.freeze([...t.heights]) as unknown as MapHeightTile['heights'] });
+      prepareTile(tile);
+      return tile;
     })),
     spheres: Object.freeze((m.spheres ?? []).map((c: any, i: number) => roundShape(c, `${where} spheres[${i}]`))),
     capsules: Object.freeze((m.capsules ?? []).map((c: any, i: number) => {
@@ -305,6 +311,8 @@ export function compileMap(raw: unknown, name = 'main'): GameMap {
     })),
     spots: Object.freeze(spots),
   });
+  indexMap(result);
+  return result;
 }
 
 /* ------------------------------------------------------------------ compiled tables */

package/rules/terrain.ts

@@ -0,0 +1,93 @@
+/** Solid triangulated height tiles. Each source triangle is a closed vertical
+ * prism; their union preserves noncoplanar samples without a convex-hull fill. */
+import { charge } from './guard.ts';
+import type { Vec3, MapHeightTile } from './rules.ts';
+import type { Solid, Hit3 } from './collision.ts';
+type Plane = { n: Vec3; c: number };
+type Prism = { vertices: Vec3[]; faces: Vec3[][]; planes: Plane[]; edges: Vec3[] };
+const cache = new WeakMap<MapHeightTile, Prism[]>();
+const sub=(a:Vec3,b:Vec3):Vec3=>({x:a.x-b.x,y:a.y-b.y,z:a.z-b.z});
+const add=(a:Vec3,b:Vec3,t=1):Vec3=>({x:a.x+b.x*t,y:a.y+b.y*t,z:a.z+b.z*t});
+const dot=(a:Vec3,b:Vec3)=>a.x*b.x+a.y*b.y+a.z*b.z;
+const cross=(a:Vec3,b:Vec3):Vec3=>({x:a.y*b.z-a.z*b.y,y:a.z*b.x-a.x*b.z,z:a.x*b.y-a.y*b.x});
+const clamp=(x:number)=>Math.max(0,Math.min(1,x));
+export function prepareTile(t:MapHeightTile):void {
+  if(t.base===undefined)return;
+  const top=t.heights.map((h,i)=>({x:t.at.x+(i%2)*t.size.x,y:t.at.y+(i>>1)*t.size.y,z:t.at.z+h}));
+  const tris=t.diagonal==='10-01'?[[0,1,2],[1,3,2]]:[[0,1,3],[0,3,2]];
+  const prisms:Prism[]=[];
+  for(const tri of tris){
+    const upper=tri.map(i=>top[i]),lower=upper.map(v=>({...v,z:t.at.z+t.base!}));
+    if(upper.every(v=>v.z===lower[0].z))continue;
+    const vertices=[...upper,...lower],faces=[upper,[...lower].reverse()];
+    for(let i=0;i<3;i++){const j=(i+1)%3;faces.push([upper[i],lower[i],lower[j]],[upper[i],lower[j],upper[j]]);}
+    const center=vertices.reduce((s,v)=>add(s,v,1/6),{x:0,y:0,z:0}),planes:Plane[]=[],valid:Vec3[][]=[],edges:Vec3[]=[];
+    for(const face of faces){let n=cross(sub(face[1],face[0]),sub(face[2],face[0]));const len=Math.sqrt(dot(n,n));if(len<1e-12)continue;n={x:n.x/len,y:n.y/len,z:n.z/len};let c=dot(n,face[0]);if(dot(n,center)>c){n={x:-n.x,y:-n.y,z:-n.z};c=-c;}planes.push({n,c});valid.push(face);for(let i=0;i<3;i++)edges.push(sub(face[(i+1)%3],face[i]));}
+    prisms.push({vertices,faces:valid,planes,edges});
+  }
+  cache.set(t,prisms);
+}
+// Closest point on a triangle, including vertex and edge Voronoi regions.
+function triangle(p:Vec3,a:Vec3,b:Vec3,c:Vec3):Vec3 {
+  const ab=sub(b,a),ac=sub(c,a),ap=sub(p,a),d1=dot(ab,ap),d2=dot(ac,ap);
+  if(d1<=0&&d2<=0)return a;
+  const bp=sub(p,b),d3=dot(ab,bp),d4=dot(ac,bp);if(d3>=0&&d4<=d3)return b;
+  const vc=d1*d4-d3*d2;if(vc<=0&&d1>=0&&d3<=0)return add(a,ab,d1/(d1-d3));
+  const cp=sub(p,c),d5=dot(ab,cp),d6=dot(ac,cp);if(d6>=0&&d5<=d6)return c;
+  const vb=d5*d2-d1*d6;if(vb<=0&&d2>=0&&d6<=0)return add(a,ac,d2/(d2-d6));
+  const va=d3*d6-d5*d4;if(va<=0&&d4-d3>=0&&d5-d6>=0)return add(b,sub(c,b),(d4-d3)/(d4-d3+d5-d6));
+  const den=1/(va+vb+vc);return add(add(a,ab,vb*den),ac,vc*den);
+}
+function segmentPair(a:Vec3,b:Vec3,c:Vec3,d:Vec3):Vec3 {
+  const u=sub(b,a),v=sub(d,c),w=sub(a,c),aa=dot(u,u),bb=dot(u,v),cc=dot(v,v),dd=dot(u,w),ee=dot(v,w);
+  let s=aa?clamp((bb*ee-cc*dd)/(aa*cc-bb*bb)||0):0;
+  let t=cc?clamp((bb*s+ee)/cc):0;
+  s=aa?clamp((bb*t-dd)/aa):0;t=cc?clamp((bb*s+ee)/cc):0;
+  return sub(add(a,u,s),add(c,v,t));
+}
+function clip(prism:Prism,p:Vec3,d:Vec3):Hit3|null {
+  let near=0,far=1,n={x:0,y:0,z:0};
+  for(const plane of prism.planes){charge(8);const gap=plane.c-dot(plane.n,p),speed=dot(plane.n,d);if(Math.abs(speed)<1e-12){if(gap< -1e-9)return null;continue;}const t=gap/speed;if(speed<0){if(t>=near){near=t;n=plane.n;}}else far=Math.min(far,t);if(near>far+1e-9)return null;}
+  return near>=0&&near<=1&&far>=0?{t:near,nx:n.x,ny:n.y,nz:n.z}:null;
+}
+function distance(prism:Prism,a:Vec3,b:Vec3):Vec3 {
+  if(clip(prism,a,sub(b,a)))return {x:0,y:0,z:0};
+  let best={x:Infinity,y:Infinity,z:Infinity},sq=Infinity;
+  const take=(v:Vec3)=>{const n=dot(v,v);if(n<sq){sq=n;best=v;}};
+  for(const [x,y,z] of prism.faces){charge(36);take(sub(a,triangle(a,x,y,z)));take(sub(b,triangle(b,x,y,z)));take(segmentPair(a,b,x,y));take(segmentPair(a,b,y,z));take(segmentPair(a,b,z,x));}
+  return best;
+}
+function boxCast(prism:Prism,a:Solid,d:Vec3):Hit3|null {
+  const axes:Vec3[]=[{x:1,y:0,z:0},{x:0,y:1,z:0},{x:0,y:0,z:1},...prism.planes.map(p=>p.n)];
+  for(const e of prism.edges)for(const k of axes.slice(0,3))axes.push(cross(e,k));
+  let near=0,far=1,normal={x:0,y:0,z:0};
+  for(const axis of axes){charge(16);const len=Math.sqrt(dot(axis,axis));if(len<1e-10)continue;const n={x:axis.x/len,y:axis.y/len,z:axis.z/len};let lo=Infinity,hi=-Infinity;
+    for(const v of prism.vertices){const p=dot(n,v);lo=Math.min(lo,p);hi=Math.max(hi,p);}
+    let amin=0,amax=0;for(const k of ['x','y','z'] as const){amin+=n[k]*(n[k]>=0?a.min[k]:a.max[k]);amax+=n[k]*(n[k]>=0?a.max[k]:a.min[k]);}
+    const speed=dot(n,d);if(Math.abs(speed)<1e-12){if(amax<=lo+1e-9||amin>=hi-1e-9)return null;continue;}
+    let enter=(lo-amax)/speed,exit=(hi-amin)/speed;if(enter>exit)[enter,exit]=[exit,enter];
+    if(enter>=near){near=enter;normal={x:n.x*(speed>0?-1:1),y:n.y*(speed>0?-1:1),z:n.z*(speed>0?-1:1)};}far=Math.min(far,exit);if(near>far)return null;
+  }
+  return near<=1&&dot(normal,d)<0?{t:near,nx:normal.x,ny:normal.y,nz:normal.z}:null;
+}
+export function castTerrain(tile:MapHeightTile,a:Solid,d:Vec3):Hit3|null {
+  charge(12);
+  let best:Hit3|null=null;
+  for(const prism of cache.get(tile)??[]){
+    let hit:Hit3|null=null;
+    if(a.r===0)hit=a.min.x===a.max.x&&a.min.y===a.max.y&&a.min.z===a.max.z?clip(prism,a.min,d):boxCast(prism,a,d);
+    else {let t=0;for(let i=0;i<32;i++){charge(24);const v=distance(prism,add(a.min,d,t),add(a.max,d,t)),len=Math.sqrt(dot(v,v)),gap=len-a.r;if(i===0&&gap< -1e-7)break;if(len===0)break;const n={x:v.x/len,y:v.y/len,z:v.z/len},closing=-dot(n,d);if(closing<=1e-9)break;if(gap<=1e-7){hit={t,nx:n.x,ny:n.y,nz:n.z};break;}t+=gap/closing;if(t>1)break;if(i===31)hit={t,nx:n.x,ny:n.y,nz:n.z};}}
+    if(hit&&(!best||hit.t<best.t))best=hit;
+  }return best;
+}
+export function overlapsTerrain(tile:MapHeightTile,a:Solid):boolean {
+  for(const prism of cache.get(tile)??[]){
+    if(a.r>0){const v=distance(prism,a.min,a.max);if(dot(v,v)<a.r*a.r-1e-9)return true;}
+    else {
+      // SAT overlap uses the same face, edge and box axes as continuous casts.
+      const axes=[{x:1,y:0,z:0},{x:0,y:1,z:0},{x:0,y:0,z:1},...prism.planes.map(p=>p.n)];
+      for(const e of prism.edges)for(const k of axes.slice(0,3))axes.push(cross(e,k));
+      let separated=false;for(const n of axes){charge(16);if(dot(n,n)<1e-18)continue;const ps=prism.vertices.map(v=>dot(n,v));let lo=0,hi=0;for(const k of ['x','y','z'] as const){lo+=n[k]*(n[k]>=0?a.min[k]:a.max[k]);hi+=n[k]*(n[k]>=0?a.max[k]:a.min[k]);}if(hi<=Math.min(...ps)+1e-9||lo>=Math.max(...ps)-1e-9){separated=true;break;}}if(!separated)return true;
+    }
+  }return false;
+}

package/starters/hero-rush-3d/src/move.ts

@@ -4,6 +4,8 @@ import { defineMove, type Vec3 } from '@homie-rocks/studio/rules';
 
 import type { MoveBody, MoveContext } from '@homie-rocks/studio/rules/types';
 
+// Solid slopes use the same contact tangent as walls; the capsule keeps its full
+// clearance. Never replace this sweep with an unchecked height assignment.
 function slide<M>(body: MoveBody<M>, delta: Vec3, ctx: MoveContext<unknown, M>) {
   const before = body.pos, hit = ctx.world.sweep(body, delta);
   if (!hit) return;

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.44.1';
+export const STUDIO_VERSION_TAG = '0.44.3';