@homie-rocks/studio 0.57.0 → 0.58.1

package/parts/terrain-route-map/preview/index.html

@@ -0,0 +1 @@
+<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Terrain route map</title><link rel="stylesheet" href="../src/style.css"><style>body{margin:0;background:#091e28;color:#f0eedf;font-family:system-ui;padding:20px}header{display:flex;justify-content:space-between;align-items:end;gap:20px;max-width:1800px;margin:0 auto 20px}small{color:#f4d47b;letter-spacing:.14em}h1{font-size:clamp(2rem,5vw,3.5rem);letter-spacing:-.05em;margin:8px 0}p{color:#a7c0c7;margin:0;max-width:28rem}#map{max-width:1800px;margin:auto;height:70vh;min-height:440px}@media(max-width:600px){header{display:block}#map{height:65vh}}</style><header><div><small>FIELD ATLAS / 01</small><h1>The coastal path.</h1></div><p>From sheltered harbour to high ridge. Drag to explore, pinch to zoom, or use the camera buttons.</p></header><main id="map" aria-label="Coastal path terrain"></main><script type="module" src="./demo.js"></script></html>

package/parts/terrain-route-map/preview/main.mjs

@@ -0,0 +1,4 @@
+import {mountTerrainMap} from '../src/index.mjs';
+const data=await (await fetch(new URL('./route.json',import.meta.url))).json();
+data.heightmap=new URL('./heightmap.png',import.meta.url).href;
+try { window.map=await mountTerrainMap(document.querySelector('main'),data); } catch(error) { document.querySelector('main').textContent=`Map could not load: ${error.message}`; throw error; }

package/parts/terrain-route-map/preview/route.json

@@ -0,0 +1 @@
+{"bounds":[0,0,100,100],"height":42,"seaLevel":6,"heightmap":"heightmap.png","route":{"type":"LineString","coordinates":[[20,72],[30,66],[40,58],[48,51],[58,45],[67,36],[75,26]]},"markers":[{"coordinates":[20,72],"label":"Harbour"},{"coordinates":[48,51],"label":"Lookout"},{"coordinates":[75,26],"label":"High ridge"}]}

package/parts/terrain-route-map/src/data.mjs

@@ -0,0 +1,81 @@
+export function validateMap(data, {baseURL = globalThis.location?.href, allowedOrigins = []} = {}) {
+  validateHeightmapURL(data.heightmap, {baseURL, allowedOrigins});
+  const {bounds, route, markers = [], height = 28, seaLevel = 6} = data;
+  if (!Array.isArray(bounds) || bounds.length !== 4 || !bounds.every(Number.isFinite) || bounds[2] <= bounds[0] || bounds[3] <= bounds[1]) throw new Error('bounds must be [minX,minZ,maxX,maxZ]');
+  const point = p => Array.isArray(p) && p.length === 2 && p.every(Number.isFinite) && p[0]>=bounds[0] && p[0]<=bounds[2] && p[1]>=bounds[1] && p[1]<=bounds[3];
+  if (route?.type !== 'LineString' || !Array.isArray(route.coordinates) || route.coordinates.length < 2 || route.coordinates.length > 2048 || !route.coordinates.every(point)) throw new Error('route must be a bounded LineString of 2–2048 points');
+  if (route.coordinates.some((p,i,a)=> i && p[0]===a[i-1][0] && p[1]===a[i-1][1])) throw new Error('Consecutive route points must differ');
+  if (!Number.isFinite(height) || height <= 0 || !Number.isFinite(seaLevel) || seaLevel < 0 || seaLevel >= height) throw new Error('Invalid height or sea level');
+  if (!Array.isArray(markers) || markers.length > 32 || markers.some(m=>!point(m.coordinates)||typeof m.label!=='string'||!m.label.trim()||m.label.length>80)) throw new Error('Invalid markers (maximum 32)');
+  return {...data, markers, height, seaLevel};
+}
+/** Red channel, row zero = minZ. Bilinear interpolation; pixel endpoints span bounds. */
+export function heightSampler({width, height, data}, bounds, amplitude) {
+  if (!Number.isInteger(width)||!Number.isInteger(height)||width<2||height<2||data.length!==width*height*4) throw new Error('Invalid RGBA heightmap');
+  return (x,z) => {
+    const u=Math.max(0,Math.min(1,(x-bounds[0])/(bounds[2]-bounds[0])))*(width-1);
+    const v=Math.max(0,Math.min(1,(z-bounds[1])/(bounds[3]-bounds[1])))*(height-1);
+    const a=Math.floor(u), b=Math.floor(v), fx=u-a, fz=v-b;
+    const sample=(i,j)=>data[(Math.min(j,height-1)*width+Math.min(i,width-1))*4]/255*amplitude;
+    return (sample(a,b)*(1-fx)+sample(a+1,b)*fx)*(1-fz)+(sample(a,b+1)*(1-fx)+sample(a+1,b+1)*fx)*fz;
+  };
+}
+
+/** Stable screen-space packing. Hidden overflow remains in the accessible marker list. */
+export function placeLabels(points, width, height) {
+  const placed=[];
+  return points.map(({x,y,w,h})=>{
+    const left=Math.max(8,Math.min(width-w-8,x-w/2));
+    for(let step=0;step<height;step+=h+8){
+      for(const sign of [-1,1]){
+        const top=Math.max(8,Math.min(height-h-112,y-72+step*sign));
+        if(top<8 || placed.some(b=>left<b.x+b.w+8&&left+w+8>b.x&&top<b.y+b.h+8&&top+h+8>b.y))continue;
+        const box={x:left,y:top,w,h};placed.push(box);return box;
+      }
+    }
+    return null;
+  });
+}
+/** Ignore startup/hidden gaps; sustained slow frames reduce the GPU budget once. */
+export function qualityMonitor({threshold=28,samples=90}={}) {
+  let count=0,slow=0;
+  return dt=>{if(dt<=0||dt>250)return false;count++;if(dt>threshold)slow++;return count>=samples&&slow/count>.25;};
+}
+
+/** PNG only: verify signature and IHDR dimensions before invoking an image decoder. */
+export function heightmapDimensions(bytes) {
+  const signature = [137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82];
+  if (bytes.length < 24 || signature.some((value,i) => bytes[i] !== value)) throw new Error('Expected a PNG heightmap');
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const width = view.getUint32(16), height = view.getUint32(20);
+  if (width < 2 || height < 2 || width > 2048 || height > 2048) throw new Error('Heightmap dimensions must be 2–2048 pixels');
+  return {width, height};
+}
+export function validateHeightmapURL(value, {baseURL, allowedOrigins = []} = {}) {
+  if (typeof value !== 'string' || !value.trim()) throw new Error('Invalid heightmap URL');
+  // Without a browser origin, validation permits relative paths only by default.
+  const base = new URL(baseURL || 'https://relative.invalid/');
+  const url = new URL(value, base);
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || !/\.png$/i.test(url.pathname) ||
+      (url.origin !== base.origin && !allowedOrigins.includes(url.origin)) ||
+      (!baseURL && /^(?:[a-z][a-z0-9+.-]*:|[\/\\]{2})/i.test(value) && !allowedOrigins.includes(url.origin))) throw new Error('Heightmap must be a same-origin or explicitly allowed PNG URL');
+  return url.href;
+}
+export async function loadHeightmap(value, options = {}) {
+  const url = validateHeightmapURL(value, options);
+  const response = await fetch(url, {redirect:'error', credentials:'same-origin'});
+  if (!response.ok || response.headers.get('content-type')?.split(';')[0].trim() !== 'image/png') throw new Error('Expected a PNG response');
+  const reader = response.body.getReader(), chunks = []; let size = 0;
+  try {
+    for (;;) {
+      const {done, value:chunk} = await reader.read(); if (done) break;
+      size += chunk.byteLength;
+      if (size > 16 * 1024 * 1024) throw new Error('Heightmap exceeds download budget');
+      chunks.push(chunk);
+    }
+  } catch (error) {await reader.cancel(); throw error;}
+  const bytes = new Uint8Array(size); let offset = 0;
+  for (const chunk of chunks) {bytes.set(chunk,offset); offset += chunk.length;}
+  const {width,height} = heightmapDimensions(bytes);
+  return createImageBitmap(new Blob([bytes], {type:'image/png'}), {resizeWidth:width, resizeHeight:height});
+}

