@homie-rocks/studio 0.45.2 → 0.45.3

package/CHANGELOG.md

@@ -17,6 +17,35 @@ 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.45.3] - 2026-10-10
+
+**Plugin 0.45.3**
+
+Run richer server-authoritative combat, admission and bots with shared collision queries.
+
+### Added
+
+- Opt-in ray options, ordered `rayAll` hits, named hit regions, projectile profiles, immutable query scenes and scratch movement queries.
+- `f.pulse()` carries a nonzero byte action once over the reliable input-event channel. Use it for weapon selection; ordinary sampled fields must not carry one-frame actions.
+- Entity field visibility: `owner`, `server` and `results`. Per-recipient projections also apply to welcome, watching and reconnect snapshots. Private-delivery deltas refer to a keyframe so packet loss cannot leave moving actors at stale poses.
+- Authenticated room round records, with a durable retry outbox and idempotent player-history append. Browser saves cannot overwrite server records.
+- Budgeted routes over baked walking graphs, ordered same-tick dispatch, player labels, ranked takeover and result-free retries. Named `navigation` graphs validate once at compilation, avoiding repeated graph-validation charges in bot handlers while retaining live obstacle checks and full searches.
+
+### Fixed
+
+- **Ray compatibility:** the earlier PR revision changed all rays to hit inside solids and charged more. Three-argument calls now retain their existing results and cost. Supplying the new options explicitly opts into inside-solid hits and the new query cost.
+- **Collider delivery:** the earlier PR revision copied every primitive field. Collider rows now carry only explicitly declared public `collider.fields`, and geometry revisions are sent only when changed relative to the snapshot baseline.
+- **Build compatibility:** `label`, `dispatch`, `rayAll`, `rays` and `restart` remain legal ordinary property and destructuring names. Guarding capability calls does not reserve these data names.
+- **Terrain compatibility:** the earlier PR revision changed terrain casting globally. Existing casts retain the 0.45.0 implementation; `body.terrain: 'exact'` and ray option `terrain: 'exact'` opt into the new algorithm and cost. Seeded compatibility tests pin old results and costs.
+- Client-requested actor rewind is bounded by server-measured round-trip latency plus presentation and scheduling margins, within the declared history limit. A client cannot simply choose any point in the history window.
+- Optional `sweep(body, delta, {ground:false})` skips redundant support work when the mover explicitly computes grounding. Default sweep behavior is unchanged. Exact terrain casts reject irrelevant support features early, reuse face-entry calculations and cache identical immutable queries within a handler. Ten thousand seeded exact casts pin zero result drift through the face optimization. Near-first tile traversal cuts charged work by 30% across 2,000 seeded dense-terrain casts; its maximum contact-component drift is 2.6e-14. These opt-in savings do not enlarge handler budgets.
+
+### Upgrade notes
+
+- New ray and terrain policies are opt-in. Query filters and locally predicted feedback do not grant damage authority.
+- `server:` save keys are reserved for declared room records; player-owned saves use other keys. Records retain at most 100 completed rounds.
+- This capability work does not itself constitute a Stormbreak gameplay parity claim.
+
 ## [0.45.2] - 2026-10-10
 
 **Plugin 0.45.2** · [#76](https://github.com/homie-rocks/homie/pull/76)

package/guides/game/RULES.md

@@ -685,8 +685,7 @@ score and other shared outcomes still arrive with the network. The studio choose
 Room state is saved automatically (default movementSeconds: 1, plus round end,
 pause and finish). After 60 seconds with no person the room ends even if screens or
 AI remain. Use browser createSaves for player-owned character progress; it is not
-server-verified money. All replicated fields are public, including disguised roles.
-Use a separate authorized records service for private or lasting app records.
+server-verified money. Entity fields default to public. Declare visibility explicitly for private information (below); shared state and motion remain public. Use declared server round records for verified match history.
 
 
 ## Spatial delivery (0.45.0; milestone 2 slice 2)
@@ -772,3 +771,224 @@ known geometry beyond received ticks: a client cannot predict an unseen remote
 build/destruction. Once that update arrives, replay uses its geometry immediately.
 Moving platforms use world.place in their handlers; sweep/support see each tick's
 position. Passenger carrying is explicit movement logic, not automatic physics.
+
+## Filtered combat and camera queries
+
+`world.ray(from, direction, metres, options?)` returns the nearest hit or undefined.
+`world.rayAll` returns all entry hits in distance order (one per shape or named
+part, not exit faces). Static geometry wins equal-distance ties; entity and part
+insertion order break remaining ties. Both queries charge their scans, geometry,
+filtering and output to the normal handler budget. The maximum ray distance is 10,000 metres; radius queries keep their 64 m bound; no query raises the game's budget.
+
+```ts
+runner: {
+  // Movement remains a capsule; these boxes apply only to ray queries.
+  body: {shape: 'capsule', radius: .42, height: 1.8, maxSpeed: 22},
+  query: {layer: 'fighters', tags: ['damageable'], parts: {
+    body: {shape: 'box', radius: .42, height: 1.5},
+    head: {shape: 'box', radius: .24, height: .4, offset: {x: 0, y: 0, z: 1.5}},
+  }},
+  fields: {hp: f.fix({init: 100})},
+  // ...player, inputs, movement and handlers...
+}
+```
+
+Parts are axis-aligned, feet-relative shapes, at most 16 per kind. `hit.part`
+is their declared name. A kind without parts uses its normal body or enabled
+collider. Parts do not resize movement bodies. Optional `query.profiles` holds up to eight named part sets; `profile` in ray options selects one, falling back to the default parts when that kind has no matching profile. For example, projectile travel may use a full-height box while bullets use separate body/head boxes. Geometry-only rays always use collision shapes. Query layers and tags are static
+kind declarations. A live collider's `enabled` and `size` fields still control
+its presence and dimensions.
+
+Options are plain data, never callbacks:
+
+- `kind`, `tag`, `layer`: exact entity-kind, declared-tag and layer matches.
+  Undeclared layers default to `geometry` for live colliders and `body` otherwise.
+  Static map shapes use `geometry` and are not subject to kind/tag/field filters.
+- `where: {hp: {gt: 0}}`: filter declared entity fields. Values may be exact
+  numbers, strings or booleans; numeric tests are `gt`, `gte`, `lt`, `lte`, plus
+  `eq`. All tests must match. Missing fields do not match. At most 16 fields.
+- `ignore: [ref]`: at most 16 opaque entity refs. Entity-handler and movement rays ignore their own entity
+  by default; `ignoreSelf: false` includes it. This also applies when a moving
+  non-player entity is itself a live collider. Local view rays use the own player
+  as caller; room-handler rays have no implicit caller. Rocket travel can ignore its owner explicitly; blast damage
+  may include the owner.
+- `geometryOnly: true`: map plus enabled live colliders, using their collision
+  shape rather than hit parts. Fighters do not shield other fighters. Use an
+  exclusion when testing the visibility of the cover being damaged. Evaluate
+  every visibility ray before sending damage events to preserve pre-blast cover.
+- `entitiesOnly: true`: omit the static map. Combine with the filters above.
+- `radius` and `shape`: cast a sphere (default) or axis-aligned box with this
+  half-size around the ray centre, useful for camera clearance. Radius defaults
+  to zero and is at most 100 metres. A point ray beginning inside a solid reports
+  an immediate hit; movement sweeps continue to allow escape from overlap.
+
+`room.ray` and `room.rayAll` use the same implementation for local aiming and
+cosmetic feedback. They use the drawn entity poses and latest known live geometry;
+only server results award damage. Spatially absent non-collider entities cannot
+be targeted by the view. Unknown remote edits are not predicted.
+
+Movement's `ctx.world.ray/rayAll` (also on `ctx.map`) query its tick's frozen static
+and live collision geometry with these same options. Collider kind, layer, tags
+and scalar fields accompany collision revisions, including outside visual
+interest, so a predicted geometry filter has the same data as authority.
+Movement cannot query fighters or award damage. These APIs do not implement lag
+compensation: they query the current authoritative or presented world.
+
+### Consent before driving an inherited bot
+
+A player's declaration may set `control: 'accepted'`, naming a declared bit in
+`motion`. When false, authority calls `think` even for a present person, and the
+view draws the authoritative body without predicting that person's movement.
+Commands remain available: validate an explicit consent command and set the bit
+true. Initialize it on arrival and reset it in `on.takeover` when appropriate.
+The server still owns driver/seat identity; this flag only controls input.
+
+Set `takeover: 'fitness'` to name a numeric field used when selecting a fill bot.
+The highest value wins (equal values use the highest seat). Update it in rules
+from health, position or whatever makes a body suitable. Reserved companions
+never yield. The selected entity keeps its ID, inventory and all state; only its
+seat and driver change. A displaced bot retains its own state at the donor's old
+seat. Without this declaration, existing seat-based selection is unchanged.
+
+Movement queries reject distant live colliders by swept bounds before detailed
+intersection, just as static map queries do. Bounds include capsule radius and
+height, vertical columns and the full sweep, preserving fast travel and support.
+
+### Ordered same-tick interactions
+
+`world.dispatch(id, event, payload)` delivers a declared event immediately and
+returns whether a live receiver had a handler. The receiver changes only its own
+state; after it returns, later queries see those changes. Use it for ordered
+pellets, where destroying a wall or killing a fighter changes the next ray.
+Ordinary `send` retains next-tick delivery. For a blast, collect every visibility
+decision before dispatching damage so one broken wall still shields that blast.
+
+Dispatch consumes the caller's remaining handler budget, including receiver work,
+and permits at most eight nested deliveries. It does not grant writes to another
+entity or shared state. It is not a transaction: mutations before an error remain
+subject to ordinary field coercion. Missing targets return false; there is no
+queued undeliverable event for immediate delivery. Movement cannot dispatch.
+
+Solid-terrain capsule distance queries reject triangle faces whose bounds cannot
+beat the closest feature already found. This preserves exact sampled geometry,
+including both source triangles and the solid sides and underside.
+
+### Bounded actor-pose rewind
+
+Declare `room.historySeconds: 1` (maximum two seconds). The server retains and
+saves non-collider body positions and placement revisions on its virtual clock.
+The view's `room.viewTick` is the tick used to interpolate remote bodies. Send it
+with an action, then use `world.ray(..., {atTick, ...filters})`. Fractional ticks
+interpolate saved poses. Player requests clamp to the smaller of the configured window and the server-measured round-trip latency plus 150 ms presentation delay and one simulation tick. Without a measurement only that small margin is allowed. The relay measures a nonce challenge; client-supplied latency figures are ignored.
+A placement or new round prevents rewinding through a teleport or reset.
+
+Rewind changes actor poses only. Eligibility filters use current fields, so a
+corpse or a fighter killed by an earlier pellet cannot absorb later pellets.
+Static terrain and live cover stay current: new cover blocks an old shot, and
+destroyed cover no longer blocks. This conservative cover policy is explicit;
+it is not a historical replay of world destruction. Rewind does not move actors,
+change movement prediction, roll back damage or rewind projectiles. Choose the
+window in game rules and validate actions normally; the client's tick is a claim.
+
+Vertical capsule sweeps against solid terrain use an exact swept sphere against
+the prism extended by the capsule centreline. Face, edge and vertex contacts
+replace iterative grazing convergence; geometry and handler budgets stay intact.
+
+For many related visibility or navigation queries in one handler, use
+`const scene = world.rays(options)`, then `scene.ray(from, direction, metres)`
+or `scene.rayAll(...)`. It captures actor poses, live geometry and filter fields
+once; later damage or placement does not change that scene. Each ray is still
+budgeted. Keep it local to the handler. Use ordinary `world.ray` when subsequent
+hits must see mutations, such as sequential pellets. Predicted movement exposes
+`ctx.world.rays` for its current geometry, too.
+
+`world.label(playerRef)` reads the relay's current display name (including bot
+names), at most 40 characters, or an empty string for a missing/non-player ref.
+Copy it into a declared field when a historical message must survive departures
+or seat exchanges. Names are presentation text, never proof of player identity;
+use the existing owner/ref for identity. The host restores labels with its save.
+
+For a body's planned route, capture `world.rays({geometryOnly:true,
+shape:'capsule', radius:.4, height:1.8})`. A capsule ray starts at its centre;
+`scene.sweep(scratchBody, delta)` and `scene.support(scratchBody, distance)` use
+its foot position instead, like shared movement. A scratch body has plain `pos`
+and `grounded` fields. These bounded queries change only that local copy, never
+a player or the captured scene. Use the same movement helper to evaluate a
+jump or dive without granting an action to the real body. Height is at least
+twice the radius, at most 200 metres; spherical casts retain their diameter.
+
+`world.round.restart()` is room-only. It abandons the current attempt and starts the
+next round on the next tick, keeping seats and entities and running the normal
+`roundStart` handlers. It publishes no completed results or `roundOver` event and
+skips the intermission. Use it for an authorized retry; validate eligibility in
+your room handler. Pending restart intent survives save/restore.
+
+
+### Discrete actions with a value
+
+Use `select: f.pulse()` for a weapon slot or other byte-valued action. Call
+`room.input({select: 2})` on the press and return to zero on release. A nonzero
+value is queued once, including a pulse shorter than a simulation tick; held
+samples do not create repeated actions. Zero is neutral. The reliable event
+channel carries these actions, with at most 16 pending per seat and one consumed
+per tick. Epoch changes discard old-round actions. `f.press()` remains the
+boolean equivalent; `f.u8()` is sampled state and can miss a one-frame pulse.
+
+### Private entity fields and verified round history
+
+Declare an entity field with `{visibility: 'server'}` for bot brains or secrets,
+`{visibility: 'owner'}` for private inventory, or `{visibility: 'results'}` for
+statistics revealed during intermission. Nested contents follow their top-level
+field. Hidden values become neutral on the client; never depend on them in shared
+movement. Server rules still read full state. Watchers receive public fields and
+results only. Entity positions, driver information, shared state and motion are
+public. This is field visibility, not fog-of-war entity hiding.
+
+A collider transmits only geometry plus explicitly named public scalar fields:
+`collider: {size: 'size', enabled: 'solid', fields: ['material']}`. Do not put
+private fields in that list. Unchanged collision rows are inherited from the
+snapshot baseline; keyframes and reconnects remain complete.
+
+For verified history declare
+`room.records: {key: 'server:career-v1', identity: 'matchKey', eligible: 'ready',
+fields: {kills: 'earnedKills', damage: 'earnedDamage'}}`. The identity names a
+shared text field that rules make unique for each round. The optional eligibility
+names a player boolean field; result fields name numeric player fields. The
+Worker associates the participant with its authenticated player ID and stores
+`id`, `endedAt`, `place`, `won` and the declared totals when the round completes.
+A durable outbox retries failed writes; duplicate round IDs are ignored. Read
+with `createSaves().get(key)`. Browser writes, deletes and save resets cannot
+change `server:` records. Keep guest/authentication setup active before playing.
+
+### Opt-in exact terrain and baked navigation
+
+Legacy three-argument rays keep their historical result and cost. Supplying ray
+options enables the richer query policy, including hits at distance zero when
+starting inside solids. Terrain changes are separate: set `terrain: 'exact'` in
+ray options or the entity body declaration to use exact face/edge/vertex terrain
+casts. Existing terrain behavior is retained when omitted. Test your map's
+slopes, ledges and movement when opting in.
+
+Declare static graphs once with `navigation: {walk: graph}` in `defineRules`, then
+call `world.route('walk', from, to, {radius, height})`. Compilation validates and
+copies the graph once; handlers pay for the live search, not graph validation.
+At most eight named graphs with 8192 nodes total are accepted. Unknown names fail.
+The array form remains available for occasional dynamic graphs.
+
+`world.route(graph, from, to, {radius, height})` searches an immutable authored
+walking graph. Nodes are `[x, y, z, neighbourIndices]`; endpoints are node indices.
+The graph has at most 8192 nodes and 16 neighbours per node. Edges must already
+encode static terrain walkability. The runtime checks live colliders, returns
+all node indices of a route or an empty list, and charges the search to the
+handler budget. It never substitutes a partial route at an expansion cap.
+Replan when the goal changes and when live geometry changes. Bake invalid or
+occupied terrain nodes out of the graph, and choose reachable endpoints.
+`@homie-rocks/nav` is the richer mesh/crowd API for applications that own that
+runtime; rules graphs avoid importing mutable navigation state into handlers.
+
+`room.predict.idleHold: true` holds small visual reconciliation offsets while
+input and body are stationary. Movement resumes smoothing. Large invalid poses
+still snap to authority. Opt in only after measuring stop/reversal and delayed
+collision behavior for the game's mover.
+
+For multi-cast movement or scratch trajectory checks, `ctx.world.sweep(body, delta, {ground:false})` (also captured-scene `sweep`) moves and returns the same collision but leaves `body.grounded` unchanged. Use it only when your mover computes support explicitly. Omitting the option retains the existing support query and grounding behavior. This avoids paying for identical support checks after horizontal and upward probes.

package/lib/build.mjs

@@ -602,7 +602,7 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
   // studio.json site.order: the catalogue's order is every listing's order.
   const shown = orderGames(all.filter((g) => existsSync(join(dist, 'games', g.id, 'index.html'))), s.order, log);
   // Server-hosted games: what this build made, and for a one-game build what the catalogue before it said of the others.
-  const rulesOf = new Map(ruled.map((r) => [r.id, { host: r.settings.host, offline: r.settings.offline, tickHz: r.settings.tickHz, inputHz: r.settings.inputHz, contract: r.schema.contract, build: r.build, stateHash: r.stateHash, rounds: r.rounds }]));
+  const rulesOf = new Map(ruled.map((r) => [r.id, { host: r.settings.host, offline: r.settings.offline, tickHz: r.settings.tickHz, inputHz: r.settings.inputHz, contract: r.schema.contract, build: r.build, stateHash: r.stateHash, rounds: r.rounds, ...(r.schema.records?{records:true}:{}) }]));
   if (only) for (const row of readJson(join(dist, 'games.json'))?.games ?? []) if (row?.room?.contract && row.id !== only && !rulesOf.has(row.id)) rulesOf.set(row.id, row.room);
   // What each game's build is (its landing's own pictures are not part of it): the digest the manifest names.
   const builds = {};

package/lib/rules-check-worker.mjs

@@ -184,7 +184,7 @@ function play(c, companions, allow) {
   const bots = (mode) => { policy = { ...(policy ?? {}), bots: mode }; frames.push({ t: 'policy', policy }); };
 
   const movesToCheck = [];
-  const moved = (...args) => movesToCheck.push(args);
+  const moved = (...args) => { movesToCheck.push(args); if (fault && fault.includes(`${args[0]}.move:`) && !fault.includes('Movement input:')) fault += ` Movement input: ${JSON.stringify(args[2])}; before: ${JSON.stringify(args[3])}.`; };
   let A = open({ observe, noted, moved, send });
   for (const m of told()) A.frame(m);
   /** The room stops and starts again as a deploy restarts it: a new epoch, everybody away until they are back. */
@@ -236,8 +236,9 @@ 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;
+  let moveSelf;
   let moveGeometry = c.map;
-  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, geometry: () => moveGeometry, name: c.map.name, spots: c.map.spots, radius: () => k.body.radius, shape: () => k.body, 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, geometry: () => moveGeometry, self: () => moveSelf, 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.
@@ -249,7 +250,7 @@ function play(c, companions, allow) {
     const e = w && L.P.unpackEntity(c.kinds, w, c.dims);
     if (!e) return null;
     G.note = (what, at, written) => noted(k.name, 'move', what, at, written);
-    moveTick = t;
+    moveTick = t; moveSelf = b.id;
     const body = L.P.stepMove(k.move, { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: L.P.thawFields(k.motion, e.motion) }, Object.freeze(values), moveCtx.get(k.name), Math.max(1, Math.floor(budget / 4)), k.motion, c.dims,
       (error) => { fault ??= `${G.file}:${G.line} ${k.name}.move: ${fix(diagnostic(String(error?.message ?? error)))} A player's own browser runs this move for its body.${when()}`; });
     G.note = null;
