@found-in-space/skykit 0.2.0-alpha.1 → 0.2.0-alpha.20260528

package/src/__tests__/skykit-xr.test.js

@@ -1,16 +1,19 @@
 import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
 import test from 'node:test';
 import * as THREE from 'three';
 
 import {
   applySkykitXrDepthRange,
   computeSkykitXrDepthRange,
+  createSkykitXrBodyPlugin,
   createSkykitXrBodyTracker,
   createSkykitXrControlBindings,
   createSkykitXrNavigationPlugin,
   createSkykitXrObserverRig,
   createSkykitXrPickRouter,
   createSkykitXrRaySource,
+  createSkykitXrRayVisualPlugin,
   createSkykitXrRig,
   createSkykitXrSessionPlugin,
   createSkykitXrStarPickingPlugin,
@@ -20,6 +23,38 @@ import {
 } from '../xr.js';
 import { createSkykitActionRegistry } from '../index.js';
 
+test('xr free-roam demo uses restored alpha XR regressions defaults', () => {
+  const source = readFileSync(new URL('../../examples/xr-free-roam/xr-free-roam.js', import.meta.url), 'utf8');
+
+  assert.match(source, /createDefaultThreeStarFieldMaterialProfile/);
+  assert.doesNotMatch(source, /createVrThreeStarFieldMaterialProfile/);
+  assert.match(source, /createSkykitXrRayVisualPlugin/);
+  assert.match(source, /createSkykitXrBodyPlugin/);
+  assert.match(source, /createSurfaceShell/);
+  assert.match(source, /createMetaSidecarProviderService/);
+  assert.match(source, /deriveMetaSidecarUrlFromRenderUrl/);
+  assert.match(source, /metaSidecarEntryDisplayFields/);
+  assert.match(source, /datasetId:\s*DATASET_ID_c56103/);
+  assert.match(source, /attributes:\s*\[\s*'objectRef'\s*,\s*'pickMeta'\s*\]/);
+  assert.match(source, /selectSun:\s*'xr-demo:selected\.sun'/);
+  assert.match(source, /primaryActionId:\s*XR_DEMO_ACTIONS\.goSelected/);
+  assert.match(source, /primaryActionLabel:\s*'Fly to'/);
+  assert.match(source, /homeControl:\s*'button'/);
+  assert.match(source, /pointerType:\s*'ray'/);
+  assert.match(source, /return xrRig\.leftHandRoot/);
+  assert.match(source, /latestPanelFrame = rootContext\?\.frame \?\? latestPanelFrame/);
+  assert.doesNotMatch(source, /dragThreshold/);
+  assert.doesNotMatch(source, /driver:\s*'pose-anchored'/);
+  assert.doesNotMatch(source, /anchorPose/);
+  assert.doesNotMatch(source, /latestPanelFrame = frame/);
+  assert.doesNotMatch(source, /createChoiceGroup/);
+  assert.doesNotMatch(source, /createSlider/);
+  assert.doesNotMatch(source, /createToggle/);
+  assert.doesNotMatch(source, /createStack/);
+  assert.doesNotMatch(source, /waypointPrefix/);
+  assert.doesNotMatch(source, /panelState\.page/);
+});
+
 test('skykit/xr rig builds multi-root hierarchy', () => {
   const camera = new THREE.PerspectiveCamera();
   const rig = createSkykitXrRig({
@@ -84,6 +119,55 @@ test('skykit/xr body, rays, and pick router compose generic route results', () =
   assert.equal(route.hit.object, 'target');
 });
 
+test('skykit/xr body plugin drives tracked hand roots before dependent parts', () => {
+  const rig = createSkykitXrRig();
+  const leftGripSpace = {};
+  const referenceSpace = {};
+  const bodyUpdates = [];
+  let part = null;
+  const plugin = createSkykitXrBodyPlugin({
+    rig,
+    onBody(body) {
+      bodyUpdates.push(body);
+    },
+  });
+  plugin.setup(createPluginContext({
+    addPart(nextPart) {
+      part = nextPart;
+    },
+  }));
+
+  part.update(createXrFrame({
+    referenceSpace,
+    inputSources: [{
+      handedness: 'left',
+      gripSpace: leftGripSpace,
+      gamepad: {
+        buttons: [{ pressed: false, touched: false, value: 0 }],
+        axes: [0, 0],
+      },
+    }],
+    xrFrame: {
+      getPose(space, ref) {
+        assert.equal(ref, referenceSpace);
+        if (space !== leftGripSpace) return null;
+        return {
+          transform: {
+            position: { x: 0.1, y: 0.2, z: 0.3 },
+            orientation: { x: 0, y: 0, z: 0, w: 1 },
+          },
+        };
+      },
+    },
+  }));
+
+  assert.deepEqual(rig.leftHandRoot.position.toArray(), [0.1, 0.2, 0.3]);
+  assert.equal(rig.leftHandRoot.visible, true);
+  assert.equal(rig.rightHandRoot.visible, false);
+  assert.equal(plugin.getBody().leftHand?.buttons, 1);
+  assert.equal(bodyUpdates.length, 1);
+});
+
 test('skykit/xr depth helpers compute and apply render state', () => {
   const range = computeSkykitXrDepthRange({
     visibleBounds: { min: { x: -1, y: -1, z: -20 }, max: { x: 1, y: 1, z: -10 } },
@@ -102,6 +186,32 @@ test('skykit/xr depth helpers compute and apply render state', () => {
   assert.deepEqual(state, { depthNear: range.depthNear, depthFar: range.depthFar });
 });
 
+test('skykit/xr depth helpers include distant visible star bounds', () => {
+  const range = computeSkykitXrDepthRange({
+    observer: { x: 0, y: 0, z: 0 },
+    visibleBounds: {
+      min: { x: 62, y: 602, z: -13 },
+      max: { x: 64, y: 604, z: -11 },
+    },
+    observerCentricSpheres: [{ radiusNavigationUnits: 16 }],
+    scale: {
+      navigationUnits: 'pc',
+      metersPerNavigationUnit: 1,
+      worldUnitsPerNavigationUnit: 1,
+    },
+    policy: {
+      near: 0.03,
+      minFar: 100,
+      maxFar: 2000000,
+      marginFactor: 1.2,
+    },
+  });
+
+  assert.ok(range.far > 720);
+  assert.ok(range.telemetry.farthestVisibleBoundsDistance > 600);
+  assert.equal(range.telemetry.farthestObserverCentricSphereDistance, 16);
+});
+
 test('skykit/xr session helpers use injected navigator', async () => {
   let ended = false;
   const session = {
@@ -118,7 +228,8 @@ test('skykit/xr session helpers use injected navigator', async () => {
       async isSessionSupported(mode) {
         return mode === 'immersive-vr';
       },
-      async requestSession() {
+      async requestSession(_mode, init) {
+        this.lastInit = init;
         return session;
       },
     },
@@ -126,6 +237,7 @@ test('skykit/xr session helpers use injected navigator', async () => {
   assert.equal(await isSkykitXrModeSupported('immersive-vr', { navigator }), true);
   const handle = await enterSkykitXrSession({ navigator, mode: 'immersive-vr' });
   assert.equal(handle.presenting, true);
+  assert.deepEqual(navigator.xr.lastInit.optionalFeatures, ['local-floor']);
   await exitSkykitXrSession(handle);
   assert.equal(ended, true);
 });
@@ -147,15 +259,20 @@ test('skykit/xr observer rig bridges viewer state to an XR rig without camera re
 
 test('skykit/xr session plugin registers enter/exit actions and syncs snapshot state', async () => {
   let activeSession = null;
+  let requestedReferenceSpaceCount = 0;
   const session = {
     async requestReferenceSpace(type) {
+      requestedReferenceSpaceCount += 1;
       return { type };
     },
     async end() {
       this.ended = true;
+      activeSession = null;
+      renderer.xr.isPresenting = false;
     },
     addEventListener() {},
   };
+  let rendererReferenceSpaceType = null;
   const renderer = {
     xr: {
       enabled: false,
@@ -163,6 +280,9 @@ test('skykit/xr session plugin registers enter/exit actions and syncs snapshot s
       getSession() {
         return activeSession;
       },
+      setReferenceSpaceType(type) {
+        rendererReferenceSpaceType = type;
+      },
       async setSession(nextSession) {
         activeSession = nextSession;
         this.isPresenting = Boolean(nextSession);
@@ -174,7 +294,8 @@ test('skykit/xr session plugin registers enter/exit actions and syncs snapshot s
       async isSessionSupported() {
         return true;
       },
-      async requestSession() {
+      async requestSession(_mode, init) {
+        this.lastInit = init;
         return session;
       },
     },
@@ -195,8 +316,12 @@ test('skykit/xr session plugin registers enter/exit actions and syncs snapshot s
 
   await actions.invoke('skykit:xr.enter');
   assert.equal(renderer.xr.enabled, true);
+  assert.equal(rendererReferenceSpaceType, 'local-floor');
+  assert.deepEqual(navigator.xr.lastInit.optionalFeatures, ['local-floor']);
+  assert.equal(requestedReferenceSpaceCount, 0);
   assert.equal(activeSession, session);
   assert.equal(plugin.getSnapshot().presenting, true);
+  assert.equal(plugin.getSnapshot().enterStage, 'presenting');
 
   const frame = createXrFrame({ renderer });
   part.update(frame);
@@ -240,6 +365,58 @@ test('skykit/xr navigation plugin updates viewer state from controller axes', ()
   assert.deepEqual(actions.getControlValue('skykit:ship.control.move'), { x: 0, y: 0, z: -10 });
 });
 
+test('skykit/xr ray visual shows the controller ray and shortens at blockers', () => {
+  let part = null;
+  let disposedRaySource = false;
+  const plugin = createSkykitXrRayVisualPlugin({
+    raySource: {
+      getRay() {
+        return {
+          id: 'ray',
+          kind: 'target-ray',
+          handedness: 'right',
+          origin: { x: 1, y: 2, z: 3 },
+          direction: { x: 0, y: 0, z: -1 },
+          length: 10,
+        };
+      },
+      getSnapshot() {
+        return { id: 'ray-source' };
+      },
+      dispose() {
+        disposedRaySource = true;
+      },
+    },
+    blockers: [{
+      blockRay() {
+        return { blocked: true, distance: 3, hit: { componentId: 'panel' } };
+      },
+    }],
+  });
+  const context = createPluginContext({
+    addPart(nextPart) {
+      part = nextPart;
+    },
+  });
+  plugin.setup(context);
+  part.attach(context);
+
+  part.update(createXrFrame());
+
+  assert.equal(part.object3d.visible, true);
+  assert.equal(plugin.getSnapshot().blocked, true);
+  assert.equal(plugin.getSnapshot().lastLength, 3);
+  assert.deepEqual(
+    Array.from(part.object3d.children[0].geometry.getAttribute('position').array),
+    [1, 2, 3, 1, 2, 0],
+  );
+
+  part.update({ ...createXrFrame(), xr: { presenting: false } });
+  assert.equal(part.object3d.visible, false);
+  part.dispose();
+  assert.equal(disposedRaySource, true);
+});
+
 test('skykit/xr star picking fires only on trigger edge and registers attribute-only demand', () => {
   const actions = createSkykitActionRegistry();
   let part = null;