@homie-rocks/studio 0.38.0 → 0.40.0

package/lib/tools-cli.mjs

@@ -0,0 +1,55 @@
+import {existsSync,mkdirSync,writeFileSync,readFileSync,chmodSync} from 'node:fs';
+import {join,dirname} from 'node:path';
+import {createServer} from 'node:http';
+import {randomUUID} from 'node:crypto';
+import {spawn} from 'node:child_process';
+export function newTool(root,name,{app=null}={}) {
+  if(!/^[a-z][a-z0-9-]{0,39}$/.test(name??'') || app!==null&&!/^[a-z][a-z0-9-]{0,39}$/.test(app))throw new Error('name uses lowercase letters, numbers and hyphens');
+  if(app&&!existsSync(join(root,'apps',app,'app.json')))throw new Error('unknown app');
+  const file=join(root,...(app?['apps',app,'tools']:['tools']),name+'.ts');if(existsSync(file))throw new Error('tool already exists');
+  mkdirSync(dirname(file),{recursive:true});writeFileSync(file,`import { defineTool } from '@homie-rocks/studio/tools';\n\nexport default defineTool<{ message: string }>({\n  name: '${name.replaceAll('-','_')}',\n  description: 'Describe what this tool does and when to use it.',\n  audience: ${app?JSON.stringify({app,role:'staff'}):"'owner'"},\n  inputSchema: { type: 'object', properties: { message: { type: 'string', maxLength: 200 } }, required: ['message'], additionalProperties: false },\n  async handler({ message }, context) {\n    return { message, by: context.caller.id };\n  },\n});\n`);
+  return {ok:true,command:'tool new',file,next:'Edit the definition, then homie-studio dev. Call it with homie-studio tool call '+name.replaceAll('-','_')+' --input \'{"message":"Hello"}\' --url http://localhost:8787'};
+}
+/** The official SDK owns discovery, registration, PKCE, refresh and issuer checks. */
+export async function connectToolClient(root,site,{publicOnly=false,open=defaultOpen,log=()=>{}}={}) {
+  const {Client,StreamableHTTPClientTransport,auth}=await import('mcp-studio-client');
+  const url=new URL('/mcp',site);if(url.protocol!=='https:'&&!['localhost','127.0.0.1','[::1]'].includes(url.hostname))throw new Error('Use HTTPS, or localhost for local development');
+  const client=new Client({name:'Homie studio tool CLI',version:'1.0.0'});
+  if(publicOnly){await client.connect(new StreamableHTTPClientTransport(url));return client;}
+  const file=join(root,'.studio','mcp',Buffer.from(url.origin).toString('base64url')+'.json');
+  let state={};try{state=JSON.parse(readFileSync(file,'utf8'));}catch{}
+  // Credentials without an issuer predate the SDK's OAuth binding fix; reconnect safely.
+  if((state.tokens&&!state.tokens.issuer)||(state.client&&!state.client.issuer))state={};
+  const save=()=>{mkdirSync(dirname(file),{recursive:true});writeFileSync(file,JSON.stringify(state),{mode:0o600});chmodSync(file,0o600);};
+  let accept;const returned=new Promise(resolve=>{accept=resolve;});
+  const csrf=randomUUID();
+  const server=createServer((req,res)=>{const back=new URL(req.url,'http://localhost');if(back.pathname!=='/callback'||back.searchParams.get('state')!==csrf){res.writeHead(400);res.end('Invalid callback');return;}res.end('Your AI is connected. You can close this tab.');accept(back);});
+  await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));
+  const redirect=`http://127.0.0.1:${server.address().port}/callback`;
+  const provider={redirectUrl:redirect,clientMetadata:{client_name:'Homie studio tool CLI',redirect_uris:[redirect],grant_types:['authorization_code','refresh_token'],response_types:['code'],token_endpoint_auth_method:'none'},state:()=>csrf,
+    clientInformation:()=>state.client,saveClientInformation:v=>{state.client=v;save();},tokens:()=>state.tokens,saveTokens:v=>{state.tokens=v;save();},
+    codeVerifier:()=>state.verifier,saveCodeVerifier:v=>{state.verifier=v;save();},
+    discoveryState:()=>state.discovery,saveDiscoveryState:v=>{state.discovery=v;save();},
+    invalidateCredentials:scope=>{if(scope==='all')state={};else {delete state[scope==='tokens'?'tokens':scope];if(scope==='tokens')delete state.client;}save();},
+    redirectToAuthorization:async u=>{log('Approve this connection in your browser.');await open(u.href);},
+  };
+  try{
+    // A new loopback port needs a matching registered redirect; refresh still uses the prior client.
+    if(!state.tokens){delete state.client;delete state.discovery;}
+    const result=await auth(provider,{serverUrl:url,scope:'studio offline_access'});
+    if(result==='REDIRECT'){
+      let timer;const timeout=new Promise((_,reject)=>{timer=setTimeout(()=>reject(new Error('Browser approval timed out')),300000);});
+      const back=await Promise.race([returned,timeout]).finally(()=>clearTimeout(timer));
+      if(back.searchParams.has('error'))throw new Error('Connection declined');
+      await auth(provider,{serverUrl:url,authorizationCode:back.searchParams.get('code'),iss:back.searchParams.get('iss')??undefined});
+    }
+    await client.connect(new StreamableHTTPClientTransport(url,{authProvider:provider}));return client;
+  }finally{server.close();}
+}
+function defaultOpen(url){const cmd=process.platform==='darwin'?'open':process.platform==='win32'?'explorer':'xdg-open';const child=spawn(cmd,[url],{stdio:'ignore',detached:true});child.unref();}
+export async function toolCommand(root,sub,positional,flags,{log=()=>{}}={}) {
+  if(sub==='new')return newTool(root,positional[2],{app:flags.get('app')??null});
+  if(!['call','list'].includes(sub))throw new Error('Use tool new <name>, tool list, or tool call <name> --input <JSON>');
+  const client=await connectToolClient(root,flags.get('url')??'http://localhost:8787',{publicOnly:flags.has('public'),log});
+  try{const result=sub==='list'?await client.listTools():await client.callTool({name:positional[2],arguments:JSON.parse(flags.get('input')??'{}')});return {ok:result.isError!==true,command:'tool '+sub,result,...(result.isError?{why:'The tool refused or failed; see its result.'}:{})};}finally{await client.close();}
+}

