spacemap 0.1.17 → 0.1.19

package/index.js

@@ -1,5 +1,5 @@
 /*! spacemap SDK — https://spacemap.co — Mozilla Public License 2.0. Bundles MIT and ISC libraries: THIRD_PARTY_NOTICES.txt in the spacemap npm package. */
-import { ACESFilmicToneMapping, AdditiveBlending, AmbientLight, ArrowHelper, BackSide, Box3, BufferAttribute, BufferGeometry, CanvasTexture, ClampToEdgeWrapping, Color, CubeTexture, CustomBlending, DataArrayTexture, DataTexture, DataUtils, DepthTexture, DirectionalLight, DoubleSide, Euler, Float32BufferAttribute, FloatType, FrontSide, Group, HalfFloatType, InstancedBufferAttribute, InstancedMesh, Line, LineBasicMaterial, LineLoop, LinearFilter, LinearMipmapLinearFilter, LinearSRGBColorSpace, MathUtils, Matrix4, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshStandardMaterial, NoBlending, NoColorSpace, NormalBlending, OneFactor, OneMinusSrcAlphaFactor, PCFShadowMap, PCFSoftShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, PointLight, Points, PointsMaterial, Quaternion, RGBAFormat, RGFormat, RawShaderMaterial, Raycaster, RedFormat, RepeatWrapping, RingGeometry, SRGBColorSpace, Scene, ShaderChunk, ShaderMaterial, ShadowMaterial, Shape, ShapeGeometry, ShapeUtils, SphereGeometry, Sprite, SpriteMaterial, TOUCH, Texture, TextureLoader, Uint16BufferAttribute, UnsignedByteType, Vector2, Vector3, Vector4, WebGLRenderTarget, WebGLRenderer } from "three";
+import { ACESFilmicToneMapping, AddEquation, AdditiveBlending, AmbientLight, ArrowHelper, BackSide, Box3, BufferAttribute, BufferGeometry, CanvasTexture, ClampToEdgeWrapping, Color, CubeTexture, CustomBlending, DataArrayTexture, DataTexture, DataUtils, DepthTexture, DirectionalLight, DoubleSide, Euler, Float32BufferAttribute, FloatType, FrontSide, Group, HalfFloatType, InstancedBufferAttribute, InstancedMesh, Line, LineBasicMaterial, LineLoop, LinearFilter, LinearMipmapLinearFilter, LinearSRGBColorSpace, MathUtils, Matrix4, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshStandardMaterial, NoBlending, NoColorSpace, NormalBlending, OneFactor, OneMinusDstColorFactor, OneMinusSrcAlphaFactor, PCFShadowMap, PCFSoftShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, PointLight, Points, PointsMaterial, Quaternion, RGBAFormat, RGFormat, RawShaderMaterial, Raycaster, RedFormat, RepeatWrapping, RingGeometry, SRGBColorSpace, Scene, ShaderChunk, ShaderMaterial, ShadowMaterial, Shape, ShapeGeometry, ShapeUtils, SphereGeometry, Sprite, SpriteMaterial, TOUCH, Texture, TextureLoader, Uint16BufferAttribute, UnsignedByteType, Vector2, Vector3, Vector4, WebGLRenderTarget, WebGLRenderer } from "three";
 import { RoomEnvironment } from "three/addons/environments/RoomEnvironment.js";
 import { CSS2DObject } from "three/addons/renderers/CSS2DRenderer.js";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