package/parts/terrain-route-map/src/index.mjs

@@ -0,0 +1,131 @@
+import * as THREE from 'three';
+import {OrbitControls} from 'three/addons/controls/OrbitControls.js';
+import {validateMap, loadHeightmap, heightSampler, placeLabels, qualityMonitor} from './data.mjs';
+/** Owns only its canvas, controls and GPU resources. Call dispose when leaving the view. */
+export async function mountTerrainMap(root, input, {segments=192, pixelRatio=1.5, quality='auto', allowedOrigins=[]}={}) {
+  if(!['auto','full','lite'].includes(quality))throw new Error('Invalid quality');
+  const imageOptions={baseURL:location.href, allowedOrigins};
+  const data=validateMap(input,imageOptions);
+  if (!Number.isInteger(segments)||segments<8||segments>256||!Number.isFinite(pixelRatio)||pixelRatio<.5||pixelRatio>2) throw new Error('Invalid rendering budget');
+  const spanBudget=Math.max(data.bounds[2]-data.bounds[0],data.bounds[3]-data.bounds[1]);
+  const estimatedPoints=data.route.coordinates.slice(1).reduce((sum,b,i)=>{const a=data.route.coordinates[i];return sum+Math.max(1,Math.ceil(Math.hypot(b[0]-a[0],b[1]-a[1])/(spanBudget/segments/2)));},1);
+  if(estimatedPoints>8192) throw new Error('Route exceeds rendering budget');
+  const image = await loadHeightmap(data.heightmap,imageOptions);
+  const sampling=document.createElement('canvas'); sampling.width=image.width; sampling.height=image.height;
+  const context=sampling.getContext('2d',{willReadFrequently:true}); context.drawImage(image,0,0);
+  image.close();
+  const rawSample=heightSampler(context.getImageData(0,0,image.width,image.height),data.bounds,data.height);
+  const sample=(x,z)=>(rawSample(x,z)*4+rawSample(x-.5,z)+rawSample(x+.5,z)+rawSample(x,z-.5)+rawSample(x,z+.5))/8;
+  const [x0,z0,x1,z1]=data.bounds, width=x1-x0, depth=z1-z0, span=Math.max(width,depth);
+  const scene=new THREE.Scene(); scene.background=new THREE.Color('#9ebbc5'); scene.fog=new THREE.FogExp2('#9ebbc5',.0009);
+  const reduced=matchMedia('(prefers-reduced-motion: reduce)').matches;
+  let lite=quality==='lite', intro=!reduced; const monitor=qualityMonitor();
+  const camera=new THREE.PerspectiveCamera(40,1,span/1000,span*12);
+  const renderer=new THREE.WebGLRenderer({antialias:true,alpha:false}); renderer.setPixelRatio(Math.min(devicePixelRatio,pixelRatio));
+  renderer.outputColorSpace=THREE.SRGBColorSpace; renderer.toneMapping=THREE.ACESFilmicToneMapping; renderer.toneMappingExposure=1.15;
+  const canvas=renderer.domElement; canvas.tabIndex=0; canvas.setAttribute('role','img'); canvas.setAttribute('aria-label','Terrain map. Drag to orbit, pinch to zoom. Arrow keys rotate, plus and minus zoom, Home resets.');
+  root.classList.add('terrain-map'); root.append(canvas);
+  const controls=new OrbitControls(camera,canvas); controls.enableDamping=false; controls.enablePan=false; controls.minDistance=span*.3; controls.maxDistance=span*3; controls.maxPolarAngle=Math.PI*.46;
+  controls.target.set((x0+x1)/2,data.seaLevel,(z0+z1)/2);
+  function reset(){const fit=Math.max(1,1/Math.max(.35,camera.aspect));camera.position.set((x0+x1)/2+span*.48*fit,span*.65*fit,(z0+z1)/2+span*.78*fit); controls.update();}
+  reset();
+  scene.add(new THREE.HemisphereLight('#bce2ff','#293d32',1.7));
+  const sun=new THREE.DirectionalLight('#ffe2ad',3.1); sun.position.set(-span,span*.9,span); scene.add(sun);
+  const sky=new THREE.Mesh(new THREE.SphereGeometry(span*5,16,12),new THREE.ShaderMaterial({side:THREE.BackSide,depthWrite:false,uniforms:{},vertexShader:`varying vec3 direction;void main(){direction=position;gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.);}`,fragmentShader:`varying vec3 direction;void main(){float h=smoothstep(-.1,.7,normalize(direction).y);gl_FragColor=vec4(mix(vec3(.62,.73,.77),vec3(.12,.32,.49),h),1.);}`}));sky.position.copy(controls.target);scene.add(sky);
+  const geometry=new THREE.PlaneGeometry(width,depth,segments,segments); geometry.rotateX(-Math.PI/2); geometry.translate((x0+x1)/2,0,(z0+z1)/2);
+  const positions=geometry.attributes.position; const colors=[];
+  for(let i=0;i<positions.count;i++) {
+    const y=sample(positions.getX(i),positions.getZ(i)); positions.setY(i,y);
+    const x=positions.getX(i),z=positions.getZ(i);
+    const slope=Math.hypot(sample(x+1,z)-sample(x-1,z),sample(x,z+1)-sample(x,z-1));
+    const color=new THREE.Color('#3e6951').lerp(new THREE.Color('#a2a493'),Math.min(1,Math.max(slope*.35,(y/data.height-.5)*2)));
+    color.lerp(new THREE.Color('#d7c99d'),1-THREE.MathUtils.smoothstep(y,data.seaLevel+.2,data.seaLevel+2.5));
+    const cavity=Math.max(0,(sample(x+3,z)+sample(x-3,z)+sample(x,z+3)+sample(x,z-3))/4-y);
+    color.multiplyScalar((.96+.04*Math.sin(x*.7+Math.sin(z*.3))*Math.cos(z*.8))*(1-Math.min(.3,cavity*.16))); colors.push(color.r,color.g,color.b);
+  }
+  geometry.setAttribute('color',new THREE.Float32BufferAttribute(colors,3)); geometry.computeVertexNormals();
+  function useLite(){lite=true;renderer.setPixelRatio(Math.min(1,pixelRatio));renderer.setSize(root.clientWidth,root.clientHeight,false);
+    // Reuse the vertex buffer, drawing every second grid cell. No second mesh allocation.
+    if(segments%2===0){const indices=[];for(let z=0;z<segments;z+=2)for(let x=0;x<segments;x+=2){const a=z*(segments+1)+x,b=a+2,c=a+2*(segments+1),d=c+2;indices.push(a,c,b,b,c,d);}geometry.setIndex(indices);}
+  }
+  if(lite)useLite();
+  scene.add(new THREE.Mesh(geometry,new THREE.MeshStandardMaterial({vertexColors:true,roughness:1,flatShading:false})));
+  const heightTexture=new THREE.CanvasTexture(sampling); heightTexture.flipY=false;
+  const waterMaterial=new THREE.ShaderMaterial({uniforms:{time:{value:0},heights:{value:heightTexture},bounds:{value:new THREE.Vector4(x0,z0,width,depth)},amplitude:{value:data.height},sea:{value:data.seaLevel},lite:{value:lite?1:0}},
+    vertexShader:`varying vec3 world; void main(){world=(modelMatrix*vec4(position,1.)).xyz;gl_Position=projectionMatrix*viewMatrix*vec4(world,1.);}`,
+    fragmentShader:`precision highp float; varying vec3 world; uniform sampler2D heights; uniform vec4 bounds; uniform float amplitude,sea,time,lite;
+    void main(){vec2 uv=(world.xz-bounds.xy)/bounds.zw;float inside=smoothstep(0.,.08,uv.x)*smoothstep(0.,.08,uv.y)*(1.-smoothstep(.92,1.,uv.x))*(1.-smoothstep(.92,1.,uv.y));
+    float depth=max(0.,sea-texture2D(heights,clamp(uv,0.,1.)).r*amplitude*inside);
+    vec3 col=mix(vec3(.14,.58,.56),vec3(.025,.18,.27),smoothstep(0.,3.5,depth));
+    float wave=sin(world.x*.7+world.z*.55+sin(world.z*.13)*2.-time*1.1)+sin(world.z*1.3-world.x*.4+sin(world.x*.17)*3.+time*.8);
+    float foam=(1.-smoothstep(.12,1.1,depth))*(.55+.45*sin(depth*15.-time*2.+wave*.5));
+    col=mix(col,vec3(.84,.93,.83),foam*.8);col+=pow(max(0.,wave*.5),12.)*.035*(1.-lite*.7);
+    float haze=1.-exp(-distance(cameraPosition,world)*.0009);col=mix(col,vec3(.35,.52,.60),haze);
+    gl_FragColor=vec4(col,1.); #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+    }`.replace(' #include','\n#include')});
+  const water=new THREE.Mesh(new THREE.PlaneGeometry(width*12,depth*12),waterMaterial); water.rotation.x=-Math.PI/2; water.position.set((x0+x1)/2,data.seaLevel,(z0+z1)/2); scene.add(water);
+  // Densify straight segments before draping: avoids spline overshoot and tubes cutting hills.
+  const points=[];
+  for(let i=1;i<data.route.coordinates.length;i++) {
+    const a=data.route.coordinates[i-1],b=data.route.coordinates[i];
+    const steps=Math.max(1,Math.ceil(Math.hypot(b[0]-a[0],b[1]-a[1])/(span/segments/2)));
+    for(let j=0;j<steps;j++){const t=j/steps,x=a[0]+(b[0]-a[0])*t,z=a[1]+(b[1]-a[1])*t;points.push(new THREE.Vector3(x,Math.max(sample(x,z),data.seaLevel)+span*.008,z));}
+  }
+  const last=data.route.coordinates.at(-1); points.push(new THREE.Vector3(last[0],Math.max(sample(...last),data.seaLevel)+span*.008,last[1]));
+  const path=new THREE.CurvePath(); for(let i=1;i<points.length;i++)path.add(new THREE.LineCurve3(points[i-1],points[i]));
+  scene.add(new THREE.Mesh(new THREE.TubeGeometry(path,Math.min(4096,points.length*2),span*.003,5,false),new THREE.MeshBasicMaterial({color:'#ffcd61'})));
+  scene.add(new THREE.Mesh(new THREE.TubeGeometry(path,Math.min(4096,points.length*2),span*.006,5,false),new THREE.MeshBasicMaterial({color:'#ffcc65',transparent:true,opacity:.12,depthWrite:false})));
+  const flowGeometry=new THREE.SphereGeometry(span*.004,6,4);
+  const flow=new THREE.InstancedMesh(flowGeometry,new THREE.MeshBasicMaterial({color:'#ffffff'}),12);scene.add(flow);
+  const flowMatrix=new THREE.Matrix4();
+  const labels=document.createElement('div');labels.className='terrain-labels';root.append(labels);
+  const labelPoints=data.markers.map((marker,index)=>{
+    const [x,z]=marker.coordinates,y=Math.max(sample(x,z),data.seaLevel);
+    const mesh=new THREE.Mesh(new THREE.CylinderGeometry(span*.003,span*.003,span*.035,8),new THREE.MeshBasicMaterial({color:'#fff2c4'}));mesh.position.set(x,y+span*.0175,z);scene.add(mesh);
+    const line=document.createElement('i');line.setAttribute('aria-hidden','true');labels.append(line);
+    const label=document.createElement('span');label.textContent=`${String(index+1).padStart(2,'0')}  ${marker.label}`;labels.append(label);
+    return {label,line,position:new THREE.Vector3(x,y+span*.04,z)};
+  });
+  const accessible=document.createElement('ul');accessible.className='terrain-accessible';
+  for(const m of data.markers){const li=document.createElement('li');li.textContent=m.label;accessible.append(li);}root.append(accessible);
+  labels.setAttribute('aria-hidden','true');
+  let scheduled=0,disposed=false,visible=true,previous=0,start=0;
+  const projected=new THREE.Vector3();
+  function render(now){scheduled=0;if(disposed||!visible||document.hidden){previous=0;return;}
+    if(!start)start=now; const elapsed=(now-start)/1000;
+    if(quality==='auto'&&!lite&&previous&&elapsed>2&&monitor(now-previous)){useLite();waterMaterial.uniforms.lite.value=1;}
+    previous=now;waterMaterial.uniforms.time.value=reduced?0:elapsed;
+    if(intro){const t=Math.min(1,elapsed/2.2);reset();const offset=camera.position.clone().sub(controls.target);offset.applyAxisAngle(new THREE.Vector3(0,1,0),.15*(1-t)*(1-t));camera.position.copy(controls.target).add(offset);controls.update();if(t===1)intro=false;}
+    for(let i=0;i<12;i++){const p=path.getPoint(((reduced?0:elapsed*.035)+i/12)%1);flowMatrix.makeTranslation(p.x,p.y,p.z);flow.setMatrixAt(i,flowMatrix);}flow.instanceMatrix.needsUpdate=true;
+    renderer.render(scene,camera);
+    const projectedLabels=labelPoints.map(({label,position})=>{projected.copy(position).project(camera);return {x:(projected.x*.5+.5)*canvas.clientWidth,y:(-projected.y*.5+.5)*canvas.clientHeight,w:label.offsetWidth,h:label.offsetHeight,visible:projected.z<=1&&projected.z>=-1};});
+    const boxes=placeLabels(projectedLabels,canvas.clientWidth,canvas.clientHeight);
+    labelPoints.forEach(({label,line},i)=>{const box=boxes[i],p=projectedLabels[i];label.style.visibility=line.style.visibility=box&&p.visible?'visible':'hidden';if(!box)return;
+      label.style.transform=`translate(${box.x}px,${box.y}px)`;
+      const dx=box.x+box.w/2-p.x,dy=box.y+box.h-p.y;line.style.width=`${Math.hypot(dx,dy)}px`;line.style.transform=`translate(${p.x}px,${p.y}px) rotate(${Math.atan2(dy,dx)}rad)`;
+    });
+    if(!reduced)invalidate();
+  }
+  function invalidate(){if(!scheduled&&!disposed)scheduled=requestAnimationFrame(render);}
+  controls.addEventListener('start',()=>{intro=false;});
+  controls.addEventListener('change',invalidate);
+  let initialSize=true;
+  const resize=new ResizeObserver(()=>{const w=root.clientWidth,h=root.clientHeight;if(!w||!h)return;renderer.setSize(w,h,false);camera.aspect=w/h;camera.updateProjectionMatrix();if(initialSize){initialSize=false;reset();}invalidate();});resize.observe(root);
+  const intersection=new IntersectionObserver(entries=>{visible=entries[0].isIntersecting;if(visible)invalidate();});intersection.observe(root);
+  document.addEventListener('visibilitychange',invalidate);
+  function command(action){
+    intro=false;
+    const offset=camera.position.clone().sub(controls.target),s=new THREE.Spherical().setFromVector3(offset);
+    if(action==='left')s.theta-=.15; if(action==='right')s.theta+=.15;
+    if(action==='up')s.phi=Math.max(.15,s.phi-.1);if(action==='down')s.phi=Math.min(controls.maxPolarAngle,s.phi+.1);
+    if(action==='in')s.radius=Math.max(controls.minDistance,s.radius*.85);if(action==='out')s.radius=Math.min(controls.maxDistance,s.radius/ .85);
+    if(action==='reset')reset();else {camera.position.copy(controls.target).add(new THREE.Vector3().setFromSpherical(s));controls.update();}invalidate();
+  }
+  const keyActions={ArrowLeft:'left',ArrowRight:'right',ArrowUp:'up',ArrowDown:'down','+':'in','=':'in','-':'out',Home:'reset'};
+  function keydown(e){if(keyActions[e.key]){e.preventDefault();command(keyActions[e.key]);}}canvas.addEventListener('keydown',keydown);
+  const toolbar=document.createElement('div');toolbar.className='terrain-controls';toolbar.setAttribute('aria-label','Map camera');
+  for(const [action,label] of [['left','Rotate left'],['right','Rotate right'],['in','Zoom in'],['out','Zoom out'],['reset','Reset view']]){const button=document.createElement('button');button.type='button';button.textContent=label;button.onclick=()=>command(action);toolbar.append(button);}root.append(toolbar);
+  invalidate();
+  return {camera,renderer,command,get quality(){return lite?'lite':'full';},render:invalidate,dispose(){disposed=true;cancelAnimationFrame(scheduled);resize.disconnect();intersection.disconnect();document.removeEventListener('visibilitychange',invalidate);canvas.removeEventListener('keydown',keydown);controls.dispose();scene.traverse(o=>{o.geometry?.dispose();if(o.material)o.material.dispose();});heightTexture.dispose();renderer.dispose();canvas.remove();labels.remove();accessible.remove();toolbar.remove();}};
+}