package/lib/worker-build.mjs

@@ -0,0 +1,35 @@
+import {existsSync,mkdirSync,readFileSync,writeFileSync,rmSync} from 'node:fs';
+import {join,relative,dirname} from 'node:path';
+import {readConfig} from './routes.mjs';
+import {paidReleases} from './parts-upload.mjs';
+import {configPath} from './studio.mjs';
+/** Preserve dynamic imports as real Worker modules: page startup never evaluates MCP libraries. */
+export async function buildWorker(root,esbuild) {
+  const source=join(root,'site/src/worker.mjs');if(!existsSync(source))return;
+  const out=join(root,'site/src/runtime');
+  const alias={...(readConfig(root)?.alias??{})};
+  if(paidReleases(root).length)alias['@homie-rocks/studio/worker']='@homie-rocks/studio/worker/selling';
+  const result=await esbuild.build({entryPoints:[source],absWorkingDir:root,alias,outdir:out,bundle:true,splitting:true,format:'esm',platform:'browser',mainFields:['module','main'],conditions:['workerd','worker','browser'],external:['node:*','cloudflare:*'],target:'es2022',write:false,minify:true,metafile:true,logLevel:'silent'});
+  rmSync(out,{recursive:true,force:true});
+  mkdirSync(out,{recursive:true});
+  for(const file of result.outputFiles)writeFileSync(file.path,file.contents);
+  const config=configPath(root);
+  if(existsSync(config)){
+    const original=readFileSync(config,'utf8');
+    const json=JSON.parse(original.replace(/^\s*\/\/.*$/gm,''));
+    const before=JSON.stringify(json);
+    json.main=relative(dirname(config),join(out,'worker.js')).split('\\').join('/');
+    json.no_bundle=true;json.find_additional_modules=true;
+    json.rules=[...(json.rules??[]).filter(r=>!r.homieMcp),{type:'ESModule',globs:['**/*.js'],fallthrough:true}];
+    // No duplicate rule on rebuild.
+    json.rules=json.rules.filter((r,i,all)=>all.findIndex(x=>JSON.stringify(x)===JSON.stringify(r))===i);
+    json.compatibility_flags=[...new Set([...(json.compatibility_flags??[]),'nodejs_compat'])];
+    if(JSON.stringify(json)!==before) {
+      const comments=original.match(/^(?:\s*\/\/[^\n]*\n)*/)?.[0]??'';
+      writeFileSync(config,comments+JSON.stringify(json,null,2)+'\n');
+    }
+  }
+  const sizes=Object.entries(result.metafile.outputs).map(([path,value])=>({path:relative(root,path),bytes:value.bytes,imports:value.imports}));
+  writeFileSync(join(out,'modules.json'),JSON.stringify(sizes,null,2)+'\n');
+  return sizes;
+}

