spacemap 0.1.13 → 0.1.14

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, 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 { 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 { OrbitControls } from "three/addons/controls/OrbitControls.js";
 import { EffectComposer } from "three/addons/postprocessing/EffectComposer.js";
 import { RenderPass } from "three/addons/postprocessing/RenderPass.js";
@@ -2960,6 +2960,12 @@ function get_custom_elements_slots(element) {
 	return result;
 }
 
+//#endregion
+//#region src/lib/fetch/tile-path.ts
+function tilePath(cap, level, x, y) {
+	return `${cap && `${cap}/`}${level}/${x}/${y}.webp`;
+}
+
 //#endregion
 //#region src/lib/fetch/data-base.ts
 function dataBase() {
@@ -2968,10 +2974,12 @@ function dataBase() {
 function tilesBase() {
 	return host().tilesUrl;
 }
+function tileRoot(tiles) {
+	return `${tilesBase()}/v1/tiles/${tiles.id}/`;
+}
 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}`;
+	return `${tileRoot(tiles)}${month}${tilePath(cap, level, x, y)}?v=${tiles.version}`;
 }
 var versions = {};
 function setDataVersions(v) {
@@ -3240,6 +3248,11 @@ function tileCredit(map) {
 	if (!tiles || tilesBase() === "" || !textureAllowed(tiles.distribution)) return void 0;
 	return tiles.source === map.source && tiles.attribution === map.attribution ? void 0 : tiles;
 }
+function patchCredits(map) {
+	const tiles = map.tiles;
+	if (!tiles?.patches || tilesBase() === "" || !textureAllowed(tiles.distribution)) return [];
+	return [...new Map(tiles.patches.map((patch) => [patch.source, patch])).values()];
+}
 
 //#endregion
 //#region src/lib/scene/state/credits.svelte.ts
@@ -3298,8 +3311,9 @@ var CreditsStore = class {
 	}
 	registerImagery(layer, bodyId, systemId, meta) {
 		this.addImagery(layer, bodyId, systemId, meta, layer === "rings");
-		const tiles = layer === "surface" ? tileCredit(meta) : void 0;
-		if (tiles) this.addImagery(layer, bodyId, systemId, tiles, true);
+		if (layer !== "surface" && layer !== "topography") return;
+		const tiles = tileCredit(meta);
+		for (const work of [...tiles ? [tiles] : [], ...patchCredits(meta)]) this.addImagery(layer, bodyId, systemId, work, true);
 	}
 	addImagery(layer, bodyId, systemId, meta, bySource) {
 		const key = [
@@ -6700,18 +6714,18 @@ function smallBodyFiltersEqual(a, b) {
 	if (a.kind === "flag" && b.kind === "flag") return a.flag === b.flag;
 	return false;
 }
-var pending$2 = null;
+var pending$3 = null;
 function fetchGroupIndex() {
-	if (pending$2) return pending$2;
+	if (pending$3) return pending$3;
 	const p = fetchWithTimeout(`${dataBase()}/v1/groups/__index__.json`).then((r) => {
 		if (!r.ok) throw new Error(`Failed to fetch group index: ${r.status}`);
 		return r.json();
 	});
-	pending$2 = p;
+	pending$3 = p;
 	p.catch(() => {
-		if (pending$2 === p) pending$2 = null;
+		if (pending$3 === p) pending$3 = null;
 	});
-	return pending$2;
+	return pending$3;
 }
 
 //#endregion
@@ -8912,9 +8926,9 @@ function partsForDate(zoom, isoDate, cap = 0) {
 	const parts = zoom.parts_by_date[isoDate] ?? zoom.parts;
 	return cap > 0 ? Math.min(parts, cap) : parts;
 }
-var pending$1 = null;
+var pending$2 = null;
 function fetchMetadata() {
-	if (pending$1) return pending$1;
+	if (pending$2) return pending$2;
 	const p = fetchWithTimeout(`${dataBase()}/v1/metadata.json`).then((r) => {
 		if (!r.ok) throw new Error(`Failed to fetch metadata: ${r.status}`);
 		return r.json();
@@ -8922,11 +8936,11 @@ function fetchMetadata() {
 		setDataVersions(meta.versions);
 		return meta;
 	});
-	pending$1 = p;
+	pending$2 = p;
 	p.catch(() => {
-		if (pending$1 === p) pending$1 = null;
+		if (pending$2 === p) pending$2 = null;
 	});
-	return pending$1;
+	return pending$2;
 }
 function chebyshevZoneParams(meta) {
 	const out = /* @__PURE__ */ new Map();
@@ -9088,7 +9102,8 @@ var ChunkWindow = class {
 	request(jd) {
 		for (const [zone, params] of this.zoneParams) {
 			const idx = chunkIndexForJd(params, jd);
-			if (this.isLoadable(params, idx)) this.loadChunk(zone, params, idx, "high")?.catch(() => {});
+			if (!this.isLoadable(params, idx)) continue;
+			this.loadChunk(zone, params, idx, "high", true)?.catch(() => {});
 		}
 	}
 	loadingAt(jd, zone) {
@@ -9099,6 +9114,14 @@ var ChunkWindow = class {
 		}
 		return false;
 	}
+	awaitedAt(jd, zone) {
+		for (const [name, params] of this.zoneParams) {
+			if (zone !== void 0 && name !== zone) continue;
+			const key = chunkKey(name, chunkIndexForJd(params, jd));
+			if (this.inflight.has(key) || this.retries.waiting(key)) return true;
+		}
+		return false;
+	}
 	isResident(zone, chunkIdx) {
 		return this.chunks.get(zone)?.has(chunkIdx) ?? false;
 	}
@@ -9122,7 +9145,10 @@ var ChunkWindow = class {
 			if (ok) this.retries.clear(key);
 			else this.retries.fail(key);
 		};
-		job.then(() => settle(true), () => settle(false));
+		job.then(() => settle(true), (error) => {
+			console.warn(`[position] chunk ${key} did not load:`, error);
+			settle(false);
+		});
 		return job;
 	}
 	async fetchAndStore(zone, params, chunkIdx, priority) {
@@ -9161,9 +9187,9 @@ var ChebyshevStore = class extends ChunkWindow {
 			end: params.end_jd
 		};
 	}
-	isLoading(objectId, jd) {
+	isAwaited(objectId, jd) {
 		const zone = this.idToZone.get(objectId);
-		return zone !== void 0 && this.loadingAt(jd, zone);
+		return zone !== void 0 && this.awaitedAt(jd, zone);
 	}
 	resolve(objectId, jd) {
 		const zone = this.idToZone.get(objectId);
@@ -9548,6 +9574,7 @@ var GROUP_BUNDLES = {
 	localizedPath: (lang, b) => `/v1/groups/${lang}/${b}.json.gz`
 };
 var clientFetcher = (path, versionClass) => fetchGzipBundle(versionClass ? versionedUrl(path, versionClass) : `${dataBase()}${path}`);
+var prefetchFetcher = (path, versionClass) => fetchGzipBundle(versionClass ? versionedUrl(path, versionClass) : `${dataBase()}${path}`, { priority: "low" });
 async function loadBundlePair(desc, key, { meta, lang, fetchBundle, localized = true }) {
 	const counts = meta[desc.counts];
 	const nGlobal = counts?.global ?? 0;
@@ -9559,22 +9586,22 @@ async function loadBundlePair(desc, key, { meta, lang, fetchBundle, localized =
 		localized: localizedBundle?.[key] ?? null
 	};
 }
-async function fetchBundlePair(desc, key, lang, localized = true) {
+async function fetchBundlePair(desc, key, lang, localized = true, background = false) {
 	return loadBundlePair(desc, key, {
 		meta: await fetchMetadata(),
 		lang,
 		localized,
-		fetchBundle: clientFetcher
+		fetchBundle: background ? prefetchFetcher : clientFetcher
 	});
 }
 
 //#endregion
 //#region src/lib/fetch/objects/object-data.ts
 function isViewable(entry) {
-	return entry.imagery !== "withheld" && textureAllowed(entry.distribution);
+	return textureAllowed(entry.distribution);
 }
-function fetchObjectDetail(fileId, fetchLocalized = true, lang = getLocale()) {
-	return fetchBundlePair(OBJECT_BUNDLES, fileId, lang, fetchLocalized);
+function fetchObjectDetail(fileId, fetchLocalized = true, lang = getLocale(), background = false) {
+	return fetchBundlePair(OBJECT_BUNDLES, fileId, lang, fetchLocalized, background);
 }
 
 //#endregion
@@ -9937,6 +9964,7 @@ var ZoneRefresher = class {
 			if (z.zone !== zoneName || z.kind !== "time") continue;
 			z.currentTime = "";
 			z.lastLoadStartMs = -Infinity;
+			this.retries.clear(loadKey(z, snapshotDate(z.zoomData, this.latestDate)));
 		}
 		this.tick(this.latestDate);
 	}
@@ -10006,7 +10034,11 @@ var ZoneRefresher = class {
 		this.wanted.add(id);
 	}
 	async ensureBody(targetId, date) {
-		if (targetId.startsWith("probe-")) await this.ensureProbe(targetId, date);
+		const anchorFailure = targetId.startsWith("probe-") ? await this.ensureProbe(targetId, date) : null;
+		await this.ensureListed(targetId, date);
+		if (anchorFailure) throw anchorFailure.error;
+	}
+	async ensureListed(targetId, date) {
 		if (this.ctx.getBody(targetId)) return;
 		if (targetId.startsWith("norad_satcat-") && !this.wanted.has(targetId)) {
 			this.want(targetId);
@@ -10020,20 +10052,22 @@ var ZoneRefresher = class {
 	}
 	async ensureProbe(targetId, date) {
 		const store = this.ctx.probeStore;
-		if (!store) return;
+		if (!store) return null;
 		const jd = dateToJD(date);
 		const passengerPromise = passengerFor(targetId);
 		await store.load(jd).catch(() => {});
 		const passenger = await passengerPromise;
 		if (passenger) store.registerCarried(passenger);
 		const fcId = store.stampedFitCenterAt(targetId, jd);
-		if (fcId) await ensureTargetStreamed(this.ctx, fcId);
-		if (this.ctx.getBody(targetId)) return;
+		const anchorFailure = fcId ? await ensureTargetStreamed(this.ctx, fcId).then(() => null, (error) => ({ error })) : null;
+		if (this.ctx.getBody(targetId)) return anchorFailure;
 		const labels = await fetchLabels();
 		const target = this.loader.processProbes(store, date, labels).find((b) => b.data.id === targetId);
-		if (!target) return;
-		this.ctx.bodies.addBodies([target]);
-		this.ctx.credits.recordOrbitSources([target]);
+		if (target) {
+			this.ctx.bodies.addBodies([target]);
+			this.ctx.credits.recordOrbitSources([target]);
+		}
+		return anchorFailure;
 	}
 	async loadTime(z, time, date) {
 		const fromTime = z.currentTime;
@@ -10212,6 +10246,9 @@ var RENDER_TIER_PRESETS = {
 		pointBudget: 4e5,
 		maxTextureTier: "medium",
 		tileWindows: 3,
+		reliefWindows: 2,
+		reliefShadowSteps: 12,
+		terrainBandCells: 16,
 		maxSkyboxFace: 2048
 	},
 	medium: {
@@ -10222,6 +10259,9 @@ var RENDER_TIER_PRESETS = {
 		pointBudget: 9e5,
 		maxTextureTier: "medium",
 		tileWindows: 4,
+		reliefWindows: 3,
+		reliefShadowSteps: 16,
+		terrainBandCells: 24,
 		maxSkyboxFace: 2048
 	},
 	high: {
@@ -10232,6 +10272,9 @@ var RENDER_TIER_PRESETS = {
 		pointBudget: Infinity,
 		maxTextureTier: "high",
 		tileWindows: 6,
+		reliefWindows: 4,
+		reliefShadowSteps: 32,
+		terrainBandCells: 32,
 		maxSkyboxFace: Infinity
 	}
 };
@@ -10243,6 +10286,13 @@ function maxTileWindows() {
 	if (isLowEndDevice()) return 0;
 	return currentRenderTier().tileWindows;
 }
+function maxReliefWindows() {
+	if (isLowEndDevice()) return 0;
+	return currentRenderTier().reliefWindows;
+}
+function reliefShadowSteps() {
+	return currentRenderTier().reliefShadowSteps;
+}
 function resolveRenderTier() {
 	const measured = sceneSettings().atmosphereCalibration?.tier;
 	if (measured === "low" || measured === "medium") return measured;
@@ -10955,7 +11005,7 @@ var SimClock = class {
 //#endregion
 //#region src/lib/math/spherical.ts
 var { PI, sin, cos, asin, atan2, sqrt } = Math;
-var DEG$8 = 180 / PI;
+var DEG$9 = 180 / PI;
 var RAD$5 = PI / 180;
 function applyQuat(v, q, inverse) {
 	const [x, y, z] = v;
@@ -10986,8 +11036,8 @@ function cartesianToSpherical(cam, target, bodyQuat) {
 		dz
 	], bodyQuat, true);
 	return {
-		latitude: asin(dy / distance) * DEG$8,
-		longitude: bodyQuat ? atan2(-dz, dx) * DEG$8 : atan2(dx, dz) * DEG$8,
+		latitude: asin(dy / distance) * DEG$9,
+		longitude: bodyQuat ? atan2(-dz, dx) * DEG$9 : atan2(dx, dz) * DEG$9,
 		distance
 	};
 }
@@ -11945,7 +11995,7 @@ function tagShaderModifier(material, mod) {
 	const mods = tagged.userData.shaderMods ??= [];
 	if (mods.includes(mod)) return;
 	mods.push(mod);
-	material.customProgramCacheKey = () => mods.join("|");
+	material.customProgramCacheKey = () => mods.map((name) => typeof name === "string" ? name : name()).join("|");
 }
 function chainShaderHook(material, mod, patch) {
 	const prev = material.onBeforeCompile;
@@ -15551,159 +15601,6 @@ function setStarLimbAlpha(material, alpha) {
 	if (alpha && uniforms?.uLimbAlpha) uniforms.uLimbAlpha.value.set(alpha[0], alpha[1], alpha[2]);
 }
 
-//#endregion
-//#region src/lib/scene/objects/surface/self-shadow.ts
-var STEPS = 32;
-var NORMAL_STRENGTH = 1;
-var GRADIENT_STENCIL = 2;
-var SLOPE_CLAMP = 1.5;
-var SHADOW_REACH = 4;
-var SHADOW_SOFT = .04;
-var TERMINATOR_GATE_LIT = .02;
-var TERMINATOR_GATE_DARK = -.08;
-var MARCH_GRAZE_FADE = .18;
-function attachSelfShadowToBody(material, heightMap, scaleScene, sunDir) {
-	const tex = heightMap.image;
-	const texel = new Vector2(1 / (tex?.width ?? 4096), 1 / (tex?.height ?? 2048));
-	const existing = material.userData.selfShadow;
-	if (existing) {
-		existing.uSelfHeightMap.value = heightMap;
-		existing.uSelfScale.value = scaleScene;
-		existing.uSelfTexel.value.copy(texel);
-		return existing;
-	}
-	const uniforms = {
-		uSelfHeightMap: { value: heightMap },
-		uSelfScale: { value: scaleScene },
-		uSelfTexel: { value: texel }
-	};
-	material.userData.selfShadow = uniforms;
-	const sun = sunDir ?? getEclipseSceneUniforms().uSunDir;
-	chainShaderHook(material, "selfShadow", (shader) => {
-		Object.assign(shader.uniforms, uniforms, { uSelfSunDir: sun });
-		shader.vertexShader = shader.vertexShader.replace("#include <common>", `#include <common>
-				varying vec3 vSelfWorldNormal;
-				varying vec2 vSelfUv;
-					varying vec3 vSelfEastW;
-					varying vec3 vSelfNorthW;
-					varying float vSelfRadiusW;
-					varying float vSelfCosLat;`).replace("#include <beginnormal_vertex>", `#include <beginnormal_vertex>
-				vSelfWorldNormal = normalize(mat3(modelMatrix) * objectNormal);
-				vSelfUv = uv;
-					// Analytic equirect tangent basis: smooth per fragment, so the
-					// relief normal doesn't inherit mesh facets.
-					vec3 nObj = normalize(position);
-					vec3 ec = cross(vec3(0.0, 1.0, 0.0), nObj);
-					float cl = length(ec);
-					vec3 eastObj = cl > 1e-5 ? ec / cl : vec3(1.0, 0.0, 0.0);
-					vSelfEastW = normalize(mat3(modelMatrix) * eastObj);
-					vSelfNorthW = normalize(mat3(modelMatrix) * cross(nObj, eastObj));
-					vSelfRadiusW = length(mat3(modelMatrix) * position);
-					vSelfCosLat = cl;`);
-		shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>
-				#define SELF_STEPS ${STEPS}
-				uniform sampler2D uSelfHeightMap;
-				uniform float uSelfScale;
-				uniform vec2 uSelfTexel;
-				uniform vec3 uSelfSunDir;
-				varying vec3 vSelfWorldNormal;
-				varying vec2 vSelfUv;
-					varying vec3 vSelfEastW;
-					varying vec3 vSelfNorthW;
-					varying float vSelfRadiusW;
-					varying float vSelfCosLat;
-
-				float selfHeight(vec2 uv) {
-					return texture2D(uSelfHeightMap, uv).r * uSelfScale;
-				}
-
-					// Analytic equirect frame (Tu=∂pos/∂u east, Tv=∂pos/∂v south). Screen-
-					// derivative tangents were piecewise-constant per triangle, tiling the
-					// relief normal with mesh facets. |Tu|=2πR·cos(lat), |Tv|=πR is the true metric.
-					void selfTangents(out vec3 Tu, out vec3 Tv) {
-						float R = vSelfRadiusW;
-						Tu = vSelfEastW * (6.2831853 * R * vSelfCosLat);
-						Tv = -vSelfNorthW * (3.14159265 * R);
-					}`).replace("#include <normal_fragment_maps>", `#include <normal_fragment_maps>
-				{
-					vec3 Tu, Tv;
-					selfTangents(Tu, Tv);
-					float lenTu = length(Tu);
-					float lenTv = length(Tv);
-					vec3 Nw = normalize(vSelfWorldNormal);
-					if (uSelfScale > 0.0 && lenTu > 1e-12 && lenTv > 1e-12) {
-						// Wider-than-one-texel stencil averages out 8-bit terracing, floored
-						// at the low tier's texel so a higher-res map keeps the same
-						// physical smoothing width instead of flattening the relief.
-						vec2 d = max(uSelfTexel, vec2(1.0 / 2048.0, 1.0 / 1024.0)) * ${GRADIENT_STENCIL.toFixed(3)};
-						float hu = selfHeight(vSelfUv + vec2(d.x, 0.0))
-							- selfHeight(vSelfUv - vec2(d.x, 0.0));
-						float hv = selfHeight(vSelfUv + vec2(0.0, d.y))
-							- selfHeight(vSelfUv - vec2(0.0, d.y));
-						// Slope = Δheight / Δworld-distance along each axis.
-						float su = ${NORMAL_STRENGTH.toFixed(3)} * hu / (2.0 * d.x * lenTu);
-						float sv = ${NORMAL_STRENGTH.toFixed(3)} * hv / (2.0 * d.y * lenTv);
-						// |Tu|/|Tv|=2·cos(lat): fade relief at the poles, where |Tu|→0 blows up east-west slope into a starburst.
-						float poleFade = smoothstep(0.0, 0.12, lenTu / (2.0 * lenTv));
-						su = clamp(su * poleFade, -${SLOPE_CLAMP.toFixed(3)}, ${SLOPE_CLAMP.toFixed(3)});
-						sv = clamp(sv * poleFade, -${SLOPE_CLAMP.toFixed(3)}, ${SLOPE_CLAMP.toFixed(3)});
-						vec3 reliefN = cross(Tu / lenTu + Nw * su, Tv / lenTv + Nw * sv);
-						float rl = length(reliefN);
-						if (rl > 1e-12) {
-							reliefN /= rl;
-							if (dot(reliefN, Nw) < 0.0) reliefN = -reliefN;
-							normal = normalize((viewMatrix * vec4(reliefN, 0.0)).xyz);
-						}
-					}
-				}`).replace("#include <lights_fragment_end>", `#include <lights_fragment_end>
-				{
-					vec3 Nw = normalize(vSelfWorldNormal);
-					vec3 L = normalize(uSelfSunDir);
-					float gN = dot(L, Nw);
-					// Gate on the GEOMETRIC normal: the relief normal can tilt sunward
-					// past the terminator and light the night side. Fading direct light
-					// by geometric N·L keeps the night dark regardless.
-					float shadow = smoothstep(${TERMINATOR_GATE_DARK.toFixed(3)}, ${TERMINATOR_GATE_LIT.toFixed(3)}, gN);
-					vec3 Tu, Tv;
-					selfTangents(Tu, Tv);
-					float lenTu = length(Tu);
-					float lenTv = length(Tv);
-					// Local crater self-shadow, lit hemisphere only — the macro gate owns
-					// the night side; the short march can't see that curvature.
-					if (shadow > 0.0 && uSelfScale > 0.0 && lenTu > 1e-12 && lenTv > 1e-12 && gN > 0.0) {
-						float lu = dot(L, Tu / lenTu);
-						float lv = dot(L, Tv / lenTv);
-						float lh = sqrt(lu * lu + lv * lv);
-						if (lh > 1e-4) {
-							float ds = ${SHADOW_REACH.toFixed(3)} * uSelfScale / float(SELF_STEPS);
-							// World step → uv step via the per-axis metric (|Tu|, |Tv|).
-							vec2 stepUv = ds * vec2((lu / lh) / lenTu, (lv / lh) / lenTv);
-							float h0 = selfHeight(vSelfUv);
-							float tanElev = gN / lh;
-							float block = 0.0;
-							for (int i = 1; i <= SELF_STEPS; i++) {
-								vec2 uv = vSelfUv + float(i) * stepUv;
-								float rayH = h0 + float(i) * ds * tanElev;
-								block = max(block, selfHeight(uv) - rayH);
-							}
-							// Fade the march out at grazing angles: a near-horizontal ray
-							// occludes every away-facing slope, banding the terminator.
-							float marchFade = smoothstep(0.0, ${MARCH_GRAZE_FADE.toFixed(3)}, gN);
-							shadow *= 1.0 - marchFade * clamp(block / (${SHADOW_SOFT.toFixed(3)} * uSelfScale), 0.0, 1.0);
-						}
-					}
-					reflectedLight.directDiffuse *= shadow;
-					reflectedLight.directSpecular *= shadow;
-				}`);
-	});
-	return uniforms;
-}
-function detachSelfShadow(uniforms) {
-	if (!uniforms) return;
-	uniforms.uSelfHeightMap.value = null;
-	uniforms.uSelfScale.value = 0;
-}
-
 //#endregion
 //#region src/lib/scene/lod/tile-window.ts
 var WINDOW_TILES = 4;