@@ -345,9 +346,9 @@ function play(c, companions, allow) {
     const stats = A.core.stats; const cut = stats.ticksCut; const held = stats.held;
     A.tickNow();
     units += A.core.stats.tickUnits;
-    for (const [name, tick, input, before, after, geometry] of movesToCheck.splice(0)) {
+    for (const [name, tick, input, before, after, geometry, id] of movesToCheck.splice(0)) {
       const kind = c.kinds.find(k => k.name === name);
-      moveTick = tick; moveGeometry = geometry ?? c.map;
+      moveTick = tick; moveGeometry = geometry ?? c.map; moveSelf = id;
       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;

package/lib/rules-check.mjs

@@ -28,10 +28,10 @@ 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: geometry, dims, contract, seats, save } = c;
+  const { kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map: geometry, dims, contract, seats, save, historySeconds } = 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);
+  return createHash('sha256').update(JSON.stringify({ kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map, dims, contract, seats, ...(historySeconds?{historySeconds}:{}), tickHz: c.settings.tickHz, save }, (k, v) => typeof v === 'function' ? true : v)).digest('hex').slice(0, 32);
 }
 
 /**

package/lib/rules-guard.mjs

@@ -66,10 +66,11 @@ export const REFUSED_NAMES = ['constructor', 'prototype', '__proto__', 'stack',
 /** The names JavaScript calls by itself to turn an object into a number or a text: no function may sit under one. */
 export const HOOK_NAMES = ['valueOf', 'toString', 'toJSON'];
 /** What the host runtime's own objects offer: `world`, `ctx`, the round, the map (rules/core.ts) and `world.math` (rules/math.ts). */
