@homie-rocks/studio 0.50.1 → 0.50.2

package/CHANGELOG.md

@@ -17,6 +17,21 @@ 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.50.2] - 2026-10-13
+
+**Plugin 0.50.2** · Keep your own runner out of solid ground.
+
+Your player's own runner stays outside declared solid terrain in a 2D game on server rules, even on a lossy connection.
+
+### Fixed
+
+- Own-runner drawing now checks interpolation and correction against the solid map, stopping at contact instead of drawing the runner inside terrain. In Homie Arcade's Tiny Platformer, measurements went from 250 penetrating frames in 12 lossy runs before the fix to 0 frames penetrating more than 0.1 tile in 30 runs and 77,368 frames after it.
+- Square 2D runners can declare a box body, and custom movement using substeps previews the remaining duration of held controls along the same movement path.
+
+### Upgrade notes
+
+- Follow [RULES.md](plugins/homie/skills/game/RULES.md): declare `map: './map'` in rules, put solid geometry in `map/main.json`, and keep it consistent with custom movement. Declare a square 2D runner with `body.shape: 'box'`, `radius` (its half-width) and `maxSpeed`. Use `ctx.substeps` for custom integration so the toolkit draws that path without a second view-side displacement. Blocked visual corrections do not change authoritative movement.
+
 ## [0.50.1] - 2026-10-13
 
 **Plugin 0.50.1** · Studio events reach their functions and the owner's AI.

package/guides/game/RULES.md

@@ -54,7 +54,7 @@ its guarded `move`. Bots, AI and away people are always moved on the server.
 `body.move: 'owner'` is an existing compatibility option that accepts bounded position
 claims and cannot enforce walls against a modified browser; do not use it for new games.
 A non-player entity may use `world.sweep(self, delta)` instead of a move function.
-Bodies require radius and maxSpeed. In 2D use circle; in 3D use sphere, capsule or
+Bodies require radius and maxSpeed. In 2D use circle or box (radius is its half-width); in 3D use sphere, capsule or
 axis-aligned box, with full height for capsule/box. `sweep: true` adds automatic map
 collision; explicit `ctx.map.sweep` moves and returns a contact for sliding.
 
@@ -1418,6 +1418,13 @@ Omit it to use the call time. A player can declare
 stun and deliver them when control returns. The default `'drop'` preserves the
 previous behaviour. The game's action handler still decides its cooldown.
 
+In 2D, own-body interpolation and correction are swept against the declared solid map.
+Keep that map consistent with custom movement and declare a square 2D runner as
+`body.shape: 'box'`. A blocked visual correction stops at contact; it never
+changes authoritative movement. Use `ctx.substeps` for custom integration so
+the toolkit draws the same path, without a second view-side displacement.
+Substep previews include the remaining duration of controls currently held.
+
 Residual drawing corrections use `room.predict.blendMs` (100 ms by default),
 slowed on each moving axis to avoid reversing movement (jumping cannot spend
 horizontal correction faster), with a one-second maximum

package/lib/template-history.json

@@ -3237,6 +3237,48 @@
      }
     }
    }
+  },
+  "0.50.2": {
+   "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": "1dbdf22c03a1e505",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "394cbbe934e80722",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "c10aa0441ea89702",
+     "## Commands (all through the pinned CLI in node_modules)": "5222e08ca55e326e",
+     "## 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": "b2234d80f6cbe71d",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "611b437f5b3303f0"
+      }
+     }
+    }
+   }
   }
  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.50.1",
+  "version": "0.50.2",
   "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/math.ts

@@ -218,7 +218,7 @@ export function rayBox(px: number, py: number, dx: number, dy: number, min: Vec3
     if (Math.abs(d[i]) < 1e-12) { if (p[i] <= lo[i] || p[i] >= hi[i]) return null; continue; }
     let ta = (lo[i] - p[i]) / d[i]; let tb = (hi[i] - p[i]) / d[i];
     if (ta > tb) { const s = ta; ta = tb; tb = s; }
-    if (ta > t0) { t0 = ta; nx = i === 0 ? (d[i] > 0 ? -1 : 1) : 0; ny = i === 1 ? (d[i] > 0 ? -1 : 1) : 0; }
+    if (ta >= t0) { t0 = ta; nx = i === 0 ? (d[i] > 0 ? -1 : 1) : 0; ny = i === 1 ? (d[i] > 0 ? -1 : 1) : 0; }
     if (tb < t1) t1 = tb;
     if (t0 > t1) return null;
   }