package/netplay/NETPLAY.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), a site with the hub's sections (Home, Games, Music, Videos, Rooms, Posts with feeds) in the studio's own look, an epic landing page for every game, big songs and videos in the studio's own R2 once it has storage (uploaded, checked by SHA-256, served at the same addresses), deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",
@@ -84,7 +84,11 @@
       "types": "./apps/apps.ts",
       "default": "./apps/apps.ts"
     },
-    "./worker/selling": "./worker/selling/index.mjs"
+    "./worker/selling": "./worker/selling/index.mjs",
+    "./tools": {
+      "types": "./tools/tools.ts",
+      "default": "./tools/tools.ts"
+    }
   },
   "files": [
     "bin/",
@@ -111,7 +115,8 @@
     "NOTICE",
     "links/",
     "apps/",
-    "app-starters/"
+    "app-starters/",
+    "tools/"
   ],
   "engines": {
     "node": ">=22"
@@ -122,17 +127,22 @@
     "@babel/parser": "8.0.7",
     "@babel/traverse": "8.0.7",
     "@babel/types": "8.0.6",
+    "@cloudflare/workers-oauth-provider": "1.2.3",
     "@coinbase/x402": "2.1.0",
     "@gltf-transform/core": "4.5.1",
     "@gltf-transform/extensions": "4.5.1",
     "@gltf-transform/functions": "4.5.1",
     "@jridgewell/trace-mapping": "0.3.31",
-    "@modelcontextprotocol/sdk": "1.32.1",
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "@modelcontextprotocol/server": "2.0.0",
     "@x402/core": "2.28.0",
     "@x402/evm": "2.28.0",
+    "agents": "0.28.0",
     "esbuild": "0.28.1",
     "gltf-validator": "2.0.0-dev.3.10",
     "jose": "6.2.12",
+    "mcp-purchase-sdk": "npm:@modelcontextprotocol/sdk@1.32.1",
+    "mcp-studio-client": "npm:@modelcontextprotocol/client@2.3.1",
     "meshoptimizer": "1.3.0",
     "mppx": "0.13.2",
     "puppeteer-core": "25.8.0",
@@ -140,10 +150,11 @@
     "spdx-expression-parse": "5.0.0",
     "stripe": "23.0.0",
     "three": "0.185.1",
+    "typescript": "5.9.3",
     "viem": "2.57.4",
-    "typescript": "5.9.3"
+    "zod": "4.3.6"
   },
   "scripts": {
-    "test": "node --test test/*.test.mjs"
+    "test": "node --test --test-concurrency=2 --test-timeout=1800000 test/*.test.mjs"
   }
 }

package/rules/collision.ts

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

package/rules/core.ts

@@ -38,6 +38,7 @@
  * that is held to its shape, and paid for, before the handler's budget is closed.
  * =============================================================================
  */
+import { castMap3, castSolid, restsOnMap, solidAt, type BodyShape, type Hit3 } from './collision.ts';
 import { argsWhy, type Vocabulary } from '../agents/agents.ts';
 import { BudgetError, G, brand, charge, deepFreeze, plainData } from './guard.ts';
 import { SKIN, castMap, exact, math, rayCircle, sweepMap } from './math.ts';
@@ -88,7 +89,7 @@ export type CoreOut =
   | { t: 'shared' }
   | { t: 'epoch'; epoch: number }
   | { t: 'fail'; why: 'budget'; kind: string; handler: string };
