@homie-rocks/studio 0.45.2 → 0.46.0

package/rules/host.ts

@@ -47,7 +47,7 @@ import { AGENT_RULES, useAgents, type Agents, type AgentsSaved, type Vocabulary
 import { DEFAULT_POLICY, type Netplay, type Peer, type Policy, type Slot } from '../netplay/netplay.ts';
 import { createCore } from './core.ts';
 import type { Core, CoreOut, Driver, SavedCore, StepInput } from './core.ts';
-import { coerce, coerceFields, num, own, fromBytes, initFields, toBytes, unpackVec } from './pack.ts';
+import { coerce, coerceFields, num, own, fromBytes, initFields, toBytes, unpackVec, unpackFields } from './pack.ts';
 import type { Compiled, KindTable, Vec3 } from './rules.ts';
 
 export interface HostClock {
@@ -56,8 +56,13 @@ export interface HostClock {
   setTimer(fn: () => void, ms: number): unknown;
   clearTimer(handle: unknown): void;
 }
+export interface CharacterLease {
+  account: string; lease: number; seat: number; character: import('./rules.ts').Character | null; returning?: boolean;
+}
 export interface HostOptions {
   game: string;
+  record?(owner:string,key:string,value:Record<string,unknown>):void;
+  characterFor?(peer: Record<string, unknown>): CharacterLease | null;
   /** The build check compares a movement step before any tick handler can change it. */
   moved?: NonNullable<Parameters<typeof createCore>[1]>['moved'];
   /** Told of every handler as it ends, and what it threw if it threw (core.ts `observe`): the build check listens. */
@@ -73,7 +78,7 @@ export interface HostOptions {
   send(frame: Record<string, unknown>, text?: string): void;
   clock: HostClock;
   /** Synchronous save: the caller's storage output gate holds this tick's outgoing frames until confirmed. */
-  store?: { save(bytes: Uint8Array): void };
+  store?: { save(bytes: Uint8Array, commitment?: { force: boolean; seconds: number; tickHz: number; fields: { kinds: number[][]; shared: number[] } }): void };
   /** Table recovery reserves this epoch in storage before starting this host. Ordinary deterministic restores omit it. */
   restoreEpoch?: number;
   startDelayMs?: number;
@@ -94,12 +99,18 @@ export interface HostOptions {
   onEnd?(why: string, facts: Record<string, unknown>): void;
 }
 export interface Host {
+  readonly characters: ReadonlyMap<string, CharacterLease>;
+  characterReturned(account: string, lease: number): void;
+  releaseCharacter(account: string): void;
+  reserveCharacter(lease: CharacterLease): void;
   readonly tick: number;
   readonly epoch: number;
   readonly running: boolean;
   readonly paused: boolean;
   readonly people: number;
   readonly viewRadiusM: number | null;
+  readonly privateDelivery: boolean;
+  projectSnapshot(snap: any, seat: number | null): any;
   readonly viewSettings: Compiled['settings']['view'];
   frame(m: Record<string, unknown>): void;
   /** Start the tick loop (the first person has joined). */
@@ -108,7 +119,7 @@ export interface Host {
   resume(): void;
   /** Publish the round, the roster, the shared state and the capabilities again (a browser host's relay restarted). */
   announce(): void;
-  /** Stop for good: the room has ended. */
+  /** Stop for good: the room has ended. A lasting world whose storage is healthy checkpoints first, and that write can throw. */
   stop(): void;
   /** Run the next tick now, whatever the clock says (tests, and the build check's runs). Like the timer's own tick, it never throws. */
   tickNow(): void;
@@ -118,8 +129,9 @@ export interface Host {
   readonly core: Core;
 }
 
-interface Entry { at: number; values: Record<string, unknown>; presses: string[]; claim: StepInput['claim'] }
+interface Entry { at: number; values: Record<string, unknown>; presses: (string | [string, number])[]; claim: StepInput['claim'] }
 interface SeatIn {
+  pulses?: [string,number][];
   held: Record<string, unknown>; claim: StepInput['claim']; entries: Entry[];
   /** The newest stamp this seat has sent, the stamps not yet acknowledged, and the newest acknowledged. */
   newest: number; stamps: number[]; ack: number;
@@ -160,19 +172,33 @@ function blameLate(now: number, period: number): void {
 
 export function createHost(o: HostOptions): Host {
   const c = o.compiled;
+  const persistent = c.settings.lifetime === 'persistent';
+  // Keep even effects and agent requests behind the same commit as their tick.
+  // Match rooms retain their existing save frequency and output behaviour.
+  const publish = o.send;
+  let pendingOutput: [Record<string, unknown>, string | undefined][] | null = null;
+  if (persistent) o = { ...o, send: (frame, text) => {
+    if (pendingOutput) pendingOutput.push([frame, text]); else publish(frame, text);
+  } };
+
   const period = 1000 / c.settings.tickHz;
   const tickHz = c.settings.tickHz;
   const lateTicks = Math.ceil(tickHz / 4);
   // A log that throws takes nothing down with it.
   const log = (line: Record<string, unknown>): void => { try { o.log?.(line); } catch { /* nothing to say it with */ } };
   const random = o.random ?? Math.random;
-  const saved = o.restore ? fromBytes(o.restore) as { v: number; core: SavedCore; names: [number, string][]; agents?: AgentsSaved; guideViews?: [number, { id: string; at: number; value: Record<string, unknown> }][]; queues: [number, Record<string, unknown>, StepInput['claim'], number, number][]; inputs?: [number, SeatIn][] } : null;
+  const saved = o.restore ? fromBytes(o.restore) as { v: number; characters?: CharacterLease[]; core: SavedCore; names: [number, string][]; agents?: AgentsSaved; guideViews?: [number, { id: string; at: number; value: Record<string, unknown> }][]; queues: [number, Record<string, unknown>, StepInput['claim'], number, number][]; inputs?: [number, SeatIn][] } : null;
   if (o.restore && (!saved || typeof saved !== 'object' || Array.isArray(saved))) throw new Error('saved host is not an object');
   if (saved) {
     const check = (ok: unknown): void => { if (!ok) throw new Error('saved host inputs are invalid'); };
     const uint = (n: unknown): boolean => Number.isSafeInteger(n) && (n as number) >= 0;
-    check(Object.keys(saved).every(k => ['v', 'core', 'names', 'agents', 'guideViews', 'queues', 'inputs'].includes(k)));
+    check(Object.keys(saved).every(k => ['v', 'core', 'names', 'agents', 'guideViews', 'queues', 'inputs', 'characters'].includes(k)));
     check(saved.core && Array.isArray(saved.names) && Array.isArray(saved.queues));
+    if (saved.characters !== undefined) {
+      check(c.settings.characters && Array.isArray(saved.characters));
+      check(new Set(saved.characters.map(c => c.account)).size === saved.characters.length);
+      for (const held of saved.characters) check(typeof held.account === 'string' && /^[A-Za-z0-9_-]{1,64}$/.test(held.account) && uint(held.lease) && held.lease > 0 && Number.isInteger(held.seat) && held.seat >= -1 && held.seat < c.seats && (held.returning === undefined || typeof held.returning === 'boolean'));
+    }
     if (saved.agents !== undefined) {
       const tables = ['goals', 'asks', 'avoid', 'sayAt', 'viewAt', 'floorAt', 'askAt'];
       check(saved.agents && Object.keys(saved.agents).every(k => tables.includes(k)));
@@ -225,17 +251,34 @@ export function createHost(o: HostOptions): Host {
       for (const [seat, q] of saved.inputs) {
         check(uint(seat) && seat < c.seats && q && valuesOk(seat, q.held) && claimOk(q.claim) && uint(q.newest) && uint(q.ack) && uint(q.lastFrameTick) && Number.isInteger(q.lead) && q.lead >= -127 && q.lead <= 127);
         check(Array.isArray(q.stamps) && q.stamps.length <= 256 && q.stamps.every(uint) && Array.isArray(q.entries) && q.entries.length <= c.settings.tickHz + 1);
-        for (const e of q.entries) check(uint(e.at) && valuesOk(seat, e.values) && claimOk(e.claim) && Array.isArray(e.presses) && e.presses.every((p) => c.kinds.some((k) => k.input.some(([name, fd]) => name === p && fd.t === 'press'))));
+        if(q.pulses!==undefined)check(Array.isArray(q.pulses)&&q.pulses.length<=16&&q.pulses.every(p=>Array.isArray(p)&&p.length===2&&c.kinds.some(k=>k.input.some(([n,f])=>n===p[0]&&f.t==='pulse'))&&Number.isInteger(p[1])&&p[1]>0&&p[1]<=255));
+        for (const e of q.entries) check(uint(e.at) && valuesOk(seat, e.values) && claimOk(e.claim) && Array.isArray(e.presses) && e.presses.every((p) => c.kinds.some((k) => k.input.some(([name, fd]) => (typeof p === 'string' ? name === p && fd.t === 'press' : Array.isArray(p) && p.length === 2 && name === p[0] && fd.t === 'pulse' && Number.isInteger(p[1]) && p[1] > 0 && p[1] <= 255)))));
       }
     }
   }
   if (saved && saved.v !== 1) throw new Error('this save was written by another version of the runtime');
-  const core = createCore(c, { moved: o.moved, observe: o.observe, noted: o.noted, seed: Math.floor(random() * 4294967296) >>> 0, epoch: saved ? undefined : (Math.floor(random() * 4294967295) >>> 0) + 1, restore: saved?.core ?? null, restoreEpoch: o.restoreEpoch, stage: o.stage, decisions: !o.check });
+  const measuredRtt = new Map<number, number>();
+  const characters = new Map<string, CharacterLease>((saved?.characters ?? []).map(c => [c.account, c.returning ? { ...c, seat: -1 } : c]));
+  const characterOptions = c.settings.characters ? {
+    characterForSeat: (seat: number) => [...characters.values()].find(c => c.seat === seat && !c.returning)?.character,
+    characterSaved: (seat: number, character: import('./rules.ts').Character) => {
+      const held = [...characters.values()].find(c => c.seat === seat);
+      if (held) {
+        held.character = character;
+        // Once removed, a delayed return must never follow a new occupant of this seat.
+        if (held.returning) held.seat = -1;
+      }
+    },
+  } : {};
+  const core = createCore(c, { ...characterOptions, rewindTicks: seat => Math.ceil(((measuredRtt.get(seat) ?? 0) + 150 + period) / period), label: (seat,driver)=>nameOf(seat,driver), moved: o.moved, observe: o.observe, noted: o.noted, seed: Math.floor(random() * 4294967296) >>> 0, epoch: saved ? undefined : (Math.floor(random() * 4294967295) >>> 0) + 1, restore: saved?.core ?? null, restoreEpoch: o.restoreEpoch, stage: o.stage, decisions: !o.check });
   let epoch = core.epoch;
   if (saved && (o.startPaused ?? o.restoreEpoch !== undefined)) for (const body of core.bodies()) if (body.driver !== 'bot' && body.owner !== 'reserved') core.seatAway(body.seat, true);
   let lastSaveAt = o.clock.now();
   let saveTick = core.tick;
   let forceSave = false;
+  let storeBroken = false;
+  /** Which state fields the game declared durable, by kind and for the shared state: what a lasting world journals at once. */
+  const durableFields = { kinds: c.kinds.map(k => k.fields.flatMap(([,f],i) => f.durable ? [i] : [])), shared: c.shared.flatMap(([,f],i) => f.durable ? [i] : []) };
   let saveFailures = 0;
   let retrySaveAt = 0;
   let roundPhase = saved?.core.round[1] ?? 1;
@@ -367,7 +410,7 @@ export function createHost(o: HostOptions): Host {
   // A restored room keeps each seat's held input, its newest stamp and its acknowledgement.
   for (const [seat, held, claim, newest, ack] of saved?.queues ?? []) queues.set(seat, { held, claim, entries: [], newest, stamps: [], ack, lead: 127, lastFrameTick: core.tick });
   for (const [seat, q] of saved?.inputs ?? []) queues.set(seat, q);
-  const neutral = (kind: KindTable): Record<string, unknown> => { const v = initFields(kind.input, c.dims); for (const [name, fd] of kind.input) if (fd.t === 'press') v[name] = false; return v; };
+  const neutral = (kind: KindTable): Record<string, unknown> => { const v = initFields(kind.input, c.dims); for (const [name, fd] of kind.input) if (fd.t === 'press' || fd.t === 'pulse') v[name] = fd.t === 'press' ? false : 0; return v; };
   function queueOf(seat: number, kind: KindTable): SeatIn {
     let q = queues.get(seat);
     if (!q) { q = { held: neutral(kind), claim: null, entries: [], newest: 0, stamps: [], ack: 0, lead: 127, lastFrameTick: core.tick }; queues.set(seat, q); }
@@ -405,11 +448,11 @@ export function createHost(o: HostOptions): Host {
       if (j > K + tickHz) { stats.dropped += 1; break; }
       q.newest = j;
       const values: Record<string, unknown> = {};
-      const presses: string[] = [];
+      const presses: (string | [string, number])[] = [];
       let i = 1;
       for (const [name, fd] of kind.input) {
         // Input values are held to their declared types, whatever was sent.
-        if (fd.t === 'press') { values[name] = false; if (raw[i] === 1) presses.push(name); } else values[name] = coerce(fd, raw[i], c.dims);
+        if (fd.t === 'press') { values[name] = false; if (raw[i] === 1) presses.push(name); } else if (fd.t === 'pulse') { values[name] = 0;  } else values[name] = coerce(fd, raw[i], c.dims);
         i += 1;
       }
       const claim = kind.body?.owner && raw.length >= i + 9 ? { pos: unpackVec([raw[i], raw[i + 1], raw[i + 2]], c.dims), vel: unpackVec([raw[i + 3], raw[i + 4], raw[i + 5]], c.dims), heading: unpackVec([raw[i + 6], raw[i + 7], raw[i + 8]], c.dims), r } : null;
@@ -437,6 +480,7 @@ export function createHost(o: HostOptions): Host {
   }
   function onFrame(m: Record<string, unknown>): void {
     switch (m.t) {
+      case 'latency': if(Number.isInteger(m.seat) && typeof m.ms==='number' && Number.isFinite(m.ms) && m.ms>=0) measuredRtt.set(m.seat as number,Math.min(m.ms,2000)); return;
       case 'vocabulary': setAgents((m.vocab ?? null) as Vocabulary | null); return;
       case 'decided': core.answer(String(m.n ?? ''), m); return;
       case 'in': return onIn(m);
@@ -452,7 +496,16 @@ export function createHost(o: HostOptions): Host {
         // The relay numbers every stay in a seat (`occ`): the same number is the same holder, back.
         const owner = `p${Number.isInteger(p.occ) ? p.occ : typeof p.id === 'string' ? p.id.slice(0, 40) : seat}`;
         const previous = core.bodies().find((s) => s.seat === seat);
-        core.seatJoin({ seat, driver, owner });
+        const grant = driver === 'person' ? o.characterFor?.(p as Record<string, unknown>) : null;
+        if (c.settings.characters && driver === 'person' && !grant && o.characterFor) throw new Error('Character lease required');
+        let character = grant?.character;
+        if (grant) {
+          const held = characters.get(grant.account);
+          if (held && (held.lease !== grant.lease || held.returning || held.seat >= 0 && held.seat !== seat)) throw new Error('Character return is still pending');
+          character = held ? core.character(held.seat) ?? held.character : grant.character;
+          characters.set(grant.account, { ...grant, character: character ?? null, seat });
+        }
+        core.seatJoin({ seat, driver, owner, ...(grant ? { character } : {}) });
         core.seatAway(seat, false);
         if (!previous || previous.driver !== driver || previous.owner !== owner) queues.delete(seat);
         rosterText = '';
@@ -464,7 +517,13 @@ export function createHost(o: HostOptions): Host {
         for (const [id, p] of peers) if (p.seat === m.seat) peers.delete(id);
         present.delete(m.seat as number);
         queues.delete(m.seat as number);
-        core.seatAway(m.seat as number, true);
+        const held = [...characters.values()].find(c => c.seat === m.seat && !c.returning);
+        if (held) {
+          held.character = core.character(held.seat) ?? held.character;
+          held.returning = true;
+          core.seatLeave(held.seat);
+          tick(o.clock.now());
+        } else core.seatAway(m.seat as number, true);
         if (running && people() === 0) pause();
         return;
       }
@@ -474,7 +533,10 @@ export function createHost(o: HostOptions): Host {
         for (const [id, p] of peers) if (p.seat === m.seat) peers.delete(id);
         present.delete(m.seat as number);
         queues.delete(m.seat as number);
+        const held = [...characters.values()].find(c => c.seat === m.seat && !c.returning);
+        if (held) { held.character = core.character(held.seat) ?? held.character; held.returning = true; }
         core.seatLeave(m.seat as number);
+        if (held) tick(o.clock.now());
         rosterText = '';
         return;
       }
@@ -486,6 +548,12 @@ export function createHost(o: HostOptions): Host {
           return;
         }
         if (agents && (kind === 'agent:do' || /^ask:/.test(kind) || (SPEECH.test(kind) && present.get(m.from as number) === false))) { if (agentInbox.length < 128) agentInbox.push(m); return; }
+        if(kind === 'pulse') {
+          const data=m.d,body=core.bodyOf(m.from as number);
+          if(!body || !hasHands(m.from as number,body.driver) || !Array.isArray(data) || data.length!==3 || data[0]!==epoch || typeof data[1]!=='string' || !body.kind.input.some(([name,fd])=>name===data[1]&&fd.t==='pulse'))return;
+          const value=coerce({t:'pulse'},data[2],c.dims) as number,q=queueOf(m.from as number,body.kind);q.pulses??=[];
+          if(value && q.pulses.length<16)q.pulses.push([data[1],value]);return;
+        }
         if (kind === 'cmd') { const d = m.d as unknown[]; if (Array.isArray(d) && typeof d[0] === 'string') core.command(m.from as number, d[0], d[1]); return; }
         // Speech keeps its payload, except the identity fields only the host may attach.
         if (SPEECH.test(kind)) o.send({ t: 'ev', from: m.from, k: kind, d: cleanSpeech(m.d) });
@@ -528,6 +596,14 @@ export function createHost(o: HostOptions): Host {
     for (const x of out) {
       if (x.t === 'round') {
         if (x.phase === 'over') forceSave = true;
+        if(!retime && x.results && c.records && o.record){
+          const declaration=c.records, shared=unpackFields(c.shared,core.shared(),c.dims), snapshot=core.snapshot();
+          for(const result of x.results){if(result.driver!=='person')continue;const row=(snapshot[1] as any[]).find(e=>e[0]===result.id);if(!row)continue;const kind=c.kinds[row[1]],fields=unpackFields(kind.fields,row[7],c.dims);if(declaration.eligible&&!fields[declaration.eligible])continue;
+            const value:Record<string,unknown>={id:String(shared[declaration.identity]),endedAt:Math.round(now),place:result.place,won:result.place===1&&x.results.filter(r=>r.place===1).length===1};
+            for(const [name,source] of Object.entries(declaration.fields))value[name]=Math.round(Number(fields[source]));
+            o.record(String(row[12]),declaration.key,value);
+          }
+        }
         const ms = (t: number): number => Math.round(now + (t - core.tick) * period);
         const drivers = new Map(core.bodies().map((b) => [b.seat, b.driver]));
         o.send({ t: 'round', ...(retime ? { retime: true } : {}), round: {
@@ -556,7 +632,7 @@ export function createHost(o: HostOptions): Host {
     for (const [seat, q] of queues) {
       const body = core.bodyOf(seat);
       if (!body) continue;
-      const presses: string[] = [];
+      const presses: (string | [string, number])[] = [];
       while (q.entries.length && q.entries[0].at <= t) {
         const e = q.entries.shift() as Entry;
         q.held = e.values; q.claim = e.claim;
@@ -566,7 +642,8 @@ export function createHost(o: HostOptions): Host {
       if (t - q.lastFrameTick > tickHz && !q.entries.length) { q.held = neutral(body.kind); q.claim = null; }
       while (q.stamps.length && q.stamps[0] <= t) q.ack = q.stamps.shift() as number;
       const values = { ...q.held };
-      for (const p of presses) values[p] = true;
+      for (const p of presses) { if (typeof p === 'string') values[p] = true; else values[p[0]] = p[1]; }
+      const pulse=q.pulses?.shift();if(pulse)values[pulse[0]]=pulse[1];
       inputs.set(seat, { values, claim: q.claim });
     }
     if (roundRebasePending) publishRebase(now);
@@ -612,7 +689,17 @@ export function createHost(o: HostOptions): Host {
   function tick(now: number): void {
     const cut = core.stats.ticksCut;
     let faulted = false;
-    try { tickOnce(); } catch (error) { faulted = true; fault(`tick ${core.tick} (${phase})`, error); }
+    if (persistent) pendingOutput = [];
+    try {
+      tickOnce();
+      const committed = pendingOutput; pendingOutput = null;
+      if (committed && !ended) for (const [frame, text] of committed) publish(frame, text);
+    } catch (error) {
+      pendingOutput = null;
+      faulted = true; fault(`tick ${core.tick} (${phase})`, error);
+      // Never continue from uncommitted memory or retire the last good save.
+      if (persistent) { stop(); o.onEnd?.('storage-or-tick-failed', { tick: core.tick }); return; }
+    }
     if (ended) return;
     if (!faulted && core.stats.ticksCut === cut) { failingSince = null; return; }
     if (failingSince === null) failingSince = now;
@@ -708,7 +795,7 @@ export function createHost(o: HostOptions): Host {
     // A pending timer would keep the object in memory and billed: the pause clears it.
     disarm();
     log({ ev: 'host-pause', game: o.game, tick: core.tick });
-    try { checkpoint(true); o.onPause?.(); } catch (error) { fault('onPause', error); }
+    try { checkpoint(true); o.onPause?.(); } catch (error) { fault('onPause', error); if (persistent) { stop(); o.onEnd?.('storage-or-tick-failed', { tick: core.tick }); } }
   }
   function resume(): void {
     if (running || ended || !paused) return;
@@ -750,9 +837,20 @@ export function createHost(o: HostOptions): Host {
   }
 
   function save(): Uint8Array {
-    return toBytes({ v: 1, core: core.save(), guideViews: [...guideViews], ...(agents ? { agents: agents.save() } : savedAgents ? { agents: savedAgents } : {}), names: [...names].filter(([seat]) => !core.bodies().some(b => b.seat === seat && b.owner === 'reserved')), queues: [...queues].map(([seat, q]) => [seat, q.held, q.claim, q.newest, q.ack]), inputs: [...queues] });
+    return toBytes({ v: 1, ...(characters.size ? { characters: [...characters.values()] } : {}), core: core.save(), guideViews: [...guideViews], ...(agents ? { agents: agents.save() } : savedAgents ? { agents: savedAgents } : {}), names: [...names].filter(([seat]) => !core.bodies().some(b => b.seat === seat && b.owner === 'reserved')), queues: [...queues].map(([seat, q]) => [seat, q.held, q.claim, q.newest, q.ack]), inputs: [...queues] });
   }
   function checkpoint(force = false): void {
+    if (persistent) {
+      // An empty match break or an unjoined reservation has no body-removal callback.
+      for (const held of characters.values()) if (held.returning) held.seat = -1;
+      if (!o.store) return; // Local checks/offline simulation have no durable account.
+      // A write that threw leaves memory ahead of storage: nothing later may checkpoint it over the committed world.
+      storeBroken = true;
+      o.store.save(save(), { force, seconds: c.settings.durability.movementSeconds, tickHz, fields: durableFields });
+      storeBroken = false;
+      saveTick = core.tick; lastSaveAt = o.clock.now(); forceSave = false;
+      return;
+    }
     const seconds = c.settings.durability.movementSeconds;
     // Catch-up ticks can cover a second of play in less than a second of wall time. Bound both clocks.
     if (!o.store || !force && (core.tick === saveTick || o.clock.now() - lastSaveAt < seconds * 1000 && core.tick - saveTick < seconds * tickHz)) return;
@@ -769,6 +867,26 @@ export function createHost(o: HostOptions): Host {
   }
 
   return {
+    get privateDelivery() { return c.kinds.some(k => k.collider || k.fields.some(([,f]) => f.visibility)); },
+    projectSnapshot(snap, seat) {
+      return {...snap,d:[snap.d[0],snap.d[1].map((row: any[]) => {
+        const k=c.kinds[row[1]], own=seat!==null && row[9]===seat && row[10]!==1;
+        if(!k.fields.some(([,f])=>f.visibility))return row;
+        const fields=row[7].map((v: unknown,i: number)=>{const visibility=k.fields[i][1].visibility;return !visibility || visibility==='owner'&&own || visibility==='results'&&snap.d[0][1]===0 ? v : null;});
+        return [...row.slice(0,7),fields,...row.slice(8)];
+      }),...snap.d.slice(2)]};
+    },
+    get characters() { return characters; },
+    reserveCharacter(lease) { if (!characters.has(lease.account)) characters.set(lease.account, { ...lease }); },
+    releaseCharacter(account) {
+      const held = characters.get(account);
+      if (!held || held.returning || ended) return;
+      held.character = core.character(held.seat) ?? held.character; held.returning = true;
+      present.delete(held.seat); queues.delete(held.seat); names.delete(held.seat);
+      if (held.seat >= 0) core.seatLeave(held.seat); tick(o.clock.now());
+      if (running && people() === 0) pause();
+    },
+    characterReturned(account, lease) { if (characters.get(account)?.returning && characters.get(account)?.lease === lease) characters.delete(account); },
     get viewSettings() { return c.settings.view; },
     get viewRadiusM() { return c.settings.view?.radiusM ?? null; },
     get tick() { return core.tick; },
@@ -776,7 +894,9 @@ export function createHost(o: HostOptions): Host {
     get running() { return running; },
     get paused() { return paused; },
     get people() { return people(); },
-    frame, start, pause, resume, stop, announce,
+    frame, start, pause, resume, announce,
+    // An orderly stop of a lasting world folds what moved since the last checkpoint. One that follows a failed write, or arrives during one, writes nothing.
+    stop() { try { if (persistent && !ended && !storeBroken) checkpoint(true); } finally { stop(); } },
     tickNow: () => {
       if (ended) return;
       let now = lastStart;

package/rules/interest.mjs

@@ -69,7 +69,7 @@ export function snapshotEncoder(keyframeTicks, chained = false) {
         for (let i = 1; i < entity.length; i++) if (rowText(entity)[i] !== before[i]) { mask |= 1 << i; values.push(entity[i]); }
         if (mask) changed.push([id, mask, values]);
       }
-      const out = { ...snap, d: { base: base.k, round: snap.d[0], ...(snap.d.length > 2 ? { collision: snap.d[2] } : {}), changed, removed: [...rows.keys()].filter(id => !present.has(id)), ...(chained ? { chain: true } : {}), ...(own ? { own } : {}) } };
+      const out = { ...snap, d: { base: base.k, round: snap.d[0], ...(snap.d.length > 2 && JSON.stringify(snap.d[2]) !== JSON.stringify(base.d[2]) ? { collision: snap.d[2] } : {}), changed, removed: [...rows.keys()].filter(id => !present.has(id)), ...(chained ? { chain: true } : {}), ...(own ? { own } : {}) } };
       if (chained) { base = snap; rows = new Map(snap.d[1].map(e => [e[0], rowText(e)])); }
       return out;
     },
@@ -103,7 +103,7 @@ export function snapshotDecoder() {
         const visible = new Map(rows);
         for (const id of d.removed) visible.delete(id);
         for (const e of d.own) visible.set(e[0], e);
-        return { ...snap, d: [d.round, [...visible.values()], ...(d.collision === undefined ? [] : [d.collision])] };
+        return { ...snap, d: [d.round, [...visible.values()], ...(d.collision === undefined ? base.d.slice(2) : [d.collision])] };
       }
       const next = new Map(rows);
       for (const id of d.removed) next.delete(id);
@@ -122,7 +122,7 @@ export function snapshotDecoder() {
         next.set(entity[0], entity);
       }
       for (const e of d.own ?? []) next.set(e[0], e);
-      const decoded = { ...snap, d: [d.round, [...next.values()], ...(d.collision === undefined ? [] : [d.collision])] };
+      const decoded = { ...snap, d: [d.round, [...next.values()], ...(d.collision === undefined ? base.d.slice(2) : [d.collision])] };
       if (d.chain) { base = decoded; rows = next; }
       return decoded;
     },

package/rules/live.ts

@@ -1,22 +1,25 @@
+import { rayQuery, raySnapshot, type QueryTarget } from './query.ts';
 import { overlapsTerrain } from './terrain.ts';
 import { nearbyMap } from './map-index.ts';
 /** Declared collision geometry, shared by authority and prediction. Entity fields
  * own its lifetime and dimensions; this projection contains no gameplay state. */
-import type { Vec3, ColliderDef } from './rules.ts';
+import type { Vec3, ColliderDef, QueryDef } from './rules.ts';
 import type { MapShapes } from './math.ts';
 import { charge, own } from './guard.ts';
 import { castMap3, solidAt, type BodyShape } from './collision.ts';
 import { sweepMap, rayBox, rayCircle } from './math.ts';
 
-export type ColliderRow = [string, string, number, number, number, number, number, number];
+export type ColliderRow = [string, string, number, number, number, number, number, number, {kind: string; query?: QueryDef; fields: Record<string, number | string | boolean>}?];
 export type CollisionRevision = [number, number, ColliderRow[]];
-export function colliderRow(id: string, at: Vec3, body: BodyShape, def: ColliderDef, fields: Record<string, unknown>): ColliderRow | null {
+export function colliderRow(id: string, at: Vec3, body: BodyShape, def: ColliderDef, fields: Record<string, unknown>, kind?: string, query?: QueryDef): ColliderRow | null {
   const opts = def === true ? {} : def;
   if (opts.enabled && fields[opts.enabled] !== true) return null;
   const size = opts.size ? fields[opts.size] as Vec3 : null;
   const x = size ? size.x : body.radius * 2, y = size ? size.y : body.radius * 2, z = size ? size.z : body.height || body.radius * 2;
   if (![x, y, z].every(Number.isFinite) || x <= 0 || y <= 0 || z < 0) return null;
-  return [id, size ? 'box' : body.shape, at.x, at.y, at.z, x, y, z];
+  const row: ColliderRow = [id, size ? 'box' : body.shape, at.x, at.y, at.z, x, y, z];
+  if(kind) row.push({kind, ...(query?{query}:{}), fields:Object.fromEntries((opts.fields ?? []).filter(name=>['number','string','boolean'].includes(typeof fields[name])).map(name=>[name,fields[name]])) as Record<string,number|string|boolean>});
+  return row;
 }
 export function colliderSolid(row: ColliderRow): ReturnType<typeof solidAt> {
   const [, shape, x, y, z, w, d, h] = row;
@@ -27,6 +30,10 @@ export function castCollider2(row: ColliderRow, p: Vec3, d: Vec3, radius: number
   const solid = colliderSolid(row);
   return row[1] === 'box' ? rayBox(p.x,p.y,d.x,d.y,solid.min,solid.max,radius) : rayCircle(p.x,p.y,d.x,d.y,row[2],row[3],row[5]/2+radius);
 }
+const rowsOf = new WeakMap<object, readonly ColliderRow[]>();
+export function collisionTargets(map: MapShapes): QueryTarget[] {
+  return (rowsOf.get(map) ?? []).map(row=>({id:row[0],kind:row[8]?.kind??'',query:row[8]?.query,fields:row[8]?.fields??{},geometry:true,solid:colliderSolid(row),at:{x:row[2],y:row[3],z:row[4]}}));
+}
 export function collisionMap(map: MapShapes, rows: readonly ColliderRow[]): MapShapes {
   if (!rows.length) return map;
   const boxes: any[] = [], circles: any[] = [], spheres: any[] = [], capsules: any[] = [];
@@ -37,7 +44,9 @@ export function collisionMap(map: MapShapes, rows: readonly ColliderRow[]): MapS
     else if (shape === 'sphere') spheres.push({ at: { x, y, z: z + w / 2 }, r: w / 2, id } as any);
     else capsules.push({ at, r: w / 2, height: h, id } as any);
   }
-  return { bounds: map.bounds, staticMap: map, boxes, circles, spheres, capsules };
+  const combined = { bounds: map.bounds, staticMap: map, boxes, circles, spheres, capsules };
+  rowsOf.set(combined, rows);
+  return combined;
 }
 /** Latest known revision at the requested tick. Unknown future edits are never
  * guessed: a later snapshot rebases the body and replays its pending inputs. */
@@ -45,14 +54,17 @@ export function revisionAt(history: readonly CollisionRevision[], tick: number):
   for (let i = history.length - 1; i >= 0; i--) if (history[i][1] <= tick) return history[i];
   return undefined;
 }
-export function collisionQueries(map: () => MapShapes, shape: () => BodyShape, dims: number): object {
+export function collisionQueries(map: () => MapShapes, shape: () => BodyShape, dims: number, self: () => string | undefined = () => undefined): object {
   const position = (body: unknown): Vec3 => {
     const p = own(body, 'pos');
     const n = (k: string): number => { const v = own(p, k); return typeof v === 'number' && Number.isFinite(v) ? Math.fround(v) : 0; };
     return { x: n('x'), y: n('y'), z: n('z') };
   };
   return {
-    sweep: (body: unknown, delta: unknown) => sweepMap(map(), body, delta, shape().radius, dims, shape()),
+    ray: (from: unknown, direction: unknown, max: unknown, options?: unknown) => {const m=map();return rayQuery(m.staticMap??m,collisionTargets(m),dims,from,direction,max,options,self())[0];},
+    rays: (options?: unknown) => {const m=map();return raySnapshot(m.staticMap??m,collisionTargets(m),dims,options,self());},
+    rayAll: (from: unknown, direction: unknown, max: unknown, options?: unknown) => {const m=map();return rayQuery(m.staticMap??m,collisionTargets(m),dims,from,direction,max,options,self(),true);},
+    sweep: (body: unknown, delta: unknown, options?: unknown) => sweepMap(map(), body, delta, shape().radius, dims, shape(), options),
     support: (body: unknown, distance: unknown = 0.002) => {
       charge(20);
       const p = position(body), m = map();

package/rules/map-index.ts

@@ -46,6 +46,12 @@ export function nearbyMap(map: MapShapes, p:Vec3, d:Vec3, radius:number, height:
   function visit(n:Node){if(!touches(n))return;if(n.entries){for(const e of n.entries)if(touches(e))found.push(e);}else{visit(n.left!);visit(n.right!);}}
   visit(root);charge(found.length*Math.ceil(Math.log2(found.length+1)));
   found.sort((a,b)=>a.order-b.order);for(const e of found)out[e.key].push(e.value);
-  if(parent)for(const key of ['boxes','circles','spheres','capsules','heightTiles'] as const)for(const v of map[key]??[]){charge(12);out[key].push(v);}
+  if(parent)for(const key of ['boxes','circles','spheres','capsules','heightTiles'] as const)for(const raw of map[key]??[]){
+    const v:any=raw;let min:Vec3,max:Vec3;
+    if(key==='boxes'){min=v.min;max=v.max;}
+    else if(key==='heightTiles'){min={...v.at,z:v.at.z+Math.min(v.base??Infinity,...v.heights)};max={x:v.at.x+v.size.x,y:v.at.y+v.size.y,z:v.at.z+Math.max(...v.heights)};}
+    else{min={x:v.at.x-v.r,y:v.at.y-v.r,z:key==='circles'?-Infinity:key==='capsules'?v.at.z:v.at.z-v.r};max={x:v.at.x+v.r,y:v.at.y+v.r,z:key==='circles'?Infinity:key==='capsules'?v.at.z+v.height:v.at.z+v.r};}
+    if(touches({min,max}))out[key].push(raw);
+  }
   return out;
 }

package/rules/math.ts

@@ -14,7 +14,7 @@ import { collisionQueries } from './live.ts';
  * Every call is charged 4 units to the running handler's budget (guard.ts), beside what any guarded call costs.
  * =============================================================================
  */
-import { castMap3, restsOnMap, type BodyShape } from './collision.ts';
+import { castMap3, castSolid, restsOnMap, type BodyShape } from './collision.ts';
 import { brand, charge, own, put } from './guard.ts';
 import { num } from './pack.ts';
 
@@ -237,12 +237,24 @@ function rayBounds(px: number, py: number, dx: number, dy: number, b: { min: Vec
   return best;
 }
 /** A circle (or a point, r 0) moved along d against the static map: the first thing in the way, and how many shapes were tested. */
-export function castMap(map: MapShapes, px: number, py: number, dx: number, dy: number, r: number): { hit: Hit | null; tested: number } {
+export function castMap(map: MapShapes, px: number, py: number, dx: number, dy: number, r: number, hits?: Hit[], includeInside = false, square = false): { hit: Hit | null; tested: number } {
   map = nearbyMap(map, {x:px,y:py,z:0}, {x:dx,y:dy,z:0}, r, 0, 2);
   charge(16 + 4 * (map.boxes.length + map.circles.length));
   let best: Hit | null = rayBounds(Math.max(map.bounds.min.x + r, Math.min(map.bounds.max.x - r, px)), Math.max(map.bounds.min.y + r, Math.min(map.bounds.max.y - r, py)), dx, dy, map.bounds, r);
-  for (const b of map.boxes) { const h = rayBox(px, py, dx, dy, b.min, b.max, r); if (h && (!best || h.t < best.t)) best = { ...h, id: (b as any).id }; }
-  for (const c of map.circles) { const h = rayCircle(px, py, dx, dy, c.at.x, c.at.y, c.r + r); if (h && (!best || h.t < best.t)) best = { ...h, id: (c as any).id }; }
+  if (hits && best) hits.push(best);
+  const take=(h: Hit | null,id?:string): void => {if(!h)return;const hit={...h,...(id?{id}:{})};if(hits)hits.push(hit);if(!best||h.t<best.t)best=hit;};
+  const length=Math.sqrt(dx*dx+dy*dy)||1;
+  const inside: Hit={t:0,nx:-dx/length,ny:-dy/length};
+  for (const b of map.boxes) {
+    const min=square?{x:b.min.x-r,y:b.min.y-r,z:0}:b.min,max=square?{x:b.max.x+r,y:b.max.y+r,z:0}:b.max;
+    const embedded=includeInside&&px>min.x&&px<max.x&&py>min.y&&py<max.y;
+    take(embedded?inside:rayBox(px,py,dx,dy,min,max,square?0:r),(b as {id?:string}).id);
+  }
+  for (const c of map.circles) {
+    const embedded=includeInside&&(px-c.at.x)*(px-c.at.x)+(py-c.at.y)*(py-c.at.y)<(c.r+r)*(c.r+r);
+    const h=square?castSolid({min:{x:px-r,y:py-r,z:0},max:{x:px+r,y:py+r,z:1},r:0},{x:dx,y:dy,z:0},{min:{x:c.at.x,y:c.at.y,z:-1},max:{x:c.at.x,y:c.at.y,z:2},r:c.r},includeInside):embedded?inside:rayCircle(px,py,dx,dy,c.at.x,c.at.y,c.r+r);
+    take(h,(c as {id?:string}).id);
+  }
   return { hit: best, tested: 4 + map.boxes.length + map.circles.length };
 }
 
@@ -251,7 +263,7 @@ export function castMap(map: MapShapes, px: number, py: number, dx: number, dy:
  * and a browser both move a body with this, so they agree to the last bit. Returns nothing, or `{ at, normal }`.
  * The 2D path charges 20 units and 4 per shape; 3D also charges each convex cast and terrain tile. With `dims` 2 a body always rests on the ground.
  */
-export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius: number, dims: number, shape: BodyShape = { shape: 'sphere', radius, height: 2 * radius }): unknown {
+export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius: number, dims: number, shape: BodyShape = { shape: 'sphere', radius, height: 2 * radius }, options?: unknown): unknown {
   // Charged before the cast, for every shape of the map it may test.
   charge(20);
   const fr = Math.fround;
@@ -267,7 +279,7 @@ export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius:
     const length = Math.sqrt(dx * dx + dy * dy + d.z * d.z);
     const t = h ? Math.max(0, h.t - (length > 0 ? SKIN / length : 0)) : 1;
     const at = v(fr(px + dx * t), fr(py + dy * t), fr(p.z + d.z * t));
-    put(body, 'pos', at); put(body, 'grounded', restsOnMap(map, at, shape));
+    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);
@@ -285,9 +297,9 @@ export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius:
  * map. One function, so that the browser (view.ts) and the person the build check plays hold the same one. The
  * server's own (core.ts `moveCtx`) is made beside the rest of its world, and charges as that does.
  */
-export function moveContext(o: { tick: () => number; tickHz: number; tune: unknown; map: MapShapes; name: string; spots: Readonly<Record<string, readonly unknown[]>>; radius: () => number; shape?: () => BodyShape; dims: number; geometry?: () => MapShapes }): unknown {
+export function moveContext(o: { tick: () => number; tickHz: number; tune: unknown; map: MapShapes; name: string; spots: Readonly<Record<string, readonly unknown[]>>; radius: () => number; shape?: () => BodyShape; dims: number; geometry?: () => MapShapes; self?: () => string | undefined }): unknown {
   const none = Object.freeze([]);
-  const queries = collisionQueries(() => o.geometry?.() ?? o.map, () => o.shape?.() ?? {shape: 'sphere', radius: o.radius(), height: 2 * o.radius()}, o.dims);
+  const queries = collisionQueries(() => o.geometry?.() ?? o.map, () => o.shape?.() ?? {shape: 'sphere', radius: o.radius(), height: 2 * o.radius()}, o.dims, o.self);
   return brand(Object.freeze({
     get tick() { return o.tick(); }, dt: 1 / o.tickHz, tune: o.tune, math,
     // As the server's `ctx.ticks` reads it: a plain number, or nothing.

package/rules/navigation.ts

@@ -0,0 +1,69 @@
+/** Deterministic routing over an authored, baked walking graph. Full searches
+ * either reach the goal or return no path; never silently truncate a route. */
+import {own,charge} from './guard.ts';
+import type {Solid} from './collision.ts';
+import {castSolid} from './collision.ts';
+export type RouteNode = readonly [number,number,number,readonly number[]];
+const graphs = new WeakMap<object,readonly RouteNode[]>();
+const incoming = new WeakMap<object,readonly (readonly number[])[]>();
+function graphOf(value: unknown, billing=true): readonly RouteNode[] {
+ if(!Array.isArray(value)||value.length>8192)throw new Error('route graph has at most 8192 nodes');
+ if(billing)charge(value.length*12);const cached=graphs.get(value);if(cached)return cached;
+ const nodes:RouteNode[]=[];
+ for(let i=0;i<value.length;i++){
+  const n=own(value,i),links=own(n,3),x=own(n,0),y=own(n,1),z=own(n,2);
+  if(![x,y,z].every(v=>typeof v==='number'&&Number.isFinite(v))||!Array.isArray(links)||links.length>16)throw new Error('route nodes are [x,y,z,links], at most 16 neighbours');
+  const adjacent:number[]=[];for(let j=0;j<links.length;j++){const id=own(links,j);if(typeof id!=='number'||!Number.isInteger(id)||id<0||id>=value.length)throw new Error('route links name graph nodes');adjacent.push(id);}
+  nodes.push(Object.freeze([x as number,y as number,z as number,Object.freeze(adjacent)]));
+ }
+ const result=Object.freeze(nodes);const reverse:number[][]=nodes.map(()=>[]);nodes.forEach((n,i)=>{for(const next of n[3])reverse[next].push(i);});incoming.set(result,reverse);if(Object.isFrozen(value)&&value.every(n=>Object.isFrozen(n)&&Object.isFrozen(own(n,3))))graphs.set(value,result);return result;
+}
+export const prepareGraph=(value:unknown):readonly RouteNode[]=>graphOf(value,false);
+export function routeGraph(value: unknown, origin: unknown, destination: unknown, solids: readonly Solid[], radius: number, height: number, prepared=false): readonly number[] {
+ const nodes=prepared?value as readonly RouteNode[]:graphOf(value);if(prepared)charge(16);
+ if(!Number.isInteger(origin)||!Number.isInteger(destination)||Number(origin)<0||Number(destination)<0||Number(origin)>=nodes.length||Number(destination)>=nodes.length)throw new Error('route endpoints name graph nodes');
+ let start=Number(origin),goal=Number(destination),end=nodes[goal];
+ const buckets=new Map<string,Solid[]>();
+ for(const solid of solids){const minX=Math.floor((solid.min.x-solid.r-radius)/4),maxX=Math.floor((solid.max.x+solid.r+radius)/4),minY=Math.floor((solid.min.y-solid.r-radius)/4),maxY=Math.floor((solid.max.y+solid.r+radius)/4);
+  if((maxX-minX+1)*(maxY-minY+1)>65536)throw new Error('route obstacle spans too many graph cells');
+  for(let x=minX;x<=maxX;x++)for(let y=minY;y<=maxY;y++){charge(2);const key=x+','+y;const rows=buckets.get(key)??[];rows.push(solid);buckets.set(key,rows);}
+ }
+ const blocked=(a:RouteNode,b:RouteNode)=>{
+  const from={min:{x:a[0]-radius,y:a[1]-radius,z:a[2]+.05},max:{x:a[0]+radius,y:a[1]+radius,z:a[2]+height},r:0},delta={x:b[0]-a[0],y:b[1]-a[1],z:b[2]-a[2]};
+  const candidates=new Set<Solid>();
+  for(let x=Math.floor(Math.min(a[0],b[0])/4);x<=Math.floor(Math.max(a[0],b[0])/4);x++)for(let y=Math.floor(Math.min(a[1],b[1])/4);y<=Math.floor(Math.max(a[1],b[1])/4);y++){charge(1);for(const solid of buckets.get(x+','+y)??[])candidates.add(solid);}
+  for(const s of candidates){charge(2);if(Math.max(a[0],b[0])+radius<s.min.x-s.r||Math.min(a[0],b[0])-radius>s.max.x+s.r||Math.max(a[1],b[1])+radius<s.min.y-s.r||Math.min(a[1],b[1])-radius>s.max.y+s.r||Math.max(a[2],b[2])+height<s.min.z-s.r||Math.min(a[2],b[2])+.05>s.max.z+s.r)continue;if(s.r===0){
+    charge(24);let near=0,far=1,hit=true;
+    for(const axis of ['x','y','z'] as const){const low=s.min[axis]-from.max[axis],high=s.max[axis]-from.min[axis],speed=delta[axis];if(!speed){if(low>=0||high<=0){hit=false;break;}}else{let a=low/speed,b=high/speed;if(a>b)[a,b]=[b,a];near=Math.max(near,a);far=Math.min(far,b);if(near>far){hit=false;break;}}}
+    if(hit&&far>=0)return true;
+   }else if(castSolid(from,delta,s,true))return true;}
+  return false;
+ };
+ const endpoint=(id:number,limit:number)=>{
+  if(!blocked(nodes[id],nodes[id]))return id;
+  const p=nodes[id];let best=-1,score=Infinity;
+  for(let i=0;i<nodes.length;i++){charge(4);const q=nodes[i],distance=Math.hypot(q[0]-p[0],q[1]-p[1]);const cost=distance+Math.abs(q[2]-p[2])*2;if(distance>limit||cost>=score||!q[3].length||blocked(q,q))continue;best=i;score=cost;}
+  return best;
+ };
+ start=endpoint(start,4);goal=endpoint(goal,Infinity);if(start<0||goal<0)return Object.freeze([]);end=nodes[goal];
+ type Entry={id:number;f:number;order:number};let sequence=0;
+ const before=(a:Entry,b:Entry)=>a.f<b.f||a.f===b.f&&a.order<b.order;
+ const push=(heap:Entry[],id:number,f:number)=>{const item={id,f,order:sequence++};let i=heap.length;heap.push(item);while(i){const p=(i-1)>>1;if(!before(item,heap[p]))break;heap[i]=heap[p];i=p;}heap[i]=item;};
+ const pop=(heap:Entry[])=>{const first=heap[0],last=heap.pop()!;if(heap.length){let i=0;while(i*2+1<heap.length){let j=i*2+1;if(j+1<heap.length&&before(heap[j+1],heap[j]))j++;if(!before(heap[j],last))break;heap[i]=heap[j];i=j;}heap[i]=last;}return first.id;};
+ const originPoint=nodes[start],potential=(id:number)=>(Math.hypot(nodes[id][0]-end[0],nodes[id][1]-end[1])-Math.hypot(nodes[id][0]-originPoint[0],nodes[id][1]-originPoint[1]))/2;
+ const heaps:Entry[][]=[[],[]],costs=[new Map([[start,0]]),new Map([[goal,0]])],parents=[new Map<number,number>(),new Map<number,number>()],closed=[new Set<number>(),new Set<number>()],reverse=incoming.get(nodes)!;
+ push(heaps[0],start,potential(start));push(heaps[1],goal,-potential(goal));let best=Infinity,meet=-1;
+ // Balanced bidirectional A*: either frontier can prove disconnection. No
+ // expansion limit, and every returned route connects the two endpoints.
+ while(heaps[0].length&&heaps[1].length){
+  if(heaps[0][0].f+heaps[1][0].f>=best)break;
+  const side=heaps[0][0].f<=heaps[1][0].f?0:1,other=1-side,current=pop(heaps[side]);charge(12);if(closed[side].has(current))continue;closed[side].add(current);
+  const cost=costs[side].get(current)!,opposite=costs[other].get(current);if(opposite!==undefined&&cost+opposite<best){best=cost+opposite;meet=current;}
+  for(const next of side?reverse[current]:nodes[current][3]){charge(4);if(closed[side].has(next))continue;const a=nodes[side?next:current],b=nodes[side?current:next];if(blocked(a,b))continue;
+   const score=cost+Math.hypot(b[0]-a[0],b[1]-a[1])+Math.max(0,b[2]-a[2])*.3;if(score>=(costs[side].get(next)??Infinity))continue;
+   costs[side].set(next,score);parents[side].set(next,current);push(heaps[side],next,score+(side?-potential(next):potential(next)));
+   const otherCost=costs[other].get(next);if(otherCost!==undefined&&score+otherCost<best){best=score+otherCost;meet=next;}
+  }
+ }
+ if(meet<0)return Object.freeze([]);const path=[meet];while(path[0]!==start)path.unshift(parents[0].get(path[0])!);while(path[path.length-1]!==goal)path.push(parents[1].get(path[path.length-1])!);charge(path.length);return Object.freeze(path);
+}

package/rules/pack.ts

@@ -21,7 +21,7 @@ import { cellsOf } from './rules.ts';
 import type { Field, FieldList, Vec3 } from './rules.ts';
 import { G, charge, keyCount, own, refusedName } from './guard.ts';
 
-const RANGE: Record<string, [number, number]> = { u8: [0, 255], u16: [0, 65535], u32: [0, 4294967295], i8: [-128, 127], i16: [-32768, 32767], i32: [-2147483648, 2147483647], tick: [0, 4294967295], ticks: [0, 4294967295] };
+const RANGE: Record<string, [number, number]> = { pulse: [0, 255], u8: [0, 255], u16: [0, 65535], u32: [0, 4294967295], i8: [-128, 127], i16: [-32768, 32767], i32: [-2147483648, 2147483647], tick: [0, 4294967295], ticks: [0, 4294967295] };
 /** `f.fix`: steps of 1/4096, to plus or minus 2^31 (a tick count with a fraction fits for the life of any room). */
 export const FIX_STEP = 4096;
 const FIX_MAX = 2147483648;
@@ -262,7 +262,7 @@ export interface MoveBody { pos: Vec3; vel: Vec3; heading: Vec3; grounded: boole
  * `used` is the units it took. What it throws goes to `failed` (the budget's own stop too) and the body is still read.
  */
 export function stepMove(fn: (body: MoveBody, input: unknown, ctx: unknown) => void, body: MoveBody, input: Readonly<Record<string, unknown>>, ctx: unknown, quota: number, motion: FieldList, dims: number, failed: (error: unknown) => void): MoveBody & { used: number } {
-  G.left = quota;
+  G.queryEpoch++; G.left = quota;
   const bag = coerceFields(motion, body.motion, dims);
   const target: Record<string, unknown> = {};
   const work: Record<string, unknown> = {};