-export const WORLD_METHODS = ['ticks', 'random', 'send', 'sendRoom', 'announce', 'sendArea', 'after', 'emit', 'spawn', 'despawn', 'place', 'near', 'inBox', 'ray', 'sweep', 'ask', 'goalDone', 'finish', 'end', 'spot', 'spots'];
+export const WORLD_METHODS = ['ticks', 'random', 'route', 'label', 'send', 'dispatch', 'sendRoom', 'announce', 'sendArea', 'after', 'emit', 'spawn', 'despawn', 'place', 'near', 'inBox', 'ray', 'rayAll', 'rays', 'sweep', 'ask', 'goalDone', 'finish', 'end', 'restart', 'spot', 'spots'];
 export const MATH_METHODS = ['sin', 'cos', 'tan', 'atan', 'atan2', 'asin', 'acos', 'exp', 'log', 'pow', 'hypot', 'rad', 'deg', 'clamp', 'lerp', 'vec', 'add', 'sub', 'scale', 'dot', 'cross', 'len', 'dist', 'norm', 'clampLen', 'lerpVec', 'dir', 'angle'];
 const VALUE_METHODS = new Set([...ARRAY_METHODS, ...STRING_METHODS, ...MAPSET_METHODS]);
 export const MOVE_METHODS = ['support', 'overlaps'];