-export interface CorePolicy { reserved?: number; bots: 'fill' | 'off'; level: number; levelMax: number }
+export interface CorePolicy { kids?: boolean; levelSet?: boolean; guideLevel?: number; guideSeats?: readonly number[]; reserved?: number; bots: 'fill' | 'off'; level: number; levelMax: number }
 export interface Body { seat: number; id: string; kind: string; driver: Driver; owner: string; away: boolean; score: number; r: number }
 
 interface Ent {
@@ -178,7 +179,6 @@ export interface Core {
  * `Adjusted`; also `effect`, `think` and `decision`): the handler, what was done, the field's name and what was written.
  */
 export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: number, input: Readonly<Record<string, unknown>>, before: import('./pack.ts').MoveBody, after: import('./pack.ts').MoveBody) => void; observe?: (kind: string, handler: string, error?: string) => void; noted?: (kind: string, handler: string, what: string, at: string, written: string) => void; seed?: number; epoch?: number; restore?: SavedCore | null; restoreEpoch?: number; stage?: string; decisions?: boolean } = {}): Core {
-  if (c.dims !== 2) throw new Error('this release runs rules with space.dims: 2; bodies with height (dims: 3) arrive in a later one');
   const dims = c.dims;
   const tickHz = c.settings.tickHz;
   const dt = 1 / tickHz;
@@ -212,11 +212,13 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
   let vocabulary: Vocabulary | null = null;
   const restoredGoals = new Map<number, unknown>();
   const guideViews = new Map<number, Record<string, unknown>>();
+  const EMPTY_GUIDE_SEATS: readonly number[] = Object.freeze([]);
   let policy: CorePolicy = { reserved: 0, bots: 'fill', level: 3, levelMax: 5 };
   function normalizeCorePolicy(p: Partial<CorePolicy>): CorePolicy {
     const levelMax = Math.max(1, Math.min(5, Math.floor(num(own(p, 'levelMax') ?? policy.levelMax)) || 5));
+    const guideSeats = Object.freeze([...new Set(p.guideSeats ?? policy.guideSeats ?? [])].filter(seat => Number.isInteger(seat) && seat >= 0 && seat < c.seats).sort((a, b) => a - b));
     // The keys in the order the room starts with them: a save is compared byte for byte with the save of the room rebuilt from it.
-    return { reserved: Math.max(0, Math.min(c.seats - 1, Math.floor(num(own(p, 'reserved') ?? policy.reserved)) || 0)), bots: p.bots === 'off' ? 'off' : p.bots === 'fill' ? 'fill' : policy.bots, level: Math.max(1, Math.min(levelMax, Math.floor(num(own(p, 'level') ?? policy.level)) || 3)), levelMax };
+    return { reserved: Math.max(0, Math.min(c.seats - 1, Math.floor(num(own(p, 'reserved') ?? policy.reserved)) || 0)), bots: p.bots === 'off' ? 'off' : p.bots === 'fill' ? 'fill' : policy.bots, level: Math.max(1, Math.min(levelMax, Math.floor(num(own(p, 'level') ?? policy.level)) || 3)), levelMax, ...((p.kids ?? policy.kids) ? { kids: true } : {}), ...((p.levelSet ?? policy.levelSet) ? { levelSet: true } : {}), ...((p.guideLevel ?? policy.guideLevel) !== undefined ? { guideLevel: Math.max(1, Math.min(levelMax, Math.floor(num(p.guideLevel ?? policy.guideLevel)) || 3)) } : {}), ...(guideSeats.length ? { guideSeats } : {}) };
   }
   let shared: Record<string, unknown> = initFields(c.shared, dims);
   let sharedRO: Readonly<Record<string, unknown>> = Object.freeze({});
@@ -342,7 +344,7 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     naming(kind.name, 'fields'); const f = coerceFields(kind.fields, init.fields, dims);
     naming(kind.name, 'motion'); const m = coerceFields(kind.motion, init.motion, dims); naming();
     const e: Ent = {
-      id: `e${n.toString(36)}`, n, kind, pos: clampIn(V(at), kind.body?.radius ?? 0), vel: ZERO, heading: init.heading === undefined ? AHEAD : dir(init.heading, dims), grounded: true,
+      id: `e${n.toString(36)}`, n, kind, pos: clampIn(V(at), kind.body?.radius ?? 0, kind.body ? kind.body.height || 2 * kind.body.radius : 0), vel: ZERO, heading: init.heading === undefined ? AHEAD : dir(init.heading, dims), grounded: dims === 2 || restsOnMap(c.map, clampIn(V(at), kind.body?.radius ?? 0, kind.body ? kind.body.height || 2 * kind.body.radius : 0), kind.body ?? { shape: 'sphere', radius: 0, height: 0 }),
       r: 0, born: tick, arrived: false, why, dead: false,
       f, m,
       seat: player ? player.seat : -1, owner: player ? player.owner : '', driver: player ? player.driver : 'bot', away: false, goal: null,
@@ -351,10 +353,11 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     makeSelf(e);
     return e;
   }
-  function clampIn(p: Vec3, r: number): Vec3 {
+  function clampIn(p: Vec3, r: number, height = 0): Vec3 {
     const b = c.map.bounds;
     const x = Math.max(b.min.x + r, Math.min(b.max.x - r, p.x)); const y = Math.max(b.min.y + r, Math.min(b.max.y - r, p.y));
-    return x === p.x && y === p.y ? p : V({ x, y, z: p.z });
+    const z = dims === 3 ? Math.max(b.min.z, Math.min(b.max.z - height, p.z)) : 0;
+    return x === p.x && y === p.y && z === p.z ? p : V({ x, y, z });
   }
 
   /* ---------------------------------------------------------------- running a handler under the budget */
@@ -475,9 +478,19 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     return sharedRO;
   };
 
+  function cast3(p: Vec3, d: Vec3, shape: BodyShape, ignored: Set<string>): Hit3 | null {
+    let best = castMap3(c.map, p, d, shape);
+    const solid = solidAt(p, shape);
+    for (const other of ents.values()) {
+      if (!other.kind.body || ignored.has(other.id)) continue;
+      const hit = castSolid(solid, d, solidAt(other.pos, other.kind.body));
+      if (hit && (!best || hit.t < best.t)) best = { ...hit, id: other.id };
+    }
+    return best;
+  }
   const world = brand({} as Record<string, unknown>);
   const getters: Record<string, () => unknown> = {
-    tick: () => tick, dt: () => dt, round: () => roundApi, shared: sharedView, level: () => policy.level, levelMax: () => policy.levelMax,
+    tick: () => tick, dt: () => dt, round: () => roundApi, shared: sharedView, level: () => policy.level, levelMax: () => policy.levelMax, guideLevel: () => policy.guideLevel ?? policy.level, guideSeats: () => policy.guideSeats ?? EMPTY_GUIDE_SEATS, kids: () => Boolean(policy.kids), levelSet: () => Boolean(policy.levelSet),
     stage: () => stage, tune: () => c.tune, math: () => math, map: () => mapApi,
   };
   for (const [name, get] of Object.entries(getters)) Object.defineProperty(world, name, { get, enumerable: true });
@@ -558,9 +571,10 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
       charge(10 + 12 * COPY);
       const e = mine(self, 'world.place');
       const vel = own(o, 'vel'); const heading = own(o, 'heading');
-      e.pos = clampIn(V(at), e.kind.body?.radius ?? 0);
+      e.pos = clampIn(V(at), e.kind.body?.radius ?? 0, e.kind.body ? e.kind.body.height || 2 * e.kind.body.radius : 0);
       e.vel = vel !== undefined ? V(vel) : ZERO;
       if (heading !== undefined) e.heading = dir(heading, dims);
+      e.grounded = dims === 2 || restsOnMap(c.map, e.pos, e.kind.body ?? { shape: 'sphere', radius: 0, height: 0 });
       e.r = (e.r + 1) & 0xffff;
       e.allow = 0;
     },
