Ships

Native UI port: wrist/chat/debug are now the REAL chat widgets (uikit.mjs = bundled wristUI+chatPanel+debugHud). roomui imports uikit, drives the generic native wrist with Carrier00's button spec (Chat·Avatar·Debug·Report·Exit); native ChatPanel (push from chat_message) + native head-locked DebugHud. Deleted rebuilt wrist/chatpanel/debughud.js; kept React-adapted picker+feedback. Wrist is poke-driven (native) like chat; laser only for the far floating panels. import-map: uikit

Carrier00 VR: aim-ray laser + fingertip dots so you can see where you point + click the wrist/avatar buttons

VR interaction: add a visible aim ray (laser) from each hand/controller + a bright fingertip dot, so the user can SEE where they're pointing and pinch/trigger to click wrist/panel buttons (they couldn't see their own hands to aim)

Native furniture feed + fix peripheral passthrough. (1) vr.js reads frame.detectedMeshes → builds furniture groups → env.styleFurniture (chat's exact impl), so 'Computer, make the <object> visible' reveals real scanned furniture. (2) main.js sky dome radius 5900→1000: it was at/beyond the XR far plane (far=6000) and getting clipped at the FOV periphery → raw passthrough; 1000 is well inside far like chat's 540/650

Native furniture feed (Computer show objects) + fix peripheral passthrough (sky dome was far-clipped)

Fix avatar-picker access + Computer commands: 'Computer, avatar' opens the picker (companion + YOUR avatar tabs) via voice — reliable when the wrist unit isn't reachable; also 'Computer, exit' (ends VR), chat/report/debug/hide. Wrist-anchor diagnostic logs whether a hand-joint/grip is in reach

'Computer, avatar' opens the avatar picker by voice + Computer exit/chat/report/debug/hide; wrist-anchor diagnostic

Carrier00 Phase 2 BATCH: real Eve via extracted CompanionRig (companion.mjs = Chat's VrmEngine companion logic — movement/gaze/lip-sync); full in-VR room UI (chat panel, avatar pickers, wrist unit, debug HUD, voice bug/feature reporter); Computer commands re-routed to room engine. VrmEngine refactored to delegate to CompanionRig (chat unchanged)

PHASE 2 batch: real Eve behavior + full room UI. companion.js drives the extracted CompanionRig (companion.mjs = Chat's VrmEngine companion logic, bundled) — movement/gaze/lip-sync/gestures; avatar_speak → rig.speak (plays+lipsyncs). Room UI (roomui.js + src/ui/*): chat panel, avatar pickers (cl_ai_avatar/cl_user_avatar), wrist unit, debug HUD, voice-dictated bug/feature reporter. Computer commands re-routed to the room engine. import-map: companionkit

Place Eve in front of the player's gaze + log her position/size (she loaded but wasn't visible)

Eve placement: stand her 1.5m in front of where the player is LOOKING at load (not a fixed guardian-forward spot that could be behind them/in a wall), face the player, disable frustum culling, and log her world position + height (to catch scale issues)

Carrier00 Phase 2a: render Eve's VRM body in the room (three-vrm from CDN, r0.180)

PHASE 2a: render Eve's VRM in the room. companion.js loads the companion's chosen .vrm (localStorage cl_ai_avatar, same origin as /chat) via @pixiv/three-vrm (CDN, three external, now r0.180) + three/addons GLTFLoader; stands her ~1.3m in front on the floor, under the VR rig (fixed in room, not sphere-bent), vrm.update each frame. Lip-sync next

Carrier00 VR: remove thumbstick, auto bow-alignment only

Remove the thumbstick nudge — auto-snap only (no manual control, no bloat). worldYaw = _fwdYaw (auto bow-to-wall alignment)

Carrier00 VR: re-enable AUTO bow-to-wall alignment (main.js now reads the auto _fwdYaw; duplicate-room confound is fixed)

Re-enable AUTO carrier-bow alignment (was only broken because main.js read the manual thumbstick value instead of the auto _fwdYaw). worldYaw = _fwdYaw (auto-snap the front wall to the bow at rendered -Z) + optional thumbstick nudge. The duplicate-room bug that made this look broken before is now fixed, so the snap holds

Carrier00 VR: right thumbstick rotates the naval world so you align a wall to the carrier bow yourself (persisted). No more auto-snap sign guessing

Carrier-bow alignment = USER-CONTROLLED (right thumbstick), persisted. Rotate the naval world to line a wall up with the carrier's bow yourself; saved to localStorage + restored per session. Replaces the auto-snap I kept getting the sign wrong on. Applied as a yaw premultiply on the eye-frame rotation (turns the world, not the room)

Upgrade Carrier00 three.js r0.160 -> r0.180 (import-map). Aligns with CommsLink (three ^0.180) so roomkit runs native + unblocks the VRM avatar port (@pixiv/three-vrm 3.5.3 needs r0.180). r0.160 already had the color-management + physical-lights defaults, so this is incremental — no breaking APIs in Carrier00's code

Upgrade three.js r0.160 -> r0.180 (aligns with CommsLink, unblocks VRM avatar)

Voice is just-talk (mic opens on room-join, no button) like /chat

Voice = just talk (like /chat): open the mic on room-join instead of push-to-talk (removed the controller-trigger gating); stop the mic on VR exit

Carrier00 Phase 1: chat/voice/AI via a 2nd socket to Chat's namespace + presencekit (Chat's real voiceCapture+tts). Hold trigger to talk

PHASE 1 presence port: Carrier00 becomes a CommsLink Chat client. Opens a 2nd socket to the chat DEFAULT namespace (same JWT as the /carrier00 game socket), auto-joins the player's room; push-to-talk (hold controller trigger/pinch) streams 16kHz PCM via Chat's real voiceCapture → server Amazon Transcribe → transcript returns as chat_message → the room's AI agent auto-replies (1-agent-1-human) with Polly audio → playAudioBlob speaks it. presencekit.mjs = bundled voiceCapture + tts (Chat's actual pipeline, not rebuilt). Lazy-imported; import-map adds presencekit

