@homie-rocks/studio 0.51.0 → 0.51.2

package/rules/view.ts

@@ -1,3 +1,4 @@
+import { correctionPath } from './correction-path.ts';
 import { disposeMoveContext, sweepMap } from './math.ts';
 import { boundPosition, periodicDelta, blendPosition, relativePoint, wrapPoint } from './topology.mjs';
 import { rayQuery, raySnapshot, type QueryTarget } from './query.ts';
@@ -108,6 +109,14 @@ export interface OpenRoomOptions {
   predict?: Record<string, Predictor>;
   /** Camera axes on the rules' x/y plane for the testing tools. Default: x right, y up. */
   screenBasis?: PortProbeOptions['basis'];
+  /** Horizontal intent for box-bodied 2D visual corrections: -1 left, 0 neutral, +1 right. Does not affect simulation. */
+  correctionDirection?: (input: Readonly<Record<string, unknown>>, velocity: Vec3) => number;
+  /**
+   * After this browser's connection comes back, the server hands the own body back where it has it (a new placement
+   * revision). A box-bodied 2D runner is then drawn on from where it was shown, not cut across. Say here when that
+   * revision is a real placement made while the player was away (a respawn, a new round): it is then drawn at once.
+   */
+  respawned?: (before: Entity, after: Entity) => boolean;
   /** Tests: a clock in ms and a way to run without timers. */
   now?: () => number;
   timers?: boolean;
@@ -224,6 +233,15 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   /* ---------------------------------------------------------------- frames in */
 
   const delivery = snapshotDecoder();
+  /** Until when a revision of the own body counts as the server handing it back after a reconnect. */
+  let returningUntil = 0;
+  let unpackedRows = new Map<string, {wire: unknown; value: Unpacked}>();
+  const sameRow = (a: unknown, b: unknown): boolean => {
+    if (a === b) return true;
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (!sameRow(a[i], b[i])) return false;
+    return true;
+  };
   function frameOf(s: Snapshot<unknown> | null): Frame | null {
     if (!s || typeof s !== 'object') return null;
     if (frames.has(s)) return frames.get(s) ?? null;
@@ -231,13 +249,29 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     const d = delivery.decode(s)?.d as [unknown, unknown, CollisionRevision?] | null;
     if (Array.isArray(d) && Array.isArray(d[0]) && Array.isArray(d[1])) {
       const ents = new Map<string, Unpacked>();
-      for (const w of d[1] as unknown[]) { const e = unpackEntity(schema.kinds, w, dims); if (e) ents.set(e.id, e); }
+      // Delta rows and repeated keyframe rows often describe unchanged scenery.
+      // Compare the immutable wire arrays before allocating typed vectors/fields.
+      // Retain only this frame's rows, not a growing history of transient keys.
+      const nextRows = new Map<string, {wire: unknown; value: Unpacked}>();
+      for (const w of d[1] as unknown[]) {
+        const id = Array.isArray(w) && typeof w[0] === 'string' ? w[0] : '';
+        const prior = unpackedRows.get(id);
+        const e = prior && sameRow(prior.wire, w) ? prior.value : unpackEntity(schema.kinds, w, dims);
+        if (e) { nextRows.set(e.id, prior?.value === e ? prior : {wire:w,value:e}); ents.set(e.id, e); }
+      }
+      unpackedRows = nextRows;
       f = { collision: d[2], k: s.k, e: Number(s.e) || 0, at: clock(), round: [Number(d[0][0]) || 0, Number(d[0][1]) || 0, Number(d[0][2]) || 0], ents, rows: (Array.isArray(s.c) ? s.c : []) as unknown as number[][] };
     }
     frames.set(s, f);
     return f;
   }
-  const entityOf = (u: Unpacked, mine = false): Entity => Object.freeze({ id: u.id, kind: u.kind, pos: u.pos, vel: u.vel, heading: u.heading, grounded: u.grounded, ...(u.seat !== undefined ? { seat: u.seat, owner: u.owner, driver: u.driver, away: u.away, goal: u.goal } : {}), ...(mine ? { mine: true } : {}), ...u.fields, motion: Object.freeze({ ...u.motion }) }) as Entity;
+  const entities = new WeakMap<Unpacked, Entity>();
+  const entityOf = (u: Unpacked, mine = false, cache = !mine): Entity => {
+    if (cache && entities.has(u)) return entities.get(u)!;
+    const entity = Object.freeze({ id: u.id, kind: u.kind, pos: u.pos, vel: u.vel, heading: u.heading, grounded: u.grounded, ...(u.seat !== undefined ? { seat: u.seat, owner: u.owner, driver: u.driver, away: u.away, goal: u.goal } : {}), ...(mine ? { mine: true } : {}), ...u.fields, motion: Object.freeze({ ...u.motion }) }) as Entity;
+    if (cache) entities.set(u, entity);
+    return entity;
+  };
 
   /* ---------------------------------------------------------------- the own body, on this browser's copy of the clock */
 
@@ -281,7 +315,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   let offsets: { delta: Vec3; at: number; path: Vec3; fade: number; last: number; end?: number }[] = [];
   const predict = schema.settings.predict;
   const quantile = (list: number[], q: number): number => [...list].sort((a, b) => a - b)[Math.floor((list.length - 1) * q)] ?? 0;
-  const targetLead = (): number => 0.5 + Math.max(0, quantile(leads, 0.5) - quantile(leads, 0.05));
+  let leadTarget = .5, leadMedian = 0, hostMedian = 0;
+  const targetLead = (): number => leadTarget;
   const copyMine = (m: Mine): Mine => ({ ...m, motion: motionOf(m.kind, m.motion) });
   const distance = (a: Vec3, b: Vec3): number => Math.hypot(periodicDelta(b.x,a.x,map.wrap?.x),periodicDelta(b.y,a.y,map.wrap?.y),periodicDelta(b.z,a.z,map.wrap?.z));
   const correction = { count: 0, max: 0, last: 0, catches: 0, snaps: 0, rebases: 0, rebaseReason: '', rebaseError: 0 };
@@ -357,14 +392,14 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // The helper's ping ends at the relay. A browser host adds another network leg in both directions.
     // Snapshot stamps use the relay clock, so their observed age measures the complete downstream path.
     const relayRtt = net.stats().rtt ?? 100;
-    return net.offline ? 0 : Math.max(relayRtt, 2 * quantile(hostAges, 0.5));
+    return net.offline ? 0 : Math.max(relayRtt, 2 * hostMedian);
   }
   function phaseAt(at: number): number {
     let p = phases[0];
     for (let i = phases.length - 1; i >= 0; i--) if (phases[i].at <= at) { p = phases[i]; break; }
     return p ? p.tick + (at - p.at) / period * p.rate - at / period : 0;
   }