@@ -22,6 +22,7 @@ var DEFAULT_HOST = {
 	imagesUrl: "https://images.spacemap.co",
 	liveUrl: "https://live.spacemap.co",
 	tilesUrl: "",
+	extrasolarUrl: "",
 	locale: () => "en",
 	messages: {
 		body_note_no_model: () => "no model available",
@@ -31,6 +32,7 @@ var DEFAULT_HOST = {
 		scene_canvas_label: () => "Interactive 3D map of the Solar System",
 		attribution_orbits: () => "Orbits",
 		attribution_imagery: () => "Imagery",
+		attribution_stars: () => "Stars",
 		credits_see_all: () => "See full credits",
 		layer_surface: () => "Surface",
 		layer_clouds: () => "Clouds",
@@ -69,6 +71,7 @@ function configureHost(overrides) {
 	current$1.imagesUrl = current$1.imagesUrl.replace(/\/$/, "");
 	current$1.liveUrl = current$1.liveUrl.replace(/\/$/, "");
 	current$1.tilesUrl = current$1.tilesUrl.replace(/\/$/, "");
+	current$1.extrasolarUrl = current$1.extrasolarUrl.replace(/\/$/, "");
 }
 function host() {
 	return current$1;
@@ -3003,10 +3006,10 @@ function buildVersionedUrl(base, path, cls) {
 
 //#endregion
 //#region src/lib/fetch/position/format.ts
-var MAGIC$2 = 1346456915;
+var MAGIC$3 = 1346456915;
 var COMMON_HEADER_SIZE = 24;
 var EXTENSION_SIZE = 8;
-var HEADER_SIZE$2 = 24 + 8;
+var HEADER_SIZE$3 = 24 + 8;
 var labelsUrl = (lang) => `${dataBase()}/v1/labels/${lang}.gz`;
 function zoomSegment(zoom) {
 	return zoom === null ? "" : `${zoom}/`;
@@ -3073,6 +3076,9 @@ function buildObjectId(idType, value) {
 
 //#endregion
 //#region src/lib/types/objects.ts
+function isExtrasolar(body) {
+	return body.data.objectType === ObjectType.EXTRASOLAR;
+}
 function isSurfaceFeature(body) {
 	return body.data.objectType === ObjectType.SURFACE_FEATURE;
 }
@@ -3094,6 +3100,7 @@ var ObjectType = /* @__PURE__ */ function(ObjectType) {
 	ObjectType[ObjectType["DEBRIS"] = 14] = "DEBRIS";
 	ObjectType[ObjectType["UNDOCUMENTED"] = 15] = "UNDOCUMENTED";
 	ObjectType[ObjectType["SURFACE_FEATURE"] = 16] = "SURFACE_FEATURE";
+	ObjectType[ObjectType["EXTRASOLAR"] = 17] = "EXTRASOLAR";
 	return ObjectType;
 }({});
 var ZONE_A_RANGE = {
@@ -3177,7 +3184,8 @@ var NOMINAL_RADIUS_KM_BY_SOURCE = {
 var NOMINAL_RADIUS_KM_BY_TYPE = {
 	[ObjectType.SPACECRAFT]: .005,
 	[ObjectType.DEBRIS]: .005,
-	[ObjectType.SURFACE_FEATURE]: .001
+	[ObjectType.SURFACE_FEATURE]: .001,
+	[ObjectType.EXTRASOLAR]: 695700
 };
 var NOMINAL_RADIUS_KM_DEFAULT = .1;
 function effectiveRadiusKm(data) {
@@ -3292,6 +3300,13 @@ var CreditsStore = class {
 	set skybox(value) {
 		set(this.#skybox, value, true);
 	}
+	#stars = state([]);
+	get stars() {
+		return get(this.#stars);
+	}
+	set stars(value) {
+		set(this.#stars, value);
+	}
 	#orbitSources = state(proxy(/* @__PURE__ */ new Set()));
 	get orbitSources() {
 		return get(this.#orbitSources);
@@ -3342,6 +3357,9 @@ var CreditsStore = class {
 	imageryOf(layer) {
 		return [...this.imagery.values()].filter((c) => c.layer === layer);
 	}
+	setStars(credits) {
+		if (this.stars.length === 0) this.stars = credits;
+	}
 	registerOrientation(credit) {
 		if (this.orientation.has(credit.bodyId)) return;
 		this.orientation.set(credit.bodyId, credit);
@@ -3446,7 +3464,7 @@ function rowKey(cols, i) {
 	return objectKey(cols.idType, cols.id[i]);
 }
 function parseSharedColumns(buffer, rowCount) {
-	let offset = HEADER_SIZE$2;
+	let offset = HEADER_SIZE$3;
 	const id = new Int32Array(buffer, offset, rowCount);
 	offset += align8(rowCount * 4);
 	const objectType = new Uint8Array(buffer, offset, rowCount);
@@ -5315,6 +5333,12 @@ function equatorialToScene(xEq, yEq, zEq, out) {
 	target.z = -(yEq * COS_OBL$1 + zEq * SIN_OBL$1);
 	return target;
 }
+function sceneToEquatorial(x, y, z, out) {
+	out.x = x;
+	out.y = -y * SIN_OBL$1 - z * COS_OBL$1;
+	out.z = y * COS_OBL$1 - z * SIN_OBL$1;
+	return out;
+}
 
 //#endregion
 //#region src/lib/time/jd.ts
@@ -6385,7 +6409,7 @@ function resolveBodyColor(data) {
 		const planetId = `naif-${data.id.replace("naif-", "")}99`;
 		if (BODY_COLORS[planetId]) return BODY_COLORS[planetId];
 	}
-	if (objectType === ObjectType.STAR) return TYPE_COLOR_STAR;
+	if (objectType === ObjectType.STAR || objectType === ObjectType.EXTRASOLAR) return TYPE_COLOR_STAR;
 	if (objectType === ObjectType.PLANET || objectType === ObjectType.DWARF_PLANET) return TYPE_COLOR_PLANET;
 	if (objectType === ObjectType.MOON) return TYPE_COLOR_MOON;
 	if (isAsteroid(objectType)) return TYPE_COLOR_ASTEROID;
@@ -6724,12 +6748,14 @@ function adoptRow(held, fresh) {
 	held.orbitCenterId = fresh.orbitCenterId ?? held.orbitCenterId;
 	held.trailAnchorId = fresh.trailAnchorId;
 }
+var EXTRASOLAR_KEPT = 64;
 var BodyIndex = class {
 	bodiesById = /* @__PURE__ */ new Map();
 	majorBodies = [];
 	asteroidBodiesByZone = /* @__PURE__ */ new Map();
 	spacecraftByParent = /* @__PURE__ */ new Map();
 	focusFeature = null;
+	extrasolar = /* @__PURE__ */ new Map();
 	dirtyAsteroidZones = /* @__PURE__ */ new Set();
 	dirtySpacecraftGroups = /* @__PURE__ */ new Set();
 	minorStreaming = false;
@@ -6764,6 +6790,8 @@ var BodyIndex = class {
 		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);
+		if (star) return star;
 		if (zone !== void 0) return this.spacecraftByParent.get(zone)?.get(id) ?? this.asteroidBodiesByZone.get(zone)?.get(id);
 		for (const byId of this.spacecraftByParent.values()) {
 			const hit = byId.get(id);
@@ -6774,6 +6802,13 @@ var BodyIndex = class {
 			if (hit) return hit;
 		}
 	}
+	addExtrasolar(body, ids = []) {
+		for (const id of [body.data.id, ...ids]) {
+			this.extrasolar.delete(id);
+			this.extrasolar.set(id, body);
+		}
+		while (this.extrasolar.size > EXTRASOLAR_KEPT) this.extrasolar.delete(this.extrasolar.keys().next().value);
+	}
 	addBodies(bodies) {
 		let added = false;
 		for (const b of bodies) {
@@ -7210,6 +7245,7 @@ var MAP_LAYERS = [
 	"spacecraft",
 	"satellites",
 	"debris",
+	"starfield",
 	"orbits",
 	"labels",
 	"halos",
@@ -7358,6 +7394,117 @@ function computeVisibilityFromRatio(ratio, thresholds, focusedMultiplier, isFocu
 	return VISIBILITY.HIDE;
 }
 
+//#endregion
+//#region src/lib/scene/visibility/switch-fade.ts
+var SYSTEM_SWITCH_FADE_MS = 300;
+var SwitchFade = class {
+	progress;
+	target;
+	started;
+	constructor(on, durationMs = 300) {
+		this.durationMs = durationMs;
+		this.started = on !== void 0;
+		this.progress = this.target = on ? 1 : 0;
+	}
+	step(on, dtMs) {
+		this.target = on ? 1 : 0;
+		if (!this.started) {
+			this.started = true;
+			this.progress = this.target;
+			return;
+		}
+		const delta = dtMs / this.durationMs;
+		this.progress = this.target === 1 ? Math.min(this.progress + delta, 1) : Math.max(this.progress - delta, 0);
+	}
+	get share() {
+		const p = this.progress;
+		return p * p * (3 - 2 * p);
+	}
+	get fading() {
+		return this.progress !== this.target;
+	}
+};
+
+//#endregion
+//#region src/lib/scene/visibility/zone-fade.ts
+var ZoneFades = class {
+	main = new SwitchFade(true);
+	systems = [];
+	stepped = false;
+	step(activeSystemId, dtMs) {
+		if (!this.stepped) {
+			this.stepped = true;
+			this.main = new SwitchFade(activeSystemId === null);
+			if (activeSystemId !== null) this.systems.push({
+				id: activeSystemId,
+				fade: new SwitchFade(true)
+			});
+			return;
+		}
+		this.main.step(activeSystemId === null, dtMs);
+		if (activeSystemId !== null && !this.systems.some((s) => s.id === activeSystemId)) this.systems.push({
+			id: activeSystemId,
+			fade: new SwitchFade(false)
+		});
+		for (let i = this.systems.length - 1; i >= 0; i--) {
+			const { id, fade } = this.systems[i];
+			fade.step(id === activeSystemId, dtMs);
+			if (fade.share === 0 && !fade.fading) this.systems.splice(i, 1);
+		}
+	}
+	get mainShare() {
+		return this.main.share;
+	}
+	get fading() {
+		return this.main.fading || this.systems.some((s) => s.fade.fading);
+	}
+};
+
+//#endregion
+//#region src/lib/scene/visibility/threshold-fade.ts
+var VisibilityThresholdFades = class {
+	labels = /* @__PURE__ */ new Map();
+	orbits = /* @__PURE__ */ new Map();
+	frame = 0;
+	dtMs = 0;
+	beginFrame(dtMs) {
+		this.frame++;
+		this.dtMs = dtMs;
+		this.prune(this.labels);
+		this.prune(this.orbits);
+	}
+	labelShare(id, shown) {
+		return this.share(this.labels, id, shown);
+	}
+	orbitShare(id, shown) {
+		return this.share(this.orbits, id, shown);
+	}
+	get fading() {
+		return this.anyFading(this.labels) || this.anyFading(this.orbits);
+	}
+	share(entries, id, shown) {
+		let entry = entries.get(id);
+		if (!entry) {
+			entry = {
+				fade: new SwitchFade(shown, 100),
+				frame: this.frame
+			};
+			entries.set(id, entry);
+		} else if (entry.frame !== this.frame) {
+			entry.frame = this.frame;
+			entry.fade.step(shown, this.dtMs);
+		}
+		return entry.fade.share;
+	}
+	anyFading(entries) {
+		for (const entry of entries.values()) if (entry.frame === this.frame && entry.fade.fading) return true;
+		return false;
+	}
+	prune(entries) {
+		for (const [id, entry] of entries) if (entry.frame < this.frame - 1) entries.delete(id);
+	}
+};
+
 //#endregion
 //#region src/lib/scene/visibility/controller.svelte.ts
 var ALL_LAYERS = new LayerSet();
@@ -7383,6 +7530,10 @@ var VisibilityController = class {
 	}
 	activeSystemId = null;
 	isZoomedIn = false;
+	zones = new ZoneFades();
+	thresholds = new VisibilityThresholdFades();
+	systemShare = 1;
+	starShare = 0;
 	focusedBodyIdPlain = SUN_ID;
 	focusedSystemIdPlain = null;
 	travelSystemActive = false;
@@ -7429,6 +7580,19 @@ var VisibilityController = class {
 			this.recomputeFullMoons();
 		}
 	}
+	stepZones(dtMs) {
+		this.zones.step(this.activeSystemId, dtMs);
+		this.thresholds.beginFrame(dtMs);
+	}
+	labelThresholdShare(id, shown) {
+		return this.thresholds.labelShare(id, shown);
+	}
+	orbitThresholdShare(id, shown) {
+		return this.thresholds.orbitShare(id, shown);
+	}
+	get fading() {
+		return this.zones.fading || this.thresholds.fading;
+	}
 	refreshProbeFocusedSystem() {
 		const ps = this.getProbeStore();
 		if (!ps) return;
@@ -7442,6 +7606,7 @@ var VisibilityController = class {
 		this.lastRecomputeDist = -1;
 	}
 	resolveSystemId(body) {
+		if (isExtrasolar(body)) return null;
 		const isSystemBarycenter = body.data.objectType === ObjectType.BARYCENTER && isTopLevelParent(body.data.parentId) && !isTopLevelParent(body.data.id);
 		const isTopLevel = body.data.objectType === ObjectType.STAR || !isSystemBarycenter && isTopLevelParent(body.data.parentId);
 		if (isSystemBarycenter) return body.data.id;
@@ -7474,6 +7639,7 @@ var VisibilityController = class {
 		this.recomputeFullMoons();
 	}
 	getMoonVisibility(moon) {
+		if (this.systemShare === 0) return VISIBILITY.HIDE;
 		if (this.getLayers().hidesBody(moon.data.objectType, moon.data.parentId)) return VISIBILITY.HIDE;
 		const cached = this.moonVisibilityCache.get(moon.data.id);
 		if (cached !== void 0) return cached;
@@ -7498,6 +7664,7 @@ var VisibilityController = class {
 		return this.pinned.has(id);
 	}
 	getPlanetVisibility(body, camDistThreeJS) {
+		if (this.systemShare === 0 && body.data.objectType !== ObjectType.STAR) return VISIBILITY.HIDE;
 		const pinned = this.pinned.has(body.data.id);
 		const vis = this.ratioVisibility(body, camDistThreeJS, pinned);
 		return pinned && vis !== VISIBILITY.CLOSE ? VISIBILITY.FULL : vis;
@@ -7556,15 +7723,24 @@ var VisibilityController = class {
 		return sysNaif !== null && this.isInFocusedSystem(`naif-${sysNaif}`);
 	}
 	hasFullRendering(body) {
-		if (!this.activeSystemId || this.pinned.has(body.data.id)) return true;
-		if (this.isInActiveSystem(isTopLevelParent(body.data.parentId) ? body.data.id : body.data.parentId)) return true;
-		if (body.data.orbitalSource !== OrbitalSource.SPICE_PROBE) return false;
-		const ps = this.getProbeStore();
-		if (!ps) return false;
-		const sysNaif = ps.containingSystemAt(body.data.id, this.currentJd);
-		return sysNaif !== null && this.isInActiveSystem(`naif-${sysNaif}`);
+		return this.fullRenderingShare(body) > 0;
+	}
+	fullRenderingShare(body) {
+		const main = this.zones.mainShare;
+		if (main === 1 || this.pinned.has(body.data.id)) return 1;
+		const home = isTopLevelParent(body.data.parentId) ? body.data.id : body.data.parentId;
+		const probeSystem = this.probeSystemId(body);
+		let share = main;
+		for (const { id, fade } of this.zones.systems) if (this.bodies.isInSystem(home, id) || probeSystem !== null && this.bodies.isInSystem(probeSystem, id)) share += fade.share;
+		return Math.min(share, 1);
+	}
+	probeSystemId(body) {
+		if (body.data.orbitalSource !== OrbitalSource.SPICE_PROBE) return null;
+		const sysNaif = this.getProbeStore()?.containingSystemAt(body.data.id, this.currentJd);
+		return sysNaif === null || sysNaif === void 0 ? null : `naif-${sysNaif}`;
 	}
 	isMoonGroupVisible(parentId) {
+		if (this.systemShare === 0) return false;
 		if (!this.getLayers().isVisible("moons")) return false;
 		if (!this.isInFocusedSystem(parentId)) return false;
 		const maxA = this.bodies.maxMoonA(parentId);
@@ -7572,19 +7748,25 @@ var VisibilityController = class {
 		return this.cameraDistThreeJS / 10 / maxA <= this.scaledPlanetary[VISIBILITY.FAR];
 	}
 	isSpacecraftGroupVisible(groupParentId) {
-		if (this.getLayers().hidesSpacecraftGroup(groupParentId)) return false;
+		return this.spacecraftGroupShare(groupParentId) > 0;
+	}
+	spacecraftGroupShare(groupParentId) {
+		if (this.systemShare === 0) return 0;
+		if (this.getLayers().hidesSpacecraftGroup(groupParentId)) return 0;
 		const parent = this.bodies.bodiesById.get(groupParentId);
-		if (groupParentId !== "naif-0" && !parent?.position) return false;
-		const sysId = this.activeSystemId;
-		if (isTopLevelParent(groupParentId)) return !sysId;
-		if (parent?.data.objectType === ObjectType.STAR) return !sysId;
-		if (!sysId) return false;
-		if (groupParentId === sysId) return true;
-		return this.bodies.getChildren(sysId)?.has(groupParentId) ?? false;
+		if (groupParentId !== "naif-0" && !parent?.position) return 0;
+		if (isTopLevelParent(groupParentId)) return this.zones.mainShare;
+		if (parent?.data.objectType === ObjectType.STAR) return this.zones.mainShare;
+		for (const { id, fade } of this.zones.systems) if (this.bodies.isInSystem(groupParentId, id)) return fade.share;
+		return 0;
+	}
+	asteroidGroupShare(zone) {
+		return this.isAsteroidGroupVisible(zone) ? this.zones.mainShare : 0;
 	}
 	isAsteroidGroupVisible(zone) {
+		if (this.systemShare === 0) return false;
 		if (this.getLayers().hidesZone(zone)) return false;
-		if (this.activeSystemId) return false;
+		if (this.zones.mainShare === 0) return false;
 		if (!this.bodies.bodiesById.get("naif-10")?.position) return false;
 		const filter = this.getSmallBodyFilter();
 		if (filter && zone.startsWith("small_bodies/")) {
@@ -7745,7 +7927,7 @@ function parseChebyshevPayload$1(buffer, startJd, endJd) {
 	const float64Coeffs = (view.getUint8(28) & 1) !== 0;
 	const coeffBytes = float64Coeffs ? 8 : 4;
 	const bodies = [];
-	let offset = HEADER_SIZE$2;
+	let offset = HEADER_SIZE$3;
 	for (let b = 0; b < bodyCount; b++) {
 		const naifId = view.getInt32(offset, true);
 		const parentId = view.getInt32(offset + 4, true);
@@ -7905,7 +8087,7 @@ function parseProbesPayload(buffer, startJd, endJd, float64Coeffs) {
 	const subchunkS = subchunkDays * SECONDS_PER_DAY$2;
 	const chunkStartEt = tdbJdToEt(startJd);
 	const probes = [];
-	let offset = HEADER_SIZE$2;
+	let offset = HEADER_SIZE$3;
 	for (let p = 0; p < probeCount; p++) {
 		const objIdValue = view.getInt32(offset, true);
 		const idTypeOrdinal = view.getUint8(offset + 4);
@@ -8129,7 +8311,7 @@ var SEC_PER_DAY = 86400;
 var AU_PER_DAY_TO_KM_PER_SEC = AU_KM / SEC_PER_DAY;
 var SMALL_E = 1e-9;
 var SMALL_SIN_I = 1e-9;
-function clamp$3(x, lo, hi) {
+function clamp$4(x, lo, hi) {
 	return x < lo ? lo : x > hi ? hi : x;
 }
 function stateVectorToElements(r, v, muAuDay2, jd) {
@@ -8143,7 +8325,7 @@ function stateVectorToElements(r, v, muAuDay2, jd) {
 	const hz = rx * vy - ry * vx;
 	const hNorm = Math.hypot(hx, hy, hz);
 	if (hNorm === 0) return null;
-	const iRad = Math.acos(clamp$3(hz / hNorm, -1, 1));
+	const iRad = Math.acos(clamp$4(hz / hNorm, -1, 1));
 	const sinI = Math.sin(iRad);
 	const evX = (vy * hz - vz * hy) / muAuDay2 - rx / rNorm;
 	const evY = (vz * hx - vx * hz) / muAuDay2 - ry / rNorm;
@@ -8158,7 +8340,7 @@ function stateVectorToElements(r, v, muAuDay2, jd) {
 	let omRad;
 	if (sinI < SMALL_SIN_I || nNorm === 0) omRad = 0;
 	else {
-		omRad = Math.acos(clamp$3(nx / nNorm, -1, 1));
+		omRad = Math.acos(clamp$4(nx / nNorm, -1, 1));
 		if (ny < 0) omRad = 2 * Math.PI - omRad;
 	}
 	let wRad;
@@ -8169,7 +8351,7 @@ function stateVectorToElements(r, v, muAuDay2, jd) {
 		if (wRad < 0) wRad += 2 * Math.PI;
 	} else {
 		const cosW = (nx * evX + ny * evY) / (nNorm * e);
-		wRad = Math.acos(clamp$3(cosW, -1, 1));
+		wRad = Math.acos(clamp$4(cosW, -1, 1));
 		if (evZ < 0) wRad = 2 * Math.PI - wRad;
 	}
 	let nuRad;
@@ -8180,11 +8362,11 @@ function stateVectorToElements(r, v, muAuDay2, jd) {
 		if (nuRad < 0) nuRad += 2 * Math.PI;
 	} else if (e < SMALL_E) {
 		const cosU = (nx * rx + ny * ry) / (nNorm * rNorm);
-		nuRad = Math.acos(clamp$3(cosU, -1, 1));
+		nuRad = Math.acos(clamp$4(cosU, -1, 1));
 		if (rz < 0) nuRad = 2 * Math.PI - nuRad;
 	} else {
 		const cosNu = (evX * rx + evY * ry + evZ * rz) / (e * rNorm);
-		nuRad = Math.acos(clamp$3(cosNu, -1, 1));
+		nuRad = Math.acos(clamp$4(cosNu, -1, 1));
 		if (rDotV < 0) nuRad = 2 * Math.PI - nuRad;
 	}
 	let maRad;
@@ -9998,6 +10180,46 @@ async function dataVersionChanged() {
 	}
 }
 
+//#endregion
+//#region src/lib/fetch/extrasolar/ids.ts
+var CELL_LEVEL = 10;
+var CELL_COUNT = 12 * 4 ** 10;
+var FIRST_TABLE = 1;
+var LAST_TABLE = 30;
+var CELL_SPAN = 2 ** 24;
+var TABLE_SPAN = 32;
+var SERIAL_SPAN = 2 ** 29;
+var ID_TEXT = /^[1-9][0-9]{0,15}$/;
+var EXTRASOLAR_PREFIX = "x-";
+function decodeId(id) {
+	return {
+		serial: Math.floor(id / SERIAL_SPAN),
+		table: Math.floor(id / CELL_SPAN) % TABLE_SPAN,
+		cell: id % CELL_SPAN
+	};
+}
+function cellOf(id) {
+	return id % CELL_SPAN;
+}
+function tableOf(id) {
+	return Math.floor(id / CELL_SPAN) % TABLE_SPAN;
+}
+function parseExtrasolarId(text, tables) {
+	if (!ID_TEXT.test(text)) return null;
+	const id = Number(text);
+	if (id > Number.MAX_SAFE_INTEGER) return null;
+	const { table, cell } = decodeId(id);
+	if (cell >= CELL_COUNT) return null;
+	if (tables ? !tables.has(table) : table < 1 || table > 30) return null;
+	return id;
+}
+function isExtrasolarObjectId(objectId) {
+	return objectId.startsWith("x-");
+}
+function extrasolarObjectId(id) {
+	return `${"x-"}${id}`;
+}
+
 //#endregion
 //#region src/lib/fetch/gz.ts
 function gunzip(res) {
@@ -10100,6 +10322,10 @@ function isViewable(entry) {
 	return textureAllowed(entry.distribution);
 }
 function fetchObjectDetail(fileId, fetchLocalized = true, lang = getLocale(), background = false) {
+	if (isExtrasolarObjectId(fileId)) return Promise.resolve({
+		global: null,
+		localized: null
+	});
 	return fetchBundlePair(OBJECT_BUNDLES, fileId, lang, fetchLocalized, background);
 }
 
@@ -10135,6 +10361,585 @@ function planRideMarkers(rides, focusedId, sceneName) {
 	};
 }
 
+//#endregion
+//#region src/lib/fetch/extrasolar/container.ts
+var MAGIC$2 = "SMXS";
+var FORMAT_VERSION = 1;
+var KIND_NODE = 3;
+var HEADER_SIZE$2 = 32;
+var TOKEN_AT = 8;
+var TOKEN_SIZE = 16;
+var HAS_VALIDITY = 1;
+var NODE_INFO_SIZE = 80;
+var TYPE_CODES = {
+	1: "bool",
+	2: "int8",
+	3: "int16",
+	4: "int32",
+	5: "uint8",
+	6: "uint16",
+	7: "uint32",
+	8: "float32",
+	9: "float64",
+	10: "id",
+	11: "string",
+	12: "dict",
+	13: "cross_ids",
+	14: "bits"
+};
+var ContainerFormatError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ContainerFormatError";
+	}
+};
+var decoder = new TextDecoder();
+function bitAt(bytes, i) {
+	return (bytes[i >> 3] >> (i & 7) & 1) === 1;
+}
+var StringColumn = class {
+	constructor(offsets, bytes, validity) {
+		this.offsets = offsets;
+		this.bytes = bytes;
+		this.validity = validity;
+	}
+	get length() {
+		return this.offsets.length - 1;
+	}
+	get(i) {
+		if (this.validity && !bitAt(this.validity, i)) return null;
+		return decoder.decode(this.bytes.subarray(this.offsets[i], this.offsets[i + 1]));
+	}
+};
+var DictColumn = class {
+	constructor(codes, values, validity) {
+		this.codes = codes;
+		this.values = values;
+		this.validity = validity;
+	}
+	get length() {
+		return this.codes.length;
+	}
+	get(i) {
+		if (this.validity && !bitAt(this.validity, i)) return null;
+		return this.values[this.codes[i]];
+	}
+};
+var CrossIdsColumn = class {
+	constructor(list, codes, ids, pairs, validity) {
+		this.list = list;
+		this.codes = codes;
+		this.ids = ids;
+		this.pairs = pairs;
+		this.validity = validity;
+	}
+	get length() {
+		return this.list.length - 1;
+	}
+	get(i) {
+		if (this.validity && !bitAt(this.validity, i)) return null;
+		const out = [];
+		for (let j = this.list[i]; j < this.list[i + 1]; j++) {
+			const code = this.codes[j];
+			out.push({
+				catalogue: this.pairs.get(2 * code) ?? "",
+				release: this.pairs.get(2 * code + 1) ?? "",
+				catalogueId: this.ids.get(j) ?? ""
+			});
+		}
+		return out;
+	}
+};
+var BitColumn = class {
+	constructor(bytes, length) {
+		this.bytes = bytes;
+		this.length = length;
+	}
+	get(i) {
+		return bitAt(this.bytes, i);
+	}
+};
+var Container = class {
+	kind;
+	token;
+	rows;
+	info;
+	columns = /* @__PURE__ */ new Map();
+	constructor(buffer) {
+		this.buffer = buffer;
+		if (buffer.byteLength < HEADER_SIZE$2) throw new ContainerFormatError("payload too short");
+		const view = new DataView(buffer);
+		if (decoder.decode(new Uint8Array(buffer, 0, 4)) !== "SMXS") throw new ContainerFormatError("not an extrasolar file");
+		const version = view.getUint16(4, true);
+		if (version !== 1) throw new ContainerFormatError(`format version ${version}, this code reads ${1}`);
+		this.kind = view.getUint8(6);
+		this.token = decoder.decode(new Uint8Array(buffer, TOKEN_AT, TOKEN_SIZE));
+		this.rows = view.getUint32(24, true);
+		const count = view.getUint16(28, true);
+		const infoSize = view.getUint16(30, true);
+		this.info = new DataView(buffer, HEADER_SIZE$2, infoSize);
+		let at = HEADER_SIZE$2 + infoSize;
+		for (let c = 0; c < count; c++) {
+			const code = view.getUint8(at);
+			const flags = view.getUint8(at + 1);
+			const buffers = view.getUint8(at + 2);
+			const nameSize = view.getUint8(at + 3);
+			at += 4;
+			const name = decoder.decode(new Uint8Array(buffer, at, nameSize));
+			at += nameSize;
+			const places = [];
+			for (let b = 0; b < buffers; b++) {
+				const offset = view.getUint32(at, true);
+				const length = view.getUint32(at + 4, true);
+				if (offset % 8 !== 0 || offset + length > buffer.byteLength) throw new ContainerFormatError(`${name}: buffer ${b} out of place`);
+				places.push({
+					offset,
+					length
+				});
+				at += 8;
+			}
+			const type = TYPE_CODES[code];
+			if (!type) throw new ContainerFormatError(`${name}: unknown type ${code}`);
+			const first = (flags & HAS_VALIDITY) !== 0 ? places.shift() : void 0;
+			this.columns.set(name, {
+				type,
+				validity: first ? new Uint8Array(buffer, first.offset, first.length) : null,
+				places
+			});
+		}
+	}
+	names() {
+		return [...this.columns.keys()];
+	}
+	has(name) {
+		return this.columns.has(name);
+	}
+	type(name) {
+		return this.entry(name).type;
+	}
+	isValid(name, row) {
+		const { validity } = this.entry(name);
+		return validity === null || bitAt(validity, row);
+	}
+	bool(name) {
+		return this.numbers(name, "bool", Uint8Array);
+	}
+	int8(name) {
+		return this.numbers(name, "int8", Int8Array);
+	}
+	int16(name) {
+		return this.numbers(name, "int16", Int16Array);
+	}
+	int32(name) {
+		return this.numbers(name, "int32", Int32Array);
+	}
+	uint8(name) {
+		return this.numbers(name, "uint8", Uint8Array);
+	}
+	uint16(name) {
+		return this.numbers(name, "uint16", Uint16Array);
+	}
+	uint32(name) {
+		return this.numbers(name, "uint32", Uint32Array);
+	}
+	float32(name) {
+		return this.numbers(name, "float32", Float32Array);
+	}
+	float64(name) {
+		return this.numbers(name, "float64", Float64Array);
+	}
+	ids(name) {
+		return this.numbers(name, "id", Float64Array);
+	}
+	strings(name) {
+		const { validity, places } = this.typed(name, "string");
+		return this.stringList(places[0], places[1], validity);
+	}
+	dict(name) {
+		const { validity, places } = this.typed(name, "dict");
+		const values = this.stringList(places[1], places[2], null);
+		const strings = [];
+		for (let k = 0; k < values.length; k++) strings.push(values.get(k) ?? "");
+		return new DictColumn(this.view(places[0], Uint16Array), strings, validity);
+	}
+	crossIds(name) {
+		const { validity, places } = this.typed(name, "cross_ids");
+		return new CrossIdsColumn(this.view(places[0], Uint32Array), this.view(places[1], Uint16Array), this.stringList(places[2], places[3], null), this.stringList(places[4], places[5], null), validity);
+	}
+	bits(name) {
+		const { places } = this.typed(name, "bits");
+		return new BitColumn(this.view(places[0], Uint8Array), this.rows);
+	}
+	entry(name) {
+		const entry = this.columns.get(name);
+		if (!entry) throw new ContainerFormatError(`no column ${name}`);
+		return entry;
+	}
+	typed(name, type) {
+		const entry = this.entry(name);
+		if (entry.type !== type) throw new ContainerFormatError(`${name} is ${entry.type}, not ${type}`);
+		return entry;
+	}
+	numbers(name, type, Kind) {
+		return this.view(this.typed(name, type).places[0], Kind);
+	}
+	view(place, Kind) {
+		return new Kind(this.buffer, place.offset, place.length / Kind.BYTES_PER_ELEMENT);
+	}
+	stringList(offsets, bytes, validity) {
+		return new StringColumn(this.view(offsets, Uint32Array), new Uint8Array(this.buffer, bytes.offset, bytes.length), validity);
+	}
+};
+function nodeInfo(container) {
+	const info = container.info;
+	if (container.kind !== 3 || info.byteLength !== NODE_INFO_SIZE) throw new ContainerFormatError("not a render node");
+	const childRange = new Float32Array(8);
+	for (let k = 0; k < 8; k++) childRange[k] = info.getFloat32(40 + 4 * k, true);
+	return {
+		centre: [
+			info.getFloat64(0, true),
+			info.getFloat64(8, true),
+			info.getFloat64(16, true)
+		],
+		half: info.getFloat64(24, true),
+		minRange: info.getFloat32(32, true),
+		maxRange: info.getFloat32(36, true),
+		childRange,
+		depth: info.getUint8(72),
+		childMask: info.getUint8(73)
+	};
+}
+
+//#endregion
+//#region src/lib/fetch/extrasolar/files.ts
+var EXTRASOLAR_FORMAT = 1;
+var ExtrasolarStaleError = class extends Error {
+	constructor(path, found, expected) {
+		super(`${path}: token ${found}, expected ${expected}`);
+		this.name = "ExtrasolarStaleError";
+	}
+};
+function extrasolarBase() {
+	return host().extrasolarUrl;
+}
+function extrasolarAllowed(entry) {
+	return textureAllowed(entry.distribution);
+}
+function extrasolarPath(pattern, fields) {
+	return pattern.replace(/\{(\w+)\}/g, (whole, key) => {
+		const value = fields[key];
+		if (value === void 0) throw new Error(`extrasolarPath: no ${key} for ${pattern}`);
+		return String(value);
+	});
+}
+function extrasolarUrl(path, token) {
+	return `${extrasolarBase()}/v1/x/${path}?v=${token}`;
+}
+var metadataBase = null;
+var metadataPending = null;
+function fetchExtrasolarMetadata() {
+	const base = extrasolarBase();
+	if (metadataPending && metadataBase === base) return metadataPending;
+	metadataBase = base;
+	if (base === "") {
+		metadataPending = Promise.resolve(null);
+		return metadataPending;
+	}
+	const p = (async () => {
+		const res = await fetchWithTimeout(`${base}/v1/x/metadata.json`, { cache: "no-cache" });
+		if (!res.ok) throw new Error(`extrasolar metadata.json returned ${res.status}`);
+		const meta = await res.json();
+		if (meta.format !== 1) throw new Error(`extrasolar format ${meta.format}, this code reads ${1}`);
+		return meta;
+	})();
+	metadataPending = p;
+	p.catch(() => {
+		if (metadataPending === p) metadataPending = null;
+	});
+	return p;
+}
+var staleListeners = /* @__PURE__ */ new Set();
+var staleReported = false;
+function onExtrasolarStale(listener) {
+	staleListeners.add(listener);
+	return () => staleListeners.delete(listener);
+}
+function reportStale() {
+	if (staleReported) return;
+	staleReported = true;
+	for (const listener of staleListeners) listener();
+}
+async function fetchExtrasolarFile(path, token, options = {}) {
+	const url = extrasolarUrl(path, token);
+	const res = await fetchWithTimeout(url, {
+		signal: options.signal,
+		priority: options.priority
+	});
+	if (!res.ok) throw new Error(`${url} returned ${res.status}`);
+	const container = new Container(await gunzip(res).arrayBuffer());
+	if (container.token !== token) {
+		reportStale();
+		throw new ExtrasolarStaleError(path, container.token, token);
+	}
+	return container;
+}
+
+//#endregion
+//#region src/lib/fetch/extrasolar/split.ts
+var ROOTS = 12;
+var SplitTree = class SplitTree {
+	constructor(first, level) {
+		this.first = first;
+		this.level = level;
+	}
+	static fromBits(bits) {
+		const first = [];
+		const level = [];
+		let at = 0;
+		const visit = (depth, pixel) => {
+			if (at >= bits.length) throw new ContainerFormatError("split table too short");
+			if (!bits.get(at++)) {
+				first.push(pixel * 4 ** (10 - depth));
+				level.push(depth);
+				return;
+			}
+			if (depth === 10) throw new ContainerFormatError("a cell cannot split");
+			for (let k = 0; k < 4; k++) visit(depth + 1, 4 * pixel + k);
+		};
+		for (let root = 0; root < ROOTS; root++) visit(0, root);
+		if (at !== bits.length) throw new ContainerFormatError(`split table has ${bits.length} bits, the tree ${at}`);
+		return new SplitTree(Uint32Array.from(first), Uint8Array.from(level));
+	}
+	get leaves() {
+		return this.first.length;
+	}
+	tileOf(cell) {
+		const first = this.first;
+		let lo = 0;
+		let hi = first.length - 1;
+		while (lo < hi) {
+			const mid = lo + hi + 1 >> 1;
+			if (first[mid] <= cell) lo = mid;
+			else hi = mid - 1;
+		}
+		const level = this.level[lo];
+		return {
+			level,
+			pixel: first[lo] / 4 ** (10 - level)
+		};
+	}
+};
+function findId(ids, id) {
+	let lo = 0;
+	let hi = ids.length - 1;
+	while (lo <= hi) {
+		const mid = lo + hi >>> 1;
+		const at = ids[mid];
+		if (at === id) return mid;
+		if (at < id) lo = mid + 1;
+		else hi = mid - 1;
+	}
+	return -1;
+}
+
+//#endregion
+//#region src/lib/fetch/extrasolar/lookup.ts
+var METADATA_SLUG = "metadata";
+var TableRow = class {
+	constructor(slug, table, container, row) {
+		this.slug = slug;
+		this.table = table;
+		this.container = container;
+		this.row = row;
+	}
+	has(name) {
+		return this.container.has(name);
+	}
+	number(name) {
+		const c = this.container;
+		if (!c.has(name) || !c.isValid(name, this.row)) return null;
+		let value;
+		switch (c.type(name)) {
+			case "float32":
+				value = c.float32(name)[this.row];
+				break;
+			case "float64":
+				value = c.float64(name)[this.row];
+				break;
+			case "int8":
+				value = c.int8(name)[this.row];
+				break;
+			case "int16":
+				value = c.int16(name)[this.row];
+				break;
+			case "int32":
+				value = c.int32(name)[this.row];
+				break;
+			case "uint8":
+				value = c.uint8(name)[this.row];
+				break;
+			case "uint16":
+				value = c.uint16(name)[this.row];
+				break;
+			case "uint32":
+				value = c.uint32(name)[this.row];
+				break;
+			case "id":
+				value = c.ids(name)[this.row];
+				break;
+			default: throw new Error(`${this.slug}.${name} is not a number column`);
+		}
+		return Number.isNaN(value) ? null : value;
+	}
+	text(name) {
+		const c = this.container;
+		if (!c.has(name)) return null;
+		const type = c.type(name);
+		if (type === "dict") return c.dict(name).get(this.row);
+		if (type === "string") return c.strings(name).get(this.row);
+		throw new Error(`${this.slug}.${name} is not a text column`);
+	}
+	flag(name) {
+		const c = this.container;
+		if (!c.has(name) || !c.isValid(name, this.row)) return null;
+		return c.bool(name)[this.row] === 1;
+	}
+};
+var DEFAULT_LIMITS = {
+	tiles: 32,
+	results: 64
+};
+var MIN_PARALLAX_SNR = 5;
+function parallaxDistancePc(row) {
+	const parallax = row.number("parallax");
+	const error = row.number("parallax_error");
+	if (parallax === null || error === null || !(parallax / error > MIN_PARALLAX_SNR)) return null;
+	return 1e3 / parallax;
+}
+function homeRow(record) {
+	return record.home && record.rows.get(record.home) || null;
+}
+function hasDistance(record) {
+	const home = homeRow(record);
+	return home !== null && parallaxDistancePc(home) !== null;
+}
+function readMetadataRow(c, row) {
+	const alias = c.isValid("alias_target", row) ? c.ids("alias_target")[row] : 0;
+	return {
+		id: c.ids("id")[row],
+		name: c.strings("name").get(row),
+		nameSource: c.dict("name_source").get(row),
+		class: c.dict("class").get(row),
+		classSource: c.dict("class_source").get(row),
+		crossIds: c.crossIds("cross_ids").get(row) ?? [],
+		mask: c.uint32("mask")[row],
+		objectFile: c.strings("object_file").get(row),
+		aliasTarget: alias > 0 ? alias : null
+	};
+}
+var ExtrasolarLookup = class {
+	splits = /* @__PURE__ */ new Map();
+	tiles;
+	results;
+	constructor(source, limits = DEFAULT_LIMITS) {
+		this.source = source;
+		this.tiles = new LruPromiseCache(limits.tiles);
+		this.results = new LruPromiseCache(limits.results);
+	}
+	async live(id, options = {}) {
+		const first = await this.lookup(id, options);
+		return first.kind === "alias" ? this.lookup(first.target, options) : first;
+	}
+	lookup(id, options = {}) {
+		const data = options.data ?? true;
+		return this.results.getOrCompute(`${id}:${data}`, () => this.resolve(String(id), data));
+	}
+	async resolve(text, data) {
+		const meta = await this.source.metadata();
+		if (!meta) return {
+			kind: "missing",
+			reason: "unconfigured"
+		};
+		const numbered = /* @__PURE__ */ new Map();
+		for (const [slug, table] of Object.entries(meta.tables)) if (table.number !== null) numbered.set(table.number, {
+			slug,
+			table
+		});
+		const id = parseExtrasolarId(text, new Set(numbered.keys()));
+		if (id === null) return {
+			kind: "missing",
+			reason: "id"
+		};
+		const metaTable = meta.tables[METADATA_SLUG];
+		if (!metaTable || !this.source.allowed(metaTable)) return {
+			kind: "missing",
+			reason: "barred"
+		};
+		const cell = cellOf(id);
+		const home = numbered.get(tableOf(id));
+		const homeShown = data && this.source.allowed(home.table);
+		const [metaTile, homeTile] = await Promise.all([this.tile(METADATA_SLUG, metaTable, cell), homeShown ? this.tile(home.slug, home.table, cell) : null]);
+		const metaRow = findId(metaTile.ids("id"), id);
+		if (metaRow < 0) return {
+			kind: "missing",
+			reason: "no-row"
+		};
+		const metadata = readMetadataRow(metaTile, metaRow);
+		if (metadata.aliasTarget !== null) return {
+			kind: "alias",
+			id,
+			target: metadata.aliasTarget
+		};
+		const rows = /* @__PURE__ */ new Map();
+		const adopt = (entry, tile) => {
+			const row = findId(tile.ids("id"), id);
+			if (row >= 0) rows.set(entry.slug, new TableRow(entry.slug, entry.table, tile, row));
+		};
+		if (homeTile) adopt(home, homeTile);
+		if (data) {
+			const others = [];
+			for (let n = 1; n <= 30; n++) {
+				const entry = numbered.get(n);
+				if (!(metadata.mask >>> n & 1) || !entry || entry === home) continue;
+				if (this.source.allowed(entry.table)) others.push(entry);
+			}
+			const tiles = await Promise.all(others.map((entry) => this.tile(entry.slug, entry.table, cell)));
+			others.forEach((entry, i) => adopt(entry, tiles[i]));
+		}
+		return {
+			kind: "live",
+			record: {
+				id,
+				metadata,
+				rows,
+				home: home.slug,
+				credits: meta.credits
+			}
+		};
+	}
+	split(slug, table) {
+		const key = `${slug}?v=${table.token}`;
+		const held = this.splits.get(key);
+		if (held) return held;
+		const p = this.source.file(table.split, table.token).then((c) => SplitTree.fromBits(c.bits("split")));
+		this.splits.set(key, p);
+		p.catch(() => {
+			if (this.splits.get(key) === p) this.splits.delete(key);
+		});
+		return p;
+	}
+	async tile(slug, table, cell) {
+		const split = await this.split(slug, table);
+		const path = extrasolarPath(table.tile, split.tileOf(cell));
+		return this.tiles.getOrCompute(`${path}?v=${table.token}`, () => this.source.file(path, table.token));
+	}
+};
+var extrasolarLookup = new ExtrasolarLookup({
+	metadata: fetchExtrasolarMetadata,
+	file: (path, token) => fetchExtrasolarFile(path, token),
+	allowed: extrasolarAllowed
+});
+
 //#endregion
 //#region src/lib/fetch/coverage.ts
 var EDGE_INSET_JD = 1 / 1440;
@@ -10147,6 +10952,10 @@ async function earthZoneEndJd() {
 	return zoom && isDateSegmented(zoom) ? unixMsToJD(lastCoveredMs(zoom)) : Infinity;
 }
 async function coverageOf(id) {
+	if (isExtrasolarObjectId(id)) {
+		const result = await extrasolarLookup.live(id.slice("x-".length));
+		return result.kind === "live" && hasDistance(result.record) ? [[-Infinity, Infinity]] : [];
+	}
 	const detail = await fetchObjectDetail(id, false);
 	const windows = detail.global?.coverage?.windows ?? [];
 	const tle = detail.global?.orbit?.scale === "planet";
@@ -10378,6 +11187,30 @@ function applySouthTowardParent(obj, bodyPos, parentPos) {
 function applyUpVector(obj, dir) {
 	obj.quaternion.setFromUnitVectors(LOCAL_NORTH, dir);
 }
+function landedHeadingAt(headings, jd) {
+	let deg;
+	for (const h of headings ?? []) if (h.jd <= jd) deg = h.deg;
+	return deg;
+}
+var LOCAL_FRONT = new Vector3(0, 0, 1);
+var _up = new Vector3();
+var _front = new Vector3();
+var _north = new Vector3();
+var _east = new Vector3();
+var _target = new Vector3();
+var _cross = new Vector3();
+var _turn = new Quaternion();
+function turnToHeading(obj, north, headingDeg) {
+	_up.copy(LOCAL_NORTH).applyQuaternion(obj.quaternion);
+	_north.copy(north).addScaledVector(_up, -north.dot(_up)).normalize();
+	_east.crossVectors(_north, _up);
+	const h = headingDeg * DEG2RAD$5;
+	_target.copy(_north).multiplyScalar(Math.cos(h)).addScaledVector(_east, Math.sin(h));
+	_front.copy(LOCAL_FRONT).applyQuaternion(obj.quaternion);
+	_front.addScaledVector(_up, -_front.dot(_up)).normalize();
+	const angle = Math.atan2(_cross.crossVectors(_front, _target).dot(_up), _front.dot(_target));
+	obj.quaternion.premultiply(_turn.setFromAxisAngle(_up, angle));
+}
 var AXIS_VECTORS = {
 	"+x": new Vector3(1, 0, 0),
 	"-x": new Vector3(-1, 0, 0),
@@ -11405,7 +12238,7 @@ function isLowEndDevice() {
 	return typeof mem === "number" && mem > 0 && mem <= LOW_MEMORY_GIB;
 }
 var coarsePointer;
-function isCoarsePointer() {
+function isCoarsePointer$1() {
 	if (coarsePointer === void 0) coarsePointer = typeof window !== "undefined" && !!window.matchMedia?.("(pointer: coarse)").matches;
 	return coarsePointer;
 }
@@ -11526,7 +12359,7 @@ var ATMOSPHERE_QUALITY_PRESETS = {
 	}
 };
 function heuristicAtmosphereTier() {
-	if (isCoarsePointer()) return isLowEndDevice() ? "low" : "medium";
+	if (isCoarsePointer$1()) return isLowEndDevice() ? "low" : "medium";
 	return isLowEndDevice() ? "high" : "ultra";
 }
 function resolveAtmosphereTier(tier) {
@@ -12893,7 +13726,7 @@ function attachCanvasForwarders(el, canvas) {
 
 //#endregion
 //#region src/lib/scene/relief/worker.ts?worker&inline
-var jsContent$1 = "function e(e,t,n,r){return`${e&&`${e}/`}${t}/${n}/${r}.webp`}function t(e,t,n,r,i=1){let a=t.length,o=n.length,s=new Float32Array(a*o*3),c=new Float32Array(a*o*3),l=new Float32Array(a*o*2),u=Float64Array.from(n,Math.sin),d=Float64Array.from(n,Math.cos);for(let f=0;f<a;f++){let a=t[f],p=Math.sin(a),m=Math.cos(a);for(let t=0;t<o;t++){let h=f*o+t,g=-d[t]*p,_=m,v=u[t]*p,y=e+(r?r[h]*i:0),b=h*3;s[b]=y*g,s[b+1]=y*_,s[b+2]=y*v,c[b]=g,c[b+1]=_,c[b+2]=v;let x=h*2;l[x]=n[t]/(2*Math.PI),l[x+1]=1-a/Math.PI}}let f=new Uint32Array((a-1)*(o-1)*6),p=0;for(let e=0;e<a-1;e++){let n=t[e]<=0,r=t[e+1]>=Math.PI;for(let t=0;t<o-1;t++){let i=e*o+t+1,a=e*o+t,s=(e+1)*o+t,c=(e+1)*o+t+1;n||(f[p++]=i,f[p++]=a,f[p++]=c),r||(f[p++]=a,f[p++]=s,f[p++]=c)}}return{positions:s,normals:c,uvs:l,indices:f.subarray(0,p)}}const n=[``,`north`,`south`],r=Math.SQRT2-1;function i(e,t){return e===0?2<<t:1<<t-1}function a(e,t){return e===0?1<<t:1<<t-1}function o(e,t,n,i){if(e===0){let e=Math.atan2(i,-t)/(2*Math.PI);return{x:e<0?e+1:e,y:Math.acos(Math.min(Math.max(n,-1),1))/Math.PI}}let a=e===1?1:-1,o=.5/(r*(1+a*n));return{x:.5+t*o,y:.5+a*i*o}}function s(e,t,n,r){let i=e.max_level-t;return i>=0&&n>=e.x[0]>>i&&n<=e.x[1]>>i&&r>=e.y[0]>>i&&r<=e.y[1]>>i}function c(e,t,n,r){return e?.find(e=>s(e,t,n,r))}const l=Math.sin(60*Math.PI/180),u=2**18,d=2**17;function f(e,t,n,r){return((e*32+t)*u+n)*d+r}function p(e){let t=e%d,n=Math.floor(e/d)%u,r=Math.floor(e/(d*u));return{chart:Math.floor(r/32),level:r%32,x:n,y:t}}const m={chart:0,level:0,x0:0,x1:0,y0:0,y1:0,fx:0,fy:0};function h(e,t,n,r,s){let c=e<1||Math.abs(n)<=l?0:n>0?1:2,u=i(c,e)*s,d=a(c,e)*s,f=o(c,t,n,r),p=f.x*u-.5,h=f.y*d-.5,g=Math.floor(p),_=Math.floor(h),v=e=>Math.min(Math.max(e,0),u-1),y=e=>Math.min(Math.max(e,0),d-1);return m.chart=c,m.level=e,m.fx=p-g,m.fy=h-_,m.x0=c===0?(g+u)%u:v(g),m.x1=c===0?(g+1)%u:v(g+1),m.y0=y(_),m.y1=y(_+1),m}function g(e,t,n){let r=Float64Array.from(t.at,Math.sin),i=Float64Array.from(t.at,Math.cos),a=t.at.length;for(let o=0;o<e.at.length;o++){let s=Math.sin(e.at[o]),c=Math.cos(e.at[o]);for(let l=0;l<a;l++){let u=Math.min(e.level[o],t.level[l]);n(o*a+l,u,-i[l]*s,c,r[l]*s)}}}function _(e,t,n,r=1/0,i=()=>!0){let a=new Set([f(0,0,0,0),f(0,0,1,0)]);return g(e,t,(e,t,o,s,c)=>{for(let e=t;;e--){let t=h(e,o,s,c,n),l=Math.floor(t.x0/n),u=Math.floor(t.x1/n),d=Math.floor(t.y0/n),p=Math.floor(t.y1/n);if(!(e>r&&!(i(t.chart,e,l,d)&&i(t.chart,e,u,d)&&i(t.chart,e,l,p)&&i(t.chart,e,u,p)))){a.add(f(t.chart,e,l,d)),u!==l&&a.add(f(t.chart,e,u,d)),p!==d&&(a.add(f(t.chart,e,l,p)),u!==l&&a.add(f(t.chart,e,u,p)));return}}}),a}function v(e,t,n,r,i,a){for(let o=t;o>=0;o--){let t=h(o,n,r,i,a),s=(n,r)=>{let i=e(f(t.chart,o,Math.floor(n/a),Math.floor(r/a)));return i&&i[r%a*a+n%a]},c=s(t.x0,t.y0),l=s(t.x1,t.y0),u=s(t.x0,t.y1),d=s(t.x1,t.y1);if(c===void 0||l===void 0||u===void 0||d===void 0)continue;let p=c+(l-c)*t.fx;return p+(u+(d-u)*t.fx-p)*t.fy}}function y(e,t,n,r,i,a){let o=new Float32Array(e.at.length*t.at.length),s=!1;return g(e,t,(e,t,c,l,u)=>{let d=v(n,t,c,l,u,r);d===void 0?s=!0:o[e]=a+i*d/65535}),s?null:o}function b(e,t){let n=new Uint8Array(t*t*2);for(let r=0;r<t;r++){let i=(t-1-r)*t*4,a=r*t*2;for(let r=0;r<t;r++,i+=4,a+=2)n[a]=e[i],n[a+1]=e[i+1]}return n}function x(e,t){let n=new Float32Array(t*t);for(let r=0;r<t;r++){let i=(t-1-r)*t*4,a=(r+1)*t;for(let o=r*t;o<a;o++,i+=4)n[o]=(e[i]<<8|e[i+1])+e[i+2]/256}return n}function S(e,t,n){let r=n?new Float32Array(t*t):new Uint16Array(t*t);for(let t=0,i=0;t<r.length;t++,i+=4){let a=e[i]<<8|e[i+1];r[t]=n?a+e[i+2]/256:a}return r}const C=self,w=new Map;let T;async function E(e,t){let n=await fetch(e,{signal:t});if(!n.ok)throw Error(`tile ${n.status}`);let r=await createImageBitmap(await n.blob(),{premultiplyAlpha:`none`,colorSpaceConversion:`none`}),i=r.width;T?.width!==i&&(T=new OffscreenCanvas(i,i));let a=T.getContext(`2d`,{willReadFrequently:!0});if(!a)throw Error(`no 2d canvas in this worker`);return a.globalCompositeOperation=`copy`,a.drawImage(r,0,0),r.close(),{rgba:a.getImageData(0,0,i,i).data,size:i}}async function D(e,t){let{rgba:n,size:r}=await E(e.url,t),i=e.fine?x(n,r):b(n,r);C.postMessage({type:`tile`,id:e.id,size:r,heights:i},[i.buffer])}const O=new Map;let k=``;async function A(r,i){let{rows:a,columns:o,tileSize:s,maxLevel:l,patches:u}=r,d=[r.version,...u.map(e=>e.version)],f=`${r.root}?${d.join()}`;f!==k&&O.clear(),k=f;let m=(e,t,n,r)=>e===0?c(u,t,n,r):void 0,h=_(a,o,s,l,(e,t,n,r)=>m(e,t,n,r)!==void 0),g=[...h].filter(e=>!O.has(e));await Promise.all(Array.from({length:6},async()=>{for(let t=g.pop();t!==void 0;t=g.pop()){let{chart:a,level:o,x:s,y:c}=p(t),u=o>l,d=u?m(a,o,s,c)?.version:r.version,f=`${r.root}${e(n[a],o,s,c)}?v=${d}`;try{let{rgba:e,size:n}=await E(f,i);O.set(t,S(e,n,u))}catch{if(i.aborted)return}}})),i.throwIfAborted();let v=y(a,o,e=>O.get(e),s,r.scaleKm,r.biasKm);for(let e of[...O.keys()])h.has(e)||O.delete(e);if(!v)throw Error(`no height tiles for the grid`);let b=t(r.radius,a.at,o.at,v,r.unitsPerKm),x=b.indices.slice();C.postMessage({type:`grid`,id:r.id,...b,indices:x,riseKm:v},[b.positions.buffer,b.normals.buffer,b.uvs.buffer,x.buffer,v.buffer])}async function j(e){let t=new AbortController;w.set(e.id,t);try{e.type===`tile`?await D(e,t.signal):await A(e,t.signal)}catch{C.postMessage({type:`failed`,id:e.id})}finally{w.delete(e.id)}}self.onmessage=e=>{let t=e.data;t.type===`abort`?w.get(t.id)?.abort():j(t)};";
+var jsContent$1 = "function e(e,t,n,r){return`${e&&`${e}/`}${t}/${n}/${r}.webp`}function t(e,t,n,r,i=1){let a=t.length,o=n.length,s=new Float32Array(a*o*3),c=new Float32Array(a*o*3),l=new Float32Array(a*o*2),u=Float64Array.from(n,Math.sin),d=Float64Array.from(n,Math.cos);for(let f=0;f<a;f++){let a=t[f],p=Math.sin(a),m=Math.cos(a);for(let t=0;t<o;t++){let h=f*o+t,g=-d[t]*p,_=m,v=u[t]*p,y=e+(r?r[h]*i:0),b=h*3;s[b]=y*g,s[b+1]=y*_,s[b+2]=y*v,c[b]=g,c[b+1]=_,c[b+2]=v;let x=h*2;l[x]=n[t]/(2*Math.PI),l[x+1]=1-a/Math.PI}}let f=new Uint32Array((a-1)*(o-1)*6),p=0;for(let e=0;e<a-1;e++){let n=t[e]<=0,r=t[e+1]>=Math.PI;for(let t=0;t<o-1;t++){let i=e*o+t+1,a=e*o+t,s=(e+1)*o+t,c=(e+1)*o+t+1;n||(f[p++]=i,f[p++]=a,f[p++]=c),r||(f[p++]=a,f[p++]=s,f[p++]=c)}}return{positions:s,normals:c,uvs:l,indices:f.subarray(0,p)}}const n=[``,`north`,`south`],r=Math.SQRT2-1;function i(e,t){return e===0?2<<t:1<<t-1}function a(e,t){return e===0?1<<t:1<<t-1}function o(e,t,n,i){if(e===0){let e=Math.atan2(i,-t)/(2*Math.PI);return{x:e<0?e+1:e,y:Math.acos(Math.min(Math.max(n,-1),1))/Math.PI}}let a=e===1?1:-1,o=.5/(r*(1+a*n));return{x:.5+t*o,y:.5+a*i*o}}function s(e){return e.cap===`north`?1:e.cap===`south`?2:0}function c(e,t,n,r,i){let a=e.max_level-n;return a>=0&&s(e)===t&&r>=e.x[0]>>a&&r<=e.x[1]>>a&&i>=e.y[0]>>a&&i<=e.y[1]>>a}function l(e,t,n,r,i){return e?.find(e=>c(e,t,n,r,i))}const u=Math.sin(60*Math.PI/180),d=2**18,f=2**17;function p(e,t,n,r){return((e*32+t)*d+n)*f+r}function m(e){let t=e%f,n=Math.floor(e/f)%d,r=Math.floor(e/(f*d));return{chart:Math.floor(r/32),level:r%32,x:n,y:t}}const h={chart:0,level:0,x0:0,x1:0,y0:0,y1:0,fx:0,fy:0};function g(e,t){return e<1||Math.abs(t)<=u?0:t>0?1:2}function _(e,t,n,r,s){let c=g(e,n),l=i(c,e)*s,u=a(c,e)*s,d=o(c,t,n,r),f=d.x*l-.5,p=d.y*u-.5,m=Math.floor(f),_=Math.floor(p),v=e=>Math.min(Math.max(e,0),l-1),y=e=>Math.min(Math.max(e,0),u-1);return h.chart=c,h.level=e,h.fx=f-m,h.fy=p-_,h.x0=c===0?(m+l)%l:v(m),h.x1=c===0?(m+1)%l:v(m+1),h.y0=y(_),h.y1=y(_+1),h}function v(e,t,n){let r=Float64Array.from(t.at,Math.sin),i=Float64Array.from(t.at,Math.cos),a=t.at.length;for(let o=0;o<e.at.length;o++){let s=Math.sin(e.at[o]),c=Math.cos(e.at[o]);for(let l=0;l<a;l++){let u=Math.min(e.level[o],t.level[l]);n(o*a+l,u,-i[l]*s,c,r[l]*s)}}}function y(e,t,n,r=1/0,i=()=>!0){let a=new Set([p(0,0,0,0),p(0,0,1,0)]);return v(e,t,(e,t,o,s,c)=>{for(let e=t;;e--){let t=_(e,o,s,c,n),l=Math.floor(t.x0/n),u=Math.floor(t.x1/n),d=Math.floor(t.y0/n),f=Math.floor(t.y1/n);if(!(e>r&&!(i(t.chart,e,l,d)&&i(t.chart,e,u,d)&&i(t.chart,e,l,f)&&i(t.chart,e,u,f)))){a.add(p(t.chart,e,l,d)),u!==l&&a.add(p(t.chart,e,u,d)),f!==d&&(a.add(p(t.chart,e,l,f)),u!==l&&a.add(p(t.chart,e,u,f)));return}}}),a}function b(e,t,n,r,i,a){for(let o=t;o>=0;o--){let t=_(o,n,r,i,a),s=(n,r)=>{let i=e(p(t.chart,o,Math.floor(n/a),Math.floor(r/a)));return i&&i[r%a*a+n%a]},c=s(t.x0,t.y0),l=s(t.x1,t.y0),u=s(t.x0,t.y1),d=s(t.x1,t.y1);if(c===void 0||l===void 0||u===void 0||d===void 0)continue;let f=c+(l-c)*t.fx;return f+(u+(d-u)*t.fx-f)*t.fy}}function x(e,t,n,r,i,a){let o=new Float32Array(e.at.length*t.at.length),s=!1;return v(e,t,(e,t,c,l,u)=>{let d=b(n,t,c,l,u,r);d===void 0?s=!0:o[e]=a+i*d/65535}),s?null:o}function S(e,t){let n=new Uint8Array(t*t*2);for(let r=0;r<t;r++){let i=(t-1-r)*t*4,a=r*t*2;for(let r=0;r<t;r++,i+=4,a+=2)n[a]=e[i],n[a+1]=e[i+1]}return n}function C(e,t){let n=new Float32Array(t*t);for(let r=0;r<t;r++){let i=(t-1-r)*t*4,a=(r+1)*t;for(let o=r*t;o<a;o++,i+=4)n[o]=(e[i]<<8|e[i+1])+e[i+2]/256}return n}function w(e,t,n){let r=n?new Float32Array(t*t):new Uint16Array(t*t);for(let t=0,i=0;t<r.length;t++,i+=4){let a=e[i]<<8|e[i+1];r[t]=n?a+e[i+2]/256:a}return r}const T=self,E=new Map;let D;async function O(e,t){let n=await fetch(e,{signal:t});if(!n.ok)throw Error(`tile ${n.status}`);let r=await createImageBitmap(await n.blob(),{premultiplyAlpha:`none`,colorSpaceConversion:`none`}),i=r.width;D?.width!==i&&(D=new OffscreenCanvas(i,i));let a=D.getContext(`2d`,{willReadFrequently:!0});if(!a)throw Error(`no 2d canvas in this worker`);return a.globalCompositeOperation=`copy`,a.drawImage(r,0,0),r.close(),{rgba:a.getImageData(0,0,i,i).data,size:i}}async function k(e,t){let{rgba:n,size:r}=await O(e.url,t),i=e.fine?C(n,r):S(n,r);T.postMessage({type:`tile`,id:e.id,size:r,heights:i},[i.buffer])}const A=new Map;let j=``;async function M(r,i){let{rows:a,columns:o,tileSize:s,maxLevel:c,patches:u}=r,d=[r.version,...u.map(e=>e.version)],f=`${r.root}?${d.join()}`;f!==j&&A.clear(),j=f;let p=(e,t,n,r)=>l(u,e,t,n,r),h=y(a,o,s,c,(e,t,n,r)=>p(e,t,n,r)!==void 0),g=[...h].filter(e=>!A.has(e));await Promise.all(Array.from({length:6},async()=>{for(let t=g.pop();t!==void 0;t=g.pop()){let{chart:a,level:o,x:s,y:l}=m(t),u=o>c,d=u?p(a,o,s,l)?.version:r.version,f=`${r.root}${e(n[a],o,s,l)}?v=${d}`;try{let{rgba:e,size:n}=await O(f,i);A.set(t,w(e,n,u))}catch{if(i.aborted)return}}})),i.throwIfAborted();let _=x(a,o,e=>A.get(e),s,r.scaleKm,r.biasKm);for(let e of[...A.keys()])h.has(e)||A.delete(e);if(!_)throw Error(`no height tiles for the grid`);let v=t(r.radius,a.at,o.at,_,r.unitsPerKm),b=v.indices.slice();T.postMessage({type:`grid`,id:r.id,...v,indices:b,riseKm:_},[v.positions.buffer,v.normals.buffer,v.uvs.buffer,b.buffer,_.buffer])}async function N(e){let t=new AbortController;E.set(e.id,t);try{e.type===`tile`?await k(e,t.signal):await M(e,t.signal)}catch{T.postMessage({type:`failed`,id:e.id})}finally{E.delete(e.id)}}self.onmessage=e=>{let t=e.data;t.type===`abort`?E.get(t.id)?.abort():N(t)};";
 var blob$1 = typeof self !== "undefined" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", jsContent$1], { type: "text/javascript;charset=utf-8" });
 function WorkerWrapper$1(options) {
 	let objURL;
@@ -13088,34 +13921,40 @@ function placeWindow(chart, level, x, y, previous) {
 		ty0
 	};
 }
-function inRange(patch, level, x, y) {
+function patchChart(patch) {
+	return patch.cap === "north" ? 1 : patch.cap === "south" ? 2 : 0;
+}
+function inRange(patch, chart, level, x, y) {
 	const up = patch.max_level - level;
-	return up >= 0 && x >= patch.x[0] >> up && x <= patch.x[1] >> up && y >= patch.y[0] >> up && y <= patch.y[1] >> up;
+	return up >= 0 && patchChart(patch) === chart && x >= patch.x[0] >> up && x <= patch.x[1] >> up && y >= patch.y[0] >> up && y <= patch.y[1] >> up;
 }
-function patchOfTile(patches, level, x, y) {
-	return patches?.find((patch) => inRange(patch, level, x, y));
+function patchOfTile(patches, chart, level, x, y) {
+	return patches?.find((patch) => inRange(patch, chart, level, x, y));
 }
-function mapTileVersion(pyramid, level, x, y) {
-	const over = pyramid.patches?.filter((patch) => level > pyramid.max_level - (patch.map_levels ?? 0) && inRange(patch, level, x, y));
+function tileVersion(pyramid, chart, level, x, y) {
+	const over = pyramid.patches?.filter((patch) => level > pyramid.max_level - (patch.map_levels ?? 0) && inRange(patch, chart, level, x, y));
 	return over?.length ? over.map((patch) => patch.version).join(".") : pyramid.version;
 }
 var REACH_TILES = 4 / 2 - .5;
-function deepestLevel(maxLevel, patches, x, y) {
+function deepestLevel(maxLevel, patches, chart, x, y) {
 	let deepest = maxLevel;
 	if (!patches) return deepest;
-	for (const patch of patches) for (let level = patch.max_level; level > deepest; level--) {
-		const up = patch.max_level - level;
-		const columns = chartColumns(0, level);
-		const x0 = patch.x[0] >> up;
-		const y0 = patch.y[0] >> up;
-		const halfWidth = ((patch.x[1] >> up) + 1 - x0) / 2;
-		const halfHeight = ((patch.y[1] >> up) + 1 - y0) / 2;
-		let east = x * columns - (x0 + halfWidth);
-		east -= columns * Math.round(east / columns);
-		const south = y * chartRows(0, level) - (y0 + halfHeight);
-		if (Math.abs(east) - halfWidth <= REACH_TILES && Math.abs(south) - halfHeight <= REACH_TILES) {
-			deepest = level;
-			break;
+	for (const patch of patches) {
+		if (patchChart(patch) !== chart) continue;
+		for (let level = patch.max_level; level > deepest; level--) {
+			const up = patch.max_level - level;
+			const columns = chartColumns(chart, level);
+			const x0 = patch.x[0] >> up;
+			const y0 = patch.y[0] >> up;
+			const halfWidth = ((patch.x[1] >> up) + 1 - x0) / 2;
+			const halfHeight = ((patch.y[1] >> up) + 1 - y0) / 2;
+			let east = x * columns - (x0 + halfWidth);
+			if (chart === 0) east -= columns * Math.round(east / columns);
+			const south = y * chartRows(chart, level) - (y0 + halfHeight);
+			if (Math.abs(east) - halfWidth <= REACH_TILES && Math.abs(south) - halfHeight <= REACH_TILES) {
+				deepest = level;
+				break;
+			}
 		}
 	}
 	return deepest;
@@ -13123,7 +13962,7 @@ function deepestLevel(maxLevel, patches, x, y) {
 function windowHome(placement, x, y) {
 	const columns = chartColumns(placement.chart, placement.level);
 	let east = x * columns - placement.tx0;
-	east -= columns * Math.round(east / columns);
+	if (placement.chart === 0) east -= columns * Math.round(east / columns);
 	return {
 		x: east,
 		y: y * chartRows(placement.chart, placement.level) - placement.ty0
@@ -13141,6 +13980,7 @@ function slotTile(placement, sx, sy) {
 
 //#endregion
 //#region src/lib/scene/render-tier.ts
+var MB = 1024 * 1024;
 var RENDER_TIER_PRESETS = {
 	low: {
 		maxPixelRatio: 1.25,
@@ -13154,7 +13994,10 @@ var RENDER_TIER_PRESETS = {
 		reliefWindows: 2,
 		reliefShadowSteps: 12,
 		terrainBandCells: 16,
-		maxSkyboxFace: 2048
+		maxSkyboxFace: 2048,
+		starPoints: 12e5,
+		starBytes: 80 * MB,
+		starFetches: 3
 	},
 	medium: {
 		maxPixelRatio: 1.5,
@@ -13168,7 +14011,10 @@ var RENDER_TIER_PRESETS = {
 		reliefWindows: 3,
 		reliefShadowSteps: 16,
 		terrainBandCells: 24,
-		maxSkyboxFace: 2048
+		maxSkyboxFace: 2048,
+		starPoints: 16e5,
+		starBytes: 160 * MB,
+		starFetches: 4
 	},
 	high: {
 		maxPixelRatio: 2,
@@ -13182,7 +14028,10 @@ var RENDER_TIER_PRESETS = {
 		reliefWindows: 4,
 		reliefShadowSteps: 32,
 		terrainBandCells: 32,
-		maxSkyboxFace: Infinity
+		maxSkyboxFace: Infinity,
+		starPoints: 25e5,
+		starBytes: 400 * MB,
+		starFetches: 6
 	}
 };
 function maxTextureTier() {
@@ -13204,7 +14053,7 @@ function resolveRenderTier() {
 	const measured = sceneSettings().atmosphereCalibration?.tier;
 	if (measured === "low" || measured === "medium") return measured;
 	if (measured === "high" || measured === "ultra") return "high";
-	if (isCoarsePointer()) return isLowEndDevice() ? "low" : "medium";
+	if (isCoarsePointer$1()) return isLowEndDevice() ? "low" : "medium";
 	return isLowEndDevice() ? "medium" : "high";
 }
 function currentRenderTier() {
@@ -13214,6 +14063,15 @@ function renderPixelRatio() {
 	if (typeof window === "undefined") return 1;
 	return Math.min(window.devicePixelRatio, currentRenderTier().maxPixelRatio);
 }
+function starBudget() {
+	const tier = currentRenderTier();
+	const bytes = isLowEndDevice() ? Math.min(tier.starBytes, 64 * MB) : tier.starBytes;
+	return {
+		points: tier.starPoints,
+		bytes,
+		fetches: tier.starFetches
+	};
+}
 
 //#endregion
 //#region src/lib/scene/objects/surface/tile-chain.ts
@@ -13247,9 +14105,9 @@ void tileCap( vec3 dir, vec3 ddx, vec3 ddy, out float side, out mat3x2 cap ) {
 	);
 }
 
-// The point at + off on the map, counted from at, and on the cap of its own
-// hemisphere, which side gives. A position on the sphere has seven digits,
-// and a tile index of a patch takes them all; the offset keeps its own.
+// The point at + off on the map and on the cap of its own hemisphere, which
+// side gives, each counted from at. A position on the sphere has seven
+// digits, and a tile index of a patch takes them all. The offset keeps its own.
 void tileChartsFrom( vec3 at, vec3 off, out mat3x2 map, out mat3x2 cap, out float side ) {
 	vec3 pos = at + off;
 	vec3 ox = dFdx( off );
@@ -13271,12 +14129,19 @@ void tileChartsFrom( vec3 at, vec3 off, out mat3x2 map, out mat3x2 cap, out floa
 		( pos.z * oy.x - pos.x * oy.z ) * east, ( pos.y * ( pos.x * oy.x + pos.z * oy.z ) / flat1 - flat1 * oy.y ) * south
 	);
 
-	// A cap goes no deeper than the pyramid, so the direction itself will do.
 	float range = length( pos );
 	vec3 dir = pos / range;
 	vec3 ddx = ( ox - dir * dot( dir, ox ) ) / range;
 	vec3 ddy = ( oy - dir * dot( dir, oy ) ) / range;
 	tileCap( dir, ddx, ddy, side, cap );
+
+	// The point on the cap, counted from at.
+	float reach = length( at );
+	float foldAt = max( reach + side * at.y, 1e-6 * reach );
+	float grow = ( 2.0 * dot( at, off ) + dot( off, off ) ) / ( range + reach );
+	vec2 planeAt = vec2( at.x, side * at.z );
+	vec2 shift = vec2( off.x, side * off.z ) * foldAt - planeAt * ( grow + side * off.y );
+	cap[ 0 ] = shift / ( ( range + side * pos.y ) * foldAt ) * ( 0.5 / ${CAP_EDGE.toFixed(8)} );
 }
 
 // Long and short half-axes of the footprint whose sides are fx and fy. The
@@ -13319,7 +14184,7 @@ float tileWindowWeight( mat3x2 map, mat3x2 cap, float side, vec4 window, vec4 gr
 
 	float rows = ${4 .toFixed(1)};
 	// Offset from the window's north-west corner, in tiles.
-	vec2 rel = onMap ? home + chart[ 0 ] * grid.xy : chart[ 0 ] * grid.xy - grid.zw;
+	vec2 rel = home + chart[ 0 ] * grid.xy;
 	if ( onMap ) {
 		// Half a pixel in from a pole of the map: past it the filter would
 		// read the far row. The map's longitude wraps.
@@ -13421,8 +14286,8 @@ function release(store, win) {
 	store.free.push(win.layer);
 }
 function patchOf(tiles, win, tile) {
-	if (win.chart !== 0 || win.level <= tiles.max_level) return void 0;
-	return patchOfTile(tiles.patches, win.level, tile.x, tile.y);
+	if (win.level <= tiles.max_level) return void 0;
+	return patchOfTile(tiles.patches, win.chart, win.level, tile.x, tile.y);
 }
 function exists(tiles, win, slot) {
 	if (win.level <= tiles.max_level) return true;
@@ -13478,7 +14343,7 @@ function pump(chain, store, tiles, win, x, y, renderer, invalidate) {
 		});
 		chain.inflight++;
 		const folder = CHART_FOLDER[win.chart];
-		const version = patchOf(tiles, win, tile)?.version ?? (win.chart === 0 ? mapTileVersion(tiles, win.level, tile.x, tile.y) : tiles.version);
+		const version = patchOf(tiles, win, tile)?.version ?? tileVersion(tiles, win.chart, win.level, tile.x, tile.y);
 		const pyramid = {
 			id: tiles.id,
 			version
@@ -13533,9 +14398,9 @@ function pointUnderCamera(mesh, camera) {
 	return over.copy(camera.position).applyMatrix4(inverse.copy(mesh.matrixWorld).invert()).normalize();
 }
 function finestLevelAt$1(chain, tiles, over) {
-	if (cameraChart(over.y, chain?.chart) !== 0) return tiles.max_level;
-	const point = chartPoint(0, over.x, over.y, over.z);
-	return deepestLevel(tiles.max_level, tiles.patches, point.x, point.y);
+	const chart = cameraChart(over.y, chain?.chart);
+	const point = chartPoint(chart, over.x, over.y, over.z);
+	return deepestLevel(tiles.max_level, tiles.patches, chart, point.x, point.y);
 }
 function chainLength(tiles, limit) {
 	let finest = tiles.max_level;
@@ -13557,7 +14422,11 @@ function updateChain(chain, tiles, count, level, over, radius, frame, renderer,
 	anchor.set(Math.fround(over.x * radius), Math.fround(over.y * radius), Math.fround(over.z * radius));
 	chain.uniforms.anchor.value.copy(anchor);
 	const range = anchor.length();
-	const home = chartPoint(0, anchor.x / range, anchor.y / range, anchor.z / range);
+	const homes = [
+		0,
+		1,
+		2
+	].map((chart) => chartPoint(chart, anchor.x / range, anchor.y / range, anchor.z / range));
 	const windowOf = (link) => store.windows.find((win) => win.chart === link.chart && win.level === link.level);
 	store.windows = store.windows.filter((win) => {
 		win.rank = links.findIndex((link) => link.chart === win.chart && link.level === win.level);
@@ -13598,10 +14467,9 @@ function updateChain(chain, tiles, count, level, over, radius, frame, renderer,
 			continue;
 		}
 		chain.uniforms.grid.value[i].set(chartColumns(win.chart, win.level), chartRows(win.chart, win.level), win.placement.tx0, win.placement.ty0);
-		if (win.chart === 0) {
-			const from = windowHome(win.placement, home.x, home.y);
-			chain.uniforms.home.value[i].set(from.x, from.y);
-		}
+		const home = homes[win.chart];
+		const from = windowHome(win.placement, home.x, home.y);
+		chain.uniforms.home.value[i].set(from.x, from.y);
 		link.set(win.chart, win.layer, win.level, 1);
 		let loaded = 0;
 		for (let slot = 0; slot < SLOTS; slot++) if (isLoaded(store, win.layer, slot)) loaded |= 1 << slot;
@@ -13716,10 +14584,10 @@ void reliefSight( int i, mat3x2 map, mat3x2 cap, float side, vec2 mapStep, vec2
 	vec4 grid = uReliefGrid[ i ];
 	bool onMap = window.x < 0.5;
 	float rows = ${4 .toFixed(1)};
-	// In tiles from the window's north-west corner. The map is counted from
-	// the point under the camera, so the fragment is on the side of the globe
-	// nearest the window.
-	vec2 rel = onMap ? uReliefHome[ i ] + map[ 0 ] * grid.xy : cap[ 0 ] * grid.xy - grid.zw;
+	// In tiles from the window's north-west corner, counted from the point
+	// under the camera. On the map the fragment is then on the side of the
+	// globe nearest the window.
+	vec2 rel = uReliefHome[ i ] + ( onMap ? map[ 0 ] : cap[ 0 ] ) * grid.xy;
 	vec2 rate = ( onMap ? mapStep : capStep ) * grid.xy;
 
 	// Half a pixel in from the window's sides: past it the filter reads the
@@ -15770,6 +16638,7 @@ async function loadSpacecraftModel(bo, modelScene, ctx) {
 	try {
 		const detail = await fetchObjectDetail(bo.body.data.id, false);
 		bo.body.pointing = detail.global?.pointing;
+		bo.body.landedHeadings = landedHeadings(detail.global?.events?.items);
 		const attitudeManifest = detail.global?.attitude;
 		if (attitudeManifest && (bo.modelLoadEpoch ?? 0) === epoch) {
 			const probeId = bo.body.data.id.replace(/^probe-/, "");
@@ -15809,8 +16678,9 @@ async function loadSpacecraftModel(bo, modelScene, ctx) {
 		bo.model = root;
 		bo.modelName = slug;
 		setHaloLoading(bo, false);
-		if (meta.scale_meters) {
-			const spanKm = meta.scale_meters / 2e3;
+		const spanM = meta.exports[tier]?.scale_meters;
+		if (spanM) {
+			const spanKm = spanM / 2e3;
 			bo.body.data.radiusKm = spanKm * (meta.body_span_ratio ?? 1);
 			bo.radiusScene = kmToScene(effectiveRadiusKm(bo.body.data));
 			bo.modelUnitOverride = meta.body_span_ratio ? kmToScene(spanKm) : void 0;
@@ -15923,6 +16793,7 @@ function unloadBodyModel(bo) {
 	bo.model = null;
 	bo.modelName = void 0;
 	bo.body.pointing = void 0;
+	bo.body.landedHeadings = void 0;
 	bo.body.attitudeTrack = void 0;
 	bo.body.modelBaseFrame = void 0;
 	if (bo.mesh && restoreSphere) bo.mesh.visible = true;
@@ -15942,6 +16813,17 @@ function setHaloLoading(bo, loading) {
 		bo.loadingShown = void 0;
 	}
 }
+function landedHeadings(events) {
+	const out = [];
+	for (const e of events ?? []) {
+		const deg = e.type === "landing" ? e.site?.heading_deg : void 0;
+		if (deg !== void 0) out.push({
+			jd: e.jd,
+			deg
+		});
+	}
+	return out.length ? out : void 0;
+}
 function withBaseFrame(scene, q) {
 	if (!q) return scene;
 	const wrapper = new Group();
@@ -17318,7 +18200,7 @@ function setLabelName(bo, name, variant, isLarge) {
 }
 function getLabelVariant(body) {
 	const t = body.data.objectType;
-	if (isMajorBody(t) || t === ObjectType.STAR || isAsteroid(t) || t === ObjectType.COMET || t === ObjectType.BARYCENTER || t === ObjectType.LAGRANGE_POINT) return "major";
+	if (isMajorBody(t) || t === ObjectType.STAR || t === ObjectType.EXTRASOLAR || isAsteroid(t) || t === ObjectType.COMET || t === ObjectType.BARYCENTER || t === ObjectType.LAGRANGE_POINT) return "major";
 	if (t === ObjectType.SPACECRAFT) return "spacecraft";
 	if (t === ObjectType.DEBRIS) return "debris";
 	return "none";
@@ -18277,6 +19159,231 @@ async function loadSkybox(scene, renderer, ctx, disposed = () => false) {
 	}
 }
 
+//#endregion
+//#region src/lib/scene/starfield/tree.ts
+var PC_AU = 648e3 / Math.PI;
+var PC_SCENE = PC_AU * 10;
+function childCentre(centre, half, k) {
+	const q = half / 2;
+	return [
+		centre[0] + (k & 1 ? q : -q),
+		centre[1] + (k & 2 ? q : -q),
+		centre[2] + (k & 4 ? q : -q)
+	];
+}
+function boxDistance(p, centre, half) {
+	const dx = Math.max(Math.abs(p[0] - centre[0]) - half, 0);
+	const dy = Math.max(Math.abs(p[1] - centre[1]) - half, 0);
+	const dz = Math.max(Math.abs(p[2] - centre[2]) - half, 0);
+	return Math.hypot(dx, dy, dz);
+}
+function boxMagnitude(distance, range, rangeLimitMag) {
+	if (distance <= 0) return -Infinity;
+	if (range <= 0) return Infinity;
+	return rangeLimitMag + 5 * Math.log10(distance / range);
+}
+function sceneToTree(x, y, z) {
+	const eq = sceneToEquatorial(x, y, z, {
+		x: 0,
+		y: 0,
+		z: 0
+	});
+	return [
+		eq.x / PC_SCENE,
+		eq.y / PC_SCENE,
+		eq.z / PC_SCENE
+	];
+}
+function treeToScene(x, y, z, out) {
+	return equatorialToScene(x * PC_SCENE, y * PC_SCENE, z * PC_SCENE, out);
+}
+function icrsToTree(raDeg, decDeg, distancePc) {
+	const ra = raDeg * Math.PI / 180;
+	const dec = decDeg * Math.PI / 180;
+	const c = Math.cos(dec) * distancePc;
+	return [
+		c * Math.cos(ra),
+		c * Math.sin(ra),
+		Math.sin(dec) * distancePc
+	];
+}
+function treeMatrixElements(focus, out) {
+	const x = treeToScene(1, 0, 0, {
+		x: 0,
+		y: 0,
+		z: 0
+	});
+	const y = treeToScene(0, 1, 0, {
+		x: 0,
+		y: 0,
+		z: 0
+	});
+	const z = treeToScene(0, 0, 1, {
+		x: 0,
+		y: 0,
+		z: 0
+	});
+	out.length = 16;
+	out[0] = x.x;
+	out[1] = x.y;
+	out[2] = x.z;
+	out[3] = 0;
+	out[4] = y.x;
+	out[5] = y.y;
+	out[6] = y.z;
+	out[7] = 0;
+	out[8] = z.x;
+	out[9] = z.y;
+	out[10] = z.z;
+	out[11] = 0;
+	out[12] = -focus[0];
+	out[13] = -focus[1];
+	out[14] = -focus[2];
+	out[15] = 1;
+	return out;
+}
+
+//#endregion
+//#region src/lib/scene/starfield/record.ts
+var RENDER_EPOCH = 2016;
+var MAG_STEP = 1 / 1024;
+var G_MINUS_V = [
+	-.02907,
+	-.02385,
+	-.2297,
+	-.001768
+];
+var B_V_RANGE = [-.3, 2.4];
+var G_MINUS_HP = -.28;
+var BP_RP_FROM_V_I = [
+	-.01612,
+	1.274,
+	-.08143
+];
+var V_I_RANGE = [-.5, 3.5];
+var MAS_PER_RAD = 180 / Math.PI * 36e5;
+function clamp$3(x, [lo, hi]) {
+	return Math.min(Math.max(x, lo), hi);
+}
+function poly(x, coefficients) {
+	let out = 0;
+	for (let i = coefficients.length - 1; i >= 0; i--) out = out * x + coefficients[i];
+	return out;
+}
+function propagate(raDeg, decDeg, pmra, pmdec, years) {
+	const ra = raDeg * Math.PI / 180;
+	const dec = decDeg * Math.PI / 180;
+	const rate = years / MAS_PER_RAD;
+	const [cr, sr, cd, sd] = [
+		Math.cos(ra),
+		Math.sin(ra),
+		Math.cos(dec),
+		Math.sin(dec)
+	];
+	const x = cd * cr + rate * (pmra * -sr + pmdec * -sd * cr);
+	const y = cd * sr + rate * (pmra * cr + pmdec * -sd * sr);
+	const z = sd + rate * (pmdec * cd);
+	const n = Math.hypot(x, y, z);
+	return [(Math.atan2(y / n, x / n) * 180 / Math.PI % 360 + 360) % 360, Math.asin(Math.min(Math.max(z / n, -1), 1)) * 180 / Math.PI];
+}
+function starPlace(row) {
+	const distancePc = parallaxDistancePc(row);
+	let ra = row.number("ra");
+	let dec = row.number("dec");
+	if (distancePc === null || ra === null || dec === null) return null;
+	const years = RENDER_EPOCH - (row.number("epoch") ?? 2016);
+	const pmra = row.number("pmra");
+	if (years !== 0 && pmra !== null) [ra, dec] = propagate(ra, dec, pmra, row.number("pmdec") ?? 0, years);
+	const tree = icrsToTree(ra, dec, distancePc);
+	const s = treeToScene(tree[0], tree[1], tree[2], {
+		x: 0,
+		y: 0,
+		z: 0
+	});
+	return {
+		ra,
+		dec,
+		distancePc,
+		tree,
+		scene: [
+			s.x,
+			s.y,
+			s.z
+		]
+	};
+}
+function gEstimate(v, bv, hp) {
+	if (v !== null && bv !== null) return v + poly(clamp$3(bv, B_V_RANGE), G_MINUS_V);
+	return hp === null ? null : hp + G_MINUS_HP;
+}
+function apparentG(row) {
+	return row.number("phot_g_mean_mag") ?? gEstimate(row.number("v_mag"), row.number("b_v"), row.number("hp_mag"));
+}
+function absoluteG(row) {
+	const g = apparentG(row);
+	const parallax = row.number("parallax");
+	if (g === null || parallaxDistancePc(row) === null || parallax === null) return null;
+	return Math.round((g + 5 * Math.log10(parallax) - 10) / MAG_STEP) * MAG_STEP;
+}
+function colourBpRp(row) {
+	const bp = row.number("phot_bp_mean_mag");
+	const rp = row.number("phot_rp_mean_mag");
+	if (bp !== null && rp !== null) return bp - rp;
+	const vi = row.number("v_i");
+	return vi === null ? null : poly(clamp$3(vi, V_I_RANGE), BP_RP_FROM_V_I);
+}
+
+//#endregion
+//#region src/lib/scene/focus/star-focus.ts
+function makeStarBody(record) {
+	const home = homeRow(record);
+	const place = home ? starPlace(home) : null;
+	return {
+		data: {
+			id: extrasolarObjectId(record.id),
+			name: record.metadata.name,
+			objectType: ObjectType.EXTRASOLAR,
+			parentId: "",
+			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,
+		extrasolar: {
+			id: record.id,
+			record,
+			scene: place?.scene ?? null,
+			tree: place?.tree ?? null,
+			absMag: home ? absoluteG(home) : null,
+			colour: home ? colourBpRp(home) : null
+		}
+	};
+}
+
+//#endregion
+//#region src/lib/scene/setup/extrasolar.ts
+async function ensureExtrasolarBody(ctx, objectId) {
+	const text = objectId.slice("x-".length);
+	const first = await extrasolarLookup.lookup(text);
+	const result = first.kind === "alias" ? await extrasolarLookup.live(text) : first;
+	if (result.kind === "live") {
+		const held = ctx.getBody(extrasolarObjectId(result.record.id));
+		const body = held?.extrasolar ? held : makeStarBody(result.record);
+		ctx.bodies.addExtrasolar(body, first.kind === "alias" ? [objectId] : []);
+	}
+	return result;
+}
+
 //#endregion
 //#region src/lib/scene/setup/scene-load.ts
 var EAGER_ZOOM1_PARTS = 13;
@@ -18385,6 +19492,7 @@ async function loadScene(ctx, date, targetId) {
 	});
 	const probePromise = metadataPromise.then((metadata) => buildProbeStore(metadata, jd, ctx.layers));
 	const passengerPromise = passengerFor(targetId);
+	const extrasolarTarget = targetId && isExtrasolarObjectId(targetId) ? ensureExtrasolarBody(ctx, targetId).catch((e) => console.warn(`scene-load: ${targetId} did not load:`, e)) : null;
 	const metadata = await metadataPromise;
 	loadProgress.reach("metadata");
 	ctx.chebStore = await chebPromise;
@@ -18410,7 +19518,8 @@ async function loadScene(ctx, date, targetId) {
 		addedSinceFlush = false;
 		ctx.bodies.flushMinor(added);
 	};
-	if (targetId && !ctx.getBody(targetId)) {
+	if (extrasolarTarget) await extrasolarTarget;
+	else if (targetId && !ctx.getBody(targetId)) {
 		const placeholders = await createPlaceholderBody(targetId, ctx);
 		if (routePlaceholders(ctx, placeholders, labels) > 0) noteAdded();
 		if (placeholders.length > 0) flush();
@@ -18418,7 +19527,7 @@ async function loadScene(ctx, date, targetId) {
 	ctx.bodies.majorBodies = major.filter((b) => b.data.objectType !== ObjectType.BARYCENTER && b.data.objectType !== ObjectType.LAGRANGE_POINT && b.data.orbitalSource !== OrbitalSource.SPICE_PROBE);
 	try {
 		ctx.refresher = new ZoneRefresher(ctx, metadata, loader, date);
-		if (targetId) ctx.refresher.want(targetId);
+		if (targetId && !extrasolarTarget) ctx.refresher.want(targetId);
 	} catch (e) {
 		console.error("scene-load: ZoneRefresher init failed; time-segmented zones stay empty:", e);
 	}
@@ -18587,12 +19696,17 @@ var ContextManager = class {
 		console.error("[scene-load]", e);
 	}
 	refreshTick(date) {
+		if (this.visibility.systemShare === 0) return;
 		this.refresher?.tick(date);
 	}
 	async ready(date) {
 		await this.refresher?.ready(date);
 	}
 	async ensureBody(targetId, date) {
+		if (isExtrasolarObjectId(targetId)) {
+			await ensureExtrasolarBody(this, targetId);
+			return;
+		}
 		await this.refresher?.ensureBody(targetId, date);
 	}
 	applyGroupFilter(slug) {
@@ -18713,6 +19827,7 @@ var SimClock = class {
 	prevScale = 1;
 	stops = null;
 	settleTimer = null;
+	arrivals = [];
 	constructor(initialJd, live = false) {
 		this.jd = initialJd;
 		this.settledJd = initialJd;
@@ -18769,6 +19884,19 @@ var SimClock = class {
 		this.setJD(jd);
 		this.jumps++;
 		this.settle();
+		const jumps = this.jumps;
+		return new Promise((resolve) => this.arrivals.push({
+			jumps,
+			resolve
+		}));
+	}
+	placed(jumps) {
+		if (this.arrivals.length === 0) return;
+		this.arrivals = this.arrivals.filter((arrival) => {
+			if (arrival.jumps > jumps) return true;
+			arrival.resolve();
+			return false;
+		});
 	}
 	settle() {
 		if (this.settleTimer !== null) clearTimeout(this.settleTimer);
@@ -18809,7 +19937,7 @@ var SimClock = class {
 		return jdToDate(this.jd);
 	}
 	setDate(date) {
-		this.jumpTo(dateToJD(date));
+		return this.jumpTo(dateToJD(date));
 	}
 };
 
@@ -19290,6 +20418,9 @@ function installOutputDither(pass) {
 //#endregion
 //#region src/lib/scene/setup/three-boot.ts
 var CAMERA_FAR_DEFAULT = 1e5;
+var CAMERA_MAX_DISTANCE = 1e5 * PC_SCENE;
+var SOLAR_MAX_DISTANCE = 31620.5 * 10;
+var CAMERA_FAR_REVERSED = 1e6 * PC_SCENE;
 function probeClipControl() {
 	try {
 		const gl = document.createElement("canvas").getContext("webgl2");
@@ -19343,7 +20474,9 @@ function bootThree(canvas, labelContainer, ctx) {
 	shadowLight.shadow.bias = -1e-4;
 	scene.add(shadowLight);
 	scene.add(shadowLight.target);
-	const camera = new PerspectiveCamera(60, canvas.clientWidth / canvas.clientHeight, kmToScene(.001), CAMERA_FAR_DEFAULT);
+	const aspect = canvas.clientWidth / canvas.clientHeight;
+	const far = renderer.capabilities.reversedDepthBuffer ? CAMERA_FAR_REVERSED : CAMERA_FAR_DEFAULT;
+	const camera = new PerspectiveCamera(60, aspect, kmToScene(.001), far);
 	const composerTarget = new WebGLRenderTarget(canvas.clientWidth, canvas.clientHeight, {
 		type: HalfFloatType,
 		resolveDepthBuffer: false,
@@ -19375,38 +20508,1006 @@ function bootThree(canvas, labelContainer, ctx) {
 	};
 }
 
+//#endregion
+//#region src/lib/scene/starfield/band.ts
+var STARS_IN_AU = 2e3;
+var STARS_OUT_AU = 1800;
+function starsTakeSky(distanceAu, taken) {
+	if (distanceAu > 2e3) return true;
+	if (distanceAu < 1800) return false;
+	return taken;
+}
+
+//#endregion
+//#region src/lib/scene/starfield/colour.ts
+var BP_RP_TEFF = [
+	[-.12, 10700],
+	[-.087, 10400],
+	[-.037, 9700],
+	[.005, 9300],
+	[.068, 8800],
+	[.11, 8600],
+	[.166, 8250],
+	[.194, 8100],
+	[.222, 7910],
+	[.263, 7760],
+	[.32, 7590],
+	[.327, 7400],
+	[.377, 7220],
+	[.434, 7020],
+	[.49, 6820],
+	[.518, 6750],
+	[.546, 6670],
+	[.587, 6550],
+	[.64, 6350],
+	[.67, 6280],
+	[.694, 6180],
+	[.719, 6050],
+	[.767, 5990],
+	[.784, 5930],
+	[.803, 5860],
+	[.823, 5770],
+	[.832, 5720],
+	[.841, 5680],
+	[.85, 5660],
+	[.869, 5600],
+	[.88, 5550],
+	[.9, 5480],
+	[.95, 5380],
+	[.983, 5270],
+	[1.01, 5170],
+	[1.1, 5100],
+	[1.21, 4830],
+	[1.34, 4600],
+	[1.43, 4440],
+	[1.53, 4300],
+	[1.7, 4100],
+	[1.73, 3990],
+	[1.79, 3930],
+	[1.84, 3850],
+	[1.97, 3770],
+	[2.09, 3660],
+	[2.13, 3620],
+	[2.23, 3560],
+	[2.39, 3470],
+	[2.5, 3430],
+	[2.78, 3270],
+	[2.94, 3210],
+	[3.16, 3110],
+	[3.35, 3060],
+	[3.71, 2930],
+	[4.16, 2810],
+	[4.5, 2740],
+	[4.65, 2680],
+	[4.72, 2630],
+	[4.86, 2570],
+	[5.1, 2420]
+];
+function teffFromBpRp(bpRp) {
+	const table = BP_RP_TEFF;
+	if (bpRp <= table[0][0]) return table[0][1];
+	const last = table[table.length - 1];
+	if (bpRp >= last[0]) return last[1];
+	let lo = 0;
+	let hi = table.length - 1;
+	while (hi - lo > 1) {
+		const mid = lo + hi >> 1;
+		if (table[mid][0] <= bpRp) lo = mid;
+		else hi = mid;
+	}
+	const [c0, t0] = table[lo];
+	const [c1, t1] = table[hi];
+	return t0 + (bpRp - c0) / (c1 - c0) * (t1 - t0);
+}
+function planckianRgb(teff, out) {
+	const t = Math.min(Math.max(teff, 1667), 25e3);
+	const t1 = 1e3 / t;
+	const t2 = t1 * t1;
+	const t3 = t2 * t1;
+	const x = t <= 4e3 ? -.2661239 * t3 - .2343589 * t2 + .8776956 * t1 + .17991 : -3.0258469 * t3 + 2.1070379 * t2 + .2226347 * t1 + .24039;
+	const x2 = x * x;
+	const x3 = x2 * x;
+	let y;
+	if (t <= 2222) y = -1.1063814 * x3 - 1.3481102 * x2 + 2.18555832 * x - .20219683;
+	else if (t <= 4e3) y = -.9549476 * x3 - 1.37418593 * x2 + 2.09137015 * x - .16748867;
+	else y = 3.081758 * x3 - 5.8733867 * x2 + 3.75112997 * x - .37001483;
+	const X = x / y;
+	const Z = (1 - x - y) / y;
+	const r = Math.max(3.2404542 * X - 1.5371385 - .4985314 * Z, 0);
+	const g = Math.max(-.969266 * X + 1.8760108 + .041556 * Z, 0);
+	const b = Math.max(.0556434 * X - .2040259 + 1.0572252 * Z, 0);
+	const peak = Math.max(r, g, b);
+	out[0] = r / peak;
+	out[1] = g / peak;
+	out[2] = b / peak;
+	return out;
+}
+var LUT_LO = BP_RP_TEFF[0][0];
+var LUT_HI = BP_RP_TEFF[BP_RP_TEFF.length - 1][0];
+var LUT_SIZE = 512;
+var lut = null;
+function buildLut() {
+	const bytes = new Uint8Array(LUT_SIZE * 3);
+	const rgb = [
+		0,
+		0,
+		0
+	];
+	for (let i = 0; i < LUT_SIZE; i++) {
+		planckianRgb(teffFromBpRp(LUT_LO + (LUT_HI - LUT_LO) * i / (LUT_SIZE - 1)), rgb);
+		bytes[3 * i] = Math.round(rgb[0] * 255);
+		bytes[3 * i + 1] = Math.round(rgb[1] * 255);
+		bytes[3 * i + 2] = Math.round(rgb[2] * 255);
+	}
+	return bytes;
+}
+function starColours(bpRp, out) {
+	const table = lut ??= buildLut();
+	const scale = (LUT_SIZE - 1) / (LUT_HI - LUT_LO);
+	for (let i = 0; i < bpRp.length; i++) {
+		const c = bpRp[i];
+		if (Number.isNaN(c)) {
+			out[3 * i] = 255;
+			out[3 * i + 1] = 255;
+			out[3 * i + 2] = 255;
+			continue;
+		}
+		const at = 3 * Math.round(Math.min(Math.max((c - LUT_LO) * scale, 0), LUT_SIZE - 1));
+		out[3 * i] = table[at];
+		out[3 * i + 1] = table[at + 1];
+		out[3 * i + 2] = table[at + 2];
+	}
+	return out;
+}
+
+//#endregion
+//#region src/lib/scene/starfield/material.ts
+function starUniforms() {
+	return {
+		uLimit: { value: 7 },
+		uPixelRatio: { value: 1 },
+		uGain: { value: 1 }
+	};
+}
+var FADE_MAG = 1;
+var CONTRAST = .75;
+var CORE_AT_LIMIT = .06;
+var DOT_PX = 2.5;
+var MAX_DOT_PX = 14;
+var starVertexShader = (pick = false) => `
+uniform float uLimit;
+uniform float uPixelRatio;
+uniform float uGain;
+uniform float uFade;
+uniform float uFloor;
+uniform int uHidden;
+attribute float mag;
+attribute vec3 starColour;
+varying vec3 vColour;
+${pick ? "uniform highp uint uPickBase;\nflat varying highp uint vPick;" : ""}
+
+void main() {
+	${pick ? "vPick = uPickBase + uint(gl_VertexID);" : ""}
+	vec4 mv = modelViewMatrix * vec4(position, 1.0);
+	float pc = length(mv.xyz) / ${PC_SCENE.toFixed(4)};
+	float m = mag + 5.0 * log2(max(pc, 1e-9)) * 0.30103 - 5.0;
+	float above = max(uLimit - m, uFloor);
+	if (above <= 0.0 || mv.z >= 0.0 || gl_VertexID == uHidden) {
+		// Too faint, behind the camera, or drawn on its own: put it off screen.
+		gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+		gl_PointSize = 0.0;
+		vColour = vec3(0.0);
+		return;
+	}
+	float fade = smoothstep(0.0, ${FADE_MAG.toFixed(1)}, above) * uFade;
+	// Energy relative to a star at the limit. Past a full core, the dot grows.
+	float energy = ${CORE_AT_LIMIT.toFixed(3)} * exp2(above * ${(.4 * CONTRAST * Math.log2(10)).toFixed(5)});
+	float core = min(energy, 1.0);
+	float size = ${DOT_PX.toFixed(2)} * sqrt(max(energy, 1.0));
+	vColour = starColour * core * fade * uGain;
+	gl_Position = projectionMatrix * mv;
+	// Past the far plane a star stays on it, behind everything else.
+	${isReversedDepth() ? "gl_Position.z = max(gl_Position.z, 0.0);" : "gl_Position.z = min(gl_Position.z, gl_Position.w);"}
+	gl_PointSize = min(size, ${MAX_DOT_PX.toFixed(1)}) * uPixelRatio;
+}
+`;
+var FRAGMENT = `
+varying vec3 vColour;
+
+void main() {
+	vec2 c = gl_PointCoord * 2.0 - 1.0;
+	float r2 = dot(c, c);
+	if (r2 > 1.0) discard;
+	gl_FragColor = vec4(vColour * exp(-5.0 * r2), 1.0);
+}
+`;
+var PICK_MIN_LIGHT = 1 / 255;
+var pickFragment = () => `
+varying vec3 vColour;
+flat varying highp uint vPick;
+
+void main() {
+	vec2 c = gl_PointCoord * 2.0 - 1.0;
+	float r2 = dot(c, c);
+	if (r2 > 1.0) discard;
+	float light = max(vColour.r, max(vColour.g, vColour.b)) * exp(-5.0 * r2);
+	if (light < ${PICK_MIN_LIGHT.toFixed(6)}) discard;
+	gl_FragDepth = ${isReversedDepth() ? "light / (1.0 + light)" : "1.0 / (1.0 + light)"};
+	gl_FragColor = vec4(
+		float(vPick & 255u),
+		float((vPick >> 8) & 255u),
+		float((vPick >> 16) & 255u),
+		float(vPick >> 24)
+	) / 255.0;
+}
+`;
+var NO_FLOOR = -1e9;
+function makeStarMaterial(shared, floor = NO_FLOOR) {
+	return new ShaderMaterial({
+		uniforms: {
+			...shared,
+			uFade: { value: 0 },
+			uFloor: { value: floor },
+			uHidden: { value: -1 }
+		},
+		vertexShader: starVertexShader(),
+		fragmentShader: FRAGMENT,
+		blending: CustomBlending,
+		blendEquation: AddEquation,
+		blendSrc: OneMinusDstColorFactor,
+		blendDst: OneFactor,
+		transparent: true,
+		depthTest: true,
+		depthWrite: false
+	});
+}
+function makeStarPickMaterial(draw, base) {
+	return new ShaderMaterial({
+		uniforms: {
+			...draw.uniforms,
+			uPixelRatio: { value: 1 },
+			uPickBase: { value: base }
+		},
+		vertexShader: starVertexShader(true),
+		fragmentShader: pickFragment(),
+		blending: NoBlending,
+		depthTest: true,
+		depthWrite: true
+	});
+}
+
+//#endregion
+//#region src/lib/scene/starfield/starfield.ts
+var TREE = "mw";
+var ROOT = "r";
+var METADATA = "metadata.json";
+var BASE_LIMIT_MAG = 7.5;
+var EXPOSURE_PC = 1;
+var MUST_LOAD_MAG = 1;
+var ABORT_MARGIN_MAG = 1;
+var LIMIT_EASE_MS = 300;
+var NODE_FADE_MS = 400;
+var SELECT_EVERY_MS = 100;
+var ADDS_PER_FRAME = 4;
+var BOOT_GATE_MS = 1e4;
+var FOCUS_FLOOR_MAG = 3;
+var NO_MAGNITUDE = 99;
+var STAR_RENDER_ORDER = -1;
+var NODE_PICK_PREFIX = "star:";
+var FOCUS_PICK_GROUP = "star-focus";
+var _view = new Vector3();
+var StarfieldSystem = class {
+	group = new Group();
+	uniforms = starUniforms();
+	tree = null;
+	credits = [];
+	root = null;
+	nodes = /* @__PURE__ */ new Map();
+	drawn = /* @__PURE__ */ new Set();
+	retries = new RetryBackoff(() => this.markDirty());
+	idLoads = /* @__PURE__ */ new Map();
+	loading = 0;
+	cachedBytes = 0;
+	drawable;
+	metadataLoading = false;
+	bootGate = null;
+	stale = false;
+	disposed = false;
+	dirty = true;
+	lastSelectMs = -Infinity;
+	lastFrameMs = 0;
+	targetLimit = BASE_LIMIT_MAG;
+	allowedLimit = BASE_LIMIT_MAG;
+	creditsShown = false;
+	active = false;
+	ready = false;
+	skyTaken = false;
+	sky = new SwitchFade();
+	matrix = [];
+	focusStar = null;
+	focusPoints = null;
+	focusPick = null;
+	constructor(ctx, scene, budget, onChange, pickRegistry) {
+		this.ctx = ctx;
+		this.budget = budget;
+		this.onChange = onChange;
+		this.pickRegistry = pickRegistry;
+		this.group.name = "starfield";
+		this.group.matrixAutoUpdate = false;
+		this.group.visible = false;
+		scene.add(this.group);
+		const open = extrasolarBase() !== "" && !ctx.layers.skipped.has("starfield");
+		this.drawable = open ? "unknown" : "no";
+	}
+	setBudget(budget) {
+		this.budget = budget;
+		this.markDirty();
+	}
+	setFocusStar(star) {
+		const next = star?.tree ? star : null;
+		if (next?.id === this.focusStar?.id) return;
+		this.focusStar = next;
+		if (this.focusPoints) {
+			this.focusPoints.removeFromParent();
+			this.focusPoints.geometry.dispose();
+			this.focusPoints.material.dispose();
+			this.focusPoints = null;
+		}
+		this.dropPick(this.focusPick, FOCUS_PICK_GROUP);
+		this.focusPick = null;
+		if (next) this.focusPoints = this.focusPoint(next);
+		for (const node of this.drawn) if (node.points) this.applyHidden(node);
+		this.onChange();
+	}
+	treeEntry() {
+		return this.tree;
+	}
+	drawnNodes() {
+		const out = [];
+		for (const node of this.drawn) {
+			const view = this.view(node);
+			if (view) out.push(view);
+		}
+		return out;
+	}
+	node(name) {
+		const node = this.nodes.get(name);
+		return node ? this.view(node) : void 0;
+	}
+	pickDraws() {
+		if (!this.group.visible) return [];
+		const out = [];
+		for (const node of this.drawn) {
+			const points = node.points;
+			if (!points?.visible || !node.data) continue;
+			node.pick ??= {
+				base: this.pickRegistry.allocateRows(NODE_PICK_PREFIX + node.name, node.data.container.rows),
+				material: null
+			};
+			out.push({
+				points,
+				material: this.pickMaterial(node.pick, points)
+			});
+		}
+		const focus = this.focusPoints;
+		if (focus) {
+			this.focusPick ??= {
+				base: this.pickRegistry.allocateRows(FOCUS_PICK_GROUP, 1),
+				material: null
+			};
+			out.push({
+				points: focus,
+				material: this.pickMaterial(this.focusPick, focus)
+			});
+		}
+		return out;
+	}
+	pickedStar(pickId) {
+		const at = this.pickRegistry.locate(pickId);
+		if (!at) return null;
+		if (at.groupId === FOCUS_PICK_GROUP) return this.focusStar ? { id: this.focusStar.id } : null;
+		if (!at.groupId.startsWith(NODE_PICK_PREFIX)) return null;
+		return {
+			node: at.groupId.slice(5),
+			row: at.row
+		};
+	}
+	async starId(star) {
+		if ("id" in star) return star.id;
+		const id = (this.nodes.get(star.node)?.ids?.column ?? await this.idsOf(star.node))[star.row];
+		if (!id) throw new Error(`[starfield] row ${star.row} of node ${star.node} has no ID`);
+		return id;
+	}
+	idsOf(name) {
+		let load = this.idLoads.get(name);
+		if (!load) {
+			load = this.loadIds(name).finally(() => this.idLoads.delete(name));
+			this.idLoads.set(name, load);
+		}
+		return load;
+	}
+	async loadIds(name) {
+		const tree = this.tree;
+		if (!tree) throw new Error("[starfield] no tree to read IDs from");
+		const container = await fetchExtrasolarFile(extrasolarPath(tree.ids, { name }), tree.token, { priority: "high" });
+		const node = this.nodes.get(name);
+		const rows = node?.data?.container.rows;
+		if (rows !== void 0 && container.rows !== rows) throw new Error(`[starfield] ID file of node ${name} has ${container.rows} rows, not ${rows}`);
+		const column = container.ids("id");
+		if (node?.data && !node.ids) {
+			node.ids = {
+				column,
+				bytes: container.buffer.byteLength
+			};
+			this.cachedBytes += container.buffer.byteLength;
+		}
+		return column;
+	}
+	pickMaterial(range, points) {
+		range.material ??= makeStarPickMaterial(points.material, range.base);
+		return range.material;
+	}
+	dropPick(range, groupId) {
+		if (!range) return;
+		range.material?.dispose();
+		this.pickRegistry.release(groupId);
+	}
+	rowPosition(name, row) {
+		const data = this.nodes.get(name)?.data;
+		if (!data || row < 0 || row >= data.container.rows) return null;
+		const at = data.geometry.getAttribute("position").array;
+		const [cx, cy, cz] = data.info.centre;
+		const p = treeToScene(cx + at[3 * row], cy + at[3 * row + 1], cz + at[3 * row + 2], {
+			x: 0,
+			y: 0,
+			z: 0
+		});
+		return [
+			p.x,
+			p.y,
+			p.z
+		];
+	}
+	stats() {
+		let drawnPoints = 0;
+		for (const node of this.drawn) drawnPoints += node.data?.container.rows ?? 0;
+		let cachedNodes = 0;
+		for (const node of this.nodes.values()) if (node.data) cachedNodes++;
+		return {
+			drawnNodes: this.drawn.size,
+			drawnPoints,
+			cachedNodes,
+			cachedBytes: this.cachedBytes,
+			loading: this.loading,
+			limit: this.uniforms.uLimit.value,
+			targetLimit: this.targetLimit,
+			active: this.active,
+			share: this.sky.share
+		};
+	}
+	share() {
+		return this.sky.share;
+	}
+	availability() {
+		return this.drawable;
+	}
+	busy() {
+		if (this.loading > 0) return true;
+		if (this.sky.fading) return true;
+		if (this.drawn.size === 0) return false;
+		if (Math.abs(this.uniforms.uLimit.value - this.allowedLimit) > .01) return true;
+		for (const node of this.drawn) {
+			if (node.fade !== (node.wanted ? 1 : 0)) return true;
+			if (node.wanted && node.data && !node.points) return true;
+		}
+		return false;
+	}
+	update(camera, focus, pixelRatio, gain, nowMs) {
+		const dtMs = this.lastFrameMs ? Math.min(nowMs - this.lastFrameMs, 250) : 0;
+		this.lastFrameMs = nowMs;
+		const wx = camera.position.x + focus[0];
+		const wy = camera.position.y + focus[1];
+		const wz = camera.position.z + focus[2];
+		const au = Math.hypot(wx, wy, wz) / 10;
+		if (!this.active && au > 500) this.active = true;
+		else if (this.active && au < 400) this.stopLoading();
+		if (this.active) this.start();
+		const shown = this.ctx.layers.isVisible("starfield");
+		this.skyTaken = starsTakeSky(au, this.skyTaken);
+		this.sky.step(shown && this.ready && this.root !== null && this.skyTaken, dtMs);
+		const skyShare = this.sky.share;
+		this.group.visible = shown && this.root !== null && skyShare > 0;
+		if (!this.root) return;
+		this.group.matrix.fromArray(treeMatrixElements(focus, this.matrix));
+		this.group.matrixWorldNeedsUpdate = true;
+		const cam = sceneToTree(wx, wy, wz);
+		const fromSunPc = Math.hypot(wx, wy, wz) / PC_SCENE;
+		const target = BASE_LIMIT_MAG + 5 * Math.log10(Math.max(1, fromSunPc / EXPOSURE_PC));
+		if (target !== this.targetLimit) this.dirty = true;
+		this.targetLimit = target;
+		const due = this.dirty || nowMs - this.lastSelectMs >= SELECT_EVERY_MS;
+		if (this.active && !this.stale && due) this.select(cam, nowMs);
+		const limit = this.uniforms.uLimit;
+		const ease = dtMs > 0 ? 1 - Math.exp(-dtMs / LIMIT_EASE_MS) : 1;
+		limit.value += (this.allowedLimit - limit.value) * ease;
+		this.uniforms.uPixelRatio.value = pixelRatio;
+		this.uniforms.uGain.value = gain * skyShare;
+		this.applyFades(dtMs, camera, focus);
+		if (this.group.visible && !this.creditsShown && this.drawn.size > 0) {
+			this.creditsShown = true;
+			this.ctx.credits.setStars(this.credits);
+		}
+	}
+	dispose() {
+		this.disposed = true;
+		for (const node of this.nodes.values()) {
+			node.abort?.abort();
+			this.undraw(node);
+			this.dropPick(node.pick, NODE_PICK_PREFIX + node.name);
+			node.data?.geometry.dispose();
+		}
+		this.nodes.clear();
+		this.setFocusStar(null);
+		this.group.removeFromParent();
+	}
+	stopLoading() {
+		this.active = false;
+		this.ready = false;
+		for (const node of this.nodes.values()) {
+			node.wanted = false;
+			node.abort?.abort();
+		}
+		this.markDirty();
+	}
+	start() {
+		if (this.drawable !== "unknown" || this.metadataLoading) return;
+		if (this.retries.waiting(METADATA)) return;
+		this.metadataLoading = true;
+		this.bootGate ??= Promise.race([eagerMinorsDone, new Promise((resolve) => setTimeout(resolve, BOOT_GATE_MS))]);
+		(async () => {
+			await this.bootGate;
+			const meta = await fetchExtrasolarMetadata();
+			const tree = meta?.trees[TREE];
+			if (this.disposed) return;
+			this.retries.clear(METADATA);
+			if (!meta || !tree || !extrasolarAllowed(tree)) {
+				this.noStars();
+				return;
+			}
+			this.tree = tree;
+			this.credits = meta.credits;
+			this.root = this.record(ROOT, 0, tree.centre, tree.half_size, Infinity, null);
+			this.drawable = "yes";
+			this.markDirty();
+		})().catch((err) => {
+			if (this.disposed) return;
+			console.warn("[starfield] metadata.json did not load:", err);
+			this.retries.fail(METADATA);
+		}).finally(() => {
+			this.metadataLoading = false;
+		});
+	}
+	noStars() {
+		this.drawable = "no";
+		this.onChange();
+	}
+	record(name, depth, centre, half, range, parent) {
+		const node = {
+			name,
+			depth,
+			centre,
+			half,
+			range,
+			parent,
+			children: [],
+			state: "idle",
+			abort: null,
+			data: null,
+			points: null,
+			magnitude: Infinity,
+			wanted: false,
+			lastWantedMs: -Infinity,
+			fade: 0,
+			hidden: null,
+			pick: null,
+			ids: null
+		};
+		this.nodes.set(name, node);
+		return node;
+	}
+	markDirty() {
+		this.dirty = true;
+		this.onChange();
+	}
+	select(cam, nowMs) {
+		const tree = this.tree;
+		const root = this.root;
+		if (!tree || !root) return;
+		this.dirty = false;
+		this.lastSelectMs = nowMs;
+		for (const node of this.nodes.values()) node.wanted = false;
+		const magnitude = (node) => node === root ? -Infinity : boxMagnitude(boxDistance(cam, node.centre, node.half), node.range, tree.range_limit_mag);
+		const heap = new NodeHeap();
+		root.magnitude = magnitude(root);
+		heap.push(root);
+		let points = 0;
+		let allowed = this.targetLimit;
+		const wanted = [];
+		for (let node = heap.pop(); node; node = heap.pop()) {
+			if (node.magnitude > this.targetLimit) break;
+			const rows = node.data?.container.rows ?? tree.node_rows;
+			if (points + rows > this.budget.points && node.magnitude > MUST_LOAD_MAG) {
+				allowed = node.magnitude;
+				break;
+			}
+			points += rows;
+			node.wanted = true;
+			node.lastWantedMs = nowMs;
+			wanted.push(node);
+			for (const child of node.children) {
+				child.magnitude = magnitude(child);
+				heap.push(child);
+			}
+		}
+		this.allowedLimit = allowed;
+		if (wanted.every((node) => node.data || this.retries.waiting(node.name))) this.ready = true;
+		for (const node of wanted) {
+			if (this.loading >= this.budget.fetches) break;
+			if (node.state === "idle" && !this.retries.waiting(node.name)) this.load(node);
+		}
+		for (const node of this.nodes.values()) {
+			if (node.state !== "loading" || node.wanted) continue;
+			if (node.magnitude > allowed + ABORT_MARGIN_MAG || !node.parent?.wanted) node.abort?.abort();
+		}
+		for (const node of wanted) if (node.data) this.drawn.add(node);
+		this.evict();
+	}
+	load(node) {
+		const tree = this.tree;
+		if (!tree) return;
+		node.state = "loading";
+		this.loading++;
+		const abort = new AbortController();
+		node.abort = abort;
+		fetchExtrasolarFile(extrasolarPath(tree.node, { name: node.name }), tree.token, {
+			signal: abort.signal,
+			priority: "low"
+		}).then((container) => {
+			if (this.disposed) return;
+			this.retries.clear(node.name);
+			this.adopt(node, container);
+		}).catch((err) => {
+			node.state = "idle";
+			if (this.disposed || abort.signal.aborted) return;
+			if (err instanceof ExtrasolarStaleError) {
+				this.stale = true;
+				return;
+			}
+			this.retries.fail(node.name);
+			console.warn(`[starfield] node ${node.name} did not load:`, err);
+		}).finally(() => {
+			this.loading--;
+			node.abort = null;
+			this.markDirty();
+		});
+	}
+	adopt(node, container) {
+		const info = nodeInfo(container);
+		const rows = container.rows;
+		const x = container.float32("x");
+		const y = container.float32("y");
+		const z = container.float32("z");
+		const position = new Float32Array(3 * rows);
+		for (let i = 0; i < rows; i++) {
+			position[3 * i] = x[i];
+			position[3 * i + 1] = y[i];
+			position[3 * i + 2] = z[i];
+		}
+		const colour = starColours(container.float32("colour"), new Uint8Array(3 * rows));
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new BufferAttribute(position, 3));
+		geometry.setAttribute("mag", new BufferAttribute(container.float32("mag"), 1));
+		geometry.setAttribute("starColour", new BufferAttribute(colour, 3, true));
+		const bytes = container.buffer.byteLength + position.byteLength + colour.byteLength;
+		node.data = {
+			container,
+			info,
+			geometry,
+			bytes
+		};
+		node.state = "loaded";
+		node.centre = info.centre;
+		node.half = info.half;
+		node.range = info.maxRange;
+		this.cachedBytes += bytes;
+		node.children = [];
+		for (let k = 0; k < 8; k++) {
+			if (!(info.childMask >> k & 1)) continue;
+			node.children.push(this.record(node.name + k, node.depth + 1, childCentre(info.centre, info.half, k), info.half / 2, info.childRange[k], node));
+		}
+	}
+	evict() {
+		if (this.cachedBytes <= this.budget.bytes) return;
+		const candidates = [...this.nodes.values()].filter((node) => node.data && !node.wanted && !node.points && node.children.every((child) => child.state === "idle" && !child.data));
+		candidates.sort((a, b) => a.lastWantedMs - b.lastWantedMs || b.depth - a.depth);
+		for (const node of candidates) {
+			if (this.cachedBytes <= this.budget.bytes) break;
+			if (node.children.some((child) => child.data)) continue;
+			this.release(node);
+		}
+	}
+	release(node) {
+		const data = node.data;
+		if (!data) return;
+		data.geometry.dispose();
+		this.cachedBytes -= data.bytes;
+		node.data = null;
+		node.state = "idle";
+		node.hidden = null;
+		this.dropPick(node.pick, NODE_PICK_PREFIX + node.name);
+		node.pick = null;
+		if (node.ids) this.cachedBytes -= node.ids.bytes;
+		node.ids = null;
+		for (const child of node.children) this.forget(child);
+		node.children = [];
+	}
+	forget(node) {
+		for (const child of node.children) this.forget(child);
+		this.nodes.delete(node.name);
+	}
+	applyFades(dtMs, camera, focus) {
+		const step = dtMs / NODE_FADE_MS;
+		let adds = 0;
+		const view = new ViewCone(camera);
+		for (const node of [...this.drawn]) {
+			const target = node.wanted ? 1 : 0;
+			if (!node.points) {
+				if (!node.wanted || !node.data || adds >= ADDS_PER_FRAME) {
+					if (!node.wanted) this.drawn.delete(node);
+					continue;
+				}
+				adds++;
+				this.draw(node);
+			}
+			if (target > node.fade) node.fade = Math.min(node.fade + step, 1);
+			else if (target < node.fade) node.fade = Math.max(node.fade - step, 0);
+			if (node.fade === 0 && !node.wanted) {
+				this.undraw(node);
+				this.drawn.delete(node);
+				continue;
+			}
+			const points = node.points;
+			points.material.uniforms.uFade.value = node.fade;
+			points.visible = view.sees(node, focus);
+		}
+	}
+	draw(node) {
+		const data = node.data;
+		const points = new Points(data.geometry, makeStarMaterial(this.uniforms));
+		points.position.set(...data.info.centre);
+		points.updateMatrix();
+		points.matrixAutoUpdate = false;
+		points.frustumCulled = false;
+		points.renderOrder = STAR_RENDER_ORDER;
+		points.userData.starNode = node.name;
+		node.points = points;
+		node.fade = 0;
+		this.applyHidden(node);
+		this.group.add(points);
+	}
+	focusPoint(star) {
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new BufferAttribute(new Float32Array(3), 3));
+		const mag = star.absMag ?? NO_MAGNITUDE;
+		geometry.setAttribute("mag", new BufferAttribute(new Float32Array([mag]), 1));
+		const colour = starColours(new Float32Array([star.colour ?? NaN]), new Uint8Array(3));
+		geometry.setAttribute("starColour", new BufferAttribute(colour, 3, true));
+		const material = makeStarMaterial(this.uniforms, FOCUS_FLOOR_MAG);
+		material.uniforms.uFade.value = 1;
+		const points = new Points(geometry, material);
+		points.position.set(...star.tree);
+		points.updateMatrix();
+		points.matrixAutoUpdate = false;
+		points.frustumCulled = false;
+		points.renderOrder = STAR_RENDER_ORDER;
+		points.userData.focusStar = star.id;
+		this.group.add(points);
+		return points;
+	}
+	applyHidden(node) {
+		const star = this.focusStar;
+		let row = -1;
+		if (star && node.data) {
+			if (node.hidden?.id !== star.id) node.hidden = {
+				id: star.id,
+				row: findStarRow(node.data, star)
+			};
+			row = node.hidden.row;
+		}
+		node.points.material.uniforms.uHidden.value = row;
+	}
+	undraw(node) {
+		const points = node.points;
+		if (!points) return;
+		points.removeFromParent();
+		points.material.dispose();
+		if (node.pick) {
+			node.pick.material?.dispose();
+			node.pick.material = null;
+		}
+		node.data?.geometry.dispose();
+		node.points = null;
+		node.fade = 0;
+	}
+	view(node) {
+		const data = node.data;
+		if (!data || !node.points) return void 0;
+		return {
+			name: node.name,
+			rows: data.container.rows,
+			points: node.points,
+			container: data.container,
+			info: data.info
+		};
+	}
+};
+var ROW_STEPS = 2 ** -22;
+var ROW_FLOOR_PC = 1e-9;
+var ROW_MAG = .01;
+function findStarRow(data, star) {
+	const tree = star.tree;
+	if (!tree) return -1;
+	const { centre, half } = data.info;
+	const ox = tree[0] - centre[0];
+	const oy = tree[1] - centre[1];
+	const oz = tree[2] - centre[2];
+	if (Math.max(Math.abs(ox), Math.abs(oy), Math.abs(oz)) > half * 1.000001) return -1;
+	const tx = Math.abs(ox) * ROW_STEPS + ROW_FLOOR_PC;
+	const ty = Math.abs(oy) * ROW_STEPS + ROW_FLOOR_PC;
+	const tz = Math.abs(oz) * ROW_STEPS + ROW_FLOOR_PC;
+	const c = data.container;
+	const x = c.float32("x");
+	const y = c.float32("y");
+	const z = c.float32("z");
+	const mag = c.float32("mag");
+	let best = -1;
+	let bestDistance = Infinity;
+	for (let i = 0; i < c.rows; i++) {
+		const dx = Math.abs(x[i] - ox);
+		const dy = Math.abs(y[i] - oy);
+		const dz = Math.abs(z[i] - oz);
+		if (dx > tx || dy > ty || dz > tz) continue;
+		if (star.absMag !== null && Math.abs(mag[i] - star.absMag) > ROW_MAG) continue;
+		const distance = dx + dy + dz;
+		if (distance < bestDistance) {
+			best = i;
+			bestDistance = distance;
+		}
+	}
+	return best;
+}
+var ViewCone = class {
+	tanY;
+	tanX;
+	inverse;
+	constructor(camera) {
+		this.tanY = Math.tan(camera.fov / 2 * Math.PI / 180) / camera.zoom;
+		this.tanX = this.tanY * camera.aspect;
+		this.inverse = camera.matrixWorldInverse;
+	}
+	sees(node, focus) {
+		const [cx, cy, cz] = node.centre;
+		const at = treeToScene(cx, cy, cz, _view);
+		_view.set(at.x - focus[0], at.y - focus[1], at.z - focus[2]).applyMatrix4(this.inverse);
+		const r = node.half * Math.sqrt(3) * PC_SCENE;
+		const depth = -_view.z;
+		if (depth < -r) return false;
+		const sideX = (Math.abs(_view.x) - depth * this.tanX) / Math.hypot(1, this.tanX);
+		const sideY = (Math.abs(_view.y) - depth * this.tanY) / Math.hypot(1, this.tanY);
+		return sideX <= r && sideY <= r;
+	}
+};
+var NodeHeap = class {
+	items = [];
+	push(node) {
+		const items = this.items;
+		items.push(node);
+		let i = items.length - 1;
+		while (i > 0) {
+			const up = i - 1 >> 1;
+			if (items[up].magnitude <= items[i].magnitude) break;
+			[items[up], items[i]] = [items[i], items[up]];
+			i = up;
+		}
+	}
+	pop() {
+		const items = this.items;
+		const top = items[0];
+		const last = items.pop();
+		if (items.length > 0 && last) {
+			items[0] = last;
+			let i = 0;
+			for (;;) {
+				const l = 2 * i + 1;
+				const r = l + 1;
+				let min = i;
+				if (l < items.length && items[l].magnitude < items[min].magnitude) min = l;
+				if (r < items.length && items[r].magnitude < items[min].magnitude) min = r;
+				if (min === i) break;
+				[items[min], items[i]] = [items[i], items[min]];
+				i = min;
+			}
+		}
+		return top;
+	}
+};
+
+//#endregion
+//#region src/lib/scene/visibility/system-fade.ts
+var SYSTEM_RADIUS_AU = 30.07;
+var SYSTEM_OUT_PX = 4.3;
+var SYSTEM_IN_PX = 4.75;
+function systemDiameterPx(distanceScene, viewportPx, fovDeg) {
+	const pxPerRad = viewportPx / 2 / Math.tan(fovDeg * Math.PI / 360);
+	return 2 * SYSTEM_RADIUS_AU * 10 / distanceScene * pxPerRad;
+}
+function systemShown(distanceScene, viewportPx, fovDeg, shown) {
+	const px = systemDiameterPx(distanceScene, viewportPx, fovDeg);
+	if (px < 4.3) return false;
+	if (px > 4.75) return true;
+	return shown;
+}
+
 //#endregion
 //#region src/lib/scene/interaction/picking.ts
-function pickMoonDot(pointer, camera, ctx, focusTruePos, canvasWidth, canvasHeight, tmpV3, jd, pointerType, isVisible) {
-	const SCREEN_THRESHOLD = pointerType === "touch" || pointerType === "pen" ? 48 : 24;
+function isCoarsePointer(pointerType) {
+	return pointerType === "touch" || pointerType === "pen";
+}
+function pickRadiusPx(pointerType) {
+	return isCoarsePointer(pointerType) ? 48 : 24;
+}
+function pickMoonDot(pick) {
+	const { ctx } = pick;
+	return pickDot(ctx.bodies.majorBodies.filter((body) => body.data.objectType === ObjectType.MOON && ctx.visibility.isMoonGroupVisible(body.data.parentId)), pick);
+}
+function pickPlanetDot(pick) {
+	const { ctx, camera, focusTruePos } = pick;
+	const [fx, fy, fz] = focusTruePos;
+	const cam = camera.position;
+	return pickDot(ctx.bodies.majorBodies.filter((body) => {
+		const t = body.data.objectType;
+		if (t !== ObjectType.STAR && t !== ObjectType.PLANET && t !== ObjectType.DWARF_PLANET) return false;
+		const at = body.position;
+		if (!at) return false;
+		const dist = Math.hypot(at[0] - fx - cam.x, at[1] - fy - cam.y, at[2] - fz - cam.z);
+		return ctx.visibility.getPlanetVisibility(body, dist) !== VISIBILITY.HIDE;
+	}), pick);
+}
+function pickDot(bodies, pick) {
+	const { pointer, camera, ctx, canvasWidth, canvasHeight, jd, isVisible } = pick;
 	const px = (pointer.x + 1) * .5 * canvasWidth;
 	const py = (1 - pointer.y) * .5 * canvasHeight;
-	const v = tmpV3;
-	const [fx, fy, fz] = focusTruePos;
+	const v = pick.tmpV3;
+	const [fx, fy, fz] = pick.focusTruePos;
 	const cam = camera.position;
 	let bestBody;
-	let bestScreenDist = SCREEN_THRESHOLD;
+	let bestScreenDist = pickRadiusPx(pick.pointerType);
 	let bestWorldDist = Infinity;
-	const testBody = (body) => {
+	for (const body of bodies) {
 		const at = ctx.place(body, jd);
-		if (!at) return;
+		if (!at) continue;
 		v.set(at[0] - fx, at[1] - fy, at[2] - fz);
 		const worldDist = Math.hypot(v.x - cam.x, v.y - cam.y, v.z - cam.z);
 		v.project(camera);
-		if (!ndcZVisible(v.z)) return;
+		if (!ndcZVisible(v.z)) continue;
 		const sx = (v.x + 1) * .5 * canvasWidth;
 		const sy = (1 - v.y) * .5 * canvasHeight;
 		const screenDist = Math.hypot(sx - px, sy - py);
-		if (!(screenDist < bestScreenDist || screenDist === bestScreenDist && worldDist < bestWorldDist)) return;
-		if (isVisible && !isVisible(v.x, v.y, worldDist)) return;
+		if (!(screenDist < bestScreenDist || screenDist === bestScreenDist && worldDist < bestWorldDist)) continue;
+		if (isVisible && !isVisible(v.x, v.y, worldDist)) continue;
 		bestScreenDist = screenDist;
 		bestWorldDist = worldDist;
 		bestBody = body;
-	};
-	for (const body of ctx.bodies.majorBodies) {
-		if (body.data.objectType !== ObjectType.MOON) continue;
-		if (!ctx.visibility.isMoonGroupVisible(body.data.parentId)) continue;
-		testBody(body);
 	}
 	if (!bestBody) return null;
 	return {
@@ -19418,7 +21519,12 @@ function pickMoonDot(pointer, camera, ctx, focusTruePos, canvasWidth, canvasHeig
 
 //#endregion
 //#region src/lib/scene/interaction/pointer.ts
-var CLICK_DRAG_PX2 = 9;
+var CLICK_DRAG_PX = 3;
+var TOUCH_SLOP_PX = 10;
+function movedTooFar(e, from) {
+	const limit = isCoarsePointer(e.pointerType) ? TOUCH_SLOP_PX : CLICK_DRAG_PX;
+	return Math.hypot(e.clientX - from.x, e.clientY - from.y) > limit;
+}
 function inHiddenRoot(obj) {
 	let top = obj;
 	while (top.parent?.parent) top = top.parent;
@@ -19426,11 +21532,13 @@ function inHiddenRoot(obj) {
 }
 var PointerInteraction = class {
 	downPos = new Vector2();
+	down = /* @__PURE__ */ new Set();
+	gesture = false;
 	pointer = new Vector2();
 	_tmpPointer = new Vector2();
 	raycaster = new Raycaster();
 	_tmpV3 = new Vector3();
-	constructor(canvas, camera, ctx, clock, focus, clickables, meshToBody, onPick, modelPick, gpuPick, getClouds, pickRegistry) {
+	constructor(canvas, camera, ctx, clock, focus, clickables, meshToBody, onPick, modelPick, gpuPick, getClouds, pickRegistry, getStars, onStarPick) {
 		this.canvas = canvas;
 		this.camera = camera;
 		this.ctx = ctx;
@@ -19443,22 +21551,39 @@ var PointerInteraction = class {
 		this.gpuPick = gpuPick;
 		this.getClouds = getClouds;
 		this.pickRegistry = pickRegistry;
+		this.getStars = getStars;
+		this.onStarPick = onStarPick;
 	}
 	attach() {
 		this.canvas.addEventListener("pointerdown", this.onDown);
+		this.canvas.addEventListener("pointermove", this.onMove);
 		this.canvas.addEventListener("pointerup", this.onUp);
+		this.canvas.addEventListener("pointercancel", this.onCancel);
 	}
 	detach() {
 		this.canvas.removeEventListener("pointerdown", this.onDown);
+		this.canvas.removeEventListener("pointermove", this.onMove);
 		this.canvas.removeEventListener("pointerup", this.onUp);
+		this.canvas.removeEventListener("pointercancel", this.onCancel);
 	}
 	onDown = (e) => {
-		this.downPos.set(e.clientX, e.clientY);
+		if (e.isPrimary) {
+			this.down.clear();
+			this.gesture = false;
+			this.downPos.set(e.clientX, e.clientY);
+		} else this.gesture = true;
+		this.down.add(e.pointerId);
+	};
+	onMove = (e) => {
+		if (this.gesture || !this.down.has(e.pointerId)) return;
+		if (movedTooFar(e, this.downPos)) this.gesture = true;
+	};
+	onCancel = (e) => {
+		this.down.delete(e.pointerId);
+		this.gesture = true;
 	};
 	onUp = (e) => {
-		const dx = e.clientX - this.downPos.x;
-		const dy = e.clientY - this.downPos.y;
-		if (dx * dx + dy * dy > CLICK_DRAG_PX2) return;
+		if (!this.down.delete(e.pointerId) || this.gesture || movedTooFar(e, this.downPos)) return;
 		const rect = this.canvas.getBoundingClientRect();
 		this.pointer.set((e.clientX - rect.left) / rect.width * 2 - 1, -((e.clientY - rect.top) / rect.height) * 2 + 1);
 		const modelBody = this.modelPick(this.pointer.x, this.pointer.y);
@@ -19468,11 +21593,41 @@ var PointerInteraction = class {
 		}
 		this.raycaster.setFromCamera(this.pointer, this.camera);
 		const meshBody = this.resolveMeshHit(this.raycaster.intersectObjects([...this.clickables, ...attachedModelRoots]))?.body;
-		const moonHit = pickMoonDot(this.pointer, this.camera, this.ctx, this.focus.focusTruePos, this.canvas.clientWidth, this.canvas.clientHeight, this._tmpV3, this.clock.jd, e.pointerType, this.isDotVisible);
+		const dots = {
+			pointer: this.pointer,
+			camera: this.camera,
+			ctx: this.ctx,
+			focusTruePos: this.focus.focusTruePos,
+			canvasWidth: this.canvas.clientWidth,
+			canvasHeight: this.canvas.clientHeight,
+			tmpV3: this._tmpV3,
+			jd: this.clock.jd,
+			pointerType: e.pointerType,
+			isVisible: this.isDotVisible
+		};
+		const moonHit = pickMoonDot(dots);
 		const gpuHit = this.gpuPickCloud(e, rect);
 		const bestBody = this.nearer(moonHit, gpuHit)?.body ?? meshBody;
-		if (bestBody) this.onPick(bestBody);
+		if (bestBody) {
+			this.onPick(bestBody);
+			return;
+		}
+		this.pickStar(e, rect, dots);
 	};
+	pickStar(e, rect, dots) {
+		const stars = this.getStars();
+		if (stars.length === 0) return;
+		const planet = pickPlanetDot(dots);
+		if (planet) {
+			this.onPick(planet.body);
+			return;
+		}
+		const candidates = this.gpuPick.pickDraws(stars, this.camera, e.clientX, e.clientY, rect, pickRadiusPx(e.pointerType));
+		for (const c of candidates) {
+			if (!this.isDotVisible(c.ndcX, c.ndcY, Infinity)) continue;
+			if (this.onStarPick(c.pickId)) return;
+		}
+	}
 	nearer(a, b) {
 		if (!a) return b;
 		if (!b) return a;
@@ -19481,9 +21636,8 @@ var PointerInteraction = class {
 		return a;
 	}
 	gpuPickCloud(e, rect) {
-		const radius = e.pointerType === "touch" || e.pointerType === "pen" ? 48 : 24;
 		const jd = this.clock.jd;
-		const candidates = this.gpuPick.pick(this.getClouds(), this.camera, e.clientX, e.clientY, rect, radius);
+		const candidates = this.gpuPick.pick(this.getClouds(), this.camera, e.clientX, e.clientY, rect, pickRadiusPx(e.pointerType));
 		for (const c of candidates) {
 			const bodyId = this.pickRegistry.resolve(c.pickId);
 			if (!bodyId) continue;
@@ -19566,6 +21720,7 @@ var GpuPickPass = class {
 	buffer = new Uint8Array(0);
 	prevClear = new Color();
 	proxies = [];
+	idleGeometry = new BufferGeometry();
 	constructor(renderer, camera) {
 		this.renderer = renderer;
 		this.target = new WebGLRenderTarget(1, 1, { depthBuffer: true });
@@ -19588,19 +21743,33 @@ var GpuPickPass = class {
 		this.target.setSize(px, px);
 		this.buffer = new Uint8Array(px * px * 4);
 	}
-	proxyAt(index, src) {
+	proxyAt(index, src, material) {
 		let p = this.proxies[index];
 		if (!p) {
-			p = new Points(src.geometry, this.material);
+			p = new Points(src.geometry, material);
 			p.frustumCulled = false;
 			p.matrixAutoUpdate = false;
 			p.matrixWorldAutoUpdate = false;
 			this.proxies[index] = p;
-		} else p.geometry = src.geometry;
+		} else {
+			p.geometry = src.geometry;
+			p.material = material;
+		}
 		p.matrixWorld.copy(src.matrixWorld);
 		return p;
 	}
 	pick(clouds, camera, clientX, clientY, rect, radiusCss) {
+		const draws = [];
+		for (const points of clouds) {
+			if (!points.geometry.getAttribute("pickColor")) continue;
+			draws.push({
+				points,
+				material: this.material
+			});
+		}
+		return this.pickDraws(draws, camera, clientX, clientY, rect, radiusCss);
+	}
+	pickDraws(draws, camera, clientX, clientY, rect, radiusCss) {
 		const r = Math.max(1, Math.round(radiusCss));
 		const boxPx = r * 2 + 1;
 		this.ensureSize(boxPx);
@@ -19608,13 +21777,11 @@ var GpuPickPass = class {
 		const cy = clientY - rect.top;
 		const offsetX = cx - r;
 		const offsetY = cy - r;
-		this.scene.clear();
 		let n = 0;
-		for (const pts of clouds) {
-			if (!pts.visible) continue;
-			if (!pts.geometry.getAttribute("pickColor")) continue;
-			if (pts.geometry.drawRange.count === 0) continue;
-			this.scene.add(this.proxyAt(n++, pts));
+		for (const { points, material } of draws) {
+			if (!points.visible) continue;
+			if (points.geometry.drawRange.count === 0) continue;
+			this.scene.add(this.proxyAt(n++, points, material));
 		}
 		if (n === 0) return [];
 		this.pickCamera.copy(camera);
@@ -19630,12 +21797,21 @@ var GpuPickPass = class {
 		this.renderer.clear(true, true, false);
 		this.renderer.render(this.scene, this.pickCamera);
 		this.renderer.readRenderTargetPixels(this.target, 0, 0, boxPx, boxPx, this.buffer);
+		this.letGo(n);
 		this.renderer.setRenderTarget(prevTarget);
 		this.renderer.autoClear = prevAutoClear;
 		this.renderer.setClearColor(this.prevClear, prevClearAlpha);
 		this.pickCamera.clearViewOffset();
 		return this.decode(boxPx, r, rect, offsetX, offsetY);
 	}
+	letGo(n) {
+		this.scene.clear();
+		for (let i = 0; i < n; i++) {
+			this.proxies[i].geometry = this.idleGeometry;
+			this.proxies[i].material = this.material;
+		}
+		this.renderer.render(this.scene, this.pickCamera);
+	}
 	decode(boxPx, r, rect, offsetX, offsetY) {
 		const buf = this.buffer;
 		const nearest = /* @__PURE__ */ new Map();
@@ -19665,6 +21841,7 @@ var GpuPickPass = class {
 	dispose() {
 		this.target.dispose();
 		this.material.dispose();
+		this.idleGeometry.dispose();
 		this.proxies.length = 0;
 	}
 };
@@ -20078,7 +22255,7 @@ function buildMajorBodies(bodies, scene, clickables, meshToBody, bodyObjects, re
 		const id = body.data.id;
 		const isHalfPromoted = halfPromoteIds?.has(id) ?? false;
 		const t = body.data.objectType;
-		const isVirtual = isHalfPromoted || t === ObjectType.BARYCENTER || t === ObjectType.LAGRANGE_POINT || t === ObjectType.COMET || isAsteroid(t) || body.data.orbitalSource === OrbitalSource.SPICE_PROBE;
+		const isVirtual = isHalfPromoted || t === ObjectType.EXTRASOLAR || t === ObjectType.BARYCENTER || t === ObjectType.LAGRANGE_POINT || t === ObjectType.COMET || isAsteroid(t) || body.data.orbitalSource === OrbitalSource.SPICE_PROBE;
 		const color = resolveBodyColor(body.data);
 		const radius = kmToScene(effectiveRadiusKm(body.data));
 		const isStar = t === ObjectType.STAR;
@@ -20121,7 +22298,7 @@ function buildMajorBodies(bodies, scene, clickables, meshToBody, bodyObjects, re
 			}
 		}
 		const variant = getLabelVariant(body);
-		const isLarge = isStar || t === ObjectType.PLANET;
+		const isLarge = isStar || t === ObjectType.EXTRASOLAR || t === ObjectType.PLANET;
 		const isMinor = isHalfPromoted || MINOR_PROMOTED_IDS.has(id) || body.data.isMinor === true;
 		const label = createLabel(color, body.data.name ?? "", variant, host().bodyHref(id, body.data.name ?? ""), () => handleFocus(body), isLarge, onHoverChange ? (hovered) => onHoverChange(id, hovered) : void 0, isMinor);
 		if (label) {
@@ -21014,7 +23191,7 @@ function buildTrails(bodyObjects, scene, basisPos = [
 	for (const [, bo] of bodyObjects) {
 		if (bo.trail !== null) continue;
 		const { body } = bo;
-		if (body.data.objectType === ObjectType.STAR) continue;
+		if (body.data.objectType === ObjectType.STAR || isExtrasolar(body)) continue;
 		if (body.data.orbitalSource === OrbitalSource.SPICE_PROBE) {
 			if (bo.isMinor && !bo.mesh) continue;
 		} else if (!bo.mesh && !bo.focusUpgraded && isMeshUpgradable(body)) continue;
@@ -22130,10 +24307,18 @@ var PickRegistry = class {
 	#next = 1;
 	#groups = /* @__PURE__ */ new Map();
 	allocate(groupId, keys) {
+		return this.add(groupId, keys.length, keys);
+	}
+	allocateRows(groupId, length) {
+		return this.add(groupId, length, null);
+	}
+	add(groupId, length, keys) {
 		const base = this.#next;
-		this.#next += keys.length;
+		this.#next += length;
 		this.#groups.set(groupId, {
+			groupId,
 			base,
+			length,
 			keys
 		});
 		return base;
@@ -22142,8 +24327,20 @@ var PickRegistry = class {
 		this.#groups.delete(groupId);
 	}
 	resolve(pickId) {
-		if (pickId === 0) return null;
-		for (const { base, keys } of this.#groups.values()) if (pickId >= base && pickId < base + keys.length) return keyToId(keys[pickId - base]);
+		const group = this.find(pickId);
+		if (!group?.keys) return null;
+		return keyToId(group.keys[pickId - group.base]);
+	}
+	locate(pickId) {
+		const group = this.find(pickId);
+		if (!group || group.keys) return null;
+		return {
+			groupId: group.groupId,
+			row: pickId - group.base
+		};
+	}
+	find(pickId) {
+		for (const group of this.#groups.values()) if (pickId >= group.base && pickId < group.base + group.length) return group;
 		return null;
 	}
 	clear() {
@@ -22243,6 +24440,8 @@ var PointCloudSystem = class {
 		brightMult: 1,
 		opacity: EMPHASIS_BASE_OPACITY
 	};
+	fade = 1;
+	moonFades = /* @__PURE__ */ new Map();
 	constructor(ctx, scene, bodyObjects, circleTexture, focus, mapLayer, onBasisRebuilt) {
 		this.ctx = ctx;
 		this.scene = scene;
@@ -22262,13 +24461,13 @@ var PointCloudSystem = class {
 	}
 	applyPointBudget() {
 		let total = 0;
-		for (const kind of WORKER_CLOUD_KINDS) for (const pts of this.workerPoints[kind].values()) if (pts.visible) total += pts.userData.solvedCount ?? 0;
-		const fraction = total > this.pointBudget ? this.pointBudget / total : 1;
-		if (fraction === this.drawFraction) return;
-		this.drawFraction = fraction;
+		for (const kind of WORKER_CLOUD_KINDS) for (const pts of this.workerPoints[kind].values()) if (pts.visible && !pts.userData.leaving) total += pts.userData.solvedCount ?? 0;
+		this.drawFraction = total > this.pointBudget ? this.pointBudget / total : 1;
 		for (const kind of WORKER_CLOUD_KINDS) for (const pts of this.workerPoints[kind].values()) {
+			if (pts.userData.leaving || pts.userData.drawFraction === this.drawFraction) continue;
+			pts.userData.drawFraction = this.drawFraction;
 			const n = pts.userData.solvedCount;
-			if (n !== void 0) pts.geometry.setDrawRange(0, Math.ceil(n * fraction));
+			if (n !== void 0) pts.geometry.setDrawRange(0, Math.ceil(n * this.drawFraction));
 		}
 	}
 	setEarthSatEmphasis(count) {
@@ -22291,7 +24490,49 @@ var PointCloudSystem = class {
 		const { size, dim, opacity } = this.earthSatEmphasis;
 		mat.size = size;
 		mat.color.setRGB(dim, dim, dim);
-		mat.opacity = opacity;
+		this.setOpacity(pts, opacity);
+	}
+	setFade(fade) {
+		if (fade === this.fade) return;
+		this.fade = fade;
+		for (const kind of WORKER_CLOUD_KINDS) for (const pts of this.workerPoints[kind].values()) this.applyOpacity(pts);
+		for (const pts of this.moonPoints.values()) this.applyOpacity(pts);
+	}
+	setOpacity(pts, opacity) {
+		pts.userData.opacity = opacity;
+		this.applyOpacity(pts);
+	}
+	applyOpacity(pts) {
+		pts.material.opacity = pts.userData.opacity * this.fade * (pts.userData.share ?? 1);
+	}
+	updateVisibility(dtMs) {
+		const vis = this.ctx.visibility;
+		for (const [key, pts] of this.workerPoints.asteroid) this.setShare(pts, vis.asteroidGroupShare(parentIdFromSubkey(key)));
+		for (const [key, pts] of this.workerPoints.spacecraft) this.setShare(pts, vis.spacecraftGroupShare(parentIdFromSubkey(key)));
+		for (const [parentId, pts] of this.moonPoints) {
+			let fade = this.moonFades.get(parentId);
+			if (!fade) {
+				fade = new SwitchFade(void 0, 100);
+				this.moonFades.set(parentId, fade);
+			}
+			fade.step(vis.isMoonGroupVisible(parentId), dtMs);
+			this.setShare(pts, fade.share);
+		}
+	}
+	get fading() {
+		for (const fade of this.moonFades.values()) if (fade.fading) return true;
+		return false;
+	}
+	setShare(pts, share) {
+		pts.visible = share > 0;
+		const was = pts.userData.share;
+		if (was === share) return;
+		pts.userData.leaving = was !== void 0 && share < was;
+		pts.userData.share = share;
+		this.applyOpacity(pts);
+	}
+	fadeNewCloud(pts) {
+		this.setOpacity(pts, pts.material.opacity);
 	}
 	setEmphasizedSmallBodyZone(zone, count) {
 		const prev = this.emphasizedSmallBodyZone;
@@ -22323,14 +24564,14 @@ var PointCloudSystem = class {
 		const { sizeMult, brightMult, opacity } = this.smallBodyEmphasis;
 		mat.size = baseSize * sizeMult;
 		mat.color.copy(baseColor).multiplyScalar(brightMult);
-		mat.opacity = opacity;
+		this.setOpacity(pts, opacity);
 	}
 	resetSmallBodyEmphasis(pts) {
 		if (pts.userData.smallBodyBaseSize === void 0) return;
 		const mat = pts.material;
 		mat.size = pts.userData.smallBodyBaseSize;
 		mat.color.copy(pts.userData.smallBodyBaseColor);
-		mat.opacity = EMPHASIS_BASE_OPACITY;
+		this.setOpacity(pts, EMPHASIS_BASE_OPACITY);
 		pts.userData.smallBodyBaseSize = void 0;
 		pts.userData.smallBodyBaseColor = void 0;
 	}
@@ -22345,8 +24586,10 @@ var PointCloudSystem = class {
 		for (const kind of WORKER_CLOUD_KINDS) for (const [key, p] of this.workerPoints[kind]) {
 			const bucketKey = parentIdFromSubkey(key);
 			p.userData.parentBodyId = this.cloudParentId(kind, bucketKey);
+			this.fadeNewCloud(p);
 			this.emphasiseNewCloud(kind, bucketKey, p);
 		}
+		for (const p of this.moonPoints.values()) this.fadeNewCloud(p);
 		this.assignMapLayer();
 	}
 	assignMapLayer() {
@@ -22504,6 +24747,7 @@ var PointCloudSystem = class {
 			0,
 			0
 		];
+		this.fadeNewCloud(pts);
 		this.emphasiseNewCloud(kind, bucketKey, pts);
 		this.workerPoints[kind].set(key, pts);
 		this.pendingSceneAdds.push(pts);
@@ -22561,7 +24805,8 @@ var PointCloudSystem = class {
 		posAttr.needsUpdate = true;
 		this.bindPickIds(pts, pickIds);
 		pts.userData.solvedCount = count;
-		pts.geometry.setDrawRange(0, Math.ceil(count * this.drawFraction));
+		const fraction = pts.userData.drawFraction ?? this.drawFraction;
+		pts.geometry.setDrawRange(0, Math.ceil(count * fraction));
 		this.lastSolvedJd.set(groupId, jd);
 		pts.userData.frontBasis = [
 			basisUsed[0],
@@ -22697,7 +24942,7 @@ var PointCloudSystem = class {
 		for (const [parentId, moons] of this.moonsByParent()) {
 			const pts = this.moonPoints.get(parentId);
 			if (!pts) continue;
-			if (!this.ctx.visibility.isMoonGroupVisible(parentId)) continue;
+			if (!pts.visible && !this.ctx.visibility.isMoonGroupVisible(parentId)) continue;
 			const posAttr = pts.geometry.getAttribute("position");
 			const arr = posAttr.array;
 			const n = Math.min(moons.length, arr.length / 3);
@@ -23002,9 +25247,16 @@ var _anchorOut = {
 };
 var _modelSphereCenter = new Vector3();
 var _anchorProj = new Vector3();
-function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBodyId, hideCappedMoonLabels, hoveredBodyIds, asteroidPoints, spacecraftPoints, moonPoints, cullFrameCounter, renderer, tmpV3, forceCull, suppressHeliocentricTrails) {
+function fadeLabel(label, share) {
+	if (label.userData.systemShare === share) return;
+	label.userData.systemShare = share;
+	label.element.style.opacity = share < 1 ? String(share) : "";
+}
+function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBodyId, hideCappedMoonLabels, hoveredBodyIds, cullFrameCounter, renderer, tmpV3, forceCull, suppressHeliocentricTrails) {
 	const layers = ctx.layers;
 	const hideOrbits = !layers.isVisible("orbits");
+	const systemShare = ctx.visibility.systemShare;
+	const starShare = ctx.visibility.starShare;
 	const showNomenclature = layers.isVisible("nomenclature");
 	const fovRad = camera.fov * Math.PI / 180;
 	const screenW = renderer.domElement.clientWidth;
@@ -23136,10 +25388,18 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 		let isClose;
 		const isFocused = body.data.id === focusedBodyId;
 		const isSystemRoot = focusedSystemId !== null && body.data.id === focusedSystemId;
-		if (bo.mesh === null && !isMajorBody(body.data.objectType)) {
+		let zoneShare = 1;
+		let labelThresholdShare = 1;
+		let orbitThresholdShare = 1;
+		if (isExtrasolar(body)) {
+			const visible = starShare > 0;
+			group.visible = visible;
+			showLabel = visible;
+			isClose = false;
+		} else if (bo.mesh === null && !isMajorBody(body.data.objectType)) {
 			const ot = body.data.objectType;
 			if (ot === ObjectType.BARYCENTER || ot === ObjectType.LAGRANGE_POINT) {
-				let visible = true;
+				let visible = systemShare > 0;
 				const primaryId = !isFocused ? barycenterPrimaryId(body.data.id) : void 0;
 				if (primaryId) {
 					const primary = bodyObjects.get(primaryId)?.body ?? ctx.getBody(primaryId);
@@ -23152,7 +25412,9 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 				showLabel = visible;
 				isClose = false;
 			} else {
-				const visible = ctx.visibility.getPlanetVisibility(body, dist) !== VISIBILITY.HIDE && ctx.visibility.hasFullRendering(body);
+				const vis = ctx.visibility.getPlanetVisibility(body, dist);
+				zoneShare = ctx.visibility.fullRenderingShare(body);
+				const visible = vis !== VISIBILITY.HIDE && zoneShare > 0;
 				group.visible = visible;
 				if (trail) trail.visible = visible;
 				showLabel = visible;
@@ -23161,18 +25423,32 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 		} else {
 			const isMoon = body.data.objectType === ObjectType.MOON;
 			const vis = isMoon ? ctx.visibility.getMoonVisibility(body) : ctx.visibility.getPlanetVisibility(body, dist);
-			const vf = isMoon ? moonVisFlags(vis, hideCappedMoonLabels, isFocused) : bodyVisFlags(vis, ctx.visibility.hasFullRendering(body), isFocused || isSystemRoot);
+			if (!isMoon) zoneShare = ctx.visibility.fullRenderingShare(body);
+			const vf = isMoon ? moonVisFlags(vis, hideCappedMoonLabels, isFocused) : bodyVisFlags(vis, zoneShare > 0, isFocused || isSystemRoot);
 			group.visible = vf.groupVisible;
 			if (trail) trail.visible = vf.orbitVisible;
 			showLabel = vf.showLabel;
 			isClose = vf.isClose;
 		}
+		if (focusedSystemId !== null && ctx.visibility.isBodyInSystem(body, focusedSystemId)) {
+			labelThresholdShare = ctx.visibility.labelThresholdShare(body.data.id, showLabel);
+			orbitThresholdShare = ctx.visibility.orbitThresholdShare(body.data.id, !!trail?.visible);
+			if (labelThresholdShare > 0) {
+				group.visible = true;
+				showLabel = true;
+			}
+			if (trail && orbitThresholdShare > 0) trail.visible = true;
+		}
 		if (!drawn) {
 			group.visible = false;
 			showLabel = false;
 			isClose = false;
 		}
 		if (trail && (!drawn || body.orbitCenter === null)) trail.visible = false;
+		if (trail) {
+			trail.userData.zoneShare = zoneShare;
+			trail.userData.thresholdShare = orbitThresholdShare;
+		}
 		let starIsPoint = false;
 		if (bo.starPoint && drawn) {
 			const t = bo.radiusScene / dist * projScale / STAR_POINT_HANDOFF_R;
@@ -23205,12 +25481,10 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 			}
 		}
 		if (applyLabelDisplay(bo, showLabel, isClose, dist, projScale, focusedBodyId)) newlyShownLabel = true;
+		if (bo.label) fadeLabel(bo.label, bo.starPoint ? 1 : isExtrasolar(body) ? starShare : systemShare * zoneShare * labelThresholdShare);
 		const nomScreenR = bo.radiusScene > 0 ? bo.radiusScene / dist * projScale : 0;
 		updateNomenclatureVisibility(bo, showNomenclature && body.data.id === nomFocusedBodyId, nomScreenR, camera, screenW, screenH);
 	}
-	for (const [key, pts] of asteroidPoints) pts.visible = ctx.visibility.isAsteroidGroupVisible(parentIdFromSubkey(key));
-	for (const [key, pts] of spacecraftPoints) pts.visible = ctx.visibility.isSpacecraftGroupVisible(parentIdFromSubkey(key));
-	for (const [parentId, pts] of moonPoints) pts.visible = ctx.visibility.isMoonGroupVisible(parentId);
 	if (screenOccluders.length > 0) {
 		const focusedPrimaryId = focusedBodyId ? barycenterPrimaryId(focusedBodyId) : null;
 		for (const bo of bodyObjects.values()) {
@@ -23236,7 +25510,8 @@ function updateBodyVisibility(bodyObjects, camera, ctx, focusTruePos, focusedBod
 		mat.uniforms.uCenterOffset.value.set(-camera.position.x, -camera.position.y, -camera.position.z);
 		const isFocused = bo.body.data.id === focusedBodyId;
 		const isHovered = hoveredBodyIds.has(bo.body.data.id);
-		mat.uniforms.uAlphaMultiplier.value = isHovered ? 2 : isFocused ? 1.75 : 1;
+		const share = systemShare * (line.userData.zoneShare ?? 1) * (line.userData.thresholdShare ?? 1);
+		mat.uniforms.uAlphaMultiplier.value = (isHovered ? 2 : isFocused ? 1.75 : 1) * share;
 		const isClosed = line.userData.isOpenCurve === false;
 		mat.uniforms.uAlphaMin.value = isFocused && isClosed ? .15 : 0;
 		mat.uniforms.uShowFull.value = isFocused ? 1 : 0;
@@ -24524,6 +26799,7 @@ var OutOfRangeNotifier = class {
 //#region src/lib/scene/position/landed-probe.ts
 var lastSeat = /* @__PURE__ */ new Map();
 var _upScene = new Vector3();
+var _northScene = new Vector3();
 function renderLandedProbe(d, probe, landed, jd, where, ctx, bodyObjects) {
 	const sample = landedPositionAt(landed, jd, landedOpenEnded(probe));
 	if (!sample) return null;
@@ -24553,18 +26829,24 @@ function renderLandedProbe(d, probe, landed, jd, where, ctx, bodyObjects) {
 	const quat = bodyQuaternion(landingBody.orientation, jd, landingBody.nutPrec);
 	const tmp = new Vector3(bx, by, bz).applyQuaternion(quat);
 	const up = eff ? _upScene.set(eff.normal[0], eff.normal[1], eff.normal[2]).applyQuaternion(quat) : null;
+	const north = _northScene.set(-Math.sin(latR) * Math.cos(lngR), Math.cos(latR), Math.sin(latR) * Math.sin(lngR)).applyQuaternion(quat);
 	d.parentId = bodyKey;
 	return {
 		x: bodyWorldPos[0] + kmToScene(tmp.x),
 		y: bodyWorldPos[1] + kmToScene(tmp.y),
 		z: bodyWorldPos[2] + kmToScene(tmp.z),
 		parentPos: bodyWorldPos,
-		up
+		up,
+		north
 	};
 }
 
 //#endregion
 //#region src/lib/scene/position/placer.ts
+function fixedPlace(body) {
+	const at = body.extrasolar?.scene;
+	return at ? setPlaced(body, at[0], at[1], at[2]) : setUnplaced(body, "never");
+}
 var newestPosScratch = [
 	0,
 	0,
@@ -24649,7 +26931,7 @@ var Placer = class {
 			return null;
 		}
 		this.settling.add(id);
-		const pos = isSurfaceFeature(body) ? this.seatFeature(body, jd) : this.settle(body, jd);
+		const pos = isSurfaceFeature(body) ? this.seatFeature(body, jd) : isExtrasolar(body) ? fixedPlace(body) : this.settle(body, jd);
 		this.settling.delete(id);
 		if (jd === this.passJd) this.settled.add(id);
 		return pos;
@@ -24810,8 +27092,12 @@ var Placer = class {
 			const up = landedRender.up;
 			if (bo?.mesh) if (up) applyUpVector(bo.mesh, up);
 			else applySouthTowardParent(bo.mesh, pos, landedRender.parentPos);
-			if (bo?.model) if (up) applyUpVector(bo.model, up);
-			else applySouthTowardParent(bo.model, pos, landedRender.parentPos);
+			if (bo?.model) {
+				if (up) applyUpVector(bo.model, up);
+				else applySouthTowardParent(bo.model, pos, landedRender.parentPos);
+				const heading = landedHeadingAt(body.landedHeadings, jd);
+				if (heading !== void 0) turnToHeading(bo.model, landedRender.north, heading);
+			}
 			return pos;
 		}
 		const primary = resolveProbePrimary(located.probe, jd, located.fitCenterNaifId, ctx.chebStore ?? null, (id) => this.at(id, jd) !== null);
@@ -25374,6 +27660,13 @@ function updateSunShadowLight(bodyObjects, focusTruePos, ctx, shadowLight, sunPo
 	shadowCam.updateProjectionMatrix();
 }
 
+//#endregion
+//#region src/lib/scene/relief/grid-heights.ts
+var CAP_SIN = Math.sin(60 * Math.PI / 180);
+function gridChart(level, y) {
+	return level < 1 || Math.abs(y) <= CAP_SIN ? 0 : y > 0 ? 1 : 2;
+}
+
 //#endregion
 //#region src/lib/scene/lod/terrain-grid.ts
 var COARSE_SEGS = 128;
@@ -25591,7 +27884,14 @@ function heightTilesOf(bo) {
 	return reliefTilesAvailable(tiles) && !tiledStates.get(bo)?.dead ? tiles : void 0;
 }
 function gridLevel(tiles, theta, phi, radius) {
-	const deepest = deepestLevel(tiles.max_level, tiles.patches, phi / (2 * Math.PI), theta / Math.PI);
+	const y = Math.cos(theta);
+	const chart = gridChart(tiles.max_level, y);
+	const point = chartPoint(chart, ...[
+		-Math.cos(phi) * Math.sin(theta),
+		y,
+		Math.sin(phi) * Math.sin(theta)
+	]);
+	const deepest = deepestLevel(tiles.max_level, tiles.patches, chart, point.x, point.y);
 	if (deepest === tiles.max_level) return deepest;
 	const floatStep = 2 ** (Math.floor(Math.log2(radius)) - 23);
 	const cells = 2 * Math.PI * radius / (CELL_FLOAT_STEPS * floatStep);
@@ -25659,7 +27959,8 @@ function updateTiledWindow(bo, mesh, tiles, altitude, centerTheta, centerPhi, in
 		root: tileRoot(tiles),
 		version: tiles.version,
 		maxLevel: tiles.max_level,
-		patches: (tiles.patches ?? []).map(({ max_level, x, y, version }) => ({
+		patches: (tiles.patches ?? []).map(({ cap, max_level, x, y, version }) => ({
+			cap,
 			max_level,
 			x,
 			y,
@@ -26230,6 +28531,7 @@ var PromotionRegistry = class {
 	autoPromoted = /* @__PURE__ */ new Set();
 	pinned = /* @__PURE__ */ new Set();
 	pinPromoted = /* @__PURE__ */ new Set();
+	focusPromoted = /* @__PURE__ */ new Set();
 	groupTargets = null;
 	groupMode = "none";
 	smallBodyZone = null;
@@ -26314,10 +28616,15 @@ var PromotionRegistry = class {
 		if (!this.buildBodyInstance(body)) return;
 		this.finalizeBuilds();
 	}
+	releaseFocusPromoted(focusedId) {
+		if (this.focusPromoted.size === 0) return;
+		const ids = [...this.focusPromoted].filter((id) => id !== focusedId);
+		this.tearDownBodies(ids, this.focusPromoted);
+	}
 	buildBodyInstance(body, halfPromoteIds, auto = false) {
 		const { bodyObjects, ctx, clock, scene, clickables, meshToBody, renderer } = this.deps;
 		if (bodyObjects.has(body.data.id)) return false;
-		if (!body.orbitElements && !body.data.pageOnly && body.data.orbitalSource !== OrbitalSource.SPICE_PROBE) {
+		if (!body.orbitElements && !body.data.pageOnly && !isExtrasolar(body) && body.data.orbitalSource !== OrbitalSource.SPICE_PROBE) {
 			body.orbitElements = body.data;
 			body.orbitCenterId = body.data.parentId;
 		}
@@ -26331,7 +28638,8 @@ var PromotionRegistry = class {
 			if (zone) ctx.bodies.dirtyAsteroidZones.add(zone);
 		}
 		const id = body.data.id;
-		if (this.defaults.has(id)) {} else if (auto) this.autoPromoted.add(id);
+		if (this.defaults.has(id)) {} else if (isExtrasolar(body)) this.focusPromoted.add(id);
+		else if (auto) this.autoPromoted.add(id);
 		else {
 			this.userPromoted.add(id);
 			this.emitUserPromotedCount();
@@ -26524,6 +28832,7 @@ var PromotionRegistry = class {
 var FocusController = class {
 	promotion;
 	readerFocusFilter = null;
+	focusSets = 0;
 	focusedBody;
 	_tmpV3 = new Vector3();
 	pendingInitialView = null;
@@ -26551,6 +28860,9 @@ var FocusController = class {
 	get current() {
 		return this.focusedBody;
 	}
+	get focusChanges() {
+		return this.focusSets;
+	}
 	place(body) {
 		return this.deps.ctx.place(body, this.deps.clock.jd);
 	}
@@ -26643,6 +28955,7 @@ var FocusController = class {
 			];
 		}
 		this.focusedBody = void 0;
+		this.promotion.releaseFocusPromoted(void 0);
 		prepareFocusTarget(focus, [...position], camera, camWorld, camPos, sceneSettings().resolvedReducedMotion);
 		const spherical = cartesianToSpherical(camPos ?? camWorld, position, void 0);
 		callbacks.onCameraPosition?.(spherical.latitude, spherical.longitude, spherical.distance);
@@ -26661,6 +28974,8 @@ var FocusController = class {
 	}
 	setFocusTarget(body, camPos) {
 		const { ctx, bodyObjects, controls, callbacks, focus, camera, systemData, loadTexture } = this.deps;
+		this.focusSets++;
+		const drawsItself = !isSurfaceFeature(body) && !isExtrasolar(body);
 		if (!isSurfaceFeature(body)) this.promotion.ensureBodyObjects(body);
 		const prev = this.focusedBody;
 		const prevNomBodyId = nomenclatureBodyId(prev, bodyObjects);
@@ -26678,12 +28993,13 @@ var FocusController = class {
 		}
 		if (body.data.id !== prev?.data.id) this.pendingInitialView = null;
 		this.focusedBody = body;
+		this.promotion.releaseFocusPromoted(body.data.id);
 		if (!isSurfaceFeature(body)) ctx.bodies.focusFeature = null;
 		controls.minDistance = minCameraDistance(body, modelMinRadiusKm(bodyObjects.get(body.data.id)));
 		const featureHost = isSurfaceFeature(body) ? ctx.getBody(body.featureAnchor.hostId) : void 0;
 		ctx.visibility.setFocused(featureHost ?? body);
 		callbacks.onFocusChange(body);
-		if (!isSurfaceFeature(body)) loadTexture(body);
+		if (drawsItself) loadTexture(body);
 		if (newNomBodyId && newNomBodyId !== body.data.id) {
 			const landingBody = ctx.getBody(newNomBodyId);
 			if (landingBody) loadTexture(landingBody);
@@ -26755,6 +29071,30 @@ var FocusController = class {
 		callbacks.onCameraPosition?.(settled.latitude, settled.longitude, settled.distance);
 		this.pendingInitialView = null;
 	}
+	snapToBodyFrom(id, fromId, distance) {
+		const { ctx, camera, controls, callbacks } = this.deps;
+		const body = ctx.getBody(id);
+		const from = ctx.getBody(fromId);
+		const pos = body && this.place(body);
+		const at = from && this.place(from);
+		if (!body || !pos || !at) return;
+		this.settleOnBodyInstant(body, pos);
+		const d = f64dist(at, pos);
+		const offset = [
+			(at[0] - pos[0]) / d * distance,
+			(at[1] - pos[1]) / d * distance,
+			(at[2] - pos[2]) / d * distance
+		];
+		camera.position.set(offset[0], offset[1], offset[2]);
+		controls.update();
+		const settled = cartesianToSpherical(offset, [
+			0,
+			0,
+			0
+		]);
+		callbacks.onCameraPosition?.(settled.latitude, settled.longitude, settled.distance);
+		this.pendingInitialView = null;
+	}
 	settleOnBodyInstant(body, pos) {
 		const { focus, pointClouds } = this.deps;
 		this.setFocusTarget(body);
@@ -26775,7 +29115,7 @@ var FocusController = class {
 		const body = this.focusedBody;
 		if (!body) return;
 		const { camera, controls, callbacks } = this.deps;
-		const bodyFixed = !isModelBearing(body);
+		const bodyFixed = !isModelBearing(body) && !isExtrasolar(body);
 		const quat = bodyFixed ? this.focusedBodyQuat(body) ?? [
 			0,
 			0,
@@ -27174,6 +29514,7 @@ var TIGHT_FAR_RELEASE = 2.3;
 var SUN_PROXY_FAR_FRACTION = .9;
 var _sunLiftDir = new Vector3();
 var TRAIL_DRIFT_PX = .25;
+var SKY_GONE_SHARE = .9999;
 var MODEL_SHADOW_DIST = 10;
 var MODEL_SHADOW_EXTENT = 4;
 var MODEL_SHADOW_NEAR = 4;
@@ -27204,6 +29545,7 @@ var SceneRenderer = class SceneRenderer {
 	bodyObjects = /* @__PURE__ */ new Map();
 	circleTexture = makeCircleTexture();
 	pointClouds;
+	starfield;
 	systemData;
 	positionDiagnostics = new PositionDiagnostics();
 	placer;
@@ -27224,6 +29566,8 @@ var SceneRenderer = class SceneRenderer {
 	limitsArmed = false;
 	bodySelectEnabled = true;
 	featureSelectEnabled = true;
+	starSelectEnabled = false;
+	pickSerial = 0;
 	modelScene;
 	modelCamera;
 	modelLight;
@@ -27325,6 +29669,8 @@ var SceneRenderer = class SceneRenderer {
 	fpsSamples = [];
 	fpsSampleHead = 0;
 	stashedSky = null;
+	systemOn = true;
+	systemFade = new SwitchFade();
 	namesShown = true;
 	halosShown = true;
 	textureLoader = new TextureLoader();
@@ -27413,11 +29759,12 @@ var SceneRenderer = class SceneRenderer {
 		this.pointClouds = new PointCloudSystem(ctx, this.scene, this.bodyObjects, this.circleTexture, this.focus, SceneRenderer.MAP_LAYER, () => this.rebuildTrailBasis());
 		this.pointClouds.seedBasis(focusPos);
 		this.pointClouds.setPointBudget(this.tier.pointBudget);
+		this.starfield = new StarfieldSystem(ctx, this.scene, starBudget(), this.invalidate, this.pointClouds.pickRegistry);
 		this.controls = new OrbitControls(this.camera, canvas);
 		this.controls.enableDamping = true;
 		this.orbitDampingFactor = orbitDamping(sceneSettings().resolvedReducedMotion);
 		this.controls.minDistance = focusBody ? minCameraDistance(focusBody) : kmToScene(.01);
-		this.controls.maxDistance = 31620.5 * 10;
+		Object.defineProperty(this.controls, "maxDistance", { get: () => this.maxCameraDistance() });
 		this.controls.target.set(0, 0, 0);
 		this.controls.update();
 		this.controls.addEventListener("end", this.onControlsEnd);
@@ -27474,7 +29821,7 @@ var SceneRenderer = class SceneRenderer {
 		this.systemData.syncToFocus();
 		this.focusController.readerFocusFilter = this.readerMayFocus;
 		this.gpuPick = new GpuPickPass(this.renderer, this.camera);
-		this.pointerInteraction = new PointerInteraction(canvas, this.camera, ctx, clock, this.focus, this.clickables, this.meshToBody, (body) => this.focusController.handleFocus(body), (ndcX, ndcY) => this.pickFocusedModel(ndcX, ndcY), this.gpuPick, () => [...this.pointClouds.asteroids().values(), ...this.pointClouds.spacecraft().values()], this.pointClouds.pickRegistry);
+		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.starfield.pickDraws() : [], (pickId) => this.pickStar(pickId));
 		this.pointerInteraction.attach();
 		this.tick();
 	}
@@ -27733,6 +30080,7 @@ var SceneRenderer = class SceneRenderer {
 		this.lastRenderedCamPos.copy(this.camera.position);
 		this.lastRenderedCamQuat.copy(this.camera.quaternion);
 		this.applyJdUpdate(true);
+		if (!this.dateHeld() && !this.seekAwaitsData) this.clock.placed(this.seenJumps);
 		this.refreshTravelFocus();
 		this.callbacks.onFrame?.(this.sceneJd, renderedDtMs);
 		const controlsSettled = this.holdingCamera ? this.applyHeldCamera() : stepFocusAnimation(this.focus, this.camera, this.controls, () => this.repositionAll(), () => this.pointClouds.rebuildBasis());
@@ -27757,7 +30105,9 @@ var SceneRenderer = class SceneRenderer {
 		if (this.systemData.hasPendingUnloads() && performance.now() - this.focus.focusStartTime >= this.focus.focusDurationMs) this.systemData.drainPendingUnloads();
 		const { distance } = this.getCameraState();
 		this.updateTravelCraftSystem();
+		this.updateSystemShare(renderedDtMs);
 		this.ctx.visibility.updateCamera(distance, this.sceneJd);
+		this.ctx.visibility.stepZones(renderedDtMs);
 		this.updateTightFar(distance);
 		this.systemData.syncToFocus();
 		this.refreshTravelPath();
@@ -27769,7 +30119,9 @@ var SceneRenderer = class SceneRenderer {
 			viewportPx: this.viewportH,
 			ctx: this.ctx
 		});
-		this.cullFrameCounter = updateBodyVisibility(this.bodyObjects, this.camera, this.ctx, this.focus.focusTruePos, this.focusController.current?.data.id, this.hideCappedMoonLabels, this.hoveredBodyIds, this.pointClouds.asteroids(), this.pointClouds.spacecraft(), this.pointClouds.moons(), this.cullFrameCounter, this.renderer, this._tmpV3, !controlsSettled, this.tightFar);
+		this.ctx.visibility.starShare = this.starfield.share();
+		this.cullFrameCounter = updateBodyVisibility(this.bodyObjects, this.camera, this.ctx, this.focus.focusTruePos, this.focusController.current?.data.id, this.hideCappedMoonLabels, this.hoveredBodyIds, this.cullFrameCounter, this.renderer, this._tmpV3, !controlsSettled, this.tightFar);
+		this.pointClouds.updateVisibility(renderedDtMs);
 		this.pointClouds.applyPointBudget();
 		refreshDeferredTrails(this.bodyObjects, this.focus, this.lastUpdatedJd, this.trailView());
 		updateRingShaders(this.bodyObjects, this.focus.focusTruePos, sceneSettings().realisticLighting, sceneSettings().overexposeRings, this.camera.position, this.pxPerRad());
@@ -27779,7 +30131,6 @@ var SceneRenderer = class SceneRenderer {
 		occluders.length = 0;
 		const atmoState = updateAtmosphereShaders(this.bodyObjects, this.camera.position, sceneSettings().showAtmospheres, sceneSettings().realisticLighting, this.sunIntensityScale, currentAtmosphereConfig(), this.sceneJd);
 		recordAtmospherePerf(renderedDtMs, atmoState.shellProminent);
-		this.scene.backgroundIntensity = atmoState.skyboxIntensity;
 		this.applyLayerChrome();
 		const sunBo = this.bodyObjects.get(SUN_ID);
 		if (sunBo) applyStarTint(sunBo.corona, sunBo.starPoint, atmoState.sunTint);
@@ -27801,6 +30152,11 @@ var SceneRenderer = class SceneRenderer {
 		this.pointClouds.drainOnePendingSceneAdd();
 		this.updateDepthFar();
 		this.updateSunProxy(atmoState.sunRefraction);
+		this.camera.updateMatrixWorld();
+		const focusedStar = this.focusController.current;
+		this.starfield.setFocusStar(focusedStar && isExtrasolar(focusedStar) ? focusedStar.extrasolar ?? null : null);
+		this.starfield.update(this.camera, this.focus.focusTruePos, this.renderer.getPixelRatio(), atmoState.skyboxIntensity, nowMs);
+		this.updateSky(atmoState.skyboxIntensity);
 		if (atmoState.insideShell) this.atmoDepthPass.run(this.renderer, this.scene, this.camera, this.bodyObjects, SceneRenderer.ATMO_DEPTH_LAYER);
 		this.syncSceneSamples(atmoState.insideShell);
 		this.composer.readBuffer.resolveDepthBuffer = this.overlayActive;
@@ -27826,6 +30182,8 @@ var SceneRenderer = class SceneRenderer {
 		if (nowMs - this.focus.focusStartTime < this.focus.focusDurationMs) return true;
 		if (this.jumpJd !== null || this.seekAwaitsData) return true;
 		if (this.focusLoads > 0 || this.systemData.isLoading()) return true;
+		if (this.systemFade.fading || this.ctx.visibility.fading) return true;
+		if (this.pointClouds.fading) return true;
 		for (const bo of this.bodyObjects.values()) if (bo.group.visible && bodyLoading(bo)) return true;
 		return false;
 	}
@@ -27836,6 +30194,26 @@ var SceneRenderer = class SceneRenderer {
 		target.samples = samples;
 		target.dispose();
 	}
+	maxCameraDistance() {
+		switch (this.starfield.availability()) {
+			case "yes": return CAMERA_MAX_DISTANCE;
+			case "no": return SOLAR_MAX_DISTANCE;
+			case "unknown": return Math.max(SOLAR_MAX_DISTANCE, this.camera.position.distanceTo(this.controls.target));
+		}
+	}
+	updateSystemShare(dtMs) {
+		const [fx, fy, fz] = this.focus.focusTruePos;
+		const cam = this.camera.position;
+		const fromBarycentre = Math.hypot(fx + cam.x, fy + cam.y, fz + cam.z);
+		this.systemOn = systemShown(fromBarycentre, this.viewportH, this.camera.fov, this.systemOn);
+		this.systemFade.step(this.systemOn, dtMs);
+		const share = this.systemFade.share;
+		const visibility = this.ctx.visibility;
+		const wasHidden = visibility.systemShare === 0;
+		visibility.systemShare = share;
+		this.pointClouds.setFade(share);
+		if (wasHidden && share > 0) this.ctx.refreshTick(jdToDate(this.clock.jd));
+	}
 	updateTightFar(distance) {
 		if (isReversedDepth()) return;
 		const focused = this.focusController.current;
@@ -27855,10 +30233,12 @@ var SceneRenderer = class SceneRenderer {
 	}
 	updateDepthFar() {
 		if (isReversedDepth()) return;
-		let far = CAMERA_FAR_DEFAULT;
+		const [fx, fy, fz] = this.focus.focusTruePos;
+		const cam = this.camera.position;
+		const span = Math.max(cam.length(), Math.hypot(fx + cam.x, fy + cam.y, fz + cam.z));
+		let far = Math.max(CAMERA_FAR_DEFAULT, span * FAR_MARGIN);
 		const sysId = this.ctx.visibility.activeSystemId;
 		if (sysId) {
-			const [fx, fy, fz] = this.focus.focusTruePos;
 			let maxDistSq = this.camera.position.lengthSq();
 			const consider = (pos) => {
 				const dx = pos[0] - fx;
@@ -27879,7 +30259,7 @@ var SceneRenderer = class SceneRenderer {
 				const p = bo.body.position;
 				if (p && this.ctx.visibility.hasFullRendering(bo.body)) consider(p);
 			}
-			far = Math.min(CAMERA_FAR_DEFAULT, Math.max(FAR_MIN, Math.sqrt(maxDistSq) * FAR_MARGIN));
+			far = Math.min(far, Math.max(FAR_MIN, Math.sqrt(maxDistSq) * FAR_MARGIN));
 		}
 		if (Math.abs(far - this.camera.far) > this.camera.far * FAR_UPDATE_EPS) {
 			this.camera.far = far;
@@ -28137,7 +30517,30 @@ var SceneRenderer = class SceneRenderer {
 	setFeatureSelectEnabled(enabled) {
 		this.featureSelectEnabled = enabled;
 	}
+	setStarSelectEnabled(enabled) {
+		this.starSelectEnabled = enabled;
+	}
 	readerMayFocus = (body) => this.bodySelectEnabled && (this.focusableBodies?.has(body.data.id) ?? true);
+	pickBody = (body) => {
+		this.pickSerial++;
+		this.focusController.handleFocus(body);
+	};
+	pickStar(pickId) {
+		const star = this.starfield.pickedStar(pickId);
+		if (!star) return false;
+		const serial = ++this.pickSerial;
+		const focusChanges = this.focusController.focusChanges;
+		const current = () => serial === this.pickSerial && focusChanges === this.focusController.focusChanges;
+		(async () => {
+			const objectId = extrasolarObjectId(await this.starfield.starId(star));
+			if (!current()) return;
+			await this.ctx.ensureBody(objectId, jdToDate(this.clock.jd));
+			const body = this.ctx.getBody(objectId);
+			if (!body) throw new Error(`no record for ${objectId}`);
+			if (current()) this.pickBody(body);
+		})().catch((err) => console.warn("[starfield] the picked star did not load:", err));
+		return true;
+	}
 	setCooperativeTouch(cooperative) {
 		this.controls.touches.ONE = cooperative ? NO_TOUCH_GESTURE : TOUCH.ROTATE;
 		this.canvas.style.touchAction = cooperative ? "pan-x pan-y" : "none";
@@ -28226,7 +30629,7 @@ var SceneRenderer = class SceneRenderer {
 	}
 	shouldRender(nowMs) {
 		if (this.holdingCamera) return true;
-		if (nowMs - this.focus.focusStartTime < this.focus.focusDurationMs || this.focusKey() !== this.lastRenderedFocusKey || this.ctx.bodies.minorStreaming || this.pointClouds.hasPendingSceneAdds() || this.systemData.hasPendingUnloads()) return true;
+		if (nowMs - this.focus.focusStartTime < this.focus.focusDurationMs || this.focusKey() !== this.lastRenderedFocusKey || this.ctx.bodies.minorStreaming || this.pointClouds.hasPendingSceneAdds() || this.systemData.hasPendingUnloads() || this.systemFade.fading || this.ctx.visibility.fading || this.pointClouds.fading || this.starfield.busy()) return true;
 		if (this.covered) return false;
 		if (this.frameIndex - this.lastRenderedFrame >= SceneRenderer.IDLE_HEARTBEAT_FRAMES) return true;
 		if (this.cameraMovedFrom(this.lastRenderedCamPos, this.lastRenderedCamQuat) || this.frameIndex < this.wakeUntilFrame || this.haloDebug.active) return true;
@@ -28548,6 +30951,10 @@ var SceneRenderer = class SceneRenderer {
 		this.disarmLimits();
 		this.focusController.snapToBody(id, latitude, longitude, zoom);
 	}
+	snapToBodyFrom(id, fromId, distance) {
+		this.disarmLimits();
+		this.focusController.snapToBodyFrom(id, fromId, distance);
+	}
 	setFocusTarget(body, camPos) {
 		this.disarmLimits();
 		this.applyJdUpdate();
@@ -28677,16 +31084,21 @@ var SceneRenderer = class SceneRenderer {
 	setSkyDebugMarkersVisible(visible) {
 		this.skyDebugMarkers.setVisible(visible);
 	}
-	applyLayerChrome() {
-		if (this.ctx.layers.isVisible("stars")) {
+	updateSky(skyboxIntensity) {
+		const share = this.starfield.share();
+		if (this.ctx.layers.isVisible("stars") && share < SKY_GONE_SHARE) {
 			if (this.stashedSky) {
 				this.scene.background = this.stashedSky;
 				this.stashedSky = null;
 			}
 		} else if (this.scene.background) {
+			if (this.stashedSky !== this.scene.background) disposeTexture(this.stashedSky);
 			this.stashedSky = this.scene.background;
 			this.scene.background = null;
 		}
+		this.scene.backgroundIntensity = skyboxIntensity * (1 - share);
+	}
+	applyLayerChrome() {
 		const names = this.ctx.layers.isVisible("labels");
 		if (names !== this.namesShown) {
 			this.namesShown = names;
@@ -28753,6 +31165,7 @@ var SceneRenderer = class SceneRenderer {
 			this.resize(this.canvas.clientWidth, this.canvas.clientHeight);
 		}
 		this.pointClouds.setPointBudget(this.tier.pointBudget);
+		this.starfield.setBudget(starBudget());
 	}
 	resize(width, height) {
 		this.invalidate();
@@ -28790,9 +31203,11 @@ var SceneRenderer = class SceneRenderer {
 			disposeReliefTiles(bo);
 		}
 		this.pointClouds.dispose();
+		this.starfield.dispose();
 		this.disposeScene(this.scene);
 		this.disposeScene(this.modelScene);
 		disposeTexture(this.scene.background);
+		disposeTexture(this.stashedSky);
 		disposeTexture(this.scene.environment);
 		disposeTexture(this.modelScene.environment);
 		this.circleTexture.dispose();
@@ -31136,7 +33551,8 @@ var TYPES = {
 	[ObjectType.SPACECRAFT]: "spacecraft",
 	[ObjectType.DEBRIS]: "debris",
 	[ObjectType.UNDOCUMENTED]: "unknown",
-	[ObjectType.SURFACE_FEATURE]: "surface-feature"
+	[ObjectType.SURFACE_FEATURE]: "surface-feature",
+	[ObjectType.EXTRASOLAR]: "star"
 };
 var ORBIT_CLASSES = {
 	[ObjectType.ASTEROID_INNER]: "inner",
@@ -31265,9 +33681,11 @@ var SpaceMap = class {
 	canvas = null;
 	labelLayer = null;
 	stopWatching = null;
+	stopExtrasolarStale = null;
 	controls = null;
 	lostPanelTimer;
 	cooperative = null;
+	starSelectEnabled = false;
 	limits = {};
 	initialFocusPending = true;
 	pendingFocusId = null;
@@ -31409,6 +33827,7 @@ var SpaceMap = class {
 		container.classList.add("sm-map");
 		mapsIn.set(container, (mapsIn.get(container) ?? 0) + 1);
 		this.controls = new ControlHost(this, container);
+		this.stopExtrasolarStale = onExtrasolarStale(() => this.ctx.onDataStale?.());
 		const canvas = document.createElement("canvas");
 		canvas.className = "sm-map__canvas";
 		canvas.tabIndex = 0;
@@ -31472,6 +33891,8 @@ var SpaceMap = class {
 		this.controls = null;
 		this.stopWatching?.();
 		this.stopWatching = null;
+		this.stopExtrasolarStale?.();
+		this.stopExtrasolarStale = null;
 		clearTimeout(this.lostPanelTimer);
 		canvas.removeEventListener("keydown", this.onKeyDown);
 		canvas.removeEventListener("touchmove", this.onTouchMove);
@@ -31791,20 +34212,38 @@ var SpaceMap = class {
 	panTo(target) {
 		return this.toFeature(this.targetBody(target), target.feature, "pan");
 	}
-	jumpTo(target) {
+	async jumpTo(target) {
 		const body = this.targetBody(target);
+		if (this.placedNow(body) && target.facing === void 0 || this.placedNow(target.facing)) this.navigation++;
+		else {
+			const loading = this.goTo(body, {
+				clock: "keep",
+				camera: "none"
+			});
+			const token = this.navigation;
+			const arrival = await loading;
+			if (arrival.outcome === "failed") throw arrival.error;
+			if (arrival.outcome !== "placed" || token !== this.navigation) return;
+		}
+		this.snap(target, body);
+		return this.settled(0);
+	}
+	placedNow(id) {
+		const body = this.ctx.getBody(id);
+		return !!body && !!this.renderer?.placeOf(body);
+	}
+	snap(target, body) {
 		if (target.facing !== void 0) {
 			this.snapToBodyFacing(body, target.facing, target.elevationDeg ?? 0, this.framing(target, body));
-			return this;
+			return;
 		}
 		if (target.feature) {
 			const { featureId, lat, lon, diameterM } = target.feature;
 			this.focusOnFeature(body, featureId, lat, lon, diameterM, null, "snap");
-			return this;
+			return;
 		}
 		const camera = this.getCamera();
 		this.snapToBody(body, target.lat ?? camera?.lat ?? 45, target.lon ?? camera?.lon ?? 0, this.framing(target, body));
-		return this;
 	}
 	getCamera() {
 		const renderer = this.renderer;
@@ -31862,8 +34301,13 @@ var SpaceMap = class {
 		renderer.setZoomEnabled(this.scrollZoom.isEnabled());
 		renderer.setBodySelectEnabled(this.bodySelect.isEnabled());
 		renderer.setFeatureSelectEnabled(this.featureSelect.isEnabled());
+		renderer.setStarSelectEnabled(this.starSelectEnabled);
 		renderer.setCooperativeTouch(cooperative);
 	}
+	setStarSelectEnabled(enabled) {
+		this.starSelectEnabled = enabled;
+		this.renderer?.setStarSelectEnabled(enabled);
+	}
 	onWheelCapture = (e) => {
 		if (!this.scrollZoom.isEnabled()) return;
 		if (this.cooperative && !this.cooperative.allowsWheel(e)) e.stopPropagation();
@@ -31904,6 +34348,9 @@ var SpaceMap = class {
 	snapToBody(id, latitude, longitude, zoom) {
 		this.renderer?.snapToBody(id, latitude, longitude, zoom);
 	}
+	snapToBodyFrom(id, fromId, distance) {
+		this.renderer?.snapToBodyFrom(id, fromId, distance);
+	}
 	snapToBodyFacing(id, towardId, elevationDeg, distance) {
 		this.renderer?.snapToBodyFacing(id, towardId, elevationDeg, distance);
 	}
@@ -32251,7 +34698,7 @@ var MarkerDrawing = class {
 		const screen = this.visible ? viewport.project(this.at.lon, this.at.lat) : null;
 		this.element.style.display = screen ? "" : "none";
 		if (!screen) return;
-		const shift = viewport.repeatShifts.find((s) => screen[0] + s >= 0 && screen[0] + s <= viewport.width) ?? 0;
+		const shift = viewport.shiftInFrame(screen[0]);
 		this.element.style.transform = `translate(${screen[0] + shift}px, ${screen[1]}px) translate(${-this.align[0] * 100}%, ${-this.align[1] * 100}%)`;
 	}
 	setPosition(at) {
@@ -32355,14 +34802,15 @@ function stepOfLevel(level, tileSize) {
 	return 2 * Math.PI / (2 * tileSize * 2 ** level);
 }
 function finestLevelAt(pyramid, lon, lat) {
-	const [across, fy] = chartFraction(0, lon, lat);
-	const fx = across - Math.floor(across);
 	let finest = pyramid.max_level;
 	for (const patch of pyramid.patches ?? []) {
 		if (patch.max_level <= finest) continue;
-		const x = Math.floor(fx * chartColumns(0, patch.max_level));
-		const y = Math.floor(fy * chartRows(0, patch.max_level));
-		if (patchOfTile([patch], patch.max_level, x, y)) finest = patch.max_level;
+		const chart = patchChart(patch);
+		const [across, fy] = chartFraction(chart, lon, lat);
+		const fx = chart === 0 ? across - Math.floor(across) : across;
+		const x = Math.floor(fx * chartColumns(chart, patch.max_level));
+		const y = Math.floor(fy * chartRows(chart, patch.max_level));
+		if (patchOfTile([patch], chart, patch.max_level, x, y)) finest = patch.max_level;
 	}
 	return finest;
 }
@@ -32445,12 +34893,13 @@ function fitted(chart, level, tileSize, extent, margin) {
 	}
 }
 function reaches(patch, extent) {
-	const columns = chartColumns(0, patch.max_level);
-	const rows = chartRows(0, patch.max_level);
+	const chart = patchChart(patch);
+	const columns = chartColumns(chart, patch.max_level);
+	const rows = chartRows(chart, patch.max_level);
 	const south = (patch.y[1] + 1) / rows;
 	if (patch.y[0] / rows > extent.maxY || south < extent.minY) return false;
 	let west = patch.x[0] / columns;
-	west -= Math.round(west - (extent.minX + extent.maxX) / 2);
+	if (chart === 0) west -= Math.round(west - (extent.minX + extent.maxX) / 2);
 	const east = west + (patch.x[1] + 1 - patch.x[0]) / columns;
 	return west <= extent.maxX && east >= extent.minX;
 }
@@ -32464,18 +34913,32 @@ function planWindows(pyramid, frame, firstLevel, moves = true) {
 		if (place) places.push(place);
 	}
 	const onMap = extentOn(0, frame, places, centre);
+	const cap = centre[1] >= 0 ? 1 : 2;
+	const onCap = extentOn(cap, frame, places, centre);
 	const wanted = levelForStep(frame.step, pyramid.tile_size);
 	const specs = [];
 	let finest = pyramid.max_level;
-	for (const patch of pyramid.patches ?? []) if (patch.max_level > finest && reaches(patch, onMap)) finest = patch.max_level;
+	let finestOn = {
+		chart: 0,
+		extent: onMap
+	};
+	for (const patch of pyramid.patches ?? []) {
+		const chart = patchChart(patch);
+		const extent = chart === 0 ? onMap : chart === cap ? onCap : null;
+		if (extent && patch.max_level > finest && reaches(patch, extent)) {
+			finest = patch.max_level;
+			finestOn = {
+				chart,
+				extent
+			};
+		}
+	}
 	for (let level = Math.min(wanted, finest); level > pyramid.max_level; level--) {
-		const spec = fitted(0, level, pyramid.tile_size, onMap, margin);
+		const spec = fitted(finestOn.chart, level, pyramid.tile_size, finestOn.extent, margin);
 		if (!spec) continue;
 		specs.push(spec);
 		break;
 	}
-	const cap = centre[1] >= 0 ? 1 : 2;
-	const onCap = extentOn(cap, frame, places, centre);
 	for (let level = Math.min(wanted, pyramid.max_level); level >= firstLevel; level--) {
 		const map = fitted(0, level, pyramid.tile_size, onMap, margin);
 		const polar = onCap && level >= 1 ? fitted(cap, level, pyramid.tile_size, onCap, margin) : void 0;
@@ -32497,7 +34960,7 @@ function windowTiles(spec, pyramid) {
 	for (let ty = Math.max(Math.floor(spec.y0 / size), 0); ty <= lastY; ty++) for (let tx = Math.floor(spec.x0 / size); tx <= lastX; tx++) {
 		if (spec.chart !== 0 && (tx < 0 || tx >= columns)) continue;
 		const x = (tx % columns + columns) % columns;
-		const patch = spec.level > pyramid.max_level ? patchOfTile(pyramid.patches, spec.level, x, ty) : void 0;
+		const patch = spec.level > pyramid.max_level ? patchOfTile(pyramid.patches, spec.chart, spec.level, x, ty) : void 0;
 		if (spec.level > pyramid.max_level && !patch) continue;
 		tiles.push({
 			cap: CHART_FOLDER[spec.chart],
@@ -33167,7 +35630,8 @@ var LayerTiles = class {
 			win.ctx = canvas.getContext("2d") ?? void 0;
 		} else win.data = new Uint8ClampedArray(spec.width * spec.height * 4);
 		for (const tile of windowTiles(spec, this.block)) {
-			const version = tile.patch?.version ?? (tile.cap === "" ? mapTileVersion(this.block, tile.level, tile.x, tile.y) : this.block.version);
+			const chart = CHART_FOLDER.indexOf(tile.cap);
+			const version = tile.patch?.version ?? tileVersion(this.block, chart, tile.level, tile.x, tile.y);
 			const url = tileUrl({
 				id: this.block.id,
 				version
@@ -33239,7 +35703,10 @@ var Viewport = class {
 	}
 	unproject(px, py) {
 		const [x, y] = this.fromScreen(px, py);
-		return this.projection.inverse(x, y);
+		if (!this.repeatsHorizontally) return this.projection.inverse(x, y);
+		const { minX, maxX } = this.projection.extent;
+		const worldW = maxX - minX;
+		return this.projection.inverse(((x - minX) % worldW + worldW) % worldW + minX, y);
 	}
 	get worldWidthPx() {
 		const { minX, maxX } = this.projection.extent;
@@ -33258,6 +35725,9 @@ var Viewport = class {
 			w
 		].filter((shift) => left + shift < this.width && left + shift + w > 0);
 	}
+	shiftInFrame(x) {
+		return this.repeatShifts.find((shift) => x + shift >= 0 && x + shift <= this.width) ?? 0;
+	}
 };
 function repeats(projection, worldWidthPx, width) {
 	return projection.cyclic && projection.rectangular && worldWidthPx >= width - .5;
@@ -33694,7 +36164,9 @@ var FlatMap = class {
 		await this.adopt(bodyId);
 	}
 	project(lon, lat) {
-		return this.viewport().project(lon, lat);
+		const viewport = this.viewport();
+		const screen = viewport.project(lon, lat);
+		return screen ? [screen[0] + viewport.shiftInFrame(screen[0]), screen[1]] : null;
 	}
 	unproject(px, py) {
 		const found = this.viewport().unproject(px, py);
@@ -36600,9 +39072,11 @@ function attributionChips(ctx, labels = ORBIT_ARCHIVE_ORGANISATIONS) {
 	const bodyId = ctx.visibility.focusedBodyId;
 	const model = bodyId ? credits.model.get(bodyId) : void 0;
 	if (model) organisations.add(model.organisation);
+	const stars = [...new Set(credits.stars.filter((c) => c.license).map((c) => c.organisation))];
 	return {
 		orbits,
-		imagery: [...organisations].sort()
+		imagery: [...organisations].sort(),
+		stars
 	};
 }
 
@@ -36638,12 +39112,14 @@ var AttributionControl = class {
 		const root = bar();
 		const orbits = group();
 		const imagery = group();
-		root.append(link(HOME_URL, "spacemap", "sm-attribution__home"), orbits, imagery, link(CREDITS_URL, host().messages.credits_see_all()));
+		const stars = group();
+		root.append(link(HOME_URL, "spacemap", "sm-attribution__home"), orbits, imagery, stars, link(CREDITS_URL, host().messages.credits_see_all()));
 		this.stop = effect_root(() => {
 			user_effect(() => {
 				const chips = attributionChips(map.ctx);
 				fill(orbits, host().messages.attribution_orbits(), chips.orbits);
 				fill(imagery, host().messages.attribution_imagery(), chips.imagery);
+				fill(stars, host().messages.attribution_stars(), chips.stars);
 			});
 		});
 		return root;
@@ -37008,13 +39484,14 @@ async function fetchPanoramas(bodyId) {
 //#endregion
 //#region src/sdk/index.ts
 async function createMap(options) {
-	const { container, dataUrl, imagesUrl, liveUrl, tilesUrl, locale, messages, includeNonCommercial, controls, events, ...rest } = options;
+	const { container, dataUrl, imagesUrl, liveUrl, tilesUrl, extrasolarUrl, locale, messages, includeNonCommercial, controls, events, ...rest } = options;
 	const element = resolveContainer(container);
 	applyHost({
 		dataUrl,
 		imagesUrl,
 		liveUrl,
 		tilesUrl,
+		extrasolarUrl,
 		locale,
 		messages,
 		includeNonCommercial
@@ -37035,13 +39512,14 @@ async function createMap(options) {
 	return map;
 }
 async function createFlatMap(options) {
-	const { container, dataUrl, imagesUrl, liveUrl, tilesUrl, locale, messages, includeNonCommercial, controls, events, ...rest } = options;
+	const { container, dataUrl, imagesUrl, liveUrl, tilesUrl, extrasolarUrl, locale, messages, includeNonCommercial, controls, events, ...rest } = options;
 	const element = resolveContainer(container);
 	applyHost({
 		dataUrl,
 		imagesUrl,
 		liveUrl,
 		tilesUrl,
+		extrasolarUrl,
 		locale,
 		messages,
 		includeNonCommercial
@@ -37056,13 +39534,14 @@ async function createFlatMap(options) {
 	return map;
 }
 async function createPanorama(options) {
-	const { container, dataUrl, imagesUrl, liveUrl, tilesUrl, locale, messages, includeNonCommercial, controls, events, ...rest } = options;
+	const { container, dataUrl, imagesUrl, liveUrl, tilesUrl, extrasolarUrl, locale, messages, includeNonCommercial, controls, events, ...rest } = options;
 	const element = resolveContainer(container);
 	applyHost({
 		dataUrl,
 		imagesUrl,
 		liveUrl,
 		tilesUrl,
+		extrasolarUrl,
 		locale,
 		messages,
 		includeNonCommercial
@@ -37077,13 +39556,14 @@ async function createPanorama(options) {
 	return view;
 }
 async function createSystemMap(options) {
-	const { container, dataUrl, imagesUrl, liveUrl, tilesUrl, locale, messages, includeNonCommercial, events, ...rest } = options;
+	const { container, dataUrl, imagesUrl, liveUrl, tilesUrl, extrasolarUrl, locale, messages, includeNonCommercial, events, ...rest } = options;
 	const element = resolveContainer(container);
 	applyHost({
 		dataUrl,
 		imagesUrl,
 		liveUrl,
 		tilesUrl,
+		extrasolarUrl,
 		locale,
 		messages,
 		includeNonCommercial
@@ -37111,6 +39591,7 @@ function applyHost(options) {
 	if (options.imagesUrl !== void 0) overrides.imagesUrl = options.imagesUrl;
 	if (options.liveUrl !== void 0) overrides.liveUrl = options.liveUrl;
 	if (options.tilesUrl !== void 0) overrides.tilesUrl = options.tilesUrl;
+	if (options.extrasolarUrl !== void 0) overrides.extrasolarUrl = options.extrasolarUrl;
 	if (options.locale !== void 0) overrides.locale = () => options.locale;
 	if (options.messages !== void 0) overrides.messages = options.messages;
 	if (options.includeNonCommercial) overrides.textures = "non-commercial";