VR sky dome: opaque sky above the ocean horizon (fixes passthrough-above-horizon — scene.background is null for passthrough so nothing was drawn there). Backdrop on the player rig, renderOrder -50 + depthWrite off, masked by the room occluder (passthrough inside), shows through windows above the sea; color tracks _skyC. Also guard scene.background.copy in updateDayNight (was throwing on null bg in VR)

Carrier00 VR: opaque sky dome above the horizon (fixes passthrough sky); guard updateDayNight null background

VR hands: render tracked hand joints via XRHandModelFactory (getHand was an empty joint space = invisible hands with hand-tracking). Lazy-imported so it can't break the desktop game

Carrier00 VR: render hand-tracking joints (hands were invisible — getHand had no joint models)

ROOT CAUSE of the recurring VR '2nd room': loadCommandRoom is async (awaits the scan fetch) and is called on startup + every 400ms — if the fetch takes >400ms, two calls both pass the '_commandRoom null?' check and both build a c00CommandRoom, but only the last is tracked+hidden; the orphaned duplicate stays visible = the 2nd room (intermittent, timing-dependent). Fix: synchronous _roomLoading guard before the await (no more duplicates) + hide ALL c00CommandRoom copies by name in VR (clears any existing orphan without a reload). Confirmed via ancestor-aware NEAR probe: 2nd room = c00CommandRoom at 0.1m

Carrier00 VR: fix the recurring 2nd room — loadCommandRoom async race made a duplicate scanned room; add a load guard + hide all room copies by name in VR

Carrier00 VR: REVERT the wall-snap alignment (it broke the view again) — back to the stable 2nd-room-gone state

Align room to carrier: snap the naval world's yaw to the front wall's outward normal (computed from live walls) so a window squares to the bow — instead of aligning to the guardian's arbitrary forward axis (the ~27deg skew). Frozen once per session, applied as a yaw premultiply on the eye-frame rotation