@@ -286,7 +286,7 @@ export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius:
     put(body, 'pos', at); if (own(options, 'ground') !== false) put(body, 'grounded', restsOnMap(map, at, shape));
     return h ? Object.freeze({ at, normal: v(h.nx, h.ny, h.nz), ...(h.id ? { entity: h.id } : {}) }) : undefined;
   }
-  const { hit: h } = castMap(map, px, py, dx, dy, radius);
+  const { hit: h } = castMap(map, px, py, dx, dy, radius, undefined, false, shape.shape === 'box');
   put(body, 'grounded', true);
   if (!h) { put(body, 'pos', wrapPoint(v(fr(px + dx), fr(py + dy), 0), map.wrap)); return undefined; }
   const l = Math.sqrt(dx * dx + dy * dy);

package/rules/rules.ts

@@ -599,7 +599,7 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
     let body: KindTable['body'] = null;
     if (e.body !== undefined) {
       const b = e.body;
-      const shapes = dims === 2 ? ['circle'] : ['sphere', 'capsule', 'box'];
+      const shapes = dims === 2 ? ['circle', 'box'] : ['sphere', 'capsule', 'box'];
       if (!b || !shapes.includes(b.shape)) throw new Error(`${at}.body.shape is ${shapes.map((s) => `'${s}'`).join(' or ')} when space.dims is ${dims}`);
       if (typeof b.radius !== 'number' || typeof b.maxSpeed !== 'number' || !Number.isFinite(b.radius) || !Number.isFinite(b.maxSpeed) || !(b.radius > 0) || !(b.maxSpeed >= 0)) throw new Error(`${at}.body needs radius (metres) and maxSpeed (metres a second)`);
       if (b.terrain !== undefined && b.terrain !== 'exact') throw new Error(`${at}.body.terrain is 'exact', or omitted for legacy casts`);
@@ -733,7 +733,7 @@ function publicField(field: Field, hidden=false): Field {
 export function schemaOf(c: Compiled): Schema {
   return {
     contract: RULES_CONTRACT, dims: c.dims, seats: c.seats, ...(c.records?{records:true as const}:{}), ...(c.historySeconds ? { rewind: { historySeconds: c.historySeconds, ...(c.rewindSeconds !== undefined ? { capSeconds: c.rewindSeconds } : {}) } } : {}),
-    kinds: c.kinds.map((k) => ({ ...(k.query?{query:k.query}:{}), ...(k.collider?{collider:k.collider}:{}), ...(k.body?.terrain ? {terrain:k.body.terrain} : {}), name: k.name, player: Boolean(k.player), ...(k.player?.control ? {control:k.player.control}:{}), owner: Boolean(k.body?.owner), radius: k.body?.radius ?? 0, ...(c.dims === 3 && k.body ? { shape: k.body.shape, height: k.body.height || 2 * k.body.radius } : {}), maxSpeed: k.body?.maxSpeed ?? 0, score: k.score, fields: k.fields.map(([name,field])=>[name,publicField(field)]), motion: k.motion, input: k.input })),
+    kinds: c.kinds.map((k) => ({ ...(k.query?{query:k.query}:{}), ...(k.collider?{collider:k.collider}:{}), ...(k.body?.terrain ? {terrain:k.body.terrain} : {}), name: k.name, player: Boolean(k.player), ...(k.player?.control ? {control:k.player.control}:{}), owner: Boolean(k.body?.owner), ...(c.dims === 2 && k.body?.shape === 'box' ? {shape: 'box'} : {}), radius: k.body?.radius ?? 0, ...(c.dims === 3 && k.body ? { shape: k.body.shape, height: k.body.height || 2 * k.body.radius } : {}), maxSpeed: k.body?.maxSpeed ?? 0, score: k.score, fields: k.fields.map(([name,field])=>[name,publicField(field)]), motion: k.motion, input: k.input })),
     effects: c.effects, effectNames: c.effectNames, commands: c.commands, shared: c.shared, rounds: c.rounds, settings: c.settings,
   };
 }

package/rules/view.ts

@@ -1,4 +1,4 @@
-import { disposeMoveContext } from './math.ts';
+import { disposeMoveContext, sweepMap } from './math.ts';
 import { boundPosition, periodicDelta, blendPosition, relativePoint, wrapPoint } from './topology.mjs';
 import { rayQuery, raySnapshot, type QueryTarget } from './query.ts';
 import { solidAt } from './collision.ts';
@@ -422,6 +422,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     mine = { id: u.id, kind: u.kind, r: u.r, pos: u.pos, vel: u.vel, heading: u.heading, grounded: u.grounded, motion: motionOf(u.kind, u.motion), fields: predictors[u.kind] ? thawFields(kindOf.get(u.kind)?.fields ?? [], u.fields) : u.fields };
   }
   /** The game's guarded `move` for one tick, counted as the server counts it, with the result rounded as the server rounds it. */
+  const substepKinds = new Set<string>();
   function runMove(kindName: string, body: { pos: Vec3; vel: Vec3; heading: Vec3; grounded: boolean; motion: Record<string, unknown> }, input: Readonly<Record<string, unknown>>, t: number): typeof body & {steps?: readonly import('./substeps.ts').StepPose[]} {
     const fn = moves[kindName];
     if (!fn || (kindOf.get(kindName)?.control && !body.motion[kindOf.get(kindName)!.control!])) return body;
@@ -430,6 +431,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // quota. Authority debits projection once per tick, not once per mover.
     geometryAt();
     const out = stepMove(fn, body, input, moveCtx, Math.max(1, Math.floor(schema.settings.budget.tick / 4)), kindOf.get(kindName)?.motion ?? [], dims, (err) => { if (!(err instanceof BudgetError)) console.warn('[room] move', err); });
+    if (out.steps?.length) substepKinds.add(kindName);
     const kind = kindOf.get(kindName), r = kind?.radius ?? 0;
     const height = kind?.height || 2 * r;
     out.pos = vec3(boundPosition(out.pos,map,r,height,dims), dims);
@@ -930,6 +932,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     const kind = kindOf.get(mine.kind);
     if (kind?.control && !server.motion[kind.control]) return entityOf(server, true);
     let pos = mine.pos;
+    let safeOrigin = mine.pos;
     let heading = mine.heading;
     let velocity = mine.vel, grounded = mine.grounded, motion = mine.motion;
     let settled = true;
@@ -940,7 +943,9 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       // A held field previews as its mean over the part of the tick that has passed. The body is drawn that fraction of
       // the way to the preview, so it stands exactly where the control has carried it: it starts from rest at a press
       // and stops dead at a release, with nothing to blend away afterwards.
-      for (const [name, fd] of kind.input) now[name] = (fd.t === 'press' || fd.t === 'pulse') ? (pressed.get(name) ?? (fd.t === 'pulse' && pulseQueue[0]?.name===name ? pulseQueue[0].value : fd.t === 'press' ? false : 0)) : fd.t === 'held' ? coerce(fd, heldMean(name, fd.init, Math.min(clock(), edgeOf(stepped + 1)), false), dims) : coerce(fd, sample[name] ?? fd.init, dims);
+      // A recorded substep path needs the whole tick's forecast instead: include
+      // the remaining duration of controls held now, then sample its actual steps.
+      for (const [name, fd] of kind.input) now[name] = (fd.t === 'press' || fd.t === 'pulse') ? (pressed.get(name) ?? (fd.t === 'pulse' && pulseQueue[0]?.name===name ? pulseQueue[0].value : fd.t === 'press' ? false : 0)) : fd.t === 'held' ? coerce(fd, heldMean(name, fd.init, Math.min(clock(), edgeOf(stepped + 1)), false, substepKinds.has(kind.name) ? edgeOf(stepped + 1) : Math.min(clock(), edgeOf(stepped + 1))), dims) : coerce(fd, sample[name] ?? fd.init, dims);
       const next = runMove(kind.name, { pos: mine.pos, vel: mine.vel, heading: mine.heading, grounded: mine.grounded, motion: motionOf(mine.kind, mine.motion) }, Object.freeze(now), stepped + 1);
       // A landing does not take the whole tick (0.46.5): the body met the ground part way through it. How far through is
       // read from the fall it would have made at the speed it entered the tick with; it is drawn down to the ground by
@@ -958,6 +963,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       if (next.steps?.length) {
         const n = next.steps.length - 1, at = a * n, index = Math.min(n - 1, Math.floor(at)), f = at - index;
         const before = next.steps[index], after = next.steps[index + 1];
+        safeOrigin = before.pos;
         pos = vec3(blendPosition(before.pos, after.pos, f, map.wrap), dims);
         heading = blendHeading(before.heading, after.heading, f, dims);
         velocity = vec3({x:lerp(before.vel.x,after.vel.x,f),y:lerp(before.vel.y,after.vel.y,f),z:lerp(before.vel.z,after.vel.z,f)},dims);
@@ -979,14 +985,25 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
         // Catch-up can reach the fractional current tick before its next whole step exists.
         // Use the normal drawing preview, including its 3D pose, instead of holding then jumping.
         const t = Math.floor(catchTick), a = history.get(t), b = history.get(t + 1) ?? (t === stepped ? preview : null);
-        if (a && b) { const f = catchTick - t; pos = blendPosition(a.pos, b.pos, f, map.wrap); heading = blendHeading(a.heading, b.heading, f, dims);
+        if (a && b) { safeOrigin = a.pos; const f = catchTick - t; pos = blendPosition(a.pos, b.pos, f, map.wrap); heading = blendHeading(a.heading, b.heading, f, dims);
           velocity = vec3({ x: lerp(a.vel.x, b.vel.x, f), y: lerp(a.vel.y, b.vel.y, f), z: lerp(a.vel.z, b.vel.z, f) }, dims);
           grounded = a.grounded && (f === 0 || b.grounded); motion = a.motion;
-        } else if (a) { pos = a.pos; heading = a.heading; velocity = a.vel; grounded = a.grounded; motion = a.motion; }
+        } else if (a) { safeOrigin = a.pos; pos = a.pos; heading = a.heading; velocity = a.vel; grounded = a.grounded; motion = a.motion; }
       }
     }
+    // Two-dimensional presentation follows collision too: interpolation and reconciliation are not
+    // permission to cross a floor. Sweep from a valid movement pose, never feed
+    // the clipped drawing back into prediction or authority.
+    const constrain = (from: Vec3, to: Vec3): Vec3 => {
+      if (dims !== 2 || !kind || kind.owner) return to;
+      const body = {pos: from};
+      sweepMap(geometryAt(), body, {x:periodicDelta(from.x,to.x,map.wrap?.x),y:periodicDelta(from.y,to.y,map.wrap?.y),z:periodicDelta(from.z,to.z,map.wrap?.z)}, kind.radius, dims,
+        {shape:kind.shape ?? 'circle',radius:kind.radius,height:kind.height || 2*kind.radius,terrain:kind.terrain});
+      return body.pos;
+    };
+    pos = constrain(safeOrigin, pos);
     const offset = visualOffset(clock(), pos, settled);
-    pos = wrapPoint({ x: pos.x + offset.x, y: pos.y + offset.y, z: pos.z + offset.z },map.wrap);
+    pos = constrain(pos, wrapPoint({ x: pos.x + offset.x, y: pos.y + offset.y, z: pos.z + offset.z },map.wrap));
     if (headingBlend) {
       const t = predict.blendMs > 0 ? Math.min(1, (clock() - headingBlend.at) / predict.blendMs) : 1;
       heading = blendHeading(headingBlend.from, heading, t, dims);

package/worker/build-id.mjs

@@ -1,2 +1,2 @@
 // Generated by lib/build-identity.mjs; identifies the bundled runtime sources.
-export const STUDIO_BUILD = Object.freeze({"version":"0.50.1","sha256":"0ff5d7cf032cfcbfd6fa3a787c60055eadce37a46fd8f7fc09c33e073310d6ae"});
+export const STUDIO_BUILD = Object.freeze({"version":"0.50.2","sha256":"b5a5e460524fdf3585639ef1296b5e6cc9e0596e6f13da493d9a2e6938271ca4"});

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.50.1';
+export const STUDIO_VERSION_TAG = '0.50.2';