+const NEW_METHODS = new Set(['route','label','dispatch','rayAll','rays','restart']);
 const CALLABLE = new Set([...VALUE_METHODS, ...WORLD_METHODS, ...MOVE_METHODS, ...MATH_METHODS]);
 const refusedName = (k) => REFUSED_NAMES.includes(k) || k.startsWith('toLocale');
 /** Operators that turn each operand into a number or a text. (`+` is handled beside them; `==` and `!=` are refused.) */
@@ -398,7 +399,7 @@ export function guardSource(code, { file = 'rules.js', map = null, linked = fals
       const decl = path.parentPath.isVariableDeclarator() && path.parentPath.parentPath.isVariableDeclaration() && statementsOf(path.parentPath.parentPath);
       for (const p of path.node.properties) {
         if (t.isRestElement(p)) continue;
-        const risky = p.computed || CALLABLE.has(p.key.name ?? p.key.value);
+        const risky = p.computed || (CALLABLE.has(p.key.name ?? p.key.value) && !NEW_METHODS.has(p.key.name ?? p.key.value));
         if (risky && !(decl && t.isIdentifier(p.value))) bad(p, `take "${p.computed ? 'a computed key' : p.key.name ?? p.key.value}" out with a plain \`const { … } = value\` declaration, or read it with a dot: a pattern here could take a method out of a value`);
       }
     },
@@ -457,7 +458,7 @@ export function guardSource(code, { file = 'rules.js', map = null, linked = fals
         const checks = [];
         for (const d of path.node.declarations) {
           if (!t.isObjectPattern(d.id)) continue;
-          for (const p of d.id.properties) if (!t.isRestElement(p) && t.isIdentifier(p.value) && (p.computed || CALLABLE.has(p.key.name ?? p.key.value))) checks.push(t.expressionStatement(call('nf', [t.identifier(p.value.name), line(p)])));
+          for (const p of d.id.properties) if (!t.isRestElement(p) && t.isIdentifier(p.value) && (p.computed || (CALLABLE.has(p.key.name ?? p.key.value) && !NEW_METHODS.has(p.key.name ?? p.key.value)))) checks.push(t.expressionStatement(call('nf', [t.identifier(p.value.name), line(p)])));
         }
         if (checks.length) path.insertAfter(checks);
       },

package/lib/rules-types.mjs

@@ -78,7 +78,7 @@ type W = World<${parameters}>;
 type RW = World<${parameters}, true>;
 type Definition = Omit<RulesDef, 'entities' | 'room' | 'move' | 'asks'> & {
   entities: ${entities}; move?: Moves;
-  room?: { rounds?: { seconds: number; breakSeconds: number }; bots?: { keep: number };
+  room?: { records?: {key:string;identity:string;eligible?:string;fields:Readonly<Record<string,string>>}; rounds?: { seconds: number; breakSeconds: number }; bots?: { keep: number }; historySeconds?: number;
     start?: (world: RW) => void;
     join?: (ctx: Pick<W, 'map' | 'shared' | 'tune' | 'math' | 'round'>, player: { seat: number; driver: 'person' | 'bot' | 'ai'; owner: string }) => ${joins};
     on?: { [K in keyof (Omit<Events, keyof GameRoomEvents> & GameRoomEvents)]?: (world: RW, event: EventData<(Omit<Events, keyof GameRoomEvents> & GameRoomEvents)[K]>) => void };

package/lib/template-history.json

@@ -2649,6 +2649,48 @@
      }
     }
    }
+  },
+  "0.45.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": "6cc5c6131eaf6fd0"
+   },
+   "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": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "c48971c1437414c2",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "2cdd530e48170bfd"
+      }
+     }
+    }
+   }
   }
  }
 }