Carrier00 VR: snap the naval world to the room's front wall (fixes the ~27deg room-vs-deck skew so a window faces the bow squarely)

Carrier00 VR: hide all bridge superstructure (incl. the default bridge that wasn't hidden) so it stops rendering on top of the player as a 2nd room; ancestor-aware diagnostic probe

Fix VR '2nd room': hide ALL bridge superstructure in passthrough (the default bridge _bridgeInteriorMeshes was only hidden when a command room loads, so in VR it rendered at the bridge = on the player after the floating-origin). Also hide captainFig/engineers there. Deck/hull stay (ship seen through windows). Made the diagnostic probe ancestor-aware (was counting hidden _commandRoom children as visible = false positive)

Add one-time VR root-cause probe: after the eye-frame transform, log every visible mesh within 18m of the player + its parent chain (c00vrlog 'NEAR...'), to identify the '2nd room' by system instead of guessing

One-time diagnostic probe — log visible meshes near the player in VR to identify the overlapping 2nd room

Fix VR room rotated relative to the carrier: fold the carrier heading (_fcq) back into the eye-frame rotation (_sqInv = (_sq·_fcq)^-1, matching the old rig orientation). Without it the naval world's yaw tracked the carrier's sphere-longitude instead of its bow, so the room read as rotated relative to the carrier while position mapped straight

Carrier00 VR: fix room-rotated-relative-to-carrier — fold the carrier heading back into the eye-frame rotation so the bow is a fixed room direction

Carrier00 VR floating-origin: render the naval world in the eye frame so the carrier bridge sits at the player and the sea curves away under them (was parked 25km out). Ocean+cloud shells transformed; far widened to 6000. Look through a cut window → the ocean/carrier

VR floating-origin: render the bent naval world in the eye's local frame (pos=_sqInv·(bent−_scp), quat=_sqInv·bent) so the carrier bridge sits at the player origin and the ocean curves away under them — instead of parking the dolly 25km out. Ocean+cloud shells transformed too; camera.far widened to 6000 (env.activate set 650 for chat's close world). XR-gated; naval world masked by walls except through the cut windows/doors = the 'see the sea' payoff

Hide the engine's chat outdoor world (trees/sky — built as a side effect of floorCentroid) so the naval world shows through openings; restrict voice commands to windows/doors/passthrough (time/weather/day-night are server-driven, mirror/light are chat-only)

Carrier00 env fixes per user: (1) hide the engine's chat outdoor world (env.world = trees/sky/ocean, built as a side effect of passing floorCentroid) each frame — the naval world is what shows through the openings, not the chat beach; keep the occluder shell. (2) restrict voice commands to opening/visibility/list — time/weather/day-night are SERVER-driven for all players (never per-client), mirror/light are chat-only

Carrier00 voice commands: mic → 'Computer, cut a window here' / 'make the walls invisible' → the SAME environment.ts grammar (parseEnvCommands + execute) as /chat, gaze-targeted. roomkit re-bundled to export parseEnvCommands; carrier00 iframe gains microphone permission

Wire voice commands: mic (Web Speech API) → 'Computer, …' → the SAME parseEnvCommands grammar + env.execute (gaze raycaster from the headset). Player can now cut windows/doors + toggle passthrough by voice, looking at the wall. roomkit re-bundled from roomkit-entry.ts to export parseEnvCommands; iframe gains microphone permission

Fix saved window/door placement — compute the real floor centroid+polygon from the live floor plane and pass to env.syncPlanes (was null, misplacing saved openings). Openings come from shared /chat localStorage

Fix saved window/door placement: compute the real floor centroid + polygon from the live floor plane and pass to env.syncPlanes (was null → the engine keyed every wall opening at distance 0, misplacing saved openings onto the wrong surface). Openings come from the shared cl_env_state_v1 localStorage (same origin as /chat)

Fix roomkit load — add three/examples/jsm/ to the import-map so the bundled engine's Reflector import resolves (dead-code mirror on r0.160). EnvironmentEngine now loads

