spacemap 0.1.15 → 0.1.17

package/index.js

@@ -1,5 +1,6 @@
 /*! 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, Color, CubeTexture, CustomBlending, DataArrayTexture, DataTexture, 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, 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 { RoomEnvironment } from "three/addons/environments/RoomEnvironment.js";
 import { CSS2DObject } from "three/addons/renderers/CSS2DRenderer.js";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
 import { MeshoptDecoder } from "three/addons/libs/meshopt_decoder.module.js";
@@ -8,7 +9,6 @@ import { EffectComposer } from "three/addons/postprocessing/EffectComposer.js";
 import { RenderPass } from "three/addons/postprocessing/RenderPass.js";
 import { UnrealBloomPass } from "three/addons/postprocessing/UnrealBloomPass.js";
 import { OutputPass } from "three/addons/postprocessing/OutputPass.js";
-import { RoomEnvironment } from "three/addons/environments/RoomEnvironment.js";
 import { FullScreenQuad } from "three/addons/postprocessing/Pass.js";
 
 //#region src/lib/host.ts
@@ -110,7 +110,7 @@ var noop = () => {};
 function run_all(arr) {
 	for (var i = 0; i < arr.length; i++) arr[i]();
 }
-function deferred() {
+function deferred$1() {
 	var resolve;
 	var reject;
 	return {
@@ -902,7 +902,7 @@ var Batch = class Batch {
 		this.#discard_callbacks.add(fn);
 	}
 	settled() {
-		return (this.#deferred ??= deferred()).promise;
+		return (this.#deferred ??= deferred$1()).promise;
 	}
 	static ensure() {
 		if (current_batch === null) {
@@ -2986,6 +2986,9 @@ var versions = {};
 function setDataVersions(v) {
 	versions = v ?? {};
 }
+function getDataVersions() {
+	return versions;
+}
 function versionedUrl(path, cls) {
 	return buildVersionedUrl(dataBase(), path, cls);
 }
@@ -5314,13 +5317,392 @@ function equatorialToScene(xEq, yEq, zEq, out) {
 }
 
 //#endregion
-//#region src/lib/math/orbit/sgp4.ts
-var DEG2RAD$9 = Math.PI / 180;
-var COS_EPS$4 = Math.cos(EARTH_OBLIQUITY_DEG * DEG2RAD$9);
-var SIN_EPS$4 = Math.sin(EARTH_OBLIQUITY_DEG * DEG2RAD$9);
+//#region src/lib/time/jd.ts
+var J2000_JD$1 = 2451545;
+var SECONDS_PER_DAY$2 = 86400;
 var JD_UNIX_EPOCH$1 = 2440587.5;
+var MS_PER_DAY = 864e5;
+function unixMsToJD(ms) {
+	return ms / MS_PER_DAY + JD_UNIX_EPOCH$1;
+}
+function dateToJD(date) {
+	return unixMsToJD(date.getTime());
+}
+function jdToDate(jd) {
+	return new Date((jd - JD_UNIX_EPOCH$1) * MS_PER_DAY);
+}
+var TT_MINUS_TAI = 32.184;
+var LEAP_SECONDS = [
+	[2441317.5, 10],
+	[2441499.5, 11],
+	[2441683.5, 12],
+	[2442048.5, 13],
+	[2442413.5, 14],
+	[2442778.5, 15],
+	[2443144.5, 16],
+	[2443509.5, 17],
+	[2443874.5, 18],
+	[2444239.5, 19],
+	[2444786.5, 20],
+	[2445151.5, 21],
+	[2445516.5, 22],
+	[2446247.5, 23],
+	[2447161.5, 24],
+	[2447892.5, 25],
+	[2448257.5, 26],
+	[2448804.5, 27],
+	[2449169.5, 28],
+	[2449534.5, 29],
+	[2450083.5, 30],
+	[2450630.5, 31],
+	[2451179.5, 32],
+	[2453736.5, 33],
+	[2454832.5, 34],
+	[2456109.5, 35],
+	[2457204.5, 36],
+	[2457754.5, 37]
+];
+function taiMinusUtc(jdUtc) {
+	for (let k = LEAP_SECONDS.length - 1; k >= 0; k--) if (jdUtc >= LEAP_SECONDS[k][0]) return LEAP_SECONDS[k][1];
+	return LEAP_SECONDS[0][1] - 1;
+}
+function tdbMinusTt(jd) {
+	const m = 6.239996 + 1.99096871e-7 * (jd - J2000_JD$1) * SECONDS_PER_DAY$2;
+	return .001657 * Math.sin(m + .01671 * Math.sin(m));
+}
+function utcToTdb(jd) {
+	if (!Number.isFinite(jd)) return jd;
+	const tt = jd + (taiMinusUtc(jd) + TT_MINUS_TAI) / SECONDS_PER_DAY$2;
+	return tt + tdbMinusTt(tt) / SECONDS_PER_DAY$2;
+}
+function tdbToUtc(jd) {
+	if (!Number.isFinite(jd)) return jd;
+	const tt = jd - tdbMinusTt(jd) / SECONDS_PER_DAY$2;
+	return tt - (taiMinusUtc(tt - (taiMinusUtc(tt) + TT_MINUS_TAI) / SECONDS_PER_DAY$2) + TT_MINUS_TAI) / SECONDS_PER_DAY$2;
+}
+function jdToEt(jd) {
+	return (utcToTdb(jd) - J2000_JD$1) * SECONDS_PER_DAY$2;
+}
+function etToTdbJd(et) {
+	return J2000_JD$1 + et / SECONDS_PER_DAY$2;
+}
+function tdbJdToEt(jd) {
+	return (jd - J2000_JD$1) * SECONDS_PER_DAY$2;
+}
+
+//#endregion
+//#region src/lib/math/orbit/teme.ts
+var DEG$10 = Math.PI / 180;
+var ARCSEC = DEG$10 / 3600;
+var NUT_UNIT = 1e-4 * ARCSEC;
+var REUSE_DAYS = .01;
+var NUTATION = [
+	[
+		0,
+		0,
+		0,
+		0,
+		1,
+		-171996,
+		-174.2,
+		92025,
+		8.9
+	],
+	[
+		0,
+		0,
+		2,
+		-2,
+		2,
+		-13187,
+		-1.6,
+		5736,
+		-3.1
+	],
+	[
+		0,
+		0,
+		2,
+		0,
+		2,
+		-2274,
+		-.2,
+		977,
+		-.5
+	],
+	[
+		0,
+		0,
+		0,
+		0,
+		2,
+		2062,
+		.2,
+		-895,
+		.5
+	],
+	[
+		0,
+		1,
+		0,
+		0,
+		0,
+		1426,
+		-3.4,
+		54,
+		-.1
+	],
+	[
+		1,
+		0,
+		0,
+		0,
+		0,
+		712,
+		.1,
+		-7,
+		0
+	],
+	[
+		0,
+		1,
+		2,
+		-2,
+		2,
+		-517,
+		1.2,
+		224,
+		-.6
+	],
+	[
+		0,
+		0,
+		2,
+		0,
+		1,
+		-386,
+		-.4,
+		200,
+		0
+	],
+	[
+		1,
+		0,
+		2,
+		0,
+		2,
+		-301,
+		0,
+		129,
+		-.1
+	],
+	[
+		0,
+		-1,
+		2,
+		-2,
+		2,
+		217,
+		-.5,
+		-95,
+		.3
+	],
+	[
+		1,
+		0,
+		0,
+		-2,
+		0,
+		-158,
+		0,
+		-1,
+		0
+	],
+	[
+		0,
+		0,
+		2,
+		-2,
+		1,
+		129,
+		.1,
+		-70,
+		0
+	],
+	[
+		-1,
+		0,
+		2,
+		0,
+		2,
+		123,
+		0,
+		-53,
+		0
+	],
+	[
+		1,
+		0,
+		0,
+		0,
+		1,
+		63,
+		.1,
+		-33,
+		0
+	],
+	[
+		0,
+		0,
+		0,
+		2,
+		0,
+		63,
+		0,
+		-2,
+		0
+	],
+	[
+		-1,
+		0,
+		2,
+		2,
+		2,
+		-59,
+		0,
+		26,
+		0
+	],
+	[
+		-1,
+		0,
+		0,
+		0,
+		1,
+		-58,
+		-.1,
+		32,
+		0
+	],
+	[
+		1,
+		0,
+		2,
+		0,
+		1,
+		-51,
+		0,
+		27,
+		0
+	]
+];
+function mul(a, b) {
+	const out = new Array(9);
+	for (let r = 0; r < 3; r++) for (let c = 0; c < 3; c++) out[3 * r + c] = a[3 * r] * b[c] + a[3 * r + 1] * b[3 + c] + a[3 * r + 2] * b[6 + c];
+	return out;
+}
+function rx(a) {
+	const c = Math.cos(a);
+	const s = Math.sin(a);
+	return [
+		1,
+		0,
+		0,
+		0,
+		c,
+		s,
+		0,
+		-s,
+		c
+	];
+}
+function ry(a) {
+	const c = Math.cos(a);
+	const s = Math.sin(a);
+	return [
+		c,
+		0,
+		-s,
+		0,
+		1,
+		0,
+		s,
+		0,
+		c
+	];
+}
+function rz(a) {
+	const c = Math.cos(a);
+	const s = Math.sin(a);
+	return [
+		c,
+		s,
+		0,
+		-s,
+		c,
+		0,
+		0,
+		0,
+		1
+	];
+}
+function temeToEclipticAt(jd) {
+	const T = (jd - J2000_JD$1) / 36525;
+	const zeta = (2306.2181 * T + .30188 * T * T + .017998 * T ** 3) * ARCSEC;
+	const theta = (2004.3109 * T - .42665 * T * T - .041833 * T ** 3) * ARCSEC;
+	const z = (2306.2181 * T + 1.09468 * T * T + .018203 * T ** 3) * ARCSEC;
+	const l = 134.96298139 + 477198.8673981 * T + .0086972 * T * T;
+	const lp = 357.52772333 + 35999.05034 * T - 1603e-7 * T * T;
+	const F = 93.27191028 + 483202.0175381 * T - .0036825 * T * T;
+	const D = 297.85036306 + 445267.11148 * T - .0019142 * T * T;
+	const om = 125.04452222 - 1934.1362608 * T + .0020708 * T * T;
+	let dpsi = 0;
+	let deps = 0;
+	for (const [kl, klp, kF, kD, kOm, a, b, c, d] of NUTATION) {
+		const arg = (kl * l + klp * lp + kF * F + kD * D + kOm * om) * DEG$10;
+		dpsi += (a + b * T) * Math.sin(arg);
+		deps += (c + d * T) * Math.cos(arg);
+	}
+	dpsi *= NUT_UNIT;
+	deps *= NUT_UNIT;
+	const epsMean = (84381.448 - 46.815 * T - 59e-5 * T * T + .001813 * T ** 3) * ARCSEC;
+	const eqEquinoxes = dpsi * Math.cos(epsMean);
+	const toJ2000 = mul(mul(mul(mul(rz(zeta), ry(-theta)), rz(z)), mul(mul(rx(-epsMean), rz(dpsi)), rx(epsMean + deps))), rz(-eqEquinoxes));
+	return mul(rx(EARTH_OBLIQUITY_DEG * DEG$10), toJ2000);
+}
+var cachedJd = NaN;
+var cached = [
+	1,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	1
+];
+function temeToEclipticMatrix(jd) {
+	if (!(Math.abs(jd - cachedJd) <= REUSE_DAYS)) {
+		cached = temeToEclipticAt(jd);
+		cachedJd = jd;
+	}
+	return cached;
+}
+function temeToEcliptic(x, y, z, jd) {
+	const m = temeToEclipticMatrix(jd);
+	return [
+		m[0] * x + m[1] * y + m[2] * z,
+		m[3] * x + m[4] * y + m[5] * z,
+		m[6] * x + m[7] * y + m[8] * z
+	];
+}
+
+//#endregion
+//#region src/lib/math/orbit/sgp4.ts
+var JD_UNIX_EPOCH = 2440587.5;
 function jdToIso(jd) {
-	return (/* @__PURE__ */ new Date((jd - JD_UNIX_EPOCH$1) * 864e5)).toISOString();
+	return (/* @__PURE__ */ new Date((jd - JD_UNIX_EPOCH) * 864e5)).toISOString();
 }
 function buildSatrec(inputs, name) {
 	const satrec = json2satrec({
@@ -5358,25 +5740,19 @@ function sgp4PositionTEME(satrec, jd) {
 		z
 	];
 }
-function temeKmToThreeJS(x, y, z) {
+function temeKmToThreeJS(x, y, z, jd) {
 	const scale = 10 / AU_KM;
-	const xs = x * scale;
-	let ys = y * scale;
-	let zs = z * scale;
-	const yEcl = ys * COS_EPS$4 + zs * SIN_EPS$4;
-	const zEcl = -ys * SIN_EPS$4 + zs * COS_EPS$4;
-	ys = yEcl;
-	zs = zEcl;
+	const [xe, ye, ze] = temeToEcliptic(x, y, z, jd);
 	return [
-		xs,
-		zs,
-		-ys
+		xe * scale,
+		ze * scale,
+		-ye * scale
 	];
 }
 function sgp4PositionScene(satrec, jd) {
 	const teme = sgp4PositionTEME(satrec, jd);
 	if (!teme) return null;
-	return temeKmToThreeJS(teme[0], teme[1], teme[2]);
+	return temeKmToThreeJS(teme[0], teme[1], teme[2], jd);
 }
 
 //#endregion
@@ -5445,32 +5821,109 @@ function yieldToMain() {
 }
 
 //#endregion
-//#region src/lib/time/jd.ts
-var J2000_JD$2 = 2451545;
-var SECONDS_PER_DAY$2 = 86400;
-var JD_UNIX_EPOCH = 2440587.5;
-var MS_PER_DAY = 864e5;
-function unixMsToJD(ms) {
-	return ms / MS_PER_DAY + JD_UNIX_EPOCH;
+//#region src/lib/math/orbit/position.ts
+var DEG2RAD$8 = Math.PI / 180;
+var COS_EPS$2 = Math.cos(EARTH_OBLIQUITY_DEG * DEG2RAD$8);
+var SIN_EPS$2 = Math.sin(EARTH_OBLIQUITY_DEG * DEG2RAD$8);
+function orbitalToThreeJS(xOrb, yOrb, w, i, om, equatorial = false) {
+	const cosW = Math.cos(w * DEG2RAD$8);
+	const sinW = Math.sin(w * DEG2RAD$8);
+	const cosI = Math.cos(i * DEG2RAD$8);
+	const sinI = Math.sin(i * DEG2RAD$8);
+	const cosOm = Math.cos(om * DEG2RAD$8);
+	const sinOm = Math.sin(om * DEG2RAD$8);
+	const x = (cosOm * cosW - sinOm * sinW * cosI) * xOrb + (-cosOm * sinW - sinOm * cosW * cosI) * yOrb;
+	let y = (sinOm * cosW + cosOm * sinW * cosI) * xOrb + (-sinOm * sinW + cosOm * cosW * cosI) * yOrb;
+	let z = sinW * sinI * xOrb + cosW * sinI * yOrb;
+	if (equatorial) {
+		const yEcl = y * COS_EPS$2 + z * SIN_EPS$2;
+		const zEcl = -y * SIN_EPS$2 + z * COS_EPS$2;
+		y = yEcl;
+		z = zEcl;
+	}
+	return [
+		x * 10,
+		z * 10,
+		-y * 10
+	];
 }
-function dateToJD(date) {
-	return unixMsToJD(date.getTime());
+function elementsJd(el, jd) {
+	return el.equatorial ? jd : utcToTdb(jd);
 }
-function jdToDate(jd) {
-	return new Date((jd - JD_UNIX_EPOCH) * MS_PER_DAY);
+function clockJd(el, t) {
+	return el.equatorial ? t : tdbToUtc(t);
 }
-function jdToEt(jd) {
-	return (jd - J2000_JD$2) * SECONDS_PER_DAY$2;
+function propagateOrbitAngles(el, jd) {
+	return anglesAt(el, elementsJd(el, jd));
 }
-function etToJd(et) {
-	return J2000_JD$2 + et / SECONDS_PER_DAY$2;
+function anglesAt(el, t) {
+	const { omDot, wDot, om, w, epoch } = el;
+	if (!omDot && !wDot) return el;
+	const dt = t - epoch;
+	return {
+		...el,
+		om: omDot ? om + omDot * dt : om,
+		w: wDot ? w + wDot * dt : w
+	};
+}
+function orbitalElementsToPositionJD(el, jd) {
+	const { a, e, i, ma, n, epoch } = el;
+	if (!isFinite(a) || !isFinite(e) || !isFinite(ma) || !isFinite(n)) {
+		console.warn(`NaN in orbital elements: a=${a} e=${e} ma=${ma} n=${n}`);
+		return null;
+	}
+	const t = elementsJd(el, jd);
+	const M = (ma + n * (t - epoch)) * DEG2RAD$8;
+	const { om: omPropagated, w: wPropagated } = anglesAt(el, t);
+	let nu;
+	let r;
+	if (e < 1 || a > 0) {
+		const eClamped = Math.min(e, .9999999);
+		const E = solveKepler(M, eClamped);
+		const sinNu = Math.sqrt(1 - eClamped * eClamped) * Math.sin(E) / (1 - eClamped * Math.cos(E));
+		const cosNu = (Math.cos(E) - eClamped) / (1 - eClamped * Math.cos(E));
+		nu = Math.atan2(sinNu, cosNu);
+		r = a * (1 - eClamped * Math.cos(E));
+	} else {
+		const H = solveKeplerHyperbolic(M, e);
+		if (!isFinite(H)) {
+			console.warn(`solveKeplerHyperbolic overflow: M=${M} e=${e}`);
+			return null;
+		}
+		const denom = e * Math.cosh(H) - 1;
+		if (Math.abs(denom) < 1e-15) {
+			console.warn(`Hyperbolic denom near zero: H=${H} e=${e} denom=${denom}`);
+			return null;
+		}
+		const sinNu = Math.sqrt(e * e - 1) * Math.sinh(H) / denom;
+		const cosNu = (e - Math.cosh(H)) / denom;
+		nu = Math.atan2(sinNu, cosNu);
+		r = a * (1 - e * Math.cosh(H));
+	}
+	const xOrb = r * Math.cos(nu);
+	const yOrb = r * Math.sin(nu);
+	if (!isFinite(xOrb) || !isFinite(yOrb)) {
+		console.warn(`Non-finite orbital position: r=${r} nu=${nu} xOrb=${xOrb} yOrb=${yOrb} a=${a} e=${e}`);
+		return null;
+	}
+	return orbitalToThreeJS(xOrb, yOrb, wPropagated, i, omPropagated, el.equatorial);
+}
+function parabolicToPositionJD(el, jd) {
+	const { q, tp, i, om, w } = el;
+	if (q == null || tp == null || !isFinite(q) || !isFinite(tp)) return null;
+	const result = solveBarker(q, tp, elementsJd(el, jd));
+	if (!result) return null;
+	const xOrb = result.r * Math.cos(result.nu);
+	const yOrb = result.r * Math.sin(result.nu);
+	if (!isFinite(xOrb) || !isFinite(yOrb)) return null;
+	return orbitalToThreeJS(xOrb, yOrb, w, i, om, el.equatorial);
 }
 
 //#endregion
 //#region src/lib/math/orbit/soa.ts
-var DEG2RAD$8 = Math.PI / 180;
-var COS_EPS$3 = Math.cos(EARTH_OBLIQUITY_DEG * DEG2RAD$8);
-var SIN_EPS$3 = Math.sin(EARTH_OBLIQUITY_DEG * DEG2RAD$8);
+var DEG2RAD$7 = Math.PI / 180;
+var COS_EPS$1 = Math.cos(EARTH_OBLIQUITY_DEG * DEG2RAD$7);
+var SIN_EPS$1 = Math.sin(EARTH_OBLIQUITY_DEG * DEG2RAD$7);
 var KM_TO_SCENE = 10 / AU_KM;
 var KIND_SKIP = 0;
 var KIND_KEPLER = 1;
@@ -5529,8 +5982,10 @@ async function packBodiesSliced(bodies, skip, applyFlagFilter = false) {
 		}
 		if (!packRowInto(cols, idx, bodies[idx], skip)) continue;
 		const d = bodies[idx].data;
-		if (d.validityStart < start) start = d.validityStart;
-		if (d.validityEnd > end) end = d.validityEnd;
+		const s = clockJd(d, d.validityStart);
+		const e = clockJd(d, d.validityEnd);
+		if (s < start) start = s;
+		if (e > end) end = e;
 	}
 	cols.validityStart = start === Infinity ? -Infinity : start;
 	cols.validityEnd = end === -Infinity ? Infinity : end;
@@ -5870,6 +6325,11 @@ var TYPE_COLOR_PROBE = "#d5cfe7";
 var SUN_ID = "naif-10";
 var EARTH_ID = "naif-399";
 var SSB_ID = "naif-0";
+function naifId(objectId) {
+	if (!objectId.startsWith("naif-")) return null;
+	const value = Number.parseInt(objectId.slice(5), 10);
+	return Number.isFinite(value) ? value : null;
+}
 function dominantPlanetId(id) {
 	const m = /^naif-([1-9])$/.exec(id);
 	return m ? `naif-${m[1]}99` : null;
@@ -5937,10 +6397,6 @@ function resolveBodyColor(data) {
 	}
 	return DEFAULT_BODY_COLOR;
 }
-var UNKNOWN_SURFACE_COLOR = "#6b6b6b";
-function bodyMeshColor(data) {
-	return data.color ?? UNKNOWN_SURFACE_COLOR;
-}
 
 //#endregion
 //#region src/lib/math/orbit/partition.ts
@@ -6202,6 +6658,8 @@ var MinorBucket = class {
 				keys: new Float64Array(counts[b]).fill(NO_KEY)
 			});
 		}
+		const clockStarts = this.chunks.map((chunk) => tdbToUtc(chunk.validityStart));
+		const clockEnds = this.chunks.map((chunk) => tdbToUtc(chunk.validityEnd));
 		const starts = new Array(k).fill(Infinity);
 		const ends = new Array(k).fill(-Infinity);
 		const writeIdx = new Array(k).fill(0);
@@ -6222,8 +6680,11 @@ var MinorBucket = class {
 			const key = rowKey(cols, i);
 			g.keys[outIdx] = key;
 			if (fillOrbitColumnRow(cols, i, g.cols, outIdx, key, skip)) {
-				if (cols.validityStart < starts[b]) starts[b] = cols.validityStart;
-				if (cols.validityEnd > ends[b]) ends[b] = cols.validityEnd;
+				const tle = g.cols.equatorial[outIdx] === 1;
+				const start = tle ? cols.validityStart : clockStarts[c];
+				const end = tle ? cols.validityEnd : clockEnds[c];
+				if (start < starts[b]) starts[b] = start;
+				if (end > ends[b]) ends[b] = end;
 			}
 			if (g.colors && tmp) {
 				const data = materializeBodyData(cols, i, this.labels, this.parentIdType);
@@ -6618,17 +7079,23 @@ async function fetchWithTimeout(input, init = {}, timeoutMs = BOOT_FETCH_TIMEOUT
 
 //#endregion
 //#region src/lib/fetch/systems-global.ts
-var angles = /* @__PURE__ */ new Map();
+var phases = /* @__PURE__ */ new Map();
 var gmKm3s2 = /* @__PURE__ */ new Map();
 var loadPromise$1 = null;
 function loadSystemsGlobal() {
 	if (loadPromise$1) return loadPromise$1;
 	const p = (async () => {
 		const r = await fetchWithTimeout(`${dataBase()}/v1/systems/global.json`);
-		if (!r.ok) return;
+		if (!r.ok) throw new Error(`systems/global.json: ${r.status}`);
 		const raw = await r.json();
 		if (raw.gm) for (const [k, v] of Object.entries(raw.gm)) gmKm3s2.set(parseInt(k, 10), v);
-		if (raw.nut_prec_angles) for (const [k, v] of Object.entries(raw.nut_prec_angles)) angles.set(parseInt(k, 10), v);
+		if (raw.nut_prec_angles) for (const [k, v] of Object.entries(raw.nut_prec_angles)) {
+			const phaseDegree = raw.nut_prec_phase_degree?.[k] ?? 1;
+			phases.set(parseInt(k, 10), {
+				angles: v,
+				phaseDegree
+			});
+		}
 	})();
 	p.catch(() => {
 		if (loadPromise$1 === p) loadPromise$1 = null;
@@ -6636,11 +7103,14 @@ function loadSystemsGlobal() {
 	loadPromise$1 = p;
 	return p;
 }
-function ownerIdFor(naifId) {
-	return naifId >= 100 ? Math.trunc(naifId / 100) : naifId;
-}
-function getNutPrecAngles(ownerId) {
-	return angles.get(ownerId);
+function nutPrecFor(id, sums) {
+	const naif = naifId(id);
+	if (naif === null || !sums) return void 0;
+	const owned = phases.get(naif >= 100 ? Math.trunc(naif / 100) : naif);
+	return owned && {
+		...sums,
+		...owned
+	};
 }
 function getGmKm3s2(naifId) {
 	return gmKm3s2.get(naifId);
@@ -7433,7 +7903,7 @@ function parseProbesPayload(buffer, startJd, endJd, float64Coeffs) {
 	const probeCount = view.getUint32(24, true);
 	const subchunkDays = view.getFloat32(28, true);
 	const subchunkS = subchunkDays * SECONDS_PER_DAY$2;
-	const chunkStartEt = jdToEt(startJd);
+	const chunkStartEt = tdbJdToEt(startJd);
 	const probes = [];
 	let offset = HEADER_SIZE$2;
 	for (let p = 0; p < probeCount; p++) {
@@ -7558,11 +8028,12 @@ function findSegmentIndex(starts, ends, jd) {
 	return jd < ends[lo] ? lo : -1;
 }
 function chebyshevPositionKm(body, jd) {
-	const idx = findSegmentIndex(body.startJds, body.endJds, jd);
+	const tdb = utcToTdb(jd);
+	const idx = findSegmentIndex(body.startJds, body.endJds, tdb);
 	if (idx < 0) return null;
 	const start = body.startJds[idx];
 	const end = body.endJds[idx];
-	const tau = 2 * (jd - start) / (end - start) - 1;
+	const tau = 2 * (tdb - start) / (end - start) - 1;
 	const N = body.coeffsPerAxis;
 	const coeffs = body.coeffs;
 	const base = idx * 3 * N;
@@ -7599,11 +8070,12 @@ function chebyshevPositionScene(body, jd) {
 	];
 }
 function chebyshevStateKm(body, jd) {
-	const idx = findSegmentIndex(body.startJds, body.endJds, jd);
+	const tdb = utcToTdb(jd);
+	const idx = findSegmentIndex(body.startJds, body.endJds, tdb);
 	if (idx < 0) return null;
 	const start = body.startJds[idx];
 	const end = body.endJds[idx];
-	const tau = 2 * (jd - start) / (end - start) - 1;
+	const tau = 2 * (tdb - start) / (end - start) - 1;
 	const dTauDt = 2 / (end - start);
 	const N = body.coeffsPerAxis;
 	const coeffs = body.coeffs;
@@ -7651,7 +8123,7 @@ function chebyshevStateKm(body, jd) {
 
 //#endregion
 //#region src/lib/math/orbit/state.ts
-var DEG2RAD$7 = Math.PI / 180;
+var DEG2RAD$6 = Math.PI / 180;
 var RAD2DEG$1 = 180 / Math.PI;
 var SEC_PER_DAY = 86400;
 var AU_PER_DAY_TO_KM_PER_SEC = AU_KM / SEC_PER_DAY;
@@ -7920,7 +8392,7 @@ var RAD2DEG = 180 / Math.PI;
 function keplerPureElements(sub, subStartEt, muKm3S2) {
 	if (muKm3S2 <= 0) return null;
 	const nRadS = Math.sqrt(muKm3S2 / (sub.aKm * sub.aKm * sub.aKm));
-	const epoch = etToJd(subStartEt + sub.tAnchorOffsetS);
+	const epoch = etToTdbJd(subStartEt + sub.tAnchorOffsetS);
 	return {
 		a: sub.aKm / AU_KM,
 		e: sub.e,
@@ -7934,7 +8406,7 @@ function keplerPureElements(sub, subStartEt, muKm3S2) {
 	};
 }
 function keplerDriftElements(sub, subStartEt) {
-	const epoch = etToJd(subStartEt + sub.tAnchorOffsetS);
+	const epoch = etToTdbJd(subStartEt + sub.tAnchorOffsetS);
 	return {
 		a: sub.aKm / AU_KM,
 		e: sub.e,
@@ -7962,7 +8434,7 @@ function chebyshevElements(probe, jd, muKm3S2) {
 		state.velocity[0] * KM_DAY_TO_AU_DAY,
 		state.velocity[1] * KM_DAY_TO_AU_DAY,
 		state.velocity[2] * KM_DAY_TO_AU_DAY
-	], muAuDay2, jd);
+	], muAuDay2, utcToTdb(jd));
 }
 function probeOsculatingElements(probe, jd, muKm3S2) {
 	const idx = findSubChunkIndex(probe, jdToEt(jd));
@@ -8351,7 +8823,7 @@ function chebyshevOsculatingElements(body, parentId, jd, origin) {
 		(state.velocity[0] - (from?.velocity[0] ?? 0)) * KM_DAY_TO_AU_DAY,
 		(state.velocity[1] - (from?.velocity[1] ?? 0)) * KM_DAY_TO_AU_DAY,
 		(state.velocity[2] - (from?.velocity[2] ?? 0)) * KM_DAY_TO_AU_DAY
-	], muAuDay2, jd);
+	], muAuDay2, utcToTdb(jd));
 }
 function chebyshevHelioElements(body, jd, sun) {
 	if (!sun || body.parentId !== SSB_NAIF_ID || body.naifId === SUN_NAIF_ID) return null;
@@ -8845,7 +9317,7 @@ function isChebyshev(zoom) {
 	return zoom.shape === "chunked";
 }
 function chunkIndexForJd(zone, jd) {
-	const idx = Math.floor((jd - zone.start_jd) / zone.chunk_days);
+	const idx = Math.floor((utcToTdb(jd) - zone.start_jd) / zone.chunk_days);
 	return Math.max(0, Math.min(zone.chunks - 1, idx));
 }
 function isProbeZone(entry) {
@@ -9184,8 +9656,8 @@ var ChebyshevStore = class extends ChunkWindow {
 		const params = this.zoneParams.get(zone);
 		if (!params) return null;
 		return {
-			start: params.start_jd,
-			end: params.end_jd
+			start: tdbToUtc(params.start_jd),
+			end: tdbToUtc(params.end_jd)
 		};
 	}
 	isAwaited(objectId, jd) {
@@ -9504,6 +9976,28 @@ function rowsFor(chunk, id) {
 	return index.get(id) ?? NO_ROWS;
 }
 
+//#endregion
+//#region src/lib/fetch/version-check.ts
+var CHECK_TIMEOUT_MS = 15e3;
+async function dataVersionChanged() {
+	try {
+		const res = await fetch(`${dataBase()}/v1/metadata.json`, {
+			cache: "no-store",
+			signal: AbortSignal.timeout(CHECK_TIMEOUT_MS)
+		});
+		if (!res.ok) return false;
+		const meta = await res.json();
+		const live = getDataVersions();
+		if (Object.keys(live).length === 0) return false;
+		const next = meta.versions ?? {};
+		const keys = new Set([...Object.keys(live), ...Object.keys(next)]);
+		for (const k of keys) if (live[k] !== next[k]) return true;
+		return false;
+	} catch {
+		return false;
+	}
+}
+
 //#endregion
 //#region src/lib/fetch/gz.ts
 function gunzip(res) {
@@ -9537,12 +10031,12 @@ function memoizedGzJson(url, opts = {}) {
 //#endregion
 //#region src/lib/fetch/bundle-cache.ts
 var MAX_BUNDLES = 24;
-var cache$2 = /* @__PURE__ */ new Map();
+var cache$3 = /* @__PURE__ */ new Map();
 function fetchGzipBundle(url, init) {
-	let p = cache$2.get(url);
+	let p = cache$3.get(url);
 	if (p) {
-		cache$2.delete(url);
-		cache$2.set(url, p);
+		cache$3.delete(url);
+		cache$3.set(url, p);
 	}
 	if (!p) {
 		p = (async () => {
@@ -9553,13 +10047,13 @@ function fetchGzipBundle(url, init) {
 			}
 			return gunzipJson(res);
 		})();
-		cache$2.set(url, p);
+		cache$3.set(url, p);
 		p.catch(() => {
-			if (cache$2.get(url) === p) cache$2.delete(url);
+			if (cache$3.get(url) === p) cache$3.delete(url);
 		});
-		for (const key of cache$2.keys()) {
-			if (cache$2.size <= MAX_BUNDLES) break;
-			cache$2.delete(key);
+		for (const key of cache$3.keys()) {
+			if (cache$3.size <= MAX_BUNDLES) break;
+			cache$3.delete(key);
 		}
 	}
 	return p;
@@ -9653,9 +10147,11 @@ async function earthZoneEndJd() {
 	return zoom && isDateSegmented(zoom) ? unixMsToJD(lastCoveredMs(zoom)) : Infinity;
 }
 async function coverageOf(id) {
-	const windows = (await fetchObjectDetail(id, false)).global?.coverage?.windows ?? [];
-	const openEnd = id.startsWith("norad_satcat-") ? await earthZoneEndJd() : Infinity;
-	return windows.map(([start, end]) => [start ?? -Infinity, end ?? openEnd]).filter(([start, end]) => end > start);
+	const detail = await fetchObjectDetail(id, false);
+	const windows = detail.global?.coverage?.windows ?? [];
+	const tle = detail.global?.orbit?.scale === "planet";
+	const openEnd = tle ? await earthZoneEndJd() : Infinity;
+	return windows.map(([start, end]) => [start ?? -Infinity, end == null ? openEnd : tle ? end : tdbToUtc(end)]).filter(([start, end]) => end > start);
 }
 function nearestCoveredJd(windows, jd) {
 	let best = null;
@@ -9731,7 +10227,7 @@ function bodyDataFromGlobal(id, detail) {
 		validityStart: omm ? orbit.epoch_jd - SGP4_VALIDITY_SLACK_DAYS : -Infinity,
 		validityEnd: omm ? orbit.epoch_jd + SGP4_VALIDITY_SLACK_DAYS : Infinity,
 		orbitalSource: parseOrbitalSource(orbit.source),
-		...coverageStart != null ? { visibleFromDays: coverageStart - J2000_JD$2 } : {},
+		...coverageStart != null ? { visibleFromDays: coverageStart - J2000_JD$1 } : {},
 		...isParabolic ? {
 			q: orbit.q,
 			tp: orbit.tp
@@ -9829,34 +10325,44 @@ async function ensureTargetStreamed(ctx, targetId) {
 
 //#endregion
 //#region src/lib/math/orientation.ts
-var DEG2RAD$6 = Math.PI / 180;
-var J2000_JD$1 = 2451545;
+var DEG2RAD$5 = Math.PI / 180;
 var DAYS_PER_CENTURY = 36525;
-function bodyQuaternion(orientation, currentJd, nutPrec) {
-	const dt = currentJd - J2000_JD$1;
+function iauAngles(orientation, currentJd, nutPrec) {
+	const dt = utcToTdb(currentJd) - J2000_JD$1;
 	const T = dt / DAYS_PER_CENTURY;
 	let raDeg = orientation.pole_ra_0 + orientation.pole_ra_1 * T;
 	let decDeg = orientation.pole_dec_0 + orientation.pole_dec_1 * T;
 	let wDeg = orientation.w0 + orientation.w1 * dt + orientation.w2 * dt * dt;
 	if (nutPrec) {
 		const { ra, dec, pm, angles } = nutPrec;
-		const n = Math.min(angles.length >> 1, Math.max(ra.length, dec.length, pm.length));
+		const k = nutPrec.phaseDegree + 1;
+		const n = Math.min(Math.floor(angles.length / k), Math.max(ra.length, dec.length, pm.length));
 		for (let i = 0; i < n; i++) {
-			const theta = (angles[2 * i] + angles[2 * i + 1] * T) * DEG2RAD$6;
+			let thetaDeg = 0;
+			for (let j = k - 1; j >= 0; j--) thetaDeg = thetaDeg * T + angles[k * i + j];
+			const theta = thetaDeg * DEG2RAD$5;
 			const s = Math.sin(theta);
 			if (i < ra.length) raDeg += ra[i] * s;
 			if (i < dec.length) decDeg += dec[i] * Math.cos(theta);
 			if (i < pm.length) wDeg += pm[i] * s;
 		}
 	}
-	const ra = raDeg * DEG2RAD$6;
-	const dec = decDeg * DEG2RAD$6;
+	return {
+		ra: raDeg,
+		dec: decDeg,
+		w: wDeg
+	};
+}
+function bodyQuaternion(orientation, currentJd, nutPrec) {
+	const { ra: raDeg, dec: decDeg, w: wDeg } = iauAngles(orientation, currentJd, nutPrec);
+	const ra = raDeg * DEG2RAD$5;
+	const dec = decDeg * DEG2RAD$5;
 	const cosDec = Math.cos(dec);
 	const pole = equatorialToScene(cosDec * Math.cos(ra), cosDec * Math.sin(ra), Math.sin(dec), new Vector3()).normalize();
 	const node = equatorialToScene(-Math.sin(ra), Math.cos(ra), 0, new Vector3()).normalize();
 	const third = new Vector3().crossVectors(node, pole).normalize();
 	const tiltQuat = new Quaternion().setFromRotationMatrix(new Matrix4().makeBasis(node, pole, third));
-	return new Quaternion().setFromAxisAngle(pole, wDeg * DEG2RAD$6).multiply(tiltQuat);
+	return new Quaternion().setFromAxisAngle(pole, wDeg * DEG2RAD$5).multiply(tiltQuat);
 }
 function applyOrientation(obj, orientation, currentJd, nutPrec) {
 	obj.quaternion.copy(bodyQuaternion(orientation, currentJd, nutPrec));
@@ -9975,6 +10481,434 @@ function chainShaderHook(material, mod, patch) {
 	material.needsUpdate = true;
 }
 
+//#endregion
+//#region src/lib/scene/lighting.ts
+var AMBIENT_INTENSITY = .01;
+var SUN_LIGHT_INTENSITY = 3.5;
+var ENV_BASE_INTENSITY = .04;
+function sunIrradianceFactor(sunDistScene) {
+	const au = Math.max(sunDistScene / 10, .01);
+	return 1 / (au * au);
+}
+function applySunPointLightMode(light, realistic, scale = 1) {
+	light.decay = realistic ? 2 : 0;
+	light.intensity = (realistic ? SUN_LIGHT_INTENSITY * 10 * 10 : SUN_LIGHT_INTENSITY) * scale;
+}
+function makeEnvMap(renderer) {
+	const pmrem = new PMREMGenerator(renderer);
+	const tex = pmrem.fromScene(new RoomEnvironment()).texture;
+	pmrem.dispose();
+	return tex;
+}
+
+//#endregion
+//#region src/lib/scene/objects/surface/ring-light.ts
+var UNLIT_TINT = [
+	1,
+	.97075,
+	.952
+];
+var FORWARD_TINT_BIAS = [
+	1.02,
+	.99,
+	.97
+];
+var PROFILE_MU = Math.sin(8 * Math.PI / 180);
+function oneMinusExp(x) {
+	return x < .001 ? x * (1 - .5 * x) : 1 - Math.exp(-x);
+}
+function reflectionGain(mu0, mu, tau) {
+	const a = Math.max(mu0, 1e-4);
+	const b = Math.max(mu, 1e-4);
+	const t = Math.max(tau, 1e-6);
+	return mu0 / (a + b) * oneMinusExp(t * (1 / a + 1 / b)) / (.5 * oneMinusExp(2 * t / PROFILE_MU));
+}
+var RINGSHINE_BANDS = 3;
+var SECTORS = 12;
+var RINGSHINE_PATCHES = RINGSHINE_BANDS * (SECTORS / 2 + 1);
+var RINGSHINE_MIN_MU0 = 1e-4;
+var PROFILE_BINS = 256;
+var _litGain = new Float64Array(PROFILE_BINS);
+var SECTOR_STEPS = 6;
+var PLANET_LIGHT_AZIMUTHS = 19;
+var PLANET_LIGHT_RADII = 8;
+var PLANET_ROWS = 24;
+var PLANET_COLUMNS = 48;
+function luminance$2(r, g, b) {
+	return .2126 * r + .7152 * g + .0722 * b;
+}
+var SRGB_TO_LINEAR = Float64Array.from({ length: 256 }, (_, i) => {
+	const c = i / 255;
+	return c <= .04045 ? c / 12.92 : ((c + .055) / 1.055) ** 2.4;
+});
+function ringProfile(pixels, width, rows, inner, outer, intensity) {
+	const back = new Float64Array(PROFILE_BINS);
+	const forward = new Float64Array(PROFILE_BINS);
+	const unlit = new Float64Array(PROFILE_BINS);
+	const transmission = new Float64Array(PROFILE_BINS);
+	const unlitLuminance = luminance$2(...UNLIT_TINT);
+	const [br, bg, bb] = FORWARD_TINT_BIAS;
+	const tint = [
+		0,
+		0,
+		0
+	];
+	const at = (row, i) => (row * width + i) * 4;
+	for (let k = 0; k < PROFILE_BINS; k++) {
+		const from = Math.floor(k * width / PROFILE_BINS);
+		const to = Math.max(from + 1, Math.floor((k + 1) * width / PROFILE_BINS));
+		const r = inner + (k + .5) / PROFILE_BINS * (outer - inner);
+		for (let i = from; i < to; i++) {
+			const c = at(rows.color, i);
+			const red = SRGB_TO_LINEAR[pixels[c]];
+			const green = SRGB_TO_LINEAR[pixels[c + 1]];
+			const blue = SRGB_TO_LINEAR[pixels[c + 2]];
+			const opacity = Math.min(1, (1 - pixels[at(rows.transparency, i)] / 255) * intensity);
+			const backscatter = pixels[at(rows.backscattered, i)] / 255 * intensity;
+			back[k] += backscatter * luminance$2(red, green, blue);
+			forward[k] += pixels[at(rows.forwardscattered, i)] / 255 * opacity * intensity * luminance$2(red * br, green * bg, blue * bb);
+			unlit[k] += pixels[at(rows.unlitside, i)] / 255 * opacity * intensity * unlitLuminance;
+			transmission[k] += 1 - opacity;
+			tint[0] += backscatter * red * r;
+			tint[1] += backscatter * green * r;
+			tint[2] += backscatter * blue * r;
+		}
+		const n = to - from;
+		back[k] /= n;
+		forward[k] /= n;
+		unlit[k] /= n;
+		transmission[k] /= n;
+	}
+	const tintLuminance = luminance$2(tint[0], tint[1], tint[2]);
+	return {
+		inner,
+		outer,
+		back,
+		forward,
+		unlit,
+		transmission,
+		litTint: tintLuminance > 0 ? new Color(tint[0], tint[1], tint[2]).multiplyScalar(1 / tintLuminance) : new Color(1, 1, 1),
+		bands: equalLightBands(back, unlit, inner, outer)
+	};
+}
+function equalLightBands(back, unlit, inner, outer) {
+	const cumulative = new Float64Array(PROFILE_BINS + 1);
+	for (let k = 0; k < PROFILE_BINS; k++) {
+		const r = inner + (k + .5) / PROFILE_BINS * (outer - inner);
+		cumulative[k + 1] = cumulative[k] + (back[k] + unlit[k]) / r;
+	}
+	const total = cumulative[PROFILE_BINS];
+	const edges = new Int32Array(RINGSHINE_BANDS + 1);
+	edges[RINGSHINE_BANDS] = PROFILE_BINS;
+	for (let b = 1; b < RINGSHINE_BANDS; b++) {
+		let k = edges[b - 1] + 1;
+		while (k < PROFILE_BINS - (RINGSHINE_BANDS - b) && cumulative[k] < total * b / RINGSHINE_BANDS) k++;
+		edges[b] = k;
+	}
+	return edges;
+}
+function forwardWeight(cosPhase) {
+	const t = Math.min(Math.max((cosPhase + 1) / 2, 0), 1);
+	return 1 - t * t * (3 - 2 * t);
+}
+var PARTICLE_PHASE_EXPONENT = 3.09;
+function particlePhase(cosPhase) {
+	return (1 - Math.acos(Math.min(Math.max(cosPhase, -1), 1)) / Math.PI) ** PARTICLE_PHASE_EXPONENT;
+}
+function inPlanetShadow(x, y, cosB, sinB, planet) {
+	const ox = x / planet.equatorial;
+	const oy = y / planet.equatorial;
+	const dx = cosB / planet.equatorial;
+	const dz = sinB / planet.polar;
+	const b = ox * dx;
+	if (b >= 0) return false;
+	return ox * ox + oy * oy - b * b / (dx * dx + dz * dz) < 1;
+}
+function ringshinePatches(out, profile, sinB, planet) {
+	const cosB = Math.sqrt(Math.max(0, 1 - sinB * sinB));
+	const mu0 = Math.abs(sinB);
+	const sunAbove = sinB >= 0;
+	const { inner, outer, back, forward, unlit, transmission, bands } = profile;
+	for (let i = 0; i < PROFILE_BINS; i++) _litGain[i] = reflectionGain(mu0, mu0, -Math.log(Math.max(transmission[i], 1e-6)));
+	const dr = (outer - inner) / PROFILE_BINS;
+	const sector = 2 * Math.PI / SECTORS;
+	const dPhi = sector / SECTOR_STEPS;
+	let p = 0;
+	for (let band = 0; band < RINGSHINE_BANDS; band++) for (let k = 0; k <= SECTORS / 2; k++, p++) {
+		let above = 0;
+		let below = 0;
+		let weight = 0;
+		let wx = 0;
+		let wy = 0;
+		for (let s = 0; s < SECTOR_STEPS; s++) {
+			const phi = (k - .5) * sector + (s + .5) * dPhi;
+			const c = Math.cos(phi);
+			const sn = Math.sin(phi);
+			const w = forwardWeight(-cosB * c);
+			const phase = particlePhase(-cosB * c);
+			for (let i = bands[band]; i < bands[band + 1]; i++) {
+				const r = inner + (i + .5) * dr;
+				if (inPlanetShadow(r * c, r * sn, cosB, sinB, planet)) continue;
+				const area = r * dr * dPhi;
+				const lit = (back[i] * phase + (forward[i] - back[i] * phase) * w) * _litGain[i] * area;
+				const through = unlit[i] * area;
+				above += sunAbove ? lit : through;
+				below += sunAbove ? through : lit;
+				const light = lit + through;
+				weight += light;
+				wx += light * r * c;
+				wy += light * r * Math.abs(sn);
+			}
+		}
+		const share = k === 0 || k === SECTORS / 2 ? .5 : 1;
+		if (weight > 0) {
+			out[4 * p] = wx / weight;
+			out[4 * p + 1] = wy / weight;
+		} else {
+			const r = inner + (bands[band] + bands[band + 1]) / 2 * dr;
+			out[4 * p] = r * Math.cos(k * sector);
+			out[4 * p + 1] = r * Math.abs(Math.sin(k * sector));
+		}
+		out[4 * p + 2] = above * share;
+		out[4 * p + 3] = below * share;
+	}
+}
+function ringshineAt(patches, mu0, qx, qy, qz, nx, ny, nz) {
+	const above = qz >= 0;
+	const height = Math.abs(qz);
+	const qq = qx * qx + qy * qy + qz * qz;
+	const nq = nx * qx + ny * qy + nz * qz;
+	let sum = 0;
+	for (let i = 0; i < 21; i++) {
+		const px = patches[4 * i];
+		const py = patches[4 * i + 1];
+		const light = above ? patches[4 * i + 2] : patches[4 * i + 3];
+		const base = qq + px * px + py * py - 2 * px * qx;
+		const across = 2 * py * qy;
+		const facingBase = px * nx - nq;
+		const facingAcross = py * ny;
+		for (const sign of [1, -1]) {
+			const d2 = base - sign * across;
+			const d = Math.sqrt(d2);
+			const facing = Math.max(facingBase + sign * facingAcross, 0);
+			sum += light * facing / (d2 * d * (mu0 * d + height));
+		}
+	}
+	return 2 * mu0 * height * sum;
+}
+function ringTransmission(profile, x, y, z, cosB, sinB) {
+	if (Math.abs(sinB) < 1e-6) return 1;
+	const t = -z / sinB;
+	if (t < 0) return 1;
+	const u = (Math.hypot(x + t * cosB, y) - profile.inner) / (profile.outer - profile.inner);
+	if (u < 0 || u > 1) return 1;
+	const bin = Math.min(Math.floor(u * PROFILE_BINS), PROFILE_BINS - 1);
+	return Math.max(profile.transmission[bin], 1e-4) ** (1 / Math.max(Math.abs(sinB), .02));
+}
+var _cells = {
+	x: new Float64Array(PLANET_ROWS * PLANET_COLUMNS),
+	y: new Float64Array(PLANET_ROWS * PLANET_COLUMNS),
+	z: new Float64Array(PLANET_ROWS * PLANET_COLUMNS),
+	nx: new Float64Array(PLANET_ROWS * PLANET_COLUMNS),
+	ny: new Float64Array(PLANET_ROWS * PLANET_COLUMNS),
+	nz: new Float64Array(PLANET_ROWS * PLANET_COLUMNS),
+	light: new Float64Array(PLANET_ROWS * PLANET_COLUMNS)
+};
+function planetLightOnRing(out, inner, outer, sinB, planet, caster, patches) {
+	const cosB = Math.sqrt(Math.max(0, 1 - sinB * sinB));
+	const mu0 = Math.abs(sinB);
+	const { equatorial: a, polar: c } = planet;
+	const cells = _cells;
+	const dBeta = Math.PI / PLANET_ROWS;
+	const dLambda = 2 * Math.PI / PLANET_COLUMNS;
+	for (let row = 0; row < PLANET_ROWS; row++) {
+		const beta = -Math.PI / 2 + (row + .5) * dBeta;
+		const cb = Math.cos(beta);
+		const sb = Math.sin(beta);
+		const area = a * cb * Math.sqrt(c * c * cb * cb + a * a * sb * sb) * dBeta * dLambda;
+		for (let col = 0; col < PLANET_COLUMNS; col++) {
+			const lambda = (col + .5) * dLambda;
+			const cl = Math.cos(lambda);
+			const sl = Math.sin(lambda);
+			const i = row * PLANET_COLUMNS + col;
+			const x = a * cb * cl;
+			const y = a * cb * sl;
+			const z = c * sb;
+			let nx = cb * cl / a;
+			let ny = cb * sl / a;
+			let nz = sb / c;
+			const len = Math.hypot(nx, ny, nz);
+			nx /= len;
+			ny /= len;
+			nz /= len;
+			const cosSun = nx * cosB + nz * sinB;
+			const day = cosSun > 0 ? cosSun * ringTransmission(caster, x, y, z, cosB, sinB) : 0;
+			const night = mu0 < RINGSHINE_MIN_MU0 ? 0 : ringshineAt(patches, mu0, x, y, z, nx, ny, nz) / SUN_LIGHT_INTENSITY;
+			cells.x[i] = x;
+			cells.y[i] = y;
+			cells.z[i] = z;
+			cells.nx[i] = nx;
+			cells.ny[i] = ny;
+			cells.nz[i] = nz;
+			cells.light[i] = (day + night) / Math.PI * area;
+		}
+	}
+	for (let j = 0; j < 8; j++) {
+		const r = inner + j / (8 - 1) * (outer - inner);
+		for (let k = 0; k < 19; k++) {
+			const cosPhi = 1 - 2 * k / (19 - 1);
+			const px = r * cosPhi;
+			const py = r * Math.sqrt(1 - cosPhi * cosPhi);
+			let above = 0;
+			let below = 0;
+			let aboveMu = 0;
+			let belowMu = 0;
+			for (let i = 0; i < PLANET_ROWS * PLANET_COLUMNS; i++) {
+				const vx = px - cells.x[i];
+				const vy = py - cells.y[i];
+				const vz = -cells.z[i];
+				const d2 = vx * vx + vy * vy + vz * vz;
+				const facing = cells.nx[i] * vx + cells.ny[i] * vy + cells.nz[i] * vz;
+				if (facing <= 0) continue;
+				const d = Math.sqrt(d2);
+				const e = cells.light[i] * facing / (d2 * d);
+				const mu = Math.abs(vz) / d;
+				if (cells.z[i] > 0) {
+					above += e;
+					aboveMu += e * mu;
+				} else {
+					below += e;
+					belowMu += e * mu;
+				}
+			}
+			const node = 4 * (j * 19 + k);
+			out[node] = above;
+			out[node + 1] = below;
+			out[node + 2] = above > 0 ? aboveMu / above : 0;
+			out[node + 3] = below > 0 ? belowMu / below : 0;
+		}
+	}
+}
+var _grid = new Float32Array(4 * 19 * 8);
+function makeRingLight(profile) {
+	const texture = new DataTexture(new Uint16Array(4 * 19 * 8), 19, 8, RGBAFormat, HalfFloatType);
+	texture.minFilter = LinearFilter;
+	texture.magFilter = LinearFilter;
+	texture.wrapS = ClampToEdgeWrapping;
+	texture.wrapT = ClampToEdgeWrapping;
+	texture.needsUpdate = true;
+	return {
+		profile,
+		planet: {
+			equatorial: 0,
+			polar: 0
+		},
+		planetLight: texture,
+		planetLightSinB: NaN,
+		patches: new Float64Array(4 * 21),
+		patchesSinB: NaN
+	};
+}
+function fillPlanetLight(light, sinB, caster) {
+	planetLightOnRing(_grid, light.profile.inner, light.profile.outer, sinB, light.planet, caster.profile, caster.patches);
+	const data = light.planetLight.image.data;
+	for (let i = 0; i < _grid.length; i++) data[i] = DataUtils.toHalfFloat(_grid[i]);
+	light.planetLight.needsUpdate = true;
+	light.planetLightSinB = sinB;
+}
+function peakRingshine(profile, planet) {
+	const patches = new Float64Array(4 * 21);
+	ringshinePatches(patches, profile, 1, planet);
+	let peak = 0;
+	for (let deg = 2; deg < 90; deg += 2) {
+		const beta = deg * Math.PI / 180;
+		const cb = Math.cos(beta);
+		const sb = Math.sin(beta);
+		const nx = cb / planet.equatorial;
+		const nz = sb / planet.polar;
+		const len = Math.hypot(nx, nz);
+		const e = ringshineAt(patches, 1, planet.equatorial * cb, 0, planet.polar * sb, nx / len, 0, nz / len);
+		peak = Math.max(peak, e / SUN_LIGHT_INTENSITY);
+	}
+	return peak;
+}
+var RINGSHINE_PARS = `
+	#define RINGSHINE_PATCHES ${21}
+	uniform vec4 uRingshinePatch[RINGSHINE_PATCHES];
+	uniform vec3 uRingshineAxis;
+	uniform vec3 uRingshineTint[2];
+`;
+var RINGSHINE_LIGHT = `
+	if (uRingshineTint[0].g + uRingshineTint[1].g > 0.0) {
+		vec3 q = vRingShadowWorldPos - uRingShadowCenter;
+		vec3 axisY = cross(uRingShadowPoleDir, uRingshineAxis);
+		float height = dot(q, uRingShadowPoleDir);
+		float mu0 = abs(dot(uRingShadowSunDir, uRingShadowPoleDir));
+		vec3 n = inverseTransformDirection(geometryNormal, viewMatrix);
+		float qx = dot(q, uRingshineAxis);
+		float qy = dot(q, axisY);
+		float qq = dot(q, q);
+		float nx = dot(n, uRingshineAxis);
+		float ny = dot(n, axisY);
+		float nq = dot(n, q);
+		float above = step(0.0, height);
+		float absHeight = abs(height);
+		float sum = 0.0;
+		for (int i = 0; i < RINGSHINE_PATCHES; i++) {
+			vec4 p = uRingshinePatch[i];
+			float light = mix(p.w, p.z, above);
+			float base = qq + dot(p.xy, p.xy) - 2.0 * p.x * qx;
+			float across = 2.0 * p.y * qy;
+			float facingBase = p.x * nx - nq;
+			float facingAcross = p.y * ny;
+			// The patch and its mirror at -y.
+			vec2 d2 = vec2(base - across, base + across);
+			vec2 d = sqrt(d2);
+			vec2 facing = max(vec2(facingBase + facingAcross, facingBase - facingAcross), 0.0);
+			sum += light * dot(facing, 1.0 / (d2 * d * (mu0 * d + absHeight)));
+		}
+		vec3 tint = mix(uRingshineTint[1], uRingshineTint[0], above);
+		reflectedLight.indirectDiffuse +=
+			tint * (2.0 * mu0 * absHeight * sum) * BRDF_Lambert(material.diffuseContribution);
+	}
+`;
+function attachRingshine(material) {
+	const carrier = material.userData;
+	if (carrier.ringshine) return carrier.ringshine;
+	const uniforms = {
+		uRingshinePatch: { value: Array.from({ length: 21 }, () => new Vector4()) },
+		uRingshineAxis: { value: new Vector3(1, 0, 0) },
+		uRingshineTint: { value: [new Vector3(), new Vector3()] },
+		disable: () => {
+			for (const tint of uniforms.uRingshineTint.value) tint.set(0, 0, 0);
+		}
+	};
+	chainShaderHook(material, "ringshine", (shader) => {
+		shader.uniforms.uRingshinePatch = uniforms.uRingshinePatch;
+		shader.uniforms.uRingshineAxis = uniforms.uRingshineAxis;
+		shader.uniforms.uRingshineTint = uniforms.uRingshineTint;
+		shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>\n${RINGSHINE_PARS}`).replace("#include <lights_fragment_end>", `#include <lights_fragment_end>\n${RINGSHINE_LIGHT}`);
+	});
+	carrier.ringshine = uniforms;
+	return uniforms;
+}
+function writeRingshine(uniforms, light, axis, sinB, lightScale) {
+	const patches = uniforms.uRingshinePatch.value;
+	for (let i = 0; i < 21; i++) patches[i].fromArray(light.patches, 4 * i);
+	uniforms.uRingshineAxis.value.copy(axis);
+	const [above, below] = uniforms.uRingshineTint.value;
+	if (Math.abs(sinB) < RINGSHINE_MIN_MU0) {
+		above.set(0, 0, 0);
+		below.set(0, 0, 0);
+		return;
+	}
+	const lit = light.profile.litTint;
+	const unlitLuminance = luminance$2(...UNLIT_TINT);
+	const [litFace, unlitFace] = sinB >= 0 ? [above, below] : [below, above];
+	litFace.set(lit.r, lit.g, lit.b).multiplyScalar(lightScale);
+	unlitFace.set(...UNLIT_TINT).multiplyScalar(lightScale / unlitLuminance);
+}
+
 //#endregion
 //#region src/lib/scene/objects/surface/rings.ts
 var RING_ANGULAR_SEGMENTS = 256;
@@ -9986,30 +10920,47 @@ async function loadStripTextures(url, rows, maxTextureSize) {
 	if (!response.ok) throw new Error(`Failed to load ${url}: ${response.status} ${response.statusText}`);
 	const blob = await response.blob();
 	const bitmap = await createImageBitmap(blob);
-	const targetWidth = Math.min(bitmap.width, maxTextureSize);
-	if (targetWidth < bitmap.width) console.info(`Ring strip ${url}: downscaling ${bitmap.width}px → ${targetWidth}px to fit GL MAX_TEXTURE_SIZE.`);
-	const strip = readStripPixels(bitmap, url, maxTextureSize);
-	const textures = {};
-	for (const [channel, row] of Object.entries(rows)) {
+	const width = bitmap.width;
+	const targetWidth = Math.min(width, maxTextureSize);
+	if (targetWidth < width) console.info(`Ring strip ${url}: downscaling ${width}px → ${targetWidth}px to fit GL MAX_TEXTURE_SIZE.`);
+	const pixels = readStripPixels(bitmap, url, maxTextureSize);
+	bitmap.close();
+	const line = (row) => boxFilterRow(pixels, width, row, targetWidth);
+	const texture = (data, srgb = false) => {
 		const canvas = document.createElement("canvas");
 		canvas.width = targetWidth;
 		canvas.height = 2;
 		const ctx = canvas.getContext("2d");
 		if (!ctx) throw new Error(`Failed to acquire 2D context for ring strip ${url}`);
-		const line = boxFilterRow(strip, bitmap.width, row, targetWidth);
-		ctx.putImageData(line, 0, 0);
-		ctx.putImageData(line, 0, 1);
+		ctx.putImageData(data, 0, 0);
+		ctx.putImageData(data, 0, 1);
 		const tex = new CanvasTexture(canvas);
-		if (channel === "color") tex.colorSpace = SRGBColorSpace;
+		if (srgb) tex.colorSpace = SRGBColorSpace;
 		tex.minFilter = LinearMipmapLinearFilter;
 		tex.magFilter = LinearFilter;
 		tex.generateMipmaps = true;
 		tex.anisotropy = 16;
 		tex.needsUpdate = true;
-		textures[channel] = tex;
+		return tex;
+	};
+	const scatter = line(rows.backscattered);
+	const forward = line(rows.forwardscattered);
+	const unlit = line(rows.unlitside);
+	for (let d = 0; d < scatter.data.length; d += 4) {
+		scatter.data[d + 1] = forward.data[d];
+		scatter.data[d + 2] = unlit.data[d];
 	}
-	bitmap.close();
-	return textures;
+	const textures = {
+		color: texture(line(rows.color), true),
+		scatter: texture(scatter),
+		transparency: texture(line(rows.transparency))
+	};
+	if (rows.thickness !== void 0) textures.thickness = texture(line(rows.thickness));
+	return {
+		textures,
+		pixels,
+		width
+	};
 }
 function readStripPixels(bitmap, url, maxTextureSize) {
 	const out = new Uint8ClampedArray(bitmap.width * bitmap.height * 4);
@@ -10090,9 +11041,7 @@ var FRAGMENT_SHADER$2 = `
 	#include <common>
 	#include <logdepthbuf_pars_fragment>
 
-	uniform sampler2D uBackscattered;
-	uniform sampler2D uForwardscattered;
-	uniform sampler2D uUnlitside;
+	uniform sampler2D uScatter;
 	uniform sampler2D uTransparency;
 	uniform sampler2D uColor;
 	uniform float uInnerScene;
@@ -10114,18 +11063,56 @@ var FRAGMENT_SHADER$2 = `
 	// 1/layerCount: opacity is split across the vertical layer instances so
 	// the composited stack reproduces the strip's alpha.
 	uniform float uLayerAlphaExp;
+	// Light of the planet on the +Y and the -Y face over the Sun's, per unit of the
+	// planet's albedo, and the mean sine of its incidence on each, by the cosine
+	// of the azimuth from the Sun (x) and radius (y).
+	uniform sampler2D uPlanetLight;
+	// Lambert albedo of the planet, linear RGB.
+	uniform vec3 uPlanetAlbedo;
+	// Unit direction of the Sun in the local XZ plane.
+	uniform vec2 uSunAzimuth;
 
 	varying vec3 vLocalPos;
 	varying vec3 vWorldPos;
 	varying vec3 vWorldNormal;
 
-	// Per BJJ: the Cassini-derived color profile only fits backscattered
-	// light. Unlit/forward branches get a fixed near-white tint per BJJ.
-	const vec3 UNLIT_TINT = vec3(1.0, 0.97075, 0.952);
+	const vec3 UNLIT_TINT = vec3(${UNLIT_TINT.join(", ")});
+	const vec3 FORWARD_TINT_BIAS = vec3(${FORWARD_TINT_BIAS.join(", ")});
+	const float PROFILE_MU = ${PROFILE_MU};
+
+	float oneMinusExp(float x) {
+		return x < 1e-3 ? x * (1.0 - 0.5 * x) : 1.0 - exp(-x);
+	}
+
+	float reflectionGain(float mu0, float mu, float tau) {
+		float a = max(mu0, 1e-4);
+		float b = max(mu, 1e-4);
+		return mu0 / (a + b) * oneMinusExp(tau * (1.0 / a + 1.0 / b))
+			/ (0.5 * oneMinusExp(2.0 * tau / PROFILE_MU));
+	}
+
+	float unlitGain(float mu0, float mu) {
+		return 2.0 * mu0 / max(mu0 + mu, 1e-4);
+	}
 
-	// Red bias on the forward-scatter branch, per BJJ's "becoming slightly
-	// redder" observation as phase angle climbs.
-	const vec3 FORWARD_TINT_BIAS = vec3(1.02, 0.99, 0.97);
+	// Weight of forward scatter: 0 at phase 0, 1 at phase 180 deg, 0.5 edge-on.
+	float forwardWeight(float cosPhase) {
+		return 1.0 - smoothstep(-1.0, 1.0, cosPhase);
+	}
+
+	float particlePhase(float cosPhase) {
+		return pow(1.0 - acos(clamp(cosPhase, -1.0, 1.0)) / PI, ${PARTICLE_PHASE_EXPONENT});
+	}
+
+	// The lit face at a phase and a gain: the backscatter profile under the
+	// phase function of the particles, blended into the forward-scatter profile.
+	vec3 litLight(vec3 back, vec3 forward, float cosPhase, float gain) {
+		return mix(
+			back * particlePhase(cosPhase) * gain,
+			forward * min(gain, 1.0),
+			forwardWeight(cosPhase)
+		);
+	}
 
 	// Ray-march from the fragment toward the sun against the planet's oblate
 	// spheroid: warp into the pole-aligned frame so the spheroid becomes a
@@ -10166,40 +11153,49 @@ var FRAGMENT_SHADER$2 = `
 		// the outward direction of the face actually being viewed.
 		vec3 N = gl_FrontFacing ? vWorldNormal : -vWorldNormal;
 
-		bool lit = dot(uSunDir, N) > 0.0;
+		float sunMu = dot(uSunDir, N);
+		bool lit = sunMu > 0.0;
+		float mu0 = abs(sunMu);
 
-		// cosAlpha = cos(phase angle): +1 low phase, -1 high phase.
 		vec3 viewDir = normalize(cameraPosition - vWorldPos);
-		float cosAlpha = dot(uSunDir, viewDir);
-
-		vec3 finalAlbedo;
-		if (lit) {
-			// Blend backscatter → forward scatter with phase angle; smoothstep
-			// over [-1, 1] centers the transition on edge-on viewing (α = 90°).
-			// Both branches share the Cassini color profile (calibrated for
-			// backscatter only) plus a small red bias on the forward branch,
-			// since dropping color entirely visibly loses the ring's tan/gold
-			// hue seen in forward-scattered Cassini imagery.
-			vec3 colorTint = texture2D(uColor, uv).rgb;
-			vec3 forwardTint = colorTint * FORWARD_TINT_BIAS;
-			vec3 back = texture2D(uBackscattered, uv).rgb * colorTint;
-			vec3 forward = texture2D(uForwardscattered, uv).rgb * forwardTint;
-			float wForward = 1.0 - smoothstep(-1.0, 1.0, cosAlpha);
-			finalAlbedo = mix(back, forward, wForward);
-		} else {
-			// unlitside already is the transmitted-light appearance; no
-			// phase-angle blend needed.
-			finalAlbedo = texture2D(uUnlitside, uv).rgb * UNLIT_TINT;
-		}
+		float mu = abs(dot(viewDir, N));
 		// Transparency convention: 1.0 = empty space, 0.0 = opaque.
-		float alpha = clamp((1.0 - texture2D(uTransparency, uv).r) * uIntensityScale, 0.0, 1.0);
-		// Split opacity across layer instances so the composited stack
-		// reproduces the strip's alpha.
-		alpha = 1.0 - pow(1.0 - alpha, uLayerAlphaExp);
+		float opacity = clamp((1.0 - texture2D(uTransparency, uv).r) * uIntensityScale, 0.0, 1.0);
+		float tau = max(-log(max(1.0 - opacity, 1e-6)), 1e-6);
+
+		vec3 colorTint = texture2D(uColor, uv).rgb;
+		vec3 scatter = texture2D(uScatter, uv).rgb;
+		vec3 back = scatter.r * colorTint;
+		vec3 forward = scatter.g * opacity * colorTint * FORWARD_TINT_BIAS;
+		vec3 unlit = scatter.b * opacity * UNLIT_TINT;
+		vec3 sunLit = lit
+			? litLight(back, forward, dot(uSunDir, viewDir), reflectionGain(mu0, mu, tau))
+			: unlit * min(unlitGain(mu0, mu), 1.0);
+
+		// The light is the same at plus and minus an azimuth, so the texture holds its cosine.
+		float azimuth = 0.5 - 0.5 * dot(vLocalPos.xz, uSunAzimuth) / radius;
+		const vec2 NODES = vec2(${19}.0, ${8}.0);
+		vec4 planet = texture2D(uPlanetLight, (vec2(azimuth, t) * (NODES - 1.0) + 0.5) / NODES);
+		vec2 near = gl_FrontFacing ? planet.xz : planet.yw;
+		vec2 far = gl_FrontFacing ? planet.yw : planet.xz;
+		float planetPhase = dot(normalize(uPlanetCenter - vWorldPos), viewDir);
+		vec3 planetLit = uPlanetAlbedo * (
+			near.x * litLight(back, forward, planetPhase, reflectionGain(near.y, mu, tau))
+			+ far.x * min(unlitGain(far.y, mu), 1.0) * unlit);
+
+		// The slant path hides more of the background.
+		float alpha = oneMinusExp(tau / max(mu, 0.02));
+		// Split the opacity across the sheets of the stack so that it composites
+		// to the layer's. Each sheet adds its share of the light.
+		float layerAlpha = 1.0 - pow(1.0 - alpha, uLayerAlphaExp);
+		float share = alpha > 1e-4 ? layerAlpha / alpha : uLayerAlphaExp;
 
 		float shadow = planetShadow();
 
-		gl_FragColor = vec4(finalAlbedo * uIntensityScale * shadow * uLightScale, alpha);
+		gl_FragColor = vec4(
+			(sunLit * shadow + planetLit) * uIntensityScale * uLightScale * share,
+			layerAlpha
+		);
 		#include <logdepthbuf_fragment>
 	}
 `;
@@ -10306,8 +11302,11 @@ async function loadRingNode(bodyId, meta, maxTextureSize) {
 	const outerScene = kmToScene(meta.outer_radius_km);
 	const intensityScale = meta.intensity_scale ?? 1;
 	let textures;
+	let light;
 	try {
-		textures = await loadStripTextures(versionedUrl(`/v1/rings/${bodyId}/${meta.strip}`, "rings"), meta.strip_rows, maxTextureSize);
+		const strip = await loadStripTextures(versionedUrl(`/v1/rings/${bodyId}/${meta.strip}`, "rings"), meta.strip_rows, maxTextureSize);
+		textures = strip.textures;
+		light = makeRingLight(ringProfile(strip.pixels, strip.width, meta.strip_rows, innerScene, outerScene, intensityScale));
 	} catch (err) {
 		console.warn(`Failed to load ring strip for ${bodyId}:`, err);
 		return null;
@@ -10316,9 +11315,7 @@ async function loadRingNode(bodyId, meta, maxTextureSize) {
 	const layers = thicknessScene > 0 ? 48 : 1;
 	const material = new ShaderMaterial({
 		uniforms: {
-			uBackscattered: { value: textures.backscattered },
-			uForwardscattered: { value: textures.forwardscattered },
-			uUnlitside: { value: textures.unlitside },
+			uScatter: { value: textures.scatter },
 			uTransparency: { value: textures.transparency },
 			uColor: { value: textures.color },
 			uThickness: { value: textures.thickness ?? textures.transparency },
@@ -10334,13 +11331,17 @@ async function loadRingNode(bodyId, meta, maxTextureSize) {
 			uPlanetEquatorialScene: { value: 0 },
 			uPlanetPolarScene: { value: 0 },
 			uLightScale: { value: 1 },
-			uIntensityScale: { value: intensityScale }
+			uIntensityScale: { value: intensityScale },
+			uPlanetLight: { value: light.planetLight },
+			uPlanetAlbedo: { value: new Color(0, 0, 0) },
+			uSunAzimuth: { value: new Vector2(1, 0) }
 		},
 		vertexShader: VERTEX_SHADER$2,
 		fragmentShader: FRAGMENT_SHADER$2,
 		transparent: true,
 		depthWrite: false,
 		blending: NormalBlending,
+		premultipliedAlpha: true,
 		side: DoubleSide
 	});
 	const geometry = new RingGeometry(innerScene, outerScene * (1 / Math.cos(Math.PI / RING_ANGULAR_SEGMENTS)), RING_ANGULAR_SEGMENTS, layers > 1 ? RING_RADIAL_SEGMENTS : 1);
@@ -10371,19 +11372,20 @@ async function loadRingNode(bodyId, meta, maxTextureSize) {
 		innerScene,
 		outerScene,
 		planetShadow: null,
-		planetShadowOnRing
+		planetShadowOnRing,
+		light,
+		ringshine: null
 	};
 }
 function disposeRingNode(ring) {
 	ring.mesh.geometry.dispose();
 	const uniforms = ring.material.uniforms;
 	for (const key of [
-		"uBackscattered",
-		"uForwardscattered",
-		"uUnlitside",
+		"uScatter",
 		"uTransparency",
 		"uColor",
-		"uThickness"
+		"uThickness",
+		"uPlanetLight"
 	]) (uniforms[key]?.value)?.dispose();
 	ring.mesh.material.dispose();
 }
@@ -10627,6 +11629,14 @@ var SHARED = {
 	uOccluders: { value: Array.from({ length: 32 }, () => new Vector4()) },
 	uOccluderLeak: { value: Array.from({ length: 32 }, () => new Vector4()) }
 };
+var POOL = {
+	occluders: [],
+	leaks: [],
+	count: 0
+};
+function getOccluderPool() {
+	return POOL;
+}
 var ECLIPSE_FACTOR_GLSL = `
 	#define ECLIPSE_MAX_OCCLUDERS ${32}
 	uniform float uSunAngularRadius;
@@ -10712,13 +11722,18 @@ function makeEclipseSelfUniforms() {
 		uOccluderCount: { value: 0 }
 	};
 }
+var _kept = new Int32Array(0);
+var _size = new Float64Array(0);
+var largestFirst = (a, b) => _size[b] - _size[a];
 function cullOccludersFor(dst, center, radius, sunDir, leakDst) {
 	const aSun = SHARED.uSunAngularRadius.value;
-	const src = SHARED.uOccluders.value;
-	const leak = SHARED.uOccluderLeak.value;
-	const srcCount = SHARED.uOccluderCount.value;
+	const src = POOL.occluders;
+	if (_kept.length < POOL.count) {
+		_kept = new Int32Array(POOL.count);
+		_size = new Float64Array(POOL.count);
+	}
 	let n = 0;
-	for (let i = 0; i < srcCount; i++) {
+	for (let i = 0; i < POOL.count; i++) {
 		const oc = src[i];
 		const ox = oc.x - center.x;
 		const oy = oc.y - center.y;
@@ -10729,8 +11744,17 @@ function cullOccludersFor(dst, center, radius, sunDir, leakDst) {
 		if (t < -(radius + oc.w)) continue;
 		const reach = radius + oc.w + aSun * (t + radius) * 1.5;
 		if (d2 - t * t > reach * reach) continue;
-		leakDst?.[n].copy(leak[i]);
-		dst[n++].copy(oc);
+		_size[i] = oc.w * oc.w / d2;
+		_kept[n++] = i;
+	}
+	if (n > 32) {
+		_kept.subarray(0, n).sort(largestFirst);
+		n = 32;
+	}
+	for (let k = 0; k < n; k++) {
+		const i = _kept[k];
+		leakDst?.[k].copy(POOL.leaks[i]);
+		dst[k].copy(src[i]);
 	}
 	return n;
 }
@@ -11616,6 +12640,96 @@ function disposeAtmosphereNode(node) {
 	node.mesh.material.dispose();
 }
 
+//#endregion
+//#region src/lib/scene/objects/surface/planetshine.ts
+var MAX_SHINERS = 2;
+var SHINE_FLOOR = 1e-4;
+function lambertSpherePhase(a) {
+	return (Math.sin(a) + (Math.PI - a) * Math.cos(a)) / Math.PI;
+}
+function planetshineFraction(radius, distance, a) {
+	const k = radius / distance;
+	return 2 / 3 * lambertSpherePhase(a) * k * k;
+}
+var PLANETSHINE_GLSL = `
+	#define PLANETSHINE_SHINERS ${2}
+	uniform vec4 uShineDir[PLANETSHINE_SHINERS];
+	uniform vec3 uShineLight[PLANETSHINE_SHINERS];
+
+	float sphereLightCosine(float cosTheta, float sinAlpha) {
+		float t = max(cosTheta + sinAlpha, 0.0);
+		return cosTheta >= sinAlpha ? cosTheta : t * t / (4.0 * sinAlpha);
+	}
+`;
+var PLANETSHINE_LIGHT = `
+	for (int i = 0; i < PLANETSHINE_SHINERS; i++) {
+		vec4 shiner = uShineDir[i];
+		// The slots fill in order, so the first empty slot ends the list.
+		if (shiner.w <= 0.0) break;
+		float cosine = sphereLightCosine(dot(geometryNormal, mat3(viewMatrix) * shiner.xyz), shiner.w);
+		reflectedLight.indirectDiffuse += uShineLight[i] * cosine * BRDF_Lambert(material.diffuseContribution);
+	}
+`;
+function makePlanetshineUniforms() {
+	return {
+		uShineDir: { value: Array.from({ length: 2 }, () => new Vector4(0, 0, 0, 0)) },
+		uShineLight: { value: Array.from({ length: 2 }, () => new Vector3()) }
+	};
+}
+function attachPlanetshine(material, uniforms) {
+	const self = uniforms ?? makePlanetshineUniforms();
+	chainShaderHook(material, "planetshine", (shader) => {
+		Object.assign(shader.uniforms, self);
+		shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>\n${PLANETSHINE_GLSL}`).replace("#include <lights_fragment_end>", `#include <lights_fragment_end>\n${PLANETSHINE_LIGHT}`);
+	});
+	return self;
+}
+var _strength = new Float64Array(2);
+var _swapDir = new Vector4();
+var _swapLight = new Vector3();
+function selectShiners(out, x, y, z, shiners, count) {
+	const dirs = out.uShineDir.value;
+	const lights = out.uShineLight.value;
+	let kept = 0;
+	for (let i = 0; i < count; i++) {
+		const s = shiners[i];
+		const dx = s.x - x;
+		const dy = s.y - y;
+		const dz = s.z - z;
+		const d2 = dx * dx + dy * dy + dz * dz;
+		if (2 / 3 * s.radius * s.radius < 1e-4 * d2) continue;
+		const d = Math.sqrt(d2);
+		if (d <= s.radius) continue;
+		const k = s.radius / d;
+		const cosPhase = -(dx * s.sunX + dy * s.sunY + dz * s.sunZ) / d;
+		const fraction = planetshineFraction(s.radius, d, Math.acos(Math.max(-1, Math.min(1, cosPhase))));
+		const strength = fraction * (.2126 * s.albedo.r + .7152 * s.albedo.g + .0722 * s.albedo.b);
+		if (strength < 1e-4) continue;
+		let slot = kept;
+		if (kept < 2) kept++;
+		else if (strength > _strength[2 - 1]) slot = 2 - 1;
+		else continue;
+		_strength[slot] = strength;
+		dirs[slot].set(dx / d, dy / d, dz / d, k);
+		lights[slot].set(s.albedo.r, s.albedo.g, s.albedo.b).multiplyScalar(s.sunlight * fraction);
+		for (; slot > 0 && _strength[slot - 1] < strength; slot--) {
+			_strength[slot] = _strength[slot - 1];
+			_strength[slot - 1] = strength;
+			_swapDir.copy(dirs[slot - 1]);
+			dirs[slot - 1].copy(dirs[slot]);
+			dirs[slot].copy(_swapDir);
+			_swapLight.copy(lights[slot - 1]);
+			lights[slot - 1].copy(lights[slot]);
+			lights[slot].copy(_swapLight);
+		}
+	}
+	for (let i = kept; i < 2; i++) {
+		dirs[i].set(0, 0, 0, 0);
+		lights[i].set(0, 0, 0);
+	}
+	return kept;
+}
+
 //#endregion
 //#region src/lib/scene/objects/surface/ring-attach.ts
 function attachRingBundles(bodyId, systemId, rings, radii, bo, scene, maxTextureSize, ctx) {
@@ -11635,12 +12749,15 @@ function attachRingBundles(bodyId, systemId, rings, radii, bo, scene, maxTexture
 				return;
 			}
 			node.mesh.userData.ringBundle = ringMeta.bundle;
+			node.light.planet = ringPlanet(radii, bo.radiusScene);
 			const host = bo.mesh ?? bo.model;
 			if (host) node.mesh.quaternion.copy(host.quaternion);
 			bo.rings.push(node);
 			bo.root.add(node.mesh);
 			if (bo.mesh && ringMeta === shadowCaster) {
-				node.planetShadow = attachRingShadowToPlanet(bo.mesh.material, node.innerScene, node.outerScene, node.transparency, node.intensityScale);
+				const material = bo.mesh.material;
+				node.planetShadow = attachRingShadowToPlanet(material, node.innerScene, node.outerScene, node.transparency, node.intensityScale);
+				if (peakRingshine(node.light.profile, node.light.planet) >= 1e-4) node.ringshine = attachRingshine(material);
 				if (bo.atmosphere) attachRingShadowToAtmosphere(bo.atmosphere, node.planetShadow, node.transparency, node.innerScene, node.outerScene);
 			}
 			if (radii) {
@@ -11651,6 +12768,15 @@ function attachRingBundles(bodyId, systemId, rings, radii, bo, scene, maxTexture
 	}
 	return promises;
 }
+function ringPlanet(radii, radiusScene) {
+	return radii ? {
+		equatorial: kmToScene((radii.a + radii.b) / 2),
+		polar: kmToScene(radii.c)
+	} : {
+		equatorial: radiusScene,
+		polar: radiusScene
+	};
+}
 
 //#endregion
 //#region src/lib/fetch/nomenclature/parse.ts
@@ -11685,7 +12811,7 @@ function parseNomenclature(buffer) {
 
 //#endregion
 //#region src/lib/fetch/nomenclature/fetch.ts
-var cache$1 = /* @__PURE__ */ new Map();
+var cache$2 = /* @__PURE__ */ new Map();
 async function fetchPositions(bodyId) {
 	const url = versionedUrl(`/v1/nomenclature/positions/${bodyId}.bin.gz`, "nomenclature");
 	const res = await fetch(url);
@@ -11713,16 +12839,16 @@ function nameFeatures(records, labelText) {
 }
 function fetchBodyNomenclature(bodyId, lang = getLocale()) {
 	const key = `${bodyId}:${lang}`;
-	let p = cache$1.get(key);
+	let p = cache$2.get(key);
 	if (!p) {
 		p = (async () => {
 			await fetchMetadata();
 			const [records, labels] = await Promise.all([fetchPositions(bodyId), fetchLabelText(bodyId, lang)]);
 			return nameFeatures(records, labels);
 		})();
-		cache$1.set(key, p);
+		cache$2.set(key, p);
 		p.catch(() => {
-			if (cache$1.get(key) === p) cache$1.delete(key);
+			if (cache$2.get(key) === p) cache$2.delete(key);
 		});
 	}
 	return p;
@@ -11765,6 +12891,100 @@ 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 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;
+	try {
+		objURL = blob$1 && (self.URL || self.webkitURL).createObjectURL(blob$1);
+		if (!objURL) throw "";
+		const worker = new Worker(objURL, {
+			type: "module",
+			name: options?.name
+		});
+		worker.addEventListener("error", () => {
+			(self.URL || self.webkitURL).revokeObjectURL(objURL);
+		});
+		return worker;
+	} catch (e) {
+		return new Worker("data:text/javascript;charset=utf-8," + encodeURIComponent(jsContent$1), {
+			type: "module",
+			name: options?.name
+		});
+	}
+}
+
+//#endregion
+//#region src/lib/scene/relief/client.ts
+var worker = null;
+var nextId = 1;
+var pending$1 = /* @__PURE__ */ new Map();
+function drop(reason) {
+	worker?.terminate();
+	worker = null;
+	const lost = [...pending$1.values()];
+	pending$1.clear();
+	for (const { reject } of lost) reject(new Error(reason));
+}
+function ensureWorker() {
+	if (worker) return worker;
+	worker = new WorkerWrapper$1();
+	worker.onmessage = (ev) => {
+		const msg = ev.data;
+		const request = pending$1.get(msg.id);
+		pending$1.delete(msg.id);
+		if (!request) return;
+		if (msg.type === "failed") request.reject(/* @__PURE__ */ new Error("relief worker could not answer"));
+		else request.resolve(msg);
+	};
+	worker.onerror = (ev) => drop(`relief worker error: ${ev.message || "unknown"}`);
+	worker.onmessageerror = () => drop("relief worker sent a message that could not be read");
+	return worker;
+}
+function ask(build, signal) {
+	return new Promise((resolve, reject) => {
+		if (typeof Worker === "undefined") {
+			reject(/* @__PURE__ */ new Error("no workers here"));
+			return;
+		}
+		const id = nextId++;
+		pending$1.set(id, {
+			resolve,
+			reject
+		});
+		signal.addEventListener("abort", () => {
+			if (!pending$1.delete(id)) return;
+			ensureWorker().postMessage({
+				type: "abort",
+				id
+			});
+			reject(new DOMException("aborted", "AbortError"));
+		}, { once: true });
+		ensureWorker().postMessage(build(id));
+	});
+}
+function absolute(url) {
+	return new URL(url, location.href).href;
+}
+function loadHeightTile(url, fine, signal) {
+	return ask((id) => ({
+		type: "tile",
+		id,
+		url: absolute(url),
+		fine
+	}), signal);
+}
+function buildTerrainGrid(spec, signal) {
+	return ask((id) => ({
+		...spec,
+		type: "grid",
+		id,
+		root: absolute(spec.root)
+	}), signal);
+}
+
 //#endregion
 //#region src/lib/scene/lod/tile-window.ts
 var WINDOW_TILES = 4;
@@ -11919,100 +13139,6 @@ function slotTile(placement, sx, sy) {
 	};
 }
 
-//#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 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;
-	try {
-		objURL = blob$1 && (self.URL || self.webkitURL).createObjectURL(blob$1);
-		if (!objURL) throw "";
-		const worker = new Worker(objURL, {
-			type: "module",
-			name: options?.name
-		});
-		worker.addEventListener("error", () => {
-			(self.URL || self.webkitURL).revokeObjectURL(objURL);
-		});
-		return worker;
-	} catch (e) {
-		return new Worker("data:text/javascript;charset=utf-8," + encodeURIComponent(jsContent$1), {
-			type: "module",
-			name: options?.name
-		});
-	}
-}
-
-//#endregion
-//#region src/lib/scene/relief/client.ts
-var worker = null;
-var nextId = 1;
-var pending$1 = /* @__PURE__ */ new Map();
-function drop(reason) {
-	worker?.terminate();
-	worker = null;
-	const lost = [...pending$1.values()];
-	pending$1.clear();
-	for (const { reject } of lost) reject(new Error(reason));
-}
-function ensureWorker() {
-	if (worker) return worker;
-	worker = new WorkerWrapper$1();
-	worker.onmessage = (ev) => {
-		const msg = ev.data;
-		const request = pending$1.get(msg.id);
-		pending$1.delete(msg.id);
-		if (!request) return;
-		if (msg.type === "failed") request.reject(/* @__PURE__ */ new Error("relief worker could not answer"));
-		else request.resolve(msg);
-	};
-	worker.onerror = (ev) => drop(`relief worker error: ${ev.message || "unknown"}`);
-	worker.onmessageerror = () => drop("relief worker sent a message that could not be read");
-	return worker;
-}
-function ask(build, signal) {
-	return new Promise((resolve, reject) => {
-		if (typeof Worker === "undefined") {
-			reject(/* @__PURE__ */ new Error("no workers here"));
-			return;
-		}
-		const id = nextId++;
-		pending$1.set(id, {
-			resolve,
-			reject
-		});
-		signal.addEventListener("abort", () => {
-			if (!pending$1.delete(id)) return;
-			ensureWorker().postMessage({
-				type: "abort",
-				id
-			});
-			reject(new DOMException("aborted", "AbortError"));
-		}, { once: true });
-		ensureWorker().postMessage(build(id));
-	});
-}
-function absolute(url) {
-	return new URL(url, location.href).href;
-}
-function loadHeightTile(url, fine, signal) {
-	return ask((id) => ({
-		type: "tile",
-		id,
-		url: absolute(url),
-		fine
-	}), signal);
-}
-function buildTerrainGrid(spec, signal) {
-	return ask((id) => ({
-		...spec,
-		type: "grid",
-		id,
-		root: absolute(spec.root)
-	}), signal);
-}
-
 //#endregion
 //#region src/lib/scene/render-tier.ts
 var RENDER_TIER_PRESETS = {
@@ -12103,37 +13229,28 @@ var TILE_CHAIN_GLSL = `
 #ifndef TILE_CHAIN
 #define TILE_CHAIN
 
-// Where a fragment is on the map and on the cap of its own hemisphere, as
-// fractions of the chart, and what a screen pixel spans there. The place on
-// the cap is from the chart's north-west corner. The place on the map is from
-// the point that the maker of the charts counts from.
-struct TileCharts {
-	vec2 mapAt;
-	vec2 mapDx;
-	vec2 mapDy;
-	vec2 capAt;
-	vec2 capDx;
-	vec2 capDy;
-	float side;
-};
+// A fragment on one chart is a mat3x2: its place, as a fraction of the
+// chart, then what a screen pixel adds to that along x and along y.
 
-// The cap of the hemisphere of dir, seen from above its pole. ddx and ddy are
-// what a screen pixel adds to dir.
-void tileCap( vec3 dir, vec3 ddx, vec3 ddy, out float side, out vec2 capAt, out vec2 capDx, out vec2 capDy ) {
+// The cap of the hemisphere of dir, seen from above its pole: the place is
+// from the chart's north-west corner. ddx and ddy are what a screen pixel
+// adds to dir.
+void tileCap( vec3 dir, vec3 ddx, vec3 ddy, out float side, out mat3x2 cap ) {
 	side = dir.y < 0.0 ? - 1.0 : 1.0;
 	float fold = 1.0 + side * dir.y;
 	vec2 plane = vec2( dir.x, side * dir.z );
 	float capScale = 0.5 / ( ${CAP_EDGE.toFixed(8)} * fold );
-	capAt = 0.5 + plane * capScale;
-	capDx = ( vec2( ddx.x, side * ddx.z ) - plane * ( side * ddx.y / fold ) ) * capScale;
-	capDy = ( vec2( ddy.x, side * ddy.z ) - plane * ( side * ddy.y / fold ) ) * capScale;
+	cap = mat3x2(
+		0.5 + plane * capScale,
+		( vec2( ddx.x, side * ddx.z ) - plane * ( side * ddx.y / fold ) ) * capScale,
+		( vec2( ddy.x, side * ddy.z ) - plane * ( side * ddy.y / fold ) ) * capScale
+	);
 }
 
-// The charts of the point at + off, the map 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.
-TileCharts tileChartsFrom( vec3 at, vec3 off ) {
-	TileCharts charts;
+// 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.
+void tileChartsFrom( vec3 at, vec3 off, out mat3x2 map, out mat3x2 cap, out float side ) {
 	vec3 pos = at + off;
 	vec3 ox = dFdx( off );
 	vec3 oy = dFdy( off );
@@ -12146,19 +13263,20 @@ TileCharts tileChartsFrom( vec3 at, vec3 off ) {
 	float turn = atan( at.z * off.x - at.x * off.z, at.x * pos.x + at.z * pos.z );
 	float out1 = ( 2.0 * ( at.x * off.x + at.z * off.z ) + off.x * off.x + off.z * off.z ) / ( flat1 + flat0 );
 	float drop = atan( out1 * at.y - off.y * flat0, pos.y * at.y + flat1 * flat0 );
-	charts.mapAt = vec2( turn / ( 2.0 * PI ), drop / PI );
 	float east = 1.0 / ( 2.0 * PI * flat2 );
 	float south = 1.0 / ( PI * dot( pos, pos ) );
-	charts.mapDx = vec2( ( pos.z * ox.x - pos.x * ox.z ) * east, ( pos.y * ( pos.x * ox.x + pos.z * ox.z ) / flat1 - flat1 * ox.y ) * south );
-	charts.mapDy = vec2( ( pos.z * oy.x - pos.x * oy.z ) * east, ( pos.y * ( pos.x * oy.x + pos.z * oy.z ) / flat1 - flat1 * oy.y ) * south );
+	map = mat3x2(
+		turn / ( 2.0 * PI ), drop / PI,
+		( pos.z * ox.x - pos.x * ox.z ) * east, ( pos.y * ( pos.x * ox.x + pos.z * ox.z ) / flat1 - flat1 * ox.y ) * south,
+		( 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, charts.side, charts.capAt, charts.capDx, charts.capDy );
-	return charts;
+	tileCap( dir, ddx, ddy, side, cap );
 }
 
 // Long and short half-axes of the footprint whose sides are fx and fy. The
@@ -12182,12 +13300,13 @@ void tileAxes( vec2 fx, vec2 fy, out vec2 major, out vec2 minor ) {
 // home is the point that the charts count the map from, in tiles from the
 // window's north-west corner. Gives the fragment's place in the window's
 // texture, in tiles, and the axes of its footprint, in the window's pixels.
-float tileWindowWeight( TileCharts charts, vec4 window, vec4 grid, vec2 home, vec2 tileFilter, out vec2 spot, out vec2 major, out vec2 minor ) {
+float tileWindowWeight( mat3x2 map, mat3x2 cap, float side, vec4 window, vec4 grid, vec2 home, vec2 tileFilter, out vec2 spot, out vec2 major, out vec2 minor ) {
 	bool onMap = window.x < 0.5;
 	// The other pole's cap.
-	if ( ! onMap && ( window.x < 1.5 ) != ( charts.side > 0.0 ) ) return 0.0;
-	vec2 dx = ( onMap ? charts.mapDx : charts.capDx ) * grid.xy * tileFilter.y;
-	vec2 dy = ( onMap ? charts.mapDy : charts.capDy ) * grid.xy * tileFilter.y;
+	if ( ! onMap && ( window.x < 1.5 ) != ( side > 0.0 ) ) return 0.0;
+	mat3x2 chart = onMap ? map : cap;
+	vec2 dx = chart[ 1 ] * grid.xy * tileFilter.y;
+	vec2 dy = chart[ 2 ] * grid.xy * tileFilter.y;
 
 	// Level this fragment asks of the window, from the short axis of its
 	// footprint in the window's pixels: the long axis is the anisotropic
@@ -12200,7 +13319,7 @@ float tileWindowWeight( TileCharts charts, vec4 window, vec4 grid, vec2 home, ve
 
 	float rows = ${4 .toFixed(1)};
 	// Offset from the window's north-west corner, in tiles.
-	vec2 rel = onMap ? home + charts.mapAt * grid.xy : charts.capAt * grid.xy - grid.zw;
+	vec2 rel = onMap ? home + chart[ 0 ] * grid.xy : chart[ 0 ] * grid.xy - grid.zw;
 	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.
@@ -12398,6 +13517,11 @@ function disposeChain(chain) {
 	chain.uniforms.map.value = null;
 	chain.uniforms.mask.value = null;
 }
+function chainSettled(chain, tiles) {
+	const store = chain.store;
+	if (!store || chain.dead || chain.uniforms.window.value[0].w === 0) return true;
+	return store.windows.every((win) => settled(chain, store, tiles, win));
+}
 function restChain(chain, now) {
 	switchOff(chain);
 	if (now - chain.lastUsed > IDLE_DISPOSE_S * 1e3) disposeChain(chain);
@@ -12511,40 +13635,35 @@ float reliefValue( vec4 texel ) {
 	return dot( texel, uReliefRead );
 }
 
-// How the coordinates of each chart change along the sphere at a direction:
-// the dot product with a step along the sphere is that step on the chart.
-struct ReliefRates {
-	vec3 mapX;
-	vec3 mapY;
-	vec3 capX;
-	vec3 capY;
-};
-
-ReliefRates reliefRates( vec3 dir, float side ) {
-	ReliefRates rates;
+// How the coordinates of each chart change along the sphere at a direction,
+// as a mat2x3 per chart: a step along the sphere times it is that step on the
+// chart, and it times a step on the chart is that step along the sphere.
+void reliefRates( vec3 dir, float side, out mat2x3 map, out mat2x3 cap ) {
 	float flat2 = max( dir.x * dir.x + dir.z * dir.z, 1e-12 );
-	rates.mapX = vec3( dir.z, 0.0, - dir.x ) / ( 2.0 * PI * flat2 );
-	rates.mapY = ( dir * dir.y - vec3( 0.0, 1.0, 0.0 ) ) / ( PI * sqrt( flat2 ) );
+	map = mat2x3(
+		vec3( dir.z, 0.0, - dir.x ) / ( 2.0 * PI * flat2 ),
+		( dir * dir.y - vec3( 0.0, 1.0, 0.0 ) ) / ( PI * sqrt( flat2 ) )
+	);
 	float fold = 1.0 + side * dir.y;
 	float capScale = 0.5 / ( ${CAP_EDGE.toFixed(8)} * fold );
 	vec2 plane = vec2( dir.x, side * dir.z ) * side / fold;
-	rates.capX = vec3( 1.0, - plane.x, 0.0 ) * capScale;
-	rates.capY = vec3( 0.0, - plane.y, side ) * capScale;
-	rates.capX -= dir * dot( rates.capX, dir );
-	rates.capY -= dir * dot( rates.capY, dir );
-	return rates;
+	vec3 capX = vec3( 1.0, - plane.x, 0.0 ) * capScale;
+	vec3 capY = vec3( 0.0, - plane.y, side ) * capScale;
+	cap = mat2x3( capX - dir * dot( capX, dir ), capY - dir * dot( capY, dir ) );
 }
 
 // Slope of the ground at a direction of the body's frame: a vector along the
 // unit sphere that points uphill, as long as the rise over the run. Also
 // gives the part of the fragment that the tiles answer for, and the finest
 // window that does, or -1.
-vec3 reliefTileSlope( vec3 dir, TileCharts charts, out float covered, out int first ) {
+vec3 reliefTileSlope( vec3 dir, mat3x2 map, mat3x2 cap, float side, out float covered, out int first ) {
 	covered = 0.0;
 	first = - 1;
 	vec3 slope = vec3( 0.0 );
 	if ( uReliefWindow[ 0 ].w < 0.5 ) return slope;
-	ReliefRates rates = reliefRates( dir, charts.side );
+	mat2x3 mapRates;
+	mat2x3 capRates;
+	reliefRates( dir, side, mapRates, capRates );
 
 	float rows = ${4 .toFixed(1)};
 	for ( int i = 0; i < ${7}; i ++ ) {
@@ -12554,7 +13673,7 @@ vec3 reliefTileSlope( vec3 dir, TileCharts charts, out float covered, out int fi
 		vec2 spot;
 		vec2 major;
 		vec2 minor;
-		float alpha = tileWindowWeight( charts, window, grid, uReliefHome[ i ], uReliefFilter, spot, major, minor );
+		float alpha = tileWindowWeight( map, cap, side, window, grid, uReliefHome[ i ], uReliefFilter, spot, major, minor );
 		if ( alpha <= 0.0 ) continue;
 		// Filtered, the mask falls towards a missing tile. The pixels beside
 		// one are left out: their slope would read its blank slot.
@@ -12573,8 +13692,7 @@ vec3 reliefTileSlope( vec3 dir, TileCharts charts, out float covered, out int fi
 			reliefValue( textureGrad( uReliefMap, st + east, gx, gy ) ) - reliefValue( textureGrad( uReliefMap, st - east, gx, gy ) ),
 			reliefValue( textureGrad( uReliefMap, st + south, gx, gy ) ) - reliefValue( textureGrad( uReliefMap, st - south, gx, gy ) )
 		) * 0.5 * grid.xy * uReliefFilter.y;
-		bool onMap = window.x < 0.5;
-		vec3 uphill = rise.x * ( onMap ? rates.mapX : rates.capX ) + rise.y * ( onMap ? rates.mapY : rates.capY );
+		vec3 uphill = ( window.x < 0.5 ? mapRates : capRates ) * rise;
 		slope += ( 1.0 - covered ) * alpha * uphill;
 		covered += ( 1.0 - covered ) * alpha;
 		if ( covered > 0.995 ) break;
@@ -12586,25 +13704,14 @@ function shadowGlsl(steps) {
 	return `
 // One window as a shadow ray reads it. The ray is a line on the window's
 // chart, so where it is inside the window is worked out once, not at each
-// sample.
-struct ReliefSight {
-	// The fragment in the window's texture, with its layer, and how far the
-	// ray goes there in a radian.
-	vec3 from;
-	vec2 rate;
-	// The part of the ray inside the window, in radians along it.
-	float enters;
-	float leaves;
-	// The longest step that the window's pixels still hold, and the step from
-	// which the ray reads the next window.
-	float widest;
-	float hands;
-	// How far from the fragment the next window can be read at all.
-	float beyond;
-	int loaded;
-};
-
-ReliefSight reliefSight( int i, TileCharts charts, vec2 mapStep, vec2 capStep ) {
+// sample. 'sight' holds what a sample reads, as a mat2x4 and not a struct
+// (see the chain code): the fragment's place in the window's texture and how
+// far the ray goes there in a radian; then the part of the ray inside the
+// window, in radians along it, the window's layer and its tiles that are in,
+// a bit each. 'widest' is the longest step that the window's pixels still
+// hold, 'hands' the step from which the ray reads the next window, and
+// 'beyond' how far from the fragment the next window can be read at all.
+void reliefSight( int i, mat3x2 map, mat3x2 cap, float side, vec2 mapStep, vec2 capStep, out mat2x4 sight, out float widest, out float hands, out float beyond ) {
 	vec4 window = uReliefWindow[ i ];
 	vec4 grid = uReliefGrid[ i ];
 	bool onMap = window.x < 0.5;
@@ -12612,7 +13719,7 @@ ReliefSight reliefSight( int i, TileCharts charts, vec2 mapStep, vec2 capStep )
 	// 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 ] + charts.mapAt * grid.xy : charts.capAt * grid.xy - grid.zw;
+	vec2 rel = onMap ? uReliefHome[ i ] + map[ 0 ] * grid.xy : cap[ 0 ] * grid.xy - grid.zw;
 	vec2 rate = ( onMap ? mapStep : capStep ) * grid.xy;
 
 	// Half a pixel in from the window's sides: past it the filter reads the
@@ -12624,51 +13731,50 @@ ReliefSight reliefSight( int i, TileCharts charts, vec2 mapStep, vec2 capStep )
 	vec2 near = min( a, b );
 	vec2 far = max( a, b );
 
-	ReliefSight sight;
 	// The texture repeats every window. The tile index of a patch alone takes
 	// all the digits of a float: only its place in the window is added.
 	vec2 slot = rel + mod( grid.zw, rows );
-	sight.from = vec3( slot.x / rows, - slot.y / rows, window.y );
-	sight.rate = vec2( rate.x, - rate.y ) / rows;
-	sight.enters = max( near.x, near.y );
-	sight.leaves = min( far.x, far.y );
+	float leaves = min( far.x, far.y );
 	// The other pole's cap holds none of the ray.
-	if ( ! onMap && ( window.x < 1.5 ) != ( charts.side > 0.0 ) ) sight.leaves = - 1.0;
-	sight.widest = ${STEP_PIXELS.toFixed(2)} * PI / ( uReliefFilter.y * exp2( window.z ) );
+	if ( ! onMap && ( window.x < 1.5 ) != ( side > 0.0 ) ) leaves = - 1.0;
+	sight = mat2x4(
+		slot.x / rows, - slot.y / rows, rate.x / rows, - rate.y / rows,
+		max( near.x, near.y ), leaves, window.y, float( uReliefLoaded[ i ] )
+	);
+	widest = ${STEP_PIXELS.toFixed(2)} * PI / ( uReliefFilter.y * exp2( window.z ) );
 	// Near a patch the next window can be some levels coarser. The ray then
 	// stays here until its step is half of what that window holds: too wide
 	// for these pixels, but they are the same ground as the fragment's. The
 	// pyramid around a patch is not: it has none of the hills that only the
 	// patch resolves, and close to the fragment it would stand in the ray.
-	sight.hands = sight.widest;
-	sight.beyond = 0.0;
+	hands = widest;
+	beyond = 0.0;
 	if ( i + 1 < ${7} ) {
 		float next = PI / ( uReliefFilter.y * exp2( uReliefWindow[ i + 1 ].z ) );
-		sight.hands = max( sight.hands, 0.5 * ${STEP_PIXELS.toFixed(2)} * next );
+		hands = max( hands, 0.5 * ${STEP_PIXELS.toFixed(2)} * next );
 		// Within half a pixel of a window, its height is that of the fragment's
 		// own pixel, and the fragment stands above or below that by all the
 		// relief that the pixel averages away.
-		sight.beyond = 0.5 * next;
+		beyond = 0.5 * next;
 	}
-	sight.loaded = uReliefLoaded[ i ];
-	return sight;
 }
 
 // Height of the ground 't' radians along the ray, as a part of the pyramid's
 // range. Negative where the window does not hold that ground.
-float reliefSightValue( ReliefSight sight, float t ) {
-	if ( t < sight.enters || t > sight.leaves ) return - 1.0;
-	vec2 st = sight.from.xy + t * sight.rate;
+float reliefSightValue( mat2x4 sight, float t ) {
+	if ( t < sight[ 1 ].x || t > sight[ 1 ].y ) return - 1.0;
+	vec2 st = sight[ 0 ].xy + t * sight[ 0 ].zw;
 	// Both tiles that the filter can read must be in.
-	if ( sight.loaded != ${(1 << 4 * 4) - 1} ) {
+	if ( sight[ 1 ].w != ${((1 << 4 * 4) - 1).toFixed(1)} ) {
+		int loaded = int( sight[ 1 ].w );
 		vec2 tile = vec2( st.x, - st.y ) * ${4 .toFixed(1)};
 		float inset = 0.5 / uReliefFilter.y;
 		ivec2 a = ivec2( floor( tile - inset ) ) & ${4 - 1};
 		ivec2 b = ivec2( floor( tile + inset ) ) & ${4 - 1};
-		int both = ( sight.loaded >> ( a.x + ${4} * a.y ) ) & ( sight.loaded >> ( b.x + ${4} * b.y ) );
+		int both = ( loaded >> ( a.x + ${4} * a.y ) ) & ( loaded >> ( b.x + ${4} * b.y ) );
 		if ( ( both & 1 ) == 0 ) return - 1.0;
 	}
-	return reliefValue( textureLod( uReliefMap, vec3( st, sight.from.z ), 0.0 ) );
+	return reliefValue( textureLod( uReliefMap, vec3( st, sight[ 1 ].z ), 0.0 ) );
 }
 
 // Part of the Sun's disc that the ground leaves in sight of the fragment at
@@ -12681,23 +13787,28 @@ float reliefSightValue( ReliefSight sight, float t ) {
 // read from the window whose pixels are about as wide as the step. A shadow
 // is then sharp beside what casts it, at a cost that does not grow with its
 // length.
-float reliefTileShadow( vec3 dir, TileCharts charts, vec3 toSun, float tanElev, float sunSize, int first ) {
-	ReliefRates rates = reliefRates( dir, charts.side );
-	vec2 mapStep = vec2( dot( rates.mapX, toSun ), dot( rates.mapY, toSun ) );
-	vec2 capStep = vec2( dot( rates.capX, toSun ), dot( rates.capY, toSun ) );
+float reliefTileShadow( vec3 dir, mat3x2 map, mat3x2 cap, float side, vec3 toSun, float tanElev, float sunSize, int first ) {
+	mat2x3 mapRates;
+	mat2x3 capRates;
+	reliefRates( dir, side, mapRates, capRates );
+	vec2 mapStep = toSun * mapRates;
+	vec2 capStep = toSun * capRates;
 
 	int drawn = 0;
 	for ( int i = 0; i < ${7}; i ++ ) {
 		if ( uReliefWindow[ i ].w > 0.5 ) drawn = i + 1;
 	}
 	int w = first;
-	ReliefSight sight;
+	mat2x4 sight;
+	float widest;
+	float hands;
+	float beyond;
 	float own = - 1.0;
 	for ( int i = 0; i < ${7}; i ++ ) {
 		if ( i < first ) continue;
 		if ( i >= drawn ) break;
 		w = i;
-		sight = reliefSight( i, charts, mapStep, capStep );
+		reliefSight( i, map, cap, side, mapStep, capStep, sight, widest, hands, beyond );
 		own = reliefSightValue( sight, 0.0 );
 		if ( own >= 0.0 ) break;
 	}
@@ -12714,7 +13825,7 @@ float reliefTileShadow( vec3 dir, TileCharts charts, vec3 toSun, float tanElev,
 	// The ratio that takes steps from one pixel to the reach: 'rate' is its
 	// logarithm times the count, and solves rate / ( exp( rate ) - 1 ) = part.
 	float count = ${steps.toFixed(1)};
-	float pixel = sight.widest / ${STEP_PIXELS.toFixed(2)};
+	float pixel = widest / ${STEP_PIXELS.toFixed(2)};
 	float part = count * pixel / reach;
 	float rate = 0.0;
 	if ( part < 1.0 ) {
@@ -12738,16 +13849,16 @@ float reliefTileShadow( vec3 dir, TileCharts charts, vec3 toSun, float tanElev,
 	for ( int i = 1; i <= ${steps}; i ++ ) {
 		float before = t;
 		t = t * ratio + head;
-		if ( w + 1 < drawn && t - before > sight.hands ) {
+		if ( w + 1 < drawn && t - before > hands ) {
 			w ++;
-			sight = reliefSight( w, charts, mapStep, capStep );
+			reliefSight( w, map, cap, side, mapStep, capStep, sight, widest, hands, beyond );
 		}
 		float value = reliefSightValue( sight, t );
 		// The ray left this window, or a tile of it is missing.
 		if ( value < 0.0 && w + 1 < drawn ) {
-			if ( t < sight.beyond ) continue;
+			if ( t < beyond ) continue;
 			w ++;
-			sight = reliefSight( w, charts, mapStep, capStep );
+			reliefSight( w, map, cap, side, mapStep, capStep, sight, widest, hands, beyond );
 			value = reliefSightValue( sight, t );
 		}
 		if ( value < 0.0 ) continue;
@@ -12769,19 +13880,19 @@ float reliefTileShadow( vec3 dir, TileCharts charts, vec3 toSun, float tanElev,
 	float crest = ${(STEEPEST * .5).toFixed(2)} * around / max( worst, 1e-9 ) * perDisc;
 	if ( hidden < 1.0 && hidden + crest > - 1.0 ) {
 		w = worstWindow;
-		sight = reliefSight( w, charts, mapStep, capStep );
+		reliefSight( w, map, cap, side, mapStep, capStep, sight, widest, hands, beyond );
 		for ( int k = 0; k < ${REFINE_STEPS}; k ++ ) {
 			around *= 0.5;
-			if ( w > start && around < sight.widest ) {
+			if ( w > start && around < widest ) {
 				w --;
-				sight = reliefSight( w, charts, mapStep, capStep );
+				reliefSight( w, map, cap, side, mapStep, capStep, sight, widest, hands, beyond );
 			}
 			float centre = worst;
 			for ( int e = 0; e < 2; e ++ ) {
 				float at = centre + ( e == 0 ? - around : around );
 				// Nearer than a pixel, the window holds no crest: only the slope
 				// of the fragment's own ground, which is the normal's to light.
-				if ( at < sight.widest * ${(1 / STEP_PIXELS).toFixed(4)} ) continue;
+				if ( at < widest * ${(1 / STEP_PIXELS).toFixed(4)} ) continue;
 				float value = reliefSightValue( sight, at );
 				if ( value < 0.0 ) continue;
 				float stands = ( ( value - own ) * uReliefScale / at - tanElev - 0.5 * at ) * perDisc;
@@ -12895,7 +14006,7 @@ var TILE_LIGHT = `
 							float up = dot(sunward, selfDir);
 							vec3 along = sunward - selfDir * up;
 							float run = length(along);
-							if (run > 1e-4) tileLight = reliefTileShadow(selfDir, selfCharts, along / run, up / run, uSelfSunSize, selfFirst);
+							if (run > 1e-4) tileLight = reliefTileShadow(selfDir, selfMap, selfCap, selfSide, along / run, up / run, uSelfSunSize, selfFirst);
 							if (tileLight < 0.0) byTiles = 0.0;
 						}`;
 function attachSelfShadowToBody(material, heightMap, scaleScene, sunDir, tiles) {
@@ -13029,10 +14140,10 @@ function attachSelfShadowToBody(material, heightMap, scaleScene, sunDir, tiles)
 				vec3 selfDir = normalize(vSelfDir);
 				// The part of the fragment that the tiles answer for.
 				float selfCovered = 0.0;
-				${tiles ? "TileCharts selfCharts = tileChartsFrom(uReliefAnchor, vReliefOff);\n				int selfFirst = -1;" : ""}
+				${tiles ? "mat3x2 selfMap;\n				mat3x2 selfCap;\n				float selfSide;\n				tileChartsFrom(uReliefAnchor, vReliefOff, selfMap, selfCap, selfSide);\n				int selfFirst = -1;" : ""}
 				{
 					vec3 slope = vec3(0.0);
-					${tiles ? "slope = reliefTileSlope(selfDir, selfCharts, selfCovered, selfFirst);" : ""}
+					${tiles ? "slope = reliefTileSlope(selfDir, selfMap, selfCap, selfSide, selfCovered, selfFirst);" : ""}
 					if (selfCovered < 0.995 && uSelfScale > 0.0) slope += (1.0 - selfCovered) * selfMapSlope(selfDir);
 					float steep = length(slope);
 					if (steep > ${SLOPE_CLAMP.toFixed(3)}) slope *= ${SLOPE_CLAMP.toFixed(3)} / steep;
@@ -13125,34 +14236,23 @@ async function readHeightRows(bitmap, y0, y1) {
 	}
 	return out;
 }
+var PYRAMID_TIER = "pyramid";
+var pyramidFailed = /* @__PURE__ */ new WeakSet();
+function pyramidHeightsServe(bo, renderer) {
+	const tiles = bo.displacementMeta?.tiles;
+	return !!tiles && tiles.scale_km !== void 0 && tilesBase() !== "" && textureAllowed(tiles.distribution) && renderer.extensions.has("OES_texture_float_linear") && !pyramidFailed.has(bo);
+}
 async function swapDisplacementTier(bo, tier) {
 	const meta = bo.displacementMeta;
 	if (!meta || !bo.mesh || bo.displacementLoading || bo.displacementTier === tier) return;
 	bo.displacementLoading = true;
 	try {
-		const bitmap = await fetchHeightBitmap(displacementTierUrl(meta, tier));
-		if (!bitmap) return;
-		const w = bitmap.width;
-		const h = bitmap.height;
-		const rows = await readHeightRows(bitmap, 0, h - 1);
-		bitmap.close();
-		if (!rows) return;
-		if (!bo.mesh || !bo.displacementMap) return;
-		const tmp = new Uint8Array(w);
-		for (let y = 0; y < h >> 1; y++) {
-			const top = rows.subarray(y * w, (y + 1) * w);
-			const bottom = rows.subarray((h - 1 - y) * w, (h - y) * w);
-			tmp.set(top);
-			top.set(bottom);
-			bottom.set(tmp);
-		}
-		const tex = new DataTexture(rows, w, h, RedFormat, UnsignedByteType);
-		tex.colorSpace = NoColorSpace;
-		tex.magFilter = LinearFilter;
-		tex.minFilter = LinearFilter;
-		tex.generateMipmaps = false;
-		tex.unpackAlignment = 1;
-		tex.needsUpdate = true;
+		const tex = tier === "pyramid" ? await pyramidMap(bo, meta) : await tierMap(meta, tier);
+		if (!tex) return;
+		if (!bo.mesh || !bo.displacementMap) {
+			tex.dispose();
+			return;
+		}
 		const material = bo.mesh.material;
 		const old = material.displacementMap;
 		material.displacementMap = tex;
@@ -13164,6 +14264,96 @@ async function swapDisplacementTier(bo, tier) {
 		bo.displacementLoading = false;
 	}
 }
+async function tierMap(meta, tier) {
+	const bitmap = await fetchHeightBitmap(displacementTierUrl(meta, tier));
+	if (!bitmap) return null;
+	const w = bitmap.width;
+	const h = bitmap.height;
+	const rows = await readHeightRows(bitmap, 0, h - 1);
+	bitmap.close();
+	if (!rows) return null;
+	const tmp = new Uint8Array(w);
+	for (let y = 0; y < h >> 1; y++) {
+		const top = rows.subarray(y * w, (y + 1) * w);
+		const bottom = rows.subarray((h - 1 - y) * w, (h - y) * w);
+		tmp.set(top);
+		top.set(bottom);
+		bottom.set(tmp);
+	}
+	const tex = new DataTexture(rows, w, h, RedFormat, UnsignedByteType);
+	tex.colorSpace = NoColorSpace;
+	tex.magFilter = LinearFilter;
+	tex.minFilter = LinearFilter;
+	tex.generateMipmaps = false;
+	tex.unpackAlignment = 1;
+	tex.needsUpdate = true;
+	return tex;
+}
+async function pyramidMap(bo, meta) {
+	if (!meta.tiles) return null;
+	try {
+		return await pyramidHeights(meta, meta.tiles);
+	} catch (err) {
+		console.warn(`Failed to load the height pyramid of ${meta.id}:`, err);
+		pyramidFailed.add(bo);
+		return null;
+	}
+}
+async function pyramidHeights(meta, tiles) {
+	const signal = new AbortController().signal;
+	const halves = await Promise.all([0, 1].map((x) => loadHeightTile(tileUrl(tiles, "", 0, x, 0), true, signal)));
+	const size = halves[0].size;
+	const width = 2 * size;
+	const data = new Float32Array(width * size);
+	const gain = (tiles.scale_km ?? 0) / 65535 / meta.scale_km;
+	const offset = ((tiles.bias_km ?? 0) - meta.bias_km) / meta.scale_km;
+	halves.forEach(({ heights }, x) => {
+		for (let row = 0; row < size; row++) {
+			const src = row * size;
+			const dst = row * width + x * size;
+			for (let i = 0; i < size; i++) data[dst + i] = heights[src + i] * gain + offset;
+		}
+	});
+	const tex = new DataTexture(data, width, size, RedFormat, FloatType);
+	tex.colorSpace = NoColorSpace;
+	tex.magFilter = LinearFilter;
+	tex.minFilter = LinearMipmapLinearFilter;
+	tex.generateMipmaps = false;
+	tex.mipmaps = mipChain(data, width, size);
+	tex.needsUpdate = true;
+	return tex;
+}
+function mipChain(data, width, height) {
+	const chain = [{
+		data,
+		width,
+		height
+	}];
+	while (width > 1 || height > 1) {
+		const w = Math.max(1, width >> 1);
+		const h = Math.max(1, height >> 1);
+		const sx = width / w;
+		const sy = height / h;
+		const out = new Float32Array(w * h);
+		for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+			let sum = 0;
+			for (let dy = 0; dy < sy; dy++) {
+				const row = (y * sy + dy) * width + x * sx;
+				for (let dx = 0; dx < sx; dx++) sum += data[row + dx];
+			}
+			out[y * w + x] = sum / (sx * sy);
+		}
+		chain.push({
+			data: out,
+			width: w,
+			height: h
+		});
+		data = out;
+		width = w;
+		height = h;
+	}
+	return chain;
+}
 function bilinearHeightTexel(data, w, h, fx, fy) {
 	const x0 = Math.floor(fx);
 	const y0 = Math.floor(fy);
@@ -13177,7 +14367,8 @@ function bilinearHeightTexel(data, w, h, fx, fy) {
 	const r1 = clampRow(y0 + 1) * w;
 	const top = data[r0 + c0] * (1 - tx) + data[r0 + c1] * tx;
 	const bot = data[r1 + c0] * (1 - tx) + data[r1 + c1] * tx;
-	return (top * (1 - ty) + bot * ty) / 255;
+	const texel = top * (1 - ty) + bot * ty;
+	return data instanceof Float32Array ? texel : texel / 255;
 }
 function disposeDisplacementFromMaterial(material) {
 	if (!material.displacementMap) return;
@@ -13367,8 +14558,9 @@ function loadLowField(bodyId, meta) {
 function heightFieldFor(bo, bodyId) {
 	const image = bo.displacementMap?.image;
 	if (!image) return null;
-	if (image.data instanceof Uint8Array && image.width && image.height) return {
-		data: image.data,
+	const data = image.data;
+	if ((data instanceof Uint8Array || data instanceof Float32Array) && image.width && image.height) return {
+		data,
 		width: image.width,
 		height: image.height,
 		bottomUp: true
@@ -13864,20 +15056,24 @@ var AttitudeTrack = class {
 		this.files = manifest.files;
 	}
 	covers(jd) {
-		return jd >= this.startJd && jd <= this.endJd && this.files.length > 0;
+		return this.coversTdb(utcToTdb(jd));
+	}
+	coversTdb(tdb) {
+		return tdb >= this.startJd && tdb <= this.endJd && this.files.length > 0;
 	}
 	orientationAt(jd, out) {
-		if (!this.covers(jd)) return false;
-		const ci = this.fileIndexFor(jd);
+		const tdb = utcToTdb(jd);
+		if (!this.coversTdb(tdb)) return false;
+		const ci = this.fileIndexFor(tdb);
 		const chunk = this.ensure(ci);
 		if (!chunk) return false;
 		this.ensure(ci - 1);
 		this.ensure(ci + 1);
-		this.sampleChunk(jd, ci, chunk);
+		this.sampleChunk(tdb, ci, chunk);
 		const baseline = this.baselines?.[this.files[ci].baseline_index ?? 0];
 		if (baseline) {
 			const { axis, rate_rad_s, anchor, anchor_jd } = baseline;
-			const tSeconds = (jd - anchor_jd) * SECONDS_PER_DAY;
+			const tSeconds = (tdb - anchor_jd) * SECONDS_PER_DAY;
 			_baselineAxis.set(axis[0], axis[1], axis[2]);
 			_qBaseline.setFromAxisAngle(_baselineAxis, rate_rad_s * tSeconds);
 			_qb.set(anchor[1], anchor[2], anchor[3], anchor[0]);
@@ -14152,29 +15348,6 @@ function setSurfaceMap(material, map, tintHex) {
 	material.needsUpdate = true;
 }
 
-//#endregion
-//#region src/lib/scene/objects/body/shape-model-policy.ts
-var PREFER_MODEL_OVER_DEM = /* @__PURE__ */ new Set([]);
-function shapeModelSkipReason(global) {
-	if (!global?.model_name) return "no-bundle";
-	if (isLowEndDevice() && global.render_quality !== "high") return "low-end-device";
-	if (global.displacement && !PREFER_MODEL_OVER_DEM.has(global.id)) return "dem-preferred";
-	return null;
-}
-
-//#endregion
-//#region src/lib/scene/objects/body/orientation-apply.ts
-function applyBodyOrientation(body, orientation, ctx, systemId) {
-	body.orientation = orientation;
-	if (ctx) ctx.bodies.dataVersion++;
-	ctx?.credits.registerOrientation({
-		bodyId: body.data.id,
-		systemId: systemId ?? body.data.id,
-		source: orientation.source,
-		reference: orientation.reference
-	});
-}
-
 //#endregion
 //#region src/lib/scene/objects/surface/photometry.ts
 var WEIGHT_POLY = [
@@ -14184,16 +15357,24 @@ var WEIGHT_POLY = [
 ];
 var GRAZE_FLOOR = .05;
 var LUNAR_LAMBERT_GLSL = `
-	float lunarLambertWeight(float phaseDeg) {
-		return clamp(1.0 + phaseDeg * (${WEIGHT_POLY[0].toFixed(8)} + phaseDeg * (${WEIGHT_POLY[1].toFixed(8)} + phaseDeg * ${WEIGHT_POLY[2].toFixed(8)})), 0.0, 1.0);
+	float lunarLambertWeight(float phaseDeg, float scale) {
+		return min(scale * clamp(1.0 + phaseDeg * (${WEIGHT_POLY[0].toFixed(8)} + phaseDeg * (${WEIGHT_POLY[1].toFixed(8)} + phaseDeg * ${WEIGHT_POLY[2].toFixed(8)})), 0.0, 1.0), 1.0);
 	}
 
-	float lunarLambertGain(float phaseDeg, float mu0, float mu) {
-		float weight = lunarLambertWeight(phaseDeg);
+	float lunarLambertGain(float phaseDeg, float mu0, float mu, float scale) {
+		float weight = lunarLambertWeight(phaseDeg, scale);
 		float sun = max(mu0, 0.0);
 		return 2.0 * weight / max(sun + max(mu, sun), ${GRAZE_FLOOR.toFixed(3)}) + 1.0 - weight;
 	}
 `;
+function makePhotometryUniforms(scale) {
+	return { uLunarWeightScale: { value: scale ?? 1 } };
+}
+function lunarLambertWeight(phaseDeg, scale) {
+	const [a, b, c] = WEIGHT_POLY;
+	const moon = Math.min(1, Math.max(0, 1 + phaseDeg * (a + phaseDeg * (b + phaseDeg * c))));
+	return Math.min(1, scale * moon);
+}
 var DRY_GROUND = `
 	#ifdef USE_ROUGHNESSMAP
 		reflectedLight.directSpecular *= texelRoughness.g;
@@ -14212,18 +15393,20 @@ var LUNAR_LAMBERT = `
 		reflectedLight.directDiffuse *= lunarLambertGain(
 			phaseDeg,
 			dot(geometryNormal, sunView),
-			dot(geometryNormal, geometryViewDir)
+			dot(geometryNormal, geometryViewDir),
+			uLunarWeightScale
 		);
 	}
 `;
-function attachSurfacePhotometry(material, bodyId, sunDir) {
+function attachSurfacePhotometry(material, bodyId, uniforms, sunDir) {
 	const airless = !getAtmosphereParams(bodyId);
 	chainShaderHook(material, airless ? "photometryAirless" : "photometry", (shader) => {
 		let pars = "";
 		let light = DRY_GROUND;
 		if (airless) {
 			shader.uniforms.uPhotometrySunDir = sunDir ?? getEclipseSceneUniforms().uSunDir;
-			pars = `uniform vec3 uPhotometrySunDir;\n${LUNAR_LAMBERT_GLSL}`;
+			Object.assign(shader.uniforms, uniforms);
+			pars = `uniform vec3 uPhotometrySunDir;\nuniform float uLunarWeightScale;\n${LUNAR_LAMBERT_GLSL}`;
 			light += LUNAR_LAMBERT;
 		}
 		shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>\n${pars}`).replace("#include <lights_fragment_end>", `#include <lights_fragment_end>\n${light}`);
@@ -14231,92 +15414,60 @@ function attachSurfacePhotometry(material, bodyId, sunDir) {
 }
 
 //#endregion
-//#region src/lib/scene/objects/surface/planetshine.ts
-var MAX_SHINERS = 2;
-var SHINE_FLOOR = 1e-4;
-function lambertSpherePhase(a) {
-	return (Math.sin(a) + (Math.PI - a) * Math.cos(a)) / Math.PI;
-}
-function planetshineFraction(radius, distance, a) {
-	const k = radius / distance;
-	return 2 / 3 * lambertSpherePhase(a) * k * k;
+//#region src/lib/scene/objects/body/surface-albedo.ts
+var UNKNOWN_SURFACE_COLOR = "#6b6b6b";
+function luminance$1(c) {
+	return .2126 * c.r + .7152 * c.g + .0722 * c.b;
+}
+function discAlbedoPerColour(airless, lunarWeightScale) {
+	if (!airless) return 2 / 3;
+	return (2 + lunarLambertWeight(0, lunarWeightScale ?? 1)) / 3;
+}
+var _hex = new Color();
+function surfaceAlbedoTarget(body) {
+	if (!body.color) return null;
+	return (body.geometricAlbedo ?? luminance$1(_hex.set(body.color))) / discAlbedoPerColour(!getAtmosphereParams(body.id), body.lunarWeightScale);
+}
+function untexturedSurfaceColour(body, out = new Color()) {
+	const target = surfaceAlbedoTarget(body);
+	if (target === null) return out.set(UNKNOWN_SURFACE_COLOR);
+	out.set(body.color);
+	return out.multiplyScalar(target / luminance$1(out));
+}
+function shinerAlbedo(body, map, out) {
+	if (body.color) out.set(body.color);
+	else if (body.geometricAlbedo === void 0) return null;
+	else {
+		const mean = map && meanMapColor(map);
+		if (mean) out.copy(mean);
+		else out.setRGB(1, 1, 1);
+	}
+	const albedo = body.geometricAlbedo ?? luminance$1(out);
+	return out.multiplyScalar(1.5 * albedo / luminance$1(out));
 }
-var PLANETSHINE_GLSL = `
-	#define PLANETSHINE_SHINERS ${2}
-	uniform vec4 uShineDir[PLANETSHINE_SHINERS];
-	uniform vec3 uShineLight[PLANETSHINE_SHINERS];
 
-	float sphereLightCosine(float cosTheta, float sinAlpha) {
-		float t = max(cosTheta + sinAlpha, 0.0);
-		return cosTheta >= sinAlpha ? cosTheta : t * t / (4.0 * sinAlpha);
-	}
-`;
-var PLANETSHINE_LIGHT = `
-	for (int i = 0; i < PLANETSHINE_SHINERS; i++) {
-		vec4 shiner = uShineDir[i];
-		// The slots fill in order, so the first empty slot ends the list.
-		if (shiner.w <= 0.0) break;
-		float cosine = sphereLightCosine(dot(geometryNormal, mat3(viewMatrix) * shiner.xyz), shiner.w);
-		reflectedLight.indirectDiffuse += uShineLight[i] * cosine * BRDF_Lambert(material.diffuseContribution);
-	}
-`;
-function makePlanetshineUniforms() {
-	return {
-		uShineDir: { value: Array.from({ length: 2 }, () => new Vector4(0, 0, 0, 0)) },
-		uShineLight: { value: Array.from({ length: 2 }, () => new Vector3()) }
-	};
+//#endregion
+//#region src/lib/scene/objects/body/shape-model-policy.ts
+var PREFER_MODEL_OVER_DEM = /* @__PURE__ */ new Set([]);
+function shapeModelSkipReason(global) {
+	if (!global?.model_name) return "no-bundle";
+	if (isLowEndDevice() && global.render_quality !== "high") return "low-end-device";
+	if (global.displacement && !PREFER_MODEL_OVER_DEM.has(global.id)) return "dem-preferred";
+	return null;
 }
-function attachPlanetshine(material, uniforms) {
-	const self = uniforms ?? makePlanetshineUniforms();
-	chainShaderHook(material, "planetshine", (shader) => {
-		Object.assign(shader.uniforms, self);
-		shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>\n${PLANETSHINE_GLSL}`).replace("#include <lights_fragment_end>", `#include <lights_fragment_end>\n${PLANETSHINE_LIGHT}`);
+
+//#endregion
+//#region src/lib/scene/objects/body/orientation-apply.ts
+function applyBodyOrientation(body, orientation, nutPrec, ctx, systemId) {
+	body.orientation = orientation;
+	body.nutPrec = nutPrecFor(body.data.id, nutPrec);
+	if (ctx) ctx.bodies.dataVersion++;
+	ctx?.credits.registerOrientation({
+		bodyId: body.data.id,
+		systemId: systemId ?? body.data.id,
+		source: orientation.source,
+		reference: orientation.reference
 	});
-	return self;
-}
-var _strength = new Float64Array(2);
-var _swapDir = new Vector4();
-var _swapLight = new Vector3();
-function selectShiners(out, x, y, z, shiners, count) {
-	const dirs = out.uShineDir.value;
-	const lights = out.uShineLight.value;
-	let kept = 0;
-	for (let i = 0; i < count; i++) {
-		const s = shiners[i];
-		const dx = s.x - x;
-		const dy = s.y - y;
-		const dz = s.z - z;
-		const d = Math.hypot(dx, dy, dz);
-		if (d <= s.radius) continue;
-		const k = s.radius / d;
-		if (2 / 3 * k * k < 1e-4) continue;
-		const cosPhase = -(dx * s.sunX + dy * s.sunY + dz * s.sunZ) / d;
-		const fraction = planetshineFraction(s.radius, d, Math.acos(Math.max(-1, Math.min(1, cosPhase))));
-		const strength = fraction * (.2126 * s.albedo.r + .7152 * s.albedo.g + .0722 * s.albedo.b);
-		if (strength < 1e-4) continue;
-		let slot = kept;
-		if (kept < 2) kept++;
-		else if (strength > _strength[2 - 1]) slot = 2 - 1;
-		else continue;
-		_strength[slot] = strength;
-		dirs[slot].set(dx / d, dy / d, dz / d, k);
-		lights[slot].set(s.albedo.r, s.albedo.g, s.albedo.b).multiplyScalar(s.sunlight * fraction);
-		for (; slot > 0 && _strength[slot - 1] < strength; slot--) {
-			_strength[slot] = _strength[slot - 1];
-			_strength[slot - 1] = strength;
-			_swapDir.copy(dirs[slot - 1]);
-			dirs[slot - 1].copy(dirs[slot]);
-			dirs[slot].copy(_swapDir);
-			_swapLight.copy(lights[slot - 1]);
-			lights[slot - 1].copy(lights[slot]);
-			lights[slot].copy(_swapLight);
-		}
-	}
-	for (let i = kept; i < 2; i++) {
-		dirs[i].set(0, 0, 0, 0);
-		lights[i].set(0, 0, 0);
-	}
-	return kept;
 }
 
 //#endregion
@@ -14647,7 +15798,11 @@ async function loadSpacecraftModel(bo, modelScene, ctx) {
 		bo.body.modelBaseFrame = baseFrame ?? void 0;
 		const root = withBaseFrame(gltf.scene, baseFrame);
 		const anchor = meta.model_anchor ? new Vector3(...meta.model_anchor) : null;
-		fitToUnitRadius(root, anchor && baseFrame ? anchor.applyQuaternion(baseFrame) : anchor);
+		if (!fitToUnitRadius(root, anchor && baseFrame ? anchor.applyQuaternion(baseFrame) : anchor)) {
+			disposeGltf(gltf.scene);
+			bo.noPhysical = "model";
+			return;
+		}
 		enableShadows(root);
 		modelScene.add(root);
 		root.visible = !bo.isCrashed;
@@ -14683,7 +15838,7 @@ async function loadNaturalBodyModel(bo, ctx) {
 			console.info(`Skipping ${detail.global?.render_quality ?? "unrated"} shape mesh for ${bo.body.data.id}: ${skip}`);
 			return;
 		}
-		if (detail.global?.orientation && !bo.body.orientation) applyBodyOrientation(bo.body, detail.global.orientation, ctx);
+		if (detail.global?.orientation && !bo.body.orientation) applyBodyOrientation(bo.body, detail.global.orientation, detail.global.nut_prec, ctx);
 		const metaPromise = fetchBundleMeta(slug);
 		const gltf = await _loader.loadAsync(versionedUrl(`/v1/models/${slug}/high.glb`, "models"));
 		if ((bo.modelLoadEpoch ?? 0) !== epoch) {
@@ -14703,14 +15858,18 @@ async function loadNaturalBodyModel(bo, ctx) {
 			return;
 		}
 		const root = gltf.scene;
-		fitToUnitRadius(root);
+		if (!fitToUnitRadius(root)) {
+			disposeGltf(gltf.scene);
+			return;
+		}
 		root.userData.radialIndex = buildRadialIndex(root);
-		const material = makeShapeModelMaterial(bo.body.data.color ?? bodyMeshColor(bo.body.data));
-		attachSurfacePhotometry(material, bo.body.data.id);
+		const material = makeShapeModelMaterial(untexturedSurfaceColour(bo.body.data));
+		bo.photometry ??= makePhotometryUniforms(bo.body.data.lunarWeightScale);
+		attachSurfacePhotometry(material, bo.body.data.id, bo.photometry);
 		bo.planetshine = attachPlanetshine(material, bo.planetshine ?? void 0);
 		applyShapeModelMaterial(root, material);
 		const sphereMap = bo.mesh ? bo.mesh.material.map : null;
-		if (sphereMap) setShapeModelMap(root, sphereMap, bodyMeshColor(bo.body.data), bo.body.data.color);
+		if (sphereMap) setShapeModelMap(root, sphereMap, untexturedSurfaceColour(bo.body.data), bo.body.data.color);
 		enableShadows(root);
 		attachModelEclipse(bo, root);
 		if (meta.true_scale) {
@@ -14796,7 +15955,7 @@ function fitToUnitRadius(root, anchor = null) {
 	const size = bbox.getSize(new Vector3());
 	const center = bbox.getCenter(new Vector3());
 	const maxDim = Math.max(size.x, size.y, size.z);
-	if (maxDim <= 0) return;
+	if (maxDim <= 0) return false;
 	const k = 2 / maxDim;
 	root.userData.boxCenter = center.clone().multiplyScalar(k);
 	if (anchor) center.addScaledVector(anchor, maxDim / 2);
@@ -14811,6 +15970,7 @@ function fitToUnitRadius(root, anchor = null) {
 	const offset = root.userData.centerOffset.length();
 	root.userData.minRadius = Math.max(0, fit.minRadius - offset);
 	root.userData.maxRadius = root.userData.halfExtents.length() + offset;
+	return true;
 }
 var OCCLUDER_SLICES = 8;
 var OCCLUDER_SAMPLE_TARGET = 4096;
@@ -14963,7 +16123,7 @@ function nomenclatureBodyId(focused, bodyObjects) {
 	if (bodyObjects.get(focused.data.id)?.isLanded) return focused.data.parentId;
 	return focused.data.id;
 }
-var DEG2RAD$5 = Math.PI / 180;
+var DEG2RAD$4 = Math.PI / 180;
 var MIN_BODY_SCREEN_RADIUS_PX = 128;
 var LABEL_DISC_FRACTION = .9;
 var MIN_FEATURE_PX = 24;
@@ -15016,8 +16176,8 @@ async function attachNomenclatureLabels(bo, canvas, onFeatureSelect) {
 		let dispKm = null;
 		if (detail.global.displacement) {
 			dispKm = await displacementsKmAt(bo, bo.body.data.id, detail.global.displacement, effectiveRadiusKm(bo.body.data), renderable.map((f) => ({
-				latRad: f.lat * DEG2RAD$5,
-				lonRad: f.lon * DEG2RAD$5
+				latRad: f.lat * DEG2RAD$4,
+				lonRad: f.lon * DEG2RAD$4
 			})));
 			if (bo.nomenclatureLabels || !bo.mesh) return;
 		}
@@ -15041,7 +16201,7 @@ async function attachNomenclatureLabels(bo, canvas, onFeatureSelect) {
 		el.dataset.featureId = String(feature.featureId);
 		attachCanvasForwarders(el, canvas);
 		if (onFeatureSelect) onTapNotDrag(el, () => onFeatureSelect(feature.featureId, feature.lat, feature.lon, effDiam));
-		const [ux, uy, uz] = bodyFixedUnit(feature.lat * DEG2RAD$5, feature.lon * DEG2RAD$5);
+		const [ux, uy, uz] = bodyFixedUnit(feature.lat * DEG2RAD$4, feature.lon * DEG2RAD$4);
 		const rf = radial[i];
 		const obj = new CSS2DObject(el);
 		obj.position.set(rf * ux, rf * uy, rf * uz);
@@ -15066,8 +16226,8 @@ async function sampleModelSurface(model, features) {
 	const he = model.userData.halfExtents;
 	for (let i = 0; i < n; i++) {
 		if (i > 0 && i % MODEL_CAST_CHUNK === 0) await new Promise((r) => setTimeout(r));
-		const latRad = features[i].lat * DEG2RAD$5;
-		const lonRad = features[i].lon * DEG2RAD$5;
+		const latRad = features[i].lat * DEG2RAD$4;
+		const lonRad = features[i].lon * DEG2RAD$4;
 		const r = castModelRadius(model, latRad, lonRad, _castNormal);
 		if (r !== null) radii[i] = r;
 		else {
@@ -16240,7 +17400,10 @@ uniform vec2 uTileFilter;
 ${TILE_CHAIN_GLSL}
 vec3 tileColour( vec3 below ) {
 	if ( uTileWindow[ 0 ].w < 0.5 ) return below;
-	TileCharts charts = tileChartsFrom( uTileAnchor, vTileOff );
+	mat3x2 map;
+	mat3x2 cap;
+	float side;
+	tileChartsFrom( uTileAnchor, vTileOff, map, cap, side );
 
 	float rows = ${4 .toFixed(1)};
 	vec3 colour = vec3( 0.0 );
@@ -16251,7 +17414,7 @@ vec3 tileColour( vec3 below ) {
 		vec2 spot;
 		vec2 major;
 		vec2 minor;
-		float alpha = tileWindowWeight( charts, window, uTileGrid[ i ], uTileHome[ i ], uTileFilter, spot, major, minor );
+		float alpha = tileWindowWeight( map, cap, side, window, uTileGrid[ i ], uTileHome[ i ], uTileFilter, spot, major, minor );
 		if ( alpha <= 0.0 ) continue;
 		ivec3 slot = ivec3( int( mod( spot.x, rows ) ), int( mod( spot.y, rows ) ), int( window.y ) );
 		alpha *= texelFetch( uTileMask, slot, 0 ).r;
@@ -16394,8 +17557,9 @@ async function swapBodyTexture(bo, tier, frame, textureLoader) {
 			return;
 		}
 		const material = bo.mesh.material;
-		setSurfaceMap(material, texture, bo.body.data.color);
-		if (bo.model) setShapeModelMap(bo.model, texture, bodyMeshColor(bo.body.data), bo.body.data.color);
+		const data = bo.body.data;
+		setSurfaceMap(material, texture, data.color);
+		if (bo.model) setShapeModelMap(bo.model, texture, untexturedSurfaceColour(data), data.color);
 		bo.textureTier = tier;
 		bo.textureFrame = frame;
 	} catch (err) {
@@ -16404,6 +17568,13 @@ async function swapBodyTexture(bo, tier, frame, textureLoader) {
 		bo.textureLoading = false;
 	}
 }
+function applySurfaceColour(bo) {
+	if (!bo.mesh || !bo.photometry || isModelBearing(bo.body) || bo.appearance?.surfaceOwned) return;
+	const material = bo.mesh.material;
+	if (material.map) return;
+	untexturedSurfaceColour(bo.body.data, material.color);
+	if (bo.model) setShapeModelMap(bo.model, null, material.color);
+}
 function applyRadiiToMesh(bo, radii) {
 	if (!bo.mesh) return;
 	const { a, b, c } = radii;
@@ -16415,6 +17586,11 @@ function applyRadiiToMesh(bo, radii) {
 		kmToScene(c),
 		kmToScene(b)
 	];
+	bo.body.drawnRadii = {
+		a,
+		b,
+		c
+	};
 	if (bo.atmosphere) {
 		const eqKm = Math.max(a, b);
 		syncAtmosphereEllipsoid(bo.atmosphere, eqKm, c, kmToScene(eqKm));
@@ -16427,14 +17603,15 @@ async function loadBodyTexture(bo, textureLoader, currentJd, scene, maxTextureSi
 	const detail = await fetchObjectDetail(bo.body.data.id, false);
 	ctx?.bodies.orientationRead.add(bo.body.data.id);
 	if (!detail.global) return;
-	if (detail.global.orientation && !bo.body.orientation) applyBodyOrientation(bo.body, detail.global.orientation, ctx);
+	if (detail.global.orientation && !bo.body.orientation) applyBodyOrientation(bo.body, detail.global.orientation, detail.global.nut_prec, ctx);
 	if (detail.global.radii && bo.radiusScene > 0 && !bo.radiiApplied && !detail.global.displacement?.absolute_radius) applyRadiiToMesh(bo, detail.global.radii);
 	if (detail.global.rings?.length) await Promise.allSettled(attachRingBundles(bo.body.data.id, bo.body.data.id, detail.global.rings, detail.global.radii, bo, scene, maxTextureSize, ctx));
-	const surfaceColor = detail.global.sbdb?.color ?? detail.global.color;
-	if (surfaceColor) {
-		bo.body.data.color = surfaceColor;
-		if (bo.mesh && !bo.textureTier) bo.mesh.material.color.set(surfaceColor);
-	}
+	const data = bo.body.data;
+	data.color = detail.global.sbdb?.color ?? detail.global.color;
+	data.geometricAlbedo = detail.global.sbdb?.geometric_albedo ?? detail.global.geometric_albedo;
+	data.lunarWeightScale = detail.global.lunar_weight_scale;
+	if (bo.photometry) bo.photometry.uLunarWeightScale.value = data.lunarWeightScale ?? 1;
+	applySurfaceColour(bo);
 	if (!detail.global.map_texture_available) return;
 	const bodyId = bo.body.data.id;
 	const surface = pickTexture([detail.global.texture && {
@@ -16476,9 +17653,9 @@ function unloadBodyTexture(bo) {
 	if (!material.map) return;
 	material.map.dispose();
 	material.map = null;
-	material.color.set(bodyMeshColor(bo.body.data));
+	untexturedSurfaceColour(bo.body.data, material.color);
 	material.needsUpdate = true;
-	if (bo.model) setShapeModelMap(bo.model, null, bodyMeshColor(bo.body.data));
+	if (bo.model) setShapeModelMap(bo.model, null, material.color);
 	bo.textureTier = void 0;
 }
 async function loadBodyTextureTier(bo, tier, frame, textureLoader) {
@@ -16505,17 +17682,6 @@ async function downloadSystemMeta(barycenterId) {
 	if (!resp.ok) throw new Error(`systems/${barycenterId}.json: ${resp.status}`);
 	return resp.json();
 }
-function adoptSystemSpin(body, orientation, nutPrec, ctx, barycenterId) {
-	applyBodyOrientation(body, orientation, ctx, barycenterId);
-	if (!nutPrec) return;
-	const naifMatch = body.data.id.match(/^naif-(-?\d+)$/);
-	const naifId = naifMatch ? parseInt(naifMatch[1], 10) : null;
-	const angles = naifId !== null ? getNutPrecAngles(ownerIdFor(naifId)) : void 0;
-	if (angles) body.nutPrec = {
-		...nutPrec,
-		angles
-	};
-}
 async function readSpin(body, ctx) {
 	const id = body.data.id;
 	const known = () => !!body.orientation || ctx.bodies.orientationRead.has(id);
@@ -16526,8 +17692,8 @@ async function readSpin(body, ctx) {
 	const record = barycenterId ? (await fetchSystemMeta(barycenterId))?.[id] : void 0;
 	const detail = record?.orientation ? null : await fetchObjectDetail(id, false);
 	if (known()) return;
-	if (record?.orientation) adoptSystemSpin(body, record.orientation, record.nut_prec, ctx, barycenterId);
-	else if (detail?.global?.orientation) applyBodyOrientation(body, detail.global.orientation, ctx);
+	if (record?.orientation) applyBodyOrientation(body, record.orientation, record.nut_prec, ctx, barycenterId);
+	else if (detail?.global?.orientation) applyBodyOrientation(body, detail.global.orientation, detail.global.nut_prec, ctx);
 	ctx.bodies.orientationRead.add(id);
 	if (body.orientation) ctx.bodies.orientationVersion++;
 }
@@ -16550,8 +17716,14 @@ async function loadSystemData(barycenterId, bodyObjects, scene, textureLoader, c
 		const bo = bodyObjects.get(bodyId);
 		if (!bo?.mesh) continue;
 		ctx?.bodies.orientationRead.add(bodyId);
+		const data = bo.body.data;
+		data.color ??= bodyMeta.color;
+		data.geometricAlbedo ??= bodyMeta.geometric_albedo;
+		data.lunarWeightScale ??= bodyMeta.lunar_weight_scale;
+		if (bo.photometry) bo.photometry.uLunarWeightScale.value = data.lunarWeightScale ?? 1;
+		applySurfaceColour(bo);
 		if (bodyMeta.orientation) {
-			adoptSystemSpin(bo.body, bodyMeta.orientation, bodyMeta.nut_prec, ctx, barycenterId);
+			applyBodyOrientation(bo.body, bodyMeta.orientation, bodyMeta.nut_prec, ctx, barycenterId);
 			applyOrientation(bo.mesh, bodyMeta.orientation, currentJd, bo.body.nutPrec);
 		}
 		if (bodyMeta.radii && bo.radiusScene > 0 && !bo.radiiApplied && !bodyMeta.displacement?.absolute_radius) applyRadiiToMesh(bo, bodyMeta.radii);
@@ -16589,6 +17761,7 @@ function unloadSystemTextures(barycenterId, bodyObjects, scene, ctx) {
 		}
 		for (const ring of bo.rings) {
 			ring.planetShadow?.disable();
+			ring.ringshine?.disable();
 			ring.mesh.removeFromParent();
 			disposeRingNode(ring);
 		}
@@ -16609,6 +17782,7 @@ var ZoneRefresher = class {
 	latestDate;
 	failureStreak = 0;
 	staleNotified = false;
+	staleCheckRunning = false;
 	retries = new RetryBackoff(() => this.wakes++);
 	wakes = 0;
 	wakeTimer;
@@ -16664,10 +17838,17 @@ var ZoneRefresher = class {
 	recordFailure(key) {
 		this.retries.fail(key);
 		this.failureStreak++;
-		if (this.failureStreak >= STALE_FAILURE_STREAK && !this.staleNotified) {
+		if (this.failureStreak < STALE_FAILURE_STREAK || this.staleNotified || this.staleCheckRunning) return;
+		this.staleCheckRunning = true;
+		dataVersionChanged().then((changed) => {
+			this.staleCheckRunning = false;
+			if (!changed) {
+				this.failureStreak = 0;
+				return;
+			}
 			this.staleNotified = true;
 			this.ctx.onDataStale?.();
-		}
+		});
 	}
 	wakeIn(ms) {
 		this.wakeTimer ??= setTimeout(() => {
@@ -17636,7 +18817,7 @@ var SimClock = class {
 //#region src/lib/math/spherical.ts
 var { PI, sin, cos, asin, atan2, sqrt } = Math;
 var DEG$9 = 180 / PI;
-var RAD$5 = PI / 180;
+var RAD$4 = PI / 180;
 function applyQuat(v, q, inverse) {
 	const [x, y, z] = v;
 	const [qx, qy, qz, qw] = inverse ? [
@@ -17672,8 +18853,8 @@ function cartesianToSpherical(cam, target, bodyQuat) {
 	};
 }
 function sphericalToCartesian(target, lat, lon, distance, bodyQuat) {
-	const latR = lat * RAD$5;
-	const lonR = lon * RAD$5;
+	const latR = lat * RAD$4;
+	const lonR = lon * RAD$4;
 	let ox;
 	let oy;
 	let oz;
@@ -17706,7 +18887,7 @@ function offsetFacing(focus, toward, elevationDeg, distance) {
 		hx = 0;
 		hz = 1;
 	}
-	const e = elevationDeg * RAD$5;
+	const e = elevationDeg * RAD$4;
 	const c = cos(e);
 	return [
 		distance * c * hx,
@@ -18041,26 +19222,6 @@ function makeFatTrailMaterial(color, lineWidth, brightness = TRAIL_DIM, dash) {
 	});
 }
 
-//#endregion
-//#region src/lib/scene/lighting.ts
-var AMBIENT_INTENSITY = .01;
-var SUN_LIGHT_INTENSITY = 3.5;
-var ENV_BASE_INTENSITY = .04;
-function sunIrradianceFactor(sunDistScene) {
-	const au = Math.max(sunDistScene / 10, .01);
-	return 1 / (au * au);
-}
-function applySunPointLightMode(light, realistic, scale = 1) {
-	light.decay = realistic ? 2 : 0;
-	light.intensity = (realistic ? SUN_LIGHT_INTENSITY * 10 * 10 : SUN_LIGHT_INTENSITY) * scale;
-}
-function makeEnvMap(renderer) {
-	const pmrem = new PMREMGenerator(renderer);
-	const tex = pmrem.fromScene(new RoomEnvironment()).texture;
-	pmrem.dispose();
-	return tex;
-}
-
 //#endregion
 //#region src/lib/scene/setup/bloom-high-pass.ts
 var MAX_SPAN = 16;
@@ -18106,6 +19267,26 @@ function installBloomHighPass(pass) {
 	});
 }
 
+//#endregion
+//#region src/lib/scene/setup/output-dither.ts
+var DITHER_GLSL = `
+	vec3 outputDither(vec3 color) {
+		// ES 1.00 gives gl_FragCoord at medium precision. Copy it before the arithmetic.
+		vec3 p3 = gl_FragCoord.xyx;
+		p3 = fract(p3 * vec3(0.1031, 0.1030, 0.0973));
+		p3 += dot(p3, p3.yxz + 33.33);
+		vec3 u = fract((p3.xxy + p3.yzz) * p3.zyx);
+		// The difference of two uniform samples has a triangular distribution on (-1, 1).
+		vec3 noise = u - u.yzx;
+		// The noise goes to 0 in the last step at each end. Thus black stays black and no value clips.
+		vec3 amplitude = clamp(min(color, 1.0 - color) * 255.0, 0.0, 1.0);
+		return color + noise * amplitude / 255.0;
+	}
+`;
+function installOutputDither(pass) {
+	pass.material.fragmentShader = pass.material.fragmentShader.replace("#include <colorspace_pars_fragment>", `#include <colorspace_pars_fragment>\n${DITHER_GLSL}`).replace(/}\s*$/, "gl_FragColor.rgb = outputDither(gl_FragColor.rgb);\n}");
+}
+
 //#endregion
 //#region src/lib/scene/setup/three-boot.ts
 var CAMERA_FAR_DEFAULT = 1e5;
@@ -18178,6 +19359,7 @@ function bootThree(canvas, labelContainer, ctx) {
 	installBloomHighPass(bloomPass);
 	composer.addPass(bloomPass);
 	const outputPass = new OutputPass();
+	installOutputDither(outputPass);
 	outputPass.needsSwap = false;
 	composer.addPass(outputPass);
 	return {
@@ -18186,7 +19368,7 @@ function bootThree(canvas, labelContainer, ctx) {
 		scene,
 		camera,
 		composer,
-		maxSceneSamples: sampleCounts[0] ?? 0,
+		maxSceneSamples: sampleCounts?.[0] ?? 0,
 		bloomPass,
 		ambientLight,
 		shadowLight
@@ -18855,7 +20037,7 @@ gl_Position = projectionMatrix * mvPosition;
 `;
 var anchors = /* @__PURE__ */ new WeakMap();
 var _modelView = new Matrix4();
-var _inverse = new Matrix4();
+var _inverse$1 = new Matrix4();
 var _eye = new Vector3();
 function patch(material, anchor) {
 	chainShaderHook(material, "cameraRelative", (shader) => {
@@ -18873,7 +20055,7 @@ function attachCameraRelative(mesh, material) {
 	patch(material, anchor);
 	mesh.onBeforeRender = (_renderer, _scene, camera) => {
 		_modelView.multiplyMatrices(camera.matrixWorldInverse, mesh.matrixWorld);
-		_eye.setFromMatrixPosition(_inverse.copy(_modelView).invert());
+		_eye.setFromMatrixPosition(_inverse$1.copy(_modelView).invert());
 		anchor.local.value.set(Math.fround(_eye.x), Math.fround(_eye.y), Math.fround(_eye.z));
 		anchor.view.value.copy(anchor.local.value).applyMatrix4(_modelView);
 	};
@@ -18911,19 +20093,21 @@ function buildMajorBodies(bodies, scene, clickables, meshToBody, bodyObjects, re
 		let starExtras = null;
 		let eclipseShadow = null;
 		let planetshine = null;
+		let photometry = null;
 		let atmosphere = null;
 		let sunTint;
 		if (!isVirtual && !noPhysical) {
 			if (isStar) starExtras = buildStarExtras(root, radius, color);
 			const segments = isStar ? STAR_SPHERE_SEGMENTS : BODY_SPHERE_SEGMENTS;
 			const geometry = new SphereGeometry(radius, segments, segments);
-			const material = isStar ? makeStarSurfaceMaterial() : new MeshStandardMaterial({ color: bodyMeshColor(body.data) });
+			const material = isStar ? makeStarSurfaceMaterial() : new MeshStandardMaterial({ color: untexturedSurfaceColour(body.data) });
 			mesh = new Mesh(geometry, material);
 			if (modelBearing) mesh.visible = false;
 			if (!isStar) {
 				eclipseShadow = attachEclipseShadowToBody(material);
 				attachCameraRelative(mesh, material);
-				attachSurfacePhotometry(material, id);
+				photometry = makePhotometryUniforms(body.data.lunarWeightScale);
+				attachSurfacePhotometry(material, id, photometry);
 				if (!modelBearing) planetshine = attachPlanetshine(material);
 			}
 			root.add(mesh);
@@ -18974,6 +20158,7 @@ function buildMajorBodies(bodies, scene, clickables, meshToBody, bodyObjects, re
 			selfShadow: null,
 			eclipseShadow,
 			planetshine,
+			photometry,
 			nomenclatureLabels: null,
 			model: null
 		});
@@ -18992,10 +20177,9 @@ function upgradeBodyMesh(bo, scene, clickables, meshToBody) {
 		bo.noPhysical = "radius";
 		return;
 	}
-	const color = bodyMeshColor(body.data);
 	const segments = BODY_SPHERE_SEGMENTS;
 	const geometry = new SphereGeometry(radiusScene, segments, segments);
-	const material = new MeshStandardMaterial({ color });
+	const material = new MeshStandardMaterial({ color: untexturedSurfaceColour(body.data) });
 	const mesh = new Mesh(geometry, material);
 	if (modelBearing) mesh.visible = false;
 	bo.root.add(mesh);
@@ -19004,7 +20188,8 @@ function upgradeBodyMesh(bo, scene, clickables, meshToBody) {
 	meshToBody.set(mesh, body);
 	bo.eclipseShadow = attachEclipseShadowToBody(material);
 	attachCameraRelative(mesh, material);
-	attachSurfacePhotometry(material, body.data.id);
+	bo.photometry = makePhotometryUniforms(body.data.lunarWeightScale);
+	attachSurfacePhotometry(material, body.data.id, bo.photometry);
 	if (!modelBearing) bo.planetshine = attachPlanetshine(material);
 	bo.currentSegments = segments;
 	const atmoParams = getAtmosphereParams(body.data.id);
@@ -19041,6 +20226,7 @@ function downgradeBodyMesh(bo, scene, clickables, meshToBody) {
 		bo.currentSegments = void 0;
 		bo.eclipseShadow = null;
 		bo.planetshine = null;
+		bo.photometry = null;
 		bo.sunTint = void 0;
 		bo.radiiApplied = false;
 		bo.semiAxesScene = void 0;
@@ -19191,9 +20377,9 @@ function revert(bo, appearance) {
 	if (applied.surfaceOwned && appearance?.surface === void 0) {
 		applied.surfaceMap?.dispose();
 		material.map = null;
-		material.color.set(bodyMeshColor(bo.body.data));
+		untexturedSurfaceColour(bo.body.data, material.color);
 		material.needsUpdate = true;
-		if (bo.model) setShapeModelMap(bo.model, null, bodyMeshColor(bo.body.data));
+		if (bo.model) setShapeModelMap(bo.model, null, material.color);
 		applied.surfaceOwned = void 0;
 		applied.surfaceUrl = void 0;
 		applied.surfaceMap = void 0;
@@ -19245,7 +20431,7 @@ async function applyToBody(bo, appearance, textureLoader, current) {
 			const live = liveMaterial(bo);
 			if (texture && live) {
 				setSurfaceMap(live, texture);
-				if (bo.model) setShapeModelMap(bo.model, texture, bodyMeshColor(bo.body.data));
+				if (bo.model) setShapeModelMap(bo.model, texture, untexturedSurfaceColour(bo.body.data));
 				applied.surfaceUrl = appearance.surface;
 				applied.surfaceMap = texture;
 			}
@@ -19465,95 +20651,6 @@ function makePointCloudFromBuffer(positions, drawCount, texture, color, size = 4
 	return points;
 }
 
-//#endregion
-//#region src/lib/math/orbit/position.ts
-var DEG2RAD$4 = Math.PI / 180;
-var COS_EPS$2 = Math.cos(EARTH_OBLIQUITY_DEG * DEG2RAD$4);
-var SIN_EPS$2 = Math.sin(EARTH_OBLIQUITY_DEG * DEG2RAD$4);
-function orbitalToThreeJS(xOrb, yOrb, w, i, om, equatorial = false) {
-	const cosW = Math.cos(w * DEG2RAD$4);
-	const sinW = Math.sin(w * DEG2RAD$4);
-	const cosI = Math.cos(i * DEG2RAD$4);
-	const sinI = Math.sin(i * DEG2RAD$4);
-	const cosOm = Math.cos(om * DEG2RAD$4);
-	const sinOm = Math.sin(om * DEG2RAD$4);
-	const x = (cosOm * cosW - sinOm * sinW * cosI) * xOrb + (-cosOm * sinW - sinOm * cosW * cosI) * yOrb;
-	let y = (sinOm * cosW + cosOm * sinW * cosI) * xOrb + (-sinOm * sinW + cosOm * cosW * cosI) * yOrb;
-	let z = sinW * sinI * xOrb + cosW * sinI * yOrb;
-	if (equatorial) {
-		const yEcl = y * COS_EPS$2 + z * SIN_EPS$2;
-		const zEcl = -y * SIN_EPS$2 + z * COS_EPS$2;
-		y = yEcl;
-		z = zEcl;
-	}
-	return [
-		x * 10,
-		z * 10,
-		-y * 10
-	];
-}
-function propagateOrbitAngles(el, jd) {
-	const { omDot, wDot, om, w, epoch } = el;
-	if (!omDot && !wDot) return el;
-	const dt = jd - epoch;
-	return {
-		...el,
-		om: omDot ? om + omDot * dt : om,
-		w: wDot ? w + wDot * dt : w
-	};
-}
-function orbitalElementsToPositionJD(el, jd) {
-	const { a, e, i, ma, n, epoch } = el;
-	if (!isFinite(a) || !isFinite(e) || !isFinite(ma) || !isFinite(n)) {
-		console.warn(`NaN in orbital elements: a=${a} e=${e} ma=${ma} n=${n}`);
-		return null;
-	}
-	const M = (ma + n * (jd - epoch)) * DEG2RAD$4;
-	const { om: omPropagated, w: wPropagated } = propagateOrbitAngles(el, jd);
-	let nu;
-	let r;
-	if (e < 1 || a > 0) {
-		const eClamped = Math.min(e, .9999999);
-		const E = solveKepler(M, eClamped);
-		const sinNu = Math.sqrt(1 - eClamped * eClamped) * Math.sin(E) / (1 - eClamped * Math.cos(E));
-		const cosNu = (Math.cos(E) - eClamped) / (1 - eClamped * Math.cos(E));
-		nu = Math.atan2(sinNu, cosNu);
-		r = a * (1 - eClamped * Math.cos(E));
-	} else {
-		const H = solveKeplerHyperbolic(M, e);
-		if (!isFinite(H)) {
-			console.warn(`solveKeplerHyperbolic overflow: M=${M} e=${e}`);
-			return null;
-		}
-		const denom = e * Math.cosh(H) - 1;
-		if (Math.abs(denom) < 1e-15) {
-			console.warn(`Hyperbolic denom near zero: H=${H} e=${e} denom=${denom}`);
-			return null;
-		}
-		const sinNu = Math.sqrt(e * e - 1) * Math.sinh(H) / denom;
-		const cosNu = (e - Math.cosh(H)) / denom;
-		nu = Math.atan2(sinNu, cosNu);
-		r = a * (1 - e * Math.cosh(H));
-	}
-	const xOrb = r * Math.cos(nu);
-	const yOrb = r * Math.sin(nu);
-	if (!isFinite(xOrb) || !isFinite(yOrb)) {
-		console.warn(`Non-finite orbital position: r=${r} nu=${nu} xOrb=${xOrb} yOrb=${yOrb} a=${a} e=${e}`);
-		return null;
-	}
-	return orbitalToThreeJS(xOrb, yOrb, wPropagated, i, omPropagated, el.equatorial);
-}
-function parabolicToPositionJD(el, jd) {
-	const { q, tp, i, om, w } = el;
-	if (q == null || tp == null || !isFinite(q) || !isFinite(tp)) return null;
-	const result = solveBarker(q, tp, jd);
-	if (!result) return null;
-	const xOrb = result.r * Math.cos(result.nu);
-	const yOrb = result.r * Math.sin(result.nu);
-	if (!isFinite(xOrb) || !isFinite(yOrb)) return null;
-	return orbitalToThreeJS(xOrb, yOrb, w, i, om, el.equatorial);
-}
-
 //#endregion
 //#region src/lib/math/orbit/curves.ts
 function orbitalElementsToParabola(el, numPoints = 512, rMaxAU = 50) {
@@ -19797,6 +20894,10 @@ function commitTrail(line, posArr, trailArr, fullArr, n, isOpenCurve, useTrail)
 
 //#endregion
 //#region src/lib/scene/objects/trail/builder.ts
+var FAT_TRAIL_MIN_PIXEL_RATIO = 1.5;
+function drawsFat(lineWidth) {
+	return lineWidth > 1 || renderPixelRatio() >= FAT_TRAIL_MIN_PIXEL_RATIO;
+}
 function writeBufferVerticesWithLiveHead(body, buffer, posArr, cx, cy, cz, basisPos, transform) {
 	const head = body.trailAnchor ?? body.position;
 	if (!head) return 0;
@@ -19820,7 +20921,7 @@ function makeBufferTrail(body, trailBuffer, color, basisPos, lineWidth) {
 	const fullAlphas = new Float32Array(geomCap);
 	const trailAlphas = new Float32Array(geomCap);
 	if (total > 0) writeTrailAlphas(fullAlphas.subarray(0, total), trailAlphas.subarray(0, total), true, useTrail);
-	const isFat = lineWidth > 1;
+	const isFat = drawsFat(lineWidth);
 	const obj = isFat ? buildFatLineFromThin(geomCap, posArr, trailAlphas, fullAlphas, total, color, lineWidth) : buildThinLineFromArrays(posArr, trailAlphas, fullAlphas, total, color);
 	obj.frustumCulled = false;
 	obj.visible = false;
@@ -19871,7 +20972,7 @@ function makeTrail(body, color, basisPos = [
 		posArr[k * 3 + 1] = validPoints[k][1] + by;
 		posArr[k * 3 + 2] = validPoints[k][2] + bz;
 	}
-	const isFat = lineWidth > 1;
+	const isFat = drawsFat(lineWidth);
 	const obj = isFat ? buildFatLineFromThin(bufferCapacity, posArr, trailAlphas, fullAlphas, validPoints.length, color, lineWidth) : buildThinLineFromArrays(posArr, trailAlphas, fullAlphas, validPoints.length, color);
 	obj.frustumCulled = false;
 	obj.visible = false;
@@ -20004,6 +21105,7 @@ var SystemDataLoader = class {
 	lastBaryId = null;
 	pendingUnloads = /* @__PURE__ */ new Set();
 	prefetched = /* @__PURE__ */ new Set();
+	loads = 0;
 	constructor(scene, ctx, renderer, textureLoader, bodyObjects, clock, onLoaded) {
 		this.scene = scene;
 		this.ctx = ctx;
@@ -20049,10 +21151,14 @@ var SystemDataLoader = class {
 		return isTopLevelParent(baryId) ? null : baryId;
 	}
 	load(baryId) {
+		this.loads++;
 		loadSystemData(baryId, this.bodyObjects, this.scene, this.textureLoader, this.clock.jd, this.renderer.capabilities.maxTextureSize, this.ctx).then(() => {
 			this.onLoaded();
 			this.ctx.bodies.orientationVersion++;
-		});
+		}).finally(() => this.loads--);
+	}
+	isLoading() {
+		return this.loads > 0;
 	}
 	drainPendingUnloads() {
 		if (this.pendingUnloads.size === 0) return;
@@ -20765,7 +21871,7 @@ function collectDebugStats(params) {
 
 //#endregion
 //#region src/lib/math/orbit/worker.ts?worker&inline
-var jsContent = "function e(e,t,n=1e-10,r=50){let i=e;for(let a=0;a<r;a++){let r=(i-t*Math.sin(i)-e)/(1-t*Math.cos(i));if(i-=Math.max(-1,Math.min(1,r)),Math.abs(r)<n)break}return i}function t(e,t,n=1e-10,r=50){if(e===0)return 0;let i=e<0?-1:1,a=Math.abs(e),o=0,s=1;for(;t*Math.sinh(s)-s<a;)if(s*=2,s>700)return NaN;let c=.5*(o+s);for(let e=0;e<r;e++){let e=t*Math.sinh(c)-c-a;e>0?s=c:o=c;let r=c-e/(t*Math.cosh(c)-1);r>o&&r<s||(r=.5*(o+s));let i=Math.abs(r-c);if(c=r,i<n)break}return i*c}function n(e,t,n){let r=.01720209895*(n-t)/(Math.sqrt(2)*e**1.5),i=Math.cbrt(3*r+Math.sqrt(1+9*r*r)),a=i-1/i,o=2*Math.atan(a),s=e*(1+a*a);return!isFinite(o)||!isFinite(s)||s<=0?null:{nu:o,r:s}}const r=149597870.7,i=23.4392911;86400**2/r**3,1/r,Math.cos(Math.PI/180*i),Math.sin(Math.PI/180*i);const a=Math.PI,o=a*2,s=a/180;180/a;const c=6378.135,l=60/Math.sqrt(c*c*c/398600.8),u=c*l/60,d=1/l,f=.001082616,p=-253881e-11/f,m=2/3,ee=1440/(2*a);function te(e,t){let n=[31,e%4==0?29:28,31,30,31,30,31,31,30,31,30,31],r=Math.floor(t),i=1,a=0;for(;r>a+n[i-1]&&i<12;)a+=n[i-1],i+=1;let o=i,s=r-a,c=(t-r)*24,l=Math.floor(c);c=(c-l)*60;let u=Math.floor(c);return{mon:o,day:s,hr:l,minute:u,sec:(c-u)*60}}function h(e,t,n,r,i,a,o=0){return 367*e-Math.floor(7*(e+Math.floor((t+9)/12))*.25)+Math.floor(275*t/9)+n+1721013.5+((o/6e4+a/60+i)/60+r)/24}function g(e,t,n,r,i,a,o=0){if(e instanceof Date){let t=e;return h(t.getUTCFullYear(),t.getUTCMonth()+1,t.getUTCDate(),t.getUTCHours(),t.getUTCMinutes(),t.getUTCSeconds(),t.getUTCMilliseconds())}return h(e,t,n,r,i,a,o)}function ne(e,t){let{e3:n,ee2:r,peo:i,pgho:s,pho:c,pinco:l,plo:u,se2:d,se3:f,sgh2:p,sgh3:m,sgh4:ee,sh2:te,sh3:h,si2:g,si3:ne,sl2:_,sl3:v,sl4:y,t:b,xgh2:re,xgh3:ie,xgh4:x,xh2:ae,xh3:S,xi2:C,xi3:w,xl2:T,xl3:E,xl4:D,zmol:O,zmos:k}=e,{init:A,opsmode:j}=t,{ep:oe,inclp:M,nodep:N,argpp:se,mp:P}=t,F,I,L,R,ce,z,B,V,H,U,W,G,K,q,J,le,Y,ue,de,X,fe;fe=k+119459e-10*b,A===`y`&&(fe=k),X=fe+2*.01675*Math.sin(fe),Y=Math.sin(X),U=.5*Y*Y-.25,W=-.5*Y*Math.cos(X);let pe=d*U+f*W,me=g*U+ne*W,he=_*U+v*W+y*Y,ge=p*U+m*W+ee*Y,Z=te*U+h*W;fe=O+.00015835218*b,A===`y`&&(fe=O),X=fe+2*.0549*Math.sin(fe),Y=Math.sin(X),U=.5*Y*Y-.25,W=-.5*Y*Math.cos(X);let _e=r*U+n*W,ve=C*U+w*W,ye=T*U+E*W+D*Y,be=re*U+ie*W+x*Y,xe=ae*U+S*W;return G=pe+_e,J=me+ve,le=he+ye,K=ge+be,q=Z+xe,A===`n`&&(G-=i,J-=l,le-=u,K-=s,q-=c,M+=J,oe+=G,R=Math.sin(M),L=Math.cos(M),M>=.2?(q/=R,K-=L*q,se+=K,N+=q,P+=le):(z=Math.sin(N),ce=Math.cos(N),F=R*z,I=R*ce,B=q*ce+J*L*z,V=-q*z+J*L*ce,F+=B,I+=V,N%=o,N<0&&j===`a`&&(N+=o),ue=P+se+L*N,H=le+K-J*N*R,ue+=H,de=N,N=Math.atan2(F,I),N<0&&j===`a`&&(N+=o),Math.abs(de-N)>a&&(N<de?N+=o:N-=o),P+=le,se=ue-P-L*N)),{ep:oe,inclp:M,nodep:N,argpp:se,mp:P}}function _(e){let{epoch:t,ep:n,argpp:r,tc:i,inclp:a,nodep:s,np:c}=e,l,u,d,f,p,m,ee,te,h,g,ne,_,v,y,b,re,ie,x,ae,S,C,w,T,E,D,O,k,A,j,oe,M,N,se,P,F,I,L,R,ce,z,B,V,H,U,W,G,K,q,J,le,Y,ue,de,X,fe,pe,me,he,ge,Z,_e,ve,ye,be=.01675,xe=.0549,Se=c,Ce=n,we=Math.sin(s),Te=Math.cos(s),Ee=Math.sin(r),Q=Math.cos(r),De=Math.sin(a),Oe=Math.cos(a),$=Ce*Ce,ke=1-$,Ae=Math.sqrt(ke),je=t+18261.5+i/1440,Me=(4.523602-.00092422029*je)%o,Ne=Math.sin(Me),Pe=Math.cos(Me),Fe=.91375164-.03568096*Pe,Ie=Math.sqrt(1-Fe*Fe),Le=.089683511*Ne/Ie,Re=Math.sqrt(1-Le*Le),ze=5.8351514+.001944368*je,Be=.39785416*Ne/Ie,Ve=Re*Pe+.91744867*Le*Ne;Be=Math.atan2(Be,Ve),Be+=ze-Me;let He=Math.cos(Be),Ue=Math.sin(Be);S=.1945905,C=-.98088458,E=.91744867,D=.39785416,w=Te,T=we,ne=29864797e-13;let We=1/Se,Ge=0;for(;Ge<2;)Ge+=1,l=S*w+C*E*T,d=-C*w+S*E*T,ee=-S*T+C*E*w,te=C*D,h=C*T+S*E*w,g=S*D,u=Oe*ee+De*te,f=Oe*h+De*g,p=-De*ee+Oe*te,m=-De*h+Oe*g,_=l*Q+u*Ee,v=d*Q+f*Ee,y=-l*Ee+u*Q,b=-d*Ee+f*Q,re=p*Ee,ie=m*Ee,x=p*Q,ae=m*Q,_e=12*_*_-3*y*y,ve=24*_*v-6*y*b,ye=12*v*v-3*b*b,ue=3*(l*l+u*u)+_e*$,de=6*(l*d+u*f)+ve*$,X=3*(d*d+f*f)+ye*$,fe=-6*l*p+$*(-24*_*x-6*y*re),pe=-6*(l*m+d*p)+$*(-24*(v*x+_*ae)+-6*(y*ie+b*re)),me=-6*d*m+$*(-24*v*ae-6*b*ie),he=6*u*p+$*(24*_*re-6*y*x),ge=6*(f*p+u*m)+$*(24*(v*re+_*ie)-6*(b*x+y*ae)),Z=6*f*m+$*(24*v*ie-6*b*ae),ue=ue+ue+ke*_e,de=de+de+ke*ve,X=X+X+ke*ye,K=ne*We,G=-.5*K/Ae,q=K*Ae,W=-15*Ce*q,J=_*y+v*b,le=v*y+_*b,Y=v*b-_*y,Ge===1&&(O=W,k=G,A=K,j=q,oe=J,M=le,N=Y,se=ue,P=de,F=X,I=fe,L=pe,R=me,ce=he,z=ge,B=Z,V=_e,H=ve,U=ye,S=He,C=Ue,E=Fe,D=Ie,w=Re*Te+Le*we,T=we*Re-Te*Le,ne=4.7968065e-7);let Ke=(4.7199672+(.2299715*je-ze))%o,qe=(6.2565837+.017201977*je)%o,Je=2*O*M,Ye=2*O*N,Xe=2*k*L,Ze=2*k*(R-I),Qe=-2*A*P,$e=-2*A*(F-se),et=-2*A*(-21-9*$)*be,tt=2*j*H,nt=2*j*(U-V),rt=-18*j*be,it=-2*k*z,at=-2*k*(B-ce),ot=2*W*le,st=2*W*Y,ct=2*G*pe,lt=2*G*(me-fe),ut=-2*K*de,dt=-2*K*(X-ue),ft=-2*K*(-21-9*$)*xe,pt=2*q*ve,mt=2*q*(ye-_e),ht=-18*q*xe,gt=-2*G*ge,_t=-2*G*(Z-he);return{snodm:we,cnodm:Te,sinim:De,cosim:Oe,sinomm:Ee,cosomm:Q,day:je,e3:st,ee2:ot,em:Ce,emsq:$,gam:ze,peo:0,pgho:0,pho:0,pinco:0,plo:0,rtemsq:Ae,se2:Je,se3:Ye,sgh2:tt,sgh3:nt,sgh4:rt,sh2:it,sh3:at,si2:Xe,si3:Ze,sl2:Qe,sl3:$e,sl4:et,s1:W,s2:G,s3:K,s4:q,s5:J,s6:le,s7:Y,ss1:O,ss2:k,ss3:A,ss4:j,ss5:oe,ss6:M,ss7:N,sz1:se,sz2:P,sz3:F,sz11:I,sz12:L,sz13:R,sz21:ce,sz22:z,sz23:B,sz31:V,sz32:H,sz33:U,xgh2:pt,xgh3:mt,xgh4:ht,xh2:gt,xh3:_t,xi2:ct,xi3:lt,xl2:ut,xl3:dt,xl4:ft,nm:Se,z1:ue,z2:de,z3:X,z11:fe,z12:pe,z13:me,z21:he,z22:ge,z23:Z,z31:_e,z32:ve,z33:ye,zmol:Ke,zmos:qe}}function v(e){let{cosim:t,argpo:n,s1:r,s2:i,s3:s,s4:c,s5:u,sinim:d,ss1:f,ss2:p,ss3:ee,ss4:te,ss5:h,sz1:g,sz3:ne,sz11:_,sz13:v,sz21:y,sz23:b,sz31:re,sz33:ie,t:x,tc:ae,gsto:S,mo:C,mdot:w,no:T,nodeo:E,nodedot:D,xpidot:O,z1:k,z3:A,z11:j,z13:oe,z21:M,z23:N,z31:se,z33:P,ecco:F,eccsq:I}=e,{emsq:L,em:R,argpm:ce,inclm:z,mm:B,nm:V,nodem:H,irez:U,atime:W,d2201:G,d2211:K,d3210:q,d3222:J,d4410:le,d4422:Y,d5220:ue,d5232:de,d5421:X,d5433:fe,dedt:pe,didt:me,dmdt:he,dnodt:ge,domdt:Z,del1:_e,del2:ve,del3:ye,xfact:be,xlamo:xe,xli:Se,xni:Ce}=e,we,Te,Ee,Q,De,Oe,$,ke,Ae,je,Me,Ne,Pe,Fe,Ie,Le,Re,ze,Be,Ve,He,Ue,We,Ge,Ke,qe,Je,Ye,Xe,Ze,Qe,$e,et=.0043752690880113,tt=.00015835218,nt=119459e-10;U=0,V<.0052359877&&V>.0034906585&&(U=1),V>=.00826&&V<=.00924&&R>=.5&&(U=2);let rt=f*nt*h,it=p*nt*(_+v),at=-nt*ee*(g+ne-14-6*L),ot=te*nt*(re+ie-6),st=-nt*p*(y+b);(z<.052359877||z>a-.052359877)&&(st=0),d!==0&&(st/=d);let ct=ot-t*st;pe=rt+r*tt*u,me=it+i*tt*(j+oe),he=at-tt*s*(k+A-14-6*L);let lt=c*tt*(se+P-6),ut=-tt*i*(M+N);(z<.052359877||z>a-.052359877)&&(ut=0),Z=ct+lt,ge=st,d!==0&&(Z-=t/d*ut,ge+=ut/d);let dt=(S+ae*et)%o;if(R+=pe*x,z+=me*x,ce+=Z*x,H+=ge*x,B+=he*x,U!==0){if(Ze=(V/l)**m,U===2){Qe=t*t;let e=R;R=F;let n=L;L=I,$e=R*L,Fe=-.306-(R-.64)*.44,R<=.65?(Ie=3.616-13.247*R+16.29*L,Re=-19.302+117.39*R-228.419*L+156.591*$e,ze=-18.9068+109.7927*R-214.6334*L+146.5816*$e,Be=-41.122+242.694*R-471.094*L+313.953*$e,Ve=-146.407+841.88*R-1629.014*L+1083.435*$e,He=-532.114+3017.977*R-5740.032*L+3708.276*$e):(Ie=-72.099+331.819*R-508.738*L+266.724*$e,Re=-346.844+1582.851*R-2415.925*L+1246.113*$e,ze=-342.585+1554.908*R-2366.899*L+1215.972*$e,Be=-1052.797+4758.686*R-7193.992*L+3651.957*$e,Ve=-3581.69+16178.11*R-24462.77*L+12422.52*$e,He=R>.715?-5149.66+29936.92*R-54087.36*L+31324.56*$e:1464.74-4664.75*R+3763.64*L),R<.7?(Ge=-919.2277+4988.61*R-9064.77*L+5542.21*$e,Ue=-822.71072+4568.6173*R-8491.4146*L+5337.524*$e,We=-853.666+4690.25*R-8624.77*L+5341.4*$e):(Ge=-37995.78+161616.52*R-229838.2*L+109377.94*$e,Ue=-51752.104+218913.95*R-309468.16*L+146349.42*$e,We=-40023.88+170470.89*R-242699.48*L+115605.82*$e),Ke=d*d,we=.75*(1+2*t+Qe),Te=1.5*Ke,Q=1.875*d*(1-2*t-3*Qe),De=-1.875*d*(1+2*t-3*Qe),$=35*Ke*we,ke=39.375*Ke*Ke,Ae=9.84375*d*(Ke*(1-2*t-5*Qe)+.33333333*(-2+4*t+6*Qe)),je=d*(4.92187512*Ke*(-2-4*t+10*Qe)+6.56250012*(1+2*t-3*Qe)),Me=29.53125*d*(2-8*t+Qe*(-12+8*t+10*Qe)),Ne=29.53125*d*(-2-8*t+Qe*(12+8*t-10*Qe)),Ye=V*V,Xe=Ze*Ze,Je=3*Ye*Xe,qe=Je*17891679e-13,G=qe*we*Fe,K=qe*Te*Ie,Je*=Ze,qe=Je*3.7393792e-7,q=qe*Q*Re,J=qe*De*ze,Je*=Ze,qe=2*Je*7.3636953e-9,le=qe*$*Be,Y=qe*ke*Ve,Je*=Ze,qe=Je*1.1428639e-7,ue=qe*Ae*He,de=qe*je*We,qe=2*Je*2.1765803e-9,X=qe*Me*Ue,fe=qe*Ne*Ge,xe=(C+E+E-(dt+dt))%o,be=w+he+2*(D+ge-et)-T,R=e,L=n}U===1&&(Pe=1+L*(-2.5+.8125*L),Re=1+2*L,Le=1+L*(-6+6.60937*L),we=.75*(1+t)*(1+t),Ee=.9375*d*d*(1+3*t)-.75*(1+t),Oe=1+t,Oe*=1.875*Oe*Oe,_e=3*V*V*Ze*Ze,ve=2*_e*we*Pe*17891679e-13,ye=3*_e*Oe*Le*2.2123015e-7*Ze,_e=_e*Ee*Re*21460748e-13*Ze,xe=(C+E+n-dt)%o,be=w+O+he+Z+ge-(T+et)),Se=xe,Ce=T,W=0,V=T+0}return{em:R,argpm:ce,inclm:z,mm:B,nm:V,nodem:H,irez:U,atime:W,d2201:G,d2211:K,d3210:q,d3222:J,d4410:le,d4422:Y,d5220:ue,d5232:de,d5421:X,d5433:fe,dedt:pe,didt:me,dmdt:he,dndt:0,dnodt:ge,domdt:Z,del1:_e,del2:ve,del3:ye,xfact:be,xlamo:xe,xli:Se,xni:Ce}}function y(e){let t=(e-2451545)/36525,n=-62e-7*t*t*t+.093104*t*t+3164400184.812866*t+67310.54841;return n=n*s/240%o,n<0&&(n+=o),n}function b(e,t,n,r,i,a,o){return e instanceof Date?y(g(e)):y(t===void 0?e:g(e,t,n,r,i,a,o))}function re(e){let{ecco:t,epoch:n,inclo:r,opsmode:i}=e,{no:a}=e,s=t*t,c=1-s,u=Math.sqrt(c),d=Math.cos(r),p=d*d,ee=(l/a)**m,te=.75*f*(3*p-1)/(u*c),h=te/(ee*ee),g=ee*(1-h*h-h*(1/3+134*h*h/81));h=te/(g*g),a/=1+h;let ne=(l/a)**m,_=Math.sin(r),v=ne*c,y=1-5*p,re=-y-p-p,ie=1/ne,x=v*v,ae=ne*(1-t),S;if(i===`a`){let e=n-7305,t=Math.floor(e+1e-8),r=e-t,i=.017202791694070362,a=i+o;S=(1.7321343856509375+i*t+a*r+e*e*5075514194322695e-30)%o,S<0&&(S+=o)}else S=b(n+2433281.5);return{no:a,method:`n`,ainv:ie,ao:ne,con41:re,con42:y,cosio:d,cosio2:p,eccsq:s,omeosq:c,posq:x,rp:ae,rteosq:u,sinio:_,gsto:S}}function ie(e){let{irez:t,d2201:n,d2211:r,d3210:i,d3222:a,d4410:s,d4422:c,d5220:l,d5232:u,d5421:d,d5433:f,dedt:p,del1:m,del2:ee,del3:te,didt:h,dmdt:g,dnodt:ne,domdt:_,argpo:v,argpdot:y,t:b,tc:re,gsto:ie,xfact:x,xlamo:ae,no:S}=e,{atime:C,em:w,argpm:T,inclm:E,xli:D,mm:O,xni:k,nodem:A,nm:j}=e,oe=.13130908,M=2.8843198,N=.37448087,se=5.7686396,P=.95240898,F=1.8014998,I=1.050833,L=4.4108898,R=259200,ce,z,B,V,H,U,W,G,K=0,q=0,J=(ie+re*.0043752690880113)%o;if(w+=p*b,E+=h*b,T+=_*b,A+=ne*b,O+=g*b,t!==0){(C===0||b*C<=0||Math.abs(b)<Math.abs(C))&&(C=0,k=S,D=ae),ce=b>0?720:-720;let e=381;for(;e===381;)t===2?(G=v+y*C,B=G+G,z=D+D,W=n*Math.sin(B+D-se)+r*Math.sin(D-se)+i*Math.sin(G+D-P)+a*Math.sin(-G+D-P)+s*Math.sin(B+z-F)+c*Math.sin(z-F)+l*Math.sin(G+D-I)+u*Math.sin(-G+D-I)+d*Math.sin(G+z-L)+f*Math.sin(-G+z-L),H=k+x,U=n*Math.cos(B+D-se)+r*Math.cos(D-se)+i*Math.cos(G+D-P)+a*Math.cos(-G+D-P)+l*Math.cos(G+D-I)+u*Math.cos(-G+D-I)+2*(s*Math.cos(B+z-F)+c*Math.cos(z-F)+d*Math.cos(G+z-L)+f*Math.cos(-G+z-L)),U*=H):(W=m*Math.sin(D-oe)+ee*Math.sin(2*(D-M))+te*Math.sin(3*(D-N)),H=k+x,U=m*Math.cos(D-oe)+2*ee*Math.cos(2*(D-M))+3*te*Math.cos(3*(D-N)),U*=H),Math.abs(b-C)>=720?e=381:(q=b-C,e=0),e===381&&(D+=H*ce+W*R,k+=W*ce+U*R,C+=ce);j=k+W*q+U*q*q*.5,V=D+H*q+W*q*q*.5,t===1?(O=V-A-T+J,K=j-S):(O=V-2*A+2*J,K=j-S),j=S+K}return{atime:C,em:w,argpm:T,inclm:E,xli:D,mm:O,xni:k,nodem:A,dndt:K,nm:j}}var x;(function(e){e[e.None=0]=`None`,e[e.MeanEccentricityOutOfRange=1]=`MeanEccentricityOutOfRange`,e[e.MeanMotionBelowZero=2]=`MeanMotionBelowZero`,e[e.PerturbedEccentricityOutOfRange=3]=`PerturbedEccentricityOutOfRange`,e[e.SemiLatusRectumBelowZero=4]=`SemiLatusRectumBelowZero`,e[e.Decayed=6]=`Decayed`})(x||={});function ae(e,t){let n,r,i,s,d,ee,te,h,g,_,v,y,b,re,ae,S,C,w,T,E,D,O,k,A,j,oe,M;e.t=t,e.error=x.None;let N=e.mo+e.mdot*e.t,se=e.argpo+e.argpdot*e.t,P=e.nodeo+e.nodedot*e.t;g=se,D=N;let F=e.t*e.t;if(k=P+e.nodecf*F,C=1-e.cc1*e.t,w=e.bstar*e.cc4*e.t,T=e.t2cof*F,e.isimp!==1){te=e.omgcof*e.t;let t=1+e.eta*Math.cos(N);ee=e.xmcof*(t*t*t-e.delmo),S=te+ee,D=N+S,g=se-S,y=F*e.t,b=y*e.t,C=C-e.d2*F-e.d3*y-e.d4*b,w+=e.bstar*e.cc5*(Math.sin(D)-e.sinmao),T=T+e.t3cof*y+b*(e.t4cof+e.t*e.t5cof)}O=e.no;let I=e.ecco;if(E=e.inclo,e.method===`d`){re=e.t;let t=ie({irez:e.irez,d2201:e.d2201,d2211:e.d2211,d3210:e.d3210,d3222:e.d3222,d4410:e.d4410,d4422:e.d4422,d5220:e.d5220,d5232:e.d5232,d5421:e.d5421,d5433:e.d5433,dedt:e.dedt,del1:e.del1,del2:e.del2,del3:e.del3,didt:e.didt,dmdt:e.dmdt,dnodt:e.dnodt,domdt:e.domdt,argpo:e.argpo,argpdot:e.argpdot,t:e.t,tc:re,gsto:e.gsto,xfact:e.xfact,xlamo:e.xlamo,no:e.no,atime:e.atime,em:I,argpm:g,inclm:E,xli:e.xli,mm:D,xni:e.xni,nodem:k,nm:O});({em:I,argpm:g,inclm:E,mm:D,nodem:k,nm:O}=t)}if(O<=0)return e.error=x.MeanMotionBelowZero,null;let L=(l/O)**m*C*C;if(O=l/L**1.5,I-=w,I>=1||I<-.001)return e.error=x.MeanEccentricityOutOfRange,null;I<1e-6&&(I=1e-6),D+=e.no*T,j=D+g+k,k%=o,g%=o,j%=o,D=(j-g-k)%o;let R={am:L,em:I,im:E,Om:k,om:g,mm:D,nm:O},ce=Math.sin(E),z=Math.cos(E),B=I;if(A=E,_=g,M=k,oe=D,s=ce,i=z,e.method===`d`){let t=ne(e,{inclo:e.inclo,init:`n`,ep:B,inclp:A,nodep:M,argpp:_,mp:oe,opsmode:e.operationmode});if({ep:B,nodep:M,argpp:_,mp:oe}=t,A=t.inclp,A<0&&(A=-A,M+=a,_-=a),B<0||B>1)return e.error=x.PerturbedEccentricityOutOfRange,null}e.method===`d`&&(s=Math.sin(A),i=Math.cos(A),e.aycof=-.5*p*s,Math.abs(i+1)>15e-13?e.xlcof=-.25*p*s*(3+5*i)/(1+i):e.xlcof=-.25*p*s*(3+5*i)/15e-13);let V=B*Math.cos(_);S=1/(L*(1-B*B));let H=B*Math.sin(_)+S*e.aycof,U=(oe+_+M+S*e.xlcof*V-M)%o;h=U,ae=9999.9;let W=1;for(;Math.abs(ae)>=1e-12&&W<=10;)r=Math.sin(h),n=Math.cos(h),ae=1-n*V-r*H,ae=(U-H*n+V*r-h)/ae,Math.abs(ae)>=.95&&(ae=ae>0?.95:-.95),h+=ae,W+=1;let G=V*n+H*r,K=V*r-H*n,q=V*V+H*H,J=L*(1-q);if(J<0)return e.error=x.SemiLatusRectumBelowZero,null;let le=L*(1-G),Y=Math.sqrt(L)*K/le,ue=Math.sqrt(J)/le,de=Math.sqrt(1-q);S=K/(1+de);let X=L/le*(r-H-V*S),fe=L/le*(n-V+H*S);v=Math.atan2(X,fe);let pe=(fe+fe)*X,me=1-2*X*X;S=1/J;let he=.5*f*S,ge=he*S;e.method===`d`&&(d=i*i,e.con41=3*d-1,e.x1mth2=1-d,e.x7thm1=7*d-1);let Z=le*(1-1.5*ge*de*e.con41)+.5*he*e.x1mth2*me;if(Z<1)return e.error=x.Decayed,null;v-=.25*ge*e.x7thm1*pe;let _e=M+1.5*ge*i*pe,ve=A+1.5*ge*i*s*me,ye=Y-O*he*e.x1mth2*pe/l,be=ue+O*he*(e.x1mth2*me+1.5*e.con41)/l,xe=Math.sin(v),Se=Math.cos(v),Ce=Math.sin(_e),we=Math.cos(_e),Te=Math.sin(ve),Ee=Math.cos(ve),Q=-Ce*Ee,De=we*Ee,Oe=Q*xe+we*Se,$=De*xe+Ce*Se,ke=Te*xe,Ae=Q*Se-we*xe,je=De*Se-Ce*xe,Me=Te*Se;return{position:{x:Z*Oe*c,y:Z*$*c,z:Z*ke*c},velocity:{x:(ye*Oe+be*Ae)*u,y:(ye*$+be*je)*u,z:(ye*ke+be*Me)*u},meanElements:R}}function S(e,t){let{opsmode:n,satn:r,epoch:i,xbstar:o,xecco:s,xargpo:l,xinclo:u,xmo:ee,xno:te,xnodeo:h}=t,g,y,b,ie,x,S,C,w,T,E,D,O,k,A,j,oe,M,N,se,P,F,I,L,R,ce,z,B,V,H,U,W,G,K,q,J,le,Y,ue,de,X,fe,pe,me,he,ge,Z,_e,ve,ye,be,xe,Se,Ce,we,Te,Ee,Q=e;Q.isimp=0,Q.method=`n`,Q.aycof=0,Q.con41=0,Q.cc1=0,Q.cc4=0,Q.cc5=0,Q.d2=0,Q.d3=0,Q.d4=0,Q.delmo=0,Q.eta=0,Q.argpdot=0,Q.omgcof=0,Q.sinmao=0,Q.t=0,Q.t2cof=0,Q.t3cof=0,Q.t4cof=0,Q.t5cof=0,Q.x1mth2=0,Q.x7thm1=0,Q.mdot=0,Q.nodedot=0,Q.xlcof=0,Q.xmcof=0,Q.nodecf=0,Q.irez=0,Q.d2201=0,Q.d2211=0,Q.d3210=0,Q.d3222=0,Q.d4410=0,Q.d4422=0,Q.d5220=0,Q.d5232=0,Q.d5421=0,Q.d5433=0,Q.dedt=0,Q.del1=0,Q.del2=0,Q.del3=0,Q.didt=0,Q.dmdt=0,Q.dnodt=0,Q.domdt=0,Q.e3=0,Q.ee2=0,Q.peo=0,Q.pgho=0,Q.pho=0,Q.pinco=0,Q.plo=0,Q.se2=0,Q.se3=0,Q.sgh2=0,Q.sgh3=0,Q.sgh4=0,Q.sh2=0,Q.sh3=0,Q.si2=0,Q.si3=0,Q.sl2=0,Q.sl3=0,Q.sl4=0,Q.gsto=0,Q.xfact=0,Q.xgh2=0,Q.xgh3=0,Q.xgh4=0,Q.xh2=0,Q.xh3=0,Q.xi2=0,Q.xi3=0,Q.xl2=0,Q.xl3=0,Q.xl4=0,Q.xlamo=0,Q.zmol=0,Q.zmos=0,Q.atime=0,Q.xli=0,Q.xni=0,Q.bstar=o,Q.ecco=s,Q.argpo=l,Q.inclo=u,Q.mo=ee,Q.no=te,Q.nodeo=h,Q.operationmode=n,78/c+1;let De=42/c;De*De*De*De,Q.init=`y`,Q.t=0;let Oe=re({satn:r,ecco:Q.ecco,epoch:i,inclo:Q.inclo,no:Q.no,method:Q.method,opsmode:Q.operationmode}),{ao:$,con42:ke,cosio:Ae,cosio2:je,eccsq:Me,omeosq:Ne,posq:Pe,rp:Fe,rteosq:Ie,sinio:Le}=Oe;if(Q.no=Oe.no,Q.con41=Oe.con41,Q.gsto=Oe.gsto,Q.a=(Q.no*d)**(-2/3),Q.alta=Q.a*(1+Q.ecco)-1,Q.altp=Q.a*(1-Q.ecco)-1,Q.error=0,Ne>=0||Q.no>=0){if(Q.isimp=0,Fe<1.034492841559484&&(Q.isimp=1),B=1.0122292801892716,F=1.880279159015271e-9,N=(Fe-1)*c,N<156){B=N-78,N<98&&(B=20);let e=(120-B)/c;F=e*e*e*e,B=B/c+1}se=1/Pe,Z=1/($-B),Q.eta=$*Q.ecco*Z,O=Q.eta*Q.eta,D=Q.ecco*Q.eta,P=Math.abs(1-O),S=F*Z**4,C=S/P**3.5,ie=C*Q.no*($*(1+1.5*O+D*(4+O))+.375*f*Z/P*Q.con41*(8+3*O*(8+O))),Q.cc1=Q.bstar*ie,x=0,Q.ecco>1e-4&&(x=-2*S*Z*p*Q.no*Le/Q.ecco),Q.x1mth2=1-je,Q.cc4=2*Q.no*C*$*Ne*(Q.eta*(2+.5*O)+Q.ecco*(.5+2*O)-f*Z/($*P)*(-3*Q.con41*(1-2*D+O*(1.5-.5*D))+.75*Q.x1mth2*(2*O-D*(1+O))*Math.cos(2*Q.argpo))),Q.cc5=2*C*$*Ne*(1+2.75*(O+D)+D*O),w=je*je,me=1.5*f*se*Q.no,he=.5*me*f*se,ge=-.46875*-165597e-11*se*se*Q.no,Q.mdot=Q.no+.5*me*Ie*Q.con41+.0625*he*Ie*(13-78*je+137*w),Q.argpdot=-.5*me*ke+.0625*he*(7-114*je+395*w)+ge*(3-36*je+49*w),ve=-me*Ae,Q.nodedot=ve+(.5*he*(4-19*je)+2*ge*(3-7*je))*Ae,_e=Q.argpdot+Q.nodedot,Q.omgcof=Q.bstar*x*Math.cos(Q.argpo),Q.xmcof=0,Q.ecco>1e-4&&(Q.xmcof=-m*S*Q.bstar/D),Q.nodecf=3.5*Ne*ve*Q.cc1,Q.t2cof=1.5*Q.cc1,Math.abs(Ae+1)>15e-13?Q.xlcof=-.25*p*Le*(3+5*Ae)/(1+Ae):Q.xlcof=-.25*p*Le*(3+5*Ae)/15e-13,Q.aycof=-.5*p*Le;let e=1+Q.eta*Math.cos(Q.mo);if(Q.delmo=e*e*e,Q.sinmao=Math.sin(Q.mo),Q.x7thm1=7*je-1,2*a/Q.no>=225){Q.method=`d`,Q.isimp=1,fe=0,j=Q.inclo;let e=_({epoch:i,ep:Q.ecco,argpp:Q.argpo,tc:fe,inclp:Q.inclo,nodep:Q.nodeo,np:Q.no,e3:Q.e3,ee2:Q.ee2,peo:Q.peo,pgho:Q.pgho,pho:Q.pho,pinco:Q.pinco,plo:Q.plo,se2:Q.se2,se3:Q.se3,sgh2:Q.sgh2,sgh3:Q.sgh3,sgh4:Q.sgh4,sh2:Q.sh2,sh3:Q.sh3,si2:Q.si2,si3:Q.si3,sl2:Q.sl2,sl3:Q.sl3,sl4:Q.sl4,xgh2:Q.xgh2,xgh3:Q.xgh3,xgh4:Q.xgh4,xh2:Q.xh2,xh3:Q.xh3,xi2:Q.xi2,xi3:Q.xi3,xl2:Q.xl2,xl3:Q.xl3,xl4:Q.xl4,zmol:Q.zmol,zmos:Q.zmos});Q.e3=e.e3,Q.ee2=e.ee2,Q.peo=e.peo,Q.pgho=e.pgho,Q.pho=e.pho,Q.pinco=e.pinco,Q.plo=e.plo,Q.se2=e.se2,Q.se3=e.se3,Q.sgh2=e.sgh2,Q.sgh3=e.sgh3,Q.sgh4=e.sgh4,Q.sh2=e.sh2,Q.sh3=e.sh3,Q.si2=e.si2,Q.si3=e.si3,Q.sl2=e.sl2,Q.sl3=e.sl3,Q.sl4=e.sl4,{sinim:y,cosim:g,em:T,emsq:E,s1:I,s2:L,s3:R,s4:ce,s5:z,ss1:V,ss2:H,ss3:U,ss4:W,ss5:G,sz1:K,sz3:q,sz11:J,sz13:le,sz21:Y,sz23:ue,sz31:de,sz33:X}=e,Q.xgh2=e.xgh2,Q.xgh3=e.xgh3,Q.xgh4=e.xgh4,Q.xh2=e.xh2,Q.xh3=e.xh3,Q.xi2=e.xi2,Q.xi3=e.xi3,Q.xl2=e.xl2,Q.xl3=e.xl3,Q.xl4=e.xl4,Q.zmol=e.zmol,Q.zmos=e.zmos,{nm:M,z1:ye,z3:be,z11:xe,z13:Se,z21:Ce,z23:we,z31:Te,z33:Ee}=e;let t=ne(Q,{inclo:j,init:Q.init,ep:Q.ecco,inclp:Q.inclo,nodep:Q.nodeo,argpp:Q.argpo,mp:Q.mo,opsmode:Q.operationmode});Q.ecco=t.ep,Q.inclo=t.inclp,Q.nodeo=t.nodep,Q.argpo=t.argpp,Q.mo=t.mp,k=0,A=0,oe=0;let n=v({cosim:g,emsq:E,argpo:Q.argpo,s1:I,s2:L,s3:R,s4:ce,s5:z,sinim:y,ss1:V,ss2:H,ss3:U,ss4:W,ss5:G,sz1:K,sz3:q,sz11:J,sz13:le,sz21:Y,sz23:ue,sz31:de,sz33:X,t:Q.t,tc:fe,gsto:Q.gsto,mo:Q.mo,mdot:Q.mdot,no:Q.no,nodeo:Q.nodeo,nodedot:Q.nodedot,xpidot:_e,z1:ye,z3:be,z11:xe,z13:Se,z21:Ce,z23:we,z31:Te,z33:Ee,ecco:Q.ecco,eccsq:Me,em:T,argpm:k,inclm:j,mm:oe,nm:M,nodem:A,irez:Q.irez,atime:Q.atime,d2201:Q.d2201,d2211:Q.d2211,d3210:Q.d3210,d3222:Q.d3222,d4410:Q.d4410,d4422:Q.d4422,d5220:Q.d5220,d5232:Q.d5232,d5421:Q.d5421,d5433:Q.d5433,dedt:Q.dedt,didt:Q.didt,dmdt:Q.dmdt,dnodt:Q.dnodt,domdt:Q.domdt,del1:Q.del1,del2:Q.del2,del3:Q.del3,xfact:Q.xfact,xlamo:Q.xlamo,xli:Q.xli,xni:Q.xni});Q.irez=n.irez,Q.atime=n.atime,Q.d2201=n.d2201,Q.d2211=n.d2211,Q.d3210=n.d3210,Q.d3222=n.d3222,Q.d4410=n.d4410,Q.d4422=n.d4422,Q.d5220=n.d5220,Q.d5232=n.d5232,Q.d5421=n.d5421,Q.d5433=n.d5433,Q.dedt=n.dedt,Q.didt=n.didt,Q.dmdt=n.dmdt,Q.dnodt=n.dnodt,Q.domdt=n.domdt,Q.del1=n.del1,Q.del2=n.del2,Q.del3=n.del3,Q.xfact=n.xfact,Q.xlamo=n.xlamo,Q.xli=n.xli,Q.xni=n.xni}Q.isimp!==1&&(b=Q.cc1*Q.cc1,Q.d2=4*$*Z*b,pe=Q.d2*Z*Q.cc1/3,Q.d3=(17*$+B)*pe,Q.d4=.5*pe*$*Z*(221*$+31*B)*Q.cc1,Q.t3cof=Q.d2+2*b,Q.t4cof=.25*(3*Q.d3+Q.cc1*(12*Q.d2+10*b)),Q.t5cof=.2*(3*Q.d4+12*Q.cc1*Q.d3+6*Q.d2*Q.d2+15*b*(2*Q.d2+b)))}ae(Q,0),Q.init=`n`}function C(e,t=`i`){let n=e.NORAD_CAT_ID.toString(),r=new Date(e.EPOCH.endsWith(`Z`)?e.EPOCH:`${e.EPOCH}Z`),i=r.getUTCFullYear(),a=Number(i.toString().slice(-2)),o=(r.valueOf()-new Date(Date.UTC(i,0,1,0,0,0)).valueOf())/(86400*1e3)+1,c=Number(e.MEAN_MOTION_DOT),l=Number(e.MEAN_MOTION_DDOT);c/=ee*1440,l/=ee*1440*1440;let u=Number(e.BSTAR),d=Number(e.INCLINATION)*s,f=Number(e.RA_OF_ASC_NODE)*s,p=Number(e.ECCENTRICITY),m=Number(e.ARG_OF_PERICENTER)*s,h=Number(e.MEAN_ANOMALY)*s,ne=Number(e.MEAN_MOTION)/ee,{mon:_,day:v,hr:y,minute:b,sec:re}=te(i,o),ie=g(i,_,v,y,b,re),x={error:0,satnum:n,epochyr:a,epochdays:o,ndot:c,nddot:l,bstar:u,inclo:d,nodeo:f,ecco:p,argpo:m,mo:h,no:ne,jdsatepoch:ie};return S(x,{opsmode:t,satn:x.satnum,epoch:x.jdsatepoch-2433281.5,xbstar:x.bstar,xecco:x.ecco,xargpo:x.argpo,xinclo:x.inclo,xmo:x.mo,xno:x.no,xnodeo:x.nodeo}),x}3*Float64Array.BYTES_PER_ELEMENT;const w=Math.PI/180;Math.cos(i*w),Math.sin(i*w);function T(e){return new Date((e-2440587.5)*864e5).toISOString()}function E(e,t){let n=C({OBJECT_NAME:t??String(e.noradCatId),OBJECT_ID:String(e.noradCatId),EPOCH:T(e.epochJd),MEAN_MOTION:e.meanMotion,ECCENTRICITY:e.eccentricity,INCLINATION:e.inclination,RA_OF_ASC_NODE:e.raOfAscNode,ARG_OF_PERICENTER:e.argOfPericenter,MEAN_ANOMALY:e.meanAnomaly,EPHEMERIS_TYPE:0,CLASSIFICATION_TYPE:`U`,NORAD_CAT_ID:e.noradCatId,ELEMENT_SET_NO:e.elementSetNo,REV_AT_EPOCH:e.revAtEpoch,BSTAR:e.bstar,MEAN_MOTION_DOT:e.meanMotionDot,MEAN_MOTION_DDOT:e.meanMotionDdot});return n.error===x.None?n:(console.warn(`buildSatrec: SGP4 init failed for NORAD ${e.noradCatId} (error=${n.error})`),null)}const D=Math.PI/180,O=Math.cos(i*D),k=Math.sin(i*D),A=10/r;function j(e,t,n,r,i){return!isFinite(Math.fround(n))||!isFinite(Math.fround(r))||!isFinite(Math.fround(i))?!1:(e[t*3]=n,e[t*3+1]=r,e[t*3+2]=i,!0)}function oe(r,i,a,o,s,c,l,u,d,f=null,p=0){if(i<r.validityStart||i>r.validityEnd)return 0;let{count:m,kind:ee,equatorial:te,a:h,e:g,i:ne,om:_,w:v,ma:y,n:b,epoch:re,q:ie,tp:S,satrec:C,flags:w,visibleFromDays:T}=r,oe=p!==0&&r.applyFlagFilter,M=r.pickBase,N=d.length/3|0,se=i-2451545,P=0;for(let F=0;F<m&&!(P>=N);F++){let m=ee[F];if(m===0||T[F]>se||oe&&(w[F]&p)!==p)continue;if(m===3){let e=C[F];if(!e){if(e=E({noradCatId:r.satnum[F],epochJd:re[F],meanMotion:b[F]/360,eccentricity:g[F],inclination:ne[F],raOfAscNode:_[F],argOfPericenter:v[F],meanAnomaly:y[F],bstar:r.bstar[F],meanMotionDot:r.ndot[F],meanMotionDdot:r.nddot[F],elementSetNo:0,revAtEpoch:0}),!e){ee[F]=0;continue}C[F]=e}let t=(i-e.jdsatepoch)*1440,n=ae(e,t);if(!n||e.error!==x.None)continue;let p=n.position.x,m=n.position.y,te=n.position.z,h=p*A,ie=m*A,S=te*A,w=ie*O+S*k,T=-ie*k+S*O,D=h,oe=T,N=-w;if(!j(d,P,a+D-c,o+oe-l,s+N-u))continue;if(f){let e=M+F,t=P*4;f[t]=e&255,f[t+1]=e>>>8&255,f[t+2]=e>>>16&255,f[t+3]=e>>>24&255}P++;continue}let N,I,L=g[F],R=ne[F],ce=_[F],z=v[F];if(m===2){let e=n(ie[F],S[F],i);if(!e)continue;N=e.r*Math.cos(e.nu),I=e.r*Math.sin(e.nu)}else{let n=h[F];if(!isFinite(n)||!isFinite(L)||!isFinite(y[F])||!isFinite(b[F]))continue;let r=i-re[F],a=(y[F]+b[F]*r)*D,o,s;if(L<1||n>0){let t=Math.min(L,.9999999),r=e(a,t),i=Math.sqrt(1-t*t)*Math.sin(r)/(1-t*Math.cos(r)),c=(Math.cos(r)-t)/(1-t*Math.cos(r));o=Math.atan2(i,c),s=n*(1-t*Math.cos(r))}else{let e=t(a,L);if(!isFinite(e))continue;let r=L*Math.cosh(e)-1;if(Math.abs(r)<1e-15)continue;let i=Math.sqrt(L*L-1)*Math.sinh(e)/r,c=(L-Math.cosh(e))/r;o=Math.atan2(i,c),s=n*(1-L*Math.cosh(e))}N=s*Math.cos(o),I=s*Math.sin(o)}if(!isFinite(N)||!isFinite(I))continue;let B=Math.cos(z*D),V=Math.sin(z*D),H=Math.cos(R*D),U=Math.sin(R*D),W=Math.cos(ce*D),G=Math.sin(ce*D),K=(W*B-G*V*H)*N+(-W*V-G*B*H)*I,q=(G*B+W*V*H)*N+(-G*V+W*B*H)*I,J=V*U*N+B*U*I;if(te[F]){let e=q*O+J*k,t=-q*k+J*O;q=e,J=t}let le=K*10,Y=J*10,ue=-q*10;if(j(d,P,a+le-c,o+Y-l,s+ue-u)){if(f){let e=M+F,t=P*4;f[t]=e&255,f[t+1]=e>>>8&255,f[t+2]=e>>>16&255,f[t+3]=e>>>24&255}P++}}return P}const M=new Map;self.onmessage=e=>{let t=e.data;if(t.type===`ping`){self.postMessage({type:`pong`});return}if(t.type===`rewireDelta`){if(t.remove)for(let e of t.remove)M.delete(e);for(let e of t.set)M.set(e.id,e.cols);return}if(t.type===`tick`){let e=[],n=[],[r,i,a]=t.basis;for(let o of t.groups){let s=M.get(o.id);if(!s){e.push({id:o.id,count:0,buf:o.out.buffer,idbuf:o.outIds.buffer}),n.push(o.out.buffer,o.outIds.buffer);continue}let c=oe(s,t.jd,o.parent[0],o.parent[1],o.parent[2],r,i,a,o.out,o.outIds,t.requiredFlags??0);e.push({id:o.id,count:c,buf:o.out.buffer,idbuf:o.outIds.buffer}),n.push(o.out.buffer,o.outIds.buffer)}self.postMessage({type:`tickResult`,groups:e},n);return}};";
+var jsContent = "function e(e,t,n=1e-10,r=50){let i=e;for(let a=0;a<r;a++){let r=(i-t*Math.sin(i)-e)/(1-t*Math.cos(i));if(i-=Math.max(-1,Math.min(1,r)),Math.abs(r)<n)break}return i}function t(e,t,n=1e-10,r=50){if(e===0)return 0;let i=e<0?-1:1,a=Math.abs(e),o=0,s=1;for(;t*Math.sinh(s)-s<a;)if(s*=2,s>700)return NaN;let c=.5*(o+s);for(let e=0;e<r;e++){let e=t*Math.sinh(c)-c-a;e>0?s=c:o=c;let r=c-e/(t*Math.cosh(c)-1);r>o&&r<s||(r=.5*(o+s));let i=Math.abs(r-c);if(c=r,i<n)break}return i*c}function n(e,t,n){let r=.01720209895*(n-t)/(Math.sqrt(2)*e**1.5),i=Math.cbrt(3*r+Math.sqrt(1+9*r*r)),a=i-1/i,o=2*Math.atan(a),s=e*(1+a*a);return!isFinite(o)||!isFinite(s)||s<=0?null:{nu:o,r:s}}const r=149597870.7,i=23.4392911;86400**2/r**3,1/r,Math.cos(Math.PI/180*i),Math.sin(Math.PI/180*i);const a=Math.PI,o=a*2,s=a/180;180/a;const c=6378.135,l=60/Math.sqrt(c*c*c/398600.8),u=c*l/60,d=1/l,f=.001082616,p=-253881e-11/f,m=2/3,ee=1440/(2*a);function te(e,t){let n=[31,e%4==0?29:28,31,30,31,30,31,31,30,31,30,31],r=Math.floor(t),i=1,a=0;for(;r>a+n[i-1]&&i<12;)a+=n[i-1],i+=1;let o=i,s=r-a,c=(t-r)*24,l=Math.floor(c);c=(c-l)*60;let u=Math.floor(c);return{mon:o,day:s,hr:l,minute:u,sec:(c-u)*60}}function h(e,t,n,r,i,a,o=0){return 367*e-Math.floor(7*(e+Math.floor((t+9)/12))*.25)+Math.floor(275*t/9)+n+1721013.5+((o/6e4+a/60+i)/60+r)/24}function g(e,t,n,r,i,a,o=0){if(e instanceof Date){let t=e;return h(t.getUTCFullYear(),t.getUTCMonth()+1,t.getUTCDate(),t.getUTCHours(),t.getUTCMinutes(),t.getUTCSeconds(),t.getUTCMilliseconds())}return h(e,t,n,r,i,a,o)}function ne(e,t){let{e3:n,ee2:r,peo:i,pgho:s,pho:c,pinco:l,plo:u,se2:d,se3:f,sgh2:p,sgh3:m,sgh4:ee,sh2:te,sh3:h,si2:g,si3:ne,sl2:_,sl3:v,sl4:y,t:b,xgh2:re,xgh3:ie,xgh4:x,xh2:ae,xh3:S,xi2:C,xi3:w,xl2:T,xl3:E,xl4:D,zmol:O,zmos:k}=e,{init:A,opsmode:j}=t,{ep:oe,inclp:M,nodep:N,argpp:P,mp:se}=t,F,I,L,R,ce,z,B,V,H,U,W,G,K,q,J,Y,X,le,ue,de,fe;fe=k+119459e-10*b,A===`y`&&(fe=k),de=fe+2*.01675*Math.sin(fe),X=Math.sin(de),U=.5*X*X-.25,W=-.5*X*Math.cos(de);let pe=d*U+f*W,me=g*U+ne*W,he=_*U+v*W+y*X,ge=p*U+m*W+ee*X,Z=te*U+h*W;fe=O+.00015835218*b,A===`y`&&(fe=O),de=fe+2*.0549*Math.sin(fe),X=Math.sin(de),U=.5*X*X-.25,W=-.5*X*Math.cos(de);let _e=r*U+n*W,ve=C*U+w*W,ye=T*U+E*W+D*X,be=re*U+ie*W+x*X,xe=ae*U+S*W;return G=pe+_e,J=me+ve,Y=he+ye,K=ge+be,q=Z+xe,A===`n`&&(G-=i,J-=l,Y-=u,K-=s,q-=c,M+=J,oe+=G,R=Math.sin(M),L=Math.cos(M),M>=.2?(q/=R,K-=L*q,P+=K,N+=q,se+=Y):(z=Math.sin(N),ce=Math.cos(N),F=R*z,I=R*ce,B=q*ce+J*L*z,V=-q*z+J*L*ce,F+=B,I+=V,N%=o,N<0&&j===`a`&&(N+=o),le=se+P+L*N,H=Y+K-J*N*R,le+=H,ue=N,N=Math.atan2(F,I),N<0&&j===`a`&&(N+=o),Math.abs(ue-N)>a&&(N<ue?N+=o:N-=o),se+=Y,P=le-se-L*N)),{ep:oe,inclp:M,nodep:N,argpp:P,mp:se}}function _(e){let{epoch:t,ep:n,argpp:r,tc:i,inclp:a,nodep:s,np:c}=e,l,u,d,f,p,m,ee,te,h,g,ne,_,v,y,b,re,ie,x,ae,S,C,w,T,E,D,O,k,A,j,oe,M,N,P,se,F,I,L,R,ce,z,B,V,H,U,W,G,K,q,J,Y,X,le,ue,de,fe,pe,me,he,ge,Z,_e,ve,ye,be=.01675,xe=.0549,Se=c,Ce=n,we=Math.sin(s),Te=Math.cos(s),Ee=Math.sin(r),Q=Math.cos(r),De=Math.sin(a),Oe=Math.cos(a),$=Ce*Ce,ke=1-$,Ae=Math.sqrt(ke),je=t+18261.5+i/1440,Me=(4.523602-.00092422029*je)%o,Ne=Math.sin(Me),Pe=Math.cos(Me),Fe=.91375164-.03568096*Pe,Ie=Math.sqrt(1-Fe*Fe),Le=.089683511*Ne/Ie,Re=Math.sqrt(1-Le*Le),ze=5.8351514+.001944368*je,Be=.39785416*Ne/Ie,Ve=Re*Pe+.91744867*Le*Ne;Be=Math.atan2(Be,Ve),Be+=ze-Me;let He=Math.cos(Be),Ue=Math.sin(Be);S=.1945905,C=-.98088458,E=.91744867,D=.39785416,w=Te,T=we,ne=29864797e-13;let We=1/Se,Ge=0;for(;Ge<2;)Ge+=1,l=S*w+C*E*T,d=-C*w+S*E*T,ee=-S*T+C*E*w,te=C*D,h=C*T+S*E*w,g=S*D,u=Oe*ee+De*te,f=Oe*h+De*g,p=-De*ee+Oe*te,m=-De*h+Oe*g,_=l*Q+u*Ee,v=d*Q+f*Ee,y=-l*Ee+u*Q,b=-d*Ee+f*Q,re=p*Ee,ie=m*Ee,x=p*Q,ae=m*Q,_e=12*_*_-3*y*y,ve=24*_*v-6*y*b,ye=12*v*v-3*b*b,le=3*(l*l+u*u)+_e*$,ue=6*(l*d+u*f)+ve*$,de=3*(d*d+f*f)+ye*$,fe=-6*l*p+$*(-24*_*x-6*y*re),pe=-6*(l*m+d*p)+$*(-24*(v*x+_*ae)+-6*(y*ie+b*re)),me=-6*d*m+$*(-24*v*ae-6*b*ie),he=6*u*p+$*(24*_*re-6*y*x),ge=6*(f*p+u*m)+$*(24*(v*re+_*ie)-6*(b*x+y*ae)),Z=6*f*m+$*(24*v*ie-6*b*ae),le=le+le+ke*_e,ue=ue+ue+ke*ve,de=de+de+ke*ye,K=ne*We,G=-.5*K/Ae,q=K*Ae,W=-15*Ce*q,J=_*y+v*b,Y=v*y+_*b,X=v*b-_*y,Ge===1&&(O=W,k=G,A=K,j=q,oe=J,M=Y,N=X,P=le,se=ue,F=de,I=fe,L=pe,R=me,ce=he,z=ge,B=Z,V=_e,H=ve,U=ye,S=He,C=Ue,E=Fe,D=Ie,w=Re*Te+Le*we,T=we*Re-Te*Le,ne=4.7968065e-7);let Ke=(4.7199672+(.2299715*je-ze))%o,qe=(6.2565837+.017201977*je)%o,Je=2*O*M,Ye=2*O*N,Xe=2*k*L,Ze=2*k*(R-I),Qe=-2*A*se,$e=-2*A*(F-P),et=-2*A*(-21-9*$)*be,tt=2*j*H,nt=2*j*(U-V),rt=-18*j*be,it=-2*k*z,at=-2*k*(B-ce),ot=2*W*Y,st=2*W*X,ct=2*G*pe,lt=2*G*(me-fe),ut=-2*K*ue,dt=-2*K*(de-le),ft=-2*K*(-21-9*$)*xe,pt=2*q*ve,mt=2*q*(ye-_e),ht=-18*q*xe,gt=-2*G*ge,_t=-2*G*(Z-he);return{snodm:we,cnodm:Te,sinim:De,cosim:Oe,sinomm:Ee,cosomm:Q,day:je,e3:st,ee2:ot,em:Ce,emsq:$,gam:ze,peo:0,pgho:0,pho:0,pinco:0,plo:0,rtemsq:Ae,se2:Je,se3:Ye,sgh2:tt,sgh3:nt,sgh4:rt,sh2:it,sh3:at,si2:Xe,si3:Ze,sl2:Qe,sl3:$e,sl4:et,s1:W,s2:G,s3:K,s4:q,s5:J,s6:Y,s7:X,ss1:O,ss2:k,ss3:A,ss4:j,ss5:oe,ss6:M,ss7:N,sz1:P,sz2:se,sz3:F,sz11:I,sz12:L,sz13:R,sz21:ce,sz22:z,sz23:B,sz31:V,sz32:H,sz33:U,xgh2:pt,xgh3:mt,xgh4:ht,xh2:gt,xh3:_t,xi2:ct,xi3:lt,xl2:ut,xl3:dt,xl4:ft,nm:Se,z1:le,z2:ue,z3:de,z11:fe,z12:pe,z13:me,z21:he,z22:ge,z23:Z,z31:_e,z32:ve,z33:ye,zmol:Ke,zmos:qe}}function v(e){let{cosim:t,argpo:n,s1:r,s2:i,s3:s,s4:c,s5:u,sinim:d,ss1:f,ss2:p,ss3:ee,ss4:te,ss5:h,sz1:g,sz3:ne,sz11:_,sz13:v,sz21:y,sz23:b,sz31:re,sz33:ie,t:x,tc:ae,gsto:S,mo:C,mdot:w,no:T,nodeo:E,nodedot:D,xpidot:O,z1:k,z3:A,z11:j,z13:oe,z21:M,z23:N,z31:P,z33:se,ecco:F,eccsq:I}=e,{emsq:L,em:R,argpm:ce,inclm:z,mm:B,nm:V,nodem:H,irez:U,atime:W,d2201:G,d2211:K,d3210:q,d3222:J,d4410:Y,d4422:X,d5220:le,d5232:ue,d5421:de,d5433:fe,dedt:pe,didt:me,dmdt:he,dnodt:ge,domdt:Z,del1:_e,del2:ve,del3:ye,xfact:be,xlamo:xe,xli:Se,xni:Ce}=e,we,Te,Ee,Q,De,Oe,$,ke,Ae,je,Me,Ne,Pe,Fe,Ie,Le,Re,ze,Be,Ve,He,Ue,We,Ge,Ke,qe,Je,Ye,Xe,Ze,Qe,$e,et=.0043752690880113,tt=.00015835218,nt=119459e-10;U=0,V<.0052359877&&V>.0034906585&&(U=1),V>=.00826&&V<=.00924&&R>=.5&&(U=2);let rt=f*nt*h,it=p*nt*(_+v),at=-nt*ee*(g+ne-14-6*L),ot=te*nt*(re+ie-6),st=-nt*p*(y+b);(z<.052359877||z>a-.052359877)&&(st=0),d!==0&&(st/=d);let ct=ot-t*st;pe=rt+r*tt*u,me=it+i*tt*(j+oe),he=at-tt*s*(k+A-14-6*L);let lt=c*tt*(P+se-6),ut=-tt*i*(M+N);(z<.052359877||z>a-.052359877)&&(ut=0),Z=ct+lt,ge=st,d!==0&&(Z-=t/d*ut,ge+=ut/d);let dt=(S+ae*et)%o;if(R+=pe*x,z+=me*x,ce+=Z*x,H+=ge*x,B+=he*x,U!==0){if(Ze=(V/l)**m,U===2){Qe=t*t;let e=R;R=F;let n=L;L=I,$e=R*L,Fe=-.306-(R-.64)*.44,R<=.65?(Ie=3.616-13.247*R+16.29*L,Re=-19.302+117.39*R-228.419*L+156.591*$e,ze=-18.9068+109.7927*R-214.6334*L+146.5816*$e,Be=-41.122+242.694*R-471.094*L+313.953*$e,Ve=-146.407+841.88*R-1629.014*L+1083.435*$e,He=-532.114+3017.977*R-5740.032*L+3708.276*$e):(Ie=-72.099+331.819*R-508.738*L+266.724*$e,Re=-346.844+1582.851*R-2415.925*L+1246.113*$e,ze=-342.585+1554.908*R-2366.899*L+1215.972*$e,Be=-1052.797+4758.686*R-7193.992*L+3651.957*$e,Ve=-3581.69+16178.11*R-24462.77*L+12422.52*$e,He=R>.715?-5149.66+29936.92*R-54087.36*L+31324.56*$e:1464.74-4664.75*R+3763.64*L),R<.7?(Ge=-919.2277+4988.61*R-9064.77*L+5542.21*$e,Ue=-822.71072+4568.6173*R-8491.4146*L+5337.524*$e,We=-853.666+4690.25*R-8624.77*L+5341.4*$e):(Ge=-37995.78+161616.52*R-229838.2*L+109377.94*$e,Ue=-51752.104+218913.95*R-309468.16*L+146349.42*$e,We=-40023.88+170470.89*R-242699.48*L+115605.82*$e),Ke=d*d,we=.75*(1+2*t+Qe),Te=1.5*Ke,Q=1.875*d*(1-2*t-3*Qe),De=-1.875*d*(1+2*t-3*Qe),$=35*Ke*we,ke=39.375*Ke*Ke,Ae=9.84375*d*(Ke*(1-2*t-5*Qe)+.33333333*(-2+4*t+6*Qe)),je=d*(4.92187512*Ke*(-2-4*t+10*Qe)+6.56250012*(1+2*t-3*Qe)),Me=29.53125*d*(2-8*t+Qe*(-12+8*t+10*Qe)),Ne=29.53125*d*(-2-8*t+Qe*(12+8*t-10*Qe)),Ye=V*V,Xe=Ze*Ze,Je=3*Ye*Xe,qe=Je*17891679e-13,G=qe*we*Fe,K=qe*Te*Ie,Je*=Ze,qe=Je*3.7393792e-7,q=qe*Q*Re,J=qe*De*ze,Je*=Ze,qe=2*Je*7.3636953e-9,Y=qe*$*Be,X=qe*ke*Ve,Je*=Ze,qe=Je*1.1428639e-7,le=qe*Ae*He,ue=qe*je*We,qe=2*Je*2.1765803e-9,de=qe*Me*Ue,fe=qe*Ne*Ge,xe=(C+E+E-(dt+dt))%o,be=w+he+2*(D+ge-et)-T,R=e,L=n}U===1&&(Pe=1+L*(-2.5+.8125*L),Re=1+2*L,Le=1+L*(-6+6.60937*L),we=.75*(1+t)*(1+t),Ee=.9375*d*d*(1+3*t)-.75*(1+t),Oe=1+t,Oe*=1.875*Oe*Oe,_e=3*V*V*Ze*Ze,ve=2*_e*we*Pe*17891679e-13,ye=3*_e*Oe*Le*2.2123015e-7*Ze,_e=_e*Ee*Re*21460748e-13*Ze,xe=(C+E+n-dt)%o,be=w+O+he+Z+ge-(T+et)),Se=xe,Ce=T,W=0,V=T+0}return{em:R,argpm:ce,inclm:z,mm:B,nm:V,nodem:H,irez:U,atime:W,d2201:G,d2211:K,d3210:q,d3222:J,d4410:Y,d4422:X,d5220:le,d5232:ue,d5421:de,d5433:fe,dedt:pe,didt:me,dmdt:he,dndt:0,dnodt:ge,domdt:Z,del1:_e,del2:ve,del3:ye,xfact:be,xlamo:xe,xli:Se,xni:Ce}}function y(e){let t=(e-2451545)/36525,n=-62e-7*t*t*t+.093104*t*t+3164400184.812866*t+67310.54841;return n=n*s/240%o,n<0&&(n+=o),n}function b(e,t,n,r,i,a,o){return e instanceof Date?y(g(e)):y(t===void 0?e:g(e,t,n,r,i,a,o))}function re(e){let{ecco:t,epoch:n,inclo:r,opsmode:i}=e,{no:a}=e,s=t*t,c=1-s,u=Math.sqrt(c),d=Math.cos(r),p=d*d,ee=(l/a)**m,te=.75*f*(3*p-1)/(u*c),h=te/(ee*ee),g=ee*(1-h*h-h*(1/3+134*h*h/81));h=te/(g*g),a/=1+h;let ne=(l/a)**m,_=Math.sin(r),v=ne*c,y=1-5*p,re=-y-p-p,ie=1/ne,x=v*v,ae=ne*(1-t),S;if(i===`a`){let e=n-7305,t=Math.floor(e+1e-8),r=e-t,i=.017202791694070362,a=i+o;S=(1.7321343856509375+i*t+a*r+e*e*5075514194322695e-30)%o,S<0&&(S+=o)}else S=b(n+2433281.5);return{no:a,method:`n`,ainv:ie,ao:ne,con41:re,con42:y,cosio:d,cosio2:p,eccsq:s,omeosq:c,posq:x,rp:ae,rteosq:u,sinio:_,gsto:S}}function ie(e){let{irez:t,d2201:n,d2211:r,d3210:i,d3222:a,d4410:s,d4422:c,d5220:l,d5232:u,d5421:d,d5433:f,dedt:p,del1:m,del2:ee,del3:te,didt:h,dmdt:g,dnodt:ne,domdt:_,argpo:v,argpdot:y,t:b,tc:re,gsto:ie,xfact:x,xlamo:ae,no:S}=e,{atime:C,em:w,argpm:T,inclm:E,xli:D,mm:O,xni:k,nodem:A,nm:j}=e,oe=.13130908,M=2.8843198,N=.37448087,P=5.7686396,se=.95240898,F=1.8014998,I=1.050833,L=4.4108898,R=259200,ce,z,B,V,H,U,W,G,K=0,q=0,J=(ie+re*.0043752690880113)%o;if(w+=p*b,E+=h*b,T+=_*b,A+=ne*b,O+=g*b,t!==0){(C===0||b*C<=0||Math.abs(b)<Math.abs(C))&&(C=0,k=S,D=ae),ce=b>0?720:-720;let e=381;for(;e===381;)t===2?(G=v+y*C,B=G+G,z=D+D,W=n*Math.sin(B+D-P)+r*Math.sin(D-P)+i*Math.sin(G+D-se)+a*Math.sin(-G+D-se)+s*Math.sin(B+z-F)+c*Math.sin(z-F)+l*Math.sin(G+D-I)+u*Math.sin(-G+D-I)+d*Math.sin(G+z-L)+f*Math.sin(-G+z-L),H=k+x,U=n*Math.cos(B+D-P)+r*Math.cos(D-P)+i*Math.cos(G+D-se)+a*Math.cos(-G+D-se)+l*Math.cos(G+D-I)+u*Math.cos(-G+D-I)+2*(s*Math.cos(B+z-F)+c*Math.cos(z-F)+d*Math.cos(G+z-L)+f*Math.cos(-G+z-L)),U*=H):(W=m*Math.sin(D-oe)+ee*Math.sin(2*(D-M))+te*Math.sin(3*(D-N)),H=k+x,U=m*Math.cos(D-oe)+2*ee*Math.cos(2*(D-M))+3*te*Math.cos(3*(D-N)),U*=H),Math.abs(b-C)>=720?e=381:(q=b-C,e=0),e===381&&(D+=H*ce+W*R,k+=W*ce+U*R,C+=ce);j=k+W*q+U*q*q*.5,V=D+H*q+W*q*q*.5,t===1?(O=V-A-T+J,K=j-S):(O=V-2*A+2*J,K=j-S),j=S+K}return{atime:C,em:w,argpm:T,inclm:E,xli:D,mm:O,xni:k,nodem:A,dndt:K,nm:j}}var x;(function(e){e[e.None=0]=`None`,e[e.MeanEccentricityOutOfRange=1]=`MeanEccentricityOutOfRange`,e[e.MeanMotionBelowZero=2]=`MeanMotionBelowZero`,e[e.PerturbedEccentricityOutOfRange=3]=`PerturbedEccentricityOutOfRange`,e[e.SemiLatusRectumBelowZero=4]=`SemiLatusRectumBelowZero`,e[e.Decayed=6]=`Decayed`})(x||={});function ae(e,t){let n,r,i,s,d,ee,te,h,g,_,v,y,b,re,ae,S,C,w,T,E,D,O,k,A,j,oe,M;e.t=t,e.error=x.None;let N=e.mo+e.mdot*e.t,P=e.argpo+e.argpdot*e.t,se=e.nodeo+e.nodedot*e.t;g=P,D=N;let F=e.t*e.t;if(k=se+e.nodecf*F,C=1-e.cc1*e.t,w=e.bstar*e.cc4*e.t,T=e.t2cof*F,e.isimp!==1){te=e.omgcof*e.t;let t=1+e.eta*Math.cos(N);ee=e.xmcof*(t*t*t-e.delmo),S=te+ee,D=N+S,g=P-S,y=F*e.t,b=y*e.t,C=C-e.d2*F-e.d3*y-e.d4*b,w+=e.bstar*e.cc5*(Math.sin(D)-e.sinmao),T=T+e.t3cof*y+b*(e.t4cof+e.t*e.t5cof)}O=e.no;let I=e.ecco;if(E=e.inclo,e.method===`d`){re=e.t;let t=ie({irez:e.irez,d2201:e.d2201,d2211:e.d2211,d3210:e.d3210,d3222:e.d3222,d4410:e.d4410,d4422:e.d4422,d5220:e.d5220,d5232:e.d5232,d5421:e.d5421,d5433:e.d5433,dedt:e.dedt,del1:e.del1,del2:e.del2,del3:e.del3,didt:e.didt,dmdt:e.dmdt,dnodt:e.dnodt,domdt:e.domdt,argpo:e.argpo,argpdot:e.argpdot,t:e.t,tc:re,gsto:e.gsto,xfact:e.xfact,xlamo:e.xlamo,no:e.no,atime:e.atime,em:I,argpm:g,inclm:E,xli:e.xli,mm:D,xni:e.xni,nodem:k,nm:O});({em:I,argpm:g,inclm:E,mm:D,nodem:k,nm:O}=t)}if(O<=0)return e.error=x.MeanMotionBelowZero,null;let L=(l/O)**m*C*C;if(O=l/L**1.5,I-=w,I>=1||I<-.001)return e.error=x.MeanEccentricityOutOfRange,null;I<1e-6&&(I=1e-6),D+=e.no*T,j=D+g+k,k%=o,g%=o,j%=o,D=(j-g-k)%o;let R={am:L,em:I,im:E,Om:k,om:g,mm:D,nm:O},ce=Math.sin(E),z=Math.cos(E),B=I;if(A=E,_=g,M=k,oe=D,s=ce,i=z,e.method===`d`){let t=ne(e,{inclo:e.inclo,init:`n`,ep:B,inclp:A,nodep:M,argpp:_,mp:oe,opsmode:e.operationmode});if({ep:B,nodep:M,argpp:_,mp:oe}=t,A=t.inclp,A<0&&(A=-A,M+=a,_-=a),B<0||B>1)return e.error=x.PerturbedEccentricityOutOfRange,null}e.method===`d`&&(s=Math.sin(A),i=Math.cos(A),e.aycof=-.5*p*s,Math.abs(i+1)>15e-13?e.xlcof=-.25*p*s*(3+5*i)/(1+i):e.xlcof=-.25*p*s*(3+5*i)/15e-13);let V=B*Math.cos(_);S=1/(L*(1-B*B));let H=B*Math.sin(_)+S*e.aycof,U=(oe+_+M+S*e.xlcof*V-M)%o;h=U,ae=9999.9;let W=1;for(;Math.abs(ae)>=1e-12&&W<=10;)r=Math.sin(h),n=Math.cos(h),ae=1-n*V-r*H,ae=(U-H*n+V*r-h)/ae,Math.abs(ae)>=.95&&(ae=ae>0?.95:-.95),h+=ae,W+=1;let G=V*n+H*r,K=V*r-H*n,q=V*V+H*H,J=L*(1-q);if(J<0)return e.error=x.SemiLatusRectumBelowZero,null;let Y=L*(1-G),X=Math.sqrt(L)*K/Y,le=Math.sqrt(J)/Y,ue=Math.sqrt(1-q);S=K/(1+ue);let de=L/Y*(r-H-V*S),fe=L/Y*(n-V+H*S);v=Math.atan2(de,fe);let pe=(fe+fe)*de,me=1-2*de*de;S=1/J;let he=.5*f*S,ge=he*S;e.method===`d`&&(d=i*i,e.con41=3*d-1,e.x1mth2=1-d,e.x7thm1=7*d-1);let Z=Y*(1-1.5*ge*ue*e.con41)+.5*he*e.x1mth2*me;if(Z<1)return e.error=x.Decayed,null;v-=.25*ge*e.x7thm1*pe;let _e=M+1.5*ge*i*pe,ve=A+1.5*ge*i*s*me,ye=X-O*he*e.x1mth2*pe/l,be=le+O*he*(e.x1mth2*me+1.5*e.con41)/l,xe=Math.sin(v),Se=Math.cos(v),Ce=Math.sin(_e),we=Math.cos(_e),Te=Math.sin(ve),Ee=Math.cos(ve),Q=-Ce*Ee,De=we*Ee,Oe=Q*xe+we*Se,$=De*xe+Ce*Se,ke=Te*xe,Ae=Q*Se-we*xe,je=De*Se-Ce*xe,Me=Te*Se;return{position:{x:Z*Oe*c,y:Z*$*c,z:Z*ke*c},velocity:{x:(ye*Oe+be*Ae)*u,y:(ye*$+be*je)*u,z:(ye*ke+be*Me)*u},meanElements:R}}function S(e,t){let{opsmode:n,satn:r,epoch:i,xbstar:o,xecco:s,xargpo:l,xinclo:u,xmo:ee,xno:te,xnodeo:h}=t,g,y,b,ie,x,S,C,w,T,E,D,O,k,A,j,oe,M,N,P,se,F,I,L,R,ce,z,B,V,H,U,W,G,K,q,J,Y,X,le,ue,de,fe,pe,me,he,ge,Z,_e,ve,ye,be,xe,Se,Ce,we,Te,Ee,Q=e;Q.isimp=0,Q.method=`n`,Q.aycof=0,Q.con41=0,Q.cc1=0,Q.cc4=0,Q.cc5=0,Q.d2=0,Q.d3=0,Q.d4=0,Q.delmo=0,Q.eta=0,Q.argpdot=0,Q.omgcof=0,Q.sinmao=0,Q.t=0,Q.t2cof=0,Q.t3cof=0,Q.t4cof=0,Q.t5cof=0,Q.x1mth2=0,Q.x7thm1=0,Q.mdot=0,Q.nodedot=0,Q.xlcof=0,Q.xmcof=0,Q.nodecf=0,Q.irez=0,Q.d2201=0,Q.d2211=0,Q.d3210=0,Q.d3222=0,Q.d4410=0,Q.d4422=0,Q.d5220=0,Q.d5232=0,Q.d5421=0,Q.d5433=0,Q.dedt=0,Q.del1=0,Q.del2=0,Q.del3=0,Q.didt=0,Q.dmdt=0,Q.dnodt=0,Q.domdt=0,Q.e3=0,Q.ee2=0,Q.peo=0,Q.pgho=0,Q.pho=0,Q.pinco=0,Q.plo=0,Q.se2=0,Q.se3=0,Q.sgh2=0,Q.sgh3=0,Q.sgh4=0,Q.sh2=0,Q.sh3=0,Q.si2=0,Q.si3=0,Q.sl2=0,Q.sl3=0,Q.sl4=0,Q.gsto=0,Q.xfact=0,Q.xgh2=0,Q.xgh3=0,Q.xgh4=0,Q.xh2=0,Q.xh3=0,Q.xi2=0,Q.xi3=0,Q.xl2=0,Q.xl3=0,Q.xl4=0,Q.xlamo=0,Q.zmol=0,Q.zmos=0,Q.atime=0,Q.xli=0,Q.xni=0,Q.bstar=o,Q.ecco=s,Q.argpo=l,Q.inclo=u,Q.mo=ee,Q.no=te,Q.nodeo=h,Q.operationmode=n,78/c+1;let De=42/c;De*De*De*De,Q.init=`y`,Q.t=0;let Oe=re({satn:r,ecco:Q.ecco,epoch:i,inclo:Q.inclo,no:Q.no,method:Q.method,opsmode:Q.operationmode}),{ao:$,con42:ke,cosio:Ae,cosio2:je,eccsq:Me,omeosq:Ne,posq:Pe,rp:Fe,rteosq:Ie,sinio:Le}=Oe;if(Q.no=Oe.no,Q.con41=Oe.con41,Q.gsto=Oe.gsto,Q.a=(Q.no*d)**(-2/3),Q.alta=Q.a*(1+Q.ecco)-1,Q.altp=Q.a*(1-Q.ecco)-1,Q.error=0,Ne>=0||Q.no>=0){if(Q.isimp=0,Fe<1.034492841559484&&(Q.isimp=1),B=1.0122292801892716,F=1.880279159015271e-9,N=(Fe-1)*c,N<156){B=N-78,N<98&&(B=20);let e=(120-B)/c;F=e*e*e*e,B=B/c+1}P=1/Pe,Z=1/($-B),Q.eta=$*Q.ecco*Z,O=Q.eta*Q.eta,D=Q.ecco*Q.eta,se=Math.abs(1-O),S=F*Z**4,C=S/se**3.5,ie=C*Q.no*($*(1+1.5*O+D*(4+O))+.375*f*Z/se*Q.con41*(8+3*O*(8+O))),Q.cc1=Q.bstar*ie,x=0,Q.ecco>1e-4&&(x=-2*S*Z*p*Q.no*Le/Q.ecco),Q.x1mth2=1-je,Q.cc4=2*Q.no*C*$*Ne*(Q.eta*(2+.5*O)+Q.ecco*(.5+2*O)-f*Z/($*se)*(-3*Q.con41*(1-2*D+O*(1.5-.5*D))+.75*Q.x1mth2*(2*O-D*(1+O))*Math.cos(2*Q.argpo))),Q.cc5=2*C*$*Ne*(1+2.75*(O+D)+D*O),w=je*je,me=1.5*f*P*Q.no,he=.5*me*f*P,ge=-.46875*-165597e-11*P*P*Q.no,Q.mdot=Q.no+.5*me*Ie*Q.con41+.0625*he*Ie*(13-78*je+137*w),Q.argpdot=-.5*me*ke+.0625*he*(7-114*je+395*w)+ge*(3-36*je+49*w),ve=-me*Ae,Q.nodedot=ve+(.5*he*(4-19*je)+2*ge*(3-7*je))*Ae,_e=Q.argpdot+Q.nodedot,Q.omgcof=Q.bstar*x*Math.cos(Q.argpo),Q.xmcof=0,Q.ecco>1e-4&&(Q.xmcof=-m*S*Q.bstar/D),Q.nodecf=3.5*Ne*ve*Q.cc1,Q.t2cof=1.5*Q.cc1,Math.abs(Ae+1)>15e-13?Q.xlcof=-.25*p*Le*(3+5*Ae)/(1+Ae):Q.xlcof=-.25*p*Le*(3+5*Ae)/15e-13,Q.aycof=-.5*p*Le;let e=1+Q.eta*Math.cos(Q.mo);if(Q.delmo=e*e*e,Q.sinmao=Math.sin(Q.mo),Q.x7thm1=7*je-1,2*a/Q.no>=225){Q.method=`d`,Q.isimp=1,fe=0,j=Q.inclo;let e=_({epoch:i,ep:Q.ecco,argpp:Q.argpo,tc:fe,inclp:Q.inclo,nodep:Q.nodeo,np:Q.no,e3:Q.e3,ee2:Q.ee2,peo:Q.peo,pgho:Q.pgho,pho:Q.pho,pinco:Q.pinco,plo:Q.plo,se2:Q.se2,se3:Q.se3,sgh2:Q.sgh2,sgh3:Q.sgh3,sgh4:Q.sgh4,sh2:Q.sh2,sh3:Q.sh3,si2:Q.si2,si3:Q.si3,sl2:Q.sl2,sl3:Q.sl3,sl4:Q.sl4,xgh2:Q.xgh2,xgh3:Q.xgh3,xgh4:Q.xgh4,xh2:Q.xh2,xh3:Q.xh3,xi2:Q.xi2,xi3:Q.xi3,xl2:Q.xl2,xl3:Q.xl3,xl4:Q.xl4,zmol:Q.zmol,zmos:Q.zmos});Q.e3=e.e3,Q.ee2=e.ee2,Q.peo=e.peo,Q.pgho=e.pgho,Q.pho=e.pho,Q.pinco=e.pinco,Q.plo=e.plo,Q.se2=e.se2,Q.se3=e.se3,Q.sgh2=e.sgh2,Q.sgh3=e.sgh3,Q.sgh4=e.sgh4,Q.sh2=e.sh2,Q.sh3=e.sh3,Q.si2=e.si2,Q.si3=e.si3,Q.sl2=e.sl2,Q.sl3=e.sl3,Q.sl4=e.sl4,{sinim:y,cosim:g,em:T,emsq:E,s1:I,s2:L,s3:R,s4:ce,s5:z,ss1:V,ss2:H,ss3:U,ss4:W,ss5:G,sz1:K,sz3:q,sz11:J,sz13:Y,sz21:X,sz23:le,sz31:ue,sz33:de}=e,Q.xgh2=e.xgh2,Q.xgh3=e.xgh3,Q.xgh4=e.xgh4,Q.xh2=e.xh2,Q.xh3=e.xh3,Q.xi2=e.xi2,Q.xi3=e.xi3,Q.xl2=e.xl2,Q.xl3=e.xl3,Q.xl4=e.xl4,Q.zmol=e.zmol,Q.zmos=e.zmos,{nm:M,z1:ye,z3:be,z11:xe,z13:Se,z21:Ce,z23:we,z31:Te,z33:Ee}=e;let t=ne(Q,{inclo:j,init:Q.init,ep:Q.ecco,inclp:Q.inclo,nodep:Q.nodeo,argpp:Q.argpo,mp:Q.mo,opsmode:Q.operationmode});Q.ecco=t.ep,Q.inclo=t.inclp,Q.nodeo=t.nodep,Q.argpo=t.argpp,Q.mo=t.mp,k=0,A=0,oe=0;let n=v({cosim:g,emsq:E,argpo:Q.argpo,s1:I,s2:L,s3:R,s4:ce,s5:z,sinim:y,ss1:V,ss2:H,ss3:U,ss4:W,ss5:G,sz1:K,sz3:q,sz11:J,sz13:Y,sz21:X,sz23:le,sz31:ue,sz33:de,t:Q.t,tc:fe,gsto:Q.gsto,mo:Q.mo,mdot:Q.mdot,no:Q.no,nodeo:Q.nodeo,nodedot:Q.nodedot,xpidot:_e,z1:ye,z3:be,z11:xe,z13:Se,z21:Ce,z23:we,z31:Te,z33:Ee,ecco:Q.ecco,eccsq:Me,em:T,argpm:k,inclm:j,mm:oe,nm:M,nodem:A,irez:Q.irez,atime:Q.atime,d2201:Q.d2201,d2211:Q.d2211,d3210:Q.d3210,d3222:Q.d3222,d4410:Q.d4410,d4422:Q.d4422,d5220:Q.d5220,d5232:Q.d5232,d5421:Q.d5421,d5433:Q.d5433,dedt:Q.dedt,didt:Q.didt,dmdt:Q.dmdt,dnodt:Q.dnodt,domdt:Q.domdt,del1:Q.del1,del2:Q.del2,del3:Q.del3,xfact:Q.xfact,xlamo:Q.xlamo,xli:Q.xli,xni:Q.xni});Q.irez=n.irez,Q.atime=n.atime,Q.d2201=n.d2201,Q.d2211=n.d2211,Q.d3210=n.d3210,Q.d3222=n.d3222,Q.d4410=n.d4410,Q.d4422=n.d4422,Q.d5220=n.d5220,Q.d5232=n.d5232,Q.d5421=n.d5421,Q.d5433=n.d5433,Q.dedt=n.dedt,Q.didt=n.didt,Q.dmdt=n.dmdt,Q.dnodt=n.dnodt,Q.domdt=n.domdt,Q.del1=n.del1,Q.del2=n.del2,Q.del3=n.del3,Q.xfact=n.xfact,Q.xlamo=n.xlamo,Q.xli=n.xli,Q.xni=n.xni}Q.isimp!==1&&(b=Q.cc1*Q.cc1,Q.d2=4*$*Z*b,pe=Q.d2*Z*Q.cc1/3,Q.d3=(17*$+B)*pe,Q.d4=.5*pe*$*Z*(221*$+31*B)*Q.cc1,Q.t3cof=Q.d2+2*b,Q.t4cof=.25*(3*Q.d3+Q.cc1*(12*Q.d2+10*b)),Q.t5cof=.2*(3*Q.d4+12*Q.cc1*Q.d3+6*Q.d2*Q.d2+15*b*(2*Q.d2+b)))}ae(Q,0),Q.init=`n`}function C(e,t=`i`){let n=e.NORAD_CAT_ID.toString(),r=new Date(e.EPOCH.endsWith(`Z`)?e.EPOCH:`${e.EPOCH}Z`),i=r.getUTCFullYear(),a=Number(i.toString().slice(-2)),o=(r.valueOf()-new Date(Date.UTC(i,0,1,0,0,0)).valueOf())/(86400*1e3)+1,c=Number(e.MEAN_MOTION_DOT),l=Number(e.MEAN_MOTION_DDOT);c/=ee*1440,l/=ee*1440*1440;let u=Number(e.BSTAR),d=Number(e.INCLINATION)*s,f=Number(e.RA_OF_ASC_NODE)*s,p=Number(e.ECCENTRICITY),m=Number(e.ARG_OF_PERICENTER)*s,h=Number(e.MEAN_ANOMALY)*s,ne=Number(e.MEAN_MOTION)/ee,{mon:_,day:v,hr:y,minute:b,sec:re}=te(i,o),ie=g(i,_,v,y,b,re),x={error:0,satnum:n,epochyr:a,epochdays:o,ndot:c,nddot:l,bstar:u,inclo:d,nodeo:f,ecco:p,argpo:m,mo:h,no:ne,jdsatepoch:ie};return S(x,{opsmode:t,satn:x.satnum,epoch:x.jdsatepoch-2433281.5,xbstar:x.bstar,xecco:x.ecco,xargpo:x.argpo,xinclo:x.inclo,xmo:x.mo,xno:x.no,xnodeo:x.nodeo}),x}3*Float64Array.BYTES_PER_ELEMENT;const w=2451545,T=86400,E=[[2441317.5,10],[2441499.5,11],[2441683.5,12],[2442048.5,13],[2442413.5,14],[2442778.5,15],[2443144.5,16],[2443509.5,17],[2443874.5,18],[2444239.5,19],[2444786.5,20],[2445151.5,21],[2445516.5,22],[2446247.5,23],[2447161.5,24],[2447892.5,25],[2448257.5,26],[2448804.5,27],[2449169.5,28],[2449534.5,29],[2450083.5,30],[2450630.5,31],[2451179.5,32],[2453736.5,33],[2454832.5,34],[2456109.5,35],[2457204.5,36],[2457754.5,37]];function D(e){for(let t=E.length-1;t>=0;t--)if(e>=E[t][0])return E[t][1];return E[0][1]-1}function O(e){let t=6.239996+1.99096871e-7*(e-w)*T;return .001657*Math.sin(t+.01671*Math.sin(t))}function k(e){if(!Number.isFinite(e))return e;let t=e+(D(e)+32.184)/T;return t+O(t)/T}const A=Math.PI/180,j=A/3600,oe=1e-4*j,M=[[0,0,0,0,1,-171996,-174.2,92025,8.9],[0,0,2,-2,2,-13187,-1.6,5736,-3.1],[0,0,2,0,2,-2274,-.2,977,-.5],[0,0,0,0,2,2062,.2,-895,.5],[0,1,0,0,0,1426,-3.4,54,-.1],[1,0,0,0,0,712,.1,-7,0],[0,1,2,-2,2,-517,1.2,224,-.6],[0,0,2,0,1,-386,-.4,200,0],[1,0,2,0,2,-301,0,129,-.1],[0,-1,2,-2,2,217,-.5,-95,.3],[1,0,0,-2,0,-158,0,-1,0],[0,0,2,-2,1,129,.1,-70,0],[-1,0,2,0,2,123,0,-53,0],[1,0,0,0,1,63,.1,-33,0],[0,0,0,2,0,63,0,-2,0],[-1,0,2,2,2,-59,0,26,0],[-1,0,0,0,1,-58,-.1,32,0],[1,0,2,0,1,-51,0,27,0]];function N(e,t){let n=Array(9);for(let r=0;r<3;r++)for(let i=0;i<3;i++)n[3*r+i]=e[3*r]*t[i]+e[3*r+1]*t[3+i]+e[3*r+2]*t[6+i];return n}function P(e){let t=Math.cos(e),n=Math.sin(e);return[1,0,0,0,t,n,0,-n,t]}function se(e){let t=Math.cos(e),n=Math.sin(e);return[t,0,-n,0,1,0,n,0,t]}function F(e){let t=Math.cos(e),n=Math.sin(e);return[t,n,0,-n,t,0,0,0,1]}function I(e){let t=(e-w)/36525,n=(2306.2181*t+.30188*t*t+.017998*t**3)*j,r=(2004.3109*t-.42665*t*t-.041833*t**3)*j,a=(2306.2181*t+1.09468*t*t+.018203*t**3)*j,o=134.96298139+477198.8673981*t+.0086972*t*t,s=357.52772333+35999.05034*t-1603e-7*t*t,c=93.27191028+483202.0175381*t-.0036825*t*t,l=297.85036306+445267.11148*t-.0019142*t*t,u=125.04452222-1934.1362608*t+.0020708*t*t,d=0,f=0;for(let[e,n,r,i,a,p,m,ee,te]of M){let h=(e*o+n*s+r*c+i*l+a*u)*A;d+=(p+m*t)*Math.sin(h),f+=(ee+te*t)*Math.cos(h)}d*=oe,f*=oe;let p=(84381.448-46.815*t-59e-5*t*t+.001813*t**3)*j,m=d*Math.cos(p),ee=N(N(N(N(F(n),se(-r)),F(a)),N(N(P(-p),F(d)),P(p+f))),F(-m));return N(P(i*A),ee)}let L=NaN,R=[1,0,0,0,1,0,0,0,1];function ce(e){return Math.abs(e-L)<=.01||(R=I(e),L=e),R}function z(e){return new Date((e-2440587.5)*864e5).toISOString()}function B(e,t){let n=C({OBJECT_NAME:t??String(e.noradCatId),OBJECT_ID:String(e.noradCatId),EPOCH:z(e.epochJd),MEAN_MOTION:e.meanMotion,ECCENTRICITY:e.eccentricity,INCLINATION:e.inclination,RA_OF_ASC_NODE:e.raOfAscNode,ARG_OF_PERICENTER:e.argOfPericenter,MEAN_ANOMALY:e.meanAnomaly,EPHEMERIS_TYPE:0,CLASSIFICATION_TYPE:`U`,NORAD_CAT_ID:e.noradCatId,ELEMENT_SET_NO:e.elementSetNo,REV_AT_EPOCH:e.revAtEpoch,BSTAR:e.bstar,MEAN_MOTION_DOT:e.meanMotionDot,MEAN_MOTION_DDOT:e.meanMotionDdot});return n.error===x.None?n:(console.warn(`buildSatrec: SGP4 init failed for NORAD ${e.noradCatId} (error=${n.error})`),null)}const V=Math.PI/180;Math.cos(i*V),Math.sin(i*V);const H=Math.PI/180,U=Math.cos(i*H),W=Math.sin(i*H),G=10/r;function K(e,t,n,r,i){return!isFinite(Math.fround(n))||!isFinite(Math.fround(r))||!isFinite(Math.fround(i))?!1:(e[t*3]=n,e[t*3+1]=r,e[t*3+2]=i,!0)}function q(r,i,a,o,s,c,l,u,d,f=null,p=0){if(i<r.validityStart||i>r.validityEnd)return 0;let{count:m,kind:ee,equatorial:te,a:h,e:g,i:ne,om:_,w:v,ma:y,n:b,epoch:re,q:ie,tp:S,satrec:C,flags:T,visibleFromDays:E}=r,D=p!==0&&r.applyFlagFilter,O=r.pickBase,A=d.length/3|0,j=i-w,oe=k(i),M=ce(i),N=0;for(let w=0;w<m&&!(N>=A);w++){let m=ee[w];if(m===0||E[w]>j||D&&(T[w]&p)!==p)continue;if(m===3){let e=C[w];if(!e){if(e=B({noradCatId:r.satnum[w],epochJd:re[w],meanMotion:b[w]/360,eccentricity:g[w],inclination:ne[w],raOfAscNode:_[w],argOfPericenter:v[w],meanAnomaly:y[w],bstar:r.bstar[w],meanMotionDot:r.ndot[w],meanMotionDdot:r.nddot[w],elementSetNo:0,revAtEpoch:0}),!e){ee[w]=0;continue}C[w]=e}let t=(i-e.jdsatepoch)*1440,n=ae(e,t);if(!n||e.error!==x.None)continue;let p=n.position.x*G,m=n.position.y*G,te=n.position.z*G,h=M[0]*p+M[1]*m+M[2]*te,ie=M[3]*p+M[4]*m+M[5]*te,S=M[6]*p+M[7]*m+M[8]*te,T=-ie;if(!K(d,N,a+h-c,o+S-l,s+T-u))continue;if(f){let e=O+w,t=N*4;f[t]=e&255,f[t+1]=e>>>8&255,f[t+2]=e>>>16&255,f[t+3]=e>>>24&255}N++;continue}let k,A,P=g[w],se=ne[w],F=_[w],I=v[w];if(m===2){let e=n(ie[w],S[w],te[w]?i:oe);if(!e)continue;k=e.r*Math.cos(e.nu),A=e.r*Math.sin(e.nu)}else{let n=h[w];if(!isFinite(n)||!isFinite(P)||!isFinite(y[w])||!isFinite(b[w]))continue;let r=(te[w]?i:oe)-re[w],a=(y[w]+b[w]*r)*H,o,s;if(P<1||n>0){let t=Math.min(P,.9999999),r=e(a,t),i=Math.sqrt(1-t*t)*Math.sin(r)/(1-t*Math.cos(r)),c=(Math.cos(r)-t)/(1-t*Math.cos(r));o=Math.atan2(i,c),s=n*(1-t*Math.cos(r))}else{let e=t(a,P);if(!isFinite(e))continue;let r=P*Math.cosh(e)-1;if(Math.abs(r)<1e-15)continue;let i=Math.sqrt(P*P-1)*Math.sinh(e)/r,c=(P-Math.cosh(e))/r;o=Math.atan2(i,c),s=n*(1-P*Math.cosh(e))}k=s*Math.cos(o),A=s*Math.sin(o)}if(!isFinite(k)||!isFinite(A))continue;let L=Math.cos(I*H),R=Math.sin(I*H),ce=Math.cos(se*H),z=Math.sin(se*H),V=Math.cos(F*H),q=Math.sin(F*H),J=(V*L-q*R*ce)*k+(-V*R-q*L*ce)*A,Y=(q*L+V*R*ce)*k+(-q*R+V*L*ce)*A,X=R*z*k+L*z*A;if(te[w]){let e=Y*U+X*W,t=-Y*W+X*U;Y=e,X=t}let le=J*10,ue=X*10,de=-Y*10;if(K(d,N,a+le-c,o+ue-l,s+de-u)){if(f){let e=O+w,t=N*4;f[t]=e&255,f[t+1]=e>>>8&255,f[t+2]=e>>>16&255,f[t+3]=e>>>24&255}N++}}return N}const J=new Map;self.onmessage=e=>{let t=e.data;if(t.type===`ping`){self.postMessage({type:`pong`});return}if(t.type===`rewireDelta`){if(t.remove)for(let e of t.remove)J.delete(e);for(let e of t.set)J.set(e.id,e.cols);return}if(t.type===`tick`){let e=[],n=[],[r,i,a]=t.basis;for(let o of t.groups){let s=J.get(o.id);if(!s){e.push({id:o.id,count:0,buf:o.out.buffer,idbuf:o.outIds.buffer}),n.push(o.out.buffer,o.outIds.buffer);continue}let c=q(s,t.jd,o.parent[0],o.parent[1],o.parent[2],r,i,a,o.out,o.outIds,t.requiredFlags??0);e.push({id:o.id,count:c,buf:o.out.buffer,idbuf:o.outIds.buffer}),n.push(o.out.buffer,o.outIds.buffer)}self.postMessage({type:`tickResult`,groups:e},n);return}};";
 var blob = typeof self !== "undefined" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", jsContent], { type: "text/javascript;charset=utf-8" });
 function WorkerWrapper(options) {
 	let objURL;
@@ -22247,8 +23353,8 @@ function between(points, jds, jd, from = 0, to = points.length) {
 //#endregion
 //#region src/lib/math/travel/state.ts
 var DEG2RAD$1 = Math.PI / 180;
-var COS_EPS$1 = Math.cos(EARTH_OBLIQUITY_DEG * DEG2RAD$1);
-var SIN_EPS$1 = Math.sin(EARTH_OBLIQUITY_DEG * DEG2RAD$1);
+var COS_EPS = Math.cos(EARTH_OBLIQUITY_DEG * DEG2RAD$1);
+var SIN_EPS = Math.sin(EARTH_OBLIQUITY_DEG * DEG2RAD$1);
 function planeRotation(w, i, om, equatorial) {
 	const cosW = Math.cos(w * DEG2RAD$1);
 	const sinW = Math.sin(w * DEG2RAD$1);
@@ -22271,8 +23377,8 @@ function perifocalToEcliptic(px, py, rot) {
 	let y = rot.m21 * px + rot.m22 * py;
 	let z = rot.m31 * px + rot.m32 * py;
 	if (rot.equatorial) {
-		const yEcl = y * COS_EPS$1 + z * SIN_EPS$1;
-		const zEcl = -y * SIN_EPS$1 + z * COS_EPS$1;
+		const yEcl = y * COS_EPS + z * SIN_EPS;
+		const zEcl = -y * SIN_EPS + z * COS_EPS;
 		y = yEcl;
 		z = zEcl;
 	}
@@ -22292,11 +23398,12 @@ function eclipticToScene(r) {
 }
 function elementsToState(el, jd, muKm3S2) {
 	const { a, e, ma, n, epoch, q, tp } = el;
+	const t = elementsJd(el, jd);
 	const { om, w } = propagateOrbitAngles(el, jd);
 	const equatorial = el.equatorial ?? false;
 	if (!isFinite(a) || a === 0 || !isFinite(n) || n <= 0) {
 		if (q == null || tp == null || !isFinite(q) || !isFinite(tp) || q <= 0) return null;
-		const solved = solveBarker(q, tp, jd);
+		const solved = solveBarker(q, tp, t);
 		if (!solved) return null;
 		const mu = muKm3S2 && muKm3S2 > 0 ? muKm3S2 : GM_SUN_KM3_S2;
 		const rKm = solved.r * AU_KM;
@@ -22308,7 +23415,7 @@ function elementsToState(el, jd, muKm3S2) {
 	const nRadPerSec = n * DEG2RAD$1 / SEC_PER_DAY$1;
 	const mu = muKm3S2 && muKm3S2 > 0 ? muKm3S2 : nRadPerSec * nRadPerSec * Math.abs(aKm) * Math.abs(aKm) * Math.abs(aKm);
 	if (!isFinite(mu) || mu <= 0) return null;
-	const M = (ma + n * (jd - epoch)) * DEG2RAD$1;
+	const M = (ma + n * (t - epoch)) * DEG2RAD$1;
 	let nu;
 	let rKm;
 	if (e < 1 || a > 0) {
@@ -23328,13 +24435,17 @@ function classifyLagrange(geocentric, earthToSun, massRatio = EARTH_SUN_MASS_RAT
 function existsAt(d, jd) {
 	return !(d.visibleFromDays !== void 0 && jd - 2451545 < d.visibleFromDays);
 }
+function withinValidity(d, jd) {
+	const t = elementsJd(d, jd);
+	return t >= d.validityStart && t <= d.validityEnd;
+}
 function sitsOnParent(d) {
 	return d.a === 0 && (d.objectType === ObjectType.BARYCENTER || d.objectType === ObjectType.LAGRANGE_POINT || isMajorBody(d.objectType));
 }
 function elementsOffset$1(d, jd) {
 	if (d.pageOnly) return "never";
 	if (!existsAt(d, jd)) return "not-yet";
-	if (jd < d.validityStart || jd > d.validityEnd) return "no-data";
+	if (!withinValidity(d, jd)) return "no-data";
 	let offset;
 	const satrec = d.satrec;
 	if (satrec) offset = sgp4PositionScene(satrec, jd);
@@ -23817,11 +24928,82 @@ var PositionDiagnostics = class {
 	}
 };
 
+//#endregion
+//#region src/lib/scene/shaders/planetshine-uniforms.ts
+var _shiners = [];
+var _albedos = /* @__PURE__ */ new WeakMap();
+function measuredShinerAlbedo(bo, map) {
+	const { color, geometricAlbedo } = bo.body.data;
+	let entry = _albedos.get(bo);
+	if (!entry || entry.color !== color || entry.geometricAlbedo !== geometricAlbedo || entry.map !== map) {
+		entry = {
+			color,
+			geometricAlbedo,
+			map,
+			albedo: shinerAlbedo(bo.body.data, map, new Color())
+		};
+		_albedos.set(bo, entry);
+	}
+	return entry.albedo;
+}
+function shineAlbedo(bo, material, out) {
+	const measured = measuredShinerAlbedo(bo, material.map);
+	if (measured) return out.copy(measured);
+	out.copy(material.color);
+	const mean = material.map && meanMapColor(material.map);
+	return mean ? out.multiply(mean) : out;
+}
+function updatePlanetshineUniforms(bodyObjects, occluders, realistic, sunScale) {
+	const sunPos = bodyObjects.get(SUN_ID)?.body.position;
+	let n = 0;
+	if (sunPos) for (const bo of occluders) {
+		if (!bo.mesh) continue;
+		const material = bo.mesh.material;
+		const [x, y, z] = bo.body.position;
+		const sx = sunPos[0] - x;
+		const sy = sunPos[1] - y;
+		const sz = sunPos[2] - z;
+		const sunDist = Math.hypot(sx, sy, sz);
+		const s = _shiners[n++] ??= {
+			x: 0,
+			y: 0,
+			z: 0,
+			radius: 0,
+			sunX: 0,
+			sunY: 0,
+			sunZ: 0,
+			sunlight: 0,
+			albedo: new Color()
+		};
+		s.x = x;
+		s.y = y;
+		s.z = z;
+		s.radius = bo.radiusScene;
+		s.sunX = sx / sunDist;
+		s.sunY = sy / sunDist;
+		s.sunZ = sz / sunDist;
+		s.sunlight = SUN_LIGHT_INTENSITY * sunScale * (realistic ? sunIrradianceFactor(sunDist) : 1);
+		shineAlbedo(bo, material, s.albedo);
+	}
+	for (const bo of bodyObjects.values()) {
+		const shine = bo.planetshine;
+		const at = bo.body.position;
+		if (!shine || !at) continue;
+		if (bo.cachedDist > 0 && bo.radiusScene < bo.cachedDist * 1e-4) continue;
+		selectShiners(shine, at[0], at[1], at[2], _shiners, n);
+	}
+}
+
 //#endregion
 //#region src/lib/scene/shaders/ring-uniforms.ts
 var SUN_RADIUS_SCENE = kmToScene(695700);
 var SHEETS_PER_PX = 2;
+var SIN_B_STEP = 1e-4;
+var RING_LIGHT_MIN_PX = 2;
 var tmp = new Vector3();
+var _axis = new Vector3();
+var _sunLocal = new Vector3();
+var _inverse = new Quaternion();
 function annulusView(camPos, center, poleDir, innerScene, outerScene) {
 	tmp.subVectors(camPos, center);
 	const axial = tmp.dot(poleDir);
@@ -23874,6 +25056,35 @@ function updateRingShaders(bodyObjects, focusTruePos, realistic, overexpose, cam
 			ps.uRingShadowPoleDir.value.copy(psOnRing.uPlanetPoleDir.value);
 			ps.uRingShadowCenter.value.copy(psOnRing.uPlanetCenter.value);
 		}
+		updateRingLight(bo, camPos, pxPerRad);
+	}
+}
+function updateRingLight(bo, camPos, pxPerRad) {
+	const caster = bo.rings.reduce((best, ring) => ring.intensityScale > best.intensityScale ? ring : best);
+	const uniforms = caster.material.uniforms;
+	const sunDir = uniforms.uSunDir.value;
+	const pole = caster.planetShadowOnRing.uPlanetPoleDir.value;
+	const center = caster.planetShadowOnRing.uPlanetCenter.value;
+	const sinB = Math.min(Math.max(sunDir.dot(pole), -1), 1);
+	const light = caster.light;
+	const seen = caster.outerScene / Math.max(camPos.distanceTo(center), 1e-12) * pxPerRad >= RING_LIGHT_MIN_PX;
+	if (seen && !(Math.abs(sinB - light.patchesSinB) < SIN_B_STEP)) {
+		ringshinePatches(light.patches, light.profile, sinB, light.planet);
+		light.patchesSinB = sinB;
+	}
+	_axis.copy(sunDir).addScaledVector(pole, -sinB);
+	if (_axis.lengthSq() < 1e-12) _axis.set(Math.abs(pole.x) < .9 ? 1 : 0, Math.abs(pole.x) < .9 ? 0 : 1, 0).cross(pole);
+	_axis.normalize();
+	if (caster.ringshine) writeRingshine(caster.ringshine, light, _axis, sinB, uniforms.uLightScale.value);
+	_sunLocal.copy(_axis).applyQuaternion(_inverse.copy(caster.mesh.quaternion).invert());
+	for (const ring of bo.rings) {
+		if (!ring.mesh.visible) continue;
+		if (seen && ring.light.planetLightSinB !== light.patchesSinB) fillPlanetLight(ring.light, light.patchesSinB, light);
+		const ringUniforms = ring.material.uniforms;
+		ringUniforms.uSunAzimuth.value.set(_sunLocal.x, _sunLocal.z).normalize();
+		const albedo = ringUniforms.uPlanetAlbedo.value;
+		if (bo.mesh) shineAlbedo(bo, bo.mesh.material, albedo);
+		else albedo.setRGB(0, 0, 0);
 	}
 }
 
@@ -23919,15 +25130,15 @@ function seasonalAtmosphereParams(base, lsDeg) {
 		seasonal: void 0
 	};
 }
-var cache = /* @__PURE__ */ new WeakMap();
+var cache$1 = /* @__PURE__ */ new WeakMap();
 var LS_QUANTUM_DEG = .25;
 function seasonalParamsForJd(base, jd) {
 	if (!base.seasonal) return base;
 	const lsQ = Math.round(marsSolarLongitudeDeg(jd) / LS_QUANTUM_DEG);
-	const hit = cache.get(base);
+	const hit = cache$1.get(base);
 	if (hit && hit.lsQ === lsQ) return hit.params;
 	const params = seasonalAtmosphereParams(base, lsQ * LS_QUANTUM_DEG);
-	cache.set(base, {
+	cache$1.set(base, {
 		lsQ,
 		params
 	});
@@ -24073,6 +25284,7 @@ function updateAtmosphereShaders(bodyObjects, cameraPosition, visible, realistic
 
 //#endregion
 //#region src/lib/scene/shaders/eclipse-uniforms.ts
+var FOCUS = new Vector3();
 function collectOccluders(bodyObjects, out) {
 	let n = 0;
 	for (const bo of bodyObjects.values()) {
@@ -24083,19 +25295,17 @@ function collectOccluders(bodyObjects, out) {
 		out[n++] = bo;
 	}
 	out.length = n;
-	if (n > 32) {
-		out.sort((a, b) => b.radiusScene - a.radiusScene);
-		out.length = 32;
-	}
 	return out;
 }
-function updateEclipseUniforms(bodyObjects, occluders, focusTruePos, air) {
+function updateEclipseUniforms(bodyObjects, occluders, focusTruePos, cameraDistance, air) {
 	const eclipse = getEclipseSceneUniforms();
+	const pool = getOccluderPool();
 	const sunBo = bodyObjects.get(SUN_ID);
 	const sunPos = sunBo?.body.position;
 	if (!sunBo || !sunPos) {
 		eclipse.uSunAngularRadius.value = 0;
 		eclipse.uOccluderCount.value = 0;
+		pool.count = 0;
 		return;
 	}
 	const [fx, fy, fz] = focusTruePos;
@@ -24108,17 +25318,20 @@ function updateEclipseUniforms(bodyObjects, occluders, focusTruePos, air) {
 		eclipse.uSunAngularRadius.value = Math.asin(Math.min(sunBo.radiusScene / sunDist, 1));
 	} else eclipse.uSunAngularRadius.value = 0;
 	const n = occluders.length;
-	const slots = eclipse.uOccluders.value;
-	const leaks = eclipse.uOccluderLeak.value;
+	while (pool.occluders.length < n) {
+		pool.occluders.push(new Vector4());
+		pool.leaks.push(new Vector4());
+	}
 	for (let i = 0; i < n; i++) {
 		const bo = occluders[i];
 		const [bx, by, bz] = bo.body.position;
-		slots[i].set(bx - fx, by - fy, bz - fz, bo.radiusScene);
-		if (air && bo.atmosphere) atmosphereLeak(bo.atmosphere.params, bo.atmosphere.planetRadiusKm, leaks[i]);
-		else leaks[i].set(0, 0, 0, 0);
+		pool.occluders[i].set(bx - fx, by - fy, bz - fz, bo.radiusScene);
+		if (air && bo.atmosphere) atmosphereLeak(bo.atmosphere.params, bo.atmosphere.planetRadiusKm, pool.leaks[i]);
+		else pool.leaks[i].set(0, 0, 0, 0);
 	}
-	eclipse.uOccluderCount.value = n;
+	pool.count = n;
 	const sunDir = eclipse.uSunDir.value;
+	eclipse.uOccluderCount.value = cullOccludersFor(eclipse.uOccluders.value, FOCUS, cameraDistance, sunDir, eclipse.uOccluderLeak.value);
 	for (const bo of bodyObjects.values()) {
 		const self = bo.eclipseShadow;
 		const at = bo.body.position;
@@ -24130,52 +25343,6 @@ function updateEclipseUniforms(bodyObjects, occluders, focusTruePos, air) {
 	}
 }
 
-//#endregion
-//#region src/lib/scene/shaders/planetshine-uniforms.ts
-var _shiners = Array.from({ length: 32 }, () => ({
-	x: 0,
-	y: 0,
-	z: 0,
-	radius: 0,
-	sunX: 0,
-	sunY: 0,
-	sunZ: 0,
-	sunlight: 0,
-	albedo: new Color()
-}));
-function updatePlanetshineUniforms(bodyObjects, occluders, realistic, sunScale) {
-	const sunPos = bodyObjects.get(SUN_ID)?.body.position;
-	let n = 0;
-	if (sunPos) for (const bo of occluders) {
-		if (!bo.mesh) continue;
-		const material = bo.mesh.material;
-		const [x, y, z] = bo.body.position;
-		const sx = sunPos[0] - x;
-		const sy = sunPos[1] - y;
-		const sz = sunPos[2] - z;
-		const sunDist = Math.hypot(sx, sy, sz);
-		const s = _shiners[n++];
-		s.x = x;
-		s.y = y;
-		s.z = z;
-		s.radius = bo.radiusScene;
-		s.sunX = sx / sunDist;
-		s.sunY = sy / sunDist;
-		s.sunZ = sz / sunDist;
-		s.sunlight = SUN_LIGHT_INTENSITY * sunScale * (realistic ? sunIrradianceFactor(sunDist) : 1);
-		s.albedo.copy(material.color);
-		const mean = material.map && meanMapColor(material.map);
-		if (mean) s.albedo.multiply(mean);
-	}
-	for (const bo of bodyObjects.values()) {
-		const shine = bo.planetshine;
-		const at = bo.body.position;
-		if (!shine || !at) continue;
-		if (bo.cachedDist > 0 && bo.radiusScene < bo.cachedDist * 1e-4) continue;
-		selectShiners(shine, at[0], at[1], at[2], _shiners, n);
-	}
-}
-
 //#endregion
 //#region src/lib/scene/shaders/sun-shadow-light.ts
 var LIGHT_DIST = 10;
@@ -24414,6 +25581,10 @@ function gridGeometry(grid) {
 	return geometry;
 }
 var tiledStates = /* @__PURE__ */ new WeakMap();
+var deferred = /* @__PURE__ */ new WeakSet();
+function terrainSettled(bo) {
+	return !tiledStates.get(bo)?.abort && !deferred.has(bo);
+}
 var MAX_BUILD_FAILURES = 2;
 function heightTilesOf(bo) {
 	const tiles = bo.displacementMeta?.tiles;
@@ -24468,7 +25639,10 @@ function updateTiledWindow(bo, mesh, tiles, altitude, centerTheta, centerPhi, in
 	if (held) {
 		const still = drift(centerTheta, centerPhi, held.centerTheta, held.centerPhi);
 		if (kept === stepLevel && still < RECENTER_FRAC * held.angRadius) return true;
-		if (performance.now() - held.builtAt < REBUILD_MIN_MS) return true;
+		if (performance.now() - held.builtAt < REBUILD_MIN_MS) {
+			deferred.add(bo);
+			return true;
+		}
 	}
 	const grid = planNestedGrid(centerTheta, centerPhi, altitude, .5 * meta.scale_km / radiusKm, finest, bandCells, stepLevel);
 	const thetas = grid.rows.at;
@@ -24530,6 +25704,7 @@ function updateTiledWindow(bo, mesh, tiles, altitude, centerTheta, centerPhi, in
 	return !!held;
 }
 function updateTerrainWindow(bo, camera, eligible, invalidate) {
+	deferred.delete(bo);
 	const mesh = bo.mesh;
 	const tex = bo.displacementMap;
 	if (!eligible || !mesh || !tex) {
@@ -24568,7 +25743,10 @@ function updateTerrainWindow(bo, camera, eligible, invalidate) {
 		if (w.stepLevel === stepLevel) {
 			if (drift(centerTheta, centerPhi, w.centerTheta, w.centerPhi) < RECENTER_FRAC * w.angRadius) return true;
 		}
-		if (performance.now() - w.builtAt < REBUILD_MIN_MS) return true;
+		if (performance.now() - w.builtAt < REBUILD_MIN_MS) {
+			deferred.add(bo);
+			return true;
+		}
 	}
 	const thetaLo = Math.max(0, centerTheta - angRadius);
 	const thetaHi = Math.min(Math.PI, centerTheta + angRadius);
@@ -24665,6 +25843,15 @@ function desiredDemTier(altitudeRadii, current) {
 	if (tierRank(down) < tierRank(current)) return down;
 	return current;
 }
+function bodyLoading(bo) {
+	if (bo.textureLoading || bo.displacementLoading || bo.clouds?.textureLoading) return true;
+	if (bo.appearance?.loading || bo.modelLoadPromise) return true;
+	const surface = bo.tileOverlay;
+	if (surface && bo.surfaceTiles && !chainSettled(surface.chain, bo.surfaceTiles)) return true;
+	const relief = bo.reliefTiles;
+	if (relief && !chainSettled(relief.chain, relief.tiles)) return true;
+	return !terrainSettled(bo);
+}
 function updateTextureLOD(bodyObjects, camera, renderer, ctx, textureLoader, focusedId, jd, appearances, invalidate) {
 	appearances.apply(bodyObjects, textureLoader);
 	const fovRad = camera.fov * Math.PI / 180;
@@ -24702,7 +25889,9 @@ function updateTextureLOD(bodyObjects, camera, renderer, ctx, textureLoader, foc
 		updateTileOverlay(bo, camera, renderer, devicePx, settings.showSurfaceTexture && !bo.appearance?.surfaceOwned, invalidate);
 		updateReliefTiles(bo, camera, renderer, devicePx, invalidate);
 		const dispTiers = bo.displacementMeta?.tiers;
-		if (bo.displacementMap && dispTiers?.length && !bo.displacementLoading) {
+		if (bo.displacementMap && !bo.displacementLoading && pyramidHeightsServe(bo, renderer)) {
+			if (bo.displacementTier !== "pyramid") swapDisplacementTier(bo, PYRAMID_TIER);
+		} else if (bo.displacementMap && dispTiers?.length && !bo.displacementLoading) {
 			const maxTex = renderer.capabilities.maxTextureSize;
 			const capRank = maxTex >= 16383 && !reliefTilesServe(bo) ? 2 : maxTex >= 8192 ? 1 : 0;
 			const current = bo.displacementTier ?? "low";
@@ -24717,6 +25906,13 @@ function updateTextureLOD(bodyObjects, camera, renderer, ctx, textureLoader, foc
 	}
 }
 
+//#endregion
+//#region src/lib/scene/perf/calibration-state.svelte.ts
+var calibrationUi = proxy({
+	progress: null,
+	bootPending: false
+});
+
 //#endregion
 //#region src/lib/scene/animation/focus.ts
 var FOCUS_DURATION_MS = FOCUS_ROT_PACING.refMs;
@@ -25025,7 +26221,7 @@ function computeGroupMode(count) {
 	return "none";
 }
 function isCurrentlyValid(body, jd) {
-	return body.data.validityStart <= jd && jd <= body.data.validityEnd;
+	return withinValidity(body.data, jd);
 }
 var PromotionRegistry = class {
 	pendingDefaults = /* @__PURE__ */ new Set();
@@ -25204,7 +26400,8 @@ var PromotionRegistry = class {
 		let n = 0;
 		for (const body of bucket.values()) {
 			if (this.groupTargets && !this.groupTargets.has(body.data.id)) continue;
-			const { validityStart, validityEnd } = body.data;
+			const validityStart = clockJd(body.data, body.data.validityStart);
+			const validityEnd = clockJd(body.data, body.data.validityEnd);
 			if (validityStart <= jd) {
 				if (validityStart > this.countStableLo) this.countStableLo = validityStart;
 			} else if (validityStart < this.countStableHi) this.countStableHi = validityStart;
@@ -25744,19 +26941,45 @@ var ExtensionRegistry = class {
 
 //#endregion
 //#region src/lib/scene/extensions/anchor.ts
-var RAD$4 = Math.PI / 180;
+var RAD$3 = Math.PI / 180;
 function isSurface(anchor) {
 	return "latitude" in anchor;
 }
-function surfaceDirection(latitude, longitude) {
-	const lat = latitude * RAD$4;
-	const lon = longitude * RAD$4;
-	return [
+function surfaceDirection(latitude, longitude, radii) {
+	const lat = latitude * RAD$3;
+	const lon = longitude * RAD$3;
+	const out = [
 		Math.cos(lat) * Math.cos(lon),
 		Math.sin(lat),
 		-Math.cos(lat) * Math.sin(lon)
 	];
+	if (radii) onEllipsoid(radii, out, 0, out, 0);
+	return out;
 }
+function onEllipsoid(radii, from, at, out, to) {
+	const x = from[at] * radii.a;
+	const y = from[at + 1] * radii.c;
+	const z = from[at + 2] * radii.b;
+	const n = Math.hypot(x, y, z);
+	out[to] = x / n;
+	out[to + 1] = y / n;
+	out[to + 2] = z / n;
+}
+var GroundDirections = class {
+	source = null;
+	radii;
+	out = new Float64Array(0);
+	of(dirs, radii) {
+		if (!radii) return dirs;
+		if (dirs !== this.source || radii !== this.radii) {
+			if (this.out.length !== dirs.length) this.out = new Float64Array(dirs.length);
+			for (let i = 0; i < dirs.length; i += 3) onEllipsoid(radii, dirs, i, this.out, i);
+			this.source = dirs;
+			this.radii = radii;
+		}
+		return this.out;
+	}
+};
 function rotateByQuaternion(q, x, y, z, out, at) {
 	const tx = 2 * (q.y * z - q.z * y);
 	const ty = 2 * (q.z * x - q.x * z);
@@ -25772,7 +26995,7 @@ function placeAnchor(anchor, body, centre, jd) {
 	const [cx, cy, cz] = centre;
 	if (isSurface(anchor)) {
 		const distance = kmToScene(effectiveRadiusKm(body.data) + (anchor.altitudeKm ?? 0));
-		const [dx, dy, dz] = surfaceDirection(anchor.latitude, anchor.longitude);
+		const [dx, dy, dz] = surfaceDirection(anchor.latitude, anchor.longitude, body.drawnRadii);
 		const q = body.orientation ? bodyQuaternion(body.orientation, jd, body.nutPrec) : null;
 		if (!q) return [
 			cx + dx * distance,
@@ -25860,9 +27083,13 @@ function resolvePose(pose, ctx, jd) {
 //#region src/lib/scene/camera/motion-scale.ts
 var MIN_TRANSLATE_SCALE = .02;
 var MIN_ROTATE_SCALE = 1e-4;
+var DAMPING_FRAME_MS = 1e3 / 60;
 function orbitDamping(reducedMotion) {
 	return reducedMotion ? .4 : .05;
 }
+function frameDamping(factor, frameDtMs) {
+	return 1 - (1 - factor) ** (frameDtMs / DAMPING_FRAME_MS);
+}
 function cameraMotionScale(camera, focusTruePos, focused, parent, seated) {
 	const orbitRadius = camera.position.length();
 	if (!(orbitRadius > 0)) return {
@@ -25892,10 +27119,10 @@ function clamp$1(value, min) {
 
 //#endregion
 //#region src/lib/scene/user-location/marker.ts
-var RAD$3 = Math.PI / 180;
+var RAD$2 = Math.PI / 180;
 function bodyLocalUnitVector(latitude, longitude) {
-	const latR = latitude * RAD$3;
-	const lonR = longitude * RAD$3;
+	const latR = latitude * RAD$2;
+	const lonR = longitude * RAD$2;
 	return [
 		Math.cos(latR) * Math.cos(lonR),
 		Math.sin(latR),
@@ -26072,6 +27299,11 @@ var SceneRenderer = class SceneRenderer {
 	lastRenderedFocusKey = "";
 	lastRenderedCamPos = new Vector3(NaN, NaN, NaN);
 	lastRenderedCamQuat = new Quaternion();
+	restCamPos = new Vector3(NaN, NaN, NaN);
+	restCamQuat = new Quaternion();
+	restFocusKey = "";
+	atRest = false;
+	focusLoads = 0;
 	unsubscribeBodiesAdded = null;
 	_trailView = {
 		camX: 0,
@@ -26088,6 +27320,7 @@ var SceneRenderer = class SceneRenderer {
 	firstFrame = true;
 	pendingUrlWrite = false;
 	lastTickMs = 0;
+	orbitDampingFactor;
 	static FPS_SAMPLE_FRAMES = 30;
 	fpsSamples = [];
 	fpsSampleHead = 0;
@@ -26182,7 +27415,7 @@ var SceneRenderer = class SceneRenderer {
 		this.pointClouds.setPointBudget(this.tier.pointBudget);
 		this.controls = new OrbitControls(this.camera, canvas);
 		this.controls.enableDamping = true;
-		this.controls.dampingFactor = orbitDamping(sceneSettings().resolvedReducedMotion);
+		this.orbitDampingFactor = orbitDamping(sceneSettings().resolvedReducedMotion);
 		this.controls.minDistance = focusBody ? minCameraDistance(focusBody) : kmToScene(.01);
 		this.controls.maxDistance = 31620.5 * 10;
 		this.controls.target.set(0, 0, 0);
@@ -26473,6 +27706,7 @@ var SceneRenderer = class SceneRenderer {
 		const nowMs = performance.now();
 		const frameDtMs = this.lastTickMs ? nowMs - this.lastTickMs : 0;
 		this.lastTickMs = nowMs;
+		this.controls.dampingFactor = frameDamping(this.orbitDampingFactor, frameDtMs || 16.666666666666668);
 		if (!this.holdingCamera) this.cameraUp.update(this.sceneJd);
 		if (this.firstFrame) {
 			this.firstFrame = false;
@@ -26540,7 +27774,7 @@ var SceneRenderer = class SceneRenderer {
 		refreshDeferredTrails(this.bodyObjects, this.focus, this.lastUpdatedJd, this.trailView());
 		updateRingShaders(this.bodyObjects, this.focus.focusTruePos, sceneSettings().realisticLighting, sceneSettings().overexposeRings, this.camera.position, this.pxPerRad());
 		const occluders = collectOccluders(this.bodyObjects, this._occluders);
-		updateEclipseUniforms(this.bodyObjects, occluders, this.focus.focusTruePos, sceneSettings().showAtmospheres);
+		updateEclipseUniforms(this.bodyObjects, occluders, this.focus.focusTruePos, this.camera.position.length(), sceneSettings().showAtmospheres);
 		updatePlanetshineUniforms(this.bodyObjects, occluders, sceneSettings().realisticLighting, this.sunIntensityScale);
 		occluders.length = 0;
 		const atmoState = updateAtmosphereShaders(this.bodyObjects, this.camera.position, sceneSettings().showAtmospheres, sceneSettings().realisticLighting, this.sunIntensityScale, currentAtmosphereConfig(), this.sceneJd);
@@ -26574,7 +27808,27 @@ var SceneRenderer = class SceneRenderer {
 		this.renderModelOverlay();
 		this.labelRenderer.render(this.scene, this.camera);
 		if (this.haloDebug.active) this.haloDebug.draw(this.bodyObjects, this.camera, this.focus.focusTruePos, this.focusController.current?.data.id, this.renderer.domElement.clientWidth, this.renderer.domElement.clientHeight);
-	};
+		this.checkRest(nowMs);
+	};
+	checkRest(nowMs) {
+		const moved = this.cameraMovedFrom(this.restCamPos, this.restCamQuat) || this.focusKey() !== this.restFocusKey;
+		this.restCamPos.copy(this.camera.position);
+		this.restCamQuat.copy(this.camera.quaternion);
+		this.restFocusKey = this.focusKey();
+		if (moved || this.settling(nowMs)) this.atRest = false;
+		else if (!this.atRest) {
+			this.atRest = true;
+			this.callbacks.onIdle?.();
+		}
+	}
+	settling(nowMs) {
+		if (this.covered || this.ctx.loading || calibrationUi.bootPending) return true;
+		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;
+		for (const bo of this.bodyObjects.values()) if (bo.group.visible && bodyLoading(bo)) return true;
+		return false;
+	}
 	syncSceneSamples(insideShell) {
 		const target = this.composer.readBuffer;
 		const samples = insideShell ? 0 : Math.min(this.tier.sceneSamples, this.maxSceneSamples);
@@ -26685,7 +27939,7 @@ var SceneRenderer = class SceneRenderer {
 	surfaceRadialKm(bodyId, latitude, longitude) {
 		const body = this.ctx.getBody(bodyId);
 		if (!body) return null;
-		const dir = bodyFixedUnit(latitude * Math.PI / 180, longitude * Math.PI / 180);
+		const dir = surfaceDirection(latitude, longitude, body.drawnRadii);
 		return renderedSurfaceRadialKm(this.bodyObjects.get(bodyId), bodyId, effectiveRadiusKm(body.data), dir);
 	}
 	surfaceClamp(body, seated) {
@@ -26975,11 +28229,14 @@ var SceneRenderer = class SceneRenderer {
 		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 (this.covered) return false;
 		if (this.frameIndex - this.lastRenderedFrame >= SceneRenderer.IDLE_HEARTBEAT_FRAMES) return true;
-		const cam = this.camera;
-		if (cam.position.distanceToSquared(this.lastRenderedCamPos) > cam.position.lengthSq() * 1e-10 || 8 * (1 - Math.abs(cam.quaternion.dot(this.lastRenderedCamQuat))) > 1e-8 || this.frameIndex < this.wakeUntilFrame || this.haloDebug.active) return true;
+		if (this.cameraMovedFrom(this.lastRenderedCamPos, this.lastRenderedCamQuat) || this.frameIndex < this.wakeUntilFrame || this.haloDebug.active) return true;
 		if (this.clock.jd === this.lastRenderedJd) return false;
 		return Math.abs(this.clock.timeScale) > 1 || nowMs - this.lastRenderMs >= SceneRenderer.REALTIME_FRAME_MS;
 	}
+	cameraMovedFrom(pos, quat) {
+		const cam = this.camera;
+		return !(cam.position.distanceToSquared(pos) <= cam.position.lengthSq() * 1e-10 && 8 * (1 - Math.abs(cam.quaternion.dot(quat))) <= 1e-8);
+	}
 	onControlsEnd = () => {
 		this.pendingUrlWrite = true;
 		this.focusController.clearPendingInitialView();
@@ -26995,13 +28252,15 @@ var SceneRenderer = class SceneRenderer {
 	maybeLoadTexture(body) {
 		const bo = this.bodyObjects.get(body.data.id);
 		if (!bo) return;
+		this.focusLoads += 2;
+		const done = () => this.focusLoads--;
 		loadBodyTexture(bo, this.textureLoader, this.sceneJd, this.scene, this.renderer.capabilities.maxTextureSize, this.ctx).then(() => {
 			if (this.focusController.current?.data.id !== body.data.id) return;
 			if (body.orientation && bo.mesh) {
 				applyOrientation(bo.mesh, body.orientation, this.sceneJd, body.nutPrec);
 				this.focusController.reapplyInitialViewIfPending();
 			}
-		});
+		}).finally(done);
 		loadBodyModel(bo, this.modelScene, this.ctx).then(() => {
 			if (this.focusController.current?.data.id === bo.body.data.id) this.controls.minDistance = minCameraDistance(bo.body, modelMinRadiusKm(bo));
 			if (this.ctx.layers.skipped.has("nomenclature")) return;
@@ -27011,7 +28270,7 @@ var SceneRenderer = class SceneRenderer {
 			});
 		}).then(() => {
 			if (this.selectedFeatureId !== null) setActiveFeatureLabel(bo, this.selectedFeatureId);
-		});
+		}).finally(done);
 	}
 	reapplyBodyLayers() {
 		const focused = this.focusController.current;
@@ -27164,7 +28423,7 @@ var SceneRenderer = class SceneRenderer {
 		}
 	}
 	setReducedMotion(on) {
-		this.controls.dampingFactor = orbitDamping(on);
+		this.orbitDampingFactor = orbitDamping(on);
 	}
 	focusOnBody(id, zoom, latitude, longitude) {
 		this.disarmLimits();
@@ -27469,7 +28728,8 @@ var SceneRenderer = class SceneRenderer {
 	setCovered(covered) {
 		if (this.covered === covered) return;
 		this.covered = covered;
-		if (!covered) this.invalidate();
+		if (covered) this.atRest = false;
+		else this.invalidate();
 	}
 	isContextLost() {
 		return this.renderer.getContext().isContextLost();
@@ -27562,13 +28822,6 @@ function disposeTexture(value) {
 	if (value && typeof value === "object" && value.isTexture) value.dispose();
 }
 
-//#endregion
-//#region src/lib/scene/perf/calibration-state.svelte.ts
-var calibrationUi = proxy({
-	progress: null,
-	bootPending: false
-});
-
 //#endregion
 //#region src/lib/scene/perf/atmosphere-benchmark.ts
 var EARTH_RADIUS_KM = 6371;
@@ -28589,7 +29842,7 @@ var IconExtension = class extends MarkerExtension {
 //#endregion
 //#region src/lib/flatmap/projection.ts
 var DEG$6 = Math.PI / 180;
-var RAD$2 = 180 / Math.PI;
+var RAD$1 = 180 / Math.PI;
 function wrapLon(lon) {
 	if (lon >= -180 && lon < 180) return lon;
 	return ((lon + 180) % 360 + 360) % 360 - 180;
@@ -28636,8 +29889,8 @@ function equirectangular(options) {
 	const rowInverse = (y) => {
 		if (Math.abs(y) > Math.PI / 2) return null;
 		return {
-			lat: y * RAD$2,
-			lonPerX: RAD$2,
+			lat: y * RAD$1,
+			lonPerX: RAD$1,
 			maxAbsX: Math.PI
 		};
 	};
@@ -28685,9 +29938,9 @@ function equalEarth(options) {
 		const theta = thetaFor(y);
 		const sinLat = 2 / EE_SQRT3 * Math.sin(theta);
 		if (Math.abs(sinLat) > 1) return null;
-		const lonPerX = 3 * eeDy(theta) / (2 * EE_SQRT3 * Math.cos(theta)) * RAD$2;
+		const lonPerX = 3 * eeDy(theta) / (2 * EE_SQRT3 * Math.cos(theta)) * RAD$1;
 		return {
-			lat: Math.asin(sinLat) * RAD$2,
+			lat: Math.asin(sinLat) * RAD$1,
 			lonPerX,
 			maxAbsX: 180 / lonPerX
 		};
@@ -28719,9 +29972,9 @@ function mollweide(options) {
 			lonPerX: 0,
 			maxAbsX: 0
 		};
-		const lonPerX = Math.PI / (2 * MW_SQRT2 * cosTheta) * RAD$2;
+		const lonPerX = Math.PI / (2 * MW_SQRT2 * cosTheta) * RAD$1;
 		return {
-			lat: Math.asin(sinLat) * RAD$2,
+			lat: Math.asin(sinLat) * RAD$1,
 			lonPerX,
 			maxAbsX: 180 / lonPerX
 		};
@@ -28768,8 +30021,8 @@ function sinusoidal(options) {
 			maxAbsX: 0
 		};
 		return {
-			lat: y * RAD$2,
-			lonPerX: RAD$2 / cosLat,
+			lat: y * RAD$1,
+			lonPerX: RAD$1 / cosLat,
 			maxAbsX: Math.PI * cosLat
 		};
 	};
@@ -28920,7 +30173,7 @@ function clamp1(v) {
 }
 function azimuthalInverse(x, y, cosC, k, lon0, sinPhi0, cosPhi0) {
 	const lat = Math.asin(clamp1(cosC * sinPhi0 + y * k * cosPhi0));
-	return [wrapLon(lon0 + Math.atan2(x * k, cosC * cosPhi0 - y * k * sinPhi0) * RAD$2), lat * RAD$2];
+	return [wrapLon(lon0 + Math.atan2(x * k, cosC * cosPhi0 - y * k * sinPhi0) * RAD$1), lat * RAD$1];
 }
 function discExtent(r) {
 	return {
@@ -29017,7 +30270,7 @@ function createProjection(id, options = {}) {
 var DEG$5 = Math.PI / 180;
 var TAU = 2 * Math.PI;
 var RIM_STEP = 2 * DEG$5;
-var RAD$1 = 180 / Math.PI;
+var RAD = 180 / Math.PI;
 var MAX_STEPS = 512;
 var DEFAULT_STEP_DEG = 2;
 function angularDistance(a, b) {
@@ -29026,7 +30279,7 @@ function angularDistance(a, b) {
 	const dφ = φ2 - φ1;
 	const dλ = wrapLon(b.lon - a.lon) * DEG$5;
 	const h = Math.sin(dφ / 2) ** 2 + Math.cos(φ1) * Math.cos(φ2) * Math.sin(dλ / 2) ** 2;
-	return 2 * Math.asin(Math.min(1, Math.sqrt(h))) * RAD$1;
+	return 2 * Math.asin(Math.min(1, Math.sqrt(h))) * RAD;
 }
 function slerp(a, b, t) {
 	const d = angularDistance(a, b) * DEG$5;
@@ -29042,8 +30295,8 @@ function slerp(a, b, t) {
 	const y = ka * Math.cos(φ1) * Math.sin(λ1) + kb * Math.cos(φ2) * Math.sin(λ2);
 	const z = ka * Math.sin(φ1) + kb * Math.sin(φ2);
 	return {
-		lon: Math.atan2(y, x) * RAD$1,
-		lat: Math.atan2(z, Math.hypot(x, y)) * RAD$1
+		lon: Math.atan2(y, x) * RAD,
+		lat: Math.atan2(z, Math.hypot(x, y)) * RAD
 	};
 }
 function lerp(a, b, t) {
@@ -29346,8 +30599,8 @@ function smallCircle(center, radiusDeg, steps = 128) {
 		const y = c[1] * cosR + e[1] * a + n[1] * b;
 		const z = c[2] * cosR + e[2] * a + n[2] * b;
 		ring.push({
-			lon: wrapLon(Math.atan2(y, x) * RAD$1),
-			lat: Math.atan2(z, Math.hypot(x, y)) * RAD$1
+			lon: wrapLon(Math.atan2(y, x) * RAD),
+			lat: Math.atan2(z, Math.hypot(x, y)) * RAD
 		});
 	}
 	return ring;
@@ -29400,6 +30653,8 @@ var SurfaceShapeExtension = class {
 	alphas = new Float32Array(0);
 	lengths = new Float32Array(0);
 	fanDirs = new Float64Array(0);
+	groundDirs = new GroundDirections();
+	groundFanDirs = new GroundDirections();
 	fill = null;
 	fillScratch = new Float32Array(0);
 	turned = [
@@ -29466,7 +30721,8 @@ var SurfaceShapeExtension = class {
 			centre[2] - basis[2]
 		];
 		if (this.line) {
-			this.place(this.dirs, this.count, q, scale, origin, this.scratch);
+			const dirs = this.groundDirs.of(this.dirs, body.drawnRadii);
+			this.place(dirs, this.count, q, scale, origin, this.scratch);
 			writeFatTrailVertices(this.line.geometry, this.scratch, this.alphas, this.alphas, this.count);
 			if (this.dash) {
 				screenLengths(this.scratch, this.count, camera, viewportPx, this.lengths);
@@ -29476,7 +30732,8 @@ var SurfaceShapeExtension = class {
 		}
 		if (this.fill) {
 			const position = this.fill.geometry.getAttribute("position");
-			this.place(this.fanDirs, this.fillScratch.length / 3, q, scale, origin, this.fillScratch);
+			const fanDirs = this.groundFanDirs.of(this.fanDirs, body.drawnRadii);
+			this.place(fanDirs, this.fillScratch.length / 3, q, scale, origin, this.fillScratch);
 			position.needsUpdate = true;
 			this.fill.material.uniforms.uCenterOffset.value.copy(camera.position).negate();
 		}
@@ -30027,6 +31284,7 @@ var SpaceMap = class {
 		clock: /* @__PURE__ */ new Set(),
 		loading: /* @__PURE__ */ new Set(),
 		progress: /* @__PURE__ */ new Set(),
+		idle: /* @__PURE__ */ new Set(),
 		error: /* @__PURE__ */ new Set(),
 		datastale: /* @__PURE__ */ new Set(),
 		notice: /* @__PURE__ */ new Set(),
@@ -30298,6 +31556,7 @@ var SpaceMap = class {
 					dtMs
 				});
 			},
+			onIdle: () => this.emit("idle"),
 			onCameraPosition: (latitude, longitude, zoom) => {
 				const body = this.focusedBody?.data.id;
 				if (body === void 0) return;
@@ -31777,7 +33036,7 @@ async function acquireBitmap(url, decodeWidth) {
 	};
 	let work = pending.get(key);
 	if (!work) {
-		work = decode(url, decodeWidth);
+		work = decode$1(url, decodeWidth);
 		pending.set(key, work);
 		const done = () => pending.delete(key);
 		work.then(done, done);
@@ -31789,7 +33048,7 @@ async function acquireBitmap(url, decodeWidth) {
 		bitmap: bitmaps.put(key, bitmap, bitmapBytes(bitmap.width, bitmap.height))
 	};
 }
-async function decode(url, decodeWidth) {
+async function decode$1(url, decodeWidth) {
 	const response = await fetch(url);
 	if (!response.ok) throw new Error(`HTTP ${response.status}`);
 	const blob = await response.blob();
@@ -33083,17 +34342,25 @@ function findPanorama(entries, at) {
 	if (!at) return null;
 	return entries.find((e) => panoramaAt(e) === at || legacyAt(e) === at) ?? null;
 }
+var MIN_STEP_M = 1;
 function neighboursOf(entries, current, radiusKm) {
 	const i = entries.findIndex((e) => e.id === current.id);
-	const sameMission = (e) => e && e.mission === current.mission;
-	const toNeighbour = (e) => sameMission(e) ? {
-		entry: e,
-		distanceM: groundDistanceM(current, e, radiusKm),
-		bearingDeg: bearingDeg(current, e)
-	} : null;
+	const nearest = (step) => {
+		for (let j = i + step; j >= 0 && j < entries.length; j += step) {
+			const e = entries[j];
+			if (e.mission !== current.mission) return null;
+			const distanceM = groundDistanceM(current, e, radiusKm);
+			if (distanceM >= MIN_STEP_M) return {
+				entry: e,
+				distanceM,
+				bearingDeg: bearingDeg(current, e)
+			};
+		}
+		return null;
+	};
 	return {
-		previous: toNeighbour(entries[i - 1]),
-		next: toNeighbour(entries[i + 1])
+		previous: nearest(-1),
+		next: nearest(1)
 	};
 }
 var DEG$1 = Math.PI / 180;
@@ -33121,7 +34388,6 @@ var ARROW_DISTANCE = 9;
 var CLICK_SLOP_PX = 6;
 var ANGLE_STEP_DEG = 10;
 var ANGLE_SAMPLE_STEP_DEG = 1;
-var MIN_ARROW_DISTANCE_M = 1;
 var GYRO_TILT = new Quaternion(-Math.SQRT1_2, 0, 0, Math.SQRT1_2);
 var SCREEN_AXIS = new Vector3(0, 0, 1);
 function wrapHeading(deg) {
@@ -33340,7 +34606,7 @@ var PanoramaView = class {
 		this.setArrowTargets(this.neighbours && hasHeading(entry) ? ["previous", "next"].map((key) => ({
 			key,
 			n: this.neighbours?.[key] ?? null
-		})).filter((a) => a.n && a.n.distanceM >= MIN_ARROW_DISTANCE_M).map((a) => ({
+		})).filter((a) => a.n).map((a) => ({
 			key: a.key,
 			bearingDeg: a.n.bearingDeg
 		})) : []);
@@ -33738,6 +35004,106 @@ var fetchPlanetarySystemsMap = memoizedGzJson(() => `${dataBase()}/v1/groups/__p
 //#region src/lib/fetch/groups/solar-system-map.ts
 var fetchSolarSystemMap = memoizedGzJson(() => `${dataBase()}/v1/groups/__solar_system_map__.json.gz`, { error: (res) => `Failed to fetch solar system map: ${res.status}` });
 
+//#endregion
+//#region src/lib/rings/strip.ts
+var cache = /* @__PURE__ */ new Map();
+function luminance(r, g, b) {
+	return .2126 * r + .7152 * g + .0722 * b;
+}
+async function decode(bodyId, meta) {
+	const rows = meta.strip_rows;
+	if (rows.transparency === void 0 || rows.color === void 0) {
+		console.warn(`Ring strip ${bodyId}/${meta.strip} has no transparency or color row, no profile drawn:`, rows);
+		return null;
+	}
+	const response = await fetch(versionedUrl(`/v1/rings/${bodyId}/${meta.strip}`, "rings"));
+	if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+	const bitmap = await createImageBitmap(await response.blob());
+	const canvas = document.createElement("canvas");
+	canvas.width = bitmap.width;
+	canvas.height = bitmap.height;
+	const ctx = canvas.getContext("2d", { willReadFrequently: true });
+	if (!ctx) {
+		console.warn(`Ring strip ${bodyId}/${meta.strip}: no 2D context, no profile drawn`);
+		return null;
+	}
+	ctx.drawImage(bitmap, 0, 0);
+	const n = bitmap.width;
+	const pixels = ctx.getImageData(0, 0, n, bitmap.height).data;
+	bitmap.close();
+	const scale = meta.intensity_scale || 1;
+	const tau = new Float32Array(n);
+	const rgb = new Uint8ClampedArray(n * 3);
+	const back = rows.backscattered ?? rows.color;
+	const brightness = new Float32Array(n);
+	let peak = 0;
+	for (let i = 0; i < n; i++) {
+		const t = (rows.transparency * n + i) * 4;
+		const b = (back * n + i) * 4;
+		const opacity = Math.min(1, (1 - pixels[t] / 255) * scale);
+		tau[i] = opacity >= 1 ? Infinity : -Math.log(1 - opacity);
+		brightness[i] = luminance(pixels[b], pixels[b + 1], pixels[b + 2]) / 255;
+		if (brightness[i] > peak) peak = brightness[i];
+	}
+	const FLOOR = .35;
+	for (let i = 0; i < n; i++) {
+		const c = (rows.color * n + i) * 4;
+		const lit = peak > 0 ? FLOOR + (1 - FLOOR) * (brightness[i] / peak) : 1;
+		rgb[i * 3] = pixels[c] * lit;
+		rgb[i * 3 + 1] = pixels[c + 1] * lit;
+		rgb[i * 3 + 2] = pixels[c + 2] * lit;
+	}
+	return {
+		inner: meta.inner_radius_km,
+		outer: meta.outer_radius_km,
+		tau,
+		rgb
+	};
+}
+async function load(bodyId) {
+	const bundles = (await fetchObjectDetail(bodyId, false)).global?.rings ?? [];
+	if (!bundles.length) console.warn(`Ring strips for ${bodyId}: no ring bundles on the object`);
+	const profiles = [];
+	for (const bundle of bundles) try {
+		const profile = await decode(bodyId, bundle);
+		if (profile) profiles.push(profile);
+	} catch (err) {
+		console.warn(`Ring strip ${bodyId}/${bundle.strip} unavailable:`, err);
+	}
+	return profiles;
+}
+var SEEN_TAU = -Math.log1p(-.02);
+function visibleSpan(profiles) {
+	let inner = Infinity;
+	let outer = -Infinity;
+	for (const profile of profiles) {
+		const n = profile.tau.length;
+		const kmPerSample = (profile.outer - profile.inner) / (n - 1);
+		for (let i = 0; i < n; i++) {
+			if (profile.tau[i] < SEEN_TAU) continue;
+			const km = profile.inner + i * kmPerSample;
+			if (km < inner) inner = km;
+			if (km > outer) outer = km;
+		}
+	}
+	return outer >= inner ? {
+		inner,
+		outer
+	} : null;
+}
+function loadRingStrips(bodyId) {
+	let pending = cache.get(bodyId);
+	if (!pending) {
+		pending = load(bodyId).catch((err) => {
+			console.warn(`Ring strips for ${bodyId} unavailable:`, err);
+			cache.delete(bodyId);
+			return [];
+		});
+		cache.set(bodyId, pending);
+	}
+	return pending;
+}
+
 //#endregion
 //#region src/lib/charts/scrub.ts
 var DRAG_SLOP = 8;
@@ -34527,6 +35893,15 @@ function systemFromMapEntry(entry, name) {
 		moonCount: entry.moon_count
 	};
 }
+function visibleRings(system, profiles) {
+	if (!system.rings || !profiles.length) return system.rings;
+	const span = visibleSpan(profiles);
+	const rKm = system.planetRadiusKm;
+	return span && {
+		innerRp: span.inner / rKm,
+		outerRp: span.outer / rKm
+	};
+}
 var TOP_MOON_R = 14;
 var AT_SURFACE = 1.001;
 var PX_PER_DEG = .62;
@@ -34876,11 +36251,12 @@ function buildSystemView(data, primaryId, exported, options, text, pick) {
 		name: scope.name(moon.id, exported[moon.id])
 	}));
 	const rKm = system.planetRadiusKm;
-	const bands = system.rings ? [{
+	const rings = data.ringProfiles ? visibleRings(system, data.ringProfiles) : system.rings;
+	const bands = rings ? [{
 		key: "rings",
 		label: text.rings,
-		innerKm: system.rings.innerRp * rKm,
-		outerKm: system.rings.outerRp * rKm,
+		innerKm: rings.innerRp * rKm,
+		outerKm: rings.outerRp * rKm,
 		tone: "amber"
 	}] : [];
 	const model = planetarySystemModel(system, {
@@ -35027,6 +36403,7 @@ var SystemMap = class {
 	names;
 	grouping;
 	zones;
+	rings;
 	places;
 	targets = [];
 	extras = /* @__PURE__ */ new Map();
@@ -35038,6 +36415,7 @@ var SystemMap = class {
 		this.names = options.names ?? {};
 		this.grouping = options.grouping ?? "bodies";
 		this.zones = options.zones ?? "belts";
+		this.rings = options.rings ?? "all";
 		this.places = (options.places ?? []).map(extraFromPlace);
 	}
 	mount(container) {
@@ -35104,7 +36482,14 @@ var SystemMap = class {
 		};
 		switch (view.kind) {
 			case "solar-system": return buildSolarView(data, options, text, pick);
-			case "system": return buildSystemView(data, view.id, await this.exportedNames(view.id, systems), options, text, pick);
+			case "system": {
+				const ringed = this.rings === "visible" && !!systemEntry(systems, view.id)?.rings;
+				const [names, ringProfiles] = await Promise.all([this.exportedNames(view.id, systems), ringed ? loadRingStrips(view.id) : void 0]);
+				return buildSystemView({
+					...data,
+					ringProfiles
+				}, view.id, names, options, text, pick);
+			}
 			case "zone": {
 				const ids = unplacedIds(solar, systems, this.bodies, this.places.map((place) => place.id));
 				const read = (await Promise.all(ids.map((id) => this.extra(id)))).filter((extra) => extra !== null);
@@ -35357,9 +36742,6 @@ var PanoramaAttributionControl = class {
 
 //#endregion
 //#region src/lib/scene/extensions/trajectory.ts
-var RAD = Math.PI / 180;
-var COS_EPS = Math.cos(EARTH_OBLIQUITY_DEG * RAD);
-var SIN_EPS = Math.sin(EARTH_OBLIQUITY_DEG * RAD);
 function fixed(place) {
 	return place;
 }
@@ -35384,17 +36766,10 @@ function tle(line1, line2) {
 		offsetKm: (jd) => {
 			if (satrec.error !== SatRecError.None) return null;
 			const teme = sgp4PositionTEME(satrec, jd);
-			return teme && temeToEcliptic(teme[0], teme[1], teme[2]);
+			return teme && temeToEcliptic(teme[0], teme[1], teme[2], jd);
 		}
 	};
 }
-function temeToEcliptic(x, y, z) {
-	return [
-		x,
-		y * COS_EPS + z * SIN_EPS,
-		-y * SIN_EPS + z * COS_EPS
-	];
-}
 function interpolateSamples(states, jd) {
 	const n = states.length;
 	if (n < 2 || jd < states[0].jd || jd > states[n - 1].jd) return null;
@@ -35478,7 +36853,7 @@ async function moonRow(id, { jd, metadata }) {
 }
 function elementsOffset(data, jd) {
 	if (!discovered(data.visibleFromDays, jd)) return null;
-	if (jd < data.validityStart || jd > data.validityEnd) return null;
+	if (!withinValidity(data, jd)) return null;
 	if (data.satrec) return sgp4PositionScene(data.satrec, jd);
 	if (data.q != null) return parabolicToPositionJD(data, jd);
 	if (data.a === 0) return [
@@ -35546,16 +36921,9 @@ function neighbours(id, { parents }, at) {
 }
 async function spinOf(id) {
 	const [detail] = await Promise.all([fetchObjectDetail(id, false), loadSystemsGlobal()]);
-	const orientation = detail.global?.orientation;
-	const sums = detail.global?.nut_prec;
-	const naif = /^naif-(-?\d+)$/.exec(id);
-	const angles = naif ? getNutPrecAngles(ownerIdFor(parseInt(naif[1], 10))) : void 0;
 	return {
-		orientation,
-		nutPrec: sums && angles ? {
-			...sums,
-			angles
-		} : void 0
+		orientation: detail.global?.orientation,
+		nutPrec: nutPrecFor(id, detail.global?.nut_prec)
 	};
 }
 async function resolve(anchor, at) {