feat(galaxy): larger UMAP world and slower Galaxy flight profile

Scale 96 + spacing×240 and Galaxy-only move/look profile (32 / 0.0014);
leaving Galaxy restores ANALYSIS/NAV defaults.

Co-authored-by: Cursor <cursoragent@cursor.com>

src/engine/Navigation.js

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import { resolveCameraPose, VIEW_CAMERA_FALLBACKS } from './cameraViewDefaults.js';
+import { DEFAULT_FLIGHT_PROFILE } from './galaxyFlightProfile.js';
 
 /**
  * Inertial Flight & Camera Navigation Controller (WASDQE + Mouse Drag Look + Shift Turbo).
@@ -21,8 +22,9 @@ export class Navigation {
     };
 
     this.velocity = new THREE.Vector3();
-    this.moveSpeed = 75.0; // Bounded speed units/sec for responsive control
-    this.turboMultiplier = 2.0;
+    this.moveSpeed = DEFAULT_FLIGHT_PROFILE.moveSpeed;
+    this.turboMultiplier = DEFAULT_FLIGHT_PROFILE.turboMultiplier;
+    this.lookSensitivity = DEFAULT_FLIGHT_PROFILE.lookSensitivity;
     this.damping = 0.85;
     this._cameraTweenRaf = null;
 
@@ -63,9 +65,12 @@ export class Navigation {
    * @param {number} deltaY
    */
   applyLookDelta(deltaX, deltaY) {
+    const sens = Number.isFinite(this.lookSensitivity)
+      ? this.lookSensitivity
+      : DEFAULT_FLIGHT_PROFILE.lookSensitivity;
     this.euler.setFromQuaternion(this.camera.quaternion);
-    this.euler.y -= deltaX * 0.003;
-    this.euler.x -= deltaY * 0.003;
+    this.euler.y -= deltaX * sens;
+    this.euler.x -= deltaY * sens;
     this.euler.x = Math.max(-Math.PI / 2 + 0.05, Math.min(Math.PI / 2 - 0.05, this.euler.x));
     this.camera.quaternion.setFromEuler(this.euler);
   }

src/engine/galaxyFlightProfile.js

@@ -0,0 +1,46 @@
+/**
+ * Flight feel profiles for Navigation (WASD/QE + mouse look).
+ * Galaxy VIEW uses a slower profile; ANALYSIS/NAVIGATION keep defaults.
+ */
+
+/** @typedef {{ moveSpeed: number, turboMultiplier: number, lookSensitivity: number }} FlightProfile */
+
+/** Current ANALYSIS / NAVIGATION feel (pre–Galaxy-feel baseline). */
+export const DEFAULT_FLIGHT_PROFILE = Object.freeze({
+  moveSpeed: 75.0,
+  turboMultiplier: 2.0,
+  lookSensitivity: 0.003,
+});
+
+/**
+ * Galaxy-only: slower cruise + softer look so a larger UMAP world feels elegant.
+ * Calibrated with GALAXY_DEFAULT_SCALE ≈ 96 (RMS≈1 → ~several seconds across IT-core).
+ */
+export const GALAXY_FLIGHT_PROFILE = Object.freeze({
+  moveSpeed: 32.0,
+  turboMultiplier: 1.75,
+  lookSensitivity: 0.0014,
+});
+
+/**
+ * @param {{ moveSpeed?: number, turboMultiplier?: number, lookSensitivity?: number }|null|undefined} nav
+ * @param {FlightProfile|null|undefined} profile
+ * @returns {typeof nav}
+ */
+export function applyFlightProfile(nav, profile) {
+  if (!nav || !profile) return nav;
+  nav.moveSpeed = profile.moveSpeed;
+  nav.turboMultiplier = profile.turboMultiplier;
+  nav.lookSensitivity = profile.lookSensitivity;
+  return nav;
+}
+
+/** @param {object|null|undefined} nav */
+export function applyGalaxyFlightProfile(nav) {
+  return applyFlightProfile(nav, GALAXY_FLIGHT_PROFILE);
+}
+
+/** @param {object|null|undefined} nav */
+export function restoreDefaultFlightProfile(nav) {
+  return applyFlightProfile(nav, DEFAULT_FLIGHT_PROFILE);
+}

src/main.js

@@ -65,6 +65,10 @@ import {
 } from './ui/galaxyChrome.js';
 import { runGalaxyPipeline, compareTextsFingerprint } from './ui/galaxyPipeline.js';
 import { galaxyCameraTarget } from './visualizer/galaxyLayout.js';
