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

package/src/__tests__/skykit.test.js

@@ -1,7 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import * as THREE from 'three';
-import { createJourney } from '@found-in-space/journey';
 import {
   createObserverShellStrategy,
   createStarCellData,
@@ -23,7 +22,6 @@ import {
   createSkykitDefaultKeyboardNavigationBindings,
   createSkykitAnimationLoop,
   createSkykitDebugBridge,
-  createSkykitJourneyPlugin,
   createSkykitNavigationPlugin,
   createSkykitStarPreloadRequestsFromSpatialHints,
   createSkykitStarStrategiesFromSpatialHints,
@@ -77,6 +75,57 @@ function createRenderer() {
   };
 }
 
+function createTextureRenderer() {
+  const renderer = createRenderer();
+  return {
+    ...renderer,
+    xr: { enabled: true },
+    currentTarget: null,
+    viewport: new THREE.Vector4(0, 0, 1, 1),
+    scissor: new THREE.Vector4(0, 0, 1, 1),
+    scissorTest: false,
+    getRenderTarget() {
+      return this.currentTarget;
+    },
+    setRenderTarget(target) {
+      this.currentTarget = target;
+    },
+    getViewport(target) {
+      return target.copy(this.viewport);
+    },
+    setViewport(value) {
+      if (value?.isVector4) this.viewport.copy(value);
+    },
+    getScissor(target) {
+      return target.copy(this.scissor);
+    },
+    setScissor(value) {
+      if (value?.isVector4) this.scissor.copy(value);
+    },
+    getScissorTest() {
+      return this.scissorTest;
+    },
+    setScissorTest(value) {
+      this.scissorTest = Boolean(value);
+    },
+  };
+}
+
+function createEmbeddedSurfaceSpy() {
+  const publishCalls = [];
+  const unpublishCalls = [];
+  return {
+    publishCalls,
+    unpublishCalls,
+    publish(sourceId, update) {
+      publishCalls.push({ sourceId, update });
+    },
+    unpublish(sourceId) {
+      unpublishCalls.push(sourceId);
+    },
+  };
+}
+
 async function flushMicrotasks(count = 10) {
   for (let index = 0; index < count; index += 1) {
     await Promise.resolve();
@@ -92,10 +141,6 @@ function assertStrategyBehavior(strategy) {
   }
 }
 
-function distance(a, b) {
-  return Math.hypot(a.x - b.x, a.y - b.y, a.z - b.z);
-}
-
 test('createSkykitViewer creates roots, mounts renderer, runs lifecycle, and disposes cleanly', async () => {
   const host = createHost();
   const renderer = createRenderer();
@@ -242,6 +287,51 @@ test('viewer exposes action registry, emits action events, and resets to initial
   await viewer.dispose();
 });
 
+test('viewer derives camera orientation from lookAt targets, sky coordinates, and stars', async () => {
+  const targetViewer = await createSkykitViewer({
+    renderer: createRenderer(),
+    view: {
+      observerPc: { x: 0, y: 0, z: 0 },
+      lookAt: { targetPc: { x: 10, y: 0, z: 0 }, positionAngleDeg: 0 },
+    },
+  });
+  let view = targetViewer.getViewState();
+  assert.deepEqual(view.targetPc, { x: 10, y: 0, z: 0 });
+  assertVectorApprox(localVectorFromView(view, { x: 0, y: 0, z: -1 }), { x: 1, y: 0, z: 0 });
+  assertVectorApprox(localVectorFromView(view, { x: 0, y: 1, z: 0 }), { x: 0, y: 0, z: 1 });
+  await targetViewer.dispose();
+
+  const skyViewer = await createSkykitViewer({
+    renderer: createRenderer(),
+    view: {
+      lookAt: { raDeg: 0, decDeg: 0, positionAngleDeg: 90 },
+    },
+  });
+  view = skyViewer.getViewState();
+  assert.equal(view.targetPc, null);
+  assertVectorApprox(localVectorFromView(view, { x: 0, y: 0, z: -1 }), { x: 1, y: 0, z: 0 });
+  assertVectorApprox(localVectorFromView(view, { x: 0, y: 1, z: 0 }), { x: 0, y: 1, z: 0 });
+  await skyViewer.dispose();
+
+  const starViewer = await createSkykitViewer({
+    renderer: createRenderer(),
+    view: { lookAt: { star: 'hyades' } },
+    resolveLookAtStar: async (star) => star === 'hyades'
+      ? { targetPc: { x: 4, y: 5, z: 6 } }
+      : null,
+  });
+  view = starViewer.getViewState();
+  assert.equal(view.lookAt?.star, 'hyades');
+  assert.deepEqual(view.targetPc, { x: 4, y: 5, z: 6 });
+  assert.ok(view.orientationIcrs);
+
+  starViewer.requestViewState({ lookAt: { star: 'orion' } }, 'test-star-look');
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  starViewer.update(0);
+  assert.deepEqual(starViewer.getViewState().targetPc, null);
+  await starViewer.dispose();
+});
+
 test('requestViewState batches patches and observer-centric root follows translation without rotation', async () => {
   const viewer = await createSkykitViewer({
     renderer: createRenderer(),
@@ -333,15 +423,15 @@ test('action registry registers contexts, invokes multiple handlers, and reports
   offLow();
   assert.equal(registry.listActions().find((entry) => entry.id === 'lesson:demo.run')?.handlerCount, 2);
 
-  const offJourney = registry.registerContext('skykit:journey', {
-    goToChapter({ payload }) {
+  const offChapters = registry.registerContext('lesson:chapters', {
+    goTo({ payload }) {
       calls.push(`chapter:${payload}`);
     },
   });
-  await registry.invoke(SKYKIT_ACTIONS.journey.goToChapter, 'intro');
+  await registry.invoke('lesson:chapters.goTo', 'intro');
   assert.equal(calls.at(-1), 'chapter:intro');
-  offJourney();
-  assert.equal(registry.listActions().some((entry) => entry.id === SKYKIT_ACTIONS.journey.goToChapter), false);
+  offChapters();
+  assert.equal(registry.listActions().some((entry) => entry.id === 'lesson:chapters.goTo'), false);
 });
 
 test('action registry tracks held action sources and control values', () => {
@@ -682,6 +772,41 @@ test('HR diagram mode changes refresh shared demand and update the renderer view
   await viewer.dispose();
 });
 
+test('HR diagram touch-os surfaces can be resolved lazily from panel runtimes', async () => {
+  const session = createFakeSession();
+  const provider = {
+    id: 'provider',
+    createSession() {
+      return session;
+    },
+  };
+  const source = createSkykitStarSourcePlugin({ provider });
+  const surfaces = createEmbeddedSurfaceSpy();
+  let activeSurfaces = null;
+  const hr = createSkykitHrDiagramPlugin({
+    id: 'hr',
+    source,
+    touchOs: {
+      sourceId: 'hr:surface',
+      surfaces: () => activeSurfaces,
+    },
+  });
+  const viewer = await createSkykitViewer({
+    renderer: createTextureRenderer(),
+    plugins: [source, hr],
+  });
+
+  activeSurfaces = surfaces;
+  viewer.frame(0.016);
+
+  assert.equal(surfaces.publishCalls.length, 1);
+  assert.equal(surfaces.publishCalls[0].sourceId, 'hr:surface');
+  assert.equal(surfaces.publishCalls[0].update.available, true);
+
+  await viewer.dispose();
+  assert.deepEqual(surfaces.unpublishCalls, ['hr:surface']);
+});
+
 test('HR diagram demand strategy override can be supplied and restored at runtime', async () => {
   const sessions = [];
   const provider = {
@@ -1417,501 +1542,6 @@ test('navigation transition action restores pose with independent lane durations
   await viewer.dispose();
 });
 
-test('journey plugin registers actions, applies scenes, timed frames, and preload hooks', async () => {
-  const preloadEvents = [];
-  const cueEvents = [];
-  const journeyPlugin = createSkykitJourneyPlugin({
-    scenes: {
-      intro: { title: 'Intro', view: { limitingMagnitude: 5 } },
-      hyades: {
-        title: 'Hyades',
-        view: { observerPc: { x: 1, y: 2, z: 3 } },
-        preloadHints: [
-          { kind: 'sphere-volume', centerPc: { x: 1, y: 2, z: 3 }, radiusPc: 4 },
-        ],
-      },
-    },
-    initialSceneId: 'intro',
-    timedJourney: {
-      durationSecs: 2,
-      locationWaypoints: [
-        { id: 'a', timeSecs: 0, positionPc: { x: 0, y: 0, z: 0 } },
-        { id: 'b', timeSecs: 2, positionPc: { x: 2, y: 0, z: 0 } },
-      ],
-      cameraLookWaypoints: [
-        { id: 'look', timeSecs: 0, kind: 'direction', forward: { x: 1, y: 0, z: 0 } },
-      ],
-      cues: [{ id: 'cue', startSecs: 0, endSecs: 2 }],
-    },
-    onPreloadHints: (hints) => preloadEvents.push(hints),
-    onCue: (cue) => cueEvents.push(cue.id),
-  });
-  const viewer = await createSkykitViewer({
-    renderer: createRenderer(),
-    plugins: [journeyPlugin],
-  });
-
-  viewer.update(0);
-  assert.equal(viewer.getViewState().limitingMagnitude, 5);
-  assert.equal(journeyPlugin.getSnapshot().initialSceneApplied, true);
-  assert.equal(journeyPlugin.getSnapshot().timedPreloadHintsEmitted, true);
-
-  assert.equal(viewer.actions.listActions().some((entry) => entry.id === SKYKIT_ACTIONS.journey.goToChapter), true);
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.goToChapter, 'hyades');
-  viewer.update(0);
-  assert.deepEqual(viewer.getViewState().observerPc, { x: 1, y: 2, z: 3 });
-  assert.equal(preloadEvents.length, 1);
-
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.seek, { timeSecs: 1 });
-  viewer.update(0);
-  assert.ok(viewer.getViewState().observerPc.x > 0);
-  assert.deepEqual(cueEvents, ['cue']);
-
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.play);
-  const beforePlayX = viewer.getViewState().observerPc.x;
-  viewer.update(0.5);
-  viewer.update(0);
-  assert.ok(viewer.getViewState().observerPc.x > beforePlayX);
-
-  await viewer.dispose();
-});
-
-test('journey plugin executes semantic orbit-transfer scenes without snapping', async () => {
-  const navigationPlugin = createSkykitNavigationPlugin({ speed: 20, acceleration: 20, deceleration: 20 });
-  const journey = createJourney({
-    initial: 'inside',
-    order: ['inside', 'outside', 'hyades', 'free'],
-    targets: {
-      sun: { positionPc: { x: 0, y: 0, z: 0 } },
-      hyades: { positionPc: { x: 18, y: 42, z: 7 } },
-      free: { positionPc: { x: -20, y: 35, z: 12 } },
-      orion: { positionPc: { x: 0, y: 0, z: -100 } },
-    },
-    scenes: {
-      inside: {
-        view: {
-          observerPc: { x: 0, y: 4, z: 0 },
-        },
-        camera: {
-          type: 'orbit',
-          center: 'sun',
-          radiusPc: 4,
-          angularSpeedRadPerSec: 0.4,
-          lookAt: 'orion',
-          normal: { x: 0, y: 0, z: 1 },
-        },
-      },
-      outside: {
-        camera: {
-          type: 'orbit',
-          center: 'sun',
-          radiusPc: 10,
-          angularSpeedRadPerSec: 0.2,
-          lookAt: 'sun',
-          normal: { x: 0, y: 0, z: 1 },
-        },
-      },
-      hyades: {
-        camera: {
-          type: 'orbit',
-          center: 'hyades',
-          radiusPc: 6,
-          angularSpeedRadPerSec: 0.3,
-          lookAt: 'hyades',
-          normal: { x: 0, y: 0, z: 1 },
-        },
-      },
-      free: {
-        camera: {
-          type: 'orbit',
-          center: 'free',
-          radiusPc: 5,
-          angularSpeedRadPerSec: 0.25,
-          lookAt: 'free',
-        },
-      },
-    },
-    travel: { type: 'orbit-transfer', durationSecs: 2, sampleStepSecs: 0.25 },
-  });
-  const viewer = await createSkykitViewer({
-    renderer: createRenderer(),
-    plugins: [
-      navigationPlugin,
-      createSkykitJourneyPlugin({ journey }),
-    ],
-  });
-
-  await flushMicrotasks();
-  viewer.update(0);
-  assert.deepEqual(viewer.getViewState().observerPc, { x: 0, y: 4, z: 0 });
-  viewer.update(0.001);
-  viewer.update(0);
-  assert.ok(Math.abs(distance(viewer.getViewState().observerPc, { x: 0, y: 0, z: 0 }) - 4) < 1e-9);
-
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.goToChapter, 'outside');
-  await flushMicrotasks();
-  viewer.update(1);
-  viewer.update(0);
-  const halfwayRadius = distance(viewer.getViewState().observerPc, { x: 0, y: 0, z: 0 });
-  assert.ok(halfwayRadius > 4);
-  assert.ok(halfwayRadius < 10);
-
-  viewer.update(1.1);
-  viewer.update(0);
-  const arrival = { ...viewer.getViewState().observerPc };
-  assert.ok(Math.abs(distance(arrival, { x: 0, y: 0, z: 0 }) - 10) < 1e-9);
-  assert.equal(navigationPlugin.getSnapshot().navigation.activeAutomation, 'orbit');
-  viewer.update(0.25);
-  viewer.update(0);
-  assert.ok(Math.abs(distance(viewer.getViewState().observerPc, { x: 0, y: 0, z: 0 }) - 10) < 1e-9);
-  assert.notDeepEqual(viewer.getViewState().observerPc, arrival);
-
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.goToChapter, 'hyades');
-  await flushMicrotasks();
-  let handoff = null;
-  let previous = { ...viewer.getViewState().observerPc };
-  for (let index = 0; index < 120; index += 1) {
-    viewer.update(1 / 30);
-    viewer.update(0);
-    const current = { ...viewer.getViewState().observerPc };
-    const step = distance(previous, current);
-    if (!handoff && navigationPlugin.getSnapshot().navigation.activeAutomation === 'orbit') {
-      handoff = { position: current, step };
-    }
-    previous = current;
-  }
-  assert.ok(handoff);
-  assert.ok(Math.abs(handoff.position.z - 7) < 1e-6);
-  assert.ok(handoff.step < 0.5);
-
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.goToChapter, 'free');
-  await flushMicrotasks();
-  for (let index = 0; index < 120; index += 1) {
-    viewer.update(1 / 30);
-    viewer.update(0);
-  }
-  const freeAutomation = navigationPlugin.getSnapshot().navigation.movementAutomation;
-  assert.equal(navigationPlugin.getSnapshot().navigation.activeAutomation, 'orbit');
-  assert.ok(freeAutomation?.normal);
-  assert.ok(Math.abs(freeAutomation.normal.z - 1) > 0.001);
-  assert.ok(Math.abs(distance(viewer.getViewState().observerPc, { x: -20, y: 35, z: 12 }) - 5) < 1e-9);
-
-  await viewer.dispose();
-});
-
-test('journey plugin uses explicit route points for authored orbit transfers', async () => {
-  const navigationPlugin = createSkykitNavigationPlugin({ speed: 80, acceleration: 80, deceleration: 80 });
-  const authoredPoints = [
-    { x: 0, y: 4, z: 0 },
-    { x: 40, y: 10, z: 80 },
-    { x: 100, y: 0, z: 10 },
-  ];
-  const journey = createJourney({
-    initial: 'inside',
-    order: ['inside', 'omega'],
-    targets: {
-      sun: { positionPc: { x: 0, y: 0, z: 0 } },
-      omega: { positionPc: { x: 100, y: 0, z: 0 } },
-    },
-    scenes: {
-      inside: {
-        view: { observerPc: { x: 0, y: 4, z: 0 } },
-        camera: {
-          type: 'orbit',
-          center: 'sun',
-          radiusPc: 4,
-          angularSpeedRadPerSec: 0.2,
-          normal: { x: 0, y: 0, z: 1 },
-        },
-      },
-      omega: {
-        camera: {
-          type: 'orbit',
-          center: 'omega',
-          radiusPc: 10,
-          angularSpeedRadPerSec: 0.12,
-          normal: { x: 0, y: 0, z: 1 },
-        },
-      },
-    },
-    transitions: [
-      {
-        fromSceneId: 'inside',
-        toSceneId: 'omega',
-        travel: {
-          type: 'orbit-transfer',
-          durationSecs: 2,
-          pointsPc: authoredPoints,
-          arrivalAction: {
-            type: 'orbit',
-            center: { x: 100, y: 0, z: 0 },
-            radius: 10,
-            angularSpeedRadPerSec: 0.12,
-            normal: { x: 0, y: 0, z: 1 },
-          },
-        },
-      },
-    ],
-  });
-  const viewer = await createSkykitViewer({
-    renderer: createRenderer(),
-    plugins: [
-      navigationPlugin,
-      createSkykitJourneyPlugin({ journey }),
-    ],
-  });
-
-  await flushMicrotasks();
-  viewer.update(0);
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.goToChapter, 'omega');
-  await flushMicrotasks();
-
-  viewer.update(1);
-  viewer.update(0);
-  assert.ok(viewer.getViewState().observerPc.z > 20);
-
-  viewer.update(1.1);
-  viewer.update(0);
-  assert.equal(navigationPlugin.getSnapshot().navigation.activeAutomation, 'orbit');
-  assert.ok(Math.abs(distance(viewer.getViewState().observerPc, { x: 100, y: 0, z: 0 }) - 10) < 1e-9);
-
-  await viewer.dispose();
-});
-
-test('journey plugin can route to non-orbit scenes before applying the arrival transition', async () => {
-  const navigationPlugin = createSkykitNavigationPlugin({ speed: 80, acceleration: 80, deceleration: 80 });
-  const journey = createJourney({
-    initial: 'omega',
-    order: ['omega', 'local'],
-    targets: {
-      omega: { positionPc: { x: 100, y: 0, z: 0 } },
-    },
-    scenes: {
-      omega: {
-        view: { observerPc: { x: 100, y: 0, z: 10 } },
-        camera: {
-          type: 'orbit',
-          center: 'omega',
-          radiusPc: 10,
-          angularSpeedRadPerSec: 0.12,
-          normal: { x: 0, y: 0, z: 1 },
-        },
-      },
-      local: {
-        view: { targetPc: { x: 1, y: 0, z: 0 } },
-        navigation: {
-          transitionTo: {
-            observerPc: { x: 0, y: 0, z: 0 },
-            orientationIcrs: { x: 0, y: 0, z: 0, w: 1 },
-            durationSecs: 1,
-            movement: { durationSecs: 1 },
-            orientationTransition: { durationSecs: 1 },
-          },
-        },
-      },
-    },
-    transitions: [
-      {
-        fromSceneId: 'omega',
-        toSceneId: 'local',
-        travel: {
-          type: 'orbit-transfer',
-          durationSecs: 2,
-          pointsPc: [
-            { x: 100, y: 0, z: 10 },
-            { x: 50, y: 0, z: 80 },
-            { x: 0, y: 0, z: 0 },
-          ],
-        },
-      },
-    ],
-  });
-  const viewer = await createSkykitViewer({
-    renderer: createRenderer(),
-    plugins: [
-      navigationPlugin,
-      createSkykitJourneyPlugin({ journey }),
-    ],
-  });
-
-  await flushMicrotasks();
-  viewer.update(0);
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.goToChapter, 'local');
-  await flushMicrotasks();
-
-  viewer.update(1);
-  viewer.update(0);
-  assert.ok(viewer.getViewState().observerPc.z > 20);
-
-  viewer.update(1.1);
-  await flushMicrotasks();
-  viewer.update(0.1);
-  viewer.update(0);
-  assert.deepEqual(viewer.getViewState().observerPc, { x: 0, y: 0, z: 0 });
-
-  await viewer.dispose();
-});
-
-test('journey plugin emits timed preload hints once and not on every frame', async () => {
-  const preloadEvents = [];
-  const viewer = await createSkykitViewer({
-    renderer: createRenderer(),
-    plugins: [
-      createSkykitJourneyPlugin({
-        autoPlay: true,
-        timedJourney: {
-          durationSecs: 4,
-          locationWaypoints: [
-            { id: 'a', timeSecs: 0, positionPc: { x: 0, y: 0, z: 0 } },
-            { id: 'b', timeSecs: 4, positionPc: { x: 4, y: 0, z: 0 } },
-          ],
-        },
-        evaluatorOptions: {
-          pathRadiusPc: 2,
-          lookaheadSecs: 1,
-          preloadStepSecs: 1,
-        },
-        onPreloadHints: (hints, source) => preloadEvents.push({ hints, source }),
-      }),
-    ],
-  });
-
-  assert.equal(preloadEvents.length, 1);
-  assert.equal(preloadEvents[0].source.type, 'journey/timed-preload');
-  viewer.update(1);
-  viewer.update(1);
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.seek, { timeSecs: 2 });
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.play);
-  assert.equal(preloadEvents.length, 1);
-
-  await viewer.dispose();
-});
-
-test('journey plugin reports scene arrival immediately for static scenes', async () => {
-  const arrivals = [];
-  const viewer = await createSkykitViewer({
-    renderer: createRenderer(),
-    plugins: [
-      createSkykitJourneyPlugin({
-        scenes: {
-          intro: { view: { limitingMagnitude: 5 } },
-        },
-        initialSceneId: 'intro',
-        onSceneArrive(scene) {
-          arrivals.push(scene.sceneId);
-        },
-      }),
-    ],
-  });
-
-  await flushMicrotasks();
-  viewer.update(0);
-  assert.deepEqual(arrivals, ['intro']);
-
-  await viewer.dispose();
-});
-
-test('journey plugin reports scene arrival after transitionTo completes', async () => {
-  const arrivals = [];
-  const viewer = await createSkykitViewer({
-    renderer: createRenderer(),
-    plugins: [
-      createSkykitNavigationPlugin(),
-      createSkykitJourneyPlugin({
-        scenes: {
-          intro: {},
-          away: {
-            navigation: {
-              transitionTo: {
-                observerPc: { x: 10, y: 0, z: 0 },
-                durationSecs: 1,
-              },
-            },
-          },
-        },
-        initialSceneId: 'intro',
-        onSceneArrive(scene) {
-          arrivals.push(scene.sceneId);
-        },
-      }),
-    ],
-  });
-
-  await flushMicrotasks();
-  arrivals.length = 0;
-
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.goToChapter, 'away');
-  await flushMicrotasks();
-  viewer.update(0.5);
-  viewer.update(0);
-  assert.deepEqual(arrivals, []);
-
-  viewer.update(0.5);
-  viewer.update(0);
-  assert.deepEqual(arrivals, ['away']);
-
-  await viewer.dispose();
-});
-
-test('journey plugin reports scene arrival after orbit-transfer travel completes', async () => {
-  const arrivals = [];
-  const journey = createJourney({
-    initial: 'sun',
-    order: ['sun', 'cluster'],
-    targets: {
-      sun: { positionPc: { x: 0, y: 0, z: 0 } },
-      cluster: { positionPc: { x: 20, y: 0, z: 0 } },
-    },
-    scenes: {
-      sun: {
-        camera: {
-          type: 'orbit',
-          center: 'sun',
-          radiusPc: 4,
-          angularSpeedRadPerSec: 0.2,
-          normal: { x: 0, y: 0, z: 1 },
-        },
-      },
-      cluster: {
-        camera: {
-          type: 'orbit',
-          center: 'cluster',
-          radiusPc: 5,
-          angularSpeedRadPerSec: 0.2,
-          normal: { x: 0, y: 0, z: 1 },
-        },
-      },
-    },
-    travel: { type: 'orbit-transfer', durationSecs: 1, sampleStepSecs: 0.25 },
-  });
-  const viewer = await createSkykitViewer({
-    renderer: createRenderer(),
-    plugins: [
-      createSkykitNavigationPlugin(),
-      createSkykitJourneyPlugin({
-        journey,
-        onSceneArrive(scene) {
-          arrivals.push(scene.sceneId);
-        },
-      }),
-    ],
-  });
-
-  await flushMicrotasks();
-  arrivals.length = 0;
-
-  await viewer.actions.invoke(SKYKIT_ACTIONS.journey.goToChapter, 'cluster');
-  await flushMicrotasks();
-  viewer.update(0.5);
-  viewer.update(0);
-  assert.deepEqual(arrivals, []);
-
-  viewer.update(0.6);
-  viewer.update(0);
-  assert.deepEqual(arrivals, ['cluster']);
-
-  await viewer.dispose();
-});
 
 test('spatial preload hints map to star-octree requests without exposing provider internals', () => {
   const hints = [
@@ -2323,6 +1953,12 @@ function localVectorFromView(view, vector) {
   return { x: result.x, y: result.y, z: result.z };
 }
 
+function assertVectorApprox(actual, expected, epsilon = 1e-9) {
+  assert.ok(Math.abs(actual.x - expected.x) < epsilon, `x ${actual.x} !== ${expected.x}`);
+  assert.ok(Math.abs(actual.y - expected.y) < epsilon, `y ${actual.y} !== ${expected.y}`);
+  assert.ok(Math.abs(actual.z - expected.z) < epsilon, `z ${actual.z} !== ${expected.z}`);
+}
+
 function createPointerTarget() {
   const target = createEventTarget();
   target.clientWidth = 800;