@worldmesh/runtime 0.2.1 → 0.2.3

package/dist/core/worldmesh.js

@@ -1,24 +1,49 @@
-import { Vector3 } from 'three';
+import { Euler, Group, PerspectiveCamera, Plane, Quaternion, Vector2, Vector3 } from 'three';
 import { resolveAbilities } from '../abilities/abilities.js';
 import { parseAvatarDescriptor } from '../avatar/descriptor.js';
-import { resolveWorldMeshAvatar, takeAvatarTicket } from '../avatar/handoff.js';
+import { getAvatarTicket, resolveWorldMeshAvatar, setAvatarTicket, takeAvatarTicket } from '../avatar/handoff.js';
+import { SharedAvatarLink, createShareVerifier } from '../avatar/share.js';
+import { rememberView, takeViewHandoff } from '../camera/viewHandoff.js';
 import { loadAvatarModel } from '../avatar/loader.js';
+import { Footsteps } from '../audio/footsteps.js';
 import { CameraRig } from '../camera/cameraRig.js';
 import { Input } from '../controls/input.js';
 import { CollisionWorld } from '../movement/collision.js';
 import { MovementController } from '../movement/controller.js';
-import { expressionForDigit, isAvatarExpression } from '../player/avatar.js';
+import { expressionForDigit, isAvatarExpression, setAvatarColor } from '../player/avatar.js';
 import { Player } from '../player/player.js';
 import { PortalManager, buildTravelUrl } from '../portals/portals.js';
 import { Overlay } from '../ui/overlay.js';
 import { isTouchDevice } from '../controls/touch.js';
+import { immersiveVrSupported, requestImmersiveVr } from '../xr/session.js';
 import { Emitter } from './events.js';
 import { DEFAULT_PRESENCE_SERVER, Presence } from '../net/presence.js';
+import { roomFullLabel } from '../net/roomFull.js';
 /** Never simulate more than this per substep, so a stall cannot tunnel the player. */
 const MAX_STEP = 1 / 60;
 /** Never simulate more than this per frame, so a backgrounded tab does not catch up violently. */
 const MAX_FRAME = 0.1;
 const DEFAULT_HUB = 'https://worldmesh.net/';
+/** Seconds to ease the field of view back to the world's own after taking over the hub's camera. */
+const FOV_RETURN = 1.5;
+/**
+ * Set by a host that draws the world live in one of its doorways (Doorway,
+ * docs/specs/doorway.md §3.1). The world stays offline, shows no UI, takes no
+ * input, and draws only when the host sends a camera (`doorway:view`), from
+ * that camera carried through the doorway onto its spawn point. When the
+ * visitor walks through (`doorway:enter`), it takes over from their pose
+ * and goes online, without reloading (§4).
+ */
+export const DOORWAY_VIEW_PARAM = 'doorway-view';
+/** Metres from the doorway back to the spawn point in a live view, and where a walk-in lands. */
+const VIEW_SPAWN_BEHIND = 0.6;
+/** Seconds a live view waits for the player to land at spawn before saying it is ready. */
+const VIEW_SETTLE = 2;
+/** The pre-Doorway names, still understood: `worldmesh:*` messages. */
+const isDoorwayMessage = (data, name) => {
+    const type = data?.type;
+    return type === `doorway:${name}` || type === `worldmesh:${name}`;
+};
 /**
  * Turn an ordinary Three.js scene into a WorldMesh world.
  *
@@ -31,15 +56,26 @@ export function createWorldMesh(options) {
     // Always take an avatar handoff ticket out of the address bar, even if this
     // world shows no avatars: portals still carry it on to the next world.
     const avatarTicket = takeAvatarTicket();
+    // A view the visitor picked here or in the world they came from wins over this world's default.
+    const rememberedView = takeViewHandoff();
     const spawn = new Vector3(...(options.spawn ?? [0, 2, 0]));
     const abilities = resolveAbilities(options.abilities);
+    // Before anything sizes the canvas: a live doorway view draws at 1×.
+    /** Drawn live in a host's doorway, not walked into yet. */
+    let viewing = isDoorwayViewRequest();
+    /** Inside a host's page (in its doorway, or walked into from it): other pages open through the host. */
+    const inHost = viewing;
     const height = options.player?.height ?? 1.8;
     const radius = options.player?.radius ?? 0.35;
     const collision = new CollisionWorld(options.colliders ?? [], options.groundLevel ?? 0);
     const events = new Emitter();