+import {
+  applyGalaxyFlightProfile,
+  restoreDefaultFlightProfile,
+} from './engine/galaxyFlightProfile.js';
 import {
   loadArithmeticSettings,
   saveArithmeticSettings,
@@ -390,6 +394,7 @@ class VHectorLabApp {
       this._preGalaxyTriad = entered.restore;
       this.viewMode = entered.viewMode;
       this.galaxyMethod = entered.method;
+      applyGalaxyFlightProfile(this.navigation);
       this.navbar.setModeRenderLocked(true);
       this.navbar.setGalaxyMethod(entered.method);
       this.navbar.setViewMode(entered.viewMode);
@@ -417,6 +422,7 @@ class VHectorLabApp {
       this._galaxyFramePending = false;
       this.comparePanel?.clearGalaxyProgress?.();
       this.viewMode = left.viewMode;
+      restoreDefaultFlightProfile(this.navigation);
       this.navbar.setModeRenderLocked(false);
       this.navbar.setViewMode(left.viewMode);
 
@@ -636,7 +642,8 @@ class VHectorLabApp {
     // Prefer fit-box so sparse cores stay readable; look-at is IT centroid when present.
     const box = target.box.clone();
     // Inflate slightly so focus isn't clipped
-    box.expandByScalar(8);
+    // Inflate padding scales with cloud size so fit framing stays comfortable
+    box.expandByScalar(24);
     void this.navigation.animateToFitBox(box, {
       viewMode: 'NAVIGATION',
       durationMs: 550,

src/visualizer/Instancer.js

@@ -13,7 +13,7 @@ import {
   computeDimRelationMetrics,
   hasGroupsForDimContrast,
 } from './groupDimContrast.js';
-import { GALAXY_DEFAULT_SCALE, layoutGalaxyPoints } from './galaxyLayout.js';
+import { layoutGalaxyPoints, resolveGalaxyWorldScale } from './galaxyLayout.js';
 
 /**
  * Instancer Manager for rendering vector points, ribbons, and highlights in the Three.js scene.
@@ -431,10 +431,7 @@ export class Instancer {
     const thicknessFactor = (spatialConfig && spatialConfig.threadThickness !== undefined)
       ? spatialConfig.threadThickness
       : 0.3;
-    // Prefer threadSpacing as global galaxy spread when present.
-    const scale = (spatialConfig && spatialConfig.threadSpacing !== undefined)
-      ? Math.max(8, Number(spatialConfig.threadSpacing) * 40)
-      : GALAXY_DEFAULT_SCALE;
+    const scale = resolveGalaxyWorldScale(spatialConfig);
 
     const { pointsData, labels } = layoutGalaxyPoints(
       compareResponse.items,

src/visualizer/galaxyLayout.js

@@ -6,8 +6,34 @@
 import * as THREE from 'three';
 import { IT_CORE_GROUP_ID } from '../ui/itCoreCorpus.js';
 
-/** Default world scale for server-normalized (RMS≈1) UMAP coords. */
-export const GALAXY_DEFAULT_SCALE = 48;
+/**
+ * Default world scale for server-normalized (RMS≈1) UMAP coords.
+ * Raised (was 48) so Galaxy feels spacious with the slower flight profile.
+ */
+export const GALAXY_DEFAULT_SCALE = 96;
+
+/**
+ * Maps Spatial `threadSpacing` → galaxy world scale.
+ * At global default spacing 0.4 → 96 (matches GALAXY_DEFAULT_SCALE).
+ * Was 40 (→ scale 16 at spacing 0.4 — cramped).
+ */
+export const GALAXY_SPACING_TO_SCALE = 240;
+
+/** Floor so tiny spacing sliders never collapse the cloud. */
+export const GALAXY_MIN_SCALE = 32;
+
+/**
+ * Resolve Galaxy world scale from Spatial sliders (or default).
+ * @param {{ threadSpacing?: number }|null|undefined} spatialConfig
+ * @returns {number}
+ */
+export function resolveGalaxyWorldScale(spatialConfig) {
+  if (spatialConfig && spatialConfig.threadSpacing !== undefined) {
+    const raw = Number(spatialConfig.threadSpacing) * GALAXY_SPACING_TO_SCALE;
+    return Math.max(GALAXY_MIN_SCALE, Number.isFinite(raw) ? raw : GALAXY_DEFAULT_SCALE);
+  }
+  return GALAXY_DEFAULT_SCALE;
+}
 
 /**
  * @param {Array<{ id?: string, text?: string, groupId?: string, groupLabel?: string, cosine_vs_first?: number }>} items

tests/Navigation.test.js

@@ -1,6 +1,12 @@
 import { describe, it, expect } from 'vitest';
 import * as THREE from 'three';
 import { Navigation } from '../src/engine/Navigation.js';
+import {
+  DEFAULT_FLIGHT_PROFILE,
+  GALAXY_FLIGHT_PROFILE,
+  applyGalaxyFlightProfile,
+  restoreDefaultFlightProfile,
+} from '../src/engine/galaxyFlightProfile.js';
 
 function stubCamera() {
   return {
@@ -66,3 +72,23 @@ describe('Navigation default poses', () => {
     expect(nav.camera.position.z).toBeCloseTo(52.2, 5);
   });
 });
+
+describe('Navigation flight profile', () => {
+  it('starts on default profile and applyLookDelta uses lookSensitivity', () => {
+    const camera = stubCamera();
+    const nav = new Navigation(camera, { addEventListener() {} });
+    expect(nav.moveSpeed).toBe(DEFAULT_FLIGHT_PROFILE.moveSpeed);
+    expect(nav.lookSensitivity).toBe(DEFAULT_FLIGHT_PROFILE.lookSensitivity);
+
+    applyGalaxyFlightProfile(nav);
+    expect(nav.moveSpeed).toBe(GALAXY_FLIGHT_PROFILE.moveSpeed);
+
+    nav.euler.set(0, 0, 0, 'YXZ');
+    nav.camera.quaternion.setFromEuler(nav.euler);
+    nav.applyLookDelta(100, 0);
+    expect(nav.euler.y).toBeCloseTo(-100 * GALAXY_FLIGHT_PROFILE.lookSensitivity, 6);
+
+    restoreDefaultFlightProfile(nav);
+    expect(nav.moveSpeed).toBe(DEFAULT_FLIGHT_PROFILE.moveSpeed);
+  });
+});

tests/galaxyFlightProfile.test.js

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_FLIGHT_PROFILE,
+  GALAXY_FLIGHT_PROFILE,
+  applyFlightProfile,
+  applyGalaxyFlightProfile,
+  restoreDefaultFlightProfile,
+} from '../src/engine/galaxyFlightProfile.js';
+
+function stubNav(overrides = {}) {
+  return {
+    moveSpeed: DEFAULT_FLIGHT_PROFILE.moveSpeed,
+    turboMultiplier: DEFAULT_FLIGHT_PROFILE.turboMultiplier,
+    lookSensitivity: DEFAULT_FLIGHT_PROFILE.lookSensitivity,
+    ...overrides,
+  };
+}
+
+describe('galaxyFlightProfile', () => {
+  it('Galaxy profile is slower translation and look than default', () => {
+    expect(GALAXY_FLIGHT_PROFILE.moveSpeed).toBeLessThan(DEFAULT_FLIGHT_PROFILE.moveSpeed);
+    expect(GALAXY_FLIGHT_PROFILE.lookSensitivity).toBeLessThan(
+      DEFAULT_FLIGHT_PROFILE.lookSensitivity,
+    );
+    expect(GALAXY_FLIGHT_PROFILE.turboMultiplier).toBeGreaterThan(1);
+  });
+
+  it('applyGalaxyFlightProfile sets slower speeds on nav', () => {
+    const nav = stubNav();
+    applyGalaxyFlightProfile(nav);
+    expect(nav.moveSpeed).toBe(GALAXY_FLIGHT_PROFILE.moveSpeed);
+    expect(nav.turboMultiplier).toBe(GALAXY_FLIGHT_PROFILE.turboMultiplier);
+    expect(nav.lookSensitivity).toBe(GALAXY_FLIGHT_PROFILE.lookSensitivity);
+  });
+
+  it('restoreDefaultFlightProfile restores ANALYSIS/NAV feel', () => {
+    const nav = stubNav();
+    applyGalaxyFlightProfile(nav);
+    restoreDefaultFlightProfile(nav);
+    expect(nav.moveSpeed).toBe(DEFAULT_FLIGHT_PROFILE.moveSpeed);
+    expect(nav.turboMultiplier).toBe(DEFAULT_FLIGHT_PROFILE.turboMultiplier);
+    expect(nav.lookSensitivity).toBe(DEFAULT_FLIGHT_PROFILE.lookSensitivity);
+  });
+
+  it('applyFlightProfile is a no-op for missing nav/profile', () => {
+    expect(applyFlightProfile(null, GALAXY_FLIGHT_PROFILE)).toBeNull();
+    const nav = stubNav({ moveSpeed: 99 });
+    expect(applyFlightProfile(nav, null)).toBe(nav);
+    expect(nav.moveSpeed).toBe(99);
+  });
+});

tests/galaxyInstancer.test.js

@@ -2,6 +2,10 @@ import { describe, expect, it } from 'vitest';
 import * as THREE from 'three';
 import { Instancer } from '../src/visualizer/Instancer.js';
 import { IT_CORE_GROUP_ID } from '../src/ui/itCoreCorpus.js';
+import {
+  GALAXY_DEFAULT_SCALE,
+  GALAXY_SPACING_TO_SCALE,
+} from '../src/visualizer/galaxyLayout.js';
 
 describe('Instancer.renderGalaxyData', () => {
   it('mounts a single POINTS mesh and no ribbons', () => {
@@ -44,6 +48,7 @@ describe('Instancer.renderGalaxyData', () => {
     expect(labels).toHaveLength(3);
     expect(labels[0].text).toBe('server');
     expect(labels[0].groupId).toBe(IT_CORE_GROUP_ID);
+    expect(labels[0].origin3D.x).toBeCloseTo(0.1 * GALAXY_DEFAULT_SCALE);
 
     expect(instancer.activeGroup.children).toHaveLength(1);
     expect(instancer.activeGroup.children[0].type).toBe('Points');
@@ -51,6 +56,23 @@ describe('Instancer.renderGalaxyData', () => {
     expect(instancer.compareRuntime).toBeNull();
   });
 
+  it('scales from threadSpacing via resolveGalaxyWorldScale', () => {
+    const scene = new THREE.Scene();
+    const instancer = new Instancer(scene);
+    const compareResponse = {
+      items: [
+        { id: 'a', text: 'a', embedding: [0], cosine_vs_first: 1 },
+      ],
+    };
+    const positions = [[1, 0, 0]];
+    const spacing = 0.5;
+    const labels = instancer.renderGalaxyData(compareResponse, positions, {
+      threadSpacing: spacing,
+      threadThickness: 0.05,
+    });
+    expect(labels[0].origin3D.x).toBeCloseTo(spacing * GALAXY_SPACING_TO_SCALE);
+  });
+
   it('returns empty when positions missing', () => {
     const scene = new THREE.Scene();
     const instancer = new Instancer(scene);

tests/galaxyLayout.test.js

@@ -5,7 +5,11 @@ import {
   boundingBoxFromLabels,
   centroidForGroup,
   galaxyCameraTarget,
+  GALAXY_DEFAULT_SCALE,
+  GALAXY_MIN_SCALE,
+  GALAXY_SPACING_TO_SCALE,
   layoutGalaxyPoints,
+  resolveGalaxyWorldScale,
 } from '../src/visualizer/galaxyLayout.js';
 
 describe('galaxyLayout', () => {
@@ -27,6 +31,23 @@ describe('galaxyLayout', () => {
     expect(pointsData[0].meta.token).toBe('server');
   });
 
+  it('default layout scale matches GALAXY_DEFAULT_SCALE', () => {
+    const { scale } = layoutGalaxyPoints(
+      [{ id: 'a', text: 'x', cosine_vs_first: 0 }],
+      [[1, 0, 0]],
+    );
+    expect(scale).toBe(GALAXY_DEFAULT_SCALE);
+    expect(GALAXY_DEFAULT_SCALE).toBeGreaterThan(48);
+  });
+
+  it('resolveGalaxyWorldScale maps spacing and floors tiny values', () => {
+    expect(resolveGalaxyWorldScale(null)).toBe(GALAXY_DEFAULT_SCALE);
+    expect(resolveGalaxyWorldScale({ threadSpacing: 0.4 })).toBeCloseTo(
+      0.4 * GALAXY_SPACING_TO_SCALE,
+    );
+    expect(resolveGalaxyWorldScale({ threadSpacing: 0.01 })).toBe(GALAXY_MIN_SCALE);
+  });
+
   it('centroidForGroup averages member origins', () => {
     const labels = [
       { groupId: IT_CORE_GROUP_ID, origin3D: new THREE.Vector3(0, 0, 0) },