Fix roomkit load: map three/examples/jsm/ in the import-map so the bundled engine's Reflector import resolves (r0.160, dead-code mirror). EnvironmentEngine failed to load without it

Wire in CommsLink's REAL room engine (roomkit.mjs = bundled environment.ts). VR now uses EnvironmentEngine fed live detected planes for the occluder shell (+ window/door cuts + voice passthrough toggles), replacing the stopgap. Lazy-imported so the desktop game is unaffected; renderWrapped skips envShell/envWorld from the bend

Wire in CommsLink's real room engine: vr.js lazily imports EnvironmentEngine from roomkit (bundled environment.ts), instantiates + activates it, and feeds it LIVE detected planes each frame (updateLiveScene) — the actual Chat occluder shell + window/door cuts + voice passthrough toggles, replacing my stopgap buildOccluder. import-map maps 'roomkit'→./roomkit.mjs; renderWrapped skips envShell/envWorld from the sphere-bend so the shell stays glued to the real room at the local-floor origin. Lazy import so it can't break the desktop game

Carrier00 VR room cleanup: remove the in-VR debug panel + hide the FPS rifle viewmodel in the passthrough command room — now it's just your real room

VR room cleanup: remove the in-VR debug panel (server log is enough) and hide the FPS rifle viewmodel in the passthrough command room. Now it's just your real room

Carrier00 VR passthrough room: rig pinned at the local-floor origin (zero offset) so headset==real-room pose; depth-only occluder from the scan masks the naval world so the Quest cameras show your REAL room; opaque virtual room hidden in VR (kept for desktop). Naval world culled for now — returns through windows + floating-origin next. Fixes 'saw the digital room, wrong location'

Fix: remove duplicate fetchScan in room.js (revert had kept the earlier copy)

VR passthrough room (increment 1): pin the rig at the local-floor origin (zero offset) so headset pose == real-room pose; add a depth-only occluder (buildOccluder) from the scan so the naval world is masked and the Quest cameras show your REAL room; hide the opaque virtual command room in VR (kept for desktop). Naval world sits far at the bent bridge (culled) for now — comes back through windows + floating-origin next. Fixes 'saw the digital room, wrong location'

Carrier00 VR step 0a: passthrough AR — flip the XR session to immersive-ar with transparent clear so the player stands in their real room with the naval world around it (desktop untouched, VR-gated). Foundation for the occluder room shell + windows/doors, reusing CommsLink's engine on r0.160

VR step 0a: passthrough. Flip the XR session from immersive-vr (opaque) to immersive-ar with a transparent clear + null background, so the player stands in their REAL room (Quest cameras) with the naval world rendered around it. Desktop untouched (all VR-gated). Occluder shell + windows/doors (0b) come next — reusing CommsLink's environment.ts on r0.160

Plop the ACTUAL scanned room onto the pylon — render the real SpaceScan geometry (walls/floor/ceiling from plane polygons, furniture from object meshes) exactly as captured, recentred onto the command pylon at its true dimensions. No reconstruction/box+blocks. No-scan players get the standard box room. Deck/pylon sized to the scan

Plop the ACTUAL scanned room onto the pylon (not a reconstructed box+blocks): buildScannedRoom renders the real SpaceScan geometry — walls/floor/ceiling from the plane polygons (ShapeGeometry + plane matrix) and furniture from the object meshes (vertices/indices + matrix) — recentred to the floor bbox centre so it sits on the command pylon at its true dimensions. Deck/pylon sized to the scan bbox. No-scan players get the standard box room. fetchScan returns raw scan; dimsFromScan exported for sizing

Command room mirrors the player's scan — render their scanned furniture (bed/desk/etc.) as recentred bounding-box blocks from the SpaceScan objects, so the room reads as their actual room. Browser-game feature; VR renders it

Room mirrors the scan: render the player's scanned FURNITURE as recentred bounding-box blocks (from SpaceScan objects — center transformed by the object matrix, sized by extents), so the command room reads as their actual room. Browser-game feature; VR just renders it