-  const medianLead = (): number => leads.length ? quantile(leads.slice(-8), 0.5) + phaseAt(clock()) : 0;
+  const medianLead = (): number => leads.length ? leadMedian + phaseAt(clock()) : 0;
   function steer(now: number): void {
     if (!base || !leads.length) return;
     base = { tick: tickAt(now), at: now };
@@ -384,11 +419,11 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     const rtt = authorityRtt(); calibratedRtt = rtt;
     // Lead samples refer to the clock which stamped them. Do not mix its offset with this clock's jitter.
     const target = targetLead();
-    leads.length = 0;
+    leads.length = 0; leadTarget = .5; leadMedian = 0;
     leadAfter = clock() + 2 * rtt + period;
     base = { tick: continuousTick ?? k + Math.min(tickHz, Math.ceil(rtt / period + target) + sendEvery - 1), at: clock() };
     stepped = Math.max(k, Math.floor(base.tick) - (continuousTick === null ? 1 : 0));
-    entries = []; sentHistory = []; controlChanges = []; pending = []; history.clear(); replayHeld = {}; serverHeld = {}; held = {}; lastSent = ''; leads.length = 0; pressed = new Map(); pulseNumber = new Map(); heldTrack.clear(); if (reason !== 'lead') dropPredictions();
+    entries = []; sentHistory = []; controlChanges = []; pending = []; history.clear(); replayHeld = {}; serverHeld = {}; held = {}; lastSent = ''; leads.length = 0; leadTarget = .5; leadMedian = 0; pressed = new Map(); pulseNumber = new Map(); heldTrack.clear(); if (reason !== 'lead') dropPredictions();
     speed = 1; phases.length = 0; phases.push({ ...base, rate: 1 }); catchTick = null; offsets = []; headingBlend = null; correction.rebases += 1;
     const u = mine && latest?.ents.get(mine.id); if (u) adopt(u);
     if (mine) {
@@ -419,22 +454,35 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   /** `motion` as this browser's own `move` may change it in place: what a snapshot carries is frozen, so every list, map and struct in it is copied. */
   const motionOf = (kindName: string, motion: Record<string, unknown>): Record<string, unknown> => thawFields(kindOf.get(kindName)?.motion ?? [], motion);
   function adopt(u: Unpacked): void {
+    presentedEntity = null;
     mine = { id: u.id, kind: u.kind, r: u.r, pos: u.pos, vel: u.vel, heading: u.heading, grounded: u.grounded, motion: motionOf(u.kind, u.motion), fields: predictors[u.kind] ? thawFields(kindOf.get(u.kind)?.fields ?? [], u.fields) : u.fields };
   }
   /** The game's guarded `move` for one tick, counted as the server counts it, with the result rounded as the server rounds it. */
   const substepKinds = new Set<string>();
+  const movementCache = new Map<string, {scene: unknown; value: ReturnType<typeof stepMove>}>();
   function runMove(kindName: string, body: { pos: Vec3; vel: Vec3; heading: Vec3; grounded: boolean; motion: Record<string, unknown> }, input: Readonly<Record<string, unknown>>, t: number): typeof body & {steps?: readonly import('./substeps.ts').StepPose[]} {
     const fn = moves[kindName];
     if (!fn || (kindOf.get(kindName)?.control && !body.motion[kindOf.get(kindName)!.control!])) return body;
     moveTick = t;
     // Like snapshot unpacking, prepare the bounded geometry outside the handler
     // quota. Authority debits projection once per tick, not once per mover.
-    geometryAt();
-    const out = stepMove(fn, body, input, moveCtx, Math.max(1, Math.floor(schema.settings.budget.tick / 4)), kindOf.get(kindName)?.motion ?? [], dims, (err) => { if (!(err instanceof BudgetError)) console.warn('[room] move', err); });
+    const scene = geometryAt();
+    // Reconciliation often replays the exact same deterministic movement. Cache
+    // its full arguments, including tick, self, motion and collision revision.
+    // Stateful physics worlds must execute their operations and are excluded.
+    const key = map.physics ? '' : JSON.stringify([mine?.id,kindName,t,body.pos,body.vel,body.heading,body.grounded,body.motion,input]);
+    const cached = key ? movementCache.get(key) : undefined;
+    if (cached?.scene === scene) return {...cached.value,motion:motionOf(kindName,cached.value.motion)};
+    let failed = false;
+    const out = stepMove(fn, body, input, moveCtx, Math.max(1, Math.floor(schema.settings.budget.tick / 4)), kindOf.get(kindName)?.motion ?? [], dims, (err) => { failed = true; if (!(err instanceof BudgetError)) console.warn('[room] move', err); });
     if (out.steps?.length) substepKinds.add(kindName);
     const kind = kindOf.get(kindName), r = kind?.radius ?? 0;
     const height = kind?.height || 2 * r;
     out.pos = vec3(boundPosition(out.pos,map,r,height,dims), dims);
+    if (key && !failed) {
+      movementCache.set(key,{scene,value:{...out,motion:motionOf(kindName,out.motion)}});
+      if(movementCache.size>128)movementCache.delete(movementCache.keys().next().value!);
+    }
     return out;
   }
   /* ---------------------------------------------------------------- the own actions, predicted (0.46.3) */
@@ -705,8 +753,10 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     }
     if (before && before.e !== f.e) hostAges.length = 0;
     hostAges.push(Math.max(0, net.now() - s.st)); if (hostAges.length > 40) hostAges.shift();
+    hostMedian = quantile(hostAges, .5);
     if (before && before.e !== f.e) fxQueue.length = 0;
     const changedEpoch = f.e !== epoch;
+    if (changedEpoch) { presented=null; routing=null; route=[]; }
     epoch = f.e;
     const seat = net.seat;
     let me: Unpacked | null = null;
@@ -716,6 +766,15 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       const row = f.rows.find((x) => x[0] === seat);
       if(changedEpoch)applications.clear();
       if(row?.[6]===471){for(let i=7;i+1<row.length;i+=2)applications.set(row[i],row[i+1]);while(applications.size>128)applications.delete(applications.keys().next().value!);}
+      // A return hands the body back at the server's pose with a new revision. It is the same body, still on the
+      // screen: keep drawing it from where it is shown unless the game says it was really placed meanwhile.
+      const prior = held2.at(-2)?.ents.get(me.id) ?? null;
+      if (placed && !changedEpoch && returningUntil > clock() && mine?.id === me.id && mine.r !== me.r && presented?.id === me.id && presented.r === mine.r) {
+        let respawn = false;
+        if (opts.respawned && prior) { try { respawn = Boolean(opts.respawned(entityOf(prior, true, false), entityOf(me, true, false))); } catch (err) { console.warn('[room] respawned', err); } }
+        if (!respawn) { presented.r = me.r; presented.at = clock(); }
+        returningUntil = 0;
+      }
       if (placed || !base) {
         adopt(me); rebase(f.k, changedEpoch ? 'epoch' : 'placement');
         if (placed) emit('placed', entityOf(me, true));
@@ -830,6 +889,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
         // our own +/-5% steering inflates the 40-sample jitter window and winds the clock ever further ahead.
         observedLeadAt = now;
         leads.push(row[3] / 16 - phaseAt(now - rtt)); if (leads.length > 40) leads.shift();
+        leadTarget = .5 + Math.max(0, quantile(leads, .5) - quantile(leads, .05));
+        leadMedian = quantile(leads.slice(-8), .5);
         const med = medianLead(), target = targetLead();
         // A changing jitter estimate must not discard already stamped input. Slew the
         // clock; late movement is settled by the server's retained history.
@@ -876,7 +937,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   net.on('snapshot', onSnapshot);
   net.on('role', (e) => { if (e.snap) onSnapshot(e.snap); if (net.offline && !net.rulesHosting) setStatus(net.closedWhy ? 'closed' : 'offline'); });
   net.on('link', (e) => {
-    if (e.state === 'online') { base = null; if (status !== 'playing') setStatus('connecting'); } else if (e.state === 'closed') setStatus('closed'); else if (e.state === 'alone' || e.state === 'offline') setStatus('offline');
+    if (e.state === 'online') { returningUntil = clock() + 3000; base = null; if (status !== 'playing') setStatus('connecting'); } else if (e.state === 'closed') setStatus('closed'); else if (e.state === 'alone' || e.state === 'offline') setStatus('offline');
   });
   net.on('round', (r) => { if (r.results) { results = r.results; if (round) { round = { ...round, results }; emit('round', roundNow()); } } });
   net.on('event', (e) => {
@@ -923,7 +984,15 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
    * the two, by how much of the tick has passed, and the copy is thrown away. So the stick answers on the next
    * drawn frame, not on the next tick.
    */
-  function meNow(): Entity | null {
+  let routing: ReturnType<typeof correctionPath> | null = null;
+  let route: Vec3[] = [];
+  let routeDirection = 0;
+  let presentedEntity: Entity | null = null;
+  let presentationQueued = false;
+  let forecast: { mine: Mine; pos: Vec3; motion: Record<string, unknown>; tick: number; key: string; geometry: unknown; next: ReturnType<typeof runMove> } | null = null;
+  let presented: { id: string; r: number; pos: Vec3; vel: Vec3; at: number } | null = null;
+  function meNow(present = false): Entity | null {
+    if (present && presentedEntity) return presentedEntity;
     if (predicting) { const u = mine && predictionFrame?.ents.get(mine.id); return u ? entityOf(u, true) : null; }
     if (solo) return solo.me;
     if (!mine || !latest) return null;
@@ -946,7 +1015,10 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       // A recorded substep path needs the whole tick's forecast instead: include
       // the remaining duration of controls held now, then sample its actual steps.
       for (const [name, fd] of kind.input) now[name] = (fd.t === 'press' || fd.t === 'pulse') ? (pressed.get(name) ?? (fd.t === 'pulse' && pulseQueue[0]?.name===name ? pulseQueue[0].value : fd.t === 'press' ? false : 0)) : fd.t === 'held' ? coerce(fd, heldMean(name, fd.init, Math.min(clock(), edgeOf(stepped + 1)), false, substepKinds.has(kind.name) ? edgeOf(stepped + 1) : Math.min(clock(), edgeOf(stepped + 1))), dims) : coerce(fd, sample[name] ?? fd.init, dims);
-      const next = runMove(kind.name, { pos: mine.pos, vel: mine.vel, heading: mine.heading, grounded: mine.grounded, motion: motionOf(mine.kind, mine.motion) }, Object.freeze(now), stepped + 1);
+      const forecastKey = JSON.stringify(now), scene = geometryAt();
+      const reuse = !map.physics && substepKinds.has(kind.name) && forecast && forecast.mine === mine && forecast.pos === mine.pos && forecast.motion === mine.motion && forecast.tick === stepped && forecast.key === forecastKey && forecast.geometry === scene;
+      const next = reuse ? forecast!.next : runMove(kind.name, { pos: mine.pos, vel: mine.vel, heading: mine.heading, grounded: mine.grounded, motion: motionOf(mine.kind, mine.motion) }, Object.freeze(now), stepped + 1);
+      forecast = {mine, pos:mine.pos, motion:mine.motion, tick:stepped, key:forecastKey, geometry:scene, next};
       // A landing does not take the whole tick (0.46.5): the body met the ground part way through it. How far through is
       // read from the fall it would have made at the speed it entered the tick with; it is drawn down to the ground by
       // then and standing from then, not sinking until the tick's end.
@@ -995,26 +1067,115 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // permission to cross a floor. Sweep from a valid movement pose, never feed
     // the clipped drawing back into prediction or authority.
     const constrain = (from: Vec3, to: Vec3): Vec3 => {
-      if (dims !== 2 || !kind || kind.owner) return to;
+      if (dims !== 2 || !kind || kind.owner || distance(from, to) < 1e-7) return to;
       const body = {pos: from};
       sweepMap(geometryAt(), body, {x:periodicDelta(from.x,to.x,map.wrap?.x),y:periodicDelta(from.y,to.y,map.wrap?.y),z:periodicDelta(from.z,to.z,map.wrap?.z)}, kind.radius, dims,
         {shape:kind.shape ?? 'circle',radius:kind.radius,height:kind.height || 2*kind.radius,terrain:kind.terrain});
       return body.pos;
     };
-    pos = constrain(safeOrigin, pos);
+    // An established box cursor is swept below from the actual displayed side.
+    // Sweeping its target from a second origin first duplicates the same query
+    // and does not add safety. New placements and other body types keep it.
+    const hasCursor = present && dims === 2 && kind?.shape === 'box' && !kind.owner && presented?.id === mine.id && presented.r === mine.r;
+    if (!hasCursor) pos = constrain(safeOrigin, pos);
     const offset = visualOffset(clock(), pos, settled);
-    pos = constrain(pos, wrapPoint({ x: pos.x + offset.x, y: pos.y + offset.y, z: pos.z + offset.z },map.wrap));
+    const offsetTarget = wrapPoint({ x: pos.x + offset.x, y: pos.y + offset.y, z: pos.z + offset.z },map.wrap);
+    pos = hasCursor ? offsetTarget : constrain(pos, offsetTarget);
+    if (present && dims === 2 && kind?.shape === 'box' && !kind.owner) {
+      const now = clock();
+      if (presented && presented.id === mine.id && presented.r === mine.r) {
+        const from = presented.pos;
+        let forward = velocity.x * presented.vel.x >= 0 ? Math.sign(velocity.x) : 0;
+        if (opts.correctionDirection) {
+          try {
+            const intent = opts.correctionDirection(sample, mine.vel);
+            // An explicit intent must not be overridden by stale replay velocity.
+            // A game can return neutral during genuine braking/reversal inertia.
+            if (Number.isFinite(intent)) forward = Math.sign(intent);
+          }
+          catch (err) { console.warn('[room] correctionDirection', err); }
+        }
+        if ((routing || route.length) && forward !== routeDirection) { routing=null; route=[]; }
+        routeDirection = forward;
+        const routeGoal = routing?.goal ?? route.at(-1);
+        if (routeGoal && distance(routeGoal, pos) > Math.max(2,kind.radius*4)) { routing=null; route=[]; }
+        if (route[0] && forward * periodicDelta(from.x,route[0].x,map.wrap?.x) < -.001) { routing=null; route=[]; }
+        if (route.length) {
+          while(route.length && distance(from,route[0])<.01)route.shift();
+        }
+        const destination = route[0] ?? pos;
+        const elapsed = Math.max(0, now - presented.at);
+        // Bound presentation by time, including expiring offsets and changed catch-up paths.
+        const length = distance(from, destination);
+        // Falling cannot spend a horizontal correction. Corrections add only
+        // blend speed to the actual movement, not a body's declared speed cap.
+        const blendSpeed = kind.radius / Math.max(.1,predict.blendMs/1000);
+        // Include the whole recorded tick's velocities: a takeoff/landing can
+        // change velocity abruptly between samples without being a correction.
+        let verticalSpeed = Math.max(Math.abs(velocity.y),Math.abs(presented.vel.y),Math.abs(mine.vel.y),Math.abs(preview?.vel.y ?? 0));
+        const recorded = preview?.steps;
+        if (recorded) for (let i=0;i<recorded.length;i++) verticalSpeed = Math.max(verticalSpeed,Math.abs(recorded[i].vel.y));
+        // Leave headroom for a substep entered part-way through a render interval.
+        verticalSpeed *= 1.5;
+        const advance = (axis: 'x' | 'y') => {
+          const delta = periodicDelta(from[axis],destination[axis],map.wrap?.[axis]);
+          // A landing can set velocity to zero before the sampled pose reaches
+          // contact. The adjacent movement velocities retain that real travel.
+          const travel = axis === 'y' ? verticalSpeed : Math.max(Math.abs(velocity.x),Math.abs(presented!.vel.x));
+          const allowance = (travel + blendSpeed) * elapsed / 1000;
+          return from[axis]+Math.max(-allowance,Math.min(allowance,delta));
+        };
+        const target = {...wrapPoint({x:advance('x'),y:advance('y'),z:0},map.wrap)};
+        // A route is a correction too: it cannot pull against continuing motion.
+        if (forward * periodicDelta(from.x,target.x,map.wrap?.x) < 0) target.x = from.x;
+        // A stalled frame cannot spend its whole elapsed-time allowance in one
+        // visible jump. Keep backlog travel below 1.4 body widths per drawing;
+        // authority/prediction keep their real clock and placements bypass this.
+        const frameDistance = distance(from,target), frameLimit = Math.max(.1,kind.radius*2.8);
+        if (frameDistance > frameLimit) {
+          const fraction = frameLimit / frameDistance;
+          target.x = from.x + periodicDelta(from.x,target.x,map.wrap?.x)*fraction;
+          target.y = from.y + periodicDelta(from.y,target.y,map.wrap?.y)*fraction;
+        }
+        let next = constrain(from, target);
+        // Slide the residual along the contact, starting on the side actually drawn.
+        if (distance(next, target) > .002) {
+          next = constrain(next, {x:target.x,y:next.y,z:0});
+          next = constrain(next, {x:next.x,y:target.y,z:0});
+        }
+        if (!route.length && distance(next, target) > .01 && distance(from,next) < .01 && length > .1) {
+          routing ??= correctionPath(from,pos,Math.max(.25,2*kind.radius));
+          const found=routing.advance((a,b)=>forward * periodicDelta(a.x,b.x,map.wrap?.x) >= -.001 && distance(constrain(a,b),b)<.002);
+          if(found) { route=[...found]; routing=null; }
+        }
+        pos = next;
+      }
+      if (!presented || presented.id !== mine.id || presented.r !== mine.r) { routing=null;route=[]; }
+      presented = {id:mine.id,r:mine.r,pos,vel:velocity,at:now};
+    }
     if (headingBlend) {
       const t = predict.blendMs > 0 ? Math.min(1, (clock() - headingBlend.at) / predict.blendMs) : 1;
       heading = blendHeading(headingBlend.from, heading, t, dims);
       if (t >= 1) headingBlend = null;
     }
-    return entityOf({ ...server, ...(kind && predictors[kind.name] ? { fields: (base ? previewFields : null) ?? mine.fields } : {}), pos, vel: velocity, heading, grounded, motion }, true);
+    const result = entityOf({ ...server, ...(kind && predictors[kind.name] ? { fields: (base ? previewFields : null) ?? mine.fields } : {}), pos, vel: velocity, heading, grounded, motion }, true);
+    // Synchronous readers (HUD, scene, probes) share one presentation. Clear at
+    // the microtask boundary: an rAF clear can run after the next drawing callback,
+    // reusing an old pose and then spending two callbacks' travel at once.
+    // Inputs and snapshots still invalidate immediately.
+    if (present && typeof window !== 'undefined') {
+      presentedEntity = result;
+      if (!presentationQueued) {
+        presentationQueued = true;
+        const clear = () => { presentedEntity = null; presentationQueued = false; };
+        queueMicrotask(clear);
+      }
+    }
+    return result;
   }
-  function drawn(id: string): Entity | null {
+  function drawn(id: string, s = net.sample()): Entity | null {
     if (solo) return solo.get(id);
-    if (mine && id === mine.id) return meNow();
-    const s = net.sample();
+    if (mine && id === mine.id) return meNow(true);
     const a = s ? frameOf(s.a) : latest;
     const b = s ? frameOf(s.b) : latest;
     const ea = a?.ents.get(id); const eb = b?.ents.get(id);
@@ -1022,8 +1183,14 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // A placed body jumps: nobody's view glides across a placement.
     if (ea.r !== eb.r || a?.e !== b?.e || !s) return entityOf(eb);
     const t = s.alpha;
+    // Static pickups and scenery need no new vectors or wrappers for every HUD,
+    // scene and probe traversal. Fields still follow the sampled snapshot.
+    if (ea.grounded === eb.grounded && ['pos','vel','heading'].every(key => {
+      const x=ea[key as 'pos'], y=eb[key as 'pos']; return x.x===y.x && x.y===y.y && x.z===y.z;
+    })) return entityOf(t < 1 ? ea : eb);
     const h = blendHeading(ea.heading, eb.heading, t, dims);
-    return entityOf({ ...(t < 1 ? ea : eb), grounded: t >= 1 ? eb.grounded : ea.grounded && (t === 0 || eb.grounded), pos: vec3(blendPosition(ea.pos, eb.pos, t, map.wrap), dims), vel: vec3({ x: lerp(ea.vel.x, eb.vel.x, t), y: lerp(ea.vel.y, eb.vel.y, t), z: lerp(ea.vel.z, eb.vel.z, t) }, dims), heading: h });
+    // This interpolated key exists for one read only; caching it retains useless weak entries.
+    return entityOf({ ...(t < 1 ? ea : eb), grounded: t >= 1 ? eb.grounded : ea.grounded && (t === 0 || eb.grounded), pos: vec3(blendPosition(ea.pos, eb.pos, t, map.wrap), dims), vel: vec3({ x: lerp(ea.vel.x, eb.vel.x, t), y: lerp(ea.vel.y, eb.vel.y, t), z: lerp(ea.vel.z, eb.vel.z, t) }, dims), heading: h }, false, false);
   }
   function get(id: string): Entity | null { const g = ghosts.get(id); return g ? ghostEntity(g) : drawn(id); }
   function each(kind: string, fn: (e: Entity) => void): void {
@@ -1036,7 +1203,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // Until the newer snapshot is reached, what the older one holds is still drawn; what only the newer one holds waits for it.
     for (const f of [a, s && s.alpha >= 1 ? b : null, a ? null : b]) if (f) for (const u of f.ents.values()) if (u.kind === kind) ids.add(u.id);
     if (mine && mine.kind === kind) ids.add(mine.id);
-    for (const id of ids) { const e = drawn(id); if (e) fn(e); }
+    for (const id of ids) { const e = drawn(id, s); if (e) fn(e); }
     // A confirmed ghost stands in until the server's own entity is drawn (it arrives a moment behind, interpolated).
     for (const g of [...ghosts.values()]) if (g.kind === kind) { if (g.real && ids.has(g.real)) { ghosts.delete(g.id); emit('leave', ghostEntity(g)); } else fn(ghostEntity(g)); }
   }
@@ -1076,25 +1243,25 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     net.line(net.full ? 'This room is full · playing on your own until a seat is free' : 'Playing on your own until the next round');
     emit('status', 'offline', true);
   }
-  let extra: Record<string, () => unknown> = {};
+  const extra: Record<string, () => unknown> = {};
   const myScore = (): number | null => { if (solo) { const k = schema.kinds.find(k => k.player); return k?.score && solo.me ? Number(solo.me[k.score]) || 0 : null; } const k = myKind(); const u = mine && latest ? latest.ents.get(mine.id) : null; return k?.score && u ? Number(u.fields[k.score]) || 0 : null; };
   const busy = (): boolean => solo ? !solo.me : status !== 'playing' || !mine || latest?.ents.get(mine.id)?.away === true;
   // The probes the testing tools read (`check`, `shoot`, `perf`, the playtest judge): the same two objects a game written the old way publishes.
   net.expose({
-    self: () => { const m = meNow(); return m ? { x: m.pos.x, y: m.pos.y, z: m.pos.z } : null; },
+    self: () => { const m = meNow(true); return m ? { x: m.pos.x, y: m.pos.y, z: m.pos.z } : null; },
     peer: (seat: number) => { if (!latest) return null; for (const u of latest.ents.values()) if (u.seat === seat) return { x: u.pos.x, y: u.pos.y, z: u.pos.z }; return null; },
     movement: () => { const kinds = schema.kinds.filter(k => k.player); return kinds.length && kinds.every(k => k.maxSpeed === 0) ? 'stationary' : 'spatial'; },
-    prediction: () => ({ ...correction, observedLeadAt, lastSendAt, now: clock(), serverTick: latest?.k, tick: stepped, catchTick, lead: targetLead(), medianLead: medianLead(), rate: speed, rtt: authorityRtt(), hostAge: quantile(hostAges, 0.5), pending: pending.length, applications: [...applications] }),
+    prediction: () => ({ ...correction, observedLeadAt, lastSendAt, now: clock(), serverTick: latest?.k, tick: stepped, catchTick, lead: targetLead(), medianLead: medianLead(), rate: speed, rtt: authorityRtt(), hostAge: hostMedian, pending: pending.length, applications: [...applications] }),
     scores: () => roster().map((r) => ({ seat: r.seat, score: r.score })),
     score: myScore, tick: () => latest?.k ?? 0, epoch: () => epoch, hosted: () => net.rulesHosting ? 'browser' : schema.settings.host, status: () => solo ? 'offline' : status,
   });
   if (typeof window !== 'undefined') {
     exposePort(net as Netplay<unknown, unknown, unknown>, {
       view: 'top', size: schema.kinds.find((k) => k.player)?.radius ?? 0.5,
-      self: () => { const m = meNow(); return m ? { x: m.pos.x, y: m.pos.y } : null; },
+      self: () => { const m = meNow(true); return m ? { x: m.pos.x, y: m.pos.y } : null; },
       basis: opts.screenBasis ?? (() => ({ right: [1, 0], up: [0, 1] })),
       score: myScore, busy: () => (typeof extra.busy === 'function' ? Boolean(extra.busy()) : busy()),
-      extra: new Proxy({}, { get: (_t, key) => (typeof key === 'string' ? extra[key] : undefined), ownKeys: () => Object.keys(extra), getOwnPropertyDescriptor: (_t, key) => (typeof key === 'string' && extra[key] ? { enumerable: true, configurable: true, value: extra[key] } : undefined) }) as Record<string, () => unknown>,
+      extra,
     });
   }
   const timer = opts.timers === false ? null : setInterval(pump, Math.max(8, period / 2));
@@ -1143,7 +1310,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     get viewTick() { return solo ? solo.viewTick : viewTickNow(); },
     get status() { return solo ? 'offline' : status; },
     get seat() { return solo ? solo.seat : net.seat; },
-    get me() { pump(); return meNow(); },
+    get me() { pump(); return meNow(true); },
     each, get,
     ray: (from,direction,max,options) => solo ? solo.ray(from,direction,max,options) : viewRay(from,direction,max,options)[0],
     rays: options => solo ? solo.rays(options) : raySnapshot(mapAt(latest?.k??0),viewTargets(atTickOf(options)),dims,options,mine?.id),
@@ -1180,6 +1347,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       if (changed) pump();
       const shown = changed ? meNow()?.pos : null;
       for (const [name, fd] of kind?.input ?? []) if ((fd.t === 'press' || fd.t === 'pulse') && coerce(fd,s[name],dims)) { const value=coerce(fd,s[name],dims) as number | boolean; if(fd.t==='pulse'){pulseCount+=1;const target=Math.max(stepped+1,(pulseQueue.at(-1)?.t??stepped)+1);pulseQueue.push({name,value:Number(value),n:pulseCount,t:target});net.send('pulse',[epoch,name,value,target,pulseCount]);} else pressed.set(name,value); }
+      if (changed) presentedEntity = null;
       sample = next;
       // A discrete action belongs to the present, even while an unseen impulse is
       // being drawn from history. Resume the live prediction and let the existing
@@ -1204,7 +1372,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     get round() { return roundNow(); },
     get roster() { return roster(); },
     follow(id) { const e = id ? latest?.ents.get(id) : null; net.follow(e && e.seat !== undefined ? e.seat : null); },
-    probe(x) { extra = { ...extra, ...x }; },
+    probe(x) { Object.assign(extra, x); },
     ask(id, askId, args = {}) { if (solo) return; const e = latest?.ents.get(id); if (e && e.seat !== undefined) agents?.ask(e.seat, askId, args); },
     askButtons(id, offer = {}) { if (solo) return []; const e = latest?.ents.get(id); return e && e.seat !== undefined ? agents?.askButtons(e.seat, offer) ?? [] : []; },
     tune, get map(){return solo ? solo.map : mapAt(latest?.k??0);}, net: net as Netplay,

package/site/SITE.md

@@ -591,3 +591,16 @@ credentials.
 X decides what it shows, may cache tags, and may change or stop this behavior.
 Local success does not prove that X will display a card. The studio can use the
 off switch above if it does not want to offer a game through a video-oriented card.
+
+
+## Canonical address and decorative app frames
+
+Set `cloudflare.domain` for the canonical public address. The manifest uses that
+address even when fetched from workers.dev; browser pages on the alias redirect,
+while discovery and tool transports remain reachable. Listing requires an explicit
+`homie.directory: true` or URL; existing claims remain valid.
+
+An iframe inside `.hero-media` is decorative and lets the parent page scroll.
+Add `data-interactive` only when people should interact with the hero. Ordinary app
+frames permit Web Share and downloads; browser capability and a user gesture still
+apply. App shells allow normal touch scrolling and text selection.

package/tools/TOOLS.md

@@ -179,3 +179,12 @@ and removes secrets directly; remote owner tools `studio_events_webhook_status`
 and `studio_events_webhook_test` inspect delivery and test it. The receiver verifies
 Standard Webhooks signatures, deduplicates events, then wakes the owner's AI to use
 its own service connectors.
+
+
+## Signed-in connector address
+
+Use `/mcp/auth` for owner and staff connectors. Its anonymous 401 includes the
+`WWW-Authenticate` resource metadata URL for `/.well-known/oauth-protected-resource/mcp`.
+Both transports use the same `/mcp` OAuth resource; `/mcp` remains public without a
+token. An approved connection retains the account’s current app grants, not a copy
+of its old permissions. Manage connections at `/_studio/office/connections`.

package/worker/arrival.mjs

@@ -1,3 +1,4 @@
+import {appWords} from './app-format.mjs';
 /**
  * THE ARRIVAL (0.26.0): the play page and the big screen never open on a blank screen. From the page's first paint
  * until the game says it is playable, an arrival card covers the game's frame in the game's own look: its title and
@@ -66,7 +67,7 @@ export function arrivalCard(cat, g, { screen = false, off = false } = {}) {
   const pitch = String(L.pitch ?? '').trim() || firstSentence(g?.blurb);
   const studio = cat?.studio?.name ?? '';
   const keys = screen
-    ? [['tv', L.controls?.tv ?? 'Phones are the controllers: scan the code to play.']]
+    ? [['tv', L.controls?.tv ?? (g.kind === 'app' ? appWords(g).join : 'Phones are the controllers: scan the code to play.')]]
     : [['phone', L.controls?.phone], ['desk', L.controls?.computer]].filter(([, v]) => v);
   const art = wide || tall
     ? `<picture class="arrive-art">${wide && tall ? `<source media="(min-aspect-ratio: 3/4)" srcset="${esc(wide)}">` : ''}<img src="${esc(tall ?? wide)}" alt="" decoding="async" fetchpriority="high" style="object-position:${esc(focus)}"></picture>`

package/worker/build-id.mjs

@@ -1,2 +1,2 @@
 // Generated by lib/build-identity.mjs; identifies the bundled runtime sources.
-export const STUDIO_BUILD = Object.freeze({"version":"0.51.0","sha256":"5a8e0df9f204fbe4978d618b507fe5ae0c5005ef4f106ac4b78dfac5f6c02b7b"});
+export const STUDIO_BUILD = Object.freeze({"version":"0.51.2","sha256":"bffe9d1a55a4cbe04cb14a1c1d20fe5d32e7a1aa2d2a637d81b45c10c4087b64"});

package/worker/directory-choice.mjs

@@ -0,0 +1,9 @@
+/** Only an explicit choice enables a new directory claim. */
+export function directoryUrl(value) {
+  if (value === true) return 'https://homie.rocks';
+  if (typeof value !== 'string') return null;
+  try {
+    const url = new URL(value);
+    return url.protocol === 'https:' || url.protocol === 'http:' && ['localhost', '127.0.0.1'].includes(url.hostname) ? url.origin : null;
+  } catch { return null; }
+}

package/worker/index.mjs

@@ -1,3 +1,4 @@
+import { directoryUrl } from './directory-choice.mjs';
 import {APP_STORAGE_JS} from './app-frame.mjs';
 import {recordsPage} from './records-page.mjs';
 import { RULES_WIRING_MESSAGE } from './rules-wiring.mjs';
@@ -235,13 +236,7 @@ const repoOf = (env) => { const r = String(env.HOMIE_REPO ?? '').trim(); return
 const repoSaid = new Map();
 
 export function directoryOf(cat) {
-  const d = cat?.studio?.directory;
-  if (d === null || d === false) return null;
-  const at = String(d ?? 'https://homie.rocks').replace(/\/+$/, '');
-  try {
-    const u = new URL(at);
-    return u.protocol === 'https:' || (u.protocol === 'http:' && ['127.0.0.1', 'localhost'].includes(u.hostname)) ? u.origin : null;
-  } catch { return null; }
+  return directoryUrl(cat?.studio?.directory);
 }
 
 /** This address's claim: kept, else asked of the directory now (and kept), else an older studio's single claim. */
@@ -251,6 +246,7 @@ async function claimOf(env, cat, url) {
   if (claimed.has(origin) && (!repo || repoSaid.get(origin) === repo)) return claimed.get(origin);
   const kept = await storedClaim(env, origin);
   if (kept?.own && (!repo || kept.repo === repo)) { claimed.set(origin, kept.own); if (repo) repoSaid.set(origin, repo); return kept.own; }
+  if (kept?.older) return kept.older;
   const directory = directoryOf(cat);
   const local = url.protocol === 'http:' && ['127.0.0.1', 'localhost'].includes(url.hostname);
   const may = directory && env.DB && env.HOMIE_PREVIEW !== '1' && (url.protocol === 'https:' || (local && directory.startsWith('http://')))
@@ -543,7 +539,7 @@ async function gameDocument(request, env, url, game, meta, cat, { agent = null }
       'cache-control': 'no-store, no-transform',
       'access-control-allow-origin': '*',
       // The game runs in an opaque origin: it cannot read this site's storage or cookies.
-      'content-security-policy': `sandbox allow-scripts allow-pointer-lock allow-forms allow-modals allow-popups; frame-ancestors ${embedded ? `'self' ${embedAncestors(cat, url.origin, env.HOMIE_EMBED_PREVIEW === '1').replace("'none'", '')}` : frameAncestors(cat)}`,
+      'content-security-policy': `sandbox allow-scripts allow-pointer-lock allow-forms allow-modals allow-popups${meta.kind === 'app' ? ' allow-downloads' : ''}; frame-ancestors ${embedded ? `'self' ${embedAncestors(cat, url.origin, env.HOMIE_EMBED_PREVIEW === '1').replace("'none'", '')}` : frameAncestors(cat)}`,
     },
   });
 }
@@ -678,9 +674,18 @@ async function route(request, env, ctx) {
   const getAll = () => (catP ??= catalogue(env, url.origin).then((cat) => named(cat, env)));
   const getCat = () => (pubP ??= Promise.all([getAll(), settingsOf(env)]).then(([cat, settings]) => publicCatalogue(cat, settings, env)));
 
+  // Keep tool transports and discovery on the alias; redirect browser pages only.
+  if (read && url.hostname.endsWith('.workers.dev') && env.HOMIE_PREVIEW !== '1'
+      && request.headers.get('upgrade')?.toLowerCase() !== 'websocket'
+      && !/\/(?:api|__[a-z]+)(?:\/|$)/.test(path)
+      && !/^\/(?:\.well-known(?:\/|$)|api(?:\/|$)|mcp(?:\/|$)|oauth(?:\/|$)|hooks(?:\/|$)|_studio(?:\/|$))/.test(path)) {
+    const canonical = (await getAll()).studio?.canonical;
+    if (canonical && canonical !== url.origin) return Response.redirect(canonical + url.pathname + url.search, 308);
+  }
+
   if (path === '/_studio/office/functions') return (await import('./functions.mjs')).functionsRoute(request,env,await getAll());
 
-  if (path === '/mcp' || path.startsWith('/hooks/tools/') || path.startsWith('/oauth/') || path.startsWith('/.well-known/oauth-') || path === '/_studio/office/connections') {
+  if (path === '/mcp' || path === '/mcp/auth' || path.startsWith('/hooks/tools/') || path.startsWith('/oauth/') || path.startsWith('/.well-known/oauth-') || path === '/_studio/office/connections') {
     const { remoteMcp } = await import('./mcp.mjs');
     return remoteMcp(request, env, ctx, { catalogueOf: getAll, definitions: await studioTools() });
   }
@@ -726,6 +731,10 @@ async function route(request, env, ctx) {
   }
   if (path === '/.well-known/homie-studio.json') {
     const cat = await getCat();
+    const canonical = cat.studio?.canonical;
+    if (canonical && env.HOMIE_PREVIEW !== '1' && url.protocol === 'https:') {
+      const address = new URL(canonical); url.protocol = address.protocol; url.host = address.host;
+    }
     const sharing = Boolean(cat.studio?.stats?.share);
     const [played, byGame] = sharing ? await Promise.all([playedThisWeek(env), playedByGame(env)]) : [null, null];
     // studio.json `"rooms": { "share": false }` keeps the rooms off the hub: a manifest that names no `rooms` shares none.

package/worker/mcp.mjs

@@ -158,7 +158,7 @@ export async function remoteMcp(request,env,ctx,{catalogueOf,definitions=[]}) {
       });
       return s;
     };
-    return createMcpHandler(server)(request,env,ctx);
+    return createMcpHandler(server,{route:path === '/mcp/auth' ? '/mcp/auth' : '/mcp'})(request,env,ctx);
   };
   if(localIdentity)return api(request,scoped,ctx);
   const provider=new OAuthProvider({
@@ -211,7 +211,7 @@ export async function remoteMcp(request,env,ctx,{catalogueOf,definitions=[]}) {
         const rows=(await env.DB.prepare(owner?'SELECT c.*,p.name FROM mcp_connections c LEFT JOIN players p ON p.id=c.person ORDER BY c.created DESC LIMIT 100 OFFSET ?1':'SELECT c.*,p.name FROM mcp_connections c LEFT JOIN players p ON p.id=c.person WHERE c.person=?1 ORDER BY c.created DESC LIMIT 100 OFFSET ?2').bind(...(owner?[offset]:[person,offset])).all()).results;
         const events=owner?(await env.DB.prepare('SELECT a.*,p.name FROM mcp_audit a LEFT JOIN players p ON p.id=a.person ORDER BY a.id DESC LIMIT 100 OFFSET ?1').bind(offset).all()).results:[];
         const names=new Map(await Promise.all([...new Set([...rows,...events].map(r=>r.client).filter(Boolean))].map(async id=>[id,(await oauth.lookupClient(id).catch(()=>null))?.clientName??id])));
-        return html(`<h1>Your studio's AI connections</h1><p>MCP address: <code>${esc(origin)}/mcp</code></p><ul>${rows.map(r=>`<li>${esc(r.name??(r.person.startsWith('office-')?'Owner browser':r.person))} · ${esc(names.get(r.client))} · ${r.revoked?'Revoked':`<form method="post"><input type="hidden" name="connection" value="${esc(r.id)}"><button>Revoke</button></form>`}</li>`).join('')}</ul><h2>Recent tool calls</h2><ul>${events.map(r=>`<li>${esc(new Date(r.at).toISOString())} · ${esc(r.name??(r.person?.startsWith('office-')?'Owner browser':r.person)??'Public')} · ${esc(names.get(r.client)??'Anonymous')} · ${esc(r.tool)} · ${esc(r.outcome)}</li>`).join('')}</ul><nav>${page?`<a href="?page=${page-1}">Newer</a>`:''}${rows.length===100||events.length===100?`<a href="?page=${page+1}">Older</a>`:''}</nav>`);
+        return html(`<h1>Your studio's AI connections</h1><p>Signed-in MCP address: <code>${esc(origin)}/mcp/auth</code> · Public: <code>${esc(origin)}/mcp</code></p><ul>${rows.map(r=>`<li>${esc(r.name??(r.person.startsWith('office-')?'Owner browser':r.person))} · ${esc(names.get(r.client))} · ${r.revoked?'Revoked':`<form method="post"><input type="hidden" name="connection" value="${esc(r.id)}"><button>Revoke</button></form>`}</li>`).join('')}</ul><h2>Recent tool calls</h2><ul>${events.map(r=>`<li>${esc(new Date(r.at).toISOString())} · ${esc(r.name??(r.person?.startsWith('office-')?'Owner browser':r.person)??'Public')} · ${esc(names.get(r.client)??'Anonymous')} · ${esc(r.tool)} · ${esc(r.outcome)}</li>`).join('')}</ul><nav>${page?`<a href="?page=${page-1}">Newer</a>`:''}${rows.length===100||events.length===100?`<a href="?page=${page+1}">Older</a>`:''}</nav>`);
       }
       return json({error:'not found'},404);
     }},

package/worker/pages.mjs

@@ -200,6 +200,7 @@ iframe.game { position: fixed; inset: 0; width: 100%; height: 100%; border: 0; d
 .notice .acts a.primary { background: var(--hot); color: #0b0b10; border-color: transparent; }
 [hidden] { display: none !important; }
 ${arrive.css}
+${g.kind === 'app' ? 'html,body,iframe.game{touch-action:auto;user-select:auto;-webkit-user-select:auto;-webkit-touch-callout:default}' : ''}
 ${embed ? `html,body{touch-action:auto}.room.at-top-center{transform:none;left:auto;right:max(8px,env(safe-area-inset-right))}.embed-open{display:flex;align-items:center;min-height:44px;color:inherit}.embed-note{font:12px/1.4 system-ui;overflow-wrap:anywhere}.sheet{position:fixed;inset:calc(max(8px,env(safe-area-inset-top)) + 48px) max(8px,env(safe-area-inset-right)) auto auto;max-width:calc(100vw - max(8px,env(safe-area-inset-left)) - max(8px,env(safe-area-inset-right)));max-height:calc(100dvh - max(8px,env(safe-area-inset-top)) - 48px - max(8px,env(safe-area-inset-bottom)));overflow:auto;overscroll-behavior:contain;touch-action:pan-y}.sheet.more::after{content:'▾ more below';position:sticky;bottom:-12px;display:block;margin:0 -12px -12px;padding:16px 0 5px;text-align:center;font:600 11px/1 system-ui;color:#cfd6e6;background:linear-gradient(transparent,rgba(8,12,22,.98) 60%);pointer-events:none}.sheet .embed-help{margin:8px 2px;font:500 12px/1.4 system-ui;color:#aab3c7}html:not(.player-frame) .frame-only{display:none}.sheet a,.sheet button{min-height:44px}.sheet .foot a,.sheet .foot button{display:inline-flex;align-items:center}.embed-open .frame-only{margin-left:4px}.player-top iframe.game{inset:env(safe-area-inset-top) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left);width:calc(100% - env(safe-area-inset-left) - env(safe-area-inset-right));height:calc(100% - env(safe-area-inset-top) - env(safe-area-inset-bottom))}.arrive-in{padding:12px}.arrive-title{font-size:clamp(24px,7vw,52px)}` : ''}
 ${shopControl ? `.shop-control{color:#eef1f8;font:600 13px/1.2 system-ui;position:fixed;top:env(safe-area-inset-top);left:max(8px,env(safe-area-inset-left));height:52px;display:flex;align-items:center;z-index:6}.shop-control button{min-height:44px;padding:0 18px}html body .room.room{flex-direction:column;align-items:flex-end;top:max(4px,env(safe-area-inset-top));right:max(8px,env(safe-area-inset-right));left:auto;bottom:auto;transform:none}html body iframe.game.game{top:calc(env(safe-area-inset-top) + 52px);height:calc(100% - env(safe-area-inset-top) - env(safe-area-inset-bottom) - 52px)}` : ''}
 ${SERVER_CSS}${CHAT_CSS}${g.saves && !screen ? SAVES_SHELL_CSS : ''}${shop ? SHOP_SHELL_CSS : ''}${pillUi}`;
@@ -241,7 +242,7 @@ ${embed ? `    <p class="embed-help">Sound starts after a press. If pointer lock
 </div>
 <div class="toast" data-toast role="status" hidden></div>`;
   return layoutless(`${g.name} · ${appWords(g).open}`, `
-<iframe class="game" title="${esc(g.name)}" sandbox="allow-scripts allow-pointer-lock allow-forms allow-modals allow-popups" allow="fullscreen *; autoplay *; gamepad *"></iframe>
+<iframe class="game" title="${esc(g.name)}" sandbox="allow-scripts allow-pointer-lock allow-forms allow-modals allow-popups${g.kind === 'app' ? ' allow-downloads' : ''}" allow="fullscreen *; autoplay *; gamepad *${g.kind === 'app' ? '; web-share *' : ''}"></iframe>
 ${arrive.html}
 <div class="chip${arrive.html ? ' held' : ''}" data-chip><span data-status>finding a room…</span></div>
 <div class="vote" data-vote role="dialog" aria-label="How strong should the AI be?" data-keep-focus hidden></div>
@@ -1178,7 +1179,7 @@ export function watchPage(cat, g, { origin = '', room = null, ticket = null, pol
   <span class="eyes" data-eyes hidden title="Watching this room"><svg viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M2 12s3.6-6.5 10-6.5S22 12 22 12s-3.6 6.5-10 6.5S2 12 2 12Z"/><circle cx="12" cy="12" r="3"/></svg><span data-eyes-n></span><span class="eyes-w"> watching</span></span>
   <a class="playb" data-playb href="${esc(openPath(g))}"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M7 4.8v14.4a1 1 0 0 0 1.5.86l12-7.2a1 1 0 0 0 0-1.72l-12-7.2A1 1 0 0 0 7 4.8Z" fill="currentColor"/></svg><span>${esc(appWords(g).open)}</span></a>
 </header>
-<main class="stage"><iframe class="game" title="${esc(g.name)}, live" tabindex="-1" sandbox="allow-scripts allow-pointer-lock allow-forms allow-modals allow-popups" allow="fullscreen *; autoplay *; gamepad *"></iframe></main>
+<main class="stage"><iframe class="game" title="${esc(g.name)}, live" tabindex="-1" sandbox="allow-scripts allow-pointer-lock allow-forms allow-modals allow-popups${g.kind === 'app' ? ' allow-downloads' : ''}" allow="fullscreen *; autoplay *; gamepad *${g.kind === 'app' ? '; web-share *' : ''}"></iframe></main>
 <footer class="dock">
   <div class="caption" data-caption role="status" aria-live="polite"><b data-cap-head>Joining the room…</b><span data-cap-sub></span></div>
   <nav class="strip" data-strip role="toolbar" aria-label="Whose view to watch"></nav>