package/parts/terrain-route-map/src/style.css

@@ -0,0 +1,3 @@
+.terrain-map{position:relative;min-height:360px;height:100%;overflow:hidden;background:#102d39;border-radius:24px}.terrain-map canvas{width:100%;height:100%;display:block;touch-action:none}.terrain-map canvas:focus-visible{outline:3px solid #ffe9a6;outline-offset:-4px}.terrain-labels{position:absolute;inset:0;pointer-events:none;overflow:hidden}.terrain-labels span{position:absolute;top:0;left:0;background:#102329e8;border:1px solid #91b1ac;border-radius:8px;padding:5px 9px;color:#f5f2de;font:600 13px system-ui;white-space:nowrap}.terrain-labels [hidden]{display:none}.terrain-controls{position:absolute;bottom:12px;left:12px;right:12px;display:flex;justify-content:center;flex-wrap:wrap;gap:6px}.terrain-controls button{min-height:44px;padding:10px 12px;border:1px solid #91b1ac;background:#102329ed;color:#fff4cf;border-radius:10px;font:600 13px system-ui;cursor:pointer}.terrain-controls button:focus-visible{outline:3px solid #ffe9a6;outline-offset:2px}
+.terrain-labels span{border:1px solid #e6d7a070;border-radius:5px;padding:9px 12px;background:#142f39ed;box-shadow:0 4px 18px #03192345;letter-spacing:.03em;font-size:12px}.terrain-labels i{position:absolute;left:0;top:0;height:1px;background:#ffe7a9b0;transform-origin:0 0}.terrain-accessible{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%)}@media(min-width:1400px){.terrain-labels span{font-size:18px;padding:12px 18px}.terrain-controls button{font-size:16px}}
+.terrain-labels span{max-width:min(240px,calc(100% - 40px));white-space:normal;overflow-wrap:anywhere;box-sizing:border-box}

package/parts/terrain-route-map/tuning.json

@@ -0,0 +1,5 @@
+{
+  "segments": 192,
+  "pixelRatio": 1.5,
+  "quality": "auto"
+}

package/rules/browser.ts

@@ -71,6 +71,8 @@ export function browserHost(def: RulesDef, game: BrowserGame): RulesHostFactory
       stage: lab.stage ?? undefined, startPaused: false, restoreEpoch: (Math.floor(Math.random() * 4294967296) >>> 0) || 1,
       clock: { now: o.now, setTimer: (fn, ms) => setTimeout(fn, ms), clearTimer: (h) => clearTimeout(h as ReturnType<typeof setTimeout>) },
       onEnd: o.onEnd,
+      // Online, the page rests its room as the server does; offline nobody is charged for it, and it never rests.
+      ...(o.onRest ? { onRest: o.onRest } : {}),
     });
     if (game.vocab) host.frame({ t: 'vocabulary', vocab: game.vocab });
     const present = new Set<number>();