@@ -15717,7 +15614,7 @@ var CHART_FOLDER = [
 ];
 var FIRST_TILE_LEVEL = 3;
 var HOLD_TILES = .75;
-var BASE_WIDTH_PX = 2048;
+var BASE_WIDTH_PX$1 = 2048;
 var CAP_EDGE = Math.SQRT2 - 1;
 var CAP_ENTER_DEG = 62;
 var CAP_LEAVE_DEG = 58;
@@ -15731,7 +15628,7 @@ function chartRows(chart, level) {
 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);
+	return Math.min(Math.ceil(Math.log2(widthPx / BASE_WIDTH_PX$1)), maxLevel);
 }
 function chartPoint(chart, x, y, z) {
 	if (chart === 0) {
@@ -15752,12 +15649,17 @@ 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) {
+function windowChain(level, count, chart, y, maxLevel) {
 	const chain = [];
-	for (let z = level; z >= 3 && chain.length < count; z--) chain.push({
-		chart,
-		level: z
-	});
+	const own = Math.max(1, Math.floor(count / 3));
+	let z = level;
+	while (z >= 3 && chain.length < count) {
+		chain.push({
+			chart,
+			level: z
+		});
+		z = z > maxLevel && chain.length >= count - own ? Math.min(z - 1, maxLevel) : z - 1;
+	}
 	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) {
@@ -15793,6 +15695,42 @@ function placeWindow(chart, level, x, y, previous) {
 		ty0
 	};
 }
+function patchOfTile(patches, level, x, y) {
+	return patches?.find((patch) => {
+		const up = patch.max_level - level;
+		return up >= 0 && x >= patch.x[0] >> up && x <= patch.x[1] >> up && y >= patch.y[0] >> up && y <= patch.y[1] >> up;
+	});
+}
+var REACH_TILES = 4 / 2 - .5;
+function deepestLevel(maxLevel, patches, x, y) {
+	let deepest = maxLevel;
+	if (!patches) return deepest;
+	for (const patch of patches) for (let level = patch.max_level; level > deepest; level--) {
+		const up = patch.max_level - level;
+		const columns = chartColumns(0, level);
+		const x0 = patch.x[0] >> up;
+		const y0 = patch.y[0] >> up;
+		const halfWidth = ((patch.x[1] >> up) + 1 - x0) / 2;
+		const halfHeight = ((patch.y[1] >> up) + 1 - y0) / 2;
+		let east = x * columns - (x0 + halfWidth);
+		east -= columns * Math.round(east / columns);
+		const south = y * chartRows(0, level) - (y0 + halfHeight);
+		if (Math.abs(east) - halfWidth <= REACH_TILES && Math.abs(south) - halfHeight <= REACH_TILES) {
+			deepest = level;
+			break;
+		}
+	}
+	return deepest;
+}
+function windowHome(placement, x, y) {
+	const columns = chartColumns(placement.chart, placement.level);
+	let east = x * columns - placement.tx0;
+	east -= columns * Math.round(east / columns);
+	return {
+		x: east,
+		y: y * chartRows(placement.chart, placement.level) - placement.ty0
+	};
+}
 function slotTile(placement, sx, sy) {
 	const columns = chartColumns(placement.chart, placement.level);
 	const dx = ((sx - placement.tx0) % 4 + 4) % 4;
@@ -15804,24 +15742,190 @@ function slotTile(placement, sx, sy) {
 }
 
 //#endregion
-//#region src/lib/scene/objects/surface/tile-overlay.ts
+//#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}}const s=Math.sin(60*Math.PI/180);function c(e,t,n,r){return((e*16+t)*8192+n)*8192+r}function l(e){let t=e%8192,n=Math.floor(e/8192)%8192,r=Math.floor(e/(8192*8192));return{chart:Math.floor(r/16),level:r%16,x:n,y:t}}const u={chart:0,level:0,x0:0,x1:0,y0:0,y1:0,fx:0,fy:0};function d(e,t,n,r,c){let l=e<1||Math.abs(n)<=s?0:n>0?1:2,d=i(l,e)*c,f=a(l,e)*c,p=o(l,t,n,r),m=p.x*d-.5,h=p.y*f-.5,g=Math.floor(m),_=Math.floor(h),v=e=>Math.min(Math.max(e,0),d-1),y=e=>Math.min(Math.max(e,0),f-1);return u.chart=l,u.level=e,u.fx=m-g,u.fy=h-_,u.x0=l===0?(g+d)%d:v(g),u.x1=l===0?(g+1)%d:v(g+1),u.y0=y(_),u.y1=y(_+1),u}function f(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 p(e,t,n){let r=new Set([c(0,0,0,0),c(0,0,1,0)]);return f(e,t,(e,t,i,a,o)=>{let s=d(t,i,a,o,n),l=Math.floor(s.x0/n),u=Math.floor(s.x1/n),f=Math.floor(s.y0/n),p=Math.floor(s.y1/n);r.add(c(s.chart,s.level,l,f)),u!==l&&r.add(c(s.chart,s.level,u,f)),p!==f&&(r.add(c(s.chart,s.level,l,p)),u!==l&&r.add(c(s.chart,s.level,u,p)))}),r}function m(e,t,n,r,i,a){for(let o=t;o>=0;o--){let t=d(o,n,r,i,a),s=(n,r)=>{let i=e(c(t.chart,o,Math.floor(n/a),Math.floor(r/a)));return i&&i[r%a*a+n%a]},l=s(t.x0,t.y0),u=s(t.x1,t.y0),f=s(t.x0,t.y1),p=s(t.x1,t.y1);if(l===void 0||u===void 0||f===void 0||p===void 0)continue;let m=l+(u-l)*t.fx;return m+(f+(p-f)*t.fx-m)*t.fy}}function h(e,t,n,r,i,a){let o=new Float32Array(e.at.length*t.at.length),s=!1;return f(e,t,(e,t,c,l,u)=>{let d=m(n,t,c,l,u,r);d===void 0?s=!0:o[e]=a+i*d/65535}),s?null:o}function g(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 _(e,t){let n=new Uint16Array(t*t);for(let t=0,r=0;t<n.length;t++,r+=4)n[t]=e[r]<<8|e[r+1];return n}const v=self,y=new Map;let b;async function x(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;b?.width!==i&&(b=new OffscreenCanvas(i,i));let a=b.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 S(e,t){let{rgba:n,size:r}=await x(e.url,t),i=g(n,r);v.postMessage({type:`tile`,id:e.id,size:r,bytes:i},[i.buffer])}const C=new Map;let w=``;async function T(r,i){let{rows:a,columns:o,tileSize:s}=r,c=`${r.root}?${r.version}`;c!==w&&C.clear(),w=c;let u=p(a,o,s),d=[...u].filter(e=>!C.has(e));await Promise.all(Array.from({length:6},async()=>{for(let t=d.pop();t!==void 0;t=d.pop()){let{chart:a,level:o,x:s,y:c}=l(t),u=`${r.root}${e(n[a],o,s,c)}?v=${r.version}`;try{let{rgba:e,size:n}=await x(u,i);C.set(t,_(e,n))}catch{if(i.aborted)return}}})),i.throwIfAborted();let f=h(a,o,e=>C.get(e),s,r.scaleKm,r.biasKm);for(let e of[...C.keys()])u.has(e)||C.delete(e);if(!f)throw Error(`no height tiles for the grid`);let m=t(r.radius,a.at,o.at,f,r.unitsPerKm),g=m.indices.slice();v.postMessage({type:`grid`,id:r.id,...m,indices:g,riseKm:f},[m.positions.buffer,m.normals.buffer,m.uvs.buffer,g.buffer,f.buffer])}async function E(e){let t=new AbortController;y.set(e.id,t);try{e.type===`tile`?await S(e,t.signal):await T(e,t.signal)}catch{v.postMessage({type:`failed`,id:e.id})}finally{y.delete(e.id)}}self.onmessage=e=>{let t=e.data;t.type===`abort`?y.get(t.id)?.abort():E(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, signal) {
+	return ask((id) => ({
+		type: "tile",
+		id,
+		url: absolute(url)
+	}), signal);
+}
+function buildTerrainGrid(spec, signal) {
+	return ask((id) => ({
+		...spec,
+		type: "grid",
+		id,
+		root: absolute(spec.root)
+	}), signal);
+}
+
+//#endregion
+//#region src/lib/scene/objects/surface/tile-chain.ts
 var MAX_WINDOWS = 6;
-var MAX_DRAWN = MAX_WINDOWS + 1;
+var MAX_DRAWN = 6 + 1;
 var MAX_INFLIGHT = 6;
-var MAX_FAILURES = 4;
+var MAX_FAILURES$1 = 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;
+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;
+};
+
+// 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 ) {
+	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;
+}
+
+// The charts of a direction, the map counted from its north-west corner. The
+// direction is the fragment's own 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.
+TileCharts tileCharts( vec3 dir ) {
+	TileCharts charts;
+	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 ) );
+	charts.mapAt = vec2( fract( atan( dir.z, - dir.x ) / ( 2.0 * PI ) ), acos( clamp( dir.y, - 1.0, 1.0 ) ) / PI );
+	charts.mapDx = vec2( ( dir.z * ddx.x - dir.x * ddx.z ) * east, ddx.y * south );
+	charts.mapDy = vec2( ( dir.z * ddy.x - dir.x * ddy.z ) * east, ddy.y * south );
+	tileCap( dir, ddx, ddy, charts.side, charts.capAt, charts.capDx, charts.capDy );
+	return charts;
+}
+
+// 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;
+	vec3 pos = at + off;
+	vec3 ox = dFdx( off );
+	vec3 oy = dFdy( off );
+
+	// The turn about the axis and the drop from the north pole, each as the
+	// angle between at and the point.
+	float flat2 = max( pos.x * pos.x + pos.z * pos.z, 1e-30 );
+	float flat1 = sqrt( flat2 );
+	float flat0 = sqrt( at.x * at.x + at.z * at.z );
+	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 );
+
+	// 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;
+}
 
 // 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;
@@ -15840,105 +15944,61 @@ void tileAxes( vec2 fx, vec2 fy, out vec2 major, out vec2 minor ) {
 	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;
+// How much of a window shows at the fragment, before the mask of its tiles.
+// 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 ) {
+	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;
+
+	// 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.
+	tileAxes( dx, dy, major, minor );
+	float foot = max( length( minor ), length( major ) / tileFilter.x );
+	float weight = clamp( 1.0 - log2( max( foot, 1e-6 ) ), 0.0, 1.0 );
+	if ( weight <= 0.0 ) return 0.0;
 
 	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;
-
+	// Offset from the window's north-west corner, in tiles.
+	vec2 rel = onMap ? home + charts.mapAt * grid.xy : charts.capAt * 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.
-		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;
+		// read the far row. The map's longitude wraps.
+		rel.y = clamp( rel.y, 0.0005 - grid.w, grid.y - 0.0005 - grid.w );
+		rel.x = mod( rel.x, grid.x );
+	}
+	if ( rel.x < 0.0 || rel.x > rows || rel.y < 0.0 || rel.y > rows ) return 0.0;
+	// 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;
+	// The texture repeats every window: a tile sits in the slot its own
+	// column and row pick, north up.
+	spot = rel + mod( grid.zw, rows );
+	return weight * smoothstep( 0.0, ${FEATHER_TILES.toFixed(2)}, min( near.x, near.y ) );
 }