package/netplay/netplay.ts

@@ -2395,6 +2395,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
         return;
       }
       case 'state': if (typeof m['k'] === 'string') applyState(m['k'], m['d']); return;
+      case 'probe': if (typeof m.n === 'string') raw({t:'probeAck',n:m.n}); return;
       case 'pong': return onPong(m);
       case 'announce': {
         if (typeof m['id'] !== 'string') return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.45.2",
+  "version": "0.45.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,12 +1,13 @@
 import { castTerrain } from './terrain.ts';
+import { castTerrain as legacyTerrain } from './terrain-legacy.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.
  */
-import { charge } from './guard.ts';
+import { charge, G } from './guard.ts';
 import type { Vec3, MapBox, MapCircle, MapHeightTile } from './rules.ts';
 
-export interface BodyShape { shape: string; radius: number; height: number }
+export interface BodyShape { shape: string; radius: number; height: number; terrain?: 'exact' }
 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 {
@@ -14,7 +15,7 @@ export interface Map3 {
   bounds: MapBox; boxes: readonly MapBox[]; circles: readonly MapCircle[];
   heightTiles?: readonly MapHeightTile[];
   spheres?: readonly MapCircle[];
-  capsules?: readonly (MapCircle & { height: number })[];
+  capsules?: readonly (MapCircle & { height: number; terrain?: 'exact' })[];
 }
 const EPS = 1e-7;
 const point = (x: number, y: number, z: number): {x: number; y: number; z: number} => ({ x, y, z });
@@ -33,8 +34,15 @@ function separation(a: Solid, b: Solid, d: Vec3, t: number): Vec3 {
 /** 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 {
+export function castSolid(a: Solid, d: Vec3, b: Solid, includeInside = false): Hit3 | null {
   charge(30);
+  if (includeInside) {
+    const gap = separation(a, b, d, 0);
+    const sq = gap.x*gap.x + gap.y*gap.y + gap.z*gap.z;
+    const radius=a.r+b.r;
+    const inside = radius > 0 ? sq < radius*radius : a.max.x > b.min.x && a.min.x < b.max.x && a.max.y > b.min.y && a.min.y < b.max.y && a.max.z > b.min.z && a.min.z < b.max.z;
+    if (inside) {const length = Math.sqrt(d.x*d.x+d.y*d.y+d.z*d.z)||1; return {t:0,nx:-d.x/length,ny:-d.y/length,nz:-d.z/length};}
+  }
   let t = 0;
   const r = a.r + b.r;
   let normal = point(0, 0, 0);
@@ -94,12 +102,27 @@ function castHeightTile(tile: MapHeightTile, p: Vec3, d: Vec3): Hit3 | null {
   return best;
 }
 
-export function castMap3(map: Map3, p: Vec3, d: Vec3, body: BodyShape): Hit3 | null {
+let memoEpoch = -1;
+let castMemo = new WeakMap<object, Map<string, Hit3 | null>>();
+export function castMap3(map: Map3, p: Vec3, d: Vec3, body: BodyShape, hits?: Hit3[], includeInside = false): Hit3 | null {
+  // Exact casts can reuse identical immutable-scene queries within one handler.
+  // The epoch resets at every authority handler, including after restore.
+  if(body.terrain !== 'exact' || hits || !Number.isFinite(G.left)) return castMap3Uncached(map,p,d,body,hits,includeInside);
+  if(memoEpoch!==G.queryEpoch){memoEpoch=G.queryEpoch;castMemo=new WeakMap();}
+  charge(16);
+  let rows=castMemo.get(map);if(!rows){rows=new Map();castMemo.set(map,rows);}
+  const key=[p.x,p.y,p.z,d.x,d.y,d.z,body.shape,body.radius,body.height,includeInside].join(',');
+  if(rows.has(key))return rows.get(key)!;
+  const hit=castMap3Uncached(map,p,d,body,hits,includeInside);
+  if(rows.size<512)rows.set(key,hit);
+  return hit;
+}
+function castMap3Uncached(map: Map3, p: Vec3, d: Vec3, body: BodyShape, hits?: Hit3[], includeInside = false): Hit3 | null {
   map = nearbyMap(map, p, d, body.radius, body.height || body.radius * 2);
   charge(24);
   const a = solidAt(p, body), r = body.radius, height = body.height || r * 2;
   let best: Hit3 | null = null;
-  const take = (h: Hit3 | null, id?: string): void => { if (h && h.t >= 0 && h.t <= 1 && (!best || h.t < best.t)) best = id ? {...h, id} : h; };
+  const take = (h: Hit3 | null, id?: string): void => { if (h && h.t >= 0 && h.t <= 1) { const hit = id ? {...h, id} : h; if (hits) {charge(8); hits.push(hit);} if (!best || h.t < best.t) best = hit; } };
   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);
@@ -107,12 +130,29 @@ 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(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);
+  const exactTerrain = body.terrain === 'exact';
+  const terrain = [...(map.heightTiles ?? [])];
+  if(exactTerrain && d.z<0){charge(terrain.length*Math.ceil(Math.log2(terrain.length+1)));terrain.sort((a,b)=>(b.at.z+Math.max(...b.heights))-(a.at.z+Math.max(...a.heights)));}
+  // Visit the nearest possible tile contacts first so later casts are shortened.
+  // All-hit queries retain authored ordering; legacy casts retain cost and behavior.
+  if(exactTerrain && (d.x||d.y) && !hits){
+    const first=(t:MapHeightTile)=>{let near=0;for(const k of ['x','y'] as const){if(d[k])near=Math.max(near,((d[k]>0?t.at[k]-r:t.at[k]+t.size[k]+r)-p[k])/d[k]);}return near;};
+    charge(terrain.length*(16+Math.ceil(Math.log2(terrain.length+1))));const order=new Map(terrain.map(t=>[t,first(t)]));terrain.sort((a,b)=>order.get(a)!-order.get(b)!);
+  }
+  for (const tile of terrain) {
+    if(exactTerrain && !hits && best?.t===0)break;
+    // Once a nearer surface is known, later solids only need to beat that time.
+    // This also bounds work on densely tessellated terrain behind the first hit.
+    const limit = exactTerrain && !hits && best ? best.t : 1;
+    const delta = limit < 1 ? point(d.x * limit, d.y * limit, d.z * limit) : d;
+    const hit = tile.base === undefined ? castHeightTile(tile, p, delta) : (exactTerrain ? castTerrain : legacyTerrain)(tile, a, delta);
+    if (hit) take({...hit, t: hit.t * limit});
+  }
+  for (const b of map.boxes) take(castSolid(a, d, { ...b, r: 0 }, includeInside), (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);
-  for (const s of map.spheres ?? []) take(castSolid(a, d, { min: s.at, max: s.at, r: s.r }), (s as any).id);
-  for (const c of map.capsules ?? []) take(castSolid(a, d, solidAt(c.at, { shape: 'capsule', radius: c.r, height: c.height })), (c as any).id);
+  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 }, includeInside), (c as any).id);
+  for (const s of map.spheres ?? []) take(castSolid(a, d, { min: s.at, max: s.at, r: s.r }, includeInside), (s as any).id);
+  for (const c of map.capsules ?? []) take(castSolid(a, d, solidAt(c.at, { shape: 'capsule', radius: c.r, height: c.height }), includeInside), (c as any).id);
   return best;
 }
 export function restsOnMap(map: Map3, p: Vec3, body: BodyShape): boolean {