@@ -572,7 +586,8 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
       for (const e of ents.values()) {
         if (k && e.kind !== k) continue;
         const dx = e.pos.x - p.x; const dy = e.pos.y - p.y;
-        const d2 = dx * dx + dy * dy;
+        const dz = dims === 3 ? e.pos.z - p.z : 0;
+        const d2 = dx * dx + dy * dy + dz * dz;
         if (d2 <= R * R) { found.push({ d: d2, e }); cost += viewCost.get(e.kind) as number; }
       }
       // Sorting them and handing each out is charged before either is done.
@@ -583,10 +598,10 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     inBox: (box: unknown, kind?: unknown): readonly unknown[] => {
       charge(20 + 2 * ents.size);
       const min = V(own(box, 'min')); const max = V(own(box, 'max')); const k = kindFilter(kind);
-      if (max.x - min.x > 2 * REACH_M || max.y - min.y > 2 * REACH_M) throw new Error(`world.inBox reaches ${REACH_M} m from its centre at most`);
+      if (max.x - min.x > 2 * REACH_M || max.y - min.y > 2 * REACH_M || dims === 3 && max.z - min.z > 2 * REACH_M) throw new Error(`world.inBox reaches ${REACH_M} m from its centre at most`);
       const found: Ent[] = [];
       let cost = 0;
-      for (const e of ents.values()) if ((!k || e.kind === k) && e.pos.x >= min.x && e.pos.x <= max.x && e.pos.y >= min.y && e.pos.y <= max.y) { found.push(e); cost += viewCost.get(e.kind) as number; }
+      for (const e of ents.values()) if ((!k || e.kind === k) && e.pos.x >= min.x && e.pos.x <= max.x && e.pos.y >= min.y && e.pos.y <= max.y && (dims === 2 || e.pos.z >= min.z && e.pos.z <= max.z)) { found.push(e); cost += viewCost.get(e.kind) as number; }
       charge(cost);
       return Object.freeze(found.map(viewOf));
     },