-`;
-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,
+function createChain(kind) {
+	return {
+		kind,
 		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) }
+			map: { value: null },
+			mask: { value: null },
+			grid: { value: Array.from({ length: 7 }, () => new Vector4()) },
+			window: { value: Array.from({ length: 7 }, () => new Vector4()) },
+			home: { value: Array.from({ length: 7 }, () => new Vector2()) },
+			anchor: { value: new Vector3(1, 0, 0) },
+			loaded: { value: new Int32Array(7) },
+			filter: { value: new Vector2(1, 1) }
 		},
 		inflight: 0,
 		failures: 0,
@@ -15946,20 +16006,14 @@ function createOverlay(material) {
 		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) {
+function createStore(kind, tileSize, layers, renderer) {
 	const size = tileSize * 4;
 	const texture = new DataArrayTexture(null, size, size, layers);
 	texture.source.dataReady = false;
-	texture.format = RGBAFormat;
+	texture.format = kind.format;
 	texture.type = UnsignedByteType;
-	texture.colorSpace = SRGBColorSpace;
+	texture.colorSpace = kind.colorSpace;
 	texture.wrapS = texture.wrapT = RepeatWrapping;
 	texture.magFilter = LinearFilter;
 	texture.minFilter = LinearMipmapLinearFilter;
@@ -15969,7 +16023,8 @@ function createStore(tileSize, layers, renderer) {
 	const mask = new DataArrayTexture(new Uint8Array(SLOTS * layers), 4, 4, layers);
 	mask.format = RedFormat;
 	mask.type = UnsignedByteType;
-	mask.minFilter = mask.magFilter = NearestFilter;
+	mask.minFilter = mask.magFilter = LinearFilter;
+	mask.wrapS = mask.wrapT = RepeatWrapping;
 	mask.unpackAlignment = 1;
 	mask.needsUpdate = true;
 	return {
@@ -16010,26 +16065,27 @@ function release(store, win) {
 	for (let slot = 0; slot < SLOTS; slot++) setLoaded(store, win.layer, slot, false);
 	store.free.push(win.layer);
 }
-function settled(overlay, store, win) {
+function patchOf(tiles, win, tile) {
+	if (win.chart !== 0 || win.level <= tiles.max_level) return void 0;
+	return patchOfTile(tiles.patches, win.level, tile.x, tile.y);
+}
+function exists(tiles, win, slot) {
+	if (win.level <= tiles.max_level) return true;
+	if (!win.placement) return false;
+	return patchOf(tiles, win, slotTile(win.placement, slot % 4, Math.floor(slot / 4))) !== void 0;
+}
+function settled(chain, store, tiles, 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;
+		if (isLoaded(store, win.layer, slot) || chain.failed.has(key)) continue;
+		if (exists(tiles, win, slot)) 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) {
+function pump(chain, store, tiles, win, x, y, renderer, invalidate) {
 	const placement = win.placement;
 	if (!placement) return;
 	const columns = chartColumns(win.chart, win.level);
@@ -16038,8 +16094,8 @@ function pump(overlay, store, tiles, win, x, y, renderer, invalidate) {
 	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;
+		if (!key || win.pending.has(slot) || chain.failed.has(key)) continue;
+		if (isLoaded(store, win.layer, slot) || !exists(tiles, win, 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);
@@ -16050,7 +16106,7 @@ function pump(overlay, store, tiles, win, x, y, renderer, invalidate) {
 	}
 	queue$1.sort((a, b) => a.far - b.far);
 	for (const { slot } of queue$1) {
-		if (overlay.inflight >= MAX_INFLIGHT) return;
+		if (chain.inflight >= MAX_INFLIGHT) return;
 		const key = win.wanted[slot];
 		const sx = slot % 4;
 		const sy = Math.floor(slot / 4);
@@ -16065,129 +16121,785 @@ function pump(overlay, store, tiles, win, x, y, renderer, invalidate) {
 			key,
 			abort
 		});
-		overlay.inflight++;
+		chain.inflight++;
 		const folder = CHART_FOLDER[win.chart];
-		fetchTile(tileUrl(tiles, folder, win.level, tile.x, tile.y, win.frame), abort.signal).then((bitmap) => {
+		const version = patchOf(tiles, win, tile)?.version ?? tiles.version;
+		const pyramid = {
+			id: tiles.id,
+			version
+		};
+		chain.kind.load(tileUrl(pyramid, folder, win.level, tile.x, tile.y, win.frame), abort.signal).then((loaded) => {
 			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();
+				renderer.copyTextureToTexture(loaded.texture, store.texture, null, copyAt);
 				setLoaded(store, win.layer, slot, true);
-				overlay.failures = 0;
+				chain.failures = 0;
 				invalidate();
 			}
-			bitmap.close();
+			loaded.release();
 		}).catch(() => {
 			if (abort.signal.aborted && !timedOut) return;
-			overlay.failed.add(key);
-			if (++overlay.failures >= MAX_FAILURES) overlay.dead = true;
+			chain.failed.add(key);
+			if (++chain.failures >= MAX_FAILURES$1) chain.dead = true;
 		}).finally(() => {
 			clearTimeout(timer);
-			overlay.inflight--;
+			chain.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 switchOff(chain) {
+	for (const link of chain.uniforms.window.value) link.w = 0;
+}
+function disposeChain(chain) {
+	switchOff(chain);
+	const store = chain.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();
+	chain.store = void 0;
+	chain.uniforms.map.value = null;
+	chain.uniforms.mask.value = null;
+}
+function restChain(chain, now) {
+	switchOff(chain);
+	if (now - chain.lastUsed > IDLE_DISPOSE_S * 1e3) disposeChain(chain);
+}
+var inverse = new Matrix4();
+var over = new Vector3();
+var anchor = new Vector3();
+function pointUnderCamera(mesh, camera) {
+	return over.copy(camera.position).applyMatrix4(inverse.copy(mesh.matrixWorld).invert()).normalize();
+}
+function finestLevelAt$1(chain, tiles, over) {
+	if (cameraChart(over.y, chain?.chart) !== 0) return tiles.max_level;
+	const point = chartPoint(0, over.x, over.y, over.z);
+	return deepestLevel(tiles.max_level, tiles.patches, point.x, point.y);
+}
+function chainLength(tiles, limit) {
+	let finest = tiles.max_level;
+	if (tiles.patches) for (const patch of tiles.patches) finest = Math.max(finest, patch.max_level);
+	const levels = finest - 3 + 1;
+	return Math.min(limit, 6, levels + 1);
+}
+function updateChain(chain, tiles, count, level, over, radius, frame, renderer, invalidate) {
+	chain.lastUsed = performance.now();
+	if (chain.store && chain.store.texture.image.depth !== count + 1) disposeChain(chain);
+	const store = chain.store ??= createStore(chain.kind, tiles.tile_size, count + 1, renderer);
+	chain.uniforms.map.value = store.texture;
+	chain.uniforms.mask.value = store.mask;
+	chain.uniforms.filter.value.set(store.texture.anisotropy, tiles.tile_size);
+	const cap = over.y >= 0 ? 1 : 2;
+	chain.chart = cameraChart(over.y, chain.chart);
+	const links = windowChain(level, count, chain.chart, over.y, tiles.max_level);
+	anchor.set(Math.fround(over.x * radius), Math.fround(over.y * radius), Math.fround(over.z * radius));
+	chain.uniforms.anchor.value.copy(anchor);
+	const range = anchor.length();
+	const home = chartPoint(0, anchor.x / range, anchor.y / range, anchor.z / range);
+	const held = (link) => store.windows.find((win) => win.chart === link.chart && win.level === link.level);
+	store.windows = store.windows.filter((win) => {
+		win.rank = links.findIndex((link) => link.chart === win.chart && link.level === win.level);
+		if (win.rank >= 0) return true;
+		win.rank = links.length;
+		const heir = links.find((link) => link.level === win.level);
+		const heirWindow = heir && held(heir);
+		const near = win.chart === 0 || win.chart === cap;
+		if (heir && near && !(heirWindow && settled(chain, store, tiles, heirWindow))) return true;
+		release(store, win);
+		return false;
+	});
+	for (let i = links.length - 1; i >= 0; i--) {
+		const link = links[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(chain, 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 < 7; i++) {
+		const win = store.windows[i];
+		const link = chain.uniforms.window.value[i];
+		if (!win?.placement) {
+			link.w = 0;
+			continue;
+		}
+		chain.uniforms.grid.value[i].set(chartColumns(win.chart, win.level), chartRows(win.chart, win.level), win.placement.tx0, win.placement.ty0);
+		if (win.chart === 0) {
+			const from = windowHome(win.placement, home.x, home.y);
+			chain.uniforms.home.value[i].set(from.x, from.y);
+		}
+		link.set(win.chart, win.layer, win.level, 1);
+		let loaded = 0;
+		for (let slot = 0; slot < SLOTS; slot++) if (isLoaded(store, win.layer, slot)) loaded |= 1 << slot;
+		chain.uniforms.loaded.value[i] = loaded;
+	}
+}
+
+//#endregion
+//#region src/lib/scene/objects/surface/relief-tiles.ts
+var MARCH_REACH = 8;
+var STEP_PIXELS = 1.5;
+var REFINE_STEPS = 3;
+var STEEPEST = 1;
+var MIN_SUN_SIZE = .006;
+var SLOPE_GLSL = `
+uniform sampler2DArray uReliefMap;
+uniform sampler2DArray uReliefMask;
+uniform vec4 uReliefGrid[ ${7} ];
+uniform vec4 uReliefWindow[ ${7} ];
+uniform int uReliefLoaded[ ${7} ];
+uniform vec2 uReliefFilter;
+uniform float uReliefScale;
+${TILE_CHAIN_GLSL}
+// Each byte is filtered alone, and the sum of the two is the filtered height.
+float reliefValue( vec4 texel ) {
+	return dot( texel.rg, vec2( 65280.0, 255.0 ) ) / 65535.0;
+}
+
+// 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;
+	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 ) );
+	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;
+}
+
+// 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 ) {
+	covered = 0.0;
+	first = - 1;
+	vec3 slope = vec3( 0.0 );
+	if ( uReliefWindow[ 0 ].w < 0.5 ) return slope;
+	ReliefRates rates = reliefRates( dir, charts.side );
+
+	float rows = ${4 .toFixed(1)};
+	for ( int i = 0; i < ${7}; i ++ ) {
+		vec4 window = uReliefWindow[ i ];
+		if ( window.w < 0.5 ) break;
+		vec4 grid = uReliefGrid[ i ];
+		vec2 spot;
+		vec2 major;
+		vec2 minor;
+		float alpha = tileWindowWeight( charts, window, grid, - grid.zw, 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.
+		alpha *= smoothstep( 0.51, 0.55, texture( uReliefMask, vec3( spot / rows, window.y ) ).r );
+		if ( alpha <= 0.0 ) continue;
+		if ( first < 0 ) first = i;
+
+		vec3 st = vec3( spot.x / rows, - spot.y / rows, window.y );
+		vec2 texel = vec2( 1.0, - 1.0 ) / ( rows * uReliefFilter.y );
+		vec2 gx = major * texel;
+		vec2 gy = minor * texel;
+		vec3 east = vec3( texel.x, 0.0, 0.0 );
+		vec3 south = vec3( 0.0, texel.y, 0.0 );
+		// Rise over two pixels of the window, then over the whole chart.
+		vec2 rise = vec2(
+			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 );
+		slope += ( 1.0 - covered ) * alpha * uphill;
+		covered += ( 1.0 - covered ) * alpha;
+		if ( covered > 0.995 ) break;
+	}
+	return slope * uReliefScale;
+}
+`;
+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.
+	float widest;
+	int loaded;
+};
+
+ReliefSight reliefSight( int i, TileCharts charts, vec2 mapStep, vec2 capStep ) {
+	vec4 window = uReliefWindow[ i ];
+	vec4 grid = uReliefGrid[ i ];
+	bool onMap = window.x < 0.5;
+	float rows = ${4 .toFixed(1)};
+	// In tiles from the window's north-west corner. The map goes round: the
+	// fragment is taken on the side nearest the window.
+	vec2 rel = ( onMap ? charts.mapAt : charts.capAt ) * grid.xy - grid.zw;
+	if ( onMap ) rel.x = mod( rel.x - 0.5 * rows + 0.5 * grid.x, grid.x ) + 0.5 * rows - 0.5 * grid.x;
+	vec2 rate = ( onMap ? mapStep : capStep ) * grid.xy;
+
+	// Half a pixel in from the window's sides: past it the filter reads the
+	// tile of the far side.
+	float inset = 0.5 / uReliefFilter.y;
+	vec2 run = mix( vec2( 1e-20 ), rate, greaterThan( abs( rate ), vec2( 1e-20 ) ) );
+	vec2 a = ( inset - rel ) / run;
+	vec2 b = ( rows - inset - rel ) / run;
+	vec2 near = min( a, b );
+	vec2 far = max( a, b );
+
+	ReliefSight sight;
+	sight.from = vec3( ( rel.x + grid.z ) / rows, - ( rel.y + grid.w ) / 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 );
+	// 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 ) );
+	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;
+	// Both tiles that the filter can read must be in.
+	if ( sight.loaded != ${(1 << 4 * 4) - 1} ) {
+		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 ) );
+		if ( ( both & 1 ) == 0 ) return - 1.0;
+	}
+	return reliefValue( textureLod( uReliefMap, vec3( st, sight.from.z ), 0.0 ) );
+}
+
+// Part of the Sun's disc that the ground leaves in sight of the fragment at
+// 'dir', or -1 where no window holds the fragment. The Sun is 'toSun' along
+// the sphere, 'tanElev' above it, and 'sunSize' is the radius of its disc.
+// 'first' is the fragment's window, as the slope gave it.
+//
+// A ray is marched towards the Sun. Each step is longer than the last by one
+// ratio, from a pixel of the fragment's window to the end of the ray, and is
+// 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 ) );
+
+	int drawn = 0;
+	for ( int i = 0; i < ${7}; i ++ ) {
+		if ( uReliefWindow[ i ].w > 0.5 ) drawn = i + 1;
+	}
+	int w = first;
+	ReliefSight sight;
+	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 );
+		own = reliefSightValue( sight, 0.0 );
+		if ( own >= 0.0 ) break;
+	}
+	if ( own < 0.0 ) return - 1.0;
+	int start = w;
+
+	// A ray rises above the sphere by its slope, and by the sphere's own
+	// curve under it. Past where it clears the pyramid's range, nothing
+	// can stand in it.
+	float clear = sqrt( tanElev * tanElev + 2.0 * uReliefScale * ( 1.0 - own ) ) - tanElev;
+	float reach = min( clear, ${MARCH_REACH.toFixed(1)} * uReliefScale );
+	if ( reach < 1e-7 ) return 1.0;
+
+	// 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 part = count * pixel / reach;
+	float rate = 0.0;
+	if ( part < 1.0 ) {
+		rate = - log( part );
+		for ( int k = 0; k < 4; k ++ ) rate = log( 1.0 + rate / part );
+	}
+	// Each sample is the one before times the ratio, plus the first step.
+	bool even = rate < 1e-3;
+	float ratio = even ? 1.0 : exp( rate / count );
+	float head = even ? reach / count : reach * ( ratio - 1.0 ) / ( exp( rate ) - 1.0 );
+
+	// How far the ground stands into the ray is counted in discs of the Sun.
+	// The disc is an angle, and the ray's rise is a slope.
+	float perDisc = 1.0 / ( max( sunSize, ${MIN_SUN_SIZE.toFixed(4)} ) * ( 1.0 + tanElev * tanElev ) );
+	float t = 0.0;
+	float hidden = - 1e9;
+	// The sample that hides the most, the step around it and its window.
+	float worst = 0.0;
+	float around = 0.0;
+	int worstWindow = w;
+	for ( int i = 1; i <= ${steps}; i ++ ) {
+		float before = t;
+		t = t * ratio + head;
+		if ( w + 1 < drawn && t - before > sight.widest ) {
+			w ++;
+			sight = reliefSight( w, charts, mapStep, capStep );
+		}
+		float value = reliefSightValue( sight, t );
+		// The ray left this window, or a tile of it is missing.
+		if ( value < 0.0 && w + 1 < drawn ) {
+			w ++;
+			sight = reliefSight( w, charts, mapStep, capStep );
+			value = reliefSightValue( sight, t );
+		}
+		if ( value < 0.0 ) continue;
+		float stands = ( ( value - own ) * uReliefScale / t - tanElev - 0.5 * t ) * perDisc;
+		if ( stands > hidden ) {
+			hidden = stands;
+			worst = t;
+			around = t - before;
+			worstWindow = w;
+			// The whole disc is hidden.
+			if ( hidden >= 1.0 ) break;
+		}
+	}
+
+	// The crest that hides the most lies between two samples, and far out
+	// those are far apart. Look for it around the best one, each time at half
+	// the distance and in a finer window. Not where the best one is so clear
+	// of the ray that no crest beside it can reach the Sun's disc.
+	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 );
+		for ( int k = 0; k < ${REFINE_STEPS}; k ++ ) {
+			around *= 0.5;
+			if ( w > start && around < sight.widest ) {
+				w --;
+				sight = reliefSight( w, charts, mapStep, capStep );
+			}
+			float centre = worst;
+			for ( int e = 0; e < 2; e ++ ) {
+				float at = centre + ( e == 0 ? - around : around );
+				float value = reliefSightValue( sight, at );
+				if ( value < 0.0 ) continue;
+				float stands = ( ( value - own ) * uReliefScale / at - tanElev - 0.5 * at ) * perDisc;
+				if ( stands > hidden ) {
+					hidden = stands;
+					worst = at;
+				}
+			}
+		}
+	}
+	return 1.0 - smoothstep( - 1.0, 1.0, hidden );
+}
+`;
+}
+function reliefTilesGlsl(steps) {
+	return steps > 0 ? SLOPE_GLSL + shadowGlsl(steps) : SLOPE_GLSL;
+}
+async function loadTile(url, signal) {
+	const { bytes, size } = await loadHeightTile(url, signal);
+	const texture = new DataTexture(bytes, size, size, RGFormat, UnsignedByteType);
+	return {
+		texture,
+		release: () => texture.dispose()
+	};
+}
+var HEIGHT_TILES = {
+	format: RGFormat,
+	colorSpace: NoColorSpace,
+	load: loadTile
+};
+function reliefTilesAvailable(tiles) {
+	return !!tiles && tiles.scale_km !== void 0 && tiles.max_level >= 3 && tilesBase() !== "" && maxReliefWindows() > 0 && textureAllowed(tiles.distribution);
+}
+function reliefTilesOf(material, tiles, radiusKm) {
+	if (!reliefTilesAvailable(tiles)) return void 0;
+	const held = material.userData.reliefTiles;
+	if (held) return held;
+	const chain = createChain(HEIGHT_TILES);
+	const relief = {
+		tiles,
+		chain,
+		shadowSteps: reliefShadowSteps(),
+		uniforms: {
+			uReliefMap: chain.uniforms.map,
+			uReliefMask: chain.uniforms.mask,
+			uReliefGrid: chain.uniforms.grid,
+			uReliefWindow: chain.uniforms.window,
+			uReliefLoaded: chain.uniforms.loaded,
+			uReliefFilter: chain.uniforms.filter,
+			uReliefScale: { value: (tiles.scale_km ?? 0) / radiusKm }
+		}
+	};
+	material.userData.reliefTiles = relief;
+	return relief;
+}
+function reliefTilesServe(bo) {
+	return !!bo.reliefTiles && !bo.reliefTiles.chain.dead;
+}
+function disposeReliefTiles(bo) {
+	if (bo.reliefTiles) disposeChain(bo.reliefTiles.chain);
+}
+function updateReliefTiles(bo, camera, renderer, projScale, invalidate) {
+	const relief = bo.reliefTiles;
+	if (!relief) return;
+	const mesh = bo.mesh;
+	if (mesh && relief.shadowSteps !== reliefShadowSteps()) {
+		relief.shadowSteps = reliefShadowSteps();
+		mesh.material.needsUpdate = true;
+	}
+	const level = mesh && bo.selfShadow && !relief.chain.dead ? neededLevel(bo.radiusScene, bo.cachedDist, projScale, relief.tiles.max_level) : -1;
+	if (!mesh || level < 3) {
+		restChain(relief.chain, performance.now());
+		return;
+	}
+	const levels = relief.tiles.max_level - 3 + 1;
+	updateChain(relief.chain, relief.tiles, Math.min(maxReliefWindows(), levels), level, pointUnderCamera(mesh, camera), bo.radiusScene, void 0, renderer, invalidate);
+}
+
+//#endregion
+//#region src/lib/scene/objects/surface/self-shadow.ts
+var STEPS = 32;
+var NORMAL_STRENGTH = 1;
+var GRADIENT_STENCIL = 2;
+var SLOPE_CLAMP = 1.5;
+var SHADOW_REACH = 4;
+var SHADOW_SOFT = .04;
+var TERMINATOR_GATE_LIT = .02;
+var TERMINATOR_GATE_DARK = -.08;
+var MARCH_GRAZE_FADE = .18;
+var TILE_LIGHT = `
+						if (byTiles > 0.005 && dot(normal, mat3(viewMatrix) * L) > 0.0) {
+							vec3 sunward = normalize(L * mat3(modelMatrix));
+							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 (tileLight < 0.0) byTiles = 0.0;
+						}`;
+function attachSelfShadowToBody(material, heightMap, scaleScene, sunDir, tiles) {
+	const tex = heightMap.image;
+	const texel = new Vector2(1 / (tex?.width ?? 4096), 1 / (tex?.height ?? 2048));
+	const existing = material.userData.selfShadow;
+	if (existing) {
+		existing.uSelfHeightMap.value = heightMap;
+		existing.uSelfScale.value = scaleScene;
+		existing.uSelfTexel.value.copy(texel);
+		return existing;
+	}
+	const uniforms = {
+		uSelfHeightMap: { value: heightMap },
+		uSelfScale: { value: scaleScene },
+		uSelfTexel: { value: texel }
+	};
+	material.userData.selfShadow = uniforms;
+	const sun = sunDir ?? getEclipseSceneUniforms().uSunDir;
+	chainShaderHook(material, tiles ? () => `selfShadowTiles${reliefShadowSteps()}` : "selfShadow", (shader) => {
+		const steps = tiles ? reliefShadowSteps() : 0;
+		Object.assign(shader.uniforms, uniforms, { uSelfSunDir: sun }, tiles?.uniforms);
+		if (tiles) shader.uniforms.uSelfSunSize = getEclipseSceneUniforms().uSunAngularRadius;
+		shader.vertexShader = shader.vertexShader.replace("#include <common>", `#include <common>
+				varying vec3 vSelfWorldNormal;
+				varying vec2 vSelfUv;
+				varying vec3 vSelfDir;
+					varying vec3 vSelfEastW;
+					varying vec3 vSelfNorthW;
+					varying float vSelfRadiusW;
+					varying float vSelfCosLat;`).replace("#include <beginnormal_vertex>", `#include <beginnormal_vertex>
+				vSelfWorldNormal = normalize(mat3(modelMatrix) * objectNormal);
+				vSelfUv = uv;
+				vSelfDir = position;
+					// Analytic equirect tangent basis: smooth per fragment, so the
+					// relief normal doesn't inherit mesh facets.
+					vec3 nObj = normalize(position);
+					vec3 ec = cross(vec3(0.0, 1.0, 0.0), nObj);
+					float cl = length(ec);
+					vec3 eastObj = cl > 1e-5 ? ec / cl : vec3(1.0, 0.0, 0.0);
+					vSelfEastW = normalize(mat3(modelMatrix) * eastObj);
+					vSelfNorthW = normalize(mat3(modelMatrix) * cross(nObj, eastObj));
+					vSelfRadiusW = length(mat3(modelMatrix) * position);
+					vSelfCosLat = cl;`);
+		shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>
+				#define SELF_STEPS ${STEPS}
+				uniform sampler2D uSelfHeightMap;
+				uniform float uSelfScale;
+				uniform vec2 uSelfTexel;
+				uniform vec3 uSelfSunDir;
+				uniform mat3 normalMatrix;
+				${tiles ? "uniform mat4 modelMatrix;\n				uniform float uSelfSunSize;" : ""}
+				varying vec3 vSelfWorldNormal;
+				varying vec2 vSelfUv;
+				varying vec3 vSelfDir;
+					varying vec3 vSelfEastW;
+					varying vec3 vSelfNorthW;
+					varying float vSelfRadiusW;
+					varying float vSelfCosLat;
+				${tiles ? reliefTilesGlsl(steps) : ""}
+
+				float selfHeight(vec2 uv) {
+					return texture2D(uSelfHeightMap, uv).r * uSelfScale;
+				}
+
+				// Slope of the whole-globe height map 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.
+				vec3 selfMapSlope(vec3 dir) {
+					float cosLat = sqrt(max(1.0 - dir.y * dir.y, 0.0));
+					if (cosLat < 1e-5) return vec3(0.0);
+					vec3 east = vec3(dir.z, 0.0, -dir.x) / cosLat;
+					vec3 north = cross(dir, east);
+					// Wider-than-one-texel stencil averages out 8-bit terracing, floored
+					// at the low tier's texel so a higher-res map keeps the same
+					// physical smoothing width instead of flattening the relief.
+					vec2 d = max(uSelfTexel, vec2(1.0 / 2048.0, 1.0 / 1024.0)) * ${GRADIENT_STENCIL.toFixed(3)};
+					float hu = selfHeight(vSelfUv + vec2(d.x, 0.0))
+						- selfHeight(vSelfUv - vec2(d.x, 0.0));
+					float hv = selfHeight(vSelfUv + vec2(0.0, d.y))
+						- selfHeight(vSelfUv - vec2(0.0, d.y));
+					// The map's u runs east over 2π·cos(lat) radii, its v north over π radii.
+					float su = hu / (2.0 * d.x * 6.2831853 * cosLat * vSelfRadiusW);
+					float sv = hv / (2.0 * d.y * 3.14159265 * vSelfRadiusW);
+					// Fade at the poles, where the columns of the map close in and
+					// blow the east-west slope up into a starburst.
+					float gain = ${NORMAL_STRENGTH.toFixed(3)} * smoothstep(0.0, 0.12, cosLat);
+					su = clamp(su * gain, -${SLOPE_CLAMP.toFixed(3)}, ${SLOPE_CLAMP.toFixed(3)});
+					sv = clamp(sv * gain, -${SLOPE_CLAMP.toFixed(3)}, ${SLOPE_CLAMP.toFixed(3)});
+					return east * su + north * sv;
+				}
+
+					// Analytic equirect frame for the shadow march: Tu=∂pos/∂u runs east and
+					// Tv=∂pos/∂v north, as the map's v does. |Tu|=2πR·cos(lat), |Tv|=πR.
+					void selfTangents(out vec3 Tu, out vec3 Tv) {
+						float R = vSelfRadiusW;
+						Tu = vSelfEastW * (6.2831853 * R * vSelfCosLat);
+						Tv = vSelfNorthW * (3.14159265 * R);
+					}
+
+				// Part of the Sun's light that the ground of the whole-globe map
+				// lets through, for a Sun towards L that is gN above the sphere.
+				float selfMapLight(vec3 L, float gN) {
+					vec3 Tu, Tv;
+					selfTangents(Tu, Tv);
+					float lenTu = length(Tu);
+					float lenTv = length(Tv);
+					if (lenTu <= 1e-12 || lenTv <= 1e-12) return 1.0;
+					float lu = dot(L, Tu / lenTu);
+					float lv = dot(L, Tv / lenTv);
+					float lh = sqrt(lu * lu + lv * lv);
+					if (lh <= 1e-4) return 1.0;
+					float ds = ${SHADOW_REACH.toFixed(3)} * uSelfScale / float(SELF_STEPS);
+					// World step → uv step via the per-axis metric (|Tu|, |Tv|).
+					vec2 stepUv = ds * vec2((lu / lh) / lenTu, (lv / lh) / lenTv);
+					float h0 = selfHeight(vSelfUv);
+					float tanElev = gN / lh;
+					float block = 0.0;
+					for (int i = 1; i <= SELF_STEPS; i++) {
+						vec2 uv = vSelfUv + float(i) * stepUv;
+						float rayH = h0 + float(i) * ds * tanElev;
+						block = max(block, selfHeight(uv) - rayH);
+					}
+					// Fade the march out at grazing angles: a near-horizontal ray
+					// occludes every away-facing slope, banding the terminator.
+					float marchFade = smoothstep(0.0, ${MARCH_GRAZE_FADE.toFixed(3)}, gN);
+					return 1.0 - marchFade * clamp(block / (${SHADOW_SOFT.toFixed(3)} * uSelfScale), 0.0, 1.0);
+				}`).replace("#include <normal_fragment_maps>", `#include <normal_fragment_maps>
+				vec3 selfDir = normalize(vSelfDir);
+				// The part of the fragment that the tiles answer for.
+				float selfCovered = 0.0;
+				${tiles ? "TileCharts selfCharts = tileCharts(selfDir);\n				int selfFirst = -1;" : ""}
+				{
+					vec3 slope = vec3(0.0);
+					${tiles ? "slope = reliefTileSlope(selfDir, selfCharts, 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;
+					normal = normalize(normalMatrix * (selfDir - slope));
+				}`).replace("#include <lights_fragment_end>", `#include <lights_fragment_end>
+				{
+					vec3 Nw = normalize(vSelfWorldNormal);
+					vec3 L = normalize(uSelfSunDir);
+					float gN = dot(L, Nw);
+					// Gate on the GEOMETRIC normal: the relief normal can tilt sunward
+					// past the terminator and light the night side. Fading direct light
+					// by geometric N·L keeps the night dark regardless.
+					float shadow = smoothstep(${TERMINATOR_GATE_DARK.toFixed(3)}, ${TERMINATOR_GATE_LIT.toFixed(3)}, gN);
+					// Local crater self-shadow, lit hemisphere only — the macro gate owns
+					// the night side; the short march can't see that curvature.
+					if (shadow > 0.0 && gN > 0.0) {
+						// The part of the fragment whose shadow the tiles cast.
+						float byTiles = ${steps > 0 ? "selfCovered" : "0.0"};
+						float tileLight = 1.0;
+						${steps > 0 ? TILE_LIGHT : ""}
+						float mapLight = 1.0;
+						if (byTiles < 0.995 && uSelfScale > 0.0) mapLight = selfMapLight(L, gN);
+						shadow *= mix(mapLight, tileLight, byTiles);
+					}
+					reflectedLight.directDiffuse *= shadow;
+					reflectedLight.directSpecular *= shadow;
+				}`);
+	});
+	return uniforms;
+}
+function detachSelfShadow(uniforms) {
+	if (!uniforms) return;
+	uniforms.uSelfHeightMap.value = null;
+	uniforms.uSelfScale.value = 0;
+}
+
+//#endregion
+//#region src/lib/scene/objects/surface/tile-overlay.ts
+var PARS = `
+varying vec3 vTileOff;
+uniform sampler2DArray uTileMap;
+uniform sampler2DArray uTileMask;
+uniform vec4 uTileGrid[ ${7} ];
+uniform vec4 uTileWindow[ ${7} ];
+uniform vec2 uTileHome[ ${7} ];
+uniform vec3 uTileAnchor;
+uniform vec2 uTileFilter;
+${TILE_CHAIN_GLSL}
+vec3 tileColour( vec3 below ) {
+	if ( uTileWindow[ 0 ].w < 0.5 ) return below;
+	TileCharts charts = tileChartsFrom( uTileAnchor, vTileOff );
+
+	float rows = ${4 .toFixed(1)};
+	vec3 colour = vec3( 0.0 );
+	float covered = 0.0;
+	for ( int i = 0; i < ${7}; i ++ ) {
+		vec4 window = uTileWindow[ i ];
+		if ( window.w < 0.5 ) break;
+		vec2 spot;
+		vec2 major;
+		vec2 minor;
+		float alpha = tileWindowWeight( charts, 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;
+		if ( alpha <= 0.0 ) continue;
+
+		vec3 st = vec3( spot.x / rows, - spot.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
+`;
+async function loadColourTile(url, signal) {
+	const response = await fetch(url, { signal });
+	if (!response.ok) throw new Error(`tile ${response.status}`);
+	const bitmap = await createImageBitmap(await response.blob(), {
+		imageOrientation: "flipY",
+		premultiplyAlpha: "none",
+		colorSpaceConversion: "none"
+	});
+	const texture = new Texture(bitmap);
+	texture.colorSpace = SRGBColorSpace;
+	texture.flipY = false;
+	texture.generateMipmaps = false;
+	return {
+		texture,
+		release() {
+			texture.dispose();
+			bitmap.close();
+		}
+	};
 }
-function rest(bo, overlay, now) {
-	switchOff(overlay);
-	if (now - overlay.lastUsed > IDLE_DISPOSE_S * 1e3) disposeTileOverlay(bo);
+var COLOUR_TILES = {
+	format: RGBAFormat,
+	colorSpace: SRGBColorSpace,
+	load: loadColourTile
+};
+function createOverlay(material) {
+	const chain = createChain(COLOUR_TILES);
+	chainShaderHook(material, "surfaceTiles", (shader) => {
+		Object.assign(shader.uniforms, {
+			uTileMap: chain.uniforms.map,
+			uTileMask: chain.uniforms.mask,
+			uTileGrid: chain.uniforms.grid,
+			uTileWindow: chain.uniforms.window,
+			uTileHome: chain.uniforms.home,
+			uTileAnchor: chain.uniforms.anchor,
+			uTileFilter: chain.uniforms.filter
+		});
+		shader.vertexShader = shader.vertexShader.replace("#include <common>", "#include <common>\nvarying vec3 vTileOff;\nuniform vec3 uTileAnchor;").replace("#include <begin_vertex>", "#include <begin_vertex>\nvTileOff = position - uTileAnchor;");
+		shader.fragmentShader = shader.fragmentShader.replace("#include <map_pars_fragment>", `#include <map_pars_fragment>\n${PARS}`).replace("#include <map_fragment>", MAP_FRAGMENT);
+	});
+	return {
+		material,
+		chain
+	};
 }
 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;
+	if (bo.tileOverlay) disposeChain(bo.tileOverlay.chain);
 }
 function tilesServe(bo) {
 	const tiles = bo.surfaceTiles;
-	return !!tiles && !bo.model && tiles.max_level >= 3 && tilesBase() !== "" && maxTileWindows() > 0 && !bo.tileOverlay?.dead && textureAllowed(tiles.distribution);
+	return !!tiles && !bo.model && tiles.max_level >= 3 && tilesBase() !== "" && maxTileWindows() > 0 && !bo.tileOverlay?.chain.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);
+	let over;
+	let level = -1;
+	if (tiles && mesh && material?.map && drawable && tilesServe(bo)) {
+		over = pointUnderCamera(mesh, camera);
+		const finest = finestLevelAt$1(bo.tileOverlay?.chain, tiles, over);
+		level = neededLevel(bo.radiusScene, bo.cachedDist, projScale, finest);
+	}
+	if (!tiles || !over || !material || level < 3) {
+		if (bo.tileOverlay) restChain(bo.tileOverlay.chain, performance.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);
-	}
+	updateChain((bo.tileOverlay ??= createOverlay(material)).chain, tiles, chainLength(tiles, maxTileWindows()), level, over, bo.radiusScene, tiles.frames ? bo.textureFrame : void 0, renderer, invalidate);
 }
 
 //#endregion
@@ -16325,6 +17037,8 @@ function downgradeBodyMesh(bo, scene, clickables, meshToBody) {
 		}
 		disposeTileOverlay(bo);
 		bo.tileOverlay = void 0;
+		disposeReliefTiles(bo);
+		bo.reliefTiles = void 0;
 		bo.terrainWindow = null;
 		mesh.removeFromParent();
 		mesh.geometry.dispose();
@@ -16613,11 +17327,14 @@ async function attachDisplacementMap(material, dispMeta, tier, textureLoader, sp
 	}
 	texture.colorSpace = NoColorSpace;
 	material.displacementMap = texture;
-	material.displacementScale = dispMeta.scale_km * kmToLocal;
-	material.displacementBias = dispMeta.bias_km * kmToLocal - (dispMeta.absolute_radius ? sphereRadius : 0);
+	setDisplacementScale(material, dispMeta, sphereRadius, kmToLocal);
 	material.needsUpdate = true;
 	return texture;
 }
+function setDisplacementScale(material, dispMeta, sphereRadius, kmToLocal = kmToScene(1)) {
+	material.displacementScale = dispMeta.scale_km * kmToLocal;
+	material.displacementBias = dispMeta.bias_km * kmToLocal - (dispMeta.absolute_radius ? sphereRadius : 0);
+}
 function displacementTierUrl(dispMeta, tier) {
 	return versionedUrl(`/v1/textures/${dispMeta.id}/${tier}.webp`, "textures");
 }
@@ -16870,7 +17587,12 @@ var SIBLING_LAYERS = {
 			bo.displacementMap = tex;
 			bo.displacementMeta = meta;
 			bo.displacementTier = "low";
-			bo.selfShadow = sceneSettings().showSelfShadow ? attachSelfShadowToBody(material, tex, kmToScene(meta.scale_km)) : null;
+			if (!sceneSettings().showSelfShadow) {
+				bo.selfShadow = null;
+				return;
+			}
+			bo.reliefTiles = reliefTilesOf(material, meta.tiles, effectiveRadiusKm(bo.body.data));
+			bo.selfShadow = attachSelfShadowToBody(material, tex, kmToScene(meta.scale_km), void 0, bo.reliefTiles);
 		},
 		unload(bo, mesh) {
 			if (!mesh) return;
@@ -16879,6 +17601,8 @@ var SIBLING_LAYERS = {
 			bo.displacementTier = void 0;
 			detachSelfShadow(bo.selfShadow);
 			bo.selfShadow = null;
+			disposeReliefTiles(bo);
+			bo.reliefTiles = void 0;
 		}
 	},
 	clouds: {
@@ -17288,6 +18012,7 @@ function fetchBodyNomenclature(bodyId, lang = getLocale()) {
 	let p = cache$1.get(key);
 	if (!p) {
 		p = (async () => {
+			await fetchMetadata();
 			const [records, labels] = await Promise.all([fetchPositions(bodyId), fetchLabelText(bodyId, lang)]);
 			return nameFeatures(records, labels);
 		})();
@@ -17351,7 +18076,7 @@ function gridCell(grid, latRad, lonRad) {
 			ty
 		};
 	}
-	const { thetas, phis } = grid;
+	const { thetas, phis, riseKm } = grid;
 	const theta = Math.PI / 2 - latRad;
 	let phi = (lonRad - Math.PI) % (2 * Math.PI);
 	if (phi < 0) phi += 2 * Math.PI;
@@ -17367,7 +18092,8 @@ function gridCell(grid, latRad, lonRad) {
 			[iy0 + 1, ix0 + 1]
 		].map(([iy, ix]) => ({
 			latRad: Math.PI / 2 - thetas[iy],
-			lonRad: phis[ix] + Math.PI
+			lonRad: phis[ix] + Math.PI,
+			riseKm: riseKm?.[iy * phis.length + ix]
 		})),
 		tx,
 		ty
@@ -17543,7 +18269,8 @@ function gridForBody(bo) {
 	return tw ? {
 		kind: "window",
 		thetas: tw.thetas,
-		phis: tw.phis
+		phis: tw.phis,
+		riseKm: tw.riseKm
 	} : {
 		kind: "uniform",
 		segs: bo?.currentSegments ?? 128
@@ -17552,20 +18279,22 @@ function gridForBody(bo) {
 function renderedCell(bo, bodyId, radiusKm, latRad, lonRad) {
 	const radii = radiiFor(bodyId, radiusKm);
 	if (!radii) return null;
+	const grid = gridForBody(bo);
 	let hf = null;
 	let scaleKm = 0;
 	let biasKm = 0;
 	const meta = bo?.displacementMeta;
-	if (meta && bo?.displacementMap) {
+	const ownHeights = grid.kind === "window" && !!grid.riseKm;
+	if (meta && bo?.displacementMap && !ownHeights) {
 		hf = heightFieldFor(bo, bodyId);
 		if (!hf) return null;
 		scaleKm = meta.scale_km;
 		biasKm = meta.bias_km - (meta.absolute_radius ? radiusKm : 0);
 	}
-	const { corners, tx, ty } = gridCell(gridForBody(bo), latRad, lonRad);
+	const { corners, tx, ty } = gridCell(grid, latRad, lonRad);
 	return {
 		pts: corners.map((corner) => {
-			const dispKm = hf ? sampleHeightTexel(hf, corner.latRad, corner.lonRad) * scaleKm + biasKm : 0;
+			const dispKm = corner.riseKm ?? (hf ? sampleHeightTexel(hf, corner.latRad, corner.lonRad) * scaleKm + biasKm : 0);
 			return displacedPoint(corner.latRad, corner.lonRad, dispKm, radiusKm, radii.a, radii.b, radii.c);
 		}),
 		tx,
@@ -20292,14 +21021,14 @@ var PointCloudSystem = class {
 
 //#endregion
 //#region src/lib/scene/objects/trail/lagrange-frame.ts
-var DEG$7 = Math.PI / 180;
+var DEG$8 = Math.PI / 180;
 var J2000 = 2451545;
 var A = 1.00000261;
 var E = .01671123;
-var L0 = 100.46457166 * DEG$7;
-var L_RATE = 35999.37244981 / 36525 * DEG$7;
-var PERI0 = 102.93768193 * DEG$7;
-var PERI_RATE = .32327364 / 36525 * DEG$7;
+var L0 = 100.46457166 * DEG$8;
+var L_RATE = 35999.37244981 / 36525 * DEG$8;
+var PERI0 = 102.93768193 * DEG$8;
+var PERI_RATE = .32327364 / 36525 * DEG$8;
 function earthHeliocentric(jd) {
 	const t = jd - J2000;
 	const peri = PERI0 + PERI_RATE * t;
@@ -22225,7 +22954,7 @@ var Placer = class {
 	}
 	chebMiss(id, jd) {
 		const store = this.ctx.chebStore;
-		if (store.isLoading(id, jd)) return "loading";
+		if (store.isAwaited(id, jd)) return "loading";
 		const coverage = store.zoneCoverage(id);
 		if (coverage !== null && (jd < coverage.start || jd > coverage.end) && jd === this.passJd) {
 			this.noData.count++;
@@ -22299,7 +23028,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");
+			if (ctx.probeStore?.awaitedAt(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";
@@ -22510,11 +23239,11 @@ function updateRingShaders(bodyObjects, focusTruePos, realistic, overexpose, cam
 
 //#endregion
 //#region src/lib/scene/objects/surface/atmosphere-season.ts
-var DEG$6 = Math.PI / 180;
+var DEG$7 = Math.PI / 180;
 var J2000_JD = 2451545;
 function marsSolarLongitudeDeg(jd) {
 	const d = jd - J2000_JD;
-	const m = (19.3871 + .52402073 * d) * DEG$6;
+	const m = (19.3871 + .52402073 * d) * DEG$7;
 	return ((270.3871 + .524038496 * d + ((10.691 + 3e-7 * d) * Math.sin(m) + .623 * Math.sin(2 * m) + .05 * Math.sin(3 * m) + .005 * Math.sin(4 * m) + 5e-4 * Math.sin(5 * m))) % 360 + 360) % 360;
 }
 function sampleSeason(lsGrid, values, lsDeg) {
@@ -22798,66 +23527,134 @@ function updateSunShadowLight(bodyObjects, focusTruePos, ctx, shadowLight, sunPo
 }
 
 //#endregion
-//#region src/lib/scene/lod/terrain-window.ts
+//#region src/lib/scene/lod/terrain-grid.ts
 var COARSE_SEGS = 128;
-var CELL_BUDGET = 256;
-var ENTER_ALT = .25;
-var EXIT_ALT = .32;
-var RECENTER_FRAC = .35;
-var REBUILD_MIN_MS = 300;
-var MARGIN = 1.25;
+var MARGIN$1 = 1.25;
 var SIN_FLOOR = .05;
-var MAX_VERTS = 4e5;
-var _inv = new Matrix4();
-var _camLocal = new Vector3();
-function mergeAxis(max, intervals, step) {
-	const inFine = (p) => intervals.some(([lo, hi]) => p > lo + 1e-9 && p < hi - 1e-9);
-	const coarseStep = max / COARSE_SEGS;
-	const pts = [];
-	for (let j = 0; j <= COARSE_SEGS; j++) {
-		const p = j === COARSE_SEGS ? max : j * coarseStep;
-		if (j === 0 || j === COARSE_SEGS || !inFine(p)) pts.push(p);
-	}
-	for (const [lo, hi] of intervals) {
-		const n0 = Math.ceil(Math.max(lo, 0) / step - 1e-9);
-		const n1 = Math.floor(Math.min(hi, max) / step + 1e-9);
-		for (let n = n0; n <= n1; n++) pts.push(n * step);
+var BASE_WIDTH_PX = 2048;
+function mergeBands(max, bands, coarseStep) {
+	const inside = (band, p) => !!band && band.intervals.some(([lo, hi]) => p > lo + 1e-9 && p < hi - 1e-9);
+	const points = [];
+	const segments = Math.round(max / coarseStep);
+	for (let j = 0; j <= segments; j++) {
+		const p = j === segments ? max : j * coarseStep;
+		if (j === 0 || j === segments || !inside(bands[bands.length - 1], p)) points.push({
+			p,
+			level: 0
+		});
 	}
-	pts.sort((a, b) => a - b);
-	const tol = step * .25;
-	const out = [];
-	for (const p of pts) {
-		if (out.length && p - out[out.length - 1] < tol) continue;
-		out.push(p);
+	bands.forEach((band, i) => {
+		for (const [lo, hi] of band.intervals) {
+			const n0 = Math.ceil(Math.max(lo, 0) / band.step - 1e-9);
+			const n1 = Math.floor(Math.min(hi, max) / band.step + 1e-9);
+			for (let n = n0; n <= n1; n++) {
+				const p = n * band.step;
+				if (!inside(bands[i - 1], p)) points.push({
+					p,
+					level: band.level
+				});
+			}
+		}
+	});
+	points.sort((a, b) => a.p - b.p || b.level - a.level);
+	const tolerance = (bands[0]?.step ?? coarseStep) * .25;
+	const kept = [];
+	for (const point of points) {
+		const last = kept[kept.length - 1];
+		if (last && point.p - last.p < tolerance) last.level = Math.max(last.level, point.level);
+		else kept.push(point);
+	}
+	kept[0].p = 0;
+	kept[kept.length - 1].p = max;
+	return {
+		at: Float64Array.from(kept, (point) => point.p),
+		level: Int8Array.from(kept, (point) => point.level)
+	};
+}
+function arcIntervals(centre, half) {
+	const full = 2 * Math.PI;
+	if (half >= Math.PI) return [[0, full]];
+	const lo = centre - half;
+	const hi = centre + half;
+	if (lo < 0) return [[0, hi], [lo + full, full]];
+	if (hi > full) return [[0, hi - full], [lo, full]];
+	return [[lo, hi]];
+}
+function finestPixel(maxLevel) {
+	return 2 * Math.PI / (BASE_WIDTH_PX * 2 ** maxLevel);
+}
+function nestedStepLevel(altitude, maxLevel, bandCells, previous) {
+	const pixel = finestPixel(maxLevel);
+	const raw = Math.log2(Math.max(altitude / bandCells, pixel) / pixel);
+	if (previous !== void 0 && raw > previous - .85 && raw < previous + .15) return previous;
+	return Math.max(0, Math.ceil(raw - 1e-9));
+}
+function planNestedGrid(centreTheta, centrePhi, altitude, peak, maxLevel, bandCells, stepLevel) {
+	const pixel = finestPixel(maxLevel);
+	const rowStep = Math.PI / 128;
+	const columnStep = 2 * Math.PI / 128;
+	const horizon = (height) => Math.acos(1 / (1 + Math.max(height, 0)));
+	const reach = MARGIN$1 * (horizon(altitude) + horizon(peak));
+	const sinTheta = Math.max(Math.sin(centreTheta), SIN_FLOOR);
+	const widen = Math.round(Math.log2(1 / sinTheta));
+	const rowBands = [];
+	const columnBands = [];
+	let radius = 0;
+	for (let exponent = stepLevel; radius < reach; exponent++) {
+		const step = pixel * 2 ** exponent;
+		if (step >= rowStep) break;
+		radius += bandCells * step;
+		const level = Math.max(maxLevel - exponent, 0);
+		rowBands.push({
+			intervals: [[Math.max(centreTheta - radius, 0), Math.min(centreTheta + radius, Math.PI)]],
+			step,
+			level
+		});
+		const half = Math.min(radius / sinTheta, Math.PI);
+		const fit = Math.ceil(Math.log2(2 * half / (4 * bandCells) / pixel) - 1e-9);
+		const columnExponent = Math.max(exponent + widen, fit);
+		const columnWidth = pixel * 2 ** columnExponent;
+		if (columnWidth >= columnStep) continue;
+		columnBands.push({
+			intervals: arcIntervals(centrePhi, half),
+			step: columnWidth,
+			level: Math.max(maxLevel - (columnExponent - widen), 0)
+		});
 	}
-	out[0] = 0;
-	out[out.length - 1] = max;
-	return Float64Array.from(out);
+	return {
+		rows: mergeBands(Math.PI, rowBands, rowStep),
+		columns: mergeBands(2 * Math.PI, columnBands, columnStep),
+		stepLevel,
+		innerRadius: bandCells * pixel * 2 ** stepLevel
+	};
 }
-function buildGridGeometry(radius, thetas, phis) {
+function buildGridArrays(radius, thetas, phis, riseKm, unitsPerKm = 1) {
 	const rows = thetas.length;
 	const cols = phis.length;
 	const positions = new Float32Array(rows * cols * 3);
 	const normals = new Float32Array(rows * cols * 3);
 	const uvs = new Float32Array(rows * cols * 2);
+	const sinPhi = Float64Array.from(phis, Math.sin);
+	const cosPhi = Float64Array.from(phis, Math.cos);
 	for (let iy = 0; iy < rows; iy++) {
 		const theta = thetas[iy];
 		const sinT = Math.sin(theta);
 		const cosT = Math.cos(theta);
 		for (let ix = 0; ix < cols; ix++) {
-			const phi = phis[ix];
-			const nx = -Math.cos(phi) * sinT;
+			const vertex = iy * cols + ix;
+			const nx = -cosPhi[ix] * sinT;
 			const ny = cosT;
-			const nz = Math.sin(phi) * sinT;
-			const i3 = (iy * cols + ix) * 3;
-			positions[i3] = radius * nx;
-			positions[i3 + 1] = radius * ny;
-			positions[i3 + 2] = radius * nz;
+			const nz = sinPhi[ix] * sinT;
+			const r = radius + (riseKm ? riseKm[vertex] * unitsPerKm : 0);
+			const i3 = vertex * 3;
+			positions[i3] = r * nx;
+			positions[i3 + 1] = r * ny;
+			positions[i3 + 2] = r * nz;
 			normals[i3] = nx;
 			normals[i3 + 1] = ny;
 			normals[i3 + 2] = nz;
-			const i2 = (iy * cols + ix) * 2;
-			uvs[i2] = phi / (2 * Math.PI);
+			const i2 = vertex * 2;
+			uvs[i2] = phis[ix] / (2 * Math.PI);
 			uvs[i2 + 1] = 1 - theta / Math.PI;
 		}
 	}
@@ -22883,19 +23680,155 @@ function buildGridGeometry(radius, thetas, phis) {
 			}
 		}
 	}
+	return {
+		positions,
+		normals,
+		uvs,
+		indices: indices.subarray(0, k)
+	};
+}
+
+//#endregion
+//#region src/lib/scene/lod/terrain-window.ts
+var CELL_BUDGET = 256;
+var ENTER_ALT = .25;
+var EXIT_ALT = .32;
+var RECENTER_FRAC = .35;
+var REBUILD_MIN_MS = 300;
+var MAX_VERTS = 4e5;
+var _inv = new Matrix4();
+var _camLocal = new Vector3();
+function mergeAxis(max, intervals, step) {
+	const inFine = (p) => intervals.some(([lo, hi]) => p > lo + 1e-9 && p < hi - 1e-9);
+	const coarseStep = max / 128;
+	const pts = [];
+	for (let j = 0; j <= 128; j++) {
+		const p = j === 128 ? max : j * coarseStep;
+		if (j === 0 || j === 128 || !inFine(p)) pts.push(p);
+	}
+	for (const [lo, hi] of intervals) {
+		const n0 = Math.ceil(Math.max(lo, 0) / step - 1e-9);
+		const n1 = Math.floor(Math.min(hi, max) / step + 1e-9);
+		for (let n = n0; n <= n1; n++) pts.push(n * step);
+	}
+	pts.sort((a, b) => a - b);
+	const tol = step * .25;
+	const out = [];
+	for (const p of pts) {
+		if (out.length && p - out[out.length - 1] < tol) continue;
+		out.push(p);
+	}
+	out[0] = 0;
+	out[out.length - 1] = max;
+	return Float64Array.from(out);
+}
+function gridGeometry(grid) {
 	const geometry = new BufferGeometry();
-	geometry.setAttribute("position", new BufferAttribute(positions, 3));
-	geometry.setAttribute("normal", new BufferAttribute(normals, 3));
-	geometry.setAttribute("uv", new BufferAttribute(uvs, 2));
-	geometry.setIndex(new BufferAttribute(indices.subarray(0, k), 1));
+	geometry.setAttribute("position", new BufferAttribute(grid.positions, 3));
+	geometry.setAttribute("normal", new BufferAttribute(grid.normals, 3));
+	geometry.setAttribute("uv", new BufferAttribute(grid.uvs, 2));
+	geometry.setIndex(new BufferAttribute(grid.indices, 1));
 	return geometry;
 }
+var tiledStates = /* @__PURE__ */ new WeakMap();
+var MAX_BUILD_FAILURES = 2;
+function heightTilesOf(bo) {
+	const tiles = bo.displacementMeta?.tiles;
+	return reliefTilesAvailable(tiles) && !tiledStates.get(bo)?.dead ? tiles : void 0;
+}
+function restoreDisplacement(bo) {
+	if (!bo.mesh || !bo.displacementMeta) return;
+	setDisplacementScale(bo.mesh.material, bo.displacementMeta, bo.radiusScene);
+}
 function exitWindow(bo) {
+	const state = tiledStates.get(bo);
+	state?.abort?.abort();
+	if (state) state.abort = void 0;
 	if (!bo.terrainWindow) return;
+	if (bo.terrainWindow.riseKm) restoreDisplacement(bo);
 	bo.terrainWindow = null;
 	bo.currentSegments = void 0;
 }
-function updateTerrainWindow(bo, camera, eligible) {
+function drift(thetaA, phiA, thetaB, phiB) {
+	const cos = Math.sin(thetaA) * Math.sin(thetaB) * Math.cos(phiA - phiB) + Math.cos(thetaA) * Math.cos(thetaB);
+	return Math.acos(Math.min(1, Math.max(-1, cos)));
+}
+function updateTiledWindow(bo, mesh, tiles, altitude, centerTheta, centerPhi, invalidate) {
+	const held = bo.terrainWindow?.riseKm ? bo.terrainWindow : void 0;
+	const material = mesh.material;
+	if (held) {
+		material.displacementScale = 0;
+		material.displacementBias = 0;
+	}
+	const state = tiledStates.get(bo) ?? {
+		failures: 0,
+		dead: false
+	};
+	tiledStates.set(bo, state);
+	if (state.abort) return !!held;
+	const meta = bo.displacementMeta;
+	if (!meta) return !!held;
+	const bandCells = currentRenderTier().terrainBandCells;
+	const stepLevel = nestedStepLevel(altitude, tiles.max_level, bandCells, held?.stepLevel);
+	if (held) {
+		const still = drift(centerTheta, centerPhi, held.centerTheta, held.centerPhi);
+		if (held.stepLevel === stepLevel && still < RECENTER_FRAC * held.angRadius) return true;
+		if (performance.now() - held.builtAt < REBUILD_MIN_MS) return true;
+	}
+	const radiusKm = effectiveRadiusKm(bo.body.data);
+	const grid = planNestedGrid(centerTheta, centerPhi, altitude, .5 * meta.scale_km / radiusKm, tiles.max_level, bandCells, stepLevel);
+	const thetas = grid.rows.at;
+	const phis = grid.columns.at;
+	if (thetas.length * phis.length > MAX_VERTS) {
+		console.warn(`terrain grid for ${bo.body.data.id} would need ${thetas.length}×${phis.length} vertices: left to the shader`);
+		state.dead = true;
+		return !!held;
+	}
+	const abort = new AbortController();
+	state.abort = abort;
+	const asked = performance.now();
+	buildTerrainGrid({
+		root: tileRoot(tiles),
+		version: tiles.version,
+		tileSize: tiles.tile_size,
+		scaleKm: tiles.scale_km ?? 0,
+		biasKm: (tiles.bias_km ?? 0) - (meta.absolute_radius ? radiusKm : 0),
+		radius: kmToScene(radiusKm),
+		unitsPerKm: kmToScene(1),
+		rows: grid.rows,
+		columns: grid.columns
+	}, abort.signal).then((built) => {
+		if (state.abort !== abort) return;
+		state.abort = void 0;
+		state.failures = 0;
+		if (bo.mesh !== mesh || !bo.displacementMap) return;
+		const old = mesh.geometry;
+		mesh.geometry = gridGeometry(built);
+		old.dispose();
+		material.displacementScale = 0;
+		material.displacementBias = 0;
+		bo.terrainWindow = {
+			thetas,
+			phis,
+			centerTheta,
+			centerPhi,
+			angRadius: grid.innerRadius,
+			stepLevel,
+			texWidth: 2048 * 2 ** tiles.max_level,
+			builtAt: performance.now(),
+			riseKm: built.riseKm
+		};
+		bo.currentSegments = 128;
+		console.debug(`terrain grid ${bo.body.data.id}: ${thetas.length}×${phis.length}, level ${stepLevel}, ${Math.round(performance.now() - asked)} ms`);
+		invalidate();
+	}).catch(() => {
+		if (state.abort !== abort) return;
+		state.abort = void 0;
+		if (++state.failures >= MAX_BUILD_FAILURES) state.dead = true;
+	});
+	return !!held;
+}
+function updateTerrainWindow(bo, camera, eligible, invalidate) {
 	const mesh = bo.mesh;
 	const tex = bo.displacementMap;
 	if (!eligible || !mesh || !tex) {
@@ -22914,23 +23847,25 @@ function updateTerrainWindow(bo, camera, eligible) {
 		exitWindow(bo);
 		return false;
 	}
+	const centerTheta = Math.acos(Math.min(1, Math.max(-1, _camLocal.y / dist)));
+	let centerPhi = Math.atan2(_camLocal.z, -_camLocal.x);
+	if (centerPhi < 0) centerPhi += 2 * Math.PI;
+	const tiles = heightTilesOf(bo);
+	if (tiles) return updateTiledWindow(bo, mesh, tiles, alt, centerTheta, centerPhi, invalidate);
+	if (bo.terrainWindow?.riseKm) restoreDisplacement(bo);
 	const texWidth = tex.image?.width ?? 2048;
 	const texelAng = 2 * Math.PI / texWidth;
 	const horizon = Math.acos(1 / (1 + alt));
-	const rawStep = Math.max(texelAng, 2 * horizon * MARGIN / CELL_BUDGET);
+	const rawStep = Math.max(texelAng, 2 * horizon * MARGIN$1 / CELL_BUDGET);
 	const rawLevel = Math.log2(rawStep / texelAng);
 	let stepLevel = Math.max(0, Math.ceil(rawLevel - 1e-9));
 	const w = bo.terrainWindow;
 	if (w && w.texWidth === texWidth && rawLevel > w.stepLevel - .85 && rawLevel < w.stepLevel + .15) stepLevel = w.stepLevel;
 	const step = texelAng * 2 ** stepLevel;
 	const angRadius = step * CELL_BUDGET / 2;
-	const centerTheta = Math.acos(Math.min(1, Math.max(-1, _camLocal.y / dist)));
-	let centerPhi = Math.atan2(_camLocal.z, -_camLocal.x);
-	if (centerPhi < 0) centerPhi += 2 * Math.PI;
 	if (w && w.texWidth === texWidth) {
 		if (w.stepLevel === stepLevel) {
-			const cosDrift = Math.sin(centerTheta) * Math.sin(w.centerTheta) * Math.cos(centerPhi - w.centerPhi) + Math.cos(centerTheta) * Math.cos(w.centerTheta);
-			if (Math.acos(Math.min(1, Math.max(-1, cosDrift))) < RECENTER_FRAC * w.angRadius) return true;
+			if (drift(centerTheta, centerPhi, w.centerTheta, w.centerPhi) < RECENTER_FRAC * w.angRadius) return true;
 		}
 		if (performance.now() - w.builtAt < REBUILD_MIN_MS) return true;
 	}
@@ -22950,7 +23885,7 @@ function updateTerrainWindow(bo, camera, eligible) {
 		return false;
 	}
 	const old = mesh.geometry;
-	mesh.geometry = buildGridGeometry(geomRadius, thetas, phis);
+	mesh.geometry = gridGeometry(buildGridArrays(geomRadius, thetas, phis));
 	old.dispose();
 	console.debug(`terrain window ${bo.body.data.id}: ${thetas.length}×${phis.length} grid, level ${stepLevel} (tex ${texWidth})`);
 	bo.terrainWindow = {
@@ -22963,7 +23898,7 @@ function updateTerrainWindow(bo, camera, eligible) {
 		texWidth,
 		builtAt: performance.now()
 	};
-	bo.currentSegments = COARSE_SEGS;
+	bo.currentSegments = 128;
 	return true;
 }
 
@@ -22997,7 +23932,7 @@ function desiredSphereSegments(screenR, isStar, inSystem, current) {
 	}
 	return target;
 }
-function updateSphereLOD(bodyObjects, camera, renderer, ctx, focusedId) {
+function updateSphereLOD(bodyObjects, camera, renderer, ctx, focusedId, invalidate) {
 	const fovRad = camera.fov * Math.PI / 180;
 	const projScale = renderer.domElement.clientHeight / (2 * Math.tan(fovRad / 2));
 	const activeSystem = ctx.visibility.activeSystemId;
@@ -23008,7 +23943,7 @@ function updateSphereLOD(bodyObjects, camera, renderer, ctx, focusedId) {
 		const isStar = bo.body.data.objectType === ObjectType.STAR;
 		const id = bo.body.data.id;
 		if (id === terrainId || bo.terrainWindow) {
-			if (updateTerrainWindow(bo, camera, id === terrainId)) continue;
+			if (updateTerrainWindow(bo, camera, id === terrainId, invalidate)) continue;
 		}
 		const desired = desiredSphereSegments(bo.radiusScene / bo.cachedDist * projScale, isStar, activeSystem ? id === activeSystem || ctx.visibility.isInActiveSystem(bo.body.data.parentId) : id === focusedId, bo.currentSegments ?? 64);
 		if (desired === bo.currentSegments) continue;
@@ -23062,11 +23997,13 @@ 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, invalidate);
+		const devicePx = projScale * renderer.getPixelRatio();
+		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) {
 			const maxTex = renderer.capabilities.maxTextureSize;
-			const capRank = maxTex >= 16383 ? 2 : maxTex >= 8192 ? 1 : 0;
+			const capRank = maxTex >= 16383 && !reliefTilesServe(bo) ? 2 : maxTex >= 8192 ? 1 : 0;
 			const current = bo.displacementTier ?? "low";
 			const target = highestAvailableTier(Math.min(tierRank(desiredDemTier(altitudeRadii, current)), capRank, tierCap), dispTiers);
 			if (target && target !== current) swapDisplacementTier(bo, target);
@@ -24908,7 +25845,7 @@ var SceneRenderer = class SceneRenderer {
 		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.sceneJd, this.appearances, this.invalidate);
-		updateSphereLOD(this.bodyObjects, this.camera, this.renderer, this.ctx, focusedIdLod);
+		updateSphereLOD(this.bodyObjects, this.camera, this.renderer, this.ctx, focusedIdLod, this.invalidate);
 		updateSunShadowLight(this.bodyObjects, this.focus.focusTruePos, this.ctx, this.shadowLight, this.sunPointLight, distance, this._tmpV3, sceneSettings().realisticLighting, this.sunIntensityScale);
 		this.updateModelMounts();
 		this.pointClouds.drainOnePendingSceneAdd();
@@ -25380,6 +26317,10 @@ var SceneRenderer = class SceneRenderer {
 	}
 	lastProbeTargetCheck = null;
 	requestedProbeTargets = /* @__PURE__ */ new Set();
+	probeTargetRetries = new RetryBackoff(() => {
+		this.lastProbeTargetCheck = null;
+		this.invalidate();
+	});
 	askedProbeRides = /* @__PURE__ */ new Set();
 	ensureFocusedProbeTarget() {
 		const focused = this.focusController.current;
@@ -25397,9 +26338,13 @@ var SceneRenderer = class SceneRenderer {
 		if (!fcId) return;
 		const body = this.ctx.getBody(fcId);
 		if (!body) {
-			if (this.requestedProbeTargets.has(fcId)) return;
+			if (this.requestedProbeTargets.has(fcId) || this.probeTargetRetries.waiting(fcId)) return;
 			this.requestedProbeTargets.add(fcId);
-			this.ctx.ensureBody(fcId, jdToDate(this.clock.jd));
+			this.ctx.ensureBody(fcId, jdToDate(this.clock.jd)).then(() => this.probeTargetRetries.clear(fcId), (error) => {
+				console.warn(`[renderer] the body ${fcId} a craft is fit to did not load:`, error);
+				this.requestedProbeTargets.delete(fcId);
+				this.probeTargetRetries.fail(fcId);
+			});
 			return;
 		}
 		this.focusController.promotion.ensureBodyObjects(body);
@@ -25845,6 +26790,10 @@ var SceneRenderer = class SceneRenderer {
 		this.travelPath.dispose();
 		this.extensions.dispose();
 		for (const bo of this.bodyObjects.values()) if (bo.model) unloadBodyModel(bo);
+		for (const bo of this.bodyObjects.values()) {
+			disposeTileOverlay(bo);
+			disposeReliefTiles(bo);
+		}
 		this.pointClouds.dispose();
 		this.disposeScene(this.scene);
 		this.disposeScene(this.modelScene);
@@ -26903,7 +27852,7 @@ var IconExtension = class extends MarkerExtension {
 
 //#endregion
 //#region src/lib/flatmap/projection.ts
-var DEG$5 = Math.PI / 180;
+var DEG$6 = Math.PI / 180;
 var RAD$2 = 180 / Math.PI;
 function wrapLon(lon) {
 	if (lon >= -180 && lon < 180) return lon;
@@ -26968,7 +27917,7 @@ function equirectangular(options) {
 			maxX: Math.PI,
 			maxY: Math.PI / 2
 		},
-		forward: (lon, lat) => [wrapLon(lon - lon0) * DEG$5, lat * DEG$5],
+		forward: (lon, lat) => [wrapLon(lon - lon0) * DEG$6, lat * DEG$6],
 		rowInverse,
 		inverse: rowToInverse(rowInverse, lon0)
 	};
@@ -26983,8 +27932,8 @@ var eeDy = (t) => 9 * EE_A4 * t ** 8 + 7 * EE_A3 * t ** 6 + 3 * EE_A2 * t ** 2 +
 function equalEarth(options) {
 	const lon0 = options.centerLon ?? 0;
 	const forward = (lon, lat) => {
-		const theta = Math.asin(clamp1(EE_SQRT3 / 2 * Math.sin(lat * DEG$5)));
-		const dl = wrapLon(lon - lon0) * DEG$5;
+		const theta = Math.asin(clamp1(EE_SQRT3 / 2 * Math.sin(lat * DEG$6)));
+		const dl = wrapLon(lon - lon0) * DEG$6;
 		return [2 * EE_SQRT3 * dl * Math.cos(theta) / (3 * eeDy(theta)), eeY(theta)];
 	};
 	const thetaFor = (y) => {
@@ -27054,7 +28003,7 @@ function mollweide(options) {
 			maxY: MW_SQRT2
 		},
 		forward: (lon, lat) => {
-			const phi = lat * DEG$5;
+			const phi = lat * DEG$6;
 			let theta = phi;
 			if (Math.abs(Math.abs(phi) - Math.PI / 2) < 1e-9) theta = Math.sign(phi) * (Math.PI / 2);
 			else {
@@ -27065,7 +28014,7 @@ function mollweide(options) {
 					if (Math.abs(step) < 1e-12) break;
 				}
 			}
-			const dl = wrapLon(lon - lon0) * DEG$5;
+			const dl = wrapLon(lon - lon0) * DEG$6;
 			return [2 * MW_SQRT2 / Math.PI * dl * Math.cos(theta), MW_SQRT2 * Math.sin(theta)];
 		},
 		rowInverse,
@@ -27101,8 +28050,8 @@ function sinusoidal(options) {
 			maxY: Math.PI / 2
 		},
 		forward: (lon, lat) => {
-			const phi = lat * DEG$5;
-			return [wrapLon(lon - lon0) * DEG$5 * Math.cos(phi), phi];
+			const phi = lat * DEG$6;
+			return [wrapLon(lon - lon0) * DEG$6 * Math.cos(phi), phi];
 		},
 		rowInverse,
 		inverse: rowToInverse(rowInverse, lon0)
@@ -27224,7 +28173,7 @@ function robinson(options) {
 			const [i, f] = robinsonSegment(Math.abs(lat) / ROBINSON_STEP);
 			const length = splineAt(splineSegment(ROBINSON_LENGTH, i), f);
 			const height = splineAt(splineSegment(ROBINSON_HEIGHT, i), f);
-			return [ROBINSON_KX * length * wrapLon(lon - lon0) * DEG$5, ROBINSON_KY * height * Math.sign(lat)];
+			return [ROBINSON_KX * length * wrapLon(lon - lon0) * DEG$6, ROBINSON_KY * height * Math.sign(lat)];
 		},
 		rowInverse,
 		inverse: rowToInverse(rowInverse, lon0)
@@ -27246,14 +28195,14 @@ function discExtent(r) {
 	};
 }
 function azimuthalDirection(lon, lat, lon0, phi0) {
-	const dl = wrapLon(lon - lon0) * DEG$5;
-	const phi = lat * DEG$5;
+	const dl = wrapLon(lon - lon0) * DEG$6;
+	const phi = lat * DEG$6;
 	return [Math.cos(phi) * Math.sin(dl), Math.cos(phi0) * Math.sin(phi) - Math.sin(phi0) * Math.cos(phi) * Math.cos(dl)];
 }
 function orthographic(options) {
 	const lon0 = options.centerLon ?? 0;
-	const phi0 = (options.centerLat ?? 0) * DEG$5;
-	const clip = Math.min(options.clipAngle ?? 90, 90) * DEG$5;
+	const phi0 = (options.centerLat ?? 0) * DEG$6;
+	const clip = Math.min(options.clipAngle ?? 90, 90) * DEG$6;
 	const cosClip = Math.cos(clip);
 	const radius = Math.sin(clip);
 	const sinPhi0 = Math.sin(phi0);
@@ -27266,8 +28215,8 @@ function orthographic(options) {
 		azimuthal: true,
 		extent: discExtent(radius),
 		forward: (lon, lat) => {
-			const dl = wrapLon(lon - lon0) * DEG$5;
-			const phi = lat * DEG$5;
+			const dl = wrapLon(lon - lon0) * DEG$6;
+			const phi = lat * DEG$6;
 			if (Math.sin(phi0) * Math.sin(phi) + Math.cos(phi0) * Math.cos(phi) * Math.cos(dl) < cosClip) return null;
 			return azimuthalDirection(lon, lat, lon0, phi0);
 		},
@@ -27281,8 +28230,8 @@ function orthographic(options) {
 var STEREOGRAPHIC_CLIP = 120;
 function stereographic(options) {
 	const lon0 = options.centerLon ?? 0;
-	const phi0 = (options.centerLat ?? 90) * DEG$5;
-	const clip = Math.min(options.clipAngle ?? STEREOGRAPHIC_CLIP, 170) * DEG$5;
+	const phi0 = (options.centerLat ?? 90) * DEG$6;
+	const clip = Math.min(options.clipAngle ?? STEREOGRAPHIC_CLIP, 170) * DEG$6;
 	const cosClip = Math.cos(clip);
 	const radius = 2 * Math.tan(clip / 2);
 	const sinPhi0 = Math.sin(phi0);
@@ -27295,8 +28244,8 @@ function stereographic(options) {
 		azimuthal: true,
 		extent: discExtent(radius),
 		forward: (lon, lat) => {
-			const dl = wrapLon(lon - lon0) * DEG$5;
-			const phi = lat * DEG$5;
+			const dl = wrapLon(lon - lon0) * DEG$6;
+			const phi = lat * DEG$6;
 			const cosC = Math.sin(phi0) * Math.sin(phi) + Math.cos(phi0) * Math.cos(phi) * Math.cos(dl);
 			if (cosC < cosClip) return null;
 			const k = 2 / (1 + cosC);
@@ -27329,30 +28278,30 @@ function createProjection(id, options = {}) {
 
 //#endregion
 //#region src/lib/flatmap/geometry.ts
-var DEG$4 = Math.PI / 180;
+var DEG$5 = Math.PI / 180;
 var TAU = 2 * Math.PI;
-var RIM_STEP = 2 * DEG$4;
+var RIM_STEP = 2 * DEG$5;
 var RAD$1 = 180 / Math.PI;
 var MAX_STEPS = 512;
 var DEFAULT_STEP_DEG = 2;
 function angularDistance(a, b) {
-	const φ1 = a.lat * DEG$4;
-	const φ2 = b.lat * DEG$4;
+	const φ1 = a.lat * DEG$5;
+	const φ2 = b.lat * DEG$5;
 	const dφ = φ2 - φ1;
-	const dλ = wrapLon(b.lon - a.lon) * DEG$4;
+	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;
 }
 function slerp(a, b, t) {
-	const d = angularDistance(a, b) * DEG$4;
+	const d = angularDistance(a, b) * DEG$5;
 	if (d < 1e-12) return a;
 	const sinD = Math.sin(d);
 	const ka = Math.sin((1 - t) * d) / sinD;
 	const kb = Math.sin(t * d) / sinD;
-	const φ1 = a.lat * DEG$4;
-	const λ1 = a.lon * DEG$4;
-	const φ2 = b.lat * DEG$4;
-	const λ2 = (a.lon + wrapLon(b.lon - a.lon)) * DEG$4;
+	const φ1 = a.lat * DEG$5;
+	const λ1 = a.lon * DEG$5;
+	const φ2 = b.lat * DEG$5;
+	const λ2 = (a.lon + wrapLon(b.lon - a.lon)) * DEG$5;
 	const x = ka * Math.cos(φ1) * Math.cos(λ1) + kb * Math.cos(φ2) * Math.cos(λ2);
 	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);
@@ -27586,7 +28535,7 @@ function turnsLeft(loop) {
 	for (let i = 0; i < loop.length; i++) {
 		const a = loop[i];
 		const b = loop[(i + 1) % loop.length];
-		sum += wrapLon(b.lon - a.lon) * DEG$4 * (2 + Math.sin(a.lat * DEG$4) + Math.sin(b.lat * DEG$4));
+		sum += wrapLon(b.lon - a.lon) * DEG$5 * (2 + Math.sin(a.lat * DEG$5) + Math.sin(b.lat * DEG$5));
 	}
 	const area = -sum / 2;
 	return area > 0 ? area < TAU : area < -TAU;
@@ -27622,8 +28571,8 @@ function boxRing(latMin, latMax, lonMin, lonSpan) {
 	return ring;
 }
 function smallCircle(center, radiusDeg, steps = 128) {
-	const φ0 = center.lat * DEG$4;
-	const λ0 = center.lon * DEG$4;
+	const φ0 = center.lat * DEG$5;
+	const λ0 = center.lon * DEG$5;
 	const c = [
 		Math.cos(φ0) * Math.cos(λ0),
 		Math.cos(φ0) * Math.sin(λ0),
@@ -27649,7 +28598,7 @@ function smallCircle(center, radiusDeg, steps = 128) {
 		c[2] * e[0] - c[0] * e[2],
 		c[0] * e[1] - c[1] * e[0]
 	];
-	const r = radiusDeg * DEG$4;
+	const r = radiusDeg * DEG$5;
 	const sinR = Math.sin(r);
 	const cosR = Math.cos(r);
 	const ring = [];
@@ -29379,8 +30328,202 @@ var Overlay = class {
 	}
 };
 
+//#endregion
+//#region src/lib/flatmap/tile-plan.ts
+var DEG$4 = Math.PI / 180;
+var MAX_STRETCH = 1.25;
+var MAX_WINDOW_PIXELS = 8e6;
+var GRID = 17;
+var MARGIN = .15;
+var CAP_GAIN = .75;
+function chartFraction(chart, lon, lat) {
+	if (chart === 0) return [(lon + 180) / 360, (90 - lat) / 180];
+	const side = chart === 1 ? 1 : -1;
+	const r = .5 * Math.tan((90 - side * lat) * DEG$4 / 2) / CAP_EDGE;
+	return [.5 + r * Math.cos(lon * DEG$4), .5 - side * r * Math.sin(lon * DEG$4)];
+}
+function levelForStep(step, tileSize) {
+	return Math.ceil(Math.log2(2 * Math.PI / (step * MAX_STRETCH * 2 * tileSize)));
+}
+function stepOfLevel(level, tileSize) {
+	return 2 * Math.PI / (2 * tileSize * 2 ** level);
+}
+function finestLevelAt(pyramid, lon, lat) {
+	const [across, fy] = chartFraction(0, lon, lat);
+	const fx = across - Math.floor(across);
+	let finest = pyramid.max_level;
+	for (const patch of pyramid.patches ?? []) {
+		if (patch.max_level <= finest) continue;
+		const x = Math.floor(fx * chartColumns(0, patch.max_level));
+		const y = Math.floor(fy * chartRows(0, patch.max_level));
+		if (patchOfTile([patch], patch.max_level, x, y)) finest = patch.max_level;
+	}
+	return finest;
+}
+function extentOn(chart, frame, places, centre) {
+	const [cx] = chartFraction(0, centre[0], centre[1]);
+	const extent = {
+		minX: Infinity,
+		maxX: -Infinity,
+		minY: Infinity,
+		maxY: -Infinity
+	};
+	for (const [lon, lat] of places) {
+		const [across, y] = chartFraction(chart, lon, lat);
+		if (chart !== 0 && (across < 0 || across > 1 || y < 0 || y > 1)) return null;
+		const x = chart === 0 ? across - Math.round(across - cx) : across;
+		extent.minX = Math.min(extent.minX, x);
+		extent.maxX = Math.max(extent.maxX, x);
+		extent.minY = Math.min(extent.minY, y);
+		extent.maxY = Math.max(extent.maxY, y);
+	}
+	const padX = (extent.maxX - extent.minX) / (GRID - 1);
+	const padY = (extent.maxY - extent.minY) / (GRID - 1);
+	extent.minX -= padX;
+	extent.maxX += padX;
+	extent.minY -= padY;
+	extent.maxY += padY;
+	if (chart === 0 && (frame.north || frame.south)) {
+		extent.minX = cx - .5;
+		extent.maxX = cx + .5;
+		if (frame.north) extent.minY = 0;
+		if (frame.south) extent.maxY = 1;
+	}
+	return extent;
+}
+function windowOver(chart, level, tileSize, extent, margin) {
+	const chartWidth = chartColumns(chart, level) * tileSize;
+	const chartHeight = chartRows(chart, level) * tileSize;
+	const rect = (grow) => {
+		const growX = (extent.maxX - extent.minX) * grow;
+		const growY = (extent.maxY - extent.minY) * grow;
+		let x0 = Math.floor((extent.minX - growX) * chartWidth);
+		let x1 = Math.ceil((extent.maxX + growX) * chartWidth);
+		if (chart !== 0) {
+			x0 = Math.max(x0, 0);
+			x1 = Math.min(x1, chartWidth);
+		} else if (x1 - x0 > chartWidth) {
+			x0 = Math.round((extent.minX + extent.maxX) / 2 * chartWidth - chartWidth / 2);
+			x1 = x0 + chartWidth;
+		}
+		const y0 = Math.max(Math.floor((extent.minY - growY) * chartHeight), 0);
+		const y1 = Math.min(Math.ceil((extent.maxY + growY) * chartHeight), chartHeight);
+		return [
+			x0,
+			y0,
+			x1,
+			y1
+		];
+	};
+	const [x0, y0, x1, y1] = rect(margin);
+	const inner = rect(0);
+	return {
+		chart,
+		level,
+		x0,
+		y0,
+		width: Math.max(x1 - x0, 1),
+		height: Math.max(y1 - y0, 1),
+		inner: [
+			inner[0],
+			inner[1],
+			inner[2] - 1,
+			inner[3] - 1
+		]
+	};
+}
+function fitted(chart, level, tileSize, extent, margin) {
+	for (const grow of [margin, 0]) {
+		const spec = windowOver(chart, level, tileSize, extent, grow);
+		if (spec.width * spec.height <= 8e6) return spec;
+	}
+}
+function reaches(patch, extent) {
+	const columns = chartColumns(0, patch.max_level);
+	const rows = chartRows(0, patch.max_level);
+	const south = (patch.y[1] + 1) / rows;
+	if (patch.y[0] / rows > extent.maxY || south < extent.minY) return false;
+	let west = patch.x[0] / columns;
+	west -= Math.round(west - (extent.minX + extent.maxX) / 2);
+	const east = west + (patch.x[1] + 1 - patch.x[0]) / columns;
+	return west <= extent.maxX && east >= extent.minX;
+}
+function planWindows(pyramid, frame, firstLevel, moves = true) {
+	const margin = moves ? MARGIN : 0;
+	const centre = frame.place(.5, .5);
+	if (!centre || !(frame.step > 0)) return [];
+	const places = [];
+	for (let j = 0; j < GRID; j++) for (let i = 0; i < GRID; i++) {
+		const place = frame.place(i / (GRID - 1), j / (GRID - 1));
+		if (place) places.push(place);
+	}
+	const onMap = extentOn(0, frame, places, centre);
+	const wanted = levelForStep(frame.step, pyramid.tile_size);
+	const specs = [];
+	let finest = pyramid.max_level;
+	for (const patch of pyramid.patches ?? []) if (patch.max_level > finest && reaches(patch, onMap)) finest = patch.max_level;
+	for (let level = Math.min(wanted, finest); level > pyramid.max_level; level--) {
+		const spec = fitted(0, level, pyramid.tile_size, onMap, margin);
+		if (!spec) continue;
+		specs.push(spec);
+		break;
+	}
+	const cap = centre[1] >= 0 ? 1 : 2;
+	const onCap = extentOn(cap, frame, places, centre);
+	for (let level = Math.min(wanted, pyramid.max_level); level >= firstLevel; level--) {
+		const map = fitted(0, level, pyramid.tile_size, onMap, margin);
+		const polar = onCap && level >= 1 ? fitted(cap, level, pyramid.tile_size, onCap, margin) : void 0;
+		const mapPixels = map ? map.width * map.height : Infinity;
+		const spec = polar && polar.width * polar.height <= mapPixels * CAP_GAIN ? polar : map ?? polar;
+		if (!spec) continue;
+		specs.push(spec);
+		break;
+	}
+	return specs;
+}
+function windowTiles(spec, pyramid) {
+	const size = pyramid.tile_size;
+	const columns = chartColumns(spec.chart, spec.level);
+	const rows = chartRows(spec.chart, spec.level);
+	const tiles = [];
+	const lastY = Math.min(Math.floor((spec.y0 + spec.height - 1) / size), rows - 1);
+	const lastX = Math.floor((spec.x0 + spec.width - 1) / size);
+	for (let ty = Math.max(Math.floor(spec.y0 / size), 0); ty <= lastY; ty++) for (let tx = Math.floor(spec.x0 / size); tx <= lastX; tx++) {
+		if (spec.chart !== 0 && (tx < 0 || tx >= columns)) continue;
+		const x = (tx % columns + columns) % columns;
+		const patch = spec.level > pyramid.max_level ? patchOfTile(pyramid.patches, spec.level, x, ty) : void 0;
+		if (spec.level > pyramid.max_level && !patch) continue;
+		tiles.push({
+			cap: CHART_FOLDER[spec.chart],
+			level: spec.level,
+			x,
+			y: ty,
+			dx: tx * size - spec.x0,
+			dy: ty * size - spec.y0,
+			patch
+		});
+	}
+	const midX = spec.width / 2 - size / 2;
+	const midY = spec.height / 2 - size / 2;
+	const off = (tile) => Math.hypot(tile.dx - midX, tile.dy - midY);
+	return tiles.sort((a, b) => off(a) - off(b));
+}
+function covers(held, spec, tileSize) {
+	if (held.chart !== spec.chart || held.level !== spec.level) return false;
+	let turn = 0;
+	if (spec.chart === 0) {
+		const chartWidth = chartColumns(0, spec.level) * tileSize;
+		turn = chartWidth * Math.round((spec.inner[0] - held.x0) / chartWidth);
+	}
+	return held.x0 + turn <= spec.inner[0] && held.x0 + turn + held.width > spec.inner[2] && held.y0 <= spec.inner[1] && held.y0 + held.height > spec.inner[3];
+}
+
 //#endregion
 //#region src/lib/flatmap/raster.ts
+var CAP_GRID = 8;
+function chartWidth(win) {
+	return chartColumns(win.chart, win.level) * win.tileSize;
+}
 function sourceSize(source) {
 	const width = "width" in source ? source.width : source.codedWidth;
 	const height = "height" in source ? source.height : source.codedHeight;
@@ -29413,9 +30556,12 @@ function imageToRaster(source, maxWidth) {
 var InverseLookup = class {
 	width;
 	height;
+	refU;
+	refV;
 	u;
 	v;
 	inside;
+	caps = /* @__PURE__ */ new Map();
 	constructor(viewport, width, height) {
 		this.width = width;
 		this.height = height;
@@ -29424,6 +30570,8 @@ var InverseLookup = class {
 		this.v = new Float32Array(count);
 		this.inside = new Uint8Array(count);
 		const { projection } = viewport;
+		const middle = projection.inverse(viewport.view.centerX, viewport.view.centerY);
+		[this.refU, this.refV] = middle ? chartFraction(0, middle[0], middle[1]) : [.5, .5];
 		const step = 1 / viewport.scale;
 		const x0 = viewport.view.centerX - viewport.width / 2 * step;
 		const y0 = viewport.view.centerY + viewport.height / 2 * step;
@@ -29437,8 +30585,8 @@ var InverseLookup = class {
 	fillRow(projection, row, y, x0, step, viewport) {
 		const line = projection.rowInverse(y);
 		if (!line) return;
-		const { width } = this;
-		const v = (90 - line.lat) / 180;
+		const { width, refU } = this;
+		const v = (90 - line.lat) / 180 - this.refV;
 		const { minX, maxX } = projection.extent;
 		const worldWidth = maxX - minX;
 		const repeating = viewport.repeatsHorizontally;
@@ -29447,9 +30595,9 @@ var InverseLookup = class {
 			if (repeating) x = ((x - minX) % worldWidth + worldWidth) % worldWidth + minX;
 			else if (x < minX || x > maxX) continue;
 			if (x < -line.maxAbsX || x > line.maxAbsX) continue;
-			const turns = (x * line.lonPerX + projection.centerLon + 180) / 360;
+			const turns = (x * line.lonPerX + projection.centerLon + 180) / 360 - refU;
 			const i = row + px;
-			this.u[i] = turns - Math.floor(turns);
+			this.u[i] = turns - Math.round(turns);
 			this.v[i] = v;
 			this.inside[i] = 1;
 		}
@@ -29470,31 +30618,154 @@ var InverseLookup = class {
 			const place = projection.inverse(x, y);
 			if (!place) continue;
 			const i = row + px;
-			this.u[i] = (place[0] + 180) / 360;
-			this.v[i] = (90 - place[1]) / 180;
+			const turns = (place[0] + 180) / 360 - this.refU;
+			this.u[i] = turns - Math.round(turns);
+			this.v[i] = (90 - place[1]) / 180 - this.refV;
 			this.inside[i] = 1;
 		}
 	}
+	offsets(chart) {
+		if (chart === 0) return {
+			refX: this.refU,
+			refY: this.refV,
+			x: this.u,
+			y: this.v
+		};
+		let cap = this.caps.get(chart);
+		if (!cap) {
+			cap = this.capOffsets(chart);
+			this.caps.set(chart, cap);
+		}
+		return cap;
+	}
+	capOffsets(chart) {
+		const { u, v, inside, refU, refV, width, height } = this;
+		const side = chart === 1 ? 1 : -1;
+		const [refX, refY] = chartFraction(chart, refU * 360 - 180, 90 - refV * 180);
+		const x = new Float32Array(u.length);
+		const y = new Float32Array(u.length);
+		const exact = (i) => {
+			const fromPole = side > 0 ? refV + v[i] : 1 - refV - v[i];
+			const radius = .5 * Math.tan(fromPole * Math.PI / 2) / CAP_EDGE;
+			const lon = (refU + u[i]) * 2 * Math.PI - Math.PI;
+			x[i] = .5 + radius * Math.cos(lon) - refX;
+			y[i] = .5 - side * radius * Math.sin(lon) - refY;
+		};
+		const columns = gridLines(width);
+		const rows = gridLines(height);
+		if (columns.length < 2 || rows.length < 2) {
+			for (let i = 0; i < u.length; i++) if (inside[i]) exact(i);
+			return {
+				refX,
+				refY,
+				x,
+				y
+			};
+		}
+		for (const py of rows) for (const px of columns) if (inside[py * width + px]) exact(py * width + px);
+		for (let r = 0; r < rows.length - 1; r++) {
+			const top = rows[r];
+			const bottom = rows[r + 1];
+			const lastRow = r === rows.length - 2 ? bottom : bottom - 1;
+			for (let c = 0; c < columns.length - 1; c++) {
+				const left = columns[c];
+				const right = columns[c + 1];
+				const lastColumn = c === columns.length - 2 ? right : right - 1;
+				const nw = top * width + left;
+				const ne = top * width + right;
+				const sw = bottom * width + left;
+				const se = bottom * width + right;
+				if (!(inside[nw] && inside[ne] && inside[sw] && inside[se])) {
+					for (let py = top; py <= lastRow; py++) for (let i = py * width + left; i <= py * width + lastColumn; i++) if (inside[i]) exact(i);
+					continue;
+				}
+				for (let py = top; py <= lastRow; py++) {
+					const fy = (py - top) / (bottom - top);
+					let atX = x[nw] + fy * (x[sw] - x[nw]);
+					let atY = y[nw] + fy * (y[sw] - y[nw]);
+					const stepX = (x[ne] + fy * (x[se] - x[ne]) - atX) / (right - left);
+					const stepY = (y[ne] + fy * (y[se] - y[ne]) - atY) / (right - left);
+					const skip = py === top || py === bottom;
+					for (let px = left; px <= lastColumn; px++) {
+						if (!(skip && (px === left || px === right))) {
+							x[py * width + px] = atX;
+							y[py * width + px] = atY;
+						}
+						atX += stepX;
+						atY += stepY;
+					}
+				}
+			}
+		}
+		return {
+			refX,
+			refY,
+			x,
+			y
+		};
+	}
 };
+function gridLines(length) {
+	const lines = [];
+	for (let at = 0; at < length - 1; at += CAP_GRID) lines.push(at);
+	lines.push(length - 1);
+	return lines;
+}
 function compositeLayers(lookup, layers, target) {
 	const out = target.data;
 	out.fill(0);
-	const { width, height, u, v, inside } = lookup;
+	const { width, height, u, v, inside, refU, refV } = lookup;
 	const count = width * height;
 	for (const layer of layers) {
 		const { image, opacity, blend } = layer;
 		if (opacity <= 0) continue;
-		const src = image.data;
+		const base = image.data;
 		const sw = image.width;
 		const sh = image.height;
 		const add = blend === "add";
+		const windows = (layer.detail ?? []).map((win) => {
+			const offsets = lookup.offsets(win.chart);
+			const across = chartWidth(win);
+			const down = win.chart === 0 ? across / 2 : across;
+			let left = offsets.refX * across - win.x0;
+			if (win.chart === 0) left -= across * Math.round((left - win.width / 2) / across);
+			return {
+				xs: offsets.x,
+				ys: offsets.y,
+				left,
+				top: offsets.refY * down - win.y0,
+				across,
+				down,
+				width: win.width,
+				height: win.height,
+				data: win.data
+			};
+		});
 		for (let i = 0; i < count; i++) {
 			if (!inside[i]) continue;
-			let sx = Math.floor(u[i] * sw);
-			let sy = Math.floor(v[i] * sh);
-			sx = sx < 0 ? sx + sw : sx >= sw ? sx - sw : sx;
-			sy = sy < 0 ? 0 : sy >= sh ? sh - 1 : sy;
-			const s = (sy * sw + sx) * 4;
+			let src = base;
+			let s = -1;
+			for (let k = 0; k < windows.length; k++) {
+				const win = windows[k];
+				const tx = win.left + win.xs[i] * win.across;
+				if (!(tx >= 0 && tx < win.width)) continue;
+				const ty = win.top + win.ys[i] * win.down;
+				if (!(ty >= 0 && ty < win.height)) continue;
+				const t = ((ty | 0) * win.width + (tx | 0)) * 4;
+				if (win.data[t + 3] === 0) continue;
+				src = win.data;
+				s = t;
+				break;
+			}
+			if (s < 0) {
+				let across = refU + u[i];
+				across -= Math.floor(across);
+				let sx = Math.floor(across * sw);
+				let sy = Math.floor((refV + v[i]) * sh);
+				sx = sx < 0 ? sx + sw : sx >= sw ? sx - sw : sx;
+				sy = sy < 0 ? 0 : sy >= sh ? sh - 1 : sy;
+				s = (sy * sw + sx) * 4;
+			}
 			const alpha = src[s + 3] / 255 * opacity;
 			if (alpha <= 0) continue;
 			const d = i * 4;
@@ -29528,22 +30799,56 @@ function drawEquirect(ctx, viewport, layers) {
 	const [right, bottom] = viewport.toScreen(maxX - meridian, minY);
 	const from = viewport.repeatsHorizontally ? 0 : viewport.toScreen(minX, maxY)[0];
 	const to = viewport.repeatsHorizontally ? ctx.canvas.width : viewport.toScreen(maxX, maxY)[0];
+	const paint = (target, layer, size) => {
+		const pattern = target.createPattern(layer.image, "repeat-x");
+		if (!pattern) return;
+		pattern.setTransform(new DOMMatrix().translateSelf(left, top).scaleSelf((right - left) / size[0], (bottom - top) / size[1]));
+		target.save();
+		target.imageSmoothingEnabled = true;
+		target.imageSmoothingQuality = "high";
+		target.fillStyle = pattern;
+		target.fillRect(from, top, to - from, bottom - top);
+		const detail = layer.detail ?? [];
+		if (detail.length) {
+			target.beginPath();
+			target.rect(from, top, to - from, bottom - top);
+			target.clip();
+		}
+		for (let k = detail.length - 1; k >= 0; k--) {
+			const win = detail[k];
+			const scale = (right - left) / chartWidth(win);
+			let x = left + win.x0 * scale;
+			const middle = x + win.width * scale / 2;
+			x += (right - left) * Math.round((target.canvas.width / 2 - middle) / (right - left));
+			target.drawImage(win.canvas, x, top + win.y0 * scale, win.width * scale, win.height * scale);
+		}
+		target.restore();
+	};
 	ctx.save();
-	ctx.imageSmoothingEnabled = true;
-	ctx.imageSmoothingQuality = "high";
 	for (const layer of layers) {
 		if (layer.opacity <= 0) continue;
 		const size = sourceSize(layer.image);
-		const pattern = size && ctx.createPattern(layer.image, "repeat-x");
-		if (!pattern) continue;
-		pattern.setTransform(new DOMMatrix().translateSelf(left, top).scaleSelf((right - left) / size[0], (bottom - top) / size[1]));
+		if (!size) continue;
 		ctx.globalAlpha = layer.opacity;
 		ctx.globalCompositeOperation = layer.blend === "add" ? "lighter" : "source-over";
-		ctx.fillStyle = pattern;
-		ctx.fillRect(from, top, to - from, bottom - top);
+		const scratch = layer.detail?.length && (layer.opacity < 1 || layer.blend === "add") ? scratchContext(ctx.canvas.width, ctx.canvas.height) : null;
+		if (scratch) {
+			paint(scratch, layer, size);
+			ctx.drawImage(scratch.canvas, 0, 0);
+		} else paint(ctx, layer, size);
 	}
 	ctx.restore();
 }
+var scratch$1 = null;
+function scratchContext(width, height) {
+	scratch$1 ??= document.createElement("canvas").getContext("2d");
+	if (!scratch$1) return null;
+	if (scratch$1.canvas.width !== width || scratch$1.canvas.height !== height) {
+		scratch$1.canvas.width = width;
+		scratch$1.canvas.height = height;
+	} else scratch$1.clearRect(0, 0, width, height);
+	return scratch$1;
+}
 
 //#endregion
 //#region src/lib/flatmap/sources.ts
@@ -29682,10 +30987,14 @@ var Store = class {
 		this.evict();
 		return value;
 	}
-	release(key) {
+	release(key, keep = true) {
 		const entry = this.entries.get(key);
 		if (!entry) return;
 		entry.claims = Math.max(0, entry.claims - 1);
+		if (!keep && !entry.claims) {
+			this.entries.delete(key);
+			this.free(entry.value);
+		}
 		this.evict();
 	}
 	evict() {
@@ -29723,7 +31032,8 @@ async function acquireBitmap(url, decodeWidth) {
 	if (!work) {
 		work = decode(url, decodeWidth);
 		pending.set(key, work);
-		work.finally(() => pending.delete(key));
+		const done = () => pending.delete(key);
+		work.then(done, done);
 	}
 	const bitmap = await work;
 	if (!bitmap) return null;
@@ -29746,8 +31056,8 @@ async function decode(url, decodeWidth) {
 		return createImageBitmap(blob);
 	}
 }
-function releaseBitmap(key) {
-	bitmaps.release(key);
+function releaseBitmap(key, keep = true) {
+	bitmaps.release(key, keep);
 }
 function acquireRaster(url, workingWidth, source) {
 	const key = textureKey(url, workingWidth);
@@ -29767,6 +31077,129 @@ function releaseRaster(key) {
 	rasters.release(key);
 }
 
+//#endregion
+//#region src/lib/flatmap/tile-windows.ts
+var MAX_FAILURES = 4;
+var MAX_STALE = 2;
+var scratch = null;
+function copyTile(win, tile, dx, dy) {
+	const x0 = Math.max(dx, 0);
+	const y0 = Math.max(dy, 0);
+	const width = Math.min(dx + tile.width, win.width) - x0;
+	const height = Math.min(dy + tile.height, win.height) - y0;
+	if (width <= 0 || height <= 0) return;
+	scratch ??= document.createElement("canvas").getContext("2d", { willReadFrequently: true });
+	if (!scratch) return;
+	if (scratch.canvas.width < tile.width || scratch.canvas.height < tile.height) {
+		scratch.canvas.width = tile.width;
+		scratch.canvas.height = tile.height;
+	}
+	scratch.globalCompositeOperation = "copy";
+	scratch.drawImage(tile, x0 - dx, y0 - dy, width, height, 0, 0, width, height);
+	const pixels = scratch.getImageData(0, 0, width, height).data;
+	const row = width * 4;
+	for (let y = 0; y < height; y++) win.data.set(pixels.subarray(y * row, (y + 1) * row), ((y0 + y) * win.width + x0) * 4);
+}
+var LayerTiles = class {
+	windows = [];
+	kind = "pixels";
+	failures = 0;
+	failed = /* @__PURE__ */ new Set();
+	dead = false;
+	constructor(block, changed, moves) {
+		this.block = block;
+		this.changed = changed;
+		this.moves = moves;
+	}
+	plan(specs, kind, frame) {
+		if (kind !== this.kind) {
+			this.clear();
+			this.kind = kind;
+		}
+		for (const win of this.windows) win.wanted = false;
+		for (const spec of this.dead ? [] : specs) {
+			const held = this.windows.find((win) => win.frame === frame && covers(win, spec, this.block.tile_size));
+			if (held) held.wanted = true;
+			else this.windows.push(this.open(spec, frame));
+		}
+		this.prune();
+	}
+	rasters() {
+		return this.ordered().filter((win) => !!win.data);
+	}
+	canvases() {
+		return this.ordered().flatMap((win) => win.ctx ? [{
+			...win,
+			canvas: win.ctx.canvas
+		}] : []);
+	}
+	clear() {
+		for (const win of this.windows) this.drop(win);
+		this.windows = [];
+	}
+	drop(win) {
+		win.dropped = true;
+		win.data = void 0;
+		if (win.ctx) win.ctx.canvas.width = 0;
+	}
+	ordered() {
+		return [...this.windows].sort((a, b) => b.level - a.level || Number(b.wanted) - Number(a.wanted));
+	}
+	open(spec, frame) {
+		const win = {
+			...spec,
+			tileSize: this.block.tile_size,
+			frame,
+			pending: 0,
+			wanted: true,
+			dropped: false
+		};
+		if (this.kind === "canvas") {
+			const canvas = document.createElement("canvas");
+			canvas.width = spec.width;
+			canvas.height = spec.height;
+			win.ctx = canvas.getContext("2d") ?? void 0;
+		} else win.data = new Uint8ClampedArray(spec.width * spec.height * 4);
+		for (const tile of windowTiles(spec, this.block)) {
+			const url = tileUrl({
+				id: this.block.id,
+				version: tile.patch?.version ?? this.block.version
+			}, tile.cap, tile.level, tile.x, tile.y, frame);
+			if (this.failed.has(url)) continue;
+			win.pending++;
+			this.load(win, url, tile.dx, tile.dy);
+		}
+		return win;
+	}
+	async load(win, url, dx, dy) {
+		try {
+			const held = await acquireBitmap(url, null);
+			if (held) try {
+				if (win.ctx && !win.dropped) win.ctx.drawImage(held.bitmap, dx, dy);
+				else if (!win.dropped) copyTile(win, held.bitmap, dx, dy);
+			} finally {
+				releaseBitmap(held.key, this.moves());
+			}
+			this.failures = 0;
+		} catch {
+			this.failed.add(url);
+			if (++this.failures >= MAX_FAILURES) this.dead = true;
+		}
+		win.pending--;
+		if (this.dead) this.clear();
+		else if (win.dropped) return;
+		else if (win.pending === 0) this.prune();
+		this.changed();
+	}
+	prune() {
+		const loading = this.windows.some((win) => win.wanted && win.pending > 0);
+		const stale = this.windows.filter((win) => !win.wanted);
+		const kept = loading ? stale.slice(-MAX_STALE) : [];
+		for (const win of stale) if (!kept.includes(win)) this.drop(win);
+		this.windows = this.windows.filter((win) => !win.dropped);
+	}
+};
+
 //#endregion
 //#region src/lib/flatmap/view.ts
 function clampToBand(lon, lat, limits) {
@@ -29865,6 +31298,9 @@ var MOVING_BUDGET_MS = 11;
 var MIN_INTERACTION_SCALE = .4;
 var WORTH_COARSENING = .8;
 var SETTLE_MS = 140;
+var TILED_BASE_TIER = "medium";
+var MOVING_PLAN_MS = 250;
+var MAX_TILE_STRETCH = 2;
 var DEFAULT_BODY = "naif-399";
 var RASTER_LAYERS = [
 	{
@@ -29911,6 +31347,7 @@ var FlatMap = class {
 	projectionOptions;
 	view;
 	limits;
+	ownMaxZoom;
 	limitsArmed = false;
 	jd;
 	cooperative = null;
@@ -29919,6 +31356,8 @@ var FlatMap = class {
 	rasters = /* @__PURE__ */ new Map();
 	pending = /* @__PURE__ */ new Set();
 	missing = /* @__PURE__ */ new Set();
+	tiles = /* @__PURE__ */ new Map();
+	plannedAt = 0;
 	generation = 0;
 	controls = null;
 	attribution = null;
@@ -29952,6 +31391,7 @@ var FlatMap = class {
 			maxZoom: 16,
 			...options.limits
 		};
+		this.ownMaxZoom = options.limits?.maxZoom === void 0;
 		this.view = {
 			zoom: options.zoom ?? 1,
 			centerX: 0,
@@ -30008,6 +31448,7 @@ var FlatMap = class {
 		for (const layer of this.layerList) if (!isRaster(layer)) layer.dispose?.();
 		this.overlay.clear();
 		this.dropTextures();
+		this.dropTiles();
 		this.root.remove();
 		this.container = null;
 	}
@@ -30035,16 +31476,18 @@ var FlatMap = class {
 	release() {
 		this.generation++;
 		this.dropTextures();
+		this.dropTiles();
 		this.missing.clear();
 		for (const layer of this.layerList) if (!isRaster(layer) && !this.customLayers.includes(layer)) layer.dispose?.();
 	}
 	buildLayers() {
 		const { messages } = host();
 		const layers = [];
+		this.dropTiles();
 		for (const spec of RASTER_LAYERS) {
 			const bundle = this.sources[spec.kind];
 			if (!bundle) continue;
-			layers.push({
+			const layer = {
 				kind: "raster",
 				id: spec.kind,
 				label: spec.label(messages),
@@ -30054,7 +31497,17 @@ var FlatMap = class {
 				credit: creditOf(bundle),
 				tiers: bundle.tiers,
 				url: (jd, tier) => bundleUrl(bundle, tier, jd)
-			});
+			};
+			layers.push(layer);
+			if (!bundle.tiles) continue;
+			const tiles = new LayerTiles(bundle.tiles, () => {
+				if (tiles.dead) {
+					this.loadVisible();
+					this.emit("layerschange", this.layers);
+				}
+				this.render();
+			}, () => this.moves());
+			this.tiles.set(layer, tiles);
 		}
 		layers.push(graticuleLayer(messages.layer_graticule()));
 		layers.push(nomenclatureLayer(this.bodyId, messages.layer_nomenclature()));
@@ -30078,11 +31531,23 @@ var FlatMap = class {
 	get credits() {
 		const seen = /* @__PURE__ */ new Set();
 		const out = [];
+		const add = (credit) => {
+			if (seen.has(credit.organisation)) return;
+			seen.add(credit.organisation);
+			out.push(credit);
+		};
 		for (const layer of this.layerList) {
 			if (!layer.visible || !layer.credit) continue;
-			if (seen.has(layer.credit.organisation)) continue;
-			seen.add(layer.credit.organisation);
-			out.push(layer.credit);
+			add(layer.credit);
+			const tiles = this.tilesOf(layer);
+			if (!tiles) continue;
+			const map = {
+				...layer.credit,
+				tiles: tiles.block
+			};
+			const pyramid = tileCredit(map);
+			if (pyramid) add(pyramid);
+			for (const patch of patchCredits(map)) add(patch);
 		}
 		return out;
 	}
@@ -30201,11 +31666,15 @@ var FlatMap = class {
 			maxZoom: 16,
 			...limits
 		};
+		this.ownMaxZoom = limits.maxZoom === void 0;
 		this.render();
 		return this;
 	}
 	getLimits() {
-		return { ...this.limits };
+		return this.ownMaxZoom ? {
+			...this.limits,
+			maxZoom: this.pictureMaxZoom()
+		} : { ...this.limits };
 	}
 	setTime(jd) {
 		this.jd = jd;
@@ -30285,8 +31754,10 @@ var FlatMap = class {
 		if (!set) return;
 		for (const listener of [...set]) listener(...args);
 	}
-	tier(tiers) {
-		return bestTier(tiers, lowerTier(TIER_BY_ZOOM.find(([zoom]) => this.view.zoom >= zoom)?.[1] ?? "low", tierForWidth(this.usableSourceWidth())));
+	tier(layer) {
+		let wanted = TIER_BY_ZOOM.find(([zoom]) => this.view.zoom >= zoom)?.[1] ?? "low";
+		if (this.tilesOf(layer)) wanted = lowerTier(wanted, TILED_BASE_TIER);
+		return bestTier(layer.tiers, lowerTier(wanted, tierForWidth(this.usableSourceWidth())));
 	}
 	usableSourceWidth() {
 		return this.projectionId === "equirectangular" ? this.deviceWidth() * this.view.zoom : this.workingWidth();
@@ -30304,7 +31775,7 @@ var FlatMap = class {
 	}
 	picturesInUse() {
 		return this.layerList.filter((l) => isRaster(l) && l.visible).map((layer) => {
-			const tier = this.tier(layer.tiers);
+			const tier = this.tier(layer);
 			return {
 				url: layer.url(this.jd, tier),
 				tier
@@ -30371,10 +31842,98 @@ var FlatMap = class {
 		this.bitmaps.clear();
 		this.rasters.clear();
 	}
+	tilesOf(layer) {
+		const tiles = this.tiles.get(layer);
+		if (!tiles || !isRaster(layer) || tiles.dead || tilesBase() === "") return void 0;
+		if (!textureAllowed(tiles.block.distribution)) return void 0;
+		return Math.max(tiles.block.max_level, ...(tiles.block.patches ?? []).map((patch) => patch.max_level)) >= this.firstTileLevel(layer, tiles) ? tiles : void 0;
+	}
+	firstTileLevel(layer, tiles) {
+		const whole = TIER_WIDTH[bestTier(layer.tiers, TILED_BASE_TIER)] ?? MAX_WORKING_WIDTH;
+		const width = this.projectionId === "equirectangular" ? whole : Math.min(whole, MAX_WORKING_WIDTH);
+		return Math.floor(Math.log2(width / (2 * tiles.block.tile_size))) + 1;
+	}
+	frameSample(viewport, density) {
+		const { width, height, projection } = viewport;
+		const at = (px, py) => viewport.unproject(px, py);
+		const middle = at(width / 2, height / 2);
+		const beside = at(width / 2 + 1, height / 2);
+		const below = at(width / 2, height / 2 + 1);
+		if (!middle || !beside || !below) return void 0;
+		const from = {
+			lon: middle[0],
+			lat: middle[1]
+		};
+		const step = Math.min(angularDistance(from, {
+			lon: beside[0],
+			lat: beside[1]
+		}), angularDistance(from, {
+			lon: below[0],
+			lat: below[1]
+		}));
+		const shows = (lat) => {
+			const pole = projection.azimuthal ? viewport.project(0, lat) : null;
+			return !!pole && pole[0] >= 0 && pole[0] <= width && pole[1] >= 0 && pole[1] <= height;
+		};
+		return {
+			place: (fx, fy) => at(fx * width, fy * height),
+			step: step * Math.PI / 180 / density,
+			north: shows(90),
+			south: shows(-90)
+		};
+	}
+	planTiles(viewport, density) {
+		const kind = this.projectionId === "equirectangular" ? "canvas" : "pixels";
+		let frame;
+		for (const [layer, tiles] of this.tiles) {
+			const drawn = isRaster(layer) && layer.visible && layer.opacity > 0 && this.tilesOf(layer);
+			frame ??= drawn ? this.frameSample(viewport, density) : void 0;
+			const first = drawn && frame ? this.firstTileLevel(layer, tiles) : 0;
+			const specs = drawn && frame ? planWindows(tiles.block, frame, first, this.moves()) : [];
+			tiles.plan(specs, kind, textureFrameForJd(this.jd, tiles.block.frames));
+		}
+	}
+	moves() {
+		return this.dragPan.isEnabled() || this.scrollZoom.isEnabled();
+	}
+	dropTiles() {
+		for (const tiles of this.tiles.values()) tiles.clear();
+		this.tiles.clear();
+	}
+	pictureMaxZoom() {
+		let zoom = 16;
+		const { clientWidth, clientHeight } = this.root;
+		if (!clientWidth || !clientHeight) return zoom;
+		const viewport = new Viewport(this.projection, clientWidth, clientHeight, this.view);
+		const frame = this.frameSample(viewport, 1);
+		const middle = frame?.place(.5, .5);
+		if (!frame || !middle) return zoom;
+		for (const layer of this.layerList) {
+			const tiles = layer.visible ? this.tilesOf(layer) : void 0;
+			if (!tiles) continue;
+			const finest = stepOfLevel(finestLevelAt(tiles.block, middle[0], middle[1]), tiles.block.tile_size) / MAX_TILE_STRETCH;
+			zoom = Math.max(zoom, this.view.zoom * frame.step / finest);
+		}
+		return zoom;
+	}
+	heldLimits() {
+		if (!this.ownMaxZoom) return this.limits;
+		return this.layerList.some((layer) => layer.visible && this.tilesOf(layer)) ? {
+			...this.limits,
+			maxZoom: void 0
+		} : this.limits;
+	}
+	tileStepDeg(lon, lat) {
+		const surface = this.layerList.find((layer) => layer.id === "surface");
+		const tiles = surface && this.tilesOf(surface);
+		if (!tiles) return null;
+		return stepOfLevel(finestLevelAt(tiles.block, lon, lat), tiles.block.tile_size) * 180 / Math.PI;
+	}
 	viewport(width, height) {
 		const w = width ?? this.root.clientWidth ?? 1;
 		const h = height ?? this.root.clientHeight ?? 1;
-		this.view = clampView(this.view, this.projection, w, h, this.limitsArmed ? this.limits : {});
+		const limits = this.limitsArmed ? this.heldLimits() : {};
+		this.view = clampView(this.view, this.projection, w, h, limits);
 		return new Viewport(this.projection, Math.max(1, w), Math.max(1, h), this.view);
 	}
 	render() {
@@ -30415,6 +31974,11 @@ var FlatMap = class {
 		}
 		const cssViewport = this.viewport(cssWidth, cssHeight);
 		const deviceViewport = new Viewport(this.projection, width, height, this.view);
+		const now = performance.now();
+		if (!this.moving || now - this.plannedAt > MOVING_PLAN_MS) {
+			this.plannedAt = now;
+			this.planTiles(cssViewport, sharp);
+		}
 		this.clipToDisc(cssViewport);
 		this.drawRaster(deviceViewport, width, height);
 		this.drawVector(cssViewport);
@@ -30451,18 +32015,20 @@ var FlatMap = class {
 		if (layers.length === 0) return;
 		if (this.projectionId === "equirectangular") {
 			const drawable = layers.map((layer) => ({
-				image: this.bitmaps.get(layer.url(this.jd, this.tier(layer.tiers)))?.bitmap,
+				image: this.bitmaps.get(layer.url(this.jd, this.tier(layer)))?.bitmap,
 				opacity: layer.opacity,
-				blend: layer.blend
+				blend: layer.blend,
+				detail: this.tilesOf(layer)?.canvases()
 			})).filter((l) => Boolean(l.image));
 			if (drawable.length) drawEquirect(ctx, viewport, drawable);
 			return;
 		}
 		const workingWidth = this.workingWidth();
 		const stack = layers.map((layer) => ({
-			image: this.rasterFor(layer.url(this.jd, this.tier(layer.tiers)), workingWidth),
+			image: this.rasterFor(layer.url(this.jd, this.tier(layer)), workingWidth),
 			opacity: layer.opacity,
-			blend: layer.blend
+			blend: layer.blend,
+			detail: this.tilesOf(layer)?.rasters()
 		})).filter((l) => Boolean(l.image));
 		if (stack.length === 0) return;
 		if (!this.buffer || this.buffer.width !== width || this.buffer.height !== height) this.buffer = ctx.createImageData(width, height);
@@ -30620,7 +32186,8 @@ var FlatMap = class {
 	zoomBy(factor, px, py) {
 		this.limitsArmed = true;
 		const anchor = this.viewport().fromScreen(px, py);
-		const zoom = Math.min(this.limits.maxZoom ?? Number.POSITIVE_INFINITY, Math.max(1, this.limits.minZoom ?? 1, this.view.zoom * factor));
+		const furthest = this.ownMaxZoom ? Math.max(this.pictureMaxZoom(), this.view.zoom) : this.limits.maxZoom ?? Number.POSITIVE_INFINITY;
+		const zoom = Math.min(furthest, Math.max(1, this.limits.minZoom ?? 1, this.view.zoom * factor));
 		if (zoom === this.view.zoom) return;
 		this.view = {
 			...this.view,
@@ -30753,7 +32320,7 @@ function wrap(deg) {
 //#region src/lib/panorama/minimap.ts
 var DEG$2 = Math.PI / 180;
 function hasHeading(entry) {
-	return entry.orientation !== "unknown" && entry.north_offset_deg !== void 0;
+	return entry.orientation !== "unknown";
 }
 
 //#endregion
@@ -31029,7 +32596,7 @@ var PanoramaView = class {
 			key: a.key,
 			bearingDeg: a.n.bearingDeg
 		})) : []);
-		await this.loadTexture(versionedUrl(`/v1/panoramas/${entry.id}.webp`, "panoramas"), entry.north_offset_deg ?? 0, !opening);
+		await this.loadTexture(versionedUrl(`/v1/panoramas/${entry.id}.webp`, "panoramas"), entry.north_offset_deg, !opening);
 		if (this.current === entry) this.emit("load", entry);
 	}
 	async step(key) {