package/rules/core.ts

@@ -175,6 +175,8 @@ export interface Core {
   round(): Extract<CoreOut, { t: 'round' }>;
   /** End a settled wall-clock break without simulating its idle ticks. */
   resumeRound(): boolean;
+  /** What the world has waiting on its own clock: events and timers on the queue, bodies yet to spawn, asks unanswered, and a running round's deadline. */
+  waiting(): number;
   bodies(): Body[];
   /** Every person's body with where it stands: who an effect with an audience reaches (0.46.3). */
   listeners(): { seat: number; id: string; pos: Vec3 }[];
@@ -1539,6 +1541,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
   }
   return {
     round: () => ({ t: 'round', ...round, ...(round.phase === 'over' && !overAt ? { results: results() } : {}) }),
+    waiting: () => queue.length + spawns.length + pendingAsks.length + (round.phase === 'live' ? (round.endsAt > 0 ? 1 : 0) : (round.endsAt > tick ? 1 : 0)) + (restartAt > tick ? 1 : 0),
     resumeRound() {
       if (round.phase !== 'over' || overAt) return false;
       // Preserve queued events and their simulation-time deadlines. Nothing

package/rules/host.ts

@@ -31,6 +31,19 @@ import { stageTimings } from './timing.mjs';
  * timer would keep the `Table` in memory and billed), the clock stops, and a person who returns finds the tick it
  * paused on. Watchers and AI seats never keep the world ticking.
  *
+ * A ROOM NOBODY IS PLAYING RESTS. When every person here has stopped playing (nothing held, pressed or sent for the
+ * game's `room.restSeconds`, 60 by default, or every page in the background for ten seconds) and, unless the game
+ * asked for an away-from-keyboard pause, no AI has sent a command for as long, the clock stops as it does for an
+ * empty room, with everybody still connected: no timer is pending, so the `Table` hibernates. It is not charged for
+ * duration while it sleeps; a liveness alarm still wakes it about once a minute (one request, and the CPU of that
+ * short wake). A deliberate rest is restored under the same epoch and does not rewrite its save. With `room.rest:
+ * 'quiet'` (the default) the world must also have nothing of its own to do (no round clock, nothing waiting on the
+ * queue, nothing moving). `'idle'` rests regardless and pauses round clocks, timers, bots and AI with it.
+ * `'never'` never rests. The first input that holds or presses something, a command, an AI's command, a page coming
+ * to the front or a new arrival starts it again at the tick it rested on.
+ * Only browsers that said they understand resting (`rest` in their hello) let a room rest, and only when the caller
+ * asks for it (`onRest`: the server's Table, or an online browser host). A lasting world never rests.
+ *
  * THE CHAIN CANNOT BREAK. One rule holds whenever this module hands control back to its caller: A ROOM THAT IS RUNNING
  * HAS EXACTLY ONE TIMER PENDING, AND A ROOM THAT IS PAUSED OR ENDED HAS NONE. A running room with no timer would stand
  * still for good with its players connected and its object billed. So every way in (`wake`, `frame`, `start`,
@@ -89,6 +102,8 @@ export interface HostOptions {
   onTick?(): void;
   /** Suspend settled round breaks; the owner persists and wakes this deadline. */
   onRoundIdle?(until: number): void;
+  /** Rest a room nobody is playing (`true`), and start it again (`false`). Without it a room never rests. */
+  onRest?(resting: boolean): void;
   /** Only the shared server isolate can attribute timer lateness to another tick. */
   enforceOverrun?: boolean;
   log?(line: Record<string, unknown>): void;
@@ -115,6 +130,8 @@ export interface Host {
   readonly paused: boolean;
   readonly roundIdleUntil: number | null;
   wakeRound(): void;
+  /** Nobody is playing: the clock is stopped with people still here (see A ROOM NOBODY IS PLAYING RESTS). */
+  readonly resting: boolean;
   readonly people: number;
   readonly viewRadiusM: number | null;
   readonly privateDelivery: boolean;
@@ -157,6 +174,10 @@ interface SeatIn {
 
 /** Every tick failing (cut short by the budget, or faulted) for this long ends the room. */
 export const FAIL_MS = 2000;
+/** How long a room plays on with nobody playing before it rests, unless the game says otherwise (`room.restSeconds`). */
+export const REST_SECONDS = 60;
+/** How long a room plays on with every page in the background before it rests (never longer than `restSeconds`). */
+export const REST_HIDDEN_MS = 10_000;
 /** Every tick blamed for running longer than a period for this long ends the room. */
 export const OVERRUN_MS = 5000;
 
@@ -203,12 +224,13 @@ export function createHost(o: HostOptions): Host {
   // 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; roundIdleUntil?: 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;
+  const saved = o.restore ? fromBytes(o.restore) as { v: number; roundIdleUntil?: number; rest?: { on: boolean; at: [number, 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', 'characters', 'roundIdleUntil'].includes(k)));
+    check(Object.keys(saved).every(k => ['v', 'core', 'names', 'agents', 'guideViews', 'queues', 'inputs', 'characters', 'roundIdleUntil', 'rest'].includes(k)));
+    if (saved.rest !== undefined) check(saved.rest && typeof saved.rest.on === 'boolean' && Array.isArray(saved.rest.at) && saved.rest.at.length <= c.seats && saved.rest.at.every(row => Array.isArray(row) && row.length === 2 && uint(row[0]) && row[0] < c.seats && Number.isFinite(row[1])));
     check(saved.core && Array.isArray(saved.names) && Array.isArray(saved.queues));
     if (saved.roundIdleUntil !== undefined) check(Number.isFinite(saved.roundIdleUntil) && saved.roundIdleUntil >= 0 && saved.core.round[1] === 0 && !saved.core.overAt);
     if (saved.characters !== undefined) {
@@ -402,8 +424,23 @@ export function createHost(o: HostOptions): Host {
     }
   }
   let roundIdleUntil: number | null = o.onRoundIdle && Number.isFinite(saved?.roundIdleUntil) ? saved!.roundIdleUntil! : null;
+  /*
+   * Resting (A ROOM NOBODY IS PLAYING RESTS): how long a room plays on with nobody playing (0: never rests), whether it
+   * rests now, when each person last played, since when each page has been in the background, which browsers can rest,
+   * and when an AI with its own hands last played. A restored room that was resting rests on.
+   */
+  const restMode = c.settings.rest ?? 'quiet';
+  const restMs = o.onRest && !persistent && restMode !== 'never' ? Math.max(0, c.settings.restSeconds ?? REST_SECONDS) * 1000 : 0;
+  /** The world as the last rest check saw it (a quiet room must also be a still one). */
+  let stillAs = '';
+  let resting = restMs > 0 && saved?.rest?.on === true && roundIdleUntil === null;
+  const playedAt = new Map<number, number>(restMs ? saved?.rest?.at ?? [] : []);
+  const hiddenSince = new Map<number, number>();
+  const restful = new Set<number>();
+  let handsAt = -Infinity;
+  let restCheckAt = 0;
   let running = false;
-  let paused = Boolean(saved && (o.startPaused ?? o.restoreEpoch !== undefined));
+  let paused = !resting && Boolean(saved && (o.startPaused ?? o.restoreEpoch !== undefined));
   let ended = false;
   /** The pending timer, and whether there is one. `armed` is the truth: a clock may hand back any value as its handle. */
   let timer: unknown = null;
@@ -471,12 +508,96 @@ export function createHost(o: HostOptions): Host {
   }
   const people = (): number => { let n = 0; for (const person of present.values()) if (person) n += 1; return n; };
 
+  /* ---------------------------------------------------------------- resting */
+
+  /** Each kind's inputs at rest, one text a field: nothing held, nothing pressed. */
+  const restingInput = new Map<KindTable, string[]>();
+  /** Whether an input frame holds or presses anything (its newest entry's values, and a press in any entry). */
+  function engaged(kind: KindTable, rows: unknown[]): boolean {
+    let idle = restingInput.get(kind);
+    if (!idle) { const v = neutral(kind); idle = kind.input.map(([name]) => JSON.stringify(v[name])); restingInput.set(kind, idle); }
+    const last = rows.length - 1;
+    for (let n = 0; n < rows.length && n < 64; n += 1) {
+      const raw = rows[n];
+      if (!Array.isArray(raw)) return false;
+      for (let i = 0; i < kind.input.length; i += 1) {
+        const fd = kind.input[i][1];
+        if (fd.t === 'press') { if (raw[i + 1] === 1) return true; }
+        else if (n === last && fd.t !== 'pulse' && JSON.stringify(coerce(fd, raw[i + 1], c.dims)) !== idle[i]) return true;
+      }
+    }
+    return false;
+  }
+  /** Somebody played: a person (their seat) or an AI with its own hands. A resting room wakes. */
+  function played(seat: number, driver: Driver, now: number): void {
+    if (driver === 'person') playedAt.set(seat, now); else handsAt = now;
+    if (resting) wakeUp('played');
+  }
+  /**
+   * Nobody is playing: every person here has a resting browser and has not played for `restMs` (or hid their page),
+   * and, unless this is an away-from-keyboard pause, no AI has played for as long. A `quiet` room (the default)
+   * must also have nothing of its own to do: no running round clock, no event, timer, spawn or ask waiting, and a
+   * world that stood still since the last check (bots, physics and anything a `tick` handler moves keep it running).
+   * An `idle` room rests regardless, pausing all of that, guides included, until somebody plays.
+   */
+  function quiet(now: number): boolean {
+    // A command already sent keeps a quiet room awake. An idle room pauses AI with the people, so that command does
+    // not keep the pause from starting. A command that arrives while the room rests still wakes it (`played`).
+    if (restMode !== 'idle' && now - handsAt < restMs) return false;
+    let anyone = false;
+    for (const [seat, person] of present) {
+      if (!person) continue;
+      anyone = true;
+      if (!restful.has(seat)) return false;
+      const hid = hiddenSince.get(seat);
+      if (hid !== undefined && now - hid >= Math.min(restMs, REST_HIDDEN_MS)) continue;
+      if (now - (playedAt.get(seat) ?? now) < restMs) return false;
+    }
+    if (!anyone || restMode === 'idle') { stillAs = ''; return anyone; }
+    if (core.waiting() > 0) { stillAs = ''; return false; }
+    const was = stillAs;
+    stillAs = JSON.stringify([core.snapshot(), core.shared()]);
+    return was === stillAs;
+  }
+  /** The clock stops with everybody still here. The room is saved first, so the object may be put away at once. */
+  function rest(): void {
+    resting = true; running = false;
+    disarm();
+    log({ ev: 'host-rest', game: o.game, tick: core.tick, people: people() });
+    try { o.send({ t: 'rest', on: true }); checkpoint(true); o.onRest?.(true); } catch (error) { fault('rest', error); }
+  }
+  /** Somebody plays again: the room carries on from the tick it rested on, on a clock started now. */
+  function wakeUp(why: string): void {
+    if (!resting || ended) return;
+    resting = false; running = true; paused = false;
+    try {
+      const now = o.clock.now();
+      base = { ms: now, tick: core.tick };
+      overSince = null; blamed = false; failingSince = null; lastStart = now;
+      for (const q of queues.values()) q.lastFrameTick = core.tick;
+      o.send({ t: 'rest', on: false });
+      roundRebaseAt = -Infinity; publishRebase(now);
+      // The save on disk says it rests, and a rested save comes back under its own epoch. Once the room moves on it
+      // must not: a restart now restores this save, under a new epoch, as any crash does.
+      checkpoint(true);
+      log({ ev: 'host-wake', game: o.game, tick: core.tick, why });
+      o.onRest?.(false);
+    } catch (error) { fault('wake', error); } finally { keepTime(); }
+  }
+
   /* ---------------------------------------------------------------- frames in */
 
   function onIn(m: Record<string, unknown>): void {
     const seat = m.from;
-    if (!Number.isInteger(seat) || m.e !== epoch || !Array.isArray(m.s)) { stats.dropped += 1; return; }
+    if (!Number.isInteger(seat) || !Array.isArray(m.s)) { stats.dropped += 1; return; }
     const body = core.bodyOf(seat as number);
+    // Somebody playing is seen before the epoch is: the first touch after a rest (which a restore may have given a new
+    // epoch) wakes the room even when the frame itself is from before it. Read at most once a second a seat.
+    if (restMs && body && hasHands(seat as number, body.driver)) {
+      const now = o.clock.now();
+      if ((resting || now - (playedAt.get(seat as number) ?? -Infinity) >= 1000) && engaged(body.kind, m.s as unknown[])) played(seat as number, body.driver, now);
+    }
+    if (m.e !== epoch) { stats.dropped += 1; return; }
     if (!body || !hasHands(seat as number, body.driver)) return;
     const kind = body.kind;
     const q = queueOf(seat as number, kind);
@@ -504,7 +625,9 @@ export function createHost(o: HostOptions): Host {
       if (seq && r !== body.r && !action) continue;
       if (seq ? q.received?.includes(seq) : j <= q.newest) continue;
       // Too early: more than a second ahead. This entry and the rest of the frame are dropped.
-      if (j > K + tickHz) { stats.dropped += 1; break; }
+      // An entry more than a second ahead is still reported, as the furthest lead there is: a browser whose clock ran on
+      // (a rest, a stalled host clock) sets its clock again instead of being dropped without a word.
+      if (j > K + tickHz) { stats.dropped += 1; q.lead = Math.min(q.lead, 126); break; }
       if(j >= q.newest && lead < q.lead)q.lead=lead;
       q.newest = Math.max(q.newest,j);
       if(seq){q.received??=[];q.received.push(seq);if(q.received.length>256)q.received.shift();}
@@ -585,7 +708,13 @@ export function createHost(o: HostOptions): Host {
         core.seatAway(seat, false);
         if (!previous || previous.driver !== driver || previous.owner !== owner) queues.delete(seat);
         rosterText = '';
-        if (people() > 0) { if (!running && !paused) start(); else if (paused) resume(); }
+        // A socket the room restored after hibernating is the same person, still resting; anybody else has just come.
+        const now = o.clock.now();
+        // The relay says whether the browser understands resting: on the server's join, or on the peer a browser host hears.
+        if (m.rest === true || (p as { rest?: unknown }).rest === true) restful.add(seat); else restful.delete(seat);
+        if (m.hidden === true) { if (!hiddenSince.has(seat)) hiddenSince.set(seat, now); } else hiddenSince.delete(seat);
+        if (m.restored !== true || !playedAt.has(seat)) playedAt.set(seat, now);
+        if (people() > 0) { if (resting) { if (m.restored !== true) wakeUp('join'); } else if (!running && !paused) start(); else if (paused) resume(); }
         return;
       }
       case 'leave': {
@@ -598,9 +727,10 @@ export function createHost(o: HostOptions): Host {
           held.character = core.character(held.seat) ?? held.character;
           held.returning = true;
           core.seatLeave(held.seat);
-          tick(o.clock.now());
+          if (!resting) tick(o.clock.now());
         } else core.seatAway(m.seat as number, true);
-        if ((running || roundIdleUntil !== null) && people() === 0) pause();
+        playedAt.delete(m.seat as number); hiddenSince.delete(m.seat as number); restful.delete(m.seat as number);
+        if ((running || resting || roundIdleUntil !== null) && people() === 0) pause();
         return;
       }
       case 'free': {
@@ -609,16 +739,30 @@ 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);
+        playedAt.delete(m.seat as number); hiddenSince.delete(m.seat as number); restful.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());
+        if (held && !resting) tick(o.clock.now());
         rosterText = '';
+        if (resting && people() === 0) pause();
+        return;
+      }
+      case 'hidden': {
+        // A page went to the background, or came back (the relay hears it on the page's clock pings). Coming back wakes a
+        // resting room: somebody is looking at it again.
+        if (!Number.isInteger(m.seat) || !present.get(m.seat as number)) return;
+        const now = o.clock.now();
+        if (m.on === true) { if (!hiddenSince.has(m.seat as number)) hiddenSince.set(m.seat as number, now); }
+        else if (hiddenSince.delete(m.seat as number)) played(m.seat as number, 'person', now);
         return;
       }
       case 'ev': {
         // What a player sends is read as what it is: a kind or a command's name that is not a text is no kind and no command.
         const kind = typeof m.k === 'string' ? m.k : '';
+        // Anything a seated person sends (a command, a pulse, a line of chat) is somebody playing, and so is an AI's
+        // command, whichever hands it plays with: a resting room wakes for a guide as for a person.
+        if (restMs && Number.isInteger(m.from)) { const b = core.bodyOf(m.from as number); if (b && (present.get(m.from as number) || hasHands(m.from as number, b.driver) || kind === 'agent:do' || /^ask:/.test(kind))) played(m.from as number, present.get(m.from as number) ? 'person' : b.driver, o.clock.now()); }
         if (!Number.isInteger(m.from)) {
           if (m.from === null && SPEECH.test(kind)) o.send({ t: 'ev', from: null, k: kind, d: cleanSpeech(m.d) });
           return;
@@ -846,6 +990,9 @@ export function createHost(o: HostOptions): Host {
         running = false; disarm();
         try { o.store?.save(save()); o.onRoundIdle(roundIdleUntil); }
         catch (error) { fault('round-idle', error); stop(); o.onEnd?.('storage-or-tick-failed', { tick: core.tick }); }
+      } else if (restMs && running && now >= restCheckAt) {
+        restCheckAt = now + 1000;
+        if (quiet(now)) rest();
       }
       return;
     }
@@ -929,7 +1076,7 @@ export function createHost(o: HostOptions): Host {
   const self = { blame: (): void => { blamed = true; } };
 
   function start(): void {
-    if (running || ended || roundIdleUntil !== null) return;
+    if (running || resting || ended || roundIdleUntil !== null) return;
     running = true; paused = false;
     try {
       base = { ms: o.clock.now() + (firstTick ? o.startDelayMs ?? 0 : 0), tick: core.tick };
@@ -943,6 +1090,10 @@ export function createHost(o: HostOptions): Host {
   }
   function pause(): void {
     if (!running) {
+      // Everybody left a resting room: it is an empty room now, paused like one. People still here (a tab
+      // went to the background) stay resting. Ending it would start every clock while the next host restores
+      // the rest save and stays asleep, so the input that should wake the room is dropped.
+      if (resting) { if (people() > 0) return; resting = false; paused = true; log({ ev: 'host-pause', game: o.game, tick: core.tick }); try { o.send({ t: 'rest', on: false }); checkpoint(true); o.onPause?.(); } catch (error) { fault('onPause', error); } return; }
       if (roundIdleUntil !== null && !paused) { paused = true; checkpoint(true); o.onPause?.(); }
       return;
     }
@@ -953,7 +1104,7 @@ export function createHost(o: HostOptions): Host {
     try { checkpoint(true); o.onPause?.(); } catch (error) { fault('onPause', error); if (persistent) { stop(); o.onEnd?.('storage-or-tick-failed', { tick: core.tick }); } }
   }
   function resume(announceRound = true): void {
-    if (running || ended || !paused || roundIdleUntil !== null) return;
+    if (running || resting || ended || !paused || roundIdleUntil !== null) return;
     running = true; paused = false;
     try {
       // The room resumes at the tick it paused on: no tick is skipped and no timer fires for the gap.
@@ -986,7 +1137,7 @@ export function createHost(o: HostOptions): Host {
     } catch (error) { fault('announce', error); }
   }
   function stop(): void {
-    running = false; paused = false; ended = true;
+    running = false; paused = false; resting = false; ended = true;
     core.dispose();
     disarm();
     agents?.stop();
@@ -1002,7 +1153,7 @@ export function createHost(o: HostOptions): Host {
 
   function save(): Uint8Array {
     const reserved = new Set(core.bodies().filter(b => b.owner === 'reserved').map(b => b.seat));
-    return toBytes({ v: 1, ...(roundIdleUntil !== null ? { roundIdleUntil } : {}), ...(characters.size ? { characters: [...characters.values()] } : {}), core: core.save(), guideViews: [...guideViews], ...(agents ? { agents: agents.save() } : savedAgents ? { agents: savedAgents } : {}), names: [...names].filter(([seat]) => !reserved.has(seat)), queues: [...queues].map(([seat, q]) => [seat, q.held, q.claim, q.newest, q.ack]), inputs: [...queues] });
+    return toBytes({ v: 1, ...(roundIdleUntil !== null ? { roundIdleUntil } : {}), ...(restMs ? { rest: { on: resting, at: [...playedAt] } } : {}), ...(characters.size ? { characters: [...characters.values()] } : {}), core: core.save(), guideViews: [...guideViews], ...(agents ? { agents: agents.save() } : savedAgents ? { agents: savedAgents } : {}), names: [...names].filter(([seat]) => !reserved.has(seat)), queues: [...queues].map(([seat, q]) => [seat, q.held, q.claim, q.newest, q.ack]), inputs: [...queues] });
   }
   function checkpoint(force = false): void {
     if (persistent) {
@@ -1048,8 +1199,10 @@ export function createHost(o: HostOptions): Host {
       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 || roundIdleUntil !== null) && people() === 0) pause();
+      playedAt.delete(held.seat); hiddenSince.delete(held.seat); restful.delete(held.seat);
+      if (held.seat >= 0) core.seatLeave(held.seat);
+      if (!resting) tick(o.clock.now());
+      if ((running || resting || roundIdleUntil !== null) && 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; },
@@ -1061,6 +1214,7 @@ export function createHost(o: HostOptions): Host {
     get paused() { return paused; },
     get roundIdleUntil() { return roundIdleUntil; },
     wakeRound,
+    get resting() { return resting; },
     get people() { return people(); },
     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.
@@ -1071,7 +1225,7 @@ export function createHost(o: HostOptions): Host {
       try { now = o.clock.now(); tick(now); } catch (error) { fault('tickNow', error); } finally { keepTime(); }
     },
     save,
-    facts: () => ({ timing: timing.facts(), tick: core.tick, epoch, running, paused, ended, armed, people: people(), tickHz, ...stats, core: { ...core.stats } }),
+    facts: () => ({ timing: timing.facts(), tick: core.tick, epoch, running, paused, resting, ended, armed, people: people(), tickHz, ...stats, core: { ...core.stats } }),
     core,
   };
 }