Keep browser + VR identical — island tower removed from ALL carriers at build; every player gets a command room (their scan if saved, else the standard room) instead of conditionally only scan players; engineers on deck for everyone. Command room is a browser-game feature; VR is just the render adapter

Keep browser + VR identical (no fork): remove the island tower from ALL carriers at build (carrier.js), and mount a command room for EVERY player — their scan if saved, else the STANDARD room — instead of conditionally replacing only for scan players. Command room is a browser-game feature on the carrier; VR is just the render adapter on top. Engineers home to the deck for everyone

Room cleanup: hide the carrier's island tower voxels (the tall block through the room's starboard side) via Carrier.hideIsland() when the scan replaces the bridge; move engineer home spots from the mid-deck cluster (z50, in the room) to the port deck line aft of the command island (where deck crew stand)

Command island cleanup (hide tower mast + rotating radar dish + beacon + helm/nav panel when scan replaces the bridge; captain moved to the deck; skinnier support column) + STEP 2: VR player now stands INSIDE the command room (VR eye moved to the room floor at the bridge, rig aligned to carrier heading so you face the front window)

Command island cleanup + VR player stands IN the room. Cleanup (when scan replaces the bridge): hide the tower mast, rotating radar dish (the white ball) + beacon, and the helm/nav panel; move the captain down onto the deck; skinnier support column (0.6x room, reads as a pillar). STEP 2: VR eye moved from carrier centre to the command room floor (bridge world pos) and the rig aligned to the carrier heading, so the headset stands inside the room facing the front window (bow)

Command island sized to the scan — room-sized platform + viewing-deck ring + railings + stairs to the carrier deck, replacing the entire oversized default bridge (fixes the room looking tiny). Plus fixes the old-bridge flash (scan fetch retries every 400ms instead of 3s, so the swap is instant)

Command island sized to the scan: room-sized platform + viewing-deck ring + railings + stairs down to the carrier deck (buildViewingDeck), replacing the ENTIRE default bridge (column+interior+stairs now all hidden). Fixes the room looking tiny on the old oversized platform. Also fixes the old-bridge flash: retry the scan fetch every 400ms (was 3s) so the swap is instant once the auth token arrives

Carrier00 Phase 1b: scanned room mounts on the carrier as the command island (renders in DESKTOP and VR). Built in main.js at the bridge location, sized to the player's scan; default bridge interior hidden, island column + stairs kept. User can verify placement in a normal browser

Phase 1b: mount the scanned room ON THE CARRIER as the command island (desktop + VR). room now built in main.js at the bridge location (BRIDGE_CX, BRIDGE.y, BRIDGE_CZ) on playerCarrier.group, sized to the scan; default bridge interior (floor/walls/ceiling/furniture) hidden, island column + stairs kept. Removed the old VR-dolly room. Retries the scan fetch until the auth token arrives

Fix VR command room not rendering: the player-rig dolly sits at the bent eye (~47k units from the cull center), so renderWrapped was distance-culling it (visible=false) and skipping the room subtree while the camera still drew the world. Now the dolly is excluded from the bend/cull loop like the camera/planet, so the command room renders

Fix: exclude the VR dolly (player rig) from renderWrapped's bend/cull loop — the dolly sits at the bent eye ~47k units from the cull center, so it was being distance-culled (visible=false), hiding the command room subtree while the camera still rendered the world. Now skipped like the camera/planet; step 3 places it at the bent eye

Carrier00 Phase 1b.1: the command room. A solid opaque room (floor/walls/ceiling + front window) stands on the carrier in VR, sized to the player's scanned room (GET /api/v1/space → largest floor plane bbox + ceiling height) or the standard-room default if no scan. Player stands inside it, looks out the front window at the naval world. Foundation for the console/doors/viewing-deck phases

Phase 1b.1: command room. New src/room.js builds a solid opaque command room (floor/walls/ceiling + front window) attached to the VR dolly so it rides the carrier and the player stands inside. Sizes to the player's SCANNED room via GET /api/v1/space (largest floor plane bbox + ceiling height), or the STANDARD_ROOM default (also the non-scan fallback). getToken wired from Net.me.token

