@found-in-space/skykit 0.2.0-dev.20260527.0 → 0.2.0

package/src/__tests__/skykit.test.js

@@ -1,13 +1,15 @@
 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,
   encodeMorton3D,
 } from '@found-in-space/star-trees';
 
+import {
+  resolveSpatialTarget,
+} from '@found-in-space/spatial';
 import {
   SKYKIT_ACTION_NAMESPACE,
   SKYKIT_ACTIONS,
@@ -18,12 +20,12 @@ import {
   createDesktopSkykitObserverRig,
   createObject3dLayer,
   createObject3dPlugin,
+  createRaDecLookAt,
   createMouseLookPlugin,
   createSkyGrabPlugin,
   createSkykitDefaultKeyboardNavigationBindings,
   createSkykitAnimationLoop,
   createSkykitDebugBridge,
-  createSkykitJourneyPlugin,
   createSkykitNavigationPlugin,
   createSkykitStarPreloadRequestsFromSpatialHints,
   createSkykitStarStrategiesFromSpatialHints,
@@ -36,6 +38,7 @@ import {
   createStreamingStarLayer,
   createStreamingStarsPlugin,
   installSkykitDebugGlobal,
+  parseSpatialLookAtText,
 } from '../index.js';
 
 function createHost() {
@@ -143,10 +146,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();
@@ -319,6 +318,50 @@ test('viewer derives camera orientation from lookAt targets, sky coordinates, an
   assertVectorApprox(localVectorFromView(view, { x: 0, y: 1, z: 0 }), { x: 0, y: 1, z: 0 });
   await skyViewer.dispose();
 
+  const alnilamViewer = await createSkykitViewer({
+    renderer: createRenderer(),
+    view: {
+      lookAt: createRaDecLookAt('05h 36m 12.81s', '−01° 12′ 06.9″'),
+    },
+  });
+  view = alnilamViewer.getViewState();
+  assertVectorApprox(
+    localVectorFromView(view, { x: 0, y: 0, z: -1 }),
+    directionFromRaDec(84.053375, -1.2019166666666667),
+  );
+  await alnilamViewer.dispose();
+
+  const siriusSpec = parseSpatialLookAtText('06h 45m 08.9s, -16d 42m 58s, 2.64pc');
+  const orionSpec = parseSpatialLookAtText('05h 35m 17.3s, -05d 23m 28s, 414pc');
+  const siriusPc = resolveSpatialTarget(siriusSpec);
+  const orionPc = resolveSpatialTarget(orionSpec);
+  assert.ok(siriusPc && orionPc && orionSpec);
+  const solarTargetViewer = await createSkykitViewer({
+    renderer: createRenderer(),
+    view: {
+      observerPc: siriusPc,
+      lookAt: orionSpec,
+    },
+  });
+  view = solarTargetViewer.getViewState();
+  assertVectorApprox(view.observerPc, siriusPc);
+  assertVectorApprox(view.targetPc, orionPc);
+  assertVectorApprox(
+    localVectorFromView(view, { x: 0, y: 0, z: -1 }),
+    normalizeVector(subtractVectors(orionPc, siriusPc)),
+  );
+
+  const movedObserver = { x: -8, y: 3, z: 11 };
+  solarTargetViewer.requestViewState({ observerPc: movedObserver, lookAt: orionSpec }, 'test-solar-radec');
+  solarTargetViewer.update(0);
+  view = solarTargetViewer.getViewState();
+  assertVectorApprox(view.targetPc, orionPc);
+  assertVectorApprox(
+    localVectorFromView(view, { x: 0, y: 0, z: -1 }),
+    normalizeVector(subtractVectors(orionPc, movedObserver)),
+  );
+  await solarTargetViewer.dispose();
+
   const starViewer = await createSkykitViewer({
     renderer: createRenderer(),
     view: { lookAt: { star: 'hyades' } },
@@ -429,15 +472,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', () => {
@@ -1533,7 +1576,7 @@ test('navigation transition action restores pose with independent lane durations
   });
   viewer.update(1);
   viewer.update(0);
-  assert.deepEqual(viewer.getViewState().observerPc, { x: 20, y: 0, z: 0 });
+  assert.deepEqual(viewer.getViewState().observerPc, { x: 10, y: 0, z: 0 });
   assert.deepEqual(viewer.getViewState().orientationIcrs, orientationAfterExplicitTransition);
 
   await viewer.actions.invoke(SKYKIT_ACTIONS.navigation.transitionTo, {
@@ -1545,504 +1588,20 @@ test('navigation transition action restores pose with independent lane durations
   assert.deepEqual(viewer.getViewState().observerPc, { x: 0, y: 0, z: 0 });
   assert.deepEqual(viewer.getViewState().orientationIcrs, orientationAfterExplicitTransition);
 
-  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: { lookAt: { 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 }),
-      }),
-    ],
+  await viewer.actions.invoke(SKYKIT_ACTIONS.navigation.transitionTo, {
+    lookAt: '05:36:12.81, −01:12:06.9',
+    orientation: { durationSecs: 1 },
   });
-
-  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']);
+  assertVectorApprox(
+    localVectorFromView(viewer.getViewState(), { x: 0, y: 0, z: -1 }),
+    directionFromRaDec(84.053375, -1.2019166666666667),
+  );
 
   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 = [
@@ -2460,6 +2019,34 @@ function assertVectorApprox(actual, expected, epsilon = 1e-9) {
   assert.ok(Math.abs(actual.z - expected.z) < epsilon, `z ${actual.z} !== ${expected.z}`);
 }
 
+function subtractVectors(a, b) {
+  return {
+    x: a.x - b.x,
+    y: a.y - b.y,
+    z: a.z - b.z,
+  };
+}
+
+function normalizeVector(vector) {
+  const length = Math.hypot(vector.x, vector.y, vector.z);
+  return {
+    x: vector.x / length,
+    y: vector.y / length,
+    z: vector.z / length,
+  };
+}
+
+function directionFromRaDec(raDeg, decDeg) {
+  const ra = raDeg * Math.PI / 180;
+  const dec = decDeg * Math.PI / 180;
+  const cosDec = Math.cos(dec);
+  return {
+    x: Math.cos(ra) * cosDec,
+    y: Math.sin(ra) * cosDec,
+    z: Math.sin(dec),
+  };
+}
+
 function createPointerTarget() {
   const target = createEventTarget();
   target.clientWidth = 800;

package/src/actions.js

@@ -51,14 +51,6 @@ export const SKYKIT_ACTIONS = Object.freeze({
     exit: 'skykit:xr.exit',
     toggle: 'skykit:xr.toggle',
   }),
-  journey: Object.freeze({
-    goToChapter: 'skykit:journey.goToChapter',
-    next: 'skykit:journey.next',
-    previous: 'skykit:journey.previous',
-    seek: 'skykit:journey.seek',
-    play: 'skykit:journey.play',
-    pause: 'skykit:journey.pause',
-  }),
 });
 
 export const SKYKIT_CONTROLS = Object.freeze({