@project-skymap/library 0.8.0 → 0.8.1

package/dist/index.cjs

@@ -1433,16 +1433,111 @@ function createEngine({
   function getSceneDebug() {
     return currentConfig?.debug?.sceneMechanics;
   }
+  function getFreezeBand() {
+    const dbg = getSceneDebug();
+    const startRaw = dbg?.freezeBandStartFov ?? ENGINE_CONFIG.freezeBandStartFov;
+    const endRaw = dbg?.freezeBandEndFov ?? ENGINE_CONFIG.freezeBandEndFov;
+    const start2 = Math.min(startRaw, endRaw);
+    const end = Math.max(startRaw, endRaw);
+    return { start: start2, end };
+  }
+  function isInTransitionFreezeBand(fov) {
+    const band = getFreezeBand();
+    return fov >= band.start && fov <= band.end;
+  }
+  function getZenithBiasStartFov() {
+    return getSceneDebug()?.zenithBiasStartFov ?? ENGINE_CONFIG.zenithBiasStartFov;
+  }
+  function getVerticalPanDampConfig() {
+    const dbg = getSceneDebug();
+    const fovStartRaw = dbg?.verticalPanDampStartFov ?? ENGINE_CONFIG.verticalPanDampStartFov;
+    const fovEndRaw = dbg?.verticalPanDampEndFov ?? ENGINE_CONFIG.verticalPanDampEndFov;
+    const latStartRaw = dbg?.verticalPanDampLatStartDeg ?? ENGINE_CONFIG.verticalPanDampLatStartDeg;
+    const latEndRaw = dbg?.verticalPanDampLatEndDeg ?? ENGINE_CONFIG.verticalPanDampLatEndDeg;
+    return {
+      fovStart: Math.min(fovStartRaw, fovEndRaw),
+      fovEnd: Math.max(fovStartRaw, fovEndRaw),
+      latStartDeg: Math.min(latStartRaw, latEndRaw),
+      latEndDeg: Math.max(latStartRaw, latEndRaw)
+    };
+  }
+  function getVerticalPanFactor(fov, lat) {
+    if (zenithProjectionLockActive) return 0;
+    const cfg = getVerticalPanDampConfig();
+    const fovT = THREE6__namespace.MathUtils.smoothstep(fov, cfg.fovStart, cfg.fovEnd);
+    const zenithT = THREE6__namespace.MathUtils.smoothstep(
+      Math.max(lat, 0),
+      THREE6__namespace.MathUtils.degToRad(cfg.latStartDeg),
+      THREE6__namespace.MathUtils.degToRad(cfg.latEndDeg)
+    );
+    const lock = Math.max(fovT * 0.65, fovT * zenithT);
+    return THREE6__namespace.MathUtils.clamp(1 - lock, 0, 1);
+  }
+  function getMovementMassFactor(fov, wideFovFactor = ENGINE_CONFIG.movementMassWideFov) {
+    const t = THREE6__namespace.MathUtils.smoothstep(fov, 24, 96);
+    return THREE6__namespace.MathUtils.lerp(1, wideFovFactor, t);
+  }
+  function compressInputDelta(delta) {
+    const absDelta = Math.abs(delta);
+    if (absDelta < 1e-4) return 0;
+    return Math.sign(delta) * (absDelta / (1 + absDelta * ENGINE_CONFIG.inputCompression));
+  }
   const constellationLayer = new ConstellationArtworkLayer(scene);
   function mix(a, b, t) {
     return a * (1 - t) + b * t;
   }
   let currentProjection = new BlendedProjection(ENGINE_CONFIG.blendStart, ENGINE_CONFIG.blendEnd);
+  let zenithProjectionLockActive = false;
+  function getZenithLockBlendThresholds() {
+    const enterRaw = ENGINE_CONFIG.zenithLockBlendEnter;
+    const exitRaw = ENGINE_CONFIG.zenithLockBlendExit;
+    return {
+      enter: Math.max(0, Math.min(1, enterRaw)),
+      exit: Math.max(0, Math.min(1, Math.min(exitRaw, enterRaw)))
+    };
+  }
+  function getZenithLockLat() {
+    return Math.PI / 2 - 1e-3;
+  }
+  function getBlendForZenithControl() {
+    if (currentProjection instanceof BlendedProjection) return currentProjection.getBlend();
+    return 0;
+  }
+  function applyZenithAutoCenter() {
+    const zenithLat = getZenithLockLat();
+    const blend = getBlendForZenithControl();
+    let pullT = THREE6__namespace.MathUtils.smoothstep(
+      blend,
+      ENGINE_CONFIG.zenithAutoCenterBlendStart,
+      ENGINE_CONFIG.zenithAutoCenterBlendEnd
+    );
+    if (zenithProjectionLockActive) pullT = 1;
+    if (pullT <= 1e-4) return;
+    const pullLerp = THREE6__namespace.MathUtils.lerp(
+      ENGINE_CONFIG.zenithAutoCenterMinLerp,
+      ENGINE_CONFIG.zenithAutoCenterMaxLerp,
+      pullT
+    );
+    state.lat = THREE6__namespace.MathUtils.lerp(state.lat, zenithLat, pullLerp);
+    state.targetLat = THREE6__namespace.MathUtils.lerp(state.targetLat, zenithLat, Math.min(1, pullLerp * 1.15));
+    state.velocityY *= 1 - 0.85 * pullT;
+    if (zenithProjectionLockActive && Math.abs(state.lat - zenithLat) < 25e-5) {
+      state.lat = zenithLat;
+      state.targetLat = zenithLat;
+      state.velocityY = 0;
+    }
+  }
   function syncProjectionState() {
     if (currentProjection instanceof BlendedProjection) {
       currentProjection.setFov(state.fov);
       currentProjection.setBlendOverride(getSceneDebug()?.projectionBlendOverride ?? null);
       globalUniforms.uBlend.value = currentProjection.getBlend();
+      const blend = currentProjection.getBlend();
+      const th = getZenithLockBlendThresholds();
+      if (!zenithProjectionLockActive && blend >= th.enter) zenithProjectionLockActive = true;
+      else if (zenithProjectionLockActive && blend <= th.exit) zenithProjectionLockActive = false;
+    } else {
+      zenithProjectionLockActive = false;
     }
     globalUniforms.uProjectionType.value = currentProjection.glslProjectionType;
   }
@@ -1699,8 +1794,13 @@ function createEngine({
     }
     const flatten = groundMaterial?.uniforms?.uZenithFlatten?.value;
     const blend = currentProjection instanceof BlendedProjection ? currentProjection.getBlend() : -1;
+    const freeze = isInTransitionFreezeBand(state.fov) ? 1 : 0;
+    const zenithBiasStart = getZenithBiasStartFov();
+    const vPanCfg = getVerticalPanDampConfig();
+    const vPan = getVerticalPanFactor(state.fov, state.lat);
+    const moveMass = getMovementMassFactor(state.fov);
     console.debug(
-      `[HorizonDiag] fov=${state.fov.toFixed(1)} latDeg=${THREE6__namespace.MathUtils.radToDeg(state.lat).toFixed(1)} mode=${activeHorizonProfile.mode} blend=${blend.toFixed(3)} flatten=${Number(flatten ?? 0).toFixed(3)} drops=${dropCount} bins=${JSON.stringify(compact)}`
+      `[HorizonDiag] fov=${state.fov.toFixed(1)} latDeg=${THREE6__namespace.MathUtils.radToDeg(state.lat).toFixed(1)} mode=${activeHorizonProfile.mode} blend=${blend.toFixed(3)} freeze=${freeze} zLock=${zenithProjectionLockActive ? 1 : 0} biasStart=${zenithBiasStart.toFixed(1)} vPan=${vPan.toFixed(3)} moveMass=${moveMass.toFixed(3)} vPanFov=${vPanCfg.fovStart.toFixed(1)}-${vPanCfg.fovEnd.toFixed(1)} vPanLat=${vPanCfg.latStartDeg.toFixed(1)}-${vPanCfg.latEndDeg.toFixed(1)} flatten=${Number(flatten ?? 0).toFixed(3)} drops=${dropCount} bins=${JSON.stringify(compact)}`
     );
   }
   function createGround() {
@@ -1849,9 +1949,6 @@ function createEngine({
   let sunDiscMesh = null;
   let sunHaloMesh = null;
   let milkyWayMesh = null;
-  let editHoverMesh = null;
-  let editHoverTargetPos = null;
-  let editDropFlash = 0;
   function createSkyBackground() {
     const geo = new THREE6__namespace.SphereGeometry(2400, 32, 32);
     const mat = createSmartMaterial({
@@ -2403,7 +2500,8 @@ function createEngine({
         uTime: globalUniforms.uTime,
         uBackdropGain: { value: 1 },
         uBackdropEnergy: { value: 2.2 },
-        uBackdropSizeExp: { value: 0.9 }
+        uBackdropSizeExp: { value: 0.9 },
+        uRevealZoom: { value: 0 }
       },
       vertexShaderBody: `
                 attribute float size;
@@ -2417,6 +2515,7 @@ function createEngine({
                 uniform float uBackdropGain;
                 uniform float uBackdropEnergy;
                 uniform float uBackdropSizeExp;
+                uniform float uRevealZoom;
 
                 void main() {
                     vec3 nPos = normalize(position);
@@ -2432,7 +2531,12 @@ function createEngine({
                     float twinkle = sin(uTime * 3.0 + position.x * 0.05 + position.z * 0.03) * 0.5 + 0.5;
                     float scintillation = mix(1.0, twinkle * 2.0, uAtmTwinkle * 0.4 * turbulence);
 
-                    vColor = color * uBackdropEnergy * extinction * horizonFade * scintillation * uBackdropGain;
+                    // Backdrop appears latest \u2014 fully hidden at wide FOV, emerges when zoomed in.
+                    // Thresholds come from ZOOM_REVEAL_CONFIG (baked at startup).
+                    float mappedZoom = pow(uRevealZoom, ${ZOOM_REVEAL_CONFIG.zoomCurveExp});
+                    float backdropReveal = smoothstep(${ZOOM_REVEAL_CONFIG.backdropRevealStart}, ${ZOOM_REVEAL_CONFIG.backdropRevealEnd}, mappedZoom);
+
+                    vColor = color * uBackdropEnergy * extinction * horizonFade * scintillation * uBackdropGain * backdropReveal;
 
                     vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
                     gl_Position = smartProject(mvPosition);
@@ -2472,55 +2576,6 @@ function createEngine({
     points.frustumCulled = false;
     backdropGroup.add(points);
   }
-  function createEditHoverRing() {
-    const geo = new THREE6__namespace.PlaneGeometry(1, 1);
-    const mat = createSmartMaterial({
-      uniforms: {
-        uRingSize: { value: 0.06 },
-        uRingAlpha: { value: 0 },
-        uRingColor: { value: new THREE6__namespace.Color(0.55, 0.88, 1) }
-      },
-      vertexShaderBody: `
-                uniform float uRingSize;
-                varying vec2 vUv;
-                void main() {
-                    vUv = uv;
-                    vec4 mvPos = modelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0);
-                    vec4 proj = smartProject(mvPos);
-                    if (proj.z > 4.0) { gl_Position = vec4(10.0, 10.0, 10.0, 1.0); return; }
-                    vec2 offset = position.xy * uRingSize * uScale;
-                    proj.xy += offset / vec2(uAspect, 1.0);
-                    vScreenPos = proj.xy / proj.w;
-                    gl_Position = proj;
-                }
-            `,
-      fragmentShader: `
-                varying vec2 vUv;
-                uniform float uRingAlpha;
-                uniform vec3 uRingColor;
-                void main() {
-                    float alphaMask = getMaskAlpha();
-                    if (alphaMask < 0.01) discard;
-                    vec2 p = vUv * 2.0 - 1.0;
-                    float d = length(p);
-                    float ring = smoothstep(0.52, 0.62, d) * (1.0 - smoothstep(0.80, 0.92, d));
-                    float glow = (1.0 - smoothstep(0.55, 0.98, d)) * 0.18;
-                    float a = (ring + glow) * uRingAlpha * alphaMask;
-                    if (a < 0.005) discard;
-                    gl_FragColor = vec4(uRingColor * (ring * 1.2 + glow), a);
-                }
-            `,
-      transparent: true,
-      depthWrite: false,
-      depthTest: false,
-      side: THREE6__namespace.DoubleSide,
-      blending: THREE6__namespace.AdditiveBlending
-    });
-    editHoverMesh = new THREE6__namespace.Mesh(geo, mat);
-    editHoverMesh.renderOrder = 500;
-    editHoverMesh.frustumCulled = false;
-    scene.add(editHoverMesh);
-  }
   createSkyBackground();
   createGround();
   createAtmosphere();
@@ -2528,7 +2583,6 @@ function createEngine({
   createSun();
   createMilkyWay();
   createBackdropStars();
-  createEditHoverRing();
   const raycaster = new THREE6__namespace.Raycaster();
   raycaster.params.Points.threshold = 5;
   new THREE6__namespace.Vector2();
@@ -2635,7 +2689,7 @@ function createEngine({
   function getPosition(n) {
     if (currentConfig?.arrangement) {
       const arr = currentConfig.arrangement[n.id];
-      if (arr) {
+      if (arr?.position) {
         const [px, py, pz] = arr.position;
         if (pz === 0) {
           const radius = currentConfig.layout?.radius ?? 2e3;
@@ -2784,6 +2838,7 @@ function createEngine({
     const starChapterIndices = [];
     const starTestamentIndices = [];
     const starDivisionIndices = [];
+    const starRevealThresholds = [];
     const chapterLineCutById = /* @__PURE__ */ new Map();
     const chapterStarSizeById = /* @__PURE__ */ new Map();
     const chapterWeightNormById = /* @__PURE__ */ new Map();
@@ -2820,12 +2875,23 @@ function createEngine({
     } else if (minWeight === maxWeight) {
       maxWeight = minWeight + 1;
     }
+    {
+      const pctCap = THREE6__namespace.MathUtils.clamp(cfg.starSizeWeightPercentile ?? 0.95, 0.5, 1);
+      const allWeights = [];
+      for (const n of laidOut.nodes) {
+        if (n.level === 3 && typeof n.weight === "number") allWeights.push(n.weight);
+      }
+      allWeights.sort((a, b) => a - b);
+      const capIdx = Math.min(Math.floor(pctCap * allWeights.length), allWeights.length - 1);
+      const cappedMax = allWeights[capIdx];
+      if (cappedMax !== void 0 && cappedMax > minWeight) maxWeight = cappedMax;
+    }
     for (const n of laidOut.nodes) {
       if (n.level === 3) {
         let baseSize = 3.5;
         let weightNorm = 0;
         if (typeof n.weight === "number") {
-          weightNorm = (n.weight - minWeight) / (maxWeight - minWeight);
+          weightNorm = THREE6__namespace.MathUtils.clamp((n.weight - minWeight) / (maxWeight - minWeight), 0, 1);
           const sizeExp = cfg.starSizeExponent ?? 4;
           const sizeScale = cfg.starSizeScale ?? 6;
           baseSize = Math.pow(weightNorm, sizeExp) * 22 * sizeScale;
@@ -2850,6 +2916,14 @@ function createEngine({
         starIndexToId.push(n.id);
         const baseSize = chapterStarSizeById.get(n.id) ?? 3.5;
         starSizes.push(baseSize);
+        {
+          const wn = chapterWeightNormById.get(n.id) ?? 0;
+          starRevealThresholds.push(THREE6__namespace.MathUtils.lerp(
+            -ZOOM_REVEAL_CONFIG.chapterFeather,
+            ZOOM_REVEAL_CONFIG.chapterRevealMax,
+            1 - wn
+          ));
+        }
         chapterLineCutById.set(
           n.id,
           THREE6__namespace.MathUtils.clamp(2.5 + baseSize * 0.45, 3, 40)
@@ -3000,6 +3074,7 @@ function createEngine({
     starGeo.setAttribute("chapterIndex", new THREE6__namespace.Float32BufferAttribute(starChapterIndices, 1));
     starGeo.setAttribute("testamentIndex", new THREE6__namespace.Float32BufferAttribute(starTestamentIndices, 1));
     starGeo.setAttribute("divisionIndex", new THREE6__namespace.Float32BufferAttribute(starDivisionIndices, 1));
+    starGeo.setAttribute("revealThreshold", new THREE6__namespace.Float32BufferAttribute(starRevealThresholds, 1));
     const starMat = createSmartMaterial({
       uniforms: {
         pixelRatio: { value: renderer.getPixelRatio() },
@@ -3017,19 +3092,22 @@ function createEngine({
         uFilterDivisionIndex: { value: -1 },
         uFilterBookIndex: { value: -1 },
         uFilterStrength: { value: 0 },
-        uFilterDimFactor: { value: 0.08 }
+        uFilterDimFactor: { value: 0.08 },
+        uRevealZoom: { value: 0 }
       },
       vertexShaderBody: `
-                attribute float size; 
-                attribute vec3 color; 
+                attribute float size;
+                attribute vec3 color;
                 attribute float phase;
                 attribute float bookIndex;
                 attribute float chapterIndex;
                 attribute float testamentIndex;
                 attribute float divisionIndex;
+                attribute float revealThreshold;
 
                 varying vec3 vColor;
                 varying float vSize;
+                varying float vReveal;
                 uniform float pixelRatio;
 
                 uniform float uTime;
@@ -3046,6 +3124,7 @@ function createEngine({
                 uniform float uFilterBookIndex;
                 uniform float uFilterStrength;
                 uniform float uFilterDimFactor;
+                uniform float uRevealZoom;
 
                 void main() { 
                     vec3 nPos = normalize(position);
@@ -3108,11 +3187,17 @@ function createEngine({
                     float perceptualSize = pow(size, 0.7);
                     gl_PointSize = clamp((perceptualSize * sizeBoost * 20.0) * uScale * pixelRatio * (2000.0 / length(mvPosition.xyz)) * horizonFade, 1.0, 600.0);
                     vSize = gl_PointSize;
+
+                    // Zoom-based reveal: faint stars hide at wide FOV, fade in as user zooms.
+                    // Exponent and feather baked from ZOOM_REVEAL_CONFIG at startup.
+                    float mappedZoom = pow(uRevealZoom, ${ZOOM_REVEAL_CONFIG.zoomCurveExp});
+                    vReveal = smoothstep(revealThreshold, revealThreshold + ${ZOOM_REVEAL_CONFIG.chapterFeather}, mappedZoom);
                 }
             `,
       fragmentShader: `
                 varying vec3 vColor;
                 varying float vSize;
+                varying float vReveal;
                 void main() {
                     vec2 coord = gl_PointCoord - vec2(0.5);
                     float d = length(coord) * 2.0;
@@ -3141,7 +3226,8 @@ function createEngine({
                     float spikeV = exp(-coord.x * coord.x * 180.0) * exp(-abs(coord.y) * 6.0);
                     float spikes = (spikeH + spikeV) * 0.18 * spikeFactor;
 
-                    gl_FragColor = vec4(finalColor * (k + spikes) * alphaMask, 1.0);
+                    // vReveal drives the additive contribution (AdditiveBlending uses SRC_ALPHA).
+                    gl_FragColor = vec4(finalColor * (k + spikes) * alphaMask, vReveal);
                 }
             `,
       transparent: true,
@@ -3646,20 +3732,23 @@ function createEngine({
       constellationLayer.load(cfg.constellations, (id) => {
         if (cfg.arrangement && cfg.arrangement[id]) {
           const arr = cfg.arrangement[id];
-          if (arr.position[2] === 0) {
-            const x = arr.position[0];
-            const y = arr.position[1];
-            const radius = cfg.layout?.radius ?? 2e3;
-            const r_norm = Math.min(1, Math.sqrt(x * x + y * y) / radius);
-            const phi = Math.atan2(y, x);
-            const theta = r_norm * (Math.PI / 2);
-            return new THREE6__namespace.Vector3(
-              Math.sin(theta) * Math.cos(phi),
-              Math.cos(theta),
-              Math.sin(theta) * Math.sin(phi)
-            ).multiplyScalar(radius);
+          const coords = arr.center ?? arr.position;
+          if (coords) {
+            if (coords[2] === 0) {
+              const x = coords[0];
+              const y = coords[1];
+              const radius = cfg.layout?.radius ?? 2e3;
+              const r_norm = Math.min(1, Math.sqrt(x * x + y * y) / radius);
+              const phi = Math.atan2(y, x);
+              const theta = r_norm * (Math.PI / 2);
+              return new THREE6__namespace.Vector3(
+                Math.sin(theta) * Math.cos(phi),
+                Math.cos(theta),
+                Math.sin(theta) * Math.sin(phi)
+              ).multiplyScalar(radius);
+            }
+            return new THREE6__namespace.Vector3(coords[0], coords[1], coords[2]);
           }
-          return new THREE6__namespace.Vector3(arr.position[0], arr.position[1], arr.position[2]);
         }
         return getLayoutPosition(id);
       }, getLayoutPosition);
@@ -3687,7 +3776,7 @@ function createEngine({
       arr[item.node.id] = { position: [item.obj.position.x, item.obj.position.y, item.obj.position.z] };
     }
     for (const item of constellationLayer.getItems()) {
-      arr[item.config.id] = { position: [item.center.x, item.center.y, item.center.z] };
+      arr[item.config.id] = { center: [item.center.x, item.center.y, item.center.z] };
     }
     Object.assign(arr, state.tempArrangement);
     return arr;
@@ -3810,29 +3899,65 @@ function createEngine({
     isMouseInWindow = false;
     edgeHoverStart = 0;
   }
+  function screenSpacePickStar(mx, my, maxPx = 50) {
+    if (!starPoints) return null;
+    const attr = starPoints.geometry.attributes.position;
+    const rect = renderer.domElement.getBoundingClientRect();
+    const w = rect.width;
+    const h = rect.height;
+    const uScale = globalUniforms.uScale.value;
+    const uAspect = globalUniforms.uAspect.value;
+    let bestIdx = -1;
+    let bestDist2 = maxPx * maxPx;
+    const worldPos = new THREE6__namespace.Vector3();
+    for (let i = 0; i < attr.count; i++) {
+      worldPos.set(attr.getX(i), attr.getY(i), attr.getZ(i));
+      const proj = smartProjectJS(worldPos);
+      if (currentProjection.isClipped(proj.z)) continue;
+      const sx = (proj.x * uScale / uAspect * 0.5 + 0.5) * w;
+      const sy = (-(proj.y * uScale) * 0.5 + 0.5) * h;
+      const dx = mx - sx;
+      const dy = my - sy;
+      const d2 = dx * dx + dy * dy;
+      if (d2 < bestDist2) {
+        bestDist2 = d2;
+        bestIdx = i;
+      }
+    }
+    if (bestIdx < 0) return null;
+    return {
+      index: bestIdx,
+      worldPos: new THREE6__namespace.Vector3(attr.getX(bestIdx), attr.getY(bestIdx), attr.getZ(bestIdx))
+    };
+  }
   function onMouseDown(e) {
     state.lastMouseX = e.clientX;
     state.lastMouseY = e.clientY;
     if (currentConfig?.editable) {
+      const rect = renderer.domElement.getBoundingClientRect();
+      const mX = e.clientX - rect.left;
+      const mY = e.clientY - rect.top;
+      const starHit = screenSpacePickStar(mX, mY);
+      if (starHit) {
+        state.dragMode = "node";
+        state.draggedStarIndex = starHit.index;
+        state.draggedNodeId = starIndexToId[starHit.index] ?? null;
+        state.draggedDist = starHit.worldPos.length();
+        state.draggedGroup = null;
+        state.tempArrangement = {};
+        state.velocityX = 0;
+        state.velocityY = 0;
+        return;
+      }
       const hit = pick(e);
-      if (hit) {
+      if (hit && (hit.type === "label" || hit.type === "constellation")) {
         state.dragMode = "node";
         state.draggedNodeId = hit.node.id;
-        if (hit.type === "star" && hit.index !== void 0 && starPoints) {
-          const attr = starPoints.geometry.attributes.position;
-          const starWorldPos = new THREE6__namespace.Vector3(attr.getX(hit.index), attr.getY(hit.index), attr.getZ(hit.index));
-          state.draggedDist = starWorldPos.length();
-        } else {
-          state.draggedDist = hit.point.length();
-        }
-        document.body.style.cursor = "crosshair";
+        state.draggedDist = hit.point.length();
+        state.draggedStarIndex = -1;
         state.velocityX = 0;
         state.velocityY = 0;
-        if (hit.type === "star") {
-          state.draggedStarIndex = hit.index ?? -1;
-          state.draggedGroup = null;
-          state.tempArrangement = {};
-        } else if (hit.type === "label") {
+        if (hit.type === "label") {
           const bookId = hit.node.id;
           const children = [];
           if (starPoints && starPoints.geometry.attributes.position) {
@@ -3847,12 +3972,21 @@ function createEngine({
               }
             }
           }
-          state.draggedGroup = { labelInitialPos: hit.object.position.clone(), children };
-          state.draggedStarIndex = -1;
-        } else if (hit.type === "constellation") {
-          state.draggedGroup = { labelInitialPos: hit.point.clone(), children: [] };
-          state.draggedStarIndex = -1;
+          const constellations = [];
+          for (const cItem of constellationLayer.getItems()) {
+            const anchored = cItem.config.anchors.some((anchorId) => {
+              const n = nodeById.get(anchorId);
+              return n?.parent === bookId;
+            });
+            if (anchored) {
+              constellations.push({ id: cItem.config.id, initialCenter: cItem.center.clone() });
+            }
+          }
+          state.draggedGroup = { labelInitialPos: hit.object.position.clone(), children, constellations };
+        } else {
+          state.draggedGroup = { labelInitialPos: hit.point.clone(), children: [], constellations: [] };
         }
+        return;
       }
       return;
     }
@@ -3879,7 +4013,6 @@ function createEngine({
         const attr = starPoints.geometry.attributes.position;
         attr.setXYZ(idx, newPos.x, newPos.y, newPos.z);
         attr.needsUpdate = true;
-        editHoverTargetPos = newPos.clone();
         const starId = starIndexToId[idx];
         if (starId) state.tempArrangement[starId] = { position: [newPos.x, newPos.y, newPos.z] };
       } else if (state.draggedGroup && state.draggedNodeId) {
@@ -3895,7 +4028,7 @@ function createEngine({
             const vE = newPos.clone().normalize();
             cItem.mesh.quaternion.setFromUnitVectors(vS, vE);
             cItem.center.copy(newPos);
-            state.tempArrangement[state.draggedNodeId] = { position: [newPos.x, newPos.y, newPos.z] };
+            state.tempArrangement[state.draggedNodeId] = { center: [newPos.x, newPos.y, newPos.z] };
           }
         }
         const vStart = group.labelInitialPos.clone().normalize();
@@ -3914,6 +4047,20 @@ function createEngine({
           }
           attr.needsUpdate = true;
         }
+        if (group.constellations.length > 0) {
+          for (const { id, initialCenter } of group.constellations) {
+            const cItem = constellationLayer.getItems().find((c) => c.config.id === id);
+            if (cItem) {
+              const newCenter = initialCenter.clone().applyQuaternion(q);
+              cItem.center.copy(newCenter);
+              cItem.mesh.quaternion.setFromUnitVectors(
+                initialCenter.clone().normalize(),
+                newCenter.clone().normalize()
+              );
+              state.tempArrangement[id] = { center: [newCenter.x, newCenter.y, newCenter.z] };
+            }
+          }
+        }
       }
     } else if (state.dragMode === "camera") {
       const deltaX = e.clientX - state.lastMouseX;
@@ -3921,13 +4068,15 @@ function createEngine({
       state.lastMouseX = e.clientX;
       state.lastMouseY = e.clientY;
       const speedScale = state.fov / ENGINE_CONFIG.defaultFov;
-      const rotLock = Math.max(0, Math.min(1, (state.fov - 100) / (ENGINE_CONFIG.maxFov - 100)));
-      const latFactor = 1 - rotLock * rotLock;
-      state.targetLon += deltaX * ENGINE_CONFIG.dragSpeed * speedScale;
-      state.targetLat += deltaY * ENGINE_CONFIG.dragSpeed * speedScale * latFactor;
+      const latFactor = getVerticalPanFactor(state.fov, state.lat);
+      const massFactor = getMovementMassFactor(state.fov);
+      const moveX = compressInputDelta(deltaX) * massFactor;
+      const moveY = compressInputDelta(deltaY) * massFactor;
+      state.targetLon += moveX * ENGINE_CONFIG.dragSpeed * speedScale;
+      state.targetLat += moveY * ENGINE_CONFIG.dragSpeed * speedScale * latFactor;
       state.targetLat = Math.max(-Math.PI / 2 + 0.01, Math.min(Math.PI / 2 - 0.01, state.targetLat));
-      state.velocityX = deltaX * ENGINE_CONFIG.dragSpeed * speedScale;
-      state.velocityY = deltaY * ENGINE_CONFIG.dragSpeed * speedScale * latFactor;
+      state.velocityX = moveX * ENGINE_CONFIG.dragSpeed * speedScale;
+      state.velocityY = moveY * ENGINE_CONFIG.dragSpeed * speedScale * latFactor;
       state.lon = state.targetLon;
       state.lat = state.targetLat;
     } else {
@@ -3947,26 +4096,17 @@ function createEngine({
         hoverLabelMesh.position.copy(hit.point);
         hoverLabelMat.uniforms.uAlpha.value = 1;
         hoverLabelMesh.visible = true;
-        if (currentConfig?.editable && hit.type === "star" && hit.index !== void 0 && starPoints) {
-          const attr = starPoints.geometry.attributes.position;
-          editHoverTargetPos = new THREE6__namespace.Vector3(attr.getX(hit.index), attr.getY(hit.index), attr.getZ(hit.index));
-        } else if (currentConfig?.editable && hit.type === "star") {
-          editHoverTargetPos = hit.point.clone();
-        }
       } else {
         currentHoverNodeId = null;
         hoverLabelMat.uniforms.uAlpha.value = 0;
         hoverLabelMesh.visible = false;
-        if (currentConfig?.editable && state.dragMode !== "node") {
-          editHoverTargetPos = null;
-        }
       }
       if (hit?.node.id !== handlers._lastHoverId) {
         handlers._lastHoverId = hit?.node.id;
         handlers.onHover?.(hit?.node);
         constellationLayer.setHovered(hit?.node.id ?? null);
       }
-      document.body.style.cursor = hit ? currentConfig?.editable ? "crosshair" : "pointer" : "default";
+      document.body.style.cursor = hit ? currentConfig?.editable && hit.type === "star" ? "grab" : "pointer" : "default";
     }
   }
   function onMouseUp(e) {
@@ -3976,7 +4116,6 @@ function createEngine({
     if (state.dragMode === "node") {
       const fullArr = getFullArrangement();
       handlers.onArrangementChange?.(fullArr);
-      editDropFlash = 1;
       state.dragMode = "none";
       state.draggedNodeId = null;
       state.draggedStarIndex = -1;
@@ -4019,20 +4158,30 @@ function createEngine({
     const aspect = container.clientWidth / container.clientHeight;
     renderer.domElement.getBoundingClientRect();
     const vBefore = getMouseViewVector(state.fov, aspect);
-    const zoomSpeed = 1e-3 * state.fov;
+    const zoomResistance = THREE6__namespace.MathUtils.lerp(
+      1,
+      ENGINE_CONFIG.zoomResistanceWideFov,
+      THREE6__namespace.MathUtils.smoothstep(state.fov, 24, 100)
+    );
+    const zoomSpeed = 1e-3 * state.fov * zoomResistance;
     state.fov += e.deltaY * zoomSpeed;
     state.fov = Math.max(ENGINE_CONFIG.minFov, Math.min(ENGINE_CONFIG.maxFov, state.fov));
     handlers.onFovChange?.(state.fov);
     updateUniforms();
     const vAfter = getMouseViewVector(state.fov, aspect);
     const quaternion = new THREE6__namespace.Quaternion().setFromUnitVectors(vAfter, vBefore);
-    const dampStartFov = 40;
-    const dampEndFov = 120;
+    const dampStartFov = 32;
+    const dampEndFov = 110;
     let spinAmount = 1;
     if (state.fov > dampStartFov) {
       const t = Math.max(0, Math.min(1, (state.fov - dampStartFov) / (dampEndFov - dampStartFov)));
-      spinAmount = 1 - Math.pow(t, 1.5) * 0.8;
+      spinAmount = 1 - Math.pow(t, 1.35) * 0.92;
     }
+    const blendForSpin = getBlendForZenithControl();
+    const blendSpinDamp = THREE6__namespace.MathUtils.smoothstep(blendForSpin, 0.58, 0.9);
+    spinAmount *= 1 - 0.88 * blendSpinDamp;
+    if (zenithProjectionLockActive) spinAmount = Math.min(spinAmount, 0.02);
+    spinAmount = Math.max(0.02, Math.min(1, spinAmount));
     if (spinAmount < 0.999) {
       const identityQuat = new THREE6__namespace.Quaternion();
       quaternion.slerp(identityQuat, 1 - spinAmount);
@@ -4054,9 +4203,10 @@ function createEngine({
     state.lon = Math.atan2(newForward.x, -newForward.z);
     const newUp = new THREE6__namespace.Vector3(0, 1, 0).applyQuaternion(qNew);
     camera.up.copy(newUp);
-    if (!getSceneDebug()?.disableZenithBias && e.deltaY > 0 && state.fov > ENGINE_CONFIG.zenithStartFov) {
-      const range = ENGINE_CONFIG.maxFov - ENGINE_CONFIG.zenithStartFov;
-      let t = (state.fov - ENGINE_CONFIG.zenithStartFov) / range;
+    const zenithBiasStartFov = getZenithBiasStartFov();
+    if (!zenithProjectionLockActive && !getSceneDebug()?.disableZenithBias && !isInTransitionFreezeBand(state.fov) && e.deltaY > 0 && state.fov > zenithBiasStartFov) {
+      const range = ENGINE_CONFIG.maxFov - zenithBiasStartFov;
+      let t = (state.fov - zenithBiasStartFov) / range;
       t = Math.max(0, Math.min(1, t));
       const bias = ENGINE_CONFIG.zenithStrength * t;
       const zenithLat = Math.PI / 2 - 1e-3;
@@ -4148,13 +4298,15 @@ function createEngine({
         }
       }
       const speedScale = state.fov / ENGINE_CONFIG.defaultFov;
-      const rotLock = Math.max(0, Math.min(1, (state.fov - 100) / (ENGINE_CONFIG.maxFov - 100)));
-      const latFactor = 1 - rotLock * rotLock;
-      state.targetLon += deltaX * ENGINE_CONFIG.dragSpeed * speedScale;
-      state.targetLat += deltaY * ENGINE_CONFIG.dragSpeed * speedScale * latFactor;
+      const latFactor = getVerticalPanFactor(state.fov, state.lat);
+      const massFactor = getMovementMassFactor(state.fov);
+      const moveX = compressInputDelta(deltaX) * massFactor;
+      const moveY = compressInputDelta(deltaY) * massFactor;
+      state.targetLon += moveX * ENGINE_CONFIG.dragSpeed * speedScale;
+      state.targetLat += moveY * ENGINE_CONFIG.dragSpeed * speedScale * latFactor;
       state.targetLat = Math.max(-Math.PI / 2 + 0.01, Math.min(Math.PI / 2 - 0.01, state.targetLat));
-      state.velocityX = deltaX * ENGINE_CONFIG.dragSpeed * speedScale;
-      state.velocityY = deltaY * ENGINE_CONFIG.dragSpeed * speedScale * latFactor;
+      state.velocityX = moveX * ENGINE_CONFIG.dragSpeed * speedScale;
+      state.velocityY = moveY * ENGINE_CONFIG.dragSpeed * speedScale * latFactor;
       state.lon = state.targetLon;
       state.lat = state.targetLat;
     } else if (touches.length === 2) {
@@ -4166,9 +4318,10 @@ function createEngine({
       state.fov = state.pinchStartFov / scale;
       state.fov = Math.max(ENGINE_CONFIG.minFov, Math.min(ENGINE_CONFIG.maxFov, state.fov));
       handlers.onFovChange?.(state.fov);
-      if (!getSceneDebug()?.disableZenithBias && state.fov > prevFov && state.fov > ENGINE_CONFIG.zenithStartFov) {
-        const range = ENGINE_CONFIG.maxFov - ENGINE_CONFIG.zenithStartFov;
-        let t = (state.fov - ENGINE_CONFIG.zenithStartFov) / range;
+      const zenithBiasStartFov = getZenithBiasStartFov();
+      if (!zenithProjectionLockActive && !getSceneDebug()?.disableZenithBias && !isInTransitionFreezeBand(state.fov) && state.fov > prevFov && state.fov > zenithBiasStartFov) {
+        const range = ENGINE_CONFIG.maxFov - zenithBiasStartFov;
+        let t = (state.fov - zenithBiasStartFov) / range;
         t = Math.max(0, Math.min(1, t));
         const bias = ENGINE_CONFIG.zenithStrength * t;
         const zenithLat = Math.PI / 2 - 1e-3;
@@ -4181,8 +4334,12 @@ function createEngine({
       state.lastMouseX = center.x;
       state.lastMouseY = center.y;
       const speedScale = state.fov / ENGINE_CONFIG.defaultFov;
-      state.targetLon += deltaX * ENGINE_CONFIG.dragSpeed * speedScale * 0.5;
-      state.targetLat += deltaY * ENGINE_CONFIG.dragSpeed * speedScale * 0.5;
+      const latFactor = getVerticalPanFactor(state.fov, state.lat);
+      const massFactor = getMovementMassFactor(state.fov);
+      const moveX = compressInputDelta(deltaX) * massFactor;
+      const moveY = compressInputDelta(deltaY) * massFactor;
+      state.targetLon += moveX * ENGINE_CONFIG.dragSpeed * speedScale * 0.5;
+      state.targetLat += moveY * ENGINE_CONFIG.dragSpeed * speedScale * 0.5 * latFactor;
       state.targetLat = Math.max(-Math.PI / 2 + 0.01, Math.min(Math.PI / 2 - 0.01, state.targetLat));
       state.lon = state.targetLon;
       state.lat = state.targetLat;
@@ -4345,7 +4502,9 @@ function createEngine({
       if (inZoneX || inZoneY) {
         if (edgeHoverStart === 0) edgeHoverStart = performance.now();
         if (performance.now() - edgeHoverStart > ENGINE_CONFIG.edgePanDelay) {
-          const speedBase = ENGINE_CONFIG.edgePanMaxSpeed * (state.fov / ENGINE_CONFIG.defaultFov);
+          const edgeMassFactor = getMovementMassFactor(state.fov, ENGINE_CONFIG.edgePanMassWideFov);
+          const speedBase = ENGINE_CONFIG.edgePanMaxSpeed * (state.fov / ENGINE_CONFIG.defaultFov) * edgeMassFactor;
+          const verticalPanFactor = getVerticalPanFactor(state.fov, state.lat);
           if (mouseNDC.x < -1 + t) {
             const s = (-1 + t - mouseNDC.x) / t;
             panX = -s * s * speedBase;
@@ -4355,10 +4514,10 @@ function createEngine({
           }
           if (mouseNDC.y < -1 + t) {
             const s = (-1 + t - mouseNDC.y) / t;
-            panY = -s * s * speedBase;
+            panY = -s * s * speedBase * verticalPanFactor;
           } else if (mouseNDC.y > 1 - t) {
             const s = (mouseNDC.y - (1 - t)) / t;
-            panY = s * s * speedBase;
+            panY = s * s * speedBase * verticalPanFactor;
           }
         }
       } else {
@@ -4390,14 +4549,32 @@ function createEngine({
       state.targetLat = state.lat;
     } else if (!state.isDragging && !flyToActive) {
       state.lon += state.velocityX;
+      state.velocityY *= getVerticalPanFactor(state.fov, state.lat);
       state.lat += state.velocityY;
-      const damping = isTouchDevice ? ENGINE_CONFIG.touchInertiaDamping : ENGINE_CONFIG.inertiaDamping;
+      const baseDamping = isTouchDevice ? ENGINE_CONFIG.touchInertiaDamping : ENGINE_CONFIG.inertiaDamping;
+      const speed = Math.hypot(state.velocityX, state.velocityY);
+      const damping = speed < ENGINE_CONFIG.lowSpeedVelocityThreshold ? Math.min(baseDamping, ENGINE_CONFIG.lowSpeedInertiaDamping) : baseDamping;
       state.velocityX *= damping;
       state.velocityY *= damping;
-      if (Math.abs(state.velocityX) < 1e-6) state.velocityX = 0;
-      if (Math.abs(state.velocityY) < 1e-6) state.velocityY = 0;
+      if (Math.abs(state.velocityX) < ENGINE_CONFIG.velocityStopThreshold) state.velocityX = 0;
+      if (Math.abs(state.velocityY) < ENGINE_CONFIG.velocityStopThreshold) state.velocityY = 0;
     }
     state.lat = Math.max(-Math.PI / 2 + 0.01, Math.min(Math.PI / 2 - 0.01, state.lat));
+    if (!flyToActive) {
+      const latDeg = THREE6__namespace.MathUtils.radToDeg(state.lat);
+      if (latDeg < HORIZON_ZOOM_CONFIG.latStartDeg) {
+        const t = THREE6__namespace.MathUtils.clamp(latDeg / HORIZON_ZOOM_CONFIG.latStartDeg, 0, 1);
+        const maxFov = THREE6__namespace.MathUtils.lerp(
+          HORIZON_ZOOM_CONFIG.safeFovAtHorizon,
+          ENGINE_CONFIG.maxFov,
+          t
+        );
+        if (state.fov > maxFov) {
+          state.fov = THREE6__namespace.MathUtils.lerp(state.fov, maxFov, HORIZON_ZOOM_CONFIG.lerpRate);
+        }
+      }
+    }
+    applyZenithAutoCenter();
     const y = Math.sin(state.lat);
     const r = Math.cos(state.lat);
     const x = r * Math.sin(state.lon);
@@ -4410,11 +4587,13 @@ function createEngine({
     camera.updateMatrixWorld();
     camera.matrixWorldInverse.copy(camera.matrixWorld).invert();
     if (groundMaterial?.uniforms?.uZenithFlatten) {
-      const flatten = getSceneDebug()?.disableZenithFlatten ? 0 : THREE6__namespace.MathUtils.smoothstep(
+      const targetFlatten = getSceneDebug()?.disableZenithFlatten ? 0 : THREE6__namespace.MathUtils.smoothstep(
         state.lat,
         THREE6__namespace.MathUtils.degToRad(68),
         THREE6__namespace.MathUtils.degToRad(88)
       );
+      const prevFlatten = Number(groundMaterial.uniforms.uZenithFlatten.value ?? 0);
+      const flatten = isInTransitionFreezeBand(state.fov) ? THREE6__namespace.MathUtils.clamp(targetFlatten, prevFlatten - 0.01, prevFlatten + 0.01) : targetFlatten;
       groundMaterial.uniforms.uZenithFlatten.value = flatten;
     }
     updateUniforms();
@@ -4431,6 +4610,11 @@ function createEngine({
     const baseArtOpacity = THREE6__namespace.MathUtils.clamp(currentConfig?.constellationBaseOpacity ?? 1, 0, 300);
     constellationLayer.setGlobalOpacity?.(artFader.eased * baseArtOpacity);
     backdropGroup.visible = currentConfig?.showBackdropStars ?? true;
+    const revealZoom = currentConfig?.starZoomReveal ?? true ? THREE6__namespace.MathUtils.clamp(
+      (ZOOM_REVEAL_CONFIG.wideFov - state.fov) / (ZOOM_REVEAL_CONFIG.wideFov - ZOOM_REVEAL_CONFIG.narrowFov),
+      0,
+      1
+    ) : 1;
     if (backdropStarsMaterial?.uniforms) {
       const minGain = THREE6__namespace.MathUtils.clamp(currentConfig?.backdropWideFovGain ?? 0.42, 0, 1);
       const fovT = THREE6__namespace.MathUtils.smoothstep(state.fov, 24, 100);
@@ -4438,6 +4622,11 @@ function createEngine({
       backdropStarsMaterial.uniforms.uBackdropGain.value = gain;
       backdropStarsMaterial.uniforms.uBackdropEnergy.value = THREE6__namespace.MathUtils.clamp(currentConfig?.backdropEnergy ?? 2.2, 0.2, 5);
       backdropStarsMaterial.uniforms.uBackdropSizeExp.value = THREE6__namespace.MathUtils.clamp(currentConfig?.backdropSizeExponent ?? 0.9, 0.4, 1.4);
+      backdropStarsMaterial.uniforms.uRevealZoom.value = revealZoom;
+    }
+    if (starPoints?.material) {
+      const sm = starPoints.material;
+      if (sm.uniforms.uRevealZoom) sm.uniforms.uRevealZoom.value = revealZoom;
     }
     if (skyBackgroundMesh) skyBackgroundMesh.visible = currentConfig?.background !== "transparent";
     if (atmosphereMesh) atmosphereMesh.visible = currentConfig?.showAtmosphere ?? false;
@@ -4447,32 +4636,6 @@ function createEngine({
     if (sunDiscMesh) sunDiscMesh.visible = showSun;
     if (sunHaloMesh) sunHaloMesh.visible = showSun;
     if (milkyWayMesh) milkyWayMesh.visible = currentConfig?.showMilkyWay ?? true;
-    if (editHoverMesh) {
-      const ringMat = editHoverMesh.material;
-      const isEditing = currentConfig?.editable ?? false;
-      const isDraggingStar = state.dragMode === "node" && state.draggedStarIndex !== -1;
-      const hasTarget = isEditing && editHoverTargetPos !== null;
-      if (hasTarget) {
-        editHoverMesh.position.copy(editHoverTargetPos);
-        const pulseBoost = editDropFlash * 1.8;
-        const targetAlpha = 0.8 + pulseBoost;
-        ringMat.uniforms.uRingAlpha.value = THREE6__namespace.MathUtils.lerp(ringMat.uniforms.uRingAlpha.value, targetAlpha, 0.15);
-        const tGold = isDraggingStar ? 1 : editDropFlash;
-        const targetColor = new THREE6__namespace.Color(
-          THREE6__namespace.MathUtils.lerp(0.55, 1, tGold),
-          THREE6__namespace.MathUtils.lerp(0.88, 0.82, tGold),
-          THREE6__namespace.MathUtils.lerp(1, 0.18, tGold)
-        );
-        ringMat.uniforms.uRingColor.value.lerp(targetColor, 0.18);
-        const baseSize = isDraggingStar ? 0.075 : 0.06;
-        const targetSize = baseSize * (1 + editDropFlash * 0.7);
-        ringMat.uniforms.uRingSize.value = THREE6__namespace.MathUtils.lerp(ringMat.uniforms.uRingSize.value, targetSize, 0.18);
-        editDropFlash = Math.max(0, editDropFlash - dt * 3);
-      } else {
-        ringMat.uniforms.uRingAlpha.value = THREE6__namespace.MathUtils.lerp(ringMat.uniforms.uRingAlpha.value, 0, 0.15);
-        ringMat.uniforms.uRingSize.value = THREE6__namespace.MathUtils.lerp(ringMat.uniforms.uRingSize.value, 0.06, 0.2);
-      }
-    }
     if (constellationLines) {
       constellationLines.visible = linesFader.eased > 0.01;
       if (constellationLines.visible && constellationLines.material) {
@@ -4580,12 +4743,6 @@ function createEngine({
       skyBackgroundMesh.material.dispose();
       skyBackgroundMesh = null;
     }
-    if (editHoverMesh) {
-      scene.remove(editHoverMesh);
-      editHoverMesh.geometry.dispose();
-      editHoverMesh.material.dispose();
-      editHoverMesh = null;
-    }
     renderer.dispose();
     renderer.domElement.remove();
   }
@@ -4628,7 +4785,7 @@ function createEngine({
   }
   return { setConfig, start, stop, dispose, setHandlers, getFullArrangement, setHoveredBook, setFocusedBook, setOrderRevealEnabled, setHierarchyFilter, flyTo, setProjection };
 }
-var ENGINE_CONFIG, ORDER_REVEAL_CONFIG;
+var ENGINE_CONFIG, ORDER_REVEAL_CONFIG, HORIZON_ZOOM_CONFIG, ZOOM_REVEAL_CONFIG;
 var init_createEngine = __esm({
   "src/engine/createEngine.ts"() {
     init_layout();
@@ -4643,8 +4800,28 @@ var init_createEngine = __esm({
       defaultFov: 35,
       dragSpeed: 125e-5,
       inertiaDamping: 0.92,
+      lowSpeedInertiaDamping: 0.78,
+      lowSpeedVelocityThreshold: 25e-4,
+      velocityStopThreshold: 4e-5,
+      zoomResistanceWideFov: 0.82,
+      movementMassWideFov: 0.74,
+      edgePanMassWideFov: 0.68,
+      inputCompression: 0.018,
       blendStart: 35,
       blendEnd: 83,
+      freezeBandStartFov: 76,
+      freezeBandEndFov: 84,
+      zenithBiasStartFov: 85,
+      zenithLockBlendEnter: 0.9,
+      zenithLockBlendExit: 0.8,
+      zenithAutoCenterBlendStart: 0.62,
+      zenithAutoCenterBlendEnd: 0.9,
+      zenithAutoCenterMinLerp: 0.012,
+      zenithAutoCenterMaxLerp: 0.16,
+      verticalPanDampStartFov: 72,
+      verticalPanDampEndFov: 96,
+      verticalPanDampLatStartDeg: 45,
+      verticalPanDampLatEndDeg: 82,
       zenithStartFov: 75,
       zenithStrength: 0.15,
       horizonLockStrength: 0.05,
@@ -4671,6 +4848,30 @@ var init_createEngine = __esm({
       pulseDuration: 2,
       delayPerChapter: 0.1
     };
+    HORIZON_ZOOM_CONFIG = {
+      latStartDeg: 20,
+      // coupling is fully off above this elevation
+      safeFovAtHorizon: 60,
+      // max FOV at the horizon (below freeze-band threshold)
+      lerpRate: 0.03
+      // gentle — should feel like a natural breathing-in
+    };
+    ZOOM_REVEAL_CONFIG = {
+      wideFov: 120,
+      // above this FOV, revealZoom = 0 (nothing new revealed)
+      narrowFov: 8,
+      // below this FOV, revealZoom = 1 (everything visible)
+      zoomCurveExp: 1.8,
+      // non-linear curve exponent (try 1.5 – 2.5)
+      chapterRevealMax: 0.5,
+      // faintest chapter star threshold — visible by ~fov 35
+      chapterFeather: 0.1,
+      // smoothstep width for chapter star fade-in
+      backdropRevealStart: 0.4,
+      // backdrop starts appearing at this mappedZoom
+      backdropRevealEnd: 0.65
+      // backdrop fully visible at this mappedZoom
+    };
   }
 });
 var StarMap = react.forwardRef(