Carrier00 VR sky decor fix: sun, moon, stars, water-climate tint, and storm clouds now anchor to the carrier's flat eye (_eyeFlat) instead of camera.position — which is dolly-local (~0) in VR, so they were placed 25k units away and disappeared. renderWrapped's bend offset now lands them correctly around the player

VR sky decor: anchor sun/moon/stars + climate + storm clouds to _eyeFlat (the carrier's flat position) instead of camera.position — in VR camera.position is dolly-local (~0), so they were placed 25k units off and vanished. renderWrapped's _cd offset then lands them correctly around the player

Carrier00 VR: render the ACTUAL sphere world. renderWrapped now handles XR — bends the world around the carrier's flat position, parks the dolly at the bent eye so the headset looks around the globe from the deck, shows sphereOcean (the real sea). Switched to immersive-VR (opaque) so the game's true sky + ocean render fully, no passthrough camper. No more flat-ocean hack

VR renders the ACTUAL sphere world (not a flat hack): renderWrapped now handles XR — bends the world around the CARRIER's flat position, parks the dolly at the bent eye (_scp/_sq) so the headset looks around the globe from the deck, shows sphereOcean. Switched to immersive-VR (opaque) so the game's real sky+ocean render fully with no passthrough camper. Removed the flat-ocean XR path (dead 3500 plane, never used)

Carrier00 VR: opaque sky dome — a BackSide sphere (depthTest off, drawn first, colour synced to the game's day/night sky) surrounds the player so every pixel not covered by the world is solid sky, never passthrough. immersive-ar leaves empty pixels transparent even with a background Color set, so real geometry is the only reliable fill. Fixes the real room showing through the sky/horizon instead of sea and sky

VR: opaque sky dome (BackSide sphere, depthTest off, drawn first, colour synced to game sky) — immersive-ar leaves empty pixels transparent even with a background Color, so real geometry is the only reliable fill; kills the passthrough camper showing behind the sea/sky

Carrier00 VR: opaque world — remove scene.background=null (root cause of BOTH the passthrough camper bleed-through AND the every-frame 'scene.background.copy of null' throw in updateDayNight); remove diagnostic box/posts. Re-deploy (prior attempt was SIGPIPE-killed before shipping)

VR: opaque world for now (user: don't show the camper) — keep the game's sky background instead of transparent passthrough; remove the diagnostic box/posts now that rendering is confirmed

Carrier00 VR FIX: the pre-try loop section (updateFps/serverWorldClock/updateDayNight/updateWeather/Aircraft.NIGHT) ran OUTSIDE the game-update try/catch — a throw there in XR killed the frame before the render, the exact root cause of 'presenting=true but 0 frames'. Now wrapped: render always runs, and the actual thrower is reported (PRE-TRY THREW). Frames should flow; box/posts/world visible

VR FIX: wrap the pre-try loop section (updateFps/serverWorldClock/updateDayNight/updateWeather) in try/catch — it ran OUTSIDE the game-update try, so a throw there killed the frame before render (root cause of presenting=true but 0 frames). Render now always runs; the thrower is reported as PRE-TRY THREW

Carrier00 VR diag: instrument the render loop — logOnce at loop-top ('XR loop tick reached'), at the render branch ('reached XR render branch'), and a try/catch around renderer.render in XR that reports the actual error. Pinpoints why frames=0 despite presenting=true (loop not driven vs loop dies before render vs render throws)

VR diag: logOnce at loop-top + render-branch + try/catch around the XR render (report the error), to pinpoint why the loop submits 0 frames despite presenting=true

Carrier00 VR self-diagnosis: add POST /api/v1/carrier00/vrlog (no-auth console sink) + the game reports every WebXR session step there, so the device's actual progress/error is readable in the api logs when the user just clicks VR (no console/typing). Reports immersive-ar/vr support on page load too

VR: report every session step to /api/v1/carrier00/vrlog so the device's WebXR progress is readable server-side (no console/typing needed); report immersive-ar/vr support on load

Add WebXR isolation test page at /carrier00-game/vrtest.html — a minimal standalone immersive-ar scene (rotating box + ring, canonical three.js pattern, on-screen status line). Isolates whether WebXR works at all in the Quest browser at commslink.net vs whether it's the game integration. Static file only; touches nothing else

Carrier00 VR: xr.enabled=true at STARTUP (the canonical requirement — three binds the loop's XR frame routing only when setAnimationLoop is called with xr.enabled already true; I'd set it on the button click, so frames never reached the headset → endless Quest loader). Plus: local-floor→local reference-space fallback, and an IN-VR head-locked debug panel (session steps + live frame count + carrier pos) so the next test pinpoints any remaining failure from inside the headset

VR: xr.enabled=true at startup (canonical — bind XR frame routing before setAnimationLoop); local-floor→local reference-space fallback; IN-VR debug panel (head-locked text: session steps + live frame count + carrier pos) so failures are diagnosable in-headset

Carrier00 VR: single-driver render loop. renderer.setAnimationLoop(loop) is now the ONLY loop for both desktop and VR (replaces the initial requestAnimationFrame + the loop's self-reschedule). setSession routes that same loop onto the XR frame callback — the previous rAF↔setAnimationLoop hand-off on button click never submitted frames, so the Quest sat on its pulsing 'waiting for first frame' loader. enterVR/onEnd no longer touch setAnimationLoop. Desktop is unchanged (setAnimationLoop behaves like rAF with xr.enabled=false)

VR: use renderer.setAnimationLoop as the single loop driver (desktop + XR) so setSession routes frames to the headset — the rAF↔setAnimationLoop hand-off left the Quest stuck on its 'waiting for first frame' loader

VR fix: don't bail the render loop on document.hidden while presenting (immersive XR reports the 2D doc hidden → nothing rendered); force flat ocean in XR; on-deck diagnostic geometry

Carrier00 VR fix: the render loop bailed every frame in VR because an immersive XR session reports document.hidden=true (the headset IS the display) — the 'tab hidden → idle' early-return is now gated on !isPresenting, so VR actually renders. Also force the flat ocean on / globe ocean off in the XR render, and add on-deck diagnostic geometry (red box + green post ring) so 'is anything rendering' is visible in-headset

Meta Quest VR Phase 1a: additive WebXR (immersive-ar passthrough), camera dolly on the carrier deck following the server-authoritative carrier, hand tracking. All main.js hooks guarded on renderer.xr.isPresenting so desktop is unchanged; renders flat in XR (globe bend fights the headset camera); alpha renderer for passthrough. VR button appears only on a WebXR headset

Carrier00 Meta Quest VR — Phase 1a (additive, desktop untouched). New src/vr.js: taps 'VR' → immersive-ar passthrough session, parents the camera to a dolly parked on the player's carrier deck (deckTopY, follows the server-authoritative carrier each frame), hand-tracking + controller grips. main.js hooks all guarded on renderer.xr.isPresenting: loop self-schedule + FPS cap gated (VR uses setAnimationLoop at headset rate), updateCamera early-returns in XR, renders FLAT in XR (the globe bend fights the headset camera), renderer gets alpha:true for passthrough. VR button hidden unless immersive-ar is supported. page.tsx: xr-spatial-tracking added to the carrier00 iframe allow. Room shell (occluder + windows) is Phase 1b. Doc: docs/CARRIER00_ROOM_FUSION.md updated with the real architecture

R54 bug batch (138/139/140): (138) worn avatar read 20-30% too large — scale now by standing-height RATIO (player eye height / avatar foot-to-eye), pelvis-independent, instead of pinning the head bone to the camera; (139) hand colliders added to the worn avatar's spring bones so touching hair/breasts moves them (adapts the companion's setupHairPhysics); (140) the tracked hand meshes + grip blobs now hide when the debug skeleton is off or an avatar is worn (the avatar's own hands render). Deferred: 141 (lip-sync needs mic-stream plumbing) + 142 (companion-under-table needs a companion-side snapshot)