spacemap 0.1.22 → 0.1.25

package/index.js

@@ -3061,9 +3061,6 @@ function isExtrasolar(body) {
 function isExoplanet(body) {
 	return body.data.objectType === ObjectType.EXOPLANET;
 }
-function isSurfaceFeature(body) {
-	return body.data.objectType === ObjectType.SURFACE_FEATURE;
-}
 var ObjectType = /* @__PURE__ */ function(ObjectType) {
 	ObjectType[ObjectType["BARYCENTER"] = 0] = "BARYCENTER";
 	ObjectType[ObjectType["LAGRANGE_POINT"] = 1] = "LAGRANGE_POINT";
@@ -6837,7 +6834,6 @@ var BodyIndex = class {
 	majorBodies = [];
 	asteroidBodiesByZone = /* @__PURE__ */ new Map();
 	spacecraftByParent = /* @__PURE__ */ new Map();
-	focusFeature = null;
 	extrasolar = /* @__PURE__ */ new Map();
 	pinnedExtrasolar = /* @__PURE__ */ new Set();
 	tripCentreId = null;
@@ -6884,7 +6880,6 @@ var BodyIndex = class {
 	getBody(id, zone) {
 		const major = this.bodiesById.get(id);
 		if (major) return major;
-		if (this.focusFeature?.data.id === id) return this.focusFeature;
 		const star = this.extrasolar.get(id) ?? this.exoplanets.get(this.exoplanetAliases.get(id) ?? id);
 		if (star) return star;
 		if (zone !== void 0) return this.spacecraftByParent.get(zone)?.get(id) ?? this.asteroidBodiesByZone.get(zone)?.get(id);
@@ -7778,6 +7773,7 @@ var VisibilityController = class {
 	systemCentres = /* @__PURE__ */ new Map();
 	focusedBodyIdPlain = SUN_ID;
 	focusedSystemIdPlain = null;
+	subjectIdPlain;
 	travelSystemActive = false;
 	cameraDistThreeJS = 0;
 	lastRecomputeDist = -1;
@@ -7881,11 +7877,15 @@ var VisibilityController = class {
 		this.focusedSystemIdPlain = sysId;
 		this.lastRecomputeDist = -1;
 	}
+	inFocus(id) {
+		return id === this.focusedBodyIdPlain || id === this.subjectIdPlain;
+	}
 	clearTravelSystem() {
 		this.travelSystemActive = false;
 	}
-	setFocused(body) {
+	setFocused(body, subject) {
 		this.travelSystemActive = false;
+		this.subjectIdPlain = subject?.data.id;
 		if (body.data.id === this.focusedBodyIdPlain) return;
 		this.focusedBodyId = body.data.id;
 		this.focusedBodyIdPlain = body.data.id;
@@ -7910,7 +7910,7 @@ var VisibilityController = class {
 		else if (isAsteroidMoon && !this.matchesSmallBodyClass(moon.data.parentId)) vis = VISIBILITY.HIDE;
 		else {
 			const ratio = this.cameraDistThreeJS / 10 / moon.data.a;
-			const isFocused = moon.data.id === this.focusedBodyIdPlain;
+			const isFocused = this.inFocus(moon.data.id);
 			vis = computeVisibilityFromRatio(ratio, this.scaledPlanetary, 5, isFocused);
 			if (!isAsteroidMoon && vis === VISIBILITY.FULL && !this.fullMoonIds.has(moon.data.id) && !isFocused) vis = VISIBILITY.CAPPED;
 		}
@@ -7958,7 +7958,7 @@ var VisibilityController = class {
 			if (!this.isInFocusedSystem(body.data.parentId)) return VISIBILITY.HIDE;
 			const refA = body.data.a;
 			if (!refA || refA <= 0) return VISIBILITY.FULL;
-			const isFocused = body.data.id === this.focusedBodyIdPlain;
+			const isFocused = this.inFocus(body.data.id);
 			return computeVisibilityFromRatio(camDistThreeJS / 10 / refA, this.scaledPlanetary, 5, isFocused);
 		}
 		let refA = body.extrasolar?.pairAxis ?? body.data.a;
@@ -7970,7 +7970,7 @@ var VisibilityController = class {
 			if (refA === 0 && body.data.e < .9) console.warn(`No semi-major axis available for body ${body.data.id} (${body.data.name}), falling back to FULL visibility`);
 			return VISIBILITY.FULL;
 		}
-		const isFocused = body.data.id === this.focusedBodyIdPlain;
+		const isFocused = this.inFocus(body.data.id);
 		const noLine = isExtrasolar(body) && !body.orbitElements;
 		const tier = computeVisibilityFromRatio(camDistThreeJS / 10 / refA, this.scaledSystem, 50, isFocused || noLine);
 		return tier === VISIBILITY.CLOSE ? VISIBILITY.FULL : tier;
@@ -7978,7 +7978,7 @@ var VisibilityController = class {
 	getProbeVisibility(body, camDistThreeJS) {
 		const ps = this.getProbeStore();
 		if ((ps ? ps.containingSystemAt(body.data.id, this.currentJd) : null) === EARTH_SYSTEM_NAIF && this.getEarthSatGroupFilter()) return VISIBILITY.HIDE;
-		const isFocused = body.data.id === this.focusedBodyIdPlain;
+		const isFocused = this.inFocus(body.data.id);
 		if (!(ps ? !ps.hasHeliocentricFit(body.data.id, this.currentJd) : false)) {
 			const sun = this.bodies.bodiesById.get(SUN_ID);
 			const helioDist = sun?.position && body.position ? f64dist(body.position, sun.position) / 10 : 0;
@@ -8043,7 +8043,7 @@ var VisibilityController = class {
 	bodyUnclearedShare(body) {
 		if (this.clearing.share === 0) return 1;
 		const { id, objectType, parentId, orbitalSource } = body.data;
-		if (id === this.focusedBodyIdPlain || id === this.focusedSystemIdPlain || this.pinned.has(id) || this.tripEnds.has(id)) return 1;
+		if (this.inFocus(id) || id === this.focusedSystemIdPlain || this.pinned.has(id) || this.tripEnds.has(id)) return 1;
 		const layer = bodyLayer(objectType, parentId);
 		if (layer === "spacecraft" || orbitalSource === OrbitalSource.SPICE_PROBE) {
 			const page = this.getProbePage();
@@ -16768,7 +16768,7 @@ function seedAccepted() {
 	for (let i = 0; i < _reservedActive; i++) copyRect(poolSlot(_accepted, i, makeRect), _reserved[i]);
 	return _reservedActive;
 }
-function cullOverlappingLabels(bodyObjects, screenWidth, screenHeight, camera, focusedBodyId, ctx, hoveredBodyIds, screenOccluders, focusTruePos = [
+function cullOverlappingLabels(bodyObjects, screenWidth, screenHeight, camera, ctx, hoveredBodyIds, screenOccluders, focusTruePos = [
 	0,
 	0,
 	0
@@ -16783,7 +16783,7 @@ function cullOverlappingLabels(bodyObjects, screenWidth, screenHeight, camera, f
 			if (span && span.offsetWidth > 0) bo.labelTextWidth = span.offsetWidth;
 		}
 		if (!labelScreenRect(bo, camera, focusTruePos, screenWidth, screenHeight, _projRect)) continue;
-		const isFocused = body.data.id === focusedBodyId;
+		const isFocused = ctx.visibility.inFocus(body.data.id);
 		const isHovered = hoveredBodyIds.has(body.data.id);
 		const c = poolSlot(_candidates, _candidatesActive++, makeCandidate);
 		copyRect(c.rect, _projRect);
@@ -17623,19 +17623,60 @@ function isModelBearing(body) {
 var modelLoader = new GLTFLoader();
 modelLoader.setMeshoptDecoder(MeshoptDecoder);
 var _loader = modelLoader;
-var _bundleMetaCache = /* @__PURE__ */ new Map();
-function fetchBundleMeta(slug) {
-	let p = _bundleMetaCache.get(slug);
-	if (!p) {
-		p = fetch(versionedUrl(`/v1/models/${slug}/metadata.json`, "models")).then((r) => r.json());
-		_bundleMetaCache.set(slug, p);
-		p.catch(() => _bundleMetaCache.delete(slug));
+function modelUrl(slug, tier) {
+	return versionedUrl(`/v1/models/${slug}/${tier}.glb`, "models");
+}
+async function loadModelBundle(slug, tier) {
+	const first = await loadTier(slug, tier);
+	if (!first || textureAllowed(first.meta.exports[tier]?.distribution)) return first;
+	disposeGltf(first.gltf.scene);
+	const other = tier === "high" ? "low" : "high";
+	if (!first.meta.tiers?.includes(other)) return null;
+	if (!textureAllowed(first.meta.exports[other]?.distribution)) return null;
+	const second = await loadTier(slug, other);
+	if (!second || textureAllowed(second.meta.exports[other]?.distribution)) return second;
+	disposeGltf(second.gltf.scene);
+	return null;
+}
+async function loadTier(slug, tier) {
+	const gltf = await _loader.loadAsync(modelUrl(slug, tier));
+	const meta = (gltf.asset?.extras)?.spacemap;
+	if (!meta?.exports?.high) {
+		disposeGltf(gltf.scene);
+		console.warn(`models/${slug}/${tier}.glb carries no payload`);
+		return null;
 	}
-	return p;
+	return {
+		gltf,
+		meta,
+		tier
+	};
+}
+var _tiers;
+function fetchModelTiers() {
+	if (!_tiers) {
+		const p = fetch(versionedUrl("/v1/models/tiers.json", "models")).then((r) => {
+			if (!r.ok) throw new Error(`models/tiers.json: ${r.status}`);
+			return r.json();
+		}).then((d) => d.bundles ?? {}).catch((e) => {
+			console.warn("models/tiers.json did not load:", e);
+			if (_tiers === p) _tiers = void 0;
+			return {};
+		});
+		_tiers = p;
+	}
+	return _tiers;
+}
+async function bundleTiers(slug) {
+	return (await fetchModelTiers())[slug];
+}
+function tierAllowed(tiers, tier) {
+	const info = tiers[tier];
+	return !!info && textureAllowed(info.distribution);
 }
-function allowedTier(meta) {
-	if (textureAllowed(meta.exports.high.distribution)) return "high";
-	if (meta.exports.low && textureAllowed(meta.exports.low.distribution)) return "low";
+function allowedTier(tiers) {
+	if (!tiers) return "high";
+	return ["high", "low"].find((tier) => tierAllowed(tiers, tier));
 }
 function shapeModelCredit(meta) {
 	return meta.credit ?? meta.exports.high.credit;
@@ -17700,13 +17741,13 @@ async function loadSpacecraftModel(bo, modelScene, ctx) {
 		if ((bo.modelLoadEpoch ?? 0) !== epoch) return;
 		if (bo.mesh) bo.mesh.visible = false;
 		setHaloLoading(bo, true);
-		const meta = await fetchBundleMeta(slug);
-		const tier = allowedTier(meta);
-		if (!tier) {
+		const wanted = allowedTier(await bundleTiers(slug));
+		const loaded = wanted && await loadModelBundle(slug, wanted);
+		if (!loaded) {
 			bo.noPhysical = "model";
 			return;
 		}
-		const gltf = await _loader.loadAsync(versionedUrl(`/v1/models/${slug}/${tier}.glb`, "models"));
+		const { gltf, meta, tier } = loaded;
 		if ((bo.modelLoadEpoch ?? 0) !== epoch || !bo.mesh) {
 			disposeGltf(gltf.scene);
 			return;
@@ -17758,20 +17799,9 @@ async function loadNaturalBodyModel(bo, ctx) {
 			return;
 		}
 		if (detail.global?.orientation && !bo.body.orientation) applyBodyOrientation(bo.body, detail.global.orientation, detail.global.nut_prec, ctx);
-		const metaPromise = fetchBundleMeta(slug);
-		const gltf = await _loader.loadAsync(versionedUrl(`/v1/models/${slug}/high.glb`, "models"));
-		if ((bo.modelLoadEpoch ?? 0) !== epoch) {
-			disposeGltf(gltf.scene);
-			return;
-		}
-		let meta;
-		try {
-			meta = await metaPromise;
-		} catch (e) {
-			disposeGltf(gltf.scene);
-			console.warn(`Failed to load shape-model metadata for ${slug}:`, e);
-			return;
-		}
+		const loaded = await loadModelBundle(slug, "high");
+		if (!loaded) return;
+		const { gltf, meta } = loaded;
 		if ((bo.modelLoadEpoch ?? 0) !== epoch) {
 			disposeGltf(gltf.scene);
 			return;
@@ -18063,12 +18093,6 @@ function onLinkTap(el, handler) {
 }
 
 // src/lib/scene/objects/surface/nomenclature.ts
-function nomenclatureBodyId(focused, bodyObjects) {
-	if (!focused) return void 0;
-	if (isSurfaceFeature(focused)) return focused.featureAnchor.hostId;
-	if (bodyObjects.get(focused.data.id)?.isLanded) return focused.data.parentId;
-	return focused.data.id;
-}
 var DEG2RAD$4 = Math.PI / 180;
 var MIN_BODY_SCREEN_RADIUS_PX = 128;
 var LABEL_DISC_FRACTION = .9;
@@ -22390,6 +22414,87 @@ var SimClock = class {
 	}
 };
 
+// src/lib/scene/camera/two-finger.ts
+var TWO_FINGER_SLOP = 10;
+var TWO_FINGER_ALONE = 30;
+var TILT_MAX_SPREAD_SLOPE = Math.tan(MathUtils.degToRad(40));
+var TILT_MAX_SIDEWAYS = .5;
+var TILT_MIN_TOGETHER = .3;
+var TWIST_ENGAGE = MathUtils.degToRad(12);
+var TwoFingerGesture = class {
+	mode = "map";
+	a0 = {
+		x: 0,
+		y: 0
+	};
+	b0 = {
+		x: 0,
+		y: 0
+	};
+	lastMidY = 0;
+	lastAngle = 0;
+	twisted = 0;
+	twisting = false;
+	begin(a, b, canTilt) {
+		this.mode = canTilt ? "undecided" : "map";
+		this.a0.x = a.x;
+		this.a0.y = a.y;
+		this.b0.x = b.x;
+		this.b0.y = b.y;
+		this.lastMidY = (a.y + b.y) / 2;
+		this.lastAngle = Math.atan2(b.y - a.y, b.x - a.x);
+		this.twisted = 0;
+		this.twisting = false;
+	}
+	move(a, b) {
+		const angle = Math.atan2(b.y - a.y, b.x - a.x);
+		const turn = MathUtils.euclideanModulo(angle - this.lastAngle + Math.PI, 2 * Math.PI) - Math.PI;
+		this.lastAngle = angle;
+		const midY = (a.y + b.y) / 2;
+		let down = midY - this.lastMidY;
+		this.lastMidY = midY;
+		this.twisted += turn;
+		if (this.mode === "undecided") {
+			this.mode = this.decide(a, b);
+			if (this.mode === "tilt") down = midY - (this.a0.y + this.b0.y) / 2;
+		}
+		switch (this.mode) {
+			case "undecided": return {
+				mode: "undecided",
+				down: 0,
+				twist: 0
+			};
+			case "tilt": return {
+				mode: "tilt",
+				down,
+				twist: 0
+			};
+			case "map": {
+				const engaged = this.twisting;
+				this.twisting ||= Math.abs(this.twisted) > TWIST_ENGAGE;
+				return {
+					mode: "map",
+					down: 0,
+					twist: engaged ? turn : 0
+				};
+			}
+		}
+	}
+	decide(a, b) {
+		const ax = a.x - this.a0.x;
+		const ay = a.y - this.a0.y;
+		const bx = b.x - this.b0.x;
+		const by = b.y - this.b0.y;
+		const aTravel = Math.hypot(ax, ay);
+		const bTravel = Math.hypot(bx, by);
+		if (Math.max(aTravel, bTravel) < (aTravel > 0 && bTravel > 0 ? 10 : TWO_FINGER_ALONE)) return "undecided";
+		const sideBySide = Math.abs(this.b0.y - this.a0.y) <= Math.abs(this.b0.x - this.a0.x) * TILT_MAX_SPREAD_SLOPE;
+		const vertical = Math.abs(ax) <= Math.abs(ay) * TILT_MAX_SIDEWAYS && Math.abs(bx) <= Math.abs(by) * TILT_MAX_SIDEWAYS;
+		const together = Math.sign(ay) === Math.sign(by) && Math.min(aTravel, bTravel) >= Math.max(aTravel, bTravel) * TILT_MIN_TOGETHER;
+		return sideBySide && vertical && together ? "tilt" : "map";
+	}
+};
+
 // src/lib/scene/camera/look-controls.ts
 var MAX_TILT = MathUtils.degToRad(80);
 var LOOK_NONE_HEIGHT = 1;
@@ -22411,14 +22516,15 @@ var _turnBack = new Quaternion();
 var _was = new Quaternion();
 var _pivotGround = new Vector3();
 var _look = new Matrix4();
+var GLIDE_DONE = 1e-5;
 var ANCHOR_PASSES = 3;
 var SIN_MIN_ANCHOR_ELEVATION = Math.sin(MathUtils.degToRad(20));
 var GROUND_PASSES = 3;
+var PIVOT_REFINE = 1e-7;
 var orbitHandlers = OrbitControls.prototype;
 var LookOrbitControls = class extends OrbitControls {
 	canvas;
 	surfaceRadius;
-	standingHeight;
 	onTurnSettled;
 	heading = 0;
 	tilt = 0;
@@ -22426,6 +22532,7 @@ var LookOrbitControls = class extends OrbitControls {
 	orbitPos = new Vector3();
 	orbitQuat = new Quaternion();
 	pivotRadius = 0;
+	placedByName = false;
 	lastUp = new Vector3();
 	holdsNorth = false;
 	northTurning = false;
@@ -22436,16 +22543,22 @@ var LookOrbitControls = class extends OrbitControls {
 	dragPointer = null;
 	dragX = 0;
 	dragY = 0;
-	constructor(camera, canvas, surfaceRadius, standingHeight = () => null, onTurnSettled = () => {}) {
+	twoFinger = new TwoFingerGesture();
+	glideHeading = 0;
+	glideTilt = 0;
+	constructor(camera, canvas, surfaceRadius, onTurnSettled = () => {}) {
 		super(camera, canvas);
 		this.canvas = canvas;
 		this.surfaceRadius = surfaceRadius;
-		this.standingHeight = standingHeight;
 		this.onTurnSettled = onTurnSettled;
 		this.mouseButtons.MIDDLE = null;
-		this.addEventListener("start", () => this.pendingLook = null);
+		this.addEventListener("start", () => {
+			this.pendingLook = null;
+			this.placedByName = false;
+		});
 		canvas.addEventListener("pointerdown", this.onLookDown);
 		canvas.addEventListener("mousedown", this.blockMiddle);
+		canvas.addEventListener("pointerdown", this.onCatch);
 	}
 	get orbitPosition() {
 		return this.looking ? this.orbitPos : this.object.position;
@@ -22464,6 +22577,8 @@ var LookOrbitControls = class extends OrbitControls {
 		const cam = this.object;
 		this.looking = false;
 		this.pendingLook = null;
+		this.placedByName = false;
+		this.stopGlide();
 		if (tilt === 0 && heading === 0) return;
 		if (!this.groundKnown()) {
 			this.pendingLook = {
@@ -22484,6 +22599,7 @@ var LookOrbitControls = class extends OrbitControls {
 		this.heading = heading;
 		this.holdAngles(share);
 		this.looking = true;
+		this.placedByName = true;
 		this.place();
 	}
 	toOrbitAxes(x, y) {
@@ -22501,6 +22617,12 @@ var LookOrbitControls = class extends OrbitControls {
 	endLook() {
 		this.looking = false;
 		this.pendingLook = null;
+		this.placedByName = false;
+		this.stopGlide();
+	}
+	stopGlide() {
+		this.glideHeading = 0;
+		this.glideTilt = 0;
 	}
 	groundKnown() {
 		_n.subVectors(this.orbitPosition, this.target).normalize();
@@ -22530,22 +22652,28 @@ var LookOrbitControls = class extends OrbitControls {
 			this.placedQuat.copy(cam.quaternion);
 			return;
 		}
-		if (this.pivotRadius === 0) {
-			const was = _from$1.subVectors(this.placedPos, this.target);
-			const now = _hit.subVectors(cam.position, this.target);
-			const stretch = now.length() / was.length();
-			_turnBack.setFromUnitVectors(was.normalize(), now.normalize());
-			this.orbitPos.sub(this.target).applyQuaternion(_turnBack).multiplyScalar(stretch).add(this.target);
-			this.orbitQuat.premultiply(_turnBack);
-			this.place();
-			return;
-		}
 		const holds = this.holdsNorth;
 		_n.subVectors(this.orbitPos, this.target).normalize();
 		this.lookToward(_pivotGround.copy(_n).multiplyScalar(this.pivotRadius));
 		this.holdsNorth = holds;
 	}
 	update(deltaTime = null) {
+		const changed = this.step(deltaTime);
+		return this.glide() || changed;
+	}
+	glide() {
+		if (!this.glideHeading && !this.glideTilt) return false;
+		const f = this.dampingFactor;
+		this.turnNow(this.glideHeading * f, this.glideTilt * f);
+		this.glideHeading *= 1 - f;
+		this.glideTilt *= 1 - f;
+		if (Math.abs(this.glideHeading) < GLIDE_DONE && Math.abs(this.glideTilt) < GLIDE_DONE) {
+			this.stopGlide();
+			this.onTurnSettled();
+		}
+		return true;
+	}
+	step(deltaTime) {
 		if (!this.looking) {
 			const changed = super.update(deltaTime);
 			if (this.pendingLook && this.groundKnown()) this.setLook(this.pendingLook);
@@ -22554,14 +22682,19 @@ var LookOrbitControls = class extends OrbitControls {
 		const cam = this.object;
 		if (!cam.position.equals(this.placedPos) || !cam.quaternion.equals(this.placedQuat)) {
 			this.looking = false;
+			this.stopGlide();
 			return super.update(deltaTime);
 		}
+		if (!this.followGround()) return super.update(deltaTime);
 		cam.position.copy(this.orbitPos);
 		cam.quaternion.copy(this.orbitQuat);
 		_was.copy(this.orbitQuat);
 		const changed = super.update(deltaTime);
 		const moved = cam.position.distanceToSquared(this.orbitPos) > this.orbitPos.lengthSq() * 1e-20;
-		if (moved) this.orbitMoved = true;
+		if (moved) {
+			this.orbitMoved = true;
+			this.placedByName = false;
+		}
 		this.orbitPos.copy(cam.position);
 		this.orbitQuat.copy(cam.quaternion);
 		if (moved) this.samplePivot();
@@ -22586,6 +22719,7 @@ var LookOrbitControls = class extends OrbitControls {
 		super.dispose();
 		this.canvas.removeEventListener("pointerdown", this.onLookDown);
 		this.canvas.removeEventListener("mousedown", this.blockMiddle);
+		this.canvas.removeEventListener("pointerdown", this.onCatch);
 		this.endLookDrag();
 	}
 	_handleMouseDownRotate(event) {
@@ -22600,6 +22734,28 @@ var LookOrbitControls = class extends OrbitControls {
 	_handleTouchMoveRotate(event) {
 		orbitHandlers._handleTouchMoveRotate.call(this, this.rotatedTouch(event));
 	}
+	_handleTouchStartDollyPan(event) {
+		orbitHandlers._handleTouchStartDollyPan.call(this, event);
+		const [a, b] = this.fingers();
+		this.twoFinger.begin(a, b, this.enableRotate && this.lookShare() > 0);
+	}
+	_handleTouchMoveDollyPan(event) {
+		const [a, b] = this.fingers();
+		const step = this.twoFinger.move(a, b);
+		if (step.mode === "undecided") return;
+		const rate = TURN_PER_HEIGHT / (this.canvas.clientHeight || 1);
+		if (step.mode === "tilt") {
+			if (this.enableRotate) this.turn(0, -step.down * rate);
+			return;
+		}
+		orbitHandlers._handleTouchMoveDollyPan.call(this, event);
+		if (step.twist !== 0 && this.enableRotate) this.turn(step.twist, 0);
+	}
+	fingers() {
+		const touch = this;
+		const [a, b] = touch._pointers;
+		return [touch._pointerPositions[a], touch._pointerPositions[b]];
+	}
 	_handleMouseWheel(event) {
 		const anchored = this.enableRotate && this.groundAt(event.clientX, event.clientY, _anchor) && -_ray.dot(_hit.copy(_anchor).normalize()) > SIN_MIN_ANCHOR_ELEVATION;
 		orbitHandlers._handleMouseWheel.call(this, event);
@@ -22664,6 +22820,7 @@ var LookOrbitControls = class extends OrbitControls {
 		const level = offset.addScaledVector(n, -offset.dot(n));
 		this.heading = Math.atan2(_ray.crossVectors(down, level).dot(n), down.dot(level));
 		this.holdsNorth = false;
+		this.placedByName = false;
 		this.looking = true;
 		if (!this.holdAngles(this.lookShare())) {
 			this.looking = false;
@@ -22712,7 +22869,15 @@ var LookOrbitControls = class extends OrbitControls {
 			pageY: 2 * y - other.y
 		};
 	}
-	turn(dx, dy) {
+	turn(heading, tilt) {
+		if (!this.enableDamping) {
+			this.turnNow(heading, tilt);
+			return;
+		}
+		this.glideHeading += heading;
+		this.glideTilt += tilt;
+	}
+	turnNow(heading, tilt) {
 		const cam = this.object;
 		const share = this.lookShare();
 		if (share === 0) return;
@@ -22726,9 +22891,8 @@ var LookOrbitControls = class extends OrbitControls {
 			this.lastUp.copy(cam.up);
 		}
 		this.holdsNorth = false;
-		const rate = TURN_PER_HEIGHT / (this.canvas.clientHeight || 1);
-		this.heading -= dx * rate;
-		this.tilt = Math.max(0, this.tilt - dy * rate);
+		this.heading += heading;
+		this.tilt = Math.max(0, this.tilt + tilt);
 		this.holdAngles(share);
 		this.place();
 	}
@@ -22736,10 +22900,7 @@ var LookOrbitControls = class extends OrbitControls {
 		_n.subVectors(this.orbitPosition, this.target);
 		const range = _n.length();
 		const ground = range > 0 ? this.surfaceRadius(_n.divideScalar(range)) : null;
-		if (ground === null) return 0;
-		if (ground > 0) return this.shareAt((range - ground) / ground);
-		const height = this.standingHeight();
-		return height === null ? 0 : this.shareAt(height);
+		return ground ? this.shareAt((range - ground) / ground) : 0;
 	}
 	shareAt(height) {
 		const t = MathUtils.clamp((1 - height) / .5, 0, 1);
@@ -22751,6 +22912,22 @@ var LookOrbitControls = class extends OrbitControls {
 		this.heading = MathUtils.clamp(this.heading, -Math.PI * share, Math.PI * share);
 		return share > 0;
 	}
+	followGround() {
+		_n.subVectors(this.orbitPos, this.target);
+		const range = _n.length();
+		const ground = range > 0 ? this.surfaceRadius(_n.divideScalar(range)) : null;
+		if (ground === null) return true;
+		const pivot = Math.min(ground, range);
+		if (Math.abs(pivot - this.pivotRadius) <= ground * PIVOT_REFINE) return true;
+		if (this.placedByName) {
+			this.pivotRadius = pivot;
+			return true;
+		}
+		const holds = this.holdsNorth;
+		this.lookToward(_pivotGround.copy(_n).multiplyScalar(ground));
+		this.holdsNorth = holds;
+		return this.looking;
+	}
 	samplePivot() {
 		_n.subVectors(this.orbitPos, this.target);
 		const range = _n.length();
@@ -22772,6 +22949,11 @@ var LookOrbitControls = class extends OrbitControls {
 		this.placedPos.copy(cam.position);
 		this.placedQuat.copy(cam.quaternion);
 	}
+	onCatch = () => {
+		if (!this.glideHeading && !this.glideTilt) return;
+		this.stopGlide();
+		this.onTurnSettled();
+	};
 	blockMiddle = (event) => {
 		if (event.button === 1) event.preventDefault();
 	};
@@ -22796,7 +22978,8 @@ var LookOrbitControls = class extends OrbitControls {
 		const dy = event.clientY - this.dragY;
 		this.dragX = event.clientX;
 		this.dragY = event.clientY;
-		if (dx !== 0 || dy !== 0) this.turn(dx, dy);
+		const rate = TURN_PER_HEIGHT / (this.canvas.clientHeight || 1);
+		if (dx !== 0 || dy !== 0) this.turn(-dx * rate, -dy * rate);
 	};
 	onLookUp = (event) => {
 		if (event.pointerId !== this.dragPointer) return;
@@ -22815,35 +22998,42 @@ var LookOrbitControls = class extends OrbitControls {
 // src/lib/scene/framing.ts
 var DEFAULT_FOCUS_ID = EARTH_ID;
 
-// src/lib/scene/focus/feature-focus.ts
-function featureBodyId(hostId, featureId) {
-	return `feature:${hostId}:${featureId}`;
-}
-function makeFeatureBody(anchor, name) {
-	return {
-		data: {
-			id: featureBodyId(anchor.hostId, anchor.featureId),
-			name,
-			objectType: ObjectType.SURFACE_FEATURE,
-			parentId: anchor.hostId,
-			radiusKm: NaN,
-			hasLocalized: false,
-			a: 0,
-			e: 0,
-			i: 0,
-			om: 0,
-			w: 0,
-			ma: 0,
-			n: 0,
-			epoch: 0,
-			validityStart: -Infinity,
-			validityEnd: Infinity,
-			orbitalSource: OrbitalSource.UNKNOWN
-		},
-		position: null,
-		orbitCenterId: anchor.hostId,
-		featureAnchor: anchor
-	};
+// src/lib/scene/position/feature-seat.ts
+var DEG2RAD$3 = Math.PI / 180;
+var _fixed = new Vector3();
+var _addend = new Vector3();
+function featureSeat(anchor, host, hostPos, hostBo, jd) {
+	_addend.set(0, 0, 0);
+	const idx = hostBo?.nomenclatureActiveIndex ?? -1;
+	const label = idx >= 0 ? hostBo?.nomenclatureLabels?.[idx] ?? null : null;
+	if (label && label.element.dataset.featureId === String(anchor.featureId)) {
+		const modelAnchor = hostBo?.nomenclatureAnchor;
+		if (modelAnchor) {
+			_fixed.copy(label.position);
+			_addend.copy(modelAnchor.position);
+		} else {
+			_fixed.copy(label.position);
+			if (hostBo?.mesh) _fixed.multiply(hostBo.mesh.scale);
+		}
+	} else {
+		const radiusKm = host.data.radiusKm;
+		const latR = anchor.lat * DEG2RAD$3;
+		const lngR = anchor.lon * DEG2RAD$3;
+		const seat = host.orientation && Number.isFinite(radiusKm) && radiusKm > 0 ? renderedSeatAt(hostBo, host.data.id, radiusKm, latR, lngR) : null;
+		if (seat) _fixed.set(seat.pointKm[0], seat.pointKm[1], seat.pointKm[2]);
+		else {
+			const r = Number.isFinite(radiusKm) && radiusKm > 0 ? radiusKm : 0;
+			const [nx, ny, nz] = bodyFixedUnit(latR, lngR);
+			_fixed.set(r * nx, r * ny, r * nz);
+		}
+		_fixed.multiplyScalar(kmToScene(1));
+	}
+	if (host.orientation) _fixed.applyQuaternion(bodyQuaternion(host.orientation, jd, host.nutPrec));
+	return [
+		hostPos[0] + _fixed.x + _addend.x,
+		hostPos[1] + _fixed.y + _addend.y,
+		hostPos[2] + _fixed.z + _addend.z
+	];
 }
 
 // src/lib/scene/label/throttled-renderer.ts
@@ -23045,6 +23235,7 @@ function makeTrailMaterial(color, brightness = TRAIL_DIM) {
 }
 var TRIM_DEPTH = CAMERA_NEAR / 2;
 var TRIM_SHARE = 1e-6;
+var MITER_LIMIT = 4;
 function makeFatTrailMaterial(color, lineWidth, brightness = TRAIL_DIM, dash) {
 	return new ShaderMaterial({
 		defines: dash ? { DASHED: "" } : {},
@@ -23070,9 +23261,11 @@ function makeFatTrailMaterial(color, lineWidth, brightness = TRAIL_DIM, dash) {
 			uniform float uLineWidth;
 			uniform vec2 uResolution;
 			uniform vec2 uTrim;
-			attribute vec2 corner;
+			attribute vec3 corner;
+			attribute vec3 segPrev;
 			attribute vec3 segStart;
 			attribute vec3 segEnd;
+			attribute vec3 segNext;
 			attribute vec2 alphaStart;
 			attribute vec2 alphaEnd;
 			varying float vAlpha;
@@ -23082,9 +23275,78 @@ function makeFatTrailMaterial(color, lineWidth, brightness = TRAIL_DIM, dash) {
 			varying float vDistW;
 			varying float vW;
 			#endif
+			vec3 toView(vec3 point) {
+				return mat3(viewMatrix) * (point + uCenterOffset);
+			}
+			vec2 toPx(vec3 view) {
+				vec4 clip = projectionMatrix * vec4(view, 1.0);
+				return clip.xy / clip.w * uResolution * 0.5;
+			}
+			// The unit direction on screen from one point to another, with the
+			// distance in pixels in z.
+			vec3 heading(vec2 from, vec2 to) {
+				vec2 d = to - from;
+				// Scaled before normalising: an end cut just ahead of the camera can
+				// sit 1e20 px off screen, and its square overflows a float.
+				float span = max(abs(d.x), abs(d.y));
+				// Seen end on: any direction will do.
+				if (span < 1e-4) return vec3(1.0, 0.0, 0.0);
+				vec2 u = d / span;
+				return vec3(normalize(u), span * length(u));
+			}
+			// The screen headings into and out of the middle of three points. Both
+			// segments at a turn call this with the same points, so they place
+			// their shared corners alike.
+			void turnAt(vec3 before, vec3 at, vec3 after, out vec3 din, out vec3 dout) {
+				vec2 p = toPx(toView(at));
+				din = heading(toPx(toView(before)), p);
+				dout = heading(p, toPx(toView(after)));
+			}
+			// A mitred corner: its offset, and how far along the quad's own
+			// segment it moves.
+			vec3 mitredAt(vec2 offset, vec2 own) {
+				return vec3(offset, dot(offset, own));
+			}
+			// This corner's offset in pixels from the point where the line turns
+			// from din to dout, and in z how far it moves along the quad's own
+			// segment, own. The quads either side compute it from the same three
+			// points, so they meet exactly. A square end, the fallback, moves
+			// nothing along: exactly nothing, since a dash can end right there.
+			vec3 cornerAt(vec3 din, vec3 dout, vec2 own, bool joins) {
+				float h = uLineWidth * 0.5;
+				vec3 square = vec3(vec2(-own.y, own.x) * corner.x * h, 0.0);
+				bool bevel = corner.z > 0.5;
+				if (!joins || din.z == 0.0 || dout.z == 0.0) return bevel ? vec3(0.0) : square;
+				float inner = din.x * dout.y - din.y * dout.x >= 0.0 ? 1.0 : -1.0;
+				vec2 bisector = din.xy + dout.xy;
+				// The cosine of half the turn.
+				float cosHalf = length(bisector) * 0.5;
+				float safeCos = max(cosHalf, 1e-6);
+				vec2 mitre = vec2(-bisector.y, bisector.x) / (2.0 * safeCos) * (h / safeCos);
+				// How far along each segment the inner corner moves. Past half the
+				// shorter segment it would cross that segment's other corner, and
+				// square ends overlap instead, as with no join.
+				float reach = h * sqrt(max(1.0 - cosHalf * cosHalf, 0.0)) / safeCos;
+				bool fits = cosHalf > 1e-3 && reach <= 0.5 * min(din.z, dout.z);
+				bool mitred = fits && cosHalf * ${MITER_LIMIT.toFixed(1)} >= 1.0;
+				if (bevel) {
+					// Each segment's square outer corner and the inner corner they
+					// share, at the turn's own distance along the line. Flat under a
+					// mitre, which covers the turn by itself, and beside a segment
+					// shorter than the line is wide, where it could reach into the
+					// quad past that segment.
+					if (mitred || (!fits && min(din.z, dout.z) < uLineWidth)) return vec3(0.0);
+					if (corner.z < 1.5) return vec3(-inner * vec2(-din.y, din.x) * h, 0.0);
+					if (corner.z < 2.5) return vec3(-inner * vec2(-dout.y, dout.x) * h, 0.0);
+					return vec3(fits ? inner * mitre : vec2(0.0), 0.0);
+				}
+				if (!fits) return square;
+				if (corner.x == inner) return mitredAt(inner * mitre, own);
+				return mitred ? mitredAt(-inner * mitre, own) : square;
+			}
 			void main() {
-				vec3 a = mat3(viewMatrix) * (segStart + uCenterOffset);
-				vec3 b = mat3(viewMatrix) * (segEnd + uCenterOffset);
+				vec3 a = toView(segStart);
+				vec3 b = toView(segEnd);
 				float aheadA = -a.z;
 				float aheadB = -b.z;
 				float front = max(aheadA, aheadB);
@@ -23106,28 +23368,32 @@ function makeFatTrailMaterial(color, lineWidth, brightness = TRAIL_DIM, dash) {
 				float cutB = aheadB < uTrim.x ? (cut - aheadB) / (aheadA - aheadB) : 0.0;
 				if (cutA > 0.0) a = vec3(mix(a.xy, b.xy, cutA), -cut);
 				if (cutB > 0.0) b = vec3(mix(b.xy, a.xy, cutB), -cut);
-				vec4 clipA = projectionMatrix * vec4(a, 1.0);
-				vec4 clipB = projectionMatrix * vec4(b, 1.0);
-				vec2 ndcA = clipA.xy / clipA.w;
-				vec2 ndcB = clipB.xy / clipB.w;
-				vec2 dirPx = (ndcB - ndcA) * uResolution * 0.5;
-				// Scaled before normalising: an end cut just ahead of the camera can
-				// sit 1e20 px off screen, and its square overflows a float.
-				float span = max(abs(dirPx.x), abs(dirPx.y));
-				// A segment seen end on: any perpendicular will do.
-				vec2 dirN = span < 1e-4 ? vec2(1.0, 0.0) : normalize(dirPx / span);
-				vec2 offsetNDC = vec2(-dirN.y, dirN.x) * corner.x * uLineWidth / uResolution;
 				bool atEnd = corner.y > 0.5;
-				vec4 clip = atEnd ? clipB : clipA;
-				vec2 ndc = atEnd ? ndcB : ndcA;
-				gl_Position = vec4((ndc + offsetNDC) * clip.w, clip.zw);
+				vec3 own = heading(toPx(a), toPx(b));
+				// The turn this corner sits on, read in the line's direction: only
+				// with all three of its points ahead of the camera, so that both
+				// segments at the turn agree on it.
+				bool joins = cutA == 0.0 && cutB == 0.0 && -toView(atEnd ? segNext : segPrev).z >= uTrim.x;
+				vec3 din = own;
+				vec3 dout = own;
+				if (joins) {
+					if (atEnd) turnAt(segStart, segEnd, segNext, din, dout);
+					else turnAt(segPrev, segStart, segEnd, din, dout);
+					own = atEnd ? din : dout;
+				}
+				vec3 offset = cornerAt(din, dout, own.xy, joins);
+				vec4 clip = projectionMatrix * vec4(atEnd ? b : a, 1.0);
+				gl_Position = vec4((clip.xy / clip.w + offset.xy * 2.0 / uResolution) * clip.w, clip.zw);
 				vec2 alphas = atEnd ? mix(alphaEnd, alphaStart, cutB) : mix(alphaStart, alphaEnd, cutA);
 				vAlpha = mix(alphas.x, alphas.y, uShowFull);
 				#ifdef DASHED
 				// Carried times w and divided back out per fragment, which undoes
 				// the perspective a varying is interpolated with: the dashes are
-				// even on screen however much nearer one end is.
+				// even on screen however much nearer one end is. A corner a mitre
+				// moves along the segment counts on by as much, so dash ends stay
+				// square to the line.
 				float dist = atEnd ? mix(distEnd, distStart, cutB) : mix(distStart, distEnd, cutA);
+				dist += offset.z;
 				vDistW = dist * clip.w;
 				vW = clip.w;
 				#endif
@@ -25015,7 +25281,7 @@ function clampCameraOutsideBody(camera, body, focusTruePos, surface, clearanceKm
 	const dist = Math.hypot(dx, dy, dz);
 	if (surface?.seated) {
 		if (dist < 1e-9) {
-			camera.position.set(cx, cy + focusDist + kmToScene(LANDED_KEEP_AWAY_KM), cz);
+			camera.position.set(cx, cy + kmToScene(radiusKm + LANDED_KEEP_AWAY_KM), cz);
 			return;
 		}
 		const hh = Math.tan(camera.fov * Math.PI / 360) * camera.near;
@@ -25060,7 +25326,7 @@ function clampCameraOutsideBody(camera, body, focusTruePos, surface, clearanceKm
 				_dirBF.y,
 				_dirBF.z
 			]);
-			const wall = (sKm !== null ? kmToScene(sKm) : focusDist) + kmToScene(LANDED_KEEP_AWAY_KM);
+			const wall = kmToScene((sKm ?? radiusKm) + LANDED_KEEP_AWAY_KM);
 			if (wall - r > lift) lift = wall - r;
 		}
 		if (lift <= 0) return;
@@ -25284,7 +25550,6 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 	screenOccluders.length = occluderCount;
 	const focusedSystemId = ctx.visibility.focusedSystemId;
 	let newlyShownLabel = false;
-	const nomFocusedBodyId = focusedBodyId ? nomenclatureBodyId(ctx.getBody(focusedBodyId), bodyObjects) : void 0;
 	for (const bo of bodyObjects.values()) {
 		const { body, group, trail } = bo;
 		const dist = bo.cachedDist;
@@ -25292,7 +25557,7 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 		const drawn = isDrawn(bo);
 		bo.root.visible = drawn;
 		let showLabel;
-		const isFocused = body.data.id === focusedBodyId;
+		const isFocused = ctx.visibility.inFocus(body.data.id);
 		const isSystemRoot = focusedSystemId !== null && body.data.id === focusedSystemId;
 		const centreShare = ctx.visibility.systemCentres.get(body.data.id);
 		const isHeldStar = isFocused || ctx.visibility.isPinned(body.data.id) || centreShare === 1;
@@ -25401,7 +25666,7 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 		if (bo.label) fadeLabel(bo.label, labelShare);
 		if (bo.planetDot) bo.planetDot.material.opacity = labelShare;
 		const nomScreenR = bo.radiusScene > 0 ? bo.radiusScene / dist * projScale : 0;
-		const isNomFocused = showNomenclature && body.data.id === nomFocusedBodyId;
+		const isNomFocused = showNomenclature && body.data.id === focusedBodyId;
 		updateNomenclatureVisibility(bo, isNomFocused, nomScreenR, projScale, camera, screenW, screenH);
 	}
 	if (screenOccluders.length > 0) {
@@ -25413,7 +25678,7 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 			if (isScreenOccluded(_occlusionRect.x, _occlusionRect.y, bo.cachedDist, id, screenOccluders, id === focusedBodyId ? focusedPrimaryId : null)) bo.label.visible = false;
 		}
 	}
-	const groundBo = nomFocusedBodyId ? bodyObjects.get(nomFocusedBodyId) : void 0;
+	const groundBo = focusedBodyId ? bodyObjects.get(focusedBodyId) : void 0;
 	const ground = groundBo?.body.position;
 	if (groundBo && ground) {
 		const relief = reliefRadiiKm(groundBo);
@@ -25424,17 +25689,17 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 		for (const bo of bodyObjects.values()) {
 			const at = bo.body.position;
 			const id = bo.body.data.id;
-			if (!bo.label?.visible || !at || id === nomFocusedBodyId || id === focusedBodyId) continue;
+			if (!bo.label?.visible || !at || ctx.visibility.inFocus(id)) continue;
 			if (behindGround(at[0] - ground[0], at[1] - ground[1], at[2] - ground[2], cx, cy, cz, top)) bo.label.visible = false;
 		}
 	}
 	if (forceCull || newlyShownLabel || ++cullFrameCounter >= 3) {
 		cullFrameCounter = 0;
-		cullOverlappingLabels(bodyObjects, screenW, screenH, camera, focusedBodyId, ctx, hoveredBodyIds, screenOccluders, focusTruePos);
+		cullOverlappingLabels(bodyObjects, screenW, screenH, camera, ctx, hoveredBodyIds, screenOccluders, focusTruePos);
 	}
 	refreshVisibleBodyLabelRects(bodyObjects, screenW, screenH, camera, focusTruePos, sceneSettings().showConstellations);
-	if (nomFocusedBodyId) {
-		const focusedBo = bodyObjects.get(nomFocusedBodyId);
+	if (focusedBodyId) {
+		const focusedBo = bodyObjects.get(focusedBodyId);
 		if (focusedBo) cullOverlappingNomenclatureLabels(focusedBo);
 	}
 	for (const bo of bodyObjects.values()) {
@@ -25442,7 +25707,7 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 		if (!line?.visible) continue;
 		const mat = line.material;
 		mat.uniforms.uCenterOffset.value.set(-camera.position.x, -camera.position.y, -camera.position.z);
-		const isFocused = bo.body.data.id === focusedBodyId;
+		const isFocused = ctx.visibility.inFocus(bo.body.data.id);
 		const isHovered = hoveredBodyIds.has(bo.body.data.id);
 		const share = ctx.visibility.systemShareOf(bo.body) * (line.userData.zoneShare ?? 1) * (line.userData.thresholdShare ?? 1) * (line.userData.haloShare ?? 1);
 		mat.uniforms.uAlphaMultiplier.value = (isHovered ? 2 : isFocused ? 1.75 : 1) * share;
@@ -29525,13 +29790,9 @@ var GALACTIC_NORTH_SCENE = (() => {
 function galacticNorthVector(out) {
 	return (out ?? new Vector3()).copy(GALACTIC_NORTH_SCENE);
 }
-function bodyNorthVector(body, jd, out, landed = false) {
+function bodyNorthVector(body, jd, out) {
 	const target = out ?? new Vector3();
 	if (!body.orientation) {
-		if (landed && body.orbitCenter && body.position) {
-			target.set(body.position[0] - body.orbitCenter[0], body.position[1] - body.orbitCenter[1], body.position[2] - body.orbitCenter[2]);
-			if (target.lengthSq() > 1e-20) return target.normalize();
-		}
 		target.copy(SCENE_UP);
 		if (body.modelBaseFrame) target.applyQuaternion(body.modelBaseFrame).normalize();
 		return target;
@@ -29545,7 +29806,6 @@ var CameraUpController = class {
 	camera;
 	controls;
 	ctx;
-	isLanded;
 	refId = null;
 	startVec = new Vector3(0, 1, 0);
 	targetVec = new Vector3(0, 1, 0);
@@ -29556,11 +29816,10 @@ var CameraUpController = class {
 	plane = null;
 	_quatA = new Quaternion();
 	_quatB = new Quaternion();
-	constructor(camera, controls, ctx, isLanded) {
+	constructor(camera, controls, ctx) {
 		this.camera = camera;
 		this.controls = controls;
 		this.ctx = ctx;
-		this.isLanded = isLanded;
 	}
 	setNorthReference(id) {
 		if (id === this.refId) return;
@@ -29579,10 +29838,8 @@ var CameraUpController = class {
 			else this.targetVec.copy(SCENE_UP);
 		} else {
 			const refBody = this.refId ? this.ctx.getBody(this.refId) : void 0;
-			if (refBody) {
-				const landed = !!refBody.featureAnchor || this.isLanded(refBody.data.id);
-				bodyNorthVector(refBody, jd, this.targetVec, landed);
-			} else this.targetVec.copy(SCENE_UP);
+			if (refBody) bodyNorthVector(refBody, jd, this.targetVec);
+			else this.targetVec.copy(SCENE_UP);
 		}
 		if (this.needsDurationCalc) {
 			this.needsDurationCalc = false;
@@ -30323,46 +30580,71 @@ function orbitalElementsToCurve(el, numPoints = 512) {
 
 // src/lib/scene/objects/trail/geometry.ts
 var TRAIL_RENDER_ORDER = 3;
-var QUAD_CORNERS = [
+var CORNERS = [
 	-1,
 	0,
+	0,
 	1,
 	0,
+	0,
 	-1,
 	1,
+	0,
 	1,
-	1
+	1,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	2,
+	0,
+	0,
+	3
 ];
-var QUAD_INDICES = [
+var CORNER_INDICES = [
 	0,
 	1,
 	2,
 	2,
 	1,
-	3
+	3,
+	4,
+	5,
+	6
 ];
 function instanced(geometry, name) {
 	return geometry.getAttribute(name).data;
 }
-function setSegmentAttributes(geometry, names, capacity, stride) {
-	const buffer = new InstancedInterleavedBuffer(new Float32Array(capacity * stride), stride);
-	geometry.setAttribute(names[0], new InterleavedBufferAttribute(buffer, stride, 0));
-	geometry.setAttribute(names[1], new InterleavedBufferAttribute(buffer, stride, stride));
+function setPointAttributes(geometry, names, count, stride) {
+	const buffer = new InstancedInterleavedBuffer(new Float32Array(count * stride), stride);
+	names.forEach((name, i) => geometry.setAttribute(name, new InterleavedBufferAttribute(buffer, stride, i * stride)));
 }
 function makeFatTrailGeometry(capacity) {
 	const geometry = new InstancedBufferGeometry();
-	geometry.setAttribute("corner", new Float32BufferAttribute(QUAD_CORNERS, 2));
-	geometry.setIndex(QUAD_INDICES);
-	setSegmentAttributes(geometry, ["segStart", "segEnd"], capacity, 3);
-	setSegmentAttributes(geometry, ["alphaStart", "alphaEnd"], capacity, 2);
+	geometry.setAttribute("corner", new Float32BufferAttribute(CORNERS, 3));
+	geometry.setIndex(CORNER_INDICES);
+	setPointAttributes(geometry, [
+		"segPrev",
+		"segStart",
+		"segEnd",
+		"segNext"
+	], capacity + 2, 3);
+	setPointAttributes(geometry, ["alphaStart", "alphaEnd"], capacity, 2);
 	geometry.instanceCount = 0;
 	return geometry;
 }
 function writeFatTrailVertices(geometry, posSrc, trailSrc, fullSrc, n) {
 	const points = instanced(geometry, "segStart");
 	const alphas = instanced(geometry, "alphaStart");
-	const m = Math.min(n, points.count);
-	points.array.set(posSrc.subarray(0, m * 3));
+	const m = Math.min(n, alphas.count);
+	const arr = points.array;
+	arr.set(posSrc.subarray(0, m * 3), 3);
+	const last = (m - 1) * 3;
+	const closed = m > 2 && posSrc[0] === posSrc[last] && posSrc[1] === posSrc[last + 1] && posSrc[2] === posSrc[last + 2];
+	arr.copyWithin(0, closed ? last : 3, closed ? last + 3 : 6);
+	arr.copyWithin((m + 1) * 3, closed ? 6 : m * 3, closed ? 9 : (m + 1) * 3);
 	const alphaArr = alphas.array;
 	for (let i = 0; i < m; i++) {
 		alphaArr[2 * i] = trailSrc[i];
@@ -30371,7 +30653,7 @@ function writeFatTrailVertices(geometry, posSrc, trailSrc, fullSrc, n) {
 	points.needsUpdate = true;
 	alphas.needsUpdate = true;
 	geometry.instanceCount = Math.max(0, m - 1);
-	geometry.setDrawRange(0, QUAD_INDICES.length);
+	geometry.setDrawRange(0, CORNER_INDICES.length);
 }
 function makeEmptyTrail() {
 	const geometry = new BufferGeometry();
@@ -30401,7 +30683,7 @@ function writeLineDistances(geometry, src, n) {
 }
 function buildFatLineFromThin(capacity, posArr, trailAlphas, fullAlphas, total, color, lineWidth, brightness, dash) {
 	const geometry = makeFatTrailGeometry(capacity);
-	if (dash) setSegmentAttributes(geometry, ["distStart", "distEnd"], capacity, 1);
+	if (dash) setPointAttributes(geometry, ["distStart", "distEnd"], capacity, 1);
 	writeFatTrailVertices(geometry, posArr, trailAlphas, fullAlphas, total);
 	const mesh = new Mesh(geometry, makeFatTrailMaterial(color, lineWidth, brightness, dash));
 	mesh.matrixAutoUpdate = false;
@@ -30768,7 +31050,7 @@ var SystemDataLoader = class {
 };
 
 // src/lib/scene/debug/skybox-adjust.ts
-var DEG2RAD$3 = Math.PI / 180;
+var DEG2RAD$2 = Math.PI / 180;
 var SkyboxAdjuster = class {
 	scene;
 	adjust = {
@@ -30792,15 +31074,15 @@ var SkyboxAdjuster = class {
 		this.adjust.rxDeg = rxDeg;
 		this.adjust.ryDeg = ryDeg;
 		this.adjust.rzDeg = rzDeg;
-		this._adjustQ.setFromAxisAngle(this._axisX, rxDeg * DEG2RAD$3).premultiply(this._tmpQ.setFromAxisAngle(this._axisY, ryDeg * DEG2RAD$3)).premultiply(this._tmpQ.setFromAxisAngle(this._axisZ, rzDeg * DEG2RAD$3));
+		this._adjustQ.setFromAxisAngle(this._axisX, rxDeg * DEG2RAD$2).premultiply(this._tmpQ.setFromAxisAngle(this._axisY, ryDeg * DEG2RAD$2)).premultiply(this._tmpQ.setFromAxisAngle(this._axisZ, rzDeg * DEG2RAD$2));
 		this._q.copy(SKYBOX_BASE_ROTATION).multiply(this._adjustQ);
 		this.scene.backgroundRotation.setFromQuaternion(this._q);
 	}
 };
 
 // src/lib/scene/objects/sky/debug-markers.ts
-var DEG2RAD$2 = Math.PI / 180;
-var OBL_RAD = EARTH_OBLIQUITY_DEG * DEG2RAD$2;
+var DEG2RAD$1 = Math.PI / 180;
+var OBL_RAD = EARTH_OBLIQUITY_DEG * DEG2RAD$1;
 var COS_OBL = Math.cos(OBL_RAD);
 var SIN_OBL = Math.sin(OBL_RAD);
 var SKY_MARKER_RADIUS = 5e3;
@@ -30916,8 +31198,8 @@ var REFERENCE_CIRCLES = [
 	}
 ];
 function eqToScene(raDeg, decDeg, out) {
-	const ra = raDeg * DEG2RAD$2;
-	const dec = decDeg * DEG2RAD$2;
+	const ra = raDeg * DEG2RAD$1;
+	const dec = decDeg * DEG2RAD$1;
 	const cd = Math.cos(dec);
 	const xEq = cd * Math.cos(ra);
 	const yEq = cd * Math.sin(ra);
@@ -32600,16 +32882,16 @@ function between(points, jds, jd, from = 0, to = points.length) {
 }
 
 // src/lib/math/travel/state.ts
-var DEG2RAD$1 = Math.PI / 180;
-var COS_EPS = Math.cos(EARTH_OBLIQUITY_DEG * DEG2RAD$1);
-var SIN_EPS = Math.sin(EARTH_OBLIQUITY_DEG * DEG2RAD$1);
+var DEG2RAD = Math.PI / 180;
+var COS_EPS = Math.cos(EARTH_OBLIQUITY_DEG * DEG2RAD);
+var SIN_EPS = Math.sin(EARTH_OBLIQUITY_DEG * DEG2RAD);
 function planeRotation(w, i, om, equatorial) {
-	const cosW = Math.cos(w * DEG2RAD$1);
-	const sinW = Math.sin(w * DEG2RAD$1);
-	const cosI = Math.cos(i * DEG2RAD$1);
-	const sinI = Math.sin(i * DEG2RAD$1);
-	const cosOm = Math.cos(om * DEG2RAD$1);
-	const sinOm = Math.sin(om * DEG2RAD$1);
+	const cosW = Math.cos(w * DEG2RAD);
+	const sinW = Math.sin(w * DEG2RAD);
+	const cosI = Math.cos(i * DEG2RAD);
+	const sinI = Math.sin(i * DEG2RAD);
+	const cosOm = Math.cos(om * DEG2RAD);
+	const sinOm = Math.sin(om * DEG2RAD);
 	return {
 		m11: cosOm * cosW - sinOm * sinW * cosI,
 		m12: -cosOm * sinW - sinOm * cosW * cosI,
@@ -32659,10 +32941,10 @@ function elementsToState(el, jd) {
 	}
 	if (!isFinite(e) || !isFinite(ma)) return null;
 	const aKm = a * AU_KM;
-	const nRadPerSec = n * DEG2RAD$1 / SEC_PER_DAY$1;
+	const nRadPerSec = n * DEG2RAD / SEC_PER_DAY$1;
 	const mu = nRadPerSec * nRadPerSec * Math.abs(aKm) * Math.abs(aKm) * Math.abs(aKm);
 	if (!isFinite(mu) || mu <= 0) return null;
-	const M = (ma + n * (t - epoch)) * DEG2RAD$1;
+	const M = (ma + n * (t - epoch)) * DEG2RAD;
 	let nu;
 	let rKm;
 	if (e < 1 || a > 0) {
@@ -33658,65 +33940,6 @@ function addVec(out, a, b) {
 	out[2] = a[2] + b[2];
 }
 
-// src/lib/scene/position/feature-seat.ts
-var DEG2RAD = Math.PI / 180;
-var SEAT_GLIDE_TAU_MS = 120;
-var SEAT_GLIDE_SNAP_SQ = kmToScene(.001) ** 2;
-var glideState = /* @__PURE__ */ new WeakMap();
-var _fixed = new Vector3();
-var _addend = new Vector3();
-function glideVec(current, target, k) {
-	if (current.distanceToSquared(target) <= SEAT_GLIDE_SNAP_SQ) current.copy(target);
-	else current.lerp(target, k);
-}
-function seatFeatureBody(fb, host, hostPos, hostBo, jd) {
-	const anchor = fb.featureAnchor;
-	setOrbitCenter(fb, hostPos);
-	_addend.set(0, 0, 0);
-	const idx = hostBo?.nomenclatureActiveIndex ?? -1;
-	const label = idx >= 0 ? hostBo?.nomenclatureLabels?.[idx] ?? null : null;
-	if (label && label.element.dataset.featureId === String(anchor.featureId)) {
-		const modelAnchor = hostBo?.nomenclatureAnchor;
-		if (modelAnchor) {
-			_fixed.copy(label.position);
-			_addend.copy(modelAnchor.position);
-		} else {
-			_fixed.copy(label.position);
-			if (hostBo?.mesh) _fixed.multiply(hostBo.mesh.scale);
-		}
-	} else {
-		const radiusKm = host.data.radiusKm;
-		const latR = anchor.lat * DEG2RAD;
-		const lngR = anchor.lon * DEG2RAD;
-		const seat = host.orientation && Number.isFinite(radiusKm) && radiusKm > 0 ? renderedSeatAt(hostBo, host.data.id, radiusKm, latR, lngR) : null;
-		if (seat) _fixed.set(seat.pointKm[0], seat.pointKm[1], seat.pointKm[2]);
-		else {
-			const r = Number.isFinite(radiusKm) && radiusKm > 0 ? radiusKm : 0;
-			const [nx, ny, nz] = bodyFixedUnit(latR, lngR);
-			_fixed.set(r * nx, r * ny, r * nz);
-		}
-		_fixed.multiplyScalar(kmToScene(1));
-	}
-	const now = performance.now();
-	let st = glideState.get(fb);
-	if (!st) {
-		st = {
-			fixed: _fixed.clone(),
-			addend: _addend.clone(),
-			t: now
-		};
-		glideState.set(fb, st);
-	} else {
-		const k = 1 - Math.exp(-(now - st.t) / SEAT_GLIDE_TAU_MS);
-		st.t = now;
-		glideVec(st.fixed, _fixed, k);
-		glideVec(st.addend, _addend, k);
-	}
-	_fixed.copy(st.fixed);
-	if (host.orientation) _fixed.applyQuaternion(bodyQuaternion(host.orientation, jd, host.nutPrec));
-	return setPlaced(fb, hostPos[0] + _fixed.x + st.addend.x, hostPos[1] + _fixed.y + st.addend.y, hostPos[2] + _fixed.z + st.addend.z);
-}
-
 // src/lib/math/orbit/lagrange.ts
 var EARTH_SUN_MASS_RATIO = 30034e-10;
 var ALONG_MIN = .45;
@@ -34051,7 +34274,7 @@ var Placer = class {
 			return null;
 		}
 		this.settling.add(id);
-		const pos = isSurfaceFeature(body) ? this.seatFeature(body, jd) : isExtrasolar(body) && !body.data.parentId ? fixedPlace(body) : this.settle(body, jd);
+		const pos = isExtrasolar(body) && !body.data.parentId ? fixedPlace(body) : this.settle(body, jd);
 		this.settling.delete(id);
 		if (jd === this.passJd) this.settled.set(id, body);
 		return pos;
@@ -34060,13 +34283,6 @@ var Placer = class {
 		const why = (this.ctx.getBody(aboveId) ?? this.bodyObjects.get(aboveId)?.body)?.unplaced;
 		return why === "loading" || why === "never" ? why : "parent";
 	}
-	seatFeature(body, jd) {
-		const hostId = body.featureAnchor.hostId;
-		const host = this.ctx.getBody(hostId);
-		const hostPos = host && this.place(host, jd);
-		if (!host || !hostPos) return setUnplaced(body, this.under(hostId));
-		return seatFeatureBody(body, host, hostPos, this.bodyObjects.get(hostId), jd);
-	}
 	rideAt(jd) {
 		if (jd !== this.rideJd || this.focusedId !== this.rideFocus) {
 			this.rideJd = jd;
@@ -35250,14 +35466,13 @@ function updateSphereLOD(bodyObjects, camera, renderer, ctx, focusedId, invalida
 	const fovRad = camera.fov * Math.PI / 180;
 	const projScale = renderer.domElement.clientHeight / (2 * Math.tan(fovRad / 2));
 	const activeSystem = ctx.visibility.activeSystemId;
-	const terrainId = focusedId;
 	for (const bo of bodyObjects.values()) {
 		if (!bo.mesh || !bo.radiusScene || !bo.group.visible) continue;
 		if (bo.cachedDist <= 0) continue;
 		const isStar = bo.body.data.objectType === ObjectType.STAR;
 		const id = bo.body.data.id;
-		if (id === terrainId || bo.terrainWindow) {
-			if (updateTerrainWindow(bo, camera, id === terrainId, invalidate)) continue;
+		if (id === focusedId || bo.terrainWindow) {
+			if (updateTerrainWindow(bo, camera, id === focusedId, invalidate)) continue;
 		}
 		const desired = desiredSphereSegments(bo.radiusScene / bo.cachedDist * projScale, isStar, activeSystem ? id === activeSystem || ctx.visibility.isInActiveSystem(bo.body.data.parentId) : id === focusedId, bo.currentSegments ?? 64);
 		if (desired === bo.currentSegments) continue;
@@ -35642,8 +35857,11 @@ var PromotionRegistry = class {
 		this.finalizeBuilds();
 	}
 	syncSystemBodies(bodies) {
-		const focusedId = this.deps.getFocusedId();
-		if (focusedId !== void 0 && this.systemPromoted.delete(focusedId)) this.userPromoted.add(focusedId);
+		for (const id of this.systemPromoted) {
+			if (!this.deps.inFocus(id)) continue;
+			this.systemPromoted.delete(id);
+			this.userPromoted.add(id);
+		}
 		const wanted = new Set(bodies.map((b) => b.data.id));
 		const dropped = [...this.systemPromoted].filter((id) => !wanted.has(id) && !this.pinned.has(id));
 		this.tearDownBodies(dropped, this.systemPromoted);
@@ -35755,11 +35973,10 @@ var PromotionRegistry = class {
 	}
 	teardownAutoPromoted(forceAll) {
 		if (this.autoPromoted.size === 0) return;
-		const focusedId = this.deps.getFocusedId();
 		const jd = this.deps.clock.jd;
 		const toRemove = [];
 		for (const id of this.autoPromoted) {
-			if (id === focusedId) continue;
+			if (this.deps.inFocus(id)) continue;
 			if (forceAll || this.groupTargets && !this.groupTargets.has(id)) {
 				toRemove.push(id);
 				continue;
@@ -35772,21 +35989,21 @@ var PromotionRegistry = class {
 	}
 	setPinned(ids) {
 		this.pinned = new Set(ids);
-		const focusedId = this.deps.getFocusedId();
 		const dropped = [...this.pinPromoted].filter((id) => !this.pinned.has(id));
-		if (focusedId && dropped.includes(focusedId)) {
-			this.pinPromoted.delete(focusedId);
-			this.userPromoted.add(focusedId);
-			this.emitUserPromotedCount();
+		const kept = dropped.filter(this.deps.inFocus);
+		for (const id of kept) {
+			this.pinPromoted.delete(id);
+			this.userPromoted.add(id);
 		}
-		this.tearDownBodies(dropped.filter((id) => id !== focusedId), this.pinPromoted);
+		if (kept.length > 0) this.emitUserPromotedCount();
+		this.tearDownBodies(dropped.filter((id) => !this.deps.inFocus(id)), this.pinPromoted);
 		this.buildPinned();
 	}
 	buildPinned() {
 		let built = false;
 		for (const id of this.pinned) {
 			const body = this.deps.ctx.getBody(id);
-			if (!body || isSurfaceFeature(body) || body.data.objectType === ObjectType.MOON) continue;
+			if (!body || body.data.objectType === ObjectType.MOON) continue;
 			if (!this.buildBodyInstance(body)) continue;
 			built = true;
 			if (this.userPromoted.delete(id)) this.pinPromoted.add(id);
@@ -35796,8 +36013,7 @@ var PromotionRegistry = class {
 		this.finalizeBuilds();
 	}
 	clearUserPromoted() {
-		const focusedId = this.deps.getFocusedId();
-		const toRemove = [...this.userPromoted].filter((id) => id !== focusedId);
+		const toRemove = [...this.userPromoted].filter((id) => !this.deps.inFocus(id));
 		this.tearDownBodies(toRemove, this.userPromoted);
 		this.emitUserPromotedCount();
 	}
@@ -35858,15 +36074,61 @@ var PromotionRegistry = class {
 	}
 	emitUserPromotedCount() {
 		if (!this.deps.onUserPromotedChange) return;
-		const focusedId = this.deps.getFocusedId();
-		let count = this.userPromoted.size;
-		if (focusedId && this.userPromoted.has(focusedId)) count--;
+		let count = 0;
+		for (const id of this.userPromoted) if (!this.deps.inFocus(id)) count++;
 		this.deps.onUserPromotedChange(count);
 	}
 };
 
 // src/lib/scene/focus/controller.ts
+function surfaceSite(host, point, hostPos, jd) {
+	const s = cartesianToSpherical([...point], [...hostPos], siteQuat(host, jd));
+	return {
+		latitude: s.latitude,
+		longitude: s.longitude,
+		radius: s.distance
+	};
+}
+function siteQuat(host, jd) {
+	const q = host.orientation && bodyQuaternion(host.orientation, jd, host.nutPrec);
+	return q ? [
+		q.x,
+		q.y,
+		q.z,
+		q.w
+	] : void 0;
+}
+function underHalfRadius(host, distance) {
+	return distance < kmToScene(effectiveRadiusKm(host.data)) / 2;
+}
+function viewOverSite(site, offset, quat) {
+	const { latitude, longitude } = site;
+	const up = new Vector3(...sphericalToCartesian([
+		0,
+		0,
+		0
+	], latitude, longitude, 1, quat));
+	const down = new Vector3(...sphericalToCartesian([
+		0,
+		0,
+		0
+	], latitude + 90, longitude, 1, quat)).negate();
+	const range = offset.length();
+	const level = offset.clone().addScaledVector(up, -offset.dot(up));
+	const tilt = Math.acos(MathUtils.clamp(offset.dot(up) / range, -1, 1));
+	const heading = Math.atan2(new Vector3().crossVectors(down, level).dot(up), down.dot(level));
+	return {
+		latitude,
+		longitude,
+		zoom: site.radius + range,
+		look: {
+			tilt,
+			heading
+		}
+	};
+}
 var _from = new Vector3();
+var _shift = new Vector3();
 var _forward = new Vector3();
 var _ground = new Vector3();
 var FocusController = class {
@@ -35875,6 +36137,10 @@ var FocusController = class {
 	readerFocusFilter = null;
 	focusSets = 0;
 	focusedBody;
+	subjectBody;
+	onGround = false;
+	subjectSite = null;
+	placedOffSubject = false;
 	_tmpV3 = new Vector3();
 	pendingInitialView = null;
 	heldEpoch = -1;
@@ -35896,7 +36162,7 @@ var FocusController = class {
 			onBodyClick: (b) => this.handleFocus(b),
 			assignMapLayerToTrails: deps.assignMapLayerToTrails,
 			repositionAll: deps.repositionAll,
-			getFocusedId: () => this.focusedBody?.data.id,
+			inFocus: (id) => id === this.focusedBody?.data.id || id === this.subjectBody?.data.id,
 			onUserPromotedChange: deps.callbacks.onUserPromotedChange,
 			onSystemBodies: (bodies) => deps.systemData.loadPlanets(bodies)
 		});
@@ -35904,6 +36170,151 @@ var FocusController = class {
 	get current() {
 		return this.focusedBody;
 	}
+	get subject() {
+		return this.subjectBody;
+	}
+	get groundView() {
+		return this.onGround;
+	}
+	onGroundAt(body, jd = this.deps.clock.jd) {
+		if (body.data.objectType !== ObjectType.SPACECRAFT) return false;
+		const probe = this.probeRecord(body, jd);
+		return probe && isLandedAt(probe, jd);
+	}
+	landedSite(body, jd = this.deps.clock.jd) {
+		const probe = this.probeRecord(body, jd);
+		if (!probe?.landed || !isLandedAt(probe, jd)) return void 0;
+		const { ctx } = this.deps;
+		const host = ctx.getBody(`naif-${probe.landed.bodyNaifId}`);
+		const pos = ctx.place(body, jd);
+		const hostPos = host && ctx.place(host, jd);
+		if (!host || !pos || !hostPos) return void 0;
+		return {
+			host,
+			site: surfaceSite(host, pos, hostPos, jd)
+		};
+	}
+	probeRecord(body, jd) {
+		if (body.data.objectType !== ObjectType.SPACECRAFT) return void 0;
+		return this.deps.ctx.probeStore?.probeWithCenter(body.data.id, jd)?.probe;
+	}
+	followSubject(jd) {
+		const subject = this.subjectBody;
+		const host = this.focusedBody;
+		const now = subject && this.landedSite(subject, jd);
+		if (!subject || !host || !now || now.host !== host) return;
+		const was = this.subjectSite;
+		this.subjectSite = now.site;
+		if (!was || !this.placedOffSubject && this.pendingInitialView) return;
+		const q = this.focusedBodyQuat(host);
+		const a = sphericalToCartesian([
+			0,
+			0,
+			0
+		], was.latitude, was.longitude, was.radius, q);
+		const b = sphericalToCartesian([
+			0,
+			0,
+			0
+		], now.site.latitude, now.site.longitude, now.site.radius, q);
+		const shift = _shift.set(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+		if (shift.length() < kmToScene(1e-6)) return;
+		this.deps.controls.moveOrbit((orbit) => orbit.add(shift));
+		const held = this.pendingInitialView;
+		if (held) {
+			const at = sphericalToCartesian([
+				0,
+				0,
+				0
+			], held.latitude, held.longitude, held.zoom, q);
+			const moved = cartesianToSpherical([
+				at[0] + shift.x,
+				at[1] + shift.y,
+				at[2] + shift.z
+			], [
+				0,
+				0,
+				0
+			], q);
+			this.pendingInitialView = {
+				...held,
+				latitude: moved.latitude,
+				longitude: moved.longitude,
+				zoom: moved.distance
+			};
+		}
+	}
+	leaveGround() {
+		const subject = this.subjectBody;
+		const host = this.focusedBody;
+		const site = this.subjectSite;
+		if (!subject || !host) return;
+		const pos = this.place(subject);
+		if (!pos || !site) {
+			this.setFocusTarget(subject);
+			return;
+		}
+		const seat = sphericalToCartesian([
+			0,
+			0,
+			0
+		], site.latitude, site.longitude, site.radius, siteQuat(host, this.deps.clock.jd));
+		const cam = this.deps.camera.position;
+		const offset = cartesianToSpherical([
+			cam.x - seat[0],
+			cam.y - seat[1],
+			cam.z - seat[2]
+		], [
+			0,
+			0,
+			0
+		]);
+		this.settleOnBodyInstant(subject, pos);
+		this.snapToBodyFrame(offset.latitude, offset.longitude, offset.distance);
+	}
+	panToSurfacePoint(host, site, height, subject) {
+		const { focus, camera, controls, callbacks, pointClouds } = this.deps;
+		const hostPos = this.place(host);
+		if (!hostPos) return 0;
+		const current = this.focusedBody;
+		if (!(current !== void 0 && (current.data.id === host.data.id || this.landedSite(current)?.host.data.id === host.data.id)) && height !== void 0) return this.arriveAbove(host, site, height, subject);
+		const camWorld = this.cameraTruePos();
+		if (f64dist(focus.focusTruePos, hostPos) > 0) {
+			focus.focusTruePos = [...hostPos];
+			camera.position.set(camWorld[0] - hostPos[0], camWorld[1] - hostPos[1], camWorld[2] - hostPos[2]);
+			this.deps.repositionAll();
+			pointClouds.rebuildBasis();
+		}
+		this.setFocusTarget(host, void 0, subject);
+		this.onGround = true;
+		this.placedOffSubject = true;
+		focus.aim = null;
+		focus.aimLooks = false;
+		focus.aimPose = null;
+		const quat = siteQuat(host, this.deps.clock.jd);
+		const ground = new Vector3(...sphericalToCartesian([
+			0,
+			0,
+			0
+		], site.latitude, site.longitude, site.radius, quat));
+		const from = _from.set(camWorld[0] - hostPos[0], camWorld[1] - hostPos[1], camWorld[2] - hostPos[2]);
+		if (controls.looksOver(from, ground)) {
+			focus.aimPose = controls.lookPose(from, ground, new Quaternion());
+			focus.aim = [
+				ground.x,
+				ground.y,
+				ground.z
+			];
+			focus.aimLooks = true;
+			focus.focusDurationMs = angularDuration(camera.quaternion.angleTo(focus.aimPose), FOCUS_ROT_PACING);
+			return focus.focusDurationMs;
+		}
+		const distance = from.length();
+		callbacks.onCameraPosition?.(site.latitude, site.longitude, distance);
+		const camPos = sphericalToCartesian([...hostPos], site.latitude, site.longitude, distance, quat);
+		prepareFlyToCamera(focus, camera, camWorld, camPos, sceneSettings().resolvedReducedMotion);
+		return focus.focusDurationMs;
+	}
 	get focusChanges() {
 		return this.focusSets;
 	}
@@ -35946,12 +36357,12 @@ var FocusController = class {
 		];
 	}
 	holdsModel(id) {
-		const focused = this.focusedBody;
-		return id === (focused && (isSurfaceFeature(focused) ? focused.featureAnchor.hostId : focused.data.id)) || this.upgradeTargetIds.has(id);
+		return id === this.focusedBody?.data.id || id === this.subjectBody?.data.id || this.upgradeTargetIds.has(id);
 	}
 	syncUpgradeTargets(body) {
 		const { ctx, scene, clickables, meshToBody, bodyObjects, pointClouds, clock, loadTexture, assignMapLayerToTrails } = this.deps;
 		const targets = upgradeTargets(body, ctx);
+		if (this.subjectBody && !targets.includes(this.subjectBody)) targets.push(this.subjectBody);
 		const newIds = new Set(targets.map((t) => t.data.id));
 		for (const id of this.upgradeTargetIds) {
 			if (newIds.has(id)) continue;
@@ -36011,6 +36422,8 @@ var FocusController = class {
 			];
 		}
 		this.focusedBody = void 0;
+		this.subjectBody = void 0;
+		this.onGround = false;
 		this.promotion.emitUserPromotedCount();
 		prepareFocusTarget(focus, [...position], camera, camWorld, camPos, sceneSettings().resolvedReducedMotion);
 		const spherical = cartesianToSpherical(camPos ?? camWorld, position, void 0);
@@ -36051,8 +36464,13 @@ var FocusController = class {
 	}
 	handleFocus(body) {
 		if (this.readerFocusFilter && !this.readerFocusFilter(body)) return;
-		if (this.focusedBody?.data.id === body.data.id && !this.deps.focus.aim) {
-			this.deps.callbacks.onFocusChange(body);
+		if ((this.subjectBody ?? this.focusedBody)?.data.id === body.data.id && !this.deps.focus.aim) {
+			this.deps.callbacks.onFocusChange(body, this.focusedBody);
+			return;
+		}
+		const landed = this.landedSite(body);
+		if (landed) {
+			this.panToSurfacePoint(landed.host, landed.site, void 0, body);
 			return;
 		}
 		this.setFocusTarget(body);
@@ -36062,36 +36480,28 @@ var FocusController = class {
 		const { latitude, longitude, distance } = cartesianToSpherical(camWorld, pos, this.focusedBodyQuat(body));
 		this.deps.callbacks.onCameraPosition?.(latitude, longitude, distance);
 	}
-	setFocusTarget(body, camPos) {
+	setFocusTarget(body, camPos, subject) {
 		const { ctx, bodyObjects, callbacks, focus, camera, systemData, loadTexture } = this.deps;
 		this.focusSets++;
-		const drawsItself = !isSurfaceFeature(body) && !isExtrasolar(body) && !isExoplanet(body);
-		if (!isSurfaceFeature(body)) this.promotion.ensureBodyObjects(body);
+		this.subjectBody = subject;
+		this.subjectSite = (subject && this.landedSite(subject)?.site) ?? null;
+		this.placedOffSubject = false;
+		this.onGround = false;
+		const drawsItself = !isExtrasolar(body) && !isExoplanet(body);
+		this.promotion.ensureBodyObjects(body);
 		const prev = this.focusedBody;
-		const prevNomBodyId = nomenclatureBodyId(prev, bodyObjects);
-		const newNomBodyId = nomenclatureBodyId(body, bodyObjects);
-		const prevModelId = prev && (isSurfaceFeature(prev) ? prev.featureAnchor.hostId : prev.data.id);
-		const newModelId = isSurfaceFeature(body) ? body.featureAnchor.hostId : body.data.id;
+		const prevId = prev?.data.id;
 		const newTargetIds = this.syncUpgradeTargets(body);
-		if (prevModelId && prevModelId !== newModelId && !newTargetIds.has(prevModelId)) {
-			const prevBo = bodyObjects.get(prevModelId);
-			if (prevBo) unloadBodyModel(prevBo);
-		}
-		if (prevNomBodyId && prevNomBodyId !== newNomBodyId) {
-			const prevNomBo = bodyObjects.get(prevNomBodyId);
-			if (prevNomBo) disposeNomenclatureLabels(prevNomBo);
+		if (prevId && prevId !== body.data.id) {
+			const prevBo = bodyObjects.get(prevId);
+			if (prevBo && !newTargetIds.has(prevId)) unloadBodyModel(prevBo);
+			if (prevBo) disposeNomenclatureLabels(prevBo);
 		}
 		if (body.data.id !== prev?.data.id) this.pendingInitialView = null;
 		this.focusedBody = body;
-		if (!isSurfaceFeature(body)) ctx.bodies.focusFeature = null;
-		const featureHost = isSurfaceFeature(body) ? ctx.getBody(body.featureAnchor.hostId) : void 0;
-		ctx.visibility.setFocused(featureHost ?? body);
-		callbacks.onFocusChange(body);
+		ctx.visibility.setFocused(body, subject);
+		callbacks.onFocusChange(subject ?? body, body);
 		if (drawsItself) loadTexture(body);
-		if (newNomBodyId && newNomBodyId !== body.data.id) {
-			const landingBody = ctx.getBody(newNomBodyId);
-			if (landingBody) loadTexture(landingBody);
-		}
 		systemData.syncToFocus();
 		const pos = this.place(body);
 		if (pos) {
@@ -36109,6 +36519,19 @@ var FocusController = class {
 			this.setFocusTarget(body);
 			return 0;
 		}
+		const landed = this.landedSite(body);
+		if (landed) {
+			const { host, site } = landed;
+			if (zoom === void 0 || underHalfRadius(host, zoom)) return this.panToSurfacePoint(host, site, zoom, body);
+			const view = {
+				latitude: latitude ?? site.latitude,
+				longitude: longitude ?? site.longitude
+			};
+			return this.flyOntoGround(host, {
+				...view,
+				zoom
+			}, body);
+		}
 		let camPos;
 		if (zoom !== void 0) {
 			if (latitude !== void 0 && longitude !== void 0) camPos = sphericalToCartesian(pos, latitude, longitude, zoom, this.focusedBodyQuat(body));
@@ -36127,7 +36550,7 @@ var FocusController = class {
 		callbacks.onCameraPosition?.(spherical.latitude, spherical.longitude, spherical.distance);
 		if (zoom !== void 0 && camPos) {
 			this.pendingInitialView = null;
-			if (this.focusedBody?.data.id === id && f64dist(focus.focusTruePos, pos) < minCameraDistance(body)) {
+			if (this.focusedBody?.data.id === id && !this.subjectBody && !this.onGround && f64dist(focus.focusTruePos, pos) < minCameraDistance(body)) {
 				focus.focusTruePos = [...pos];
 				this.deps.repositionAll();
 				pointClouds.rebuildBasis();
@@ -36143,9 +36566,55 @@ var FocusController = class {
 		const body = this.deps.ctx.getBody(id);
 		const pos = body && this.place(body);
 		if (!body || !pos) return;
+		const landed = this.landedSite(body);
+		if (landed) {
+			const { host, site } = landed;
+			if (underHalfRadius(host, zoom)) this.arriveAbove(host, site, zoom, body, true, look);
+			else this.snapOntoGround(host, {
+				latitude,
+				longitude,
+				zoom,
+				look
+			}, body);
+			return;
+		}
 		this.settleOnBodyInstant(body, pos);
 		this.snapToBodyFrame(latitude, longitude, zoom, look);
 	}
+	arriveAbove(host, site, height, subject, instant = false, look = LEVEL_LOOK) {
+		const view = {
+			latitude: site.latitude,
+			longitude: site.longitude,
+			zoom: site.radius + height
+		};
+		if (!instant) return this.flyOntoGround(host, view, subject);
+		this.snapOntoGround(host, {
+			...view,
+			look
+		}, subject);
+		this.placedOffSubject = true;
+		return 0;
+	}
+	flyOntoGround(host, view, subject) {
+		const { focus, callbacks } = this.deps;
+		const hostPos = this.place(host);
+		if (!hostPos) return 0;
+		const camPos = sphericalToCartesian([...hostPos], view.latitude, view.longitude, view.zoom, siteQuat(host, this.deps.clock.jd));
+		callbacks.onCameraPosition?.(view.latitude, view.longitude, view.zoom);
+		this.pendingInitialView = null;
+		this.setFocusTarget(host, camPos, subject);
+		focus.orbitFly = true;
+		this.onGround = true;
+		this.placedOffSubject = true;
+		return focus.focusDurationMs;
+	}
+	snapOntoGround(host, view, subject) {
+		const pos = this.place(host);
+		if (!pos) return;
+		this.settleOnBodyInstant(host, pos, subject);
+		this.snapToBodyFrame(view.latitude, view.longitude, view.zoom, view.look);
+		this.onGround = true;
+	}
 	snapToBodyFacing(id, towardId, elevationDeg, distance) {
 		const { ctx, camera, controls, callbacks } = this.deps;
 		const body = ctx.getBody(id);
@@ -36190,9 +36659,9 @@ var FocusController = class {
 		callbacks.onCameraPosition?.(settled.latitude, settled.longitude, settled.distance);
 		this.pendingInitialView = null;
 	}
-	settleOnBodyInstant(body, pos) {
+	settleOnBodyInstant(body, pos, subject) {
 		const { focus, pointClouds } = this.deps;
-		this.setFocusTarget(body);
+		this.setFocusTarget(body, void 0, subject);
 		focus.focusTruePos = [...pos];
 		focus.focusOriginWorld = [...pos];
 		focus.focusTargetWorld = [...pos];
@@ -36203,6 +36672,10 @@ var FocusController = class {
 		focus.orbitFly = false;
 		focus.arcOrbit = false;
 		focus.cameraStaysOnBody = false;
+		focus.aim = null;
+		focus.aimLooks = false;
+		focus.aimPose = null;
+		focus.leavesAim = false;
 		this.deps.repositionAll();
 		pointClouds.rebuildBasis();
 	}
@@ -36272,10 +36745,6 @@ function framesInBodyAxes(b) {
 }
 function upgradeTargets(focus, ctx) {
 	if (!focus) return [];
-	if (isSurfaceFeature(focus)) {
-		const host = ctx.getBody(focus.featureAnchor.hostId);
-		return host && isMeshUpgradable(host) ? [host] : [];
-	}
 	const out = [];
 	if (isMeshUpgradable(focus)) out.push(focus);
 	if (focus.data.objectType === ObjectType.MOON || focus.data.orbitalSource === OrbitalSource.SPICE_PROBE) {
@@ -36736,7 +37205,7 @@ var SPHERE_GROUND = {
 	radiusKm: () => null
 };
 var _toCamera = new Vector3();
-function cameraMotionScale(camera, focusTruePos, focused, parent, seated, position = camera.position, ground = SPHERE_GROUND) {
+function cameraMotionScale(camera, focusTruePos, focused, parent, position = camera.position, ground = SPHERE_GROUND) {
 	const orbitRadius = position.length();
 	if (!(orbitRadius > 0)) return {
 		rotate: 1,
@@ -36747,7 +37216,7 @@ function cameraMotionScale(camera, focusTruePos, focused, parent, seated, positi
 	const floor = focusRadius > 0 ? kmToScene(ground.clearanceKm(sized)) : 0;
 	let clearance = orbitRadius;
 	let height = Math.max(orbitRadius - focusRadius, floor);
-	for (const body of [sized, seated ? void 0 : parent]) {
+	for (const body of [sized, parent]) {
 		const at = body?.position;
 		if (!body || !at) continue;
 		if (!(effectiveRadiusKm(body.data) > 0)) continue;
@@ -36822,7 +37291,7 @@ var TIGHT_FAR_RELEASE = 2.3;
 var SUN_PROXY_FAR_FRACTION = .9;
 var _sunLiftDir = new Vector3();
 var _lookDir = new Vector3();
-var _lookUp = new Vector3();
+var _groundDir = new Vector3();
 var SPIN_FOLLOW_NONE = 2;
 var _spinNow = new Quaternion();
 var _spinStep = new Quaternion();
@@ -36985,7 +37454,6 @@ var SceneRenderer = class SceneRenderer {
 	};
 	viewportH = 1;
 	tier = currentRenderTier();
-	landedNomBodyId = null;
 	rafId = 0;
 	paused = false;
 	covered = false;
@@ -37091,7 +37559,7 @@ var SceneRenderer = class SceneRenderer {
 		const dust = new StarDust(this.renderer, dustPlan(), this.invalidate);
 		this.starfield = new StarfieldSystem(ctx, this.scene, starBudget(), this.invalidate, this.pointClouds.pickRegistry, dust, new GlowSky(this.renderer, this.scene, glowPlan(), dust, this.invalidate, () => this.skyboxSource(), new StarlessSky(loadStarlessSky, this.invalidate)));
 		this.constellations = new ConstellationSystem(ctx, this.scene, SceneRenderer.MAP_LAYER, this.invalidate, canvas, (slug, figure, name) => this.callbacks.onConstellationSelect?.(slug, figure, name), (direction, instant) => this.aimAt(direction, instant), () => this.focus.camOriginWorld !== null);
-		this.controls = new LookOrbitControls(this.camera, canvas, this.lookSurfaceRadius, this.standingHeight, () => this.pendingUrlWrite = true);
+		this.controls = new LookOrbitControls(this.camera, canvas, this.lookSurfaceRadius, () => this.pendingUrlWrite = true);
 		this.controls.enableDamping = true;
 		this.orbitDampingFactor = orbitDamping(sceneSettings().resolvedReducedMotion);
 		Object.defineProperty(this.controls, "minDistance", { get: () => this.minCameraDistance() });
@@ -37112,7 +37580,7 @@ var SceneRenderer = class SceneRenderer {
 			}
 			this.invalidate();
 		});
-		this.cameraUp = new CameraUpController(this.camera, this.controls, ctx, (id) => this.isLanded(id));
+		this.cameraUp = new CameraUpController(this.camera, this.controls, ctx);
 		this.systemData = new SystemDataLoader(this.scene, ctx, this.renderer, this.textureLoader, this.bodyObjects, clock, () => {
 			this.focusController.reapplyInitialViewIfPending();
 			this.invalidate();
@@ -37165,7 +37633,7 @@ var SceneRenderer = class SceneRenderer {
 		ctx.visibility.updateCamera(framing.zoom, this.clock.jd);
 		this.viewOpen = !ctx.loading;
 		this.updateSystemShare(0);
-		callbacks.onFocusChange(focusBody);
+		callbacks.onFocusChange(focusBody, focusBody);
 		this.buildScene();
 		if (focusBody) this.focusController.promotion.ensureBodyObjects(focusBody);
 		if (focusBody) this.focusController.syncUpgradeTargets(focusBody);
@@ -37176,6 +37644,7 @@ var SceneRenderer = class SceneRenderer {
 		this.gpuPick = new GpuPickPass(this.renderer, this.camera);
 		this.pointerInteraction = new PointerInteraction(canvas, this.camera, ctx, clock, this.focus, this.clickables, this.meshToBody, this.pickBody, (ndcX, ndcY) => this.pickFocusedModel(ndcX, ndcY), this.gpuPick, () => [...this.pointClouds.asteroids().values(), ...this.pointClouds.spacecraft().values()], this.pointClouds.pickRegistry, () => this.starSelectEnabled && this.bodySelectEnabled && this.ctx.visibility.planetarySystemShare() === 0 ? this.starfield.pickDraws() : [], (pickId) => this.pickStar(pickId));
 		this.pointerInteraction.attach();
+		if (focusBody && this.focusController.landedSite(focusBody)) this.focusController.snapToBody(focusBody.data.id, framing.latitude, framing.longitude, framing.zoom, framing.look);
 		this.tick();
 	}
 	buildScene() {
@@ -37450,6 +37919,9 @@ var SceneRenderer = class SceneRenderer {
 			at[1] + offset[1],
 			at[2] + offset[2]
 		];
+		const host = this.focusController.landedSite(body, this.sceneJd)?.host;
+		const hostAt = host && this.whereBody(host);
+		if (host && hostAt) return cartesianToSpherical(camera, hostAt, siteQuat(host, this.sceneJd));
 		return cartesianToSpherical(camera, at, this.focusController.focusedBodyQuat(body));
 	}
 	where(id) {
@@ -37496,7 +37968,7 @@ var SceneRenderer = class SceneRenderer {
 			this.controls.target.set(0, 0, 0);
 			this.controls.update();
 		}
-		this.coverageWatch?.sync(this.focusController.current, this.clock.jd);
+		this.coverageWatch?.sync(this.focusController.subject ?? this.focusController.current, this.clock.jd);
 		this.clock.tick(performance.now());
 		if (!this.shouldRender(nowMs)) {
 			this.controls.update();
@@ -37522,13 +37994,14 @@ var SceneRenderer = class SceneRenderer {
 		if (!this.dateHeld() && !this.seekAwaitsData) this.clock.placed(this.seenJumps);
 		this.refreshTravelFocus();
 		this.callbacks.onFrame?.(this.sceneJd, renderedDtMs);
+		this.followLanding(nowMs);
 		this.followSpin(nowMs);
 		const controlsSettled = this.holdingCamera ? this.applyHeldCamera() : stepFocusAnimation(this.focus, this.camera, this.controls, () => this.repositionAll(), () => this.pointClouds.rebuildBasis());
 		this.applyReaderLimits(nowMs);
 		const near = this.nearSurfaces();
 		if (near) {
 			this.clampToSurfaces(near);
-			this.setMotionScale(cameraMotionScale(this.camera, this.focus.focusTruePos, near.focused, near.parent, near.seated, this.controls.orbitPosition, this.motionGround));
+			this.setMotionScale(cameraMotionScale(this.camera, this.focus.focusTruePos, near.focused, near.parent, this.controls.orbitPosition, this.motionGround));
 		} else this.setMotionScale({
 			rotate: 1,
 			translate: 1
@@ -37587,7 +38060,7 @@ var SceneRenderer = class SceneRenderer {
 		}
 		for (const light of this.ambientLights) light.intensity = ambient;
 		updateUserLocationOcclusion(this.userLocationMarker, this.bodyObjects, this.camera);
-		const focusedIdLod = nomenclatureBodyId(this.focusController.current, this.bodyObjects);
+		const focusedIdLod = this.focusController.current?.data.id;
 		updateTextureLOD(this.bodyObjects, this.camera, this.renderer, this.ctx, this.textureLoader, focusedIdLod, this.sceneJd, this.appearances, this.invalidate);
 		updateSphereLOD(this.bodyObjects, this.camera, this.renderer, this.ctx, focusedIdLod, this.invalidate);
 		updateSunShadowLight(this.bodyObjects, this.focus.focusTruePos, this.ctx, this.shadowLight, starPointLight, distance, this._tmpV3, sceneSettings().realisticLighting && this.starLight.starId === "naif-10", this.sunIntensityScale);
@@ -37644,6 +38117,7 @@ var SceneRenderer = class SceneRenderer {
 		if (!body) return POINT_MIN_DISTANCE;
 		const bo = this.bodyObjects.get(body.data.id);
 		const lowest = bo && (modelMinRadiusKm(bo) ?? reliefRadiiKm(bo)?.min ?? smallestRadiusKm(bo));
+		if (this.focusController.groundView) return kmToScene((lowest ?? effectiveRadiusKm(body.data)) + LANDED_KEEP_AWAY_KM);
 		return minCameraDistance(body, lowest, bo && finestTexelKm(bo));
 	}
 	clearanceKm(body) {
@@ -37651,7 +38125,7 @@ var SceneRenderer = class SceneRenderer {
 		return surfaceClearanceKm(body, bo && finestTexelKm(bo));
 	}
 	followSpin(nowMs) {
-		const body = this.spinningBody();
+		const body = this.focusController.current;
 		const flying = nowMs - this.focus.focusStartTime < this.focus.focusDurationMs;
 		if (!body?.orientation || flying || this.holdingCamera || this.focus.aim) {
 			this.spinFrom = null;
@@ -37665,16 +38139,26 @@ var SceneRenderer = class SceneRenderer {
 		};
 		if (!from || from.id !== body.data.id) return;
 		const radiusKm = effectiveRadiusKm(body.data);
-		const height = sceneToKm(this.controls.orbitPosition.length()) / radiusKm - (body === this.focusController.current ? 1 : 0);
+		const height = sceneToKm(this.controls.orbitPosition.length()) / radiusKm - 1;
 		const t = MathUtils.clamp((SPIN_FOLLOW_NONE - height) / 1.5, 0, 1);
 		const share = t * t * (3 - 2 * t);
 		if (share === 0) return;
 		_spinStep.copy(_spinNow).multiply(from.quat.invert());
 		this.controls.carry(_noTurn.identity().slerp(_spinStep, share));
 	}
-	spinningBody() {
-		const focused = this.focusController.current;
-		return focused && (this.standingOn(focused) ?? focused);
+	followLanding(nowMs) {
+		if (nowMs - this.focus.focusStartTime < this.focus.focusDurationMs || this.holdingCamera || this.dateHeld()) return;
+		const fc = this.focusController;
+		const subject = fc.subject;
+		if (subject) {
+			const onGround = fc.onGroundAt(subject);
+			if (onGround === false) fc.leaveGround();
+			else if (onGround) fc.followSubject(this.sceneJd);
+			return;
+		}
+		const current = fc.current;
+		const landed = current && fc.landedSite(current);
+		if (landed) fc.panToSurfacePoint(landed.host, landed.site, void 0, current);
 	}
 	settleCamera() {
 		this.settleLook();
@@ -37692,22 +38176,23 @@ var SceneRenderer = class SceneRenderer {
 		return {
 			focused,
 			parent: parentId ? this.ctx.getBody(parentId) : void 0,
-			seated: Boolean(this.bodyObjects.get(focused.data.id)?.isLanded) || isSurfaceFeature(focused)
+			onGround: this.focusController.groundView
 		};
 	}
-	clampToSurfaces({ focused, parent, seated }) {
+	clampToSurfaces({ focused, parent, onGround }) {
 		const { camera } = this;
 		const at = this.focus.focusTruePos;
+		const own = parent?.data.id === focused.data.id;
 		if (parent) {
-			const surface = this.surfaceClamp(parent, seated);
+			const surface = this.surfaceClamp(parent, own && onGround);
 			clampCameraOutsideBody(camera, parent, at, surface, this.clearanceKm(parent));
 		}
-		if (parent?.data.id === focused.data.id) return;
-		const surface = this.surfaceClamp(focused, false);
+		if (own) return;
+		const surface = this.surfaceClamp(focused, onGround);
 		if (surface) clampCameraOutsideBody(camera, focused, at, surface, this.clearanceKm(focused));
 	}
 	motionGround = {
-		clearanceKm: (body) => this.clearanceKm(body),
+		clearanceKm: (body) => this.focusController.groundView && body === this.focusController.current ? LANDED_KEEP_AWAY_KM : this.clearanceKm(body),
 		radiusKm: (body, direction) => {
 			const surface = this.surfaceClamp(body, false);
 			if (!surface) return null;
@@ -37783,20 +38268,10 @@ var SceneRenderer = class SceneRenderer {
 	}
 	updateTightFar(distance) {
 		if (isReversedDepth()) return;
-		const focused = this.focusController.current;
-		const anchorId = focused ? nomenclatureBodyId(focused, this.bodyObjects) : void 0;
-		const anchorBo = anchorId ? this.bodyObjects.get(anchorId) : void 0;
-		const radius = anchorBo?.radiusScene ?? 0;
-		let dist = distance;
-		const anchorAt = anchorBo?.body.position;
-		if (focused && anchorAt && anchorId !== focused.data.id) {
-			const [fx, fy, fz] = this.focus.focusTruePos;
-			const [bx, by, bz] = anchorAt;
-			const cam = this.camera.position;
-			dist = Math.hypot(fx + cam.x - bx, fy + cam.y - by, fz + cam.z - bz);
-		}
+		const id = this.focusController.current?.data.id;
+		const radius = id && this.bodyObjects.get(id)?.radiusScene || 0;
 		const bound = this.tightFar ? TIGHT_FAR_RELEASE : TIGHT_FAR_ENGAGE;
-		this.tightFar = radius > 0 && this.ctx.visibility.activeSystemId !== null && dist < radius * bound;
+		this.tightFar = radius > 0 && this.ctx.visibility.activeSystemId !== null && distance < radius * bound;
 	}
 	updateDepthFar() {
 		if (isReversedDepth()) return;
@@ -38229,34 +38704,23 @@ var SceneRenderer = class SceneRenderer {
 		const cam = this.camera;
 		return !(cam.position.distanceToSquared(pos) <= cam.position.lengthSq() * 1e-10 && 8 * (1 - Math.abs(cam.quaternion.dot(quat))) <= 1e-8);
 	}
+	groundUnderCamera() {
+		const body = this.focusController?.current;
+		if (!body) return null;
+		const down = _groundDir.copy(this.controls.orbitPosition).normalize();
+		return {
+			groundKm: this.motionGround.radiusKm(body, down) ?? effectiveRadiusKm(body.data),
+			clearanceKm: this.motionGround.clearanceKm(body)
+		};
+	}
 	lookSurfaceRadius = (direction) => {
 		const focused = this.focusController.current;
 		if (this.holdingCamera || this.focus.aim || !focused) return null;
-		if (this.standingOn(focused)) return 0;
 		const bo = this.bodyObjects.get(focused.data.id);
 		if (isModelBearing(focused) || !(bo?.mesh || hasModelSurface(bo))) return null;
 		const radiusKm = effectiveRadiusKm(focused.data);
 		return kmToScene(this.motionGround.radiusKm(focused, direction) ?? radiusKm);
 	};
-	standingOn(focused) {
-		if (isSurfaceFeature(focused)) return this.ctx.getBody(focused.featureAnchor.hostId);
-		if (!this.bodyObjects.get(focused.data.id)?.isLanded) return void 0;
-		const parentId = collisionParentId(focused.data.parentId);
-		return parentId ? this.ctx.getBody(parentId) : void 0;
-	}
-	standingHeight = () => {
-		const focused = this.focusController.current;
-		const host = focused && this.standingOn(focused);
-		const at = host?.position;
-		if (!host || !at) return null;
-		const fp = this.focus.focusTruePos;
-		const cam = this.controls.orbitPosition;
-		const up = _lookUp.set(cam.x + fp[0] - at[0], cam.y + fp[1] - at[1], cam.z + fp[2] - at[2]);
-		const dist = up.length();
-		const groundKm = this.motionGround.radiusKm(host, up.divideScalar(dist));
-		const ground = kmToScene(groundKm ?? effectiveRadiusKm(host.data));
-		return ground > 0 ? (dist - ground) / ground : null;
-	};
 	onControlsEnd = () => {
 		this.pendingUrlWrite = true;
 		this.focusController.clearPendingInitialView();
@@ -38303,26 +38767,17 @@ var SceneRenderer = class SceneRenderer {
 	}
 	setSelectedFeature(featureId) {
 		this.selectedFeatureId = featureId;
-		const nomId = nomenclatureBodyId(this.focusController.current, this.bodyObjects);
+		const nomId = this.focusController.current?.data.id;
 		const bo = nomId ? this.bodyObjects.get(nomId) : void 0;
 		if (bo) setActiveFeatureLabel(bo, featureId);
 	}
-	syncLandedNomenclature() {
-		const focused = this.focusController.current;
-		const landingId = (focused ? this.bodyObjects.get(focused.data.id) : void 0)?.isLanded ? focused.data.parentId : null;
-		if (landingId === this.landedNomBodyId) return;
-		this.landedNomBodyId = landingId;
-		if (!landingId) return;
-		const landingBody = this.ctx.getBody(landingId);
-		if (landingBody) this.maybeLoadTexture(landingBody);
-	}
 	clearUserPromoted() {
 		this.focusController.promotion.clearUserPromoted();
 	}
 	focusedSeatConfigKey() {
-		const focused = this.focusController.current;
+		const focused = this.focusController.subject ?? this.focusController.current;
 		if (!focused) return null;
-		if (focused.data.objectType !== ObjectType.SPACECRAFT && !isSurfaceFeature(focused)) return null;
+		if (focused.data.objectType !== ObjectType.SPACECRAFT) return null;
 		const parentId = collisionParentId(focused.data.parentId);
 		const bo = parentId ? this.bodyObjects.get(parentId) : void 0;
 		if (!bo) return null;
@@ -38436,7 +38891,6 @@ var SceneRenderer = class SceneRenderer {
 			this.repositionBodies();
 			this.pointClouds.maybeRebase();
 		}
-		this.syncLandedNomenclature();
 		this.seekAwaitsData = seeked && result.focusLoading;
 		const losingPlace = result.focusUnplaced && !this.focusWasOutOfRange;
 		this.focusWasOutOfRange = result.focusUnplaced;
@@ -38454,83 +38908,32 @@ var SceneRenderer = class SceneRenderer {
 		this.focusWasOutOfRange = false;
 		return this.focusController.focusOnBody(id, zoom, latitude, longitude);
 	}
-	focusOnFeature(anchor, name, zoom, mode = "frame", view) {
+	focusOnFeature(anchor, zoom, move = "turn", view = null, look = LEVEL_LOOK) {
 		this.disarmLimits();
 		this.applyJdUpdate();
 		this.focusWasOutOfRange = false;
 		const host = this.ctx.getBody(anchor.hostId);
 		const hostPos = host && this.whereBody(host);
 		if (!host || !hostPos) return 0;
-		this.focusController.clearPendingInitialView();
-		const alreadyOnHost = nomenclatureBodyId(this.focusController.current, this.bodyObjects) === anchor.hostId;
-		const fb = makeFeatureBody(anchor, name);
-		this.ctx.bodies.focusFeature = fb;
+		const fc = this.focusController;
+		fc.clearPendingInitialView();
 		const hostBo = this.bodyObjects.get(host.data.id);
 		this.selectedFeatureId = anchor.featureId;
 		if (hostBo) setActiveFeatureLabel(hostBo, anchor.featureId);
-		const seat = this.whereBody(fb);
-		if (!seat) return 0;
-		const quat = this.focusController.focusedBodyQuat(fb);
-		if (mode === "pan") {
-			const s = cartesianToSpherical(this.focusController.cameraTruePos(), seat, quat);
-			this.callbacks.onCameraPosition?.(s.latitude, s.longitude, s.distance);
-			this.focusController.setFocusTarget(fb);
-			return this.focus.focusDurationMs;
-		}
-		let zx = seat[0] - hostPos[0];
-		let zy = seat[1] - hostPos[1];
-		let zz = seat[2] - hostPos[2];
-		const len = Math.hypot(zx, zy, zz);
-		if (len > 1e-9) {
-			zx /= len;
-			zy /= len;
-			zz /= len;
-		} else {
-			zx = 0;
-			zy = 1;
-			zz = 0;
-		}
-		const camPos = mode === "snap" && view ? sphericalToCartesian(seat, view.latitude, view.longitude, view.zoom, quat) : [
-			seat[0] + zx * zoom,
-			seat[1] + zy * zoom,
-			seat[2] + zz * zoom
-		];
-		const s = cartesianToSpherical(camPos, seat, quat);
-		this.callbacks.onCameraPosition?.(s.latitude, s.longitude, s.distance);
-		if (mode === "snap") {
-			this.focusController.setFocusTarget(fb, camPos);
-			const f = this.focus;
-			f.focusTruePos = [...seat];
-			f.focusOriginWorld = [...seat];
-			f.focusTargetWorld = [...seat];
-			f.focusStartTime = -FOCUS_DURATION_MS;
-			f.camOriginWorld = null;
-			f.camTargetWorld = null;
-			f.camTargetOffset = null;
-			f.camOriginOffset = null;
-			f.flyQ0 = null;
-			f.orbitFly = false;
-			f.arcOrbit = false;
-			f.cameraStaysOnBody = false;
-			this.repositionAll();
-			this.pointClouds.rebuildBasis();
-			this.camera.position.set(camPos[0] - seat[0], camPos[1] - seat[1], camPos[2] - seat[2]);
-			this.controls.update();
-			return 0;
-		}
-		if (alreadyOnHost) {
-			const camWorld = this.focusController.cameraTruePos();
-			this.focusController.setFocusTarget(fb);
-			this.focus.focusTruePos = [...seat];
-			this.camera.position.set(camWorld[0] - seat[0], camWorld[1] - seat[1], camWorld[2] - seat[2]);
-			this.repositionAll();
-			this.pointClouds.rebuildBasis();
-			prepareFlyToCamera(this.focus, this.camera, camWorld, camPos, sceneSettings().resolvedReducedMotion);
-		} else {
-			this.focusController.setFocusTarget(fb, camPos);
-			this.focus.orbitFly = true;
+		const seat = featureSeat(anchor, host, hostPos, hostBo, this.sceneJd);
+		const site = surfaceSite(host, seat, hostPos, this.sceneJd);
+		if (move === "turn") return fc.panToSurfacePoint(host, site, zoom);
+		if (move === "frame" || !view) return fc.arriveAbove(host, site, zoom, void 0, move === "snap", look);
+		if (underHalfRadius(host, view.zoom)) {
+			const offset = sphericalToCartesian([
+				0,
+				0,
+				0
+			], view.latitude, view.longitude, view.zoom);
+			view = viewOverSite(site, new Vector3(...offset), siteQuat(host, this.sceneJd));
 		}
-		return this.focus.focusDurationMs;
+		fc.snapOntoGround(host, view);
+		return 0;
 	}
 	pickFocusedModel(ndcX, ndcY) {
 		if (!this.overlayActive) return null;
@@ -38551,13 +38954,12 @@ var SceneRenderer = class SceneRenderer {
 	}
 	overlayModelBo() {
 		const withModel = (bo) => bo?.model && isDrawn(bo) ? bo : null;
-		const focusBody = this.focusController.current;
+		const focusBody = this.focusController.subject ?? this.focusController.current;
 		if (!focusBody) {
 			const centerId = this.travelFocus?.centerId;
 			return withModel(centerId ? this.bodyObjects.get(centerId) : void 0);
 		}
-		const modelId = isSurfaceFeature(focusBody) ? focusBody.featureAnchor.hostId : focusBody.data.id;
-		const bo = this.bodyObjects.get(modelId);
+		const bo = this.bodyObjects.get(focusBody.data.id);
 		const own = withModel(bo);
 		if (own) return own;
 		if (focusBody.data.orbitalSource === OrbitalSource.SPICE_PROBE && !bo?.isLanded) {
@@ -41330,6 +41732,14 @@ var SpaceMap = class {
 	set focusedBody(value) {
 		set(this.#focusedBody, value);
 	}
+	#cameraBody = state();
+	get cameraBody() {
+		return get(this.#cameraBody);
+	}
+	set cameraBody(value) {
+		set(this.#cameraBody, value);
+	}
+	movingToFeature = false;
 	attribution = null;
 	objects = new MapObjectCollection(() => this.requireRenderer().extensions, () => this.requireCanvas());
 	dragRotate;
@@ -41426,9 +41836,7 @@ var SpaceMap = class {
 	}
 	getFocusedBody() {
 		const focused = this.focusedBody;
-		if (!focused) return void 0;
-		const body = isSurfaceFeature(focused) ? this.ctx.getBody(focused.featureAnchor.hostId) : focused;
-		return body && bodyView(body);
+		return focused && bodyView(focused);
 	}
 	getChildren(id) {
 		return [...this.ctx.bodies.getChildren(id) ?? []];
@@ -41652,11 +42060,12 @@ var SpaceMap = class {
 				notify: (notice) => this.emit("notice", notice),
 				dismiss: (topic) => this.emit("noticedismiss", topic)
 			},
-			onFocusChange: (body) => {
+			onFocusChange: (body, orbited) => {
 				const initial = this.initialFocusPending;
 				this.initialFocusPending = false;
 				this.focusedBody = body;
-				const feature = body !== void 0 && isSurfaceFeature(body);
+				this.cameraBody = orbited;
+				const feature = this.movingToFeature;
 				this.emit("focuschange", {
 					body: this.getFocusedBody(),
 					initial,
@@ -41671,7 +42080,7 @@ var SpaceMap = class {
 			},
 			onIdle: () => this.emit("idle"),
 			onCameraPosition: (latitude, longitude, zoom, look = LEVEL_LOOK) => {
-				const body = this.focusedBody?.data.id;
+				const body = this.cameraBody?.data.id;
 				if (body === void 0) return;
 				this.emit("camera", {
 					body,
@@ -41904,7 +42313,7 @@ var SpaceMap = class {
 		});
 	}
 	panTo(target) {
-		return this.toFeature(this.targetBody(target), target.feature, "pan");
+		return this.toFeature(this.targetBody(target), target.feature, "turn");
 	}
 	async jumpTo(target) {
 		const body = this.targetBody(target);
@@ -41937,8 +42346,7 @@ var SpaceMap = class {
 		}
 		if (target.feature) {
 			const { featureId, lat, lon, diameterM } = target.feature;
-			this.focusOnFeature(body, featureId, lat, lon, diameterM, null, "snap");
-			this.renderer?.setLook(lookOf(target));
+			this.focusOnFeature(body, featureId, lat, lon, diameterM, "snap", null, lookOf(target));
 			return;
 		}
 		const camera = this.getCamera();
@@ -41946,7 +42354,7 @@ var SpaceMap = class {
 	}
 	getCamera() {
 		const renderer = this.renderer;
-		const body = this.focusedBody?.data.id;
+		const body = this.cameraBody?.data.id;
 		if (!renderer || body === void 0) return null;
 		const { latitude, longitude, distance } = renderer.getCameraState();
 		return {
@@ -41980,6 +42388,9 @@ var SpaceMap = class {
 	getLimits() {
 		return { ...this.limits };
 	}
+	getClosestApproach() {
+		return this.renderer?.groundUnderCamera() ?? null;
+	}
 	applyLimits() {
 		const l = this.limits;
 		const band = {};
@@ -42019,9 +42430,9 @@ var SpaceMap = class {
 	onTouchMove = (e) => {
 		this.cooperative?.allowsTouchDrag(e.touches.length);
 	};
-	toFeature(body, feature, mode) {
+	toFeature(body, feature, move) {
 		const { featureId, lat, lon, diameterM } = feature;
-		return this.settled(this.focusOnFeature(body, featureId, lat, lon, diameterM, null, mode));
+		return this.settled(this.focusOnFeature(body, featureId, lat, lon, diameterM, move));
 	}
 	settled(ms) {
 		return new Promise((resolve) => {
@@ -42071,7 +42482,7 @@ var SpaceMap = class {
 		if (!renderer || !vantage || vantage.kept) return null;
 		return (body) => renderer.viewFrom(body.data.id, vantage.offset) ?? {};
 	}
-	focusOnFeature(bodyId, featureId, lat, lon, diameterM, name, mode = "frame", view = null) {
+	focusOnFeature(bodyId, featureId, lat, lon, diameterM, move = "turn", view = null, look) {
 		const hostBody = this.ctx.getBody(bodyId);
 		if (!hostBody) return 0;
 		const idealScene = kmToScene(featureDiameterM(diameterM, effectiveRadiusKm(hostBody.data)) * 4 / 1e3);
@@ -42085,16 +42496,20 @@ var SpaceMap = class {
 			lon,
 			diameterM
 		};
-		return this.renderer?.focusOnFeature(anchor, name, zoom, mode, view) ?? 0;
+		this.movingToFeature = true;
+		try {
+			return this.renderer?.focusOnFeature(anchor, zoom, move, view, look) ?? 0;
+		} finally {
+			this.movingToFeature = false;
+		}
 	}
 	setFocusTarget(body, camPos) {
 		this.renderer?.setFocusTarget(body, camPos);
 	}
 	getPose() {
 		const renderer = this.renderer;
-		const focused = this.focusedBody;
-		if (!renderer || !focused) return null;
-		const body = focused.data.id;
+		const body = this.cameraBody?.data.id;
+		if (!renderer || body === void 0) return null;
 		return {
 			position: {
 				body,