@@ -594,6 +609,11 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
       // 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));
       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 };
+        const hit = cast3(p, delta, { shape: 'sphere', radius: 0, height: 0 }, new Set(cx.ent ? [cx.ent.id] : []));
+        return hit ? Object.freeze({ ...(hit.id ? { entity: hit.id } : {}), at: V({ x: p.x + delta.x * hit.t, y: p.y + delta.y * hit.t, z: p.z + delta.z * hit.t }), normal: V({ x: hit.nx, y: hit.ny, z: hit.nz }), dist: far * hit.t }) : undefined;
+      }
       const cast = castMap(c.map, p.x, p.y, d.x * far, d.y * far, 0);
       let best: Hit | null = cast.hit;
       for (const e of ents.values()) {
@@ -609,12 +629,23 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
       charge(20 + 4 * (mapShapes + ents.size));
       const d = V(delta);
       const radius = e.kind.body?.radius ?? 0;
-      const cast = castMap(c.map, e.pos.x, e.pos.y, d.x, d.y, radius);
-      let best: Hit | null = cast.hit;
       // 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.
       const list = own(o, 'ignore');
       const ignore = new Set<string>();
       if (Array.isArray(list)) for (let i = 0; i < list.length && i < IGNORE_MAX; i += 1) { const id = own(list, i); if (typeof id === 'string') ignore.add(id); }
+      if (dims === 3) {
+        ignore.add(e.id);
+        const shape = e.kind.body ?? { shape: 'sphere', radius: 0, height: 0 };
+        const hit = cast3(e.pos, d, shape, ignore);
+        const length = Math.sqrt(d.x * d.x + d.y * d.y + d.z * d.z);
+        const t = hit ? Math.max(0, hit.t - (length > 0 ? SKIN / length : 0)) : 1;
+        e.pos = V({ x: e.pos.x + d.x * t, y: e.pos.y + d.y * t, z: e.pos.z + d.z * t });
+        const support = cast3(e.pos, { x: 0, y: 0, z: -2 * SKIN }, shape, ignore);
+        e.grounded = Boolean(support && support.nz > 0.5);
+        return hit ? Object.freeze({ ...(hit.id ? { entity: hit.id } : {}), at: e.pos, normal: V({ x: hit.nx, y: hit.ny, z: hit.nz }) }) : undefined;
+      }
+      const cast = castMap(c.map, e.pos.x, e.pos.y, d.x, d.y, radius);
+      let best: Hit | null = cast.hit;
       for (const other of ents.values()) {
         if (other === e || !other.kind.body || ignore.has(other.id)) continue;
         const h = rayCircle(e.pos.x, e.pos.y, d.x, d.y, other.pos.x, other.pos.y, other.kind.body.radius + radius);
@@ -647,8 +678,9 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
   });
   Object.freeze(world);
 
-  const moveMap = brand(Object.freeze({ name: c.map.name, spot: mapApi.spot, spots: mapApi.spots, sweep: (body: unknown, delta: unknown): unknown => sweepMap(c.map, body, delta, moveRadius, dims) }));
+  const moveMap = brand(Object.freeze({ name: c.map.name, spot: mapApi.spot, spots: mapApi.spots, sweep: (body: unknown, delta: unknown): unknown => sweepMap(c.map, body, delta, moveRadius, dims, moveShape) }));
   let moveRadius = 0;
+  let moveShape = { shape: 'sphere', radius: 0, height: 0 };
   const moveCtx = brand({} as Record<string, unknown>);
   for (const [name, get] of Object.entries({ tick: () => tick, dt: () => dt, tune: () => c.publicTune, math: () => math, map: () => moveMap })) Object.defineProperty(moveCtx, name, { get, enumerable: true });
   Object.assign(moveCtx, { ticks: (seconds: unknown): number => { charge(1); return ticks(seconds); } });