+    const vrEnabled = options.vr !== false;
     const overlay = new Overlay({
         ...options.ui,
         onEnter: (touch) => input.requestPointerLock(touch),
+        onEnterVr: () => {
+            void enterVR();
+        },
         onInteract: () => {
             if (activePortal) {
                 activatePortal(activePortal);
@@ -66,7 +102,7 @@ export function createWorldMesh(options) {
             return false;
         },
     });
-    const cameraRig = new CameraRig({ ...options.view, camera, collision });
+    const cameraRig = new CameraRig({ ...options.view, mode: rememberedView ?? options.view?.mode, camera, collision });
     const player = new Player({ ...options.player, height, radius });
     if (player.root)
         scene.add(player.root);
@@ -81,13 +117,30 @@ export function createWorldMesh(options) {
     });
     const portals = new PortalManager(scene, options.portals);
     let running = false;
-    let frameHandle = 0;
     let lastTime = 0;
     let elapsed = 0;
     let activePortal = null;
     let disposed = false;
+    const footsteps = options.footsteps ? new Footsteps() : null;
     let avatarDescriptor = null;
     let avatarLoad = null;
+    /** The avatar other players see this visitor in; its link is renewed through the hub when it expires. */
+    const sharedAvatar = new SharedAvatarLink(options.avatar?.source === 'worldmesh'
+        ? () => {
+            const ticket = getAvatarTicket();
+            const hubUrl = (options.avatar?.source === 'worldmesh' && options.avatar.hubUrl) || DEFAULT_HUB;
+            return ticket ? resolveWorldMeshAvatar(hubUrl, ticket) : Promise.resolve(null);
+        }
+        : null);
+    let xrSession = null;
+    const xrOrigin = new Group();
+    xrOrigin.name = 'worldmesh-xr-origin';
+    const xrHeading = new Euler(0, 0, 0, 'YXZ');
+    if (vrEnabled) {
+        renderer.xr.enabled = true;
+        renderer.xr.setReferenceSpaceType('local-floor');
+        scene.add(xrOrigin);
+    }
     const handle = {
         scene,
         camera,
@@ -107,15 +160,25 @@ export function createWorldMesh(options) {
         respawn: () => doRespawn('manual'),
         setViewMode,
         getViewMode: () => cameraRig.mode,
+        getCameraDistance: () => cameraRig.distance,
+        setCameraDistance: (distance) => {
+            if (Number.isFinite(distance))
+                cameraRig.distance = Math.max(0.4, distance);
+        },
         addPortal: (portal) => {
             portals.add(portal);
         },
         travelTo,
+        releasePointer: () => input.release(),
         loadAvatar,
         clearAvatar,
+        getSharedAvatar: () => sharedAvatar.get(),
         on: (event, fn) => events.on(event, fn),
         off: (event, fn) => events.off(event, fn),
         refreshColliders: () => collision.refresh(),
+        enterVR,
+        exitVR,
+        isVR: () => renderer.xr.isPresenting,
     };
     applyViewVisibility();
     if (options.autoResize !== false)
@@ -123,12 +186,277 @@ export function createWorldMesh(options) {
     handleResize();
     if (options.autoStart !== false)
         start();
-    const network = options.network ?? createMultiplayer();
-    network?.attach(handle);
-    if (network?.bodies)
-        controller.bodies = () => network.bodies();
-    startAvatar();
+    let network;
+    /** Easing the field of view back to the world's own, after a walk-in took over the hub's. */
+    let fovReturn = null;
+    /** Live doorway view: said ready to the host, and drawn a view for it. */
+    let viewReady = false;
+    let viewFramed = false;
+    const viewStart = performance.now();
+    /** The host's latest view, not drawn yet. */
+    let pendingView = null;
+    if (viewing)
+        serveDoorwayView();
+    else
+        goOnline();
+    if (!viewing)
+        startAvatar();
+    if (vrEnabled && !viewing)
+        void offerVr();
     return handle;
+    function goOnline() {
+        network = options.network ?? createMultiplayer();
+        if (network instanceof Presence) {
+            const presence = network;
+            presence.setOnFull((full) => {
+                overlay.setRoomFull(full ? roomFullLabel(presence.url) : null, {
+                    onRetry: full ? () => presence.rejoin() : undefined,
+                });
+                if (full)
+                    input.exitPointerLock();
+                events.emit('room:full', { full });
+            });
+        }
+        network?.attach(handle);
+        const bodies = network?.bodies?.bind(network);
+        if (bodies)
+            controller.bodies = () => bodies();
+    }
+    /**
+     * Drawn live in a host's doorway (DOORWAY_VIEW_PARAM): offline, no overlay,
+     * no input, no body of its own (the visitor's is in the host). The world
+     * keeps running (water, animations) and draws, once a frame, the latest
+     * view the host sent; none sent, nothing drawn. Ready once the player has
+     * landed at spawn, so the first view doesn't sink.
+     */
+    function serveDoorwayView() {
+        // Kept, out of sight: walked into, the world shows them again.
+        injectDoorwayViewStyle();
+        document.documentElement.classList.add(DOORWAY_VIEW_CLASS);
+        applyViewVisibility();
+        const onMessage = (event) => {
+            if (event.source !== window.parent || disposed || !viewReady)
+                return;
+            const view = event.data;
+            // Only the latest counts: a world slower than the host never falls behind.
+            if (view?.type === 'doorway:view' && validDoorwayView(view))
+                pendingView = view;
+            else if (isDoorwayMessage(event.data, 'enter')) {
+                window.removeEventListener('message', onMessage);
+                enterFromView(event.data);
+            }
+        };
+        window.addEventListener('message', onMessage);
+        awaitCharacter();
+    }
+    /**
+     * Walked into from the doorway: the pose comes in the door's frame, like
+     * the views, and lands the same way, on the spawn point beyond it. Then the
+     * world is itself again: drawing on its own, its UI and the visitor's body
+     * back, online. The host hears `doorway:entered` once a frame from there
+     * is drawn.
+     */
+    function enterFromView(message) {
+        const url = typeof message.url === 'string' ? message.url : null;
+        try {
+            if (url && new URL(url).origin === window.location.origin)
+                window.history.replaceState(null, '', url);
+        }
+        catch {
+            // Keep the view address.
+        }
+        if (disposed)
+            return;
+        takePose(poseFromDoor(message.pose));
+        viewing = false;
+        pendingView = null;
+        document.documentElement.classList.remove(DOORWAY_VIEW_CLASS);
+        handleResize();
+        applyViewVisibility();
+        input.requestPointerLock(isTouchDevice());
+        window.addEventListener('message', onCarry);
+        goOnline();
+        requestAnimationFrame(() => requestAnimationFrame(() => window.parent.postMessage({ type: 'doorway:entered' }, '*')));
+    }
+    /** A pose in the door's frame (doorway:enter from a live view), in this world's coordinates; null if malformed. */
+    function poseFromDoor(pose) {
+        const p = pose;
+        const vec = (v) => Array.isArray(v) && v.length === 3 && v.every((n) => typeof n === 'number' && Number.isFinite(n));
+        if (!p || !vec(p.position))
+            return null;
+        const spawnYaw = cameraRig.yaw;
+        viewTurn.setFromAxisAngle(UP, spawnYaw);
+        viewThreshold.set(0, 0, VIEW_SPAWN_BEHIND).applyQuaternion(viewTurn).add(controller.position);
+        const place = (v) => new Vector3(...v).applyQuaternion(viewTurn).add(viewThreshold).toArray();
+        const turn = (n) => (typeof n === 'number' && Number.isFinite(n) ? n + spawnYaw : n);
+        return {
+            ...p,
+            position: place(p.position),
+            velocity: vec(p.velocity) ? new Vector3(...p.velocity).applyQuaternion(viewTurn).toArray() : p.velocity,
+            camera: vec(p.camera) ? place(p.camera) : p.camera,
+            yaw: turn(p.yaw),
+            facing: turn(p.facing),
+        };
+    }
+    /** In the loop, instead of drawing: say ready once settled at spawn, then draw the latest view. */
+    function stepDoorwayView() {
+        if (!viewReady && (controller.onGround || performance.now() - viewStart > VIEW_SETTLE * 1000)) {
+            viewReady = true;
+            window.parent.postMessage({ type: 'doorway:view-ready' }, '*');
+        }
+        const view = pendingView;
+        if (!view)
+            return;
+        pendingView = null;
+        drawDoorwayView(view);
+        if (!viewFramed) {
+            viewFramed = true;
+            window.parent.postMessage({ type: 'doorway:view-frame' }, '*');
+        }
+    }
+    /**
+     * One view: the host's camera, in the door's frame (threshold at the
+     * origin, +Y up, −Z through the doorway), carried onto the spawn point
+     * VIEW_SPAWN_BEHIND metres beyond it, facing the way the player does.
+     * Only the doorway's part of the screen, and nothing on the host's side.
+     */
+    function drawDoorwayView(view) {
+        const { width, height: viewHeight } = view.viewport;
+        renderer.getSize(viewSize);
+        if (viewSize.x !== width || viewSize.y !== viewHeight)
+            renderer.setSize(width, viewHeight);
+        if (camera instanceof PerspectiveCamera) {
+            camera.fov = view.camera.fov;
+            camera.aspect = width / viewHeight;
+            camera.updateProjectionMatrix();
+        }
+        viewTurn.setFromAxisAngle(UP, cameraRig.yaw);
+        viewThreshold.set(0, 0, VIEW_SPAWN_BEHIND).applyQuaternion(viewTurn).add(controller.position);
+        camera.position.fromArray(view.camera.position).applyQuaternion(viewTurn).add(viewThreshold);
+        camera.quaternion.copy(viewTurn).multiply(viewQuaternion.fromArray(view.camera.quaternion));
+        camera.updateMatrixWorld();
+        viewClip.setFromNormalAndCoplanarPoint(viewForward.set(0, 0, -1).applyQuaternion(viewTurn), viewThreshold);
+        const worldPlanes = renderer.clippingPlanes;
+        renderer.clippingPlanes = [...worldPlanes, viewClip];
+        const [left, top, right, bottom] = view.rect;
+        renderer.setScissorTest(true);
+        renderer.setScissor(left, viewHeight - bottom, right - left, bottom - top);
+        renderer.render(scene, camera);
+        renderer.setScissorTest(false);
+        renderer.clippingPlanes = worldPlanes;
+    }
+    /** The hub's joystick, still held as the visitor walked in, keeps them walking until it is let go. */
+    function onCarry(event) {
+        if (event.source !== window.parent || !isDoorwayMessage(event.data, 'carry'))
+            return;
+        input.carry(Number(event.data.x) || 0, Number(event.data.z) || 0);
+        if (!event.data.x && !event.data.z)
+            window.removeEventListener('message', onCarry);
+    }
+    /**
+     * In a doorway: the host hands over the visitor's character while the world
+     * still waits, so it is on screen from the first frame they walk in
+     * (Doorway §6): `{ type: 'doorway:character', format, name, data }`, the
+     * model file itself (nothing is fetched twice), or `data: null` for the
+     * default body. Taken from any host, only if the world shows visitors'
+     * characters at all. From this world's own hub (`avatar.hubUrl`), the
+     * WorldMesh extras under `worldmesh` are used too: the Avatar Wallet
+     * descriptor (for credits) and the handoff ticket for portals onwards. The
+     * pre-Doorway `worldmesh:avatar` from the hub is still understood. Answers
+     * `doorway:character-ready` (or `worldmesh:avatar-ready`).
+     */
+    function awaitCharacter() {
+        const config = options.avatar;
+        if (config?.source !== 'worldmesh')
+            return;
+        let hubOrigin;
+        try {
+            hubOrigin = new URL(config.hubUrl ?? DEFAULT_HUB).origin;
+        }
+        catch {
+            return;
+        }
+        let latest = 0;
+        window.addEventListener('message', async (event) => {
+            if (event.source !== window.parent)
+                return;
+            const message = event.data;
+            const fromHub = event.origin === hubOrigin;
+            const neutral = message?.type === 'doorway:character';
+            if (!neutral && !(fromHub && message?.type === 'worldmesh:avatar'))
+                return;
+            const turn = ++latest;
+            const extras = (neutral ? message.worldmesh : message);
+            if (fromHub && typeof extras?.ticket === 'string')
+                setAvatarTicket(extras.ticket);
+            const data = message.data instanceof ArrayBuffer ? message.data : undefined;
+            let descriptor = fromHub ? parseAvatarDescriptor(extras?.descriptor) : null;
+            if (!descriptor && neutral && data && (message.format === 'vrm' || message.format === 'glb')) {
+                descriptor = {
+                    provider: 'doorway',
+                    avatarId: '',
+                    name: typeof message.name === 'string' ? message.name.slice(0, 64) : null,
+                    thumbnail: null,
+                    format: message.format,
+                    // Never fetched: the file came with the message.
+                    modelUrl: '',
+                    expiresAt: null,
+                    sourceUrl: null,
+                };
+            }
+            let loaded = false;
+            if (descriptor) {
+                loaded = await loadAvatar(descriptor, data);
+            }
+            else if (neutral ? message.data === null : extras?.descriptor === null) {
+                // Back to the default body (private mode, or no character any more).
+                clearAvatar();
+            }
+            if (turn !== latest || disposed)
+                return;
+            const answer = neutral ? 'doorway:character-ready' : 'worldmesh:avatar-ready';
+            window.parent.postMessage({ type: answer, loaded }, event.origin);
+        });
+    }
+    /** Where a hub had the visitor as they walked in, in this world's coordinates. Ignores anything malformed. */
+    function takePose(pose) {
+        const p = pose;
+        const vec = (v) => Array.isArray(v) && v.length === 3 && v.every((n) => Number.isFinite(n));
+        const num = (n) => typeof n === 'number' && Number.isFinite(n);
+        if (!p || !vec(p.position))
+            return;
+        controller.reset(new Vector3(...p.position));
+        if (vec(p.velocity))
+            controller.velocity.set(...p.velocity);
+        if (num(p.yaw))
+            cameraRig.yaw = p.yaw;
+        if (num(p.pitch))
+            cameraRig.pitch = p.pitch;
+        if (num(p.facing))
+            player.facing = p.facing;
+        if (p.mode === 'first' || p.mode === 'third')
+            setViewMode(p.mode);
+        if (cameraRig.mode === 'third' && vec(p.camera)) {
+            // Same boom as the hub's camera had, measured from this world's eyes; it eases back out from there.
+            const eyes = new Vector3(...p.position).add(new Vector3(0, player.eyeHeight * (controller.height / height), 0));
+            cameraRig.snapBoom(eyes.distanceTo(new Vector3(...p.camera)));
+        }
+        // The figure keeps the colour it had in the hub (the default body only).
+        if (typeof p.color === 'string' && /^#[0-9a-f]{6}$/i.test(p.color) && player.root && !avatarDescriptor)
+            setAvatarColor(player.root, p.color);
+        if (num(p.fov) && camera instanceof PerspectiveCamera && Math.abs(camera.fov - p.fov) > 0.01) {
+            fovReturn = { from: p.fov, to: camera.fov, t: 0 };
+            camera.fov = p.fov;
+            camera.updateProjectionMatrix();
+        }
+    }
+    /** Leave for another page; a world inside a host's page asks the host to go there instead. */
+    function leaveFor(url) {
+        if (inHost)
+            window.parent.postMessage({ type: 'doorway:navigate', url }, '*');
+        else
+            window.location.href = url;
+    }
     /** Brings in the visitor's own avatar, if the world asked for one. The default body stays until it is ready. */
     function startAvatar() {
         const config = options.avatar;
@@ -149,7 +477,7 @@ export function createWorldMesh(options) {
                 void loadAvatar(descriptor);
         }, (error) => events.emit('avatar:error', { descriptor: null, error }));
     }
-    async function loadAvatar(descriptor) {
+    async function loadAvatar(descriptor, data) {
         if (disposed || !player.root)
             return false;
         avatarLoad?.abort();
@@ -159,6 +487,7 @@ export function createWorldMesh(options) {
                 height,
                 maxBytes: options.avatar?.maxBytes,
                 signal: load.signal,
+                data,
             });
             if (disposed || load.signal.aborted) {
                 loaded.dispose();
@@ -167,6 +496,7 @@ export function createWorldMesh(options) {
             if (!player.setExternalBody(loaded))
                 return false;
             avatarDescriptor = descriptor;
+            sharedAvatar.set(descriptor);
             applyViewVisibility();
             events.emit('avatar:load', { descriptor });
             return true;
@@ -187,38 +517,111 @@ export function createWorldMesh(options) {
         avatarLoad?.abort();
         player.clearExternalBody();
         avatarDescriptor = null;
+        sharedAvatar.set(null);
     }
     function start() {
         if (running || disposed)
             return;
         running = true;
         lastTime = performance.now();
-        frameHandle = requestAnimationFrame(frame);
+        // setAnimationLoop is the WebXR frame pump; it also drives the flat canvas.
+        renderer.setAnimationLoop(frame);
     }
     function stop() {
         running = false;
-        if (frameHandle)
-            cancelAnimationFrame(frameHandle);
-        frameHandle = 0;
+        renderer.setAnimationLoop(null);
     }
     function frame(now) {
         if (!running)
             return;
-        frameHandle = requestAnimationFrame(frame);
         const dt = Math.min((now - lastTime) / 1000, MAX_FRAME);
         lastTime = now;
         update(dt);
         options.onUpdate?.(dt, handle);
-        renderer.render(scene, camera);
+        if (fovReturn && camera instanceof PerspectiveCamera) {
+            fovReturn.t = Math.min(1, fovReturn.t + dt / FOV_RETURN);
+            const k = fovReturn.t * fovReturn.t * (3 - 2 * fovReturn.t);
+            camera.fov = fovReturn.from + (fovReturn.to - fovReturn.from) * k;
+            camera.updateProjectionMatrix();
+            if (fovReturn.t >= 1)
+                fovReturn = null;
+        }
+        // A live doorway view draws the host's latest camera instead (stepDoorwayView).
+        // Drawing is what places things otherwise, and colliders need them placed.
+        if (viewing) {
+            scene.updateMatrixWorld();
+            stepDoorwayView();
+        }
+        else {
+            renderer.render(scene, camera);
+        }
+    }
+    async function offerVr() {
+        if (disposed || !(await immersiveVrSupported()))
+            return;
+        overlay.setVrAvailable(true);
+    }
+    async function enterVR() {
+        if (!vrEnabled || disposed)
+            return false;
+        if (renderer.xr.isPresenting)
+            return true;
+        try {
+            input.exitPointerLock();
+            const session = await requestImmersiveVr(renderer);
+            bindXrSession(session);
+            return true;
+        }
+        catch (error) {
+            console.warn('[worldmesh] Could not start VR.', error);
+            return false;
+        }
+    }
+    async function exitVR() {
+        if (!xrSession)
+            return;
+        try {
+            await xrSession.end();
+        }
+        catch {
+            unbindXrSession();
+        }
+    }
+    function bindXrSession(session) {
+        xrSession = session;
+        input.setXrSession(session);
+        if (camera.parent !== xrOrigin)
+            xrOrigin.add(camera);
+        overlay.setVrPresenting(true);
+        applyViewVisibility();
+        session.addEventListener('end', unbindXrSession);
+        events.emit('vr:enter', {});
+    }
+    function unbindXrSession() {
+        if (!xrSession)
+            return;
+        xrSession.removeEventListener('end', unbindXrSession);
+        xrSession = null;
+        input.setXrSession(null);
+        if (camera.parent === xrOrigin)
+            xrOrigin.remove(camera);
+        xrOrigin.position.set(0, 0, 0);
+        xrOrigin.rotation.set(0, 0, 0);
+        overlay.setVrPresenting(false);
+        applyViewVisibility();
+        events.emit('vr:exit', {});
     }
     /** Advance the simulation. Split from rendering so a fixed tick can drive it. */
     function update(dt) {
         if (dt <= 0)
             return;
         elapsed += dt;
+        const presenting = renderer.xr.isPresenting;
+        if (presenting)
+            input.pollXr(dt);
         const look = input.readLook();
         const playing = isPlaying();
-        if (playing) {
+        if (playing && !presenting) {
             if (input.locked || isTouchDevice() || options.ui?.moveBeforeLock === true) {
                 cameraRig.look(look.dx, look.dy);
                 if (input.locked)
@@ -231,6 +634,11 @@ export function createWorldMesh(options) {
             if (expression)
                 player.setExpression(expression);
         }
+        if (presenting) {
+            xrOrigin.rotation.y += input.readXrTurn();
+            xrHeading.setFromQuaternion(renderer.xr.getCamera().quaternion, 'YXZ');
+            cameraRig.yaw = xrHeading.y;
+        }
         // Fixed substeps keep movement stable regardless of frame rate.
         let remaining = dt;
         while (remaining > 0) {
@@ -240,13 +648,19 @@ export function createWorldMesh(options) {
         }
         if (controller.position.y < controller.tuning.fallLimit)
             doRespawn('fell');
-        cameraRig.update(dt, controller.position, player.eyeHeight * (controller.height / height));
-        player.sync(controller.position, cameraRig.yaw, controller.height, {
+        if (presenting) {
+            xrOrigin.position.copy(controller.position);
+        }
+        else {
+            cameraRig.update(dt, controller.position, player.eyeHeight * (controller.height / height));
+        }
+        const footfall = player.sync(controller.position, cameraRig.yaw, controller.height, {
             dt,
             speed: Math.hypot(controller.velocity.x, controller.velocity.z),
             grounded: controller.onGround || controller.flying,
             heading: Math.atan2(-controller.velocity.x, -controller.velocity.z),
         }, cameraRig.mode === 'third');
+        footsteps?.update(dt, playing ? Math.hypot(controller.velocity.x, controller.velocity.z) : 0, controller.onGround, footfall, controller.velocity.y, controller.flying);
         portals.animate(elapsed);
         updatePortals();
         input.endFrame();
@@ -254,6 +668,8 @@ export function createWorldMesh(options) {
     }
     /** Walking, until Esc opens the pause screen. */
     function isPlaying() {
+        if (renderer.xr.isPresenting)
+            return true;
         return !overlay.isPaused() && (input.locked || options.ui?.moveBeforeLock === true);
     }
     function updatePortals() {
@@ -294,19 +710,21 @@ export function createWorldMesh(options) {
         });
         if (cancelled)
             return;
-        input.exitPointerLock();
-        window.location.href = url;
+        input.release();
+        leaveFor(url);
     }
     function setViewMode(mode) {
         if (cameraRig.mode === mode)
             return;
         cameraRig.setMode(mode);
+        rememberView(mode);
         applyViewVisibility();
         events.emit('view:change', { mode });
     }
     /** In first person the avatar would fill the screen. */
     function applyViewVisibility() {
-        player.setVisible(cameraRig.mode === 'third');
+        // In a doorway the visitor's own body is the host's: none here.
+        player.setVisible(!viewing && (cameraRig.mode === 'third' || renderer.xr.isPresenting));
     }
     function getState() {
         return {
@@ -349,15 +767,25 @@ export function createWorldMesh(options) {
         events.emit('respawn', { reason });
     }
     function travelTo(url) {
-        input.exitPointerLock();
-        window.location.href = buildTravelUrl(url);
+        input.release();
+        leaveFor(buildTravelUrl(url));
+    }
+    function isDoorwayViewRequest() {
+        try {
+            return window.parent !== window && new URLSearchParams(window.location.search).has(DOORWAY_VIEW_PARAM);
+        }
+        catch {
+            return false;
+        }
     }
     function handleResize() {
+        if (renderer.xr.isPresenting)
+            return;
         const width = window.innerWidth;
         const viewHeight = window.innerHeight;
         // Pixel ratio first: setSize derives the drawing buffer from it, and it
         // must also update the canvas CSS size or the canvas overflows the window.
-        renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+        renderer.setPixelRatio(viewing ? 1 : Math.min(window.devicePixelRatio, 2));
         renderer.setSize(width, viewHeight);
         cameraRig.resize(width, viewHeight);
     }
@@ -369,6 +797,10 @@ export function createWorldMesh(options) {
             url: `${server.replace(/\/$/, '')}/world`,
             scene,
             onCount: (count) => events.emit('players', { count }),
+            getAvatar: () => sharedAvatar.get(),
+            // Other players' avatars are shown only from links this world's hub signed.
+            verifyAvatar: createShareVerifier((options.avatar?.source === 'worldmesh' && options.avatar.hubUrl) || DEFAULT_HUB),
+            maxAvatarBytes: options.avatar?.maxBytes,
         });
     }
     function dispose() {
@@ -376,14 +808,54 @@ export function createWorldMesh(options) {
             return;
         disposed = true;
         stop();
+        const session = xrSession;
+        if (session) {
+            session.removeEventListener('end', unbindXrSession);
+            unbindXrSession();
+            void session.end().catch(() => undefined);
+        }
         avatarLoad?.abort();
+        sharedAvatar.dispose();
         window.removeEventListener('resize', handleResize);
         network?.detach?.();
         input.dispose();
         overlay.dispose();
         portals.dispose();
         player.dispose();
+        footsteps?.dispose();
+        if (vrEnabled)
+            scene.remove(xrOrigin);
         events.clear();
     }
 }
+function validDoorwayView(view) {
+    const numbers = (value, length) => Array.isArray(value) && value.length === length && value.every((n) => typeof n === 'number' && Number.isFinite(n));
+    const { camera, viewport } = view;
+    return (!!camera &&
+        numbers(camera.position, 3) &&
+        numbers(camera.quaternion, 4) &&
+        typeof camera.fov === 'number' &&
+        camera.fov > 0 &&
+        !!viewport &&
+        viewport.width > 0 &&
+        viewport.height > 0 &&
+        numbers(view.rect, 4));
+}
+const UP = new Vector3(0, 1, 0);
+const viewSize = new Vector2();
+const viewTurn = new Quaternion();
+const viewQuaternion = new Quaternion();
+const viewThreshold = new Vector3();
+const viewForward = new Vector3();
+const viewClip = new Plane();
+/** On the page while it is drawn in a host's doorway: its overlay and touch controls are kept, unseen. */
+const DOORWAY_VIEW_CLASS = 'wm-doorway-view';
+function injectDoorwayViewStyle() {
+    if (document.getElementById(DOORWAY_VIEW_CLASS))
+        return;
+    const style = document.createElement('style');
+    style.id = DOORWAY_VIEW_CLASS;
+    style.textContent = `html.${DOORWAY_VIEW_CLASS} .wm-overlay, html.${DOORWAY_VIEW_CLASS} .wm-touch-root { display: none !important; }`;
+    document.head.appendChild(style);
+}
 //# sourceMappingURL=worldmesh.js.map