spacemap 0.1.9 → 0.1.10

package/index.js

@@ -1,5 +1,5 @@
 /*! spacemap SDK — https://spacemap.co — Mozilla Public License 2.0. Bundles MIT and ISC libraries: THIRD_PARTY_NOTICES.txt in the spacemap npm package. */
-import { ACESFilmicToneMapping, AdditiveBlending, AmbientLight, ArrowHelper, BackSide, Box3, BufferAttribute, BufferGeometry, CanvasTexture, Color, CubeTexture, CustomBlending, 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, RawShaderMaterial, Raycaster, RedFormat, 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, 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, NearestFilter, NoBlending, NoColorSpace, NormalBlending, OneFactor, OneMinusSrcAlphaFactor, PCFShadowMap, PCFSoftShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, PointLight, Points, PointsMaterial, Quaternion, RGBAFormat, 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 { OrbitControls } from "three/addons/controls/OrbitControls.js";
 import { EffectComposer } from "three/addons/postprocessing/EffectComposer.js";
 import { RenderPass } from "three/addons/postprocessing/RenderPass.js";
@@ -20,6 +20,7 @@ var DEFAULT_HOST = {
 	dataUrl: "https://static.spacemap.co",
 	imagesUrl: "https://images.spacemap.co",
 	liveUrl: "https://live.spacemap.co",
+	tilesUrl: "",
 	locale: () => "en",
 	messages: {
 		body_note_no_model: () => "no model available",
@@ -66,6 +67,7 @@ function configureHost(overrides) {
 	current$1.dataUrl = current$1.dataUrl.replace(/\/$/, "");
 	current$1.imagesUrl = current$1.imagesUrl.replace(/\/$/, "");
 	current$1.liveUrl = current$1.liveUrl.replace(/\/$/, "");
+	current$1.tilesUrl = current$1.tilesUrl.replace(/\/$/, "");
 }
 function host() {
 	return current$1;
@@ -2963,6 +2965,14 @@ function get_custom_elements_slots(element) {
 function dataBase() {
 	return host().dataUrl;
 }
+function tilesBase() {
+	return host().tilesUrl;
+}
+function tileUrl(tiles, cap, level, x, y, frame) {
+	const month = frame === void 0 ? "" : `${String(frame).padStart(2, "0")}/`;
+	const chart = cap && `${cap}/`;
+	return `${tilesBase()}/v1/tiles/${tiles.id}/${month}${chart}${level}/${x}/${y}.webp?v=${tiles.version}`;
+}
 var versions = {};
 function setDataVersions(v) {
 	versions = v ?? {};
@@ -6933,7 +6943,7 @@ var VisibilityController = class {
 	}
 	ratioVisibility(body, camDistThreeJS, pinned) {
 		if (!pinned && this.getLayers().hidesBody(body.data.objectType, body.data.parentId)) return VISIBILITY.HIDE;
-		if (body.data.orbitalSource === OrbitalSource.SPICE_PROBE) return this.getProbeVisibility(body);
+		if (body.data.orbitalSource === OrbitalSource.SPICE_PROBE) return this.getProbeVisibility(body, camDistThreeJS);
 		const earthFilter = this.getEarthSatGroupFilter();
 		if (earthFilter && body.data.parentId === "naif-399" && !earthFilter.has(body.data.id)) return VISIBILITY.HIDE;
 		const ot = body.data.objectType;
@@ -6958,7 +6968,7 @@ var VisibilityController = class {
 		const tier = computeVisibilityFromRatio(camDistThreeJS / 10 / refA, this.scaledSystem, 50, isFocused);
 		return tier === VISIBILITY.CLOSE ? VISIBILITY.FULL : tier;
 	}
-	getProbeVisibility(body) {
+	getProbeVisibility(body, camDistThreeJS) {
 		const ps = this.getProbeStore();
 		if ((ps ? ps.containingSystemAt(body.data.id, this.currentJd) : null) === EARTH_SYSTEM_NAIF && this.getEarthSatGroupFilter()) return VISIBILITY.HIDE;
 		const isFocused = body.data.id === this.focusedBodyIdPlain;
@@ -6974,7 +6984,7 @@ var VisibilityController = class {
 		if (!parent?.position || !body.position) return VISIBILITY.FULL;
 		const distToParent = f64dist(body.position, parent.position) / 10;
 		if (distToParent === 0) return VISIBILITY.FULL;
-		return this.cameraDistThreeJS / 10 / distToParent <= this.scaledPlanetary[VISIBILITY.FULL] * (isFocused ? 5 : 1) ? VISIBILITY.FULL : VISIBILITY.HIDE;
+		return camDistThreeJS / 10 / distToParent <= this.scaledPlanetary[VISIBILITY.FULL] * (isFocused ? 5 : 1) ? VISIBILITY.FULL : VISIBILITY.HIDE;
 	}
 	isProbeInFocusedSystem(body) {
 		const parentId = body.data.parentId;
@@ -8179,19 +8189,11 @@ function extendProbeTrailBuffer(buf, sample, lastJd, lastPos, headJd) {
 //#endregion
 //#region src/lib/scene/objects/trail/points.ts
 var NUM_TRAIL_POINTS = 512;
-function buildTrailPoints(body, curve, isOpenCurve, cx, cy, cz) {
-	if (curve.length === 0) return [];
-	const anchor = body.trailAnchor ?? body.position;
-	if (!anchor) return [];
-	const bodyLocal = [
-		anchor[0] - cx,
-		anchor[1] - cy,
-		anchor[2] - cz
-	];
+function nearestStart(curve, at) {
 	let nearest = 0;
 	let best = Infinity;
 	for (let j = 0; j < curve.length; j++) {
-		const d = (curve[j][0] - bodyLocal[0]) ** 2 + (curve[j][1] - bodyLocal[1]) ** 2 + (curve[j][2] - bodyLocal[2]) ** 2;
+		const d = (curve[j][0] - at[0]) ** 2 + (curve[j][1] - at[1]) ** 2 + (curve[j][2] - at[2]) ** 2;
 		if (d < best) {
 			best = d;
 			nearest = j;
@@ -8199,7 +8201,18 @@ function buildTrailPoints(body, curve, isOpenCurve, cx, cy, cz) {
 	}
 	const prev = Math.max(nearest - 1, 0);
 	const next = Math.min(nearest + 1, curve.length - 1);
-	const trailStart = (curve[prev][0] - bodyLocal[0]) ** 2 + (curve[prev][1] - bodyLocal[1]) ** 2 + (curve[prev][2] - bodyLocal[2]) ** 2 < (curve[next][0] - bodyLocal[0]) ** 2 + (curve[next][1] - bodyLocal[1]) ** 2 + (curve[next][2] - bodyLocal[2]) ** 2 ? prev : nearest;
+	return (curve[prev][0] - at[0]) ** 2 + (curve[prev][1] - at[1]) ** 2 + (curve[prev][2] - at[2]) ** 2 < (curve[next][0] - at[0]) ** 2 + (curve[next][1] - at[1]) ** 2 + (curve[next][2] - at[2]) ** 2 ? prev : nearest;
+}
+function buildTrailPoints(body, curve, isOpenCurve, cx, cy, cz, start) {
+	if (curve.length === 0) return [];
+	const anchor = body.trailAnchor ?? body.position;
+	if (!anchor) return [];
+	const bodyLocal = [
+		anchor[0] - cx,
+		anchor[1] - cy,
+		anchor[2] - cz
+	];
+	const trailStart = start ?? nearestStart(curve, bodyLocal);
 	const points = [bodyLocal];
 	if (isOpenCurve) for (let k = 0; k < 512 - 1; k++) {
 		const idx = Math.max(trailStart - k, 0);
@@ -8295,12 +8308,16 @@ var ChunkLoader = class {
 			const parentKey = `naif-${body.parentId}`;
 			const objType = body.objectType;
 			const primaryId = objType === ObjectType.MOON && body.parentId >= 1 && body.parentId <= 9 ? `naif-${body.parentId * 100 + 99}` : null;
-			const elements = chebyshevOsculatingElements(body, body.parentId, jd, primaryId ? cheb.body(primaryId, jd) ?? void 0 : void 0);
+			const elementsAt = (record, at) => {
+				if (!primaryId) return chebyshevOsculatingElements(record, record.parentId, at);
+				const primary = cheb.body(primaryId, at);
+				return primary ? chebyshevOsculatingElements(record, record.parentId, at, primary) : null;
+			};
+			const elements = elementsAt(body, jd);
 			const ownId = body.id;
 			const ownRederive = (newJd) => {
 				const fresh = cheb.body(ownId, newJd);
-				if (!fresh) return null;
-				return chebyshevOsculatingElements(fresh, fresh.parentId, newJd, primaryId ? cheb.body(primaryId, newJd) ?? void 0 : void 0);
+				return fresh ? elementsAt(fresh, newJd) : null;
 			};
 			const fallbackA = Math.hypot(offset[0], offset[1], offset[2]) / 10;
 			const data = {
@@ -8950,6 +8967,14 @@ var ChunkWindow = class {
 			done
 		};
 	}
+	loadingAt(jd, zone) {
+		if (this.inflight.size === 0) return false;
+		for (const [name, params] of this.zoneParams) {
+			if (zone !== void 0 && name !== zone) continue;
+			if (this.inflight.has(chunkKey(name, chunkIndexForJd(params, jd)))) return true;
+		}
+		return false;
+	}
 	pendingCurrent(jd) {
 		if (this.inflight.size === 0) return RESOLVED;
 		let pending = null;
@@ -9021,6 +9046,10 @@ var ChebyshevStore = class extends ChunkWindow {
 			end: params.end_jd
 		};
 	}
+	isLoading(objectId, jd) {
+		const zone = this.idToZone.get(objectId);
+		return zone !== void 0 && this.loadingAt(jd, zone);
+	}
 	resolve(objectId, jd) {
 		const zone = this.idToZone.get(objectId);
 		if (zone === void 0) return null;
@@ -10059,6 +10088,7 @@ var RENDER_TIER_PRESETS = {
 		bloomScale: .5,
 		pointBudget: 4e5,
 		maxTextureTier: "medium",
+		tileWindows: 3,
 		maxSkyboxFace: 2048
 	},
 	medium: {
@@ -10068,6 +10098,7 @@ var RENDER_TIER_PRESETS = {
 		bloomScale: .75,
 		pointBudget: 9e5,
 		maxTextureTier: "medium",
+		tileWindows: 4,
 		maxSkyboxFace: 2048
 	},
 	high: {
@@ -10077,6 +10108,7 @@ var RENDER_TIER_PRESETS = {
 		bloomScale: 1,
 		pointBudget: Infinity,
 		maxTextureTier: "high",
+		tileWindows: 6,
 		maxSkyboxFace: Infinity
 	}
 };
@@ -10084,6 +10116,10 @@ function maxTextureTier() {
 	if (isLowEndDevice()) return "low";
 	return currentRenderTier().maxTextureTier;
 }
+function maxTileWindows() {
+	if (isLowEndDevice()) return 0;
+	return currentRenderTier().tileWindows;
+}
 function resolveRenderTier() {
 	const measured = sceneSettings().atmosphereCalibration?.tier;
 	if (measured === "low" || measured === "medium") return measured;
@@ -15429,6 +15465,491 @@ function detachSelfShadow(uniforms) {
 	uniforms.uSelfScale.value = 0;
 }
 
+//#endregion
+//#region src/lib/scene/lod/tile-window.ts
+var WINDOW_TILES = 4;
+var MAP = 0;
+var NORTH = 1;
+var SOUTH = 2;
+var CHART_FOLDER = [
+	"",
+	"north",
+	"south"
+];
+var FIRST_TILE_LEVEL = 3;
+var HOLD_TILES = .75;
+var BASE_WIDTH_PX = 2048;
+var CAP_EDGE = Math.SQRT2 - 1;
+var CAP_ENTER_DEG = 62;
+var CAP_LEAVE_DEG = 58;
+var BOTH_CHARTS_DEG = 45;
+function chartColumns(chart, level) {
+	return chart === 0 ? 2 << level : 1 << level - 1;
+}
+function chartRows(chart, level) {
+	return chart === 0 ? 1 << level : 1 << level - 1;
+}
+function neededLevel(radiusScene, dist, projScale, maxLevel) {
+	const height = Math.max(dist - radiusScene, radiusScene * 1e-6);
+	const widthPx = 2 * Math.PI * radiusScene * projScale / height;
+	return Math.min(Math.ceil(Math.log2(widthPx / BASE_WIDTH_PX)), maxLevel);
+}
+function chartPoint(chart, x, y, z) {
+	if (chart === 0) {
+		const east = Math.atan2(z, -x) / (2 * Math.PI);
+		return {
+			x: east < 0 ? east + 1 : east,
+			y: Math.acos(Math.min(Math.max(y, -1), 1)) / Math.PI
+		};
+	}
+	const side = chart === 1 ? 1 : -1;
+	const scale = .5 / (CAP_EDGE * (1 + side * y));
+	return {
+		x: .5 + x * scale,
+		y: .5 + side * z * scale
+	};
+}
+function cameraChart(y, previous) {
+	const cap = y >= 0 ? 1 : 2;
+	return Math.asin(Math.min(Math.abs(y), 1)) * 180 / Math.PI > (previous === cap ? CAP_LEAVE_DEG : CAP_ENTER_DEG) ? cap : 0;
+}
+function windowChain(level, count, chart, y) {
+	const chain = [];
+	for (let z = level; z >= 3 && chain.length < count; z--) chain.push({
+		chart,
+		level: z
+	});
+	const reached = chain.length > 0 && chain[chain.length - 1].level === 3;
+	const both = Math.abs(y) > Math.sin(BOTH_CHARTS_DEG * Math.PI / 180);
+	if (reached && both && chain.length < count) {
+		const cap = y >= 0 ? 1 : 2;
+		chain.push({
+			chart: chart === 0 ? cap : 0,
+			level: 3
+		});
+	}
+	return chain;
+}
+function placeAxis(at, count, wraps, kept) {
+	const last = Math.max(count - 4, 0);
+	if (kept !== void 0) {
+		let off = at - (kept + 4 / 2);
+		if (wraps) off -= count * Math.round(off / count);
+		if (!wraps && (kept === 0 && off < 0 || kept === last && off > 0) || Math.abs(off) <= HOLD_TILES) return kept;
+	}
+	const first = Math.round(at - 4 / 2);
+	return wraps ? (first % count + count) % count : Math.min(Math.max(first, 0), last);
+}
+function placeWindow(chart, level, x, y, previous) {
+	const columns = chartColumns(chart, level);
+	const rows = chartRows(chart, level);
+	const kept = previous?.chart === chart && previous.level === level ? previous : void 0;
+	const tx0 = placeAxis(x * columns, columns, chart === 0, kept?.tx0);
+	const ty0 = placeAxis(y * rows, rows, false, kept?.ty0);
+	if (kept && kept.tx0 === tx0 && kept.ty0 === ty0) return kept;
+	return {
+		chart,
+		level,
+		tx0,
+		ty0
+	};
+}
+function slotTile(placement, sx, sy) {
+	const columns = chartColumns(placement.chart, placement.level);
+	const dx = ((sx - placement.tx0) % 4 + 4) % 4;
+	const dy = ((sy - placement.ty0) % 4 + 4) % 4;
+	return {
+		x: (placement.tx0 + dx) % columns,
+		y: placement.ty0 + dy
+	};
+}
+
+//#endregion
+//#region src/lib/scene/objects/surface/tile-overlay.ts
+var MAX_WINDOWS = 6;
+var MAX_DRAWN = MAX_WINDOWS + 1;
+var MAX_INFLIGHT = 6;
+var MAX_FAILURES = 4;
+var FETCH_TIMEOUT_S = 30;
+var IDLE_DISPOSE_S = 5;
+var FEATHER_TILES = .5;
+var MAX_ANISOTROPY = 16;
+var SLOTS = 4 * 4;
+var PARS = `
+varying vec3 vTileDir;
+uniform sampler2DArray uTileMap;
+uniform sampler2DArray uTileMask;
+uniform vec4 uTileGrid[ ${MAX_DRAWN} ];
+uniform vec4 uTileWindow[ ${MAX_DRAWN} ];
+// Most taps of the anisotropic filter, and a tile's side in pixels.
+uniform vec2 uTileFilter;
+
+// Long and short half-axes of the footprint whose sides are fx and fy. The
+// two sides alone would do where the stretch runs along the screen's axes;
+// around a pole it runs every way, and each side then holds most of it.
+void tileAxes( vec2 fx, vec2 fy, out vec2 major, out vec2 minor ) {
+	float p = fx.x * fx.x + fy.x * fy.x;
+	float q = fx.y * fx.y + fy.y * fy.y;
+	float r = fx.x * fx.y + fy.x * fy.y;
+	float det = fx.x * fy.y - fx.y * fy.x;
+	float hi = 0.5 * ( p + q ) + sqrt( 0.25 * ( p - q ) * ( p - q ) + r * r );
+	float lo = det * det / max( hi, 1e-30 );
+	vec2 axis = p >= q ? vec2( hi - q, r ) : vec2( r, hi - p );
+	float len = length( axis );
+	axis = len > 0.0 ? axis / len : vec2( 1.0, 0.0 );
+	major = axis * sqrt( hi );
+	minor = vec2( - axis.y, axis.x ) * sqrt( lo );
+}
+
+vec3 tileColour( vec3 below ) {
+	if ( uTileWindow[ 0 ].w < 0.5 ) return below;
+
+	// Where the fragment is on each chart, as fractions from the chart's
+	// north-west corner, and what a screen pixel spans there. Both come from
+	// the direction of the fragment rather than its interpolated coordinates:
+	// those have one slope per triangle, which near a pole differs enough
+	// between the two triangles of a grid cell to pick different levels, and
+	// they jump at the 180° meridian.
+	vec3 dir = normalize( vTileDir );
+	vec3 ddx = dFdx( dir );
+	vec3 ddy = dFdy( dir );
+
+	float flat2 = max( dir.x * dir.x + dir.z * dir.z, 1e-12 );
+	float east = 1.0 / ( 2.0 * PI * flat2 );
+	float south = - 1.0 / ( PI * sqrt( flat2 ) );
+	vec2 mapAt = vec2( fract( atan( dir.z, - dir.x ) / ( 2.0 * PI ) ), acos( clamp( dir.y, - 1.0, 1.0 ) ) / PI );
+	vec2 mapDx = vec2( ( dir.z * ddx.x - dir.x * ddx.z ) * east, ddx.y * south );
+	vec2 mapDy = vec2( ( dir.z * ddy.x - dir.x * ddy.z ) * east, ddy.y * south );
+
+	// The cap of the fragment's own hemisphere, seen from above its pole.
+	float 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 );
+	vec2 capAt = 0.5 + plane * capScale;
+	vec2 capDx = ( vec2( ddx.x, side * ddx.z ) - plane * ( side * ddx.y / fold ) ) * capScale;
+	vec2 capDy = ( vec2( ddy.x, side * ddy.z ) - plane * ( side * ddy.y / fold ) ) * capScale;
+
+	float rows = ${4 .toFixed(1)};
+	vec3 colour = vec3( 0.0 );
+	float covered = 0.0;
+	for ( int i = 0; i < ${MAX_DRAWN}; i ++ ) {
+		vec4 window = uTileWindow[ i ];
+		if ( window.w < 0.5 ) break;
+		vec4 grid = uTileGrid[ i ];
+		bool onMap = window.x < 0.5;
+		// The other pole's cap.
+		if ( ! onMap && ( window.x < 1.5 ) != ( side > 0.0 ) ) continue;
+		vec2 tile = ( onMap ? mapAt : capAt ) * grid.xy;
+		vec2 dx = ( onMap ? mapDx : capDx ) * grid.xy * uTileFilter.y;
+		vec2 dy = ( onMap ? mapDy : capDy ) * grid.xy * uTileFilter.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
+		// filter's to cover, as far as its taps reach. The window fades in
+		// over the level below its own, as a mipmap would.
+		vec2 major;
+		vec2 minor;
+		tileAxes( dx, dy, major, minor );
+		float foot = max( length( minor ), length( major ) / uTileFilter.x );
+		float weight = clamp( 1.0 - log2( max( foot, 1e-6 ) ), 0.0, 1.0 );
+		if ( weight <= 0.0 ) continue;
+
+		// Half a pixel in from a pole of the map: past it the filter would
+		// read the far row.
+		if ( onMap ) tile.y = clamp( tile.y, 0.0005, grid.y - 0.0005 );
+		// Offset from the window's north-west corner; the map's longitude wraps.
+		vec2 rel = tile - grid.zw;
+		if ( onMap ) rel.x = mod( rel.x, grid.x );
+		if ( rel.x < 0.0 || rel.x > rows || rel.y < 0.0 || rel.y > rows ) continue;
+		// Distance to the window's edge, in tiles. A pole of the map is no
+		// edge: nothing lies past it.
+		vec2 near = min( rel, rows - rel );
+		if ( onMap && grid.w < 0.5 ) near.y = rows - rel.y;
+		if ( onMap && grid.w + rows > grid.y - 0.5 ) near.y = grid.w < 0.5 ? rows : rel.y;
+		float edge = min( near.x, near.y );
+
+		ivec3 slot = ivec3( int( mod( tile.x, rows ) ), int( mod( tile.y, rows ) ), int( window.y ) );
+		float alpha = weight * texelFetch( uTileMask, slot, 0 ).r * smoothstep( 0.0, ${FEATHER_TILES.toFixed(2)}, edge );
+		if ( alpha <= 0.0 ) continue;
+
+		// The texture repeats every window: a tile sits in the slot its own
+		// column and row pick, north up.
+		vec3 st = vec3( tile.x / rows, - tile.y / rows, window.y );
+		vec2 texel = vec2( 1.0, - 1.0 ) / ( rows * uTileFilter.y );
+		colour += ( 1.0 - covered ) * alpha * textureGrad( uTileMap, st, major * texel, minor * texel ).rgb;
+		covered += ( 1.0 - covered ) * alpha;
+		if ( covered > 0.995 ) break;
+	}
+	return colour + ( 1.0 - covered ) * below;
+}
+`;
+var MAP_FRAGMENT = `
+#ifdef USE_MAP
+	vec4 sampledDiffuseColor = texture2D( map, vMapUv );
+	sampledDiffuseColor.rgb = tileColour( sampledDiffuseColor.rgb );
+	diffuseColor *= sampledDiffuseColor;
+#endif
+`;
+function createOverlay(material) {
+	const overlay = {
+		material,
+		uniforms: {
+			uTileMap: { value: null },
+			uTileMask: { value: null },
+			uTileGrid: { value: Array.from({ length: MAX_DRAWN }, () => new Vector4()) },
+			uTileWindow: { value: Array.from({ length: MAX_DRAWN }, () => new Vector4()) },
+			uTileFilter: { value: new Vector2(1, 1) }
+		},
+		inflight: 0,
+		failures: 0,
+		failed: /* @__PURE__ */ new Set(),
+		dead: false,
+		lastUsed: 0
+	};
+	chainShaderHook(material, "surfaceTiles", (shader) => {
+		Object.assign(shader.uniforms, overlay.uniforms);
+		shader.vertexShader = shader.vertexShader.replace("#include <common>", "#include <common>\nvarying vec3 vTileDir;").replace("#include <begin_vertex>", "#include <begin_vertex>\nvTileDir = position;");
+		shader.fragmentShader = shader.fragmentShader.replace("#include <map_pars_fragment>", `#include <map_pars_fragment>\n${PARS}`).replace("#include <map_fragment>", MAP_FRAGMENT);
+	});
+	return overlay;
+}
+function createStore(tileSize, layers, renderer) {
+	const size = tileSize * 4;
+	const texture = new DataArrayTexture(null, size, size, layers);
+	texture.source.dataReady = false;
+	texture.format = RGBAFormat;
+	texture.type = UnsignedByteType;
+	texture.colorSpace = SRGBColorSpace;
+	texture.wrapS = texture.wrapT = RepeatWrapping;
+	texture.minFilter = texture.magFilter = LinearFilter;
+	texture.generateMipmaps = false;
+	texture.anisotropy = Math.min(MAX_ANISOTROPY, renderer.capabilities.getMaxAnisotropy());
+	texture.needsUpdate = true;
+	const mask = new DataArrayTexture(new Uint8Array(SLOTS * layers), 4, 4, layers);
+	mask.format = RedFormat;
+	mask.type = UnsignedByteType;
+	mask.minFilter = mask.magFilter = NearestFilter;
+	mask.unpackAlignment = 1;
+	mask.needsUpdate = true;
+	return {
+		texture,
+		mask,
+		windows: [],
+		free: Array.from({ length: layers }, (_, layer) => layer),
+		tileSize
+	};
+}
+function setLoaded(store, layer, slot, loaded) {
+	store.mask.image.data[layer * SLOTS + slot] = loaded ? 255 : 0;
+	store.mask.needsUpdate = true;
+}
+function isLoaded(store, layer, slot) {
+	return store.mask.image.data[layer * SLOTS + slot] !== 0;
+}
+function retarget(store, win, placement, frame) {
+	if (win.placement === placement && win.frame === frame) return;
+	win.placement = placement;
+	win.frame = frame;
+	for (let slot = 0; slot < SLOTS; slot++) {
+		const { x, y } = slotTile(placement, slot % 4, Math.floor(slot / 4));
+		const key = `${frame ?? 0}/${win.chart}/${win.level}/${x}/${y}`;
+		if (win.wanted[slot] === key) continue;
+		win.wanted[slot] = key;
+		setLoaded(store, win.layer, slot, false);
+		const stale = win.pending.get(slot);
+		if (stale) {
+			stale.abort.abort();
+			win.pending.delete(slot);
+		}
+	}
+}
+function release(store, win) {
+	for (const { abort } of win.pending.values()) abort.abort();
+	win.pending.clear();
+	for (let slot = 0; slot < SLOTS; slot++) setLoaded(store, win.layer, slot, false);
+	store.free.push(win.layer);
+}
+function settled(overlay, store, win) {
+	for (let slot = 0; slot < SLOTS; slot++) {
+		const key = win.wanted[slot];
+		if (!key) return false;
+		if (!isLoaded(store, win.layer, slot) && !overlay.failed.has(key)) return false;
+	}
+	return true;
+}
+async function fetchTile(url, signal) {
+	const response = await fetch(url, { signal });
+	if (!response.ok) throw new Error(`tile ${response.status}`);
+	return createImageBitmap(await response.blob(), {
+		imageOrientation: "flipY",
+		premultiplyAlpha: "none",
+		colorSpaceConversion: "none"
+	});
+}
+var copyAt = new Vector3();
+var queue$1 = [];
+function pump(overlay, store, tiles, win, x, y, renderer, invalidate) {
+	const placement = win.placement;
+	if (!placement) return;
+	const columns = chartColumns(win.chart, win.level);
+	const cx = x * columns;
+	const cy = y * chartRows(win.chart, win.level);
+	queue$1.length = 0;
+	for (let slot = 0; slot < SLOTS; slot++) {
+		const key = win.wanted[slot];
+		if (!key || win.pending.has(slot) || overlay.failed.has(key)) continue;
+		if (isLoaded(store, win.layer, slot)) continue;
+		const tile = slotTile(placement, slot % 4, Math.floor(slot / 4));
+		let dx = tile.x + .5 - cx;
+		if (win.chart === 0) dx -= columns * Math.round(dx / columns);
+		queue$1.push({
+			slot,
+			far: Math.hypot(dx, tile.y + .5 - cy)
+		});
+	}
+	queue$1.sort((a, b) => a.far - b.far);
+	for (const { slot } of queue$1) {
+		if (overlay.inflight >= MAX_INFLIGHT) return;
+		const key = win.wanted[slot];
+		const sx = slot % 4;
+		const sy = Math.floor(slot / 4);
+		const tile = slotTile(placement, sx, sy);
+		const abort = new AbortController();
+		let timedOut = false;
+		const timer = setTimeout(() => {
+			timedOut = true;
+			abort.abort();
+		}, FETCH_TIMEOUT_S * 1e3);
+		win.pending.set(slot, {
+			key,
+			abort
+		});
+		overlay.inflight++;
+		const folder = CHART_FOLDER[win.chart];
+		fetchTile(tileUrl(tiles, folder, win.level, tile.x, tile.y, win.frame), abort.signal).then((bitmap) => {
+			if (win.wanted[slot] === key && !abort.signal.aborted) {
+				const source = new Texture(bitmap);
+				source.colorSpace = SRGBColorSpace;
+				source.flipY = false;
+				source.generateMipmaps = false;
+				copyAt.set(sx * store.tileSize, (4 - 1 - sy) * store.tileSize, win.layer);
+				renderer.copyTextureToTexture(source, store.texture, null, copyAt);
+				source.dispose();
+				setLoaded(store, win.layer, slot, true);
+				overlay.failures = 0;
+				invalidate();
+			}
+			bitmap.close();
+		}).catch(() => {
+			if (abort.signal.aborted && !timedOut) return;
+			overlay.failed.add(key);
+			if (++overlay.failures >= MAX_FAILURES) overlay.dead = true;
+		}).finally(() => {
+			clearTimeout(timer);
+			overlay.inflight--;
+			if (win.pending.get(slot)?.key === key) win.pending.delete(slot);
+		});
+	}
+}
+function switchOff(overlay) {
+	for (const link of overlay.uniforms.uTileWindow.value) link.w = 0;
+}
+function rest(bo, overlay, now) {
+	switchOff(overlay);
+	if (now - overlay.lastUsed > IDLE_DISPOSE_S * 1e3) disposeTileOverlay(bo);
+}
+function disposeTileOverlay(bo) {
+	const overlay = bo.tileOverlay;
+	if (!overlay) return;
+	switchOff(overlay);
+	const store = overlay.store;
+	if (!store) return;
+	for (const win of store.windows) for (const { abort } of win.pending.values()) abort.abort();
+	store.texture.dispose();
+	store.mask.dispose();
+	overlay.store = void 0;
+	overlay.uniforms.uTileMap.value = null;
+	overlay.uniforms.uTileMask.value = null;
+}
+function tilesServe(bo) {
+	const tiles = bo.surfaceTiles;
+	return !!tiles && tiles.max_level >= 3 && tilesBase() !== "" && maxTileWindows() > 0 && !bo.tileOverlay?.dead && textureAllowed(tiles.distribution);
+}
+var inverse = new Matrix4();
+var over = new Vector3();
+function updateTileOverlay(bo, camera, renderer, projScale, drawable, invalidate) {
+	const tiles = bo.surfaceTiles;
+	const mesh = bo.mesh;
+	const material = mesh?.material;
+	const level = tiles && mesh && material?.map && drawable && tilesServe(bo) ? neededLevel(bo.radiusScene, bo.cachedDist, projScale, tiles.max_level) : -1;
+	const now = performance.now();
+	if (!tiles || !mesh || !material || level < 3) {
+		if (bo.tileOverlay) rest(bo, bo.tileOverlay, now);
+		return;
+	}
+	if (bo.tileOverlay && bo.tileOverlay.material !== material) {
+		disposeTileOverlay(bo);
+		bo.tileOverlay = void 0;
+	}
+	const overlay = bo.tileOverlay ??= createOverlay(material);
+	overlay.lastUsed = now;
+	const levels = tiles.max_level - 3 + 1;
+	const count = Math.min(maxTileWindows(), MAX_WINDOWS, levels + 1);
+	if (overlay.store && overlay.store.texture.image.depth !== count + 1) disposeTileOverlay(bo);
+	const store = overlay.store ??= createStore(tiles.tile_size, count + 1, renderer);
+	overlay.uniforms.uTileMap.value = store.texture;
+	overlay.uniforms.uTileMask.value = store.mask;
+	overlay.uniforms.uTileFilter.value.set(store.texture.anisotropy, tiles.tile_size);
+	over.copy(camera.position).applyMatrix4(inverse.copy(mesh.matrixWorld).invert()).normalize();
+	const cap = over.y >= 0 ? 1 : 2;
+	overlay.chart = cameraChart(over.y, overlay.chart);
+	const chain = windowChain(level, count, overlay.chart, over.y);
+	const frame = tiles.frames ? bo.textureFrame : void 0;
+	const held = (link) => store.windows.find((win) => win.chart === link.chart && win.level === link.level);
+	store.windows = store.windows.filter((win) => {
+		win.rank = chain.findIndex((link) => link.chart === win.chart && link.level === win.level);
+		if (win.rank >= 0) return true;
+		win.rank = chain.length;
+		const heir = chain.find((link) => link.level === win.level);
+		const heirWindow = heir && held(heir);
+		const near = win.chart === 0 || win.chart === cap;
+		if (heir && near && !(heirWindow && settled(overlay, store, heirWindow))) return true;
+		release(store, win);
+		return false;
+	});
+	for (let i = chain.length - 1; i >= 0; i--) {
+		const link = chain[i];
+		let win = held(link);
+		if (!win) {
+			const layer = store.free.pop();
+			if (layer === void 0) continue;
+			win = {
+				layer,
+				...link,
+				rank: i,
+				wanted: new Array(SLOTS),
+				pending: /* @__PURE__ */ new Map()
+			};
+			store.windows.push(win);
+		}
+		const point = chartPoint(link.chart, over.x, over.y, over.z);
+		retarget(store, win, placeWindow(link.chart, link.level, point.x, point.y, win.placement), frame);
+		pump(overlay, store, tiles, win, point.x, point.y, renderer, invalidate);
+	}
+	store.windows.sort((a, b) => b.level - a.level || a.rank - b.rank);
+	for (let i = 0; i < MAX_DRAWN; i++) {
+		const win = store.windows[i];
+		const link = overlay.uniforms.uTileWindow.value[i];
+		if (!win?.placement) {
+			link.w = 0;
+			continue;
+		}
+		overlay.uniforms.uTileGrid.value[i].set(chartColumns(win.chart, win.level), chartRows(win.chart, win.level), win.placement.tx0, win.placement.ty0);
+		link.set(win.chart, win.layer, win.level, 1);
+	}
+}
+
 //#endregion
 //#region src/lib/scene/objects/body/lifecycle.ts
 function disposeMaterial(mat) {
@@ -15562,6 +16083,8 @@ function downgradeBodyMesh(bo, scene, clickables, meshToBody) {
 			detachSelfShadow(bo.selfShadow);
 			bo.selfShadow = null;
 		}
+		disposeTileOverlay(bo);
+		bo.tileOverlay = void 0;
 		bo.terrainWindow = null;
 		mesh.removeFromParent();
 		mesh.geometry.dispose();
@@ -16269,6 +16792,7 @@ async function loadBodyTexture(bo, textureLoader, currentJd, scene, maxTextureSi
 	if (!sceneSettings().showSurfaceTexture) return;
 	if (!surface) return;
 	bo.textureBundleId = surface.id === bodyId ? void 0 : surface.id;
+	bo.surfaceTiles = surface.tiles;
 	bo.availableTiers ??= surface.tiers ?? [...TIER_NAMES];
 	bo.availableFrames = surface.frames;
 	await swapBodyTexture(bo, "low", textureFrameForJd(currentJd, bo.availableFrames), textureLoader);
@@ -16288,6 +16812,7 @@ function unloadBodyTexture(bo) {
 	bo.textureLoadGen = (bo.textureLoadGen ?? 0) + 1;
 	const material = bo.mesh.material;
 	unloadSiblingLayer("topography", bo);
+	disposeTileOverlay(bo);
 	if (!material.map) return;
 	material.map.dispose();
 	material.map = null;
@@ -17631,9 +18156,11 @@ function makeTrail(body, color, basisPos = [
 	const { orbitElements, orbitCenter, data } = body;
 	let curve;
 	let isOpenCurve;
+	let start;
 	if (data.satrec) {
 		curve = sgp4Curve(data.satrec, jd, data.n / 360, 512);
 		isOpenCurve = true;
+		start = curve.length - 1;
 	} else {
 		if (!orbitElements) throw new Error("makeTrail called without orbitElements");
 		curve = null;
@@ -17643,7 +18170,7 @@ function makeTrail(body, color, basisPos = [
 	const cy = orbitCenter?.[1] ?? 0;
 	const cz = orbitCenter?.[2] ?? 0;
 	const useTrail = isOpenCurve || data.objectType === ObjectType.DWARF_PLANET || data.objectType === ObjectType.MOON || data.objectType === ObjectType.SPACECRAFT || data.objectType === ObjectType.COMET || isAsteroid(data.objectType);
-	const validPoints = curve ? buildTrailPoints(body, curve, isOpenCurve, cx, cy, cz) : [];
+	const validPoints = curve ? buildTrailPoints(body, curve, isOpenCurve, cx, cy, cz, start) : [];
 	if (curve && validPoints.length < 2) return makeEmptyTrail();
 	const bufferCapacity = curve ? Math.max(validPoints.length, curve.length) : 512 + 1;
 	const fullAlphas = new Float32Array(bufferCapacity);
@@ -17823,6 +18350,7 @@ async function loadSystemData(barycenterId, bodyObjects, scene, textureLoader, c
 			bo.availableTiers = surface.tiers;
 			bo.availableFrames = surface.frames;
 			bo.textureBundleId = surface.id === bodyId ? void 0 : surface.id;
+			bo.surfaceTiles = surface.tiles;
 			if (!bo.textureTier) {
 				const frame = textureFrameForJd(currentJd, bo.availableFrames);
 				promises.push(loadBodyTextureTier(bo, "low", frame, textureLoader));
@@ -19650,15 +20178,17 @@ function refreshTrail(body, line, basisPos, jd, view) {
 	const useTrail = line.userData.useTrail;
 	const oc = line.userData.orbitCenter;
 	const cx = oc.x, cy = oc.y, cz = oc.z;
+	let windowStart;
 	if (body.data.satrec) {
 		const meanMotion = body.data.n / 360;
 		const stepDays = meanMotion > 0 ? 1 / meanMotion / 512 : 0;
-		const curveJd = line.userData.curveJd;
+		let curveJd = line.userData.curveJd;
 		if (curve.length === 0 || curveJd === void 0 || Math.abs(jd - curveJd) >= stepDays) {
 			curve = sgp4Curve(body.data.satrec, jd, meanMotion, 512);
 			line.userData.sourceCurve = curve;
-			line.userData.curveJd = jd;
+			line.userData.curveJd = curveJd = jd;
 		}
+		windowStart = curve.length - (jd < curveJd ? 2 : 1);
 	} else if (body.orbitElements) {
 		if (body.rederiveElements) {
 			const elementsJd = line.userData.elementsJd ?? jd;
@@ -19697,7 +20227,7 @@ function refreshTrail(body, line, basisPos, jd, view) {
 	const headY = anchor[1] - cy;
 	const headZ = anchor[2] - cz;
 	if (withinTolerance(ud, curve, offX, offY, offZ, headX, headY, headZ, view)) return;
-	const validPoints = buildTrailPoints(body, curve, isOpenCurve, cx, cy, cz);
+	const validPoints = buildTrailPoints(body, curve, isOpenCurve, cx, cy, cz, windowStart);
 	if (validPoints.length < 2) return;
 	const { posArr, trailArr, fullArr, capacity } = getTrailWorkingArrays(line);
 	const bx = cx - basisPos[0], by = cy - basisPos[1], bz = cz - basisPos[2];
@@ -20998,11 +21528,10 @@ function updatePositions(params) {
 			setVec(focus.focusTargetWorld, p);
 			const camOff = focus.camTargetOffset;
 			if (camOff && focus.camTargetWorld) addVec(focus.camTargetWorld, p, camOff);
-		} else if (a.oldPos) {
-			focus.focusTruePos[0] += p[0] - a.oldPos[0];
-			focus.focusTruePos[1] += p[1] - a.oldPos[1];
-			focus.focusTruePos[2] += p[2] - a.oldPos[2];
-			setVec(focus.focusTargetWorld, focus.focusTruePos);
+		} else if (a.oldPos) for (let k = 0; k < 3; k++) {
+			const moved = p[k] - a.oldPos[k];
+			focus.focusTruePos[k] += moved;
+			focus.focusTargetWorld[k] += moved;
 		}
 		break;
 	}
@@ -21025,8 +21554,10 @@ function updatePositions(params) {
 		refreshTrail(bo.body, line, basis, jd, trailView);
 		line.userData.refreshDeferred = false;
 	}
+	const focusLoading = !focusPos && why === "loading";
 	return {
-		focusUnplaced: focusedBody !== void 0 && !focusPos,
+		focusUnplaced: focusedBody !== void 0 && !focusPos && !focusLoading,
+		focusLoading,
 		anchorId
 	};
 }
@@ -21403,11 +21934,14 @@ var Placer = class {
 		if (jd === this.passJd) this.settled.add(id);
 		return pos;
 	}
+	under(aboveId) {
+		return (this.ctx.getBody(aboveId) ?? this.bodyObjects.get(aboveId)?.body)?.unplaced === "loading" ? "loading" : "parent";
+	}
 	seatFeature(body, jd) {
 		const hostId = body.featureAnchor.hostId;
 		const host = this.ctx.getBody(hostId);
 		const hostPos = host && this.place(host, jd);
-		if (!host || !hostPos) return setUnplaced(body, "parent");
+		if (!host || !hostPos) return setUnplaced(body, this.under(hostId));
 		return seatFeatureBody(body, host, hostPos, this.bodyObjects.get(hostId), jd);
 	}
 	rideAt(jd) {
@@ -21438,8 +21972,9 @@ var Placer = class {
 		if (d.orbitalSource === OrbitalSource.SPICE_PROBE) return this.settleProbe(body, bo, jd);
 		const parentPos = this.at(d.parentId, jd);
 		if (!parentPos) {
-			diagnostics.warnOnce("missing-parent", d.id, () => `place[${d.id}]: parent ${d.parentId} has no place`);
-			return setUnplaced(body, "parent");
+			const why = this.under(d.parentId);
+			if (why === "parent") diagnostics.warnOnce("missing-parent", d.id, () => `place[${d.id}]: parent ${d.parentId} has no place`);
+			return setUnplaced(body, why);
 		}
 		diagnostics.clear("missing-parent", d.id);
 		let offset;
@@ -21449,9 +21984,10 @@ var Placer = class {
 		return this.finish(body, bo, parentPos[0] + offset[0], parentPos[1] + offset[1], parentPos[2] + offset[2], parentPos, jd);
 	}
 	chebMiss(id, jd) {
-		const coverage = this.ctx.chebStore.zoneCoverage(id);
-		const outside = coverage !== null && (jd < coverage.start || jd > coverage.end);
-		if (outside && jd === this.passJd) {
+		const store = this.ctx.chebStore;
+		if (store.isLoading(id, jd)) return "loading";
+		const coverage = store.zoneCoverage(id);
+		if (coverage !== null && (jd < coverage.start || jd > coverage.end) && jd === this.passJd) {
 			this.noData.count++;
 			if (coverage.start < this.noData.earliestStart) this.noData.earliestStart = coverage.start;
 			if (coverage.end > this.noData.latestEnd) this.noData.latestEnd = coverage.end;
@@ -21460,7 +21996,7 @@ var Placer = class {
 			const cov = coverage ? `[${coverage.start.toFixed(1)},${coverage.end.toFixed(1)}]` : "unknown";
 			return `chebStore.positionScene[${id}] returned null at jd=${jd.toFixed(3)} (coverage=${cov})`;
 		});
-		return outside ? "no-data" : "loading";
+		return "no-data";
 	}
 	finish(body, bo, x, y, z, parentPos, jd) {
 		const d = body.data;
@@ -21523,6 +22059,7 @@ var Placer = class {
 		const zonePref = activeSysId ? (fitCenterNaif) => ctx.bodies.isInSystem(`naif-${fitCenterNaif}`, activeSysId) : void 0;
 		const located = ctx.probeStore?.probeWithCenter(d.id, jd, zonePref) ?? null;
 		if (!located) {
+			if (ctx.probeStore?.loadingAt(jd)) return setUnplaced(body, "loading");
 			setUnplaced(body, "no-data");
 			diagnostics.warnOnce("probe-unavailable", d.id, () => {
 				const reason = !ctx.probeStore ? "no ProbeStore" : "no zone has both a loaded chunk and a sub-chunk covering this jd";
@@ -21534,7 +22071,7 @@ var Placer = class {
 		if (probeLanded && isLandedAt(located.probe, jd)) {
 			const flyingFrameId = d.parentId;
 			const landedRender = renderLandedProbe(d, located.probe, probeLanded, jd, (id) => this.at(id, jd), ctx, bodyObjects);
-			if (!landedRender) return setUnplaced(body, "parent");
+			if (!landedRender) return setUnplaced(body, this.under(`naif-${probeLanded.bodyNaifId}`));
 			diagnostics.clear("probe-unavailable", d.id);
 			if (flyingFrameId !== d.parentId) body.trailBuffer?.clear();
 			if (bo) {
@@ -21559,7 +22096,8 @@ var Placer = class {
 		}
 		const primary = resolveProbePrimary(located.probe, jd, located.fitCenterNaifId, ctx.chebStore ?? null, (id) => this.at(id, jd) !== null);
 		if (!primary) {
-			setUnplaced(body, "parent");
+			const center = located.probe.fitCenter?.id;
+			setUnplaced(body, center ? this.under(center) : "parent");
 			diagnostics.warnOnce("probe-unavailable", d.id, () => `probe ${d.id} (${d.name ?? "unnamed"}): hidden — stamped fit center is not placeable this frame`);
 			return null;
 		}
@@ -21606,7 +22144,7 @@ var Placer = class {
 		if (probeParentChanged) d.parentId = probeParentKey;
 		const probeParentPos = this.at(probeParentKey, jd);
 		if (!probeParentPos) {
-			setUnplaced(body, "parent");
+			setUnplaced(body, this.under(probeParentKey));
 			diagnostics.warnOnce("probe-unavailable", d.id, () => `probe ${d.id} (${d.name ?? "unnamed"}): hidden — fit center ${probeParentKey} has no position this frame`);
 			return null;
 		}
@@ -21883,11 +22421,11 @@ function updateAtmosphereShaders(bodyObjects, cameraPosition, visible, realistic
 			spinAxis.set(0, 1, 0).applyQuaternion(bo.mesh.quaternion);
 			uniforms.uSpinAxis.value.copy(spinAxis);
 		}
-		const atmoMesh = bo.atmosphere.mesh;
-		const shellRadius = bo.atmosphere.geometryRadiusScene * atmoMesh.scale.x;
-		const camDist = cameraPosition.distanceTo(atmoMesh.position);
+		const shellCenter = bo.root.position;
+		const shellRadius = bo.atmosphere.geometryRadiusScene * bo.atmosphere.mesh.scale.x;
+		const camDist = cameraPosition.distanceTo(shellCenter);
 		if (shellRadius > camDist * .1) state.shellProminent = true;
-		if (quality.eclipseShadows) cullShellOccluders(uniforms, atmoMesh.position, sunVec, shellRadius);
+		if (quality.eclipseShadows) cullShellOccluders(uniforms, shellCenter, sunVec, shellRadius);
 		const inside = quality.insideView && camDist < shellRadius;
 		const referenceKm = bo.atmosphere.planetRadiusKm;
 		const altKm = camDist * ((referenceKm + params.topAltitudeKm) / shellRadius) - referenceKm;
@@ -21901,7 +22439,7 @@ function updateAtmosphereShaders(bodyObjects, cameraPosition, visible, realistic
 		}
 		if (inside) {
 			state.insideShell = true;
-			const sinSunElev = camUp.copy(cameraPosition).sub(atmoMesh.position).divideScalar(camDist).dot(sunVec);
+			const sinSunElev = camUp.copy(cameraPosition).sub(shellCenter).divideScalar(camDist).dot(sunVec);
 			const dim = skyboxDimFactor(params, altKm, sinSunElev);
 			state.skyboxIntensity *= dim * (1 - deckBlend);
 			if (quality.refraction && params.refractivity && !underDeck) {
@@ -21915,7 +22453,7 @@ function updateAtmosphereShaders(bodyObjects, cameraPosition, visible, realistic
 		const shellRatio = camDist / shellRadius;
 		if (quality.sunTint && shellRatio < SUN_TINT_MAX_RATIO) {
 			const planetRadiusScene = shellRadius / (1 + params.topAltitudeKm / referenceKm) * (bo.atmosphere.surfaceRadiusKm / referenceKm);
-			camRel.copy(cameraPosition).sub(atmoMesh.position);
+			camRel.copy(cameraPosition).sub(shellCenter);
 			const shellSpinAxis = uniforms.uSpinAxis.value;
 			const shellStretch = uniforms.uStretch.value;
 			if (sunPathTransmittance(params, camRel, sunVec, planetRadiusScene, bo.atmosphere.surfaceRadiusKm, sunT, shellSpinAxis, shellStretch)) {
@@ -21924,7 +22462,7 @@ function updateAtmosphereShaders(bodyObjects, cameraPosition, visible, realistic
 			}
 			if (sunViewTint && shellRatio < bestViewTintRatio) {
 				bestViewTintRatio = shellRatio;
-				bindViewTint(sunViewTint, params, atmoMesh.position, planetRadiusScene, bo.atmosphere.surfaceRadiusKm, shellSpinAxis, shellStretch);
+				bindViewTint(sunViewTint, params, shellCenter, planetRadiusScene, bo.atmosphere.surfaceRadiusKm, shellSpinAxis, shellStretch);
 			}
 		}
 	}
@@ -22251,7 +22789,7 @@ function desiredDemTier(altitudeRadii, current) {
 	if (tierRank(down) < tierRank(current)) return down;
 	return current;
 }
-function updateTextureLOD(bodyObjects, camera, renderer, ctx, textureLoader, focusedId, jd, appearances) {
+function updateTextureLOD(bodyObjects, camera, renderer, ctx, textureLoader, focusedId, jd, appearances, invalidate) {
 	appearances.apply(bodyObjects, textureLoader);
 	const fovRad = camera.fov * Math.PI / 180;
 	const projScale = renderer.domElement.clientHeight / (2 * Math.tan(fovRad / 2));
@@ -22275,7 +22813,8 @@ function updateTextureLOD(bodyObjects, camera, renderer, ctx, textureLoader, foc
 		else if (screenR < 1024 && altitudeRadii > 2) desired = "medium";
 		else desired = "high";
 		const currentRank = tierRank(bo.textureTier);
-		const desiredRank = Math.min(tierRank(desired), tierCap);
+		const bodyCap = tilesServe(bo) ? Math.min(tierCap, tierRank("medium")) : tierCap;
+		const desiredRank = Math.min(tierRank(desired), bodyCap);
 		const desiredFrame = textureFrameForJd(jd, bo.availableFrames);
 		const frameChanged = desiredFrame !== bo.textureFrame;
 		const wantsUpgrade = desiredRank > currentRank;
@@ -22283,6 +22822,7 @@ function updateTextureLOD(bodyObjects, camera, renderer, ctx, textureLoader, foc
 			const target = wantsUpgrade ? highestAvailableTier(desiredRank, bo.availableTiers) : bo.textureTier;
 			if (target) loadBodyTextureTier(bo, target, desiredFrame, textureLoader);
 		}
+		updateTileOverlay(bo, camera, renderer, projScale * renderer.getPixelRatio(), settings.showSurfaceTexture && !bo.appearance?.surfaceOwned && !bo.model, invalidate);
 		const dispTiers = bo.displacementMeta?.tiers;
 		if (bo.displacementMap && dispTiers?.length && !bo.displacementLoading) {
 			const maxTex = renderer.capabilities.maxTextureSize;
@@ -23630,6 +24170,7 @@ var SceneRenderer = class SceneRenderer {
 	lastDataVersion = -1;
 	dateHolds = 0;
 	focusWasOutOfRange = false;
+	seekAwaitsData = false;
 	frameIndex = 0;
 	static WAKE_FRAMES = 30;
 	static IDLE_HEARTBEAT_FRAMES = 10;
@@ -24124,7 +24665,7 @@ var SceneRenderer = class SceneRenderer {
 		for (const light of this.ambientLights) light.intensity = ambient;
 		updateUserLocationOcclusion(this.userLocationMarker, this.bodyObjects, this.camera);
 		const focusedIdLod = nomenclatureBodyId(this.focusController.current, this.bodyObjects);
-		updateTextureLOD(this.bodyObjects, this.camera, this.renderer, this.ctx, this.textureLoader, focusedIdLod, this.clock.jd, this.appearances);
+		updateTextureLOD(this.bodyObjects, this.camera, this.renderer, this.ctx, this.textureLoader, focusedIdLod, this.clock.jd, this.appearances, this.invalidate);
 		updateSphereLOD(this.bodyObjects, this.camera, this.renderer, this.ctx, focusedIdLod);
 		updateSunShadowLight(this.bodyObjects, this.focus.focusTruePos, this.ctx, this.shadowLight, this.sunPointLight, distance, this._tmpV3, sceneSettings().realisticLighting, this.sunIntensityScale);
 		this.updateModelMounts();
@@ -24641,7 +25182,7 @@ var SceneRenderer = class SceneRenderer {
 			this.clock.seeked = false;
 			return;
 		}
-		const seeked = this.clock.seeked;
+		const seeked = this.clock.seeked || this.seekAwaitsData;
 		this.clock.seeked = false;
 		this.lastUpdatedJd = this.clock.jd;
 		this.lastUpdatedSystemId = systemId;
@@ -24668,6 +25209,7 @@ var SceneRenderer = class SceneRenderer {
 			this.pointClouds.maybeRebase();
 		}
 		this.syncLandedNomenclature();
+		this.seekAwaitsData = seeked && result.focusLoading;
 		const losingPlace = result.focusUnplaced && !this.focusWasOutOfRange;
 		this.focusWasOutOfRange = result.focusUnplaced;
 		if (allowOorRefocus && seeked && losingPlace && result.anchorId) {