@@ -887,14 +919,15 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
   /* ---------------------------------------------------------------- one tick */
 
   function inArea(a: any, p: Vec3): boolean {
-    if (a.k === 'b') return p.x >= a.min.x && p.x <= a.max.x && p.y >= a.min.y && p.y <= a.max.y;
+    if (a.k === 'b') return p.x >= a.min.x && p.x <= a.max.x && p.y >= a.min.y && p.y <= a.max.y && (dims === 2 || p.z >= a.min.z && p.z <= a.max.z);
     const dx = p.x - a.at.x; const dy = p.y - a.at.y;
-    const d2 = dx * dx + dy * dy;
+    const dz = dims === 3 ? p.z - a.at.z : 0;
+    const d2 = dx * dx + dy * dy + dz * dz;
     if (d2 > a.r * a.r) return false;
     if (a.k === 's' || d2 === 0) return true;
     const l = Math.sqrt(d2);
     // Inside the cone: the angle to its axis is at most half its opening, compared by cosine.
-    return (dx * a.dir.x + dy * a.dir.y) / l >= exact.cos(a.half);
+    return (dx * a.dir.x + dy * a.dir.y + dz * a.dir.z) / l >= exact.cos(a.half);
   }
   function step(inputs: ReadonlyMap<number, StepInput> = new Map(), guides?: () => void): void {
     tick = (tick + 1) >>> 0;
@@ -992,10 +1025,14 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
               // The browser ran the game's own `move` and came further than `maxSpeed` allows: the body is held back.
               if (go < dist) stats.held += 1;
               e.allow -= go;
-              if (dist > 0) e.pos = clampIn(V({ x: e.pos.x + (dx / dist) * go, y: e.pos.y + (dy / dist) * go, z: 0 }), body.radius);
+              e.pos = clampIn(V({ x: e.pos.x + (dist > 0 ? (dx / dist) * go : 0), y: e.pos.y + (dist > 0 ? (dy / dist) * go : 0), z: dims === 3 ? claim.pos.z : 0 }), body.radius, body.height || 2 * body.radius);
               const sp = Math.sqrt(claim.vel.x * claim.vel.x + claim.vel.y * claim.vel.y);
-              e.vel = sp > body.maxSpeed && sp > 0 ? V({ x: (claim.vel.x / sp) * body.maxSpeed, y: (claim.vel.y / sp) * body.maxSpeed, z: 0 }) : V(claim.vel);
+              e.vel = sp > body.maxSpeed && sp > 0 ? V({ x: (claim.vel.x / sp) * body.maxSpeed, y: (claim.vel.y / sp) * body.maxSpeed, z: claim.vel.z }) : V(claim.vel);
               e.heading = dir(claim.heading, dims);
+              e.grounded = dims === 2;
+              // The support cast is map work even when a browser supplies the pose.
+              // Keep it under the same movement quota as a server-driven body's sweep.
+              if (dims === 3) run(k.name, 'move', e, 'move', () => { e.grounded = restsOnMap(c.map, e.pos, body); }, 'body');
             }
             continue;
           }
@@ -1003,13 +1040,13 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
         if (!k.move) continue;
         const b = { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: e.mself };
         const beforeMove = opts.moved ? { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: { ...e.m } } : null;
-        moveRadius = body.radius;
+        moveRadius = body.radius; moveShape = body;
         run(k.name, 'move', e, 'move', () => (k.move as NonNullable<KindTable['move']>)(b, e.input, moveCtx), 'body');
         // The runtime rounds to 32-bit floats, here and in the browser, so both step from exactly the same numbers.
         // `b` is the runtime's own object: what `move` left in it is read by its own data properties and cannot throw.
         // (A listener hears of a position that was not a number here too, as `move`'s.)
         if (noted) G.note = (what, at, written) => noted(k.name, 'move', what, at, written);
-        naming('body', 'pos'); e.pos = clampIn(V(own(b, 'pos')), body.radius); naming('body', 'vel'); e.vel = V(own(b, 'vel')); naming('body', 'heading'); e.heading = dir(own(b, 'heading'), dims); naming();
+        naming('body', 'pos'); e.pos = clampIn(V(own(b, 'pos')), body.radius, body.height || 2 * body.radius); naming('body', 'vel'); e.vel = V(own(b, 'vel')); naming('body', 'heading'); e.heading = dir(own(b, 'heading'), dims); naming();
         G.note = null;
         e.grounded = own(b, 'grounded') === true;
         if (beforeMove) opts.moved!(k.name, tick, e.input, beforeMove, { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: { ...e.m } });
@@ -1128,7 +1165,10 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     const duration = r.round[1] === 1 ? ticks(c.rounds?.seconds ?? 0) : Math.max(3, ticks(c.rounds?.breakSeconds ?? 0));
     check(r.round[3] <= r.tick && r.round[2] <= r.tick + duration && !(r.round[1] === 1 && !duration && r.round[2] !== 0));
     check(r.policy && ['fill', 'off'].includes(r.policy.bots) && Number.isInteger(r.policy.level) && Number.isInteger(r.policy.levelMax) && r.policy.level >= 1 && r.policy.level <= r.policy.levelMax && r.policy.levelMax <= 5);
-    check(Object.keys(r.policy).every((key) => ['bots', 'level', 'levelMax', 'reserved'].includes(key)));
+    check(r.policy.guideLevel === undefined || Number.isInteger(r.policy.guideLevel) && r.policy.guideLevel >= 1 && r.policy.guideLevel <= r.policy.levelMax);
+    check(r.policy.guideSeats === undefined || Array.isArray(r.policy.guideSeats) && r.policy.guideSeats.length > 0 && r.policy.guideSeats.length <= c.seats && r.policy.guideSeats.every((seat, i, seats) => uint(seat) && seat < c.seats && (i === 0 || seat > seats[i - 1])));
+    check((r.policy.kids === undefined || r.policy.kids === true) && (r.policy.levelSet === undefined || r.policy.levelSet === true));
+    check(Object.keys(r.policy).every((key) => ['bots', 'level', 'levelMax', 'reserved', 'kids', 'levelSet', 'guideLevel', 'guideSeats'].includes(key)));
     check(r.policy.reserved === undefined || uint(r.policy.reserved) && r.policy.reserved < c.seats);
     fields(c.shared, r.shared);
     check(Array.isArray(r.ents) && Array.isArray(r.spawns) && r.ents.length + r.spawns.length <= ENTITY_MAX);
@@ -1147,7 +1187,7 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
       const goal = w[15] as any;
       if (goal !== null) check(goal && typeof goal === 'object' && !Array.isArray(goal) && Object.keys(goal).every(k => ['goal', 'args', 'from', 'at', 'asked', 'state'].includes(k)) && typeof goal.goal === 'string' && goal.args && typeof goal.args === 'object' && !Array.isArray(goal.args) && ['brain', 'floor'].includes(goal.from) && uint(goal.at) && goal.at <= r.tick && typeof goal.asked === 'boolean' && goal.state === 'active');
       const pos = unpackVec(w[7] as number[], 3), bounds = c.map.bounds;
-      check(pos.x >= bounds.min.x && pos.x <= bounds.max.x && pos.y >= bounds.min.y && pos.y <= bounds.max.y && pos.z === 0);
+      check(pos.x >= bounds.min.x && pos.x <= bounds.max.x && pos.y >= bounds.min.y && pos.y <= bounds.max.y && (dims === 3 ? pos.z >= bounds.min.z && pos.z <= bounds.max.z : pos.z === 0));
       check(Number.isInteger(w[11]) && (w[11] as number) >= -1 && (w[11] as number) < c.seats && ['person', 'bot', 'ai'].includes(w[12] as string) && typeof w[13] === 'string' && w[13].length <= 128);
       if (k.player) { check(!bodySeats.has(w[11])); bodySeats.add(w[11]); }
       fields(k.fields, w[17]); fields(k.motion, w[18]); fields(k.input, w[19]);
@@ -1327,8 +1367,8 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     snapshot: () => {
       packed.n = 0;
       const list = [...ents.values()].map((e) => packEntity(e.kind, e, dims));
-      // Ten values an entity for what every entity carries (its id, its place, its velocity and heading), and one for each value of its fields.
-      snapCells = packed.n + 10 * list.length;
+      // Include all three components of position, velocity and heading in a 3D snapshot.
+      snapCells = packed.n + (dims === 3 ? 13 : 10) * list.length;
       return [[round.n, round.phase === 'live' ? 1 : 0, round.endsAt], list];
     },
     shared: () => packFields(c.shared, shared, dims),