leaflet-city-mapper 0.0.1 → 0.0.2

package/src/utils/onMapChange.js

@@ -0,0 +1,16 @@
+import { update } from "./update.js";
+import { render } from "./render.js";
+
+/** Map movement: render within the frame of Leaflet's CSS transforms, coalescing same-tick events. */
+
+export function onMapChange() {
+  const layer = this;
+  if (layer._queued) return;
+  layer._queued = true;
+  queueMicrotask(() => {
+    layer._queued = false;
+    if (layer._shared !== layer || !layer.renderer) return;
+    if (layer._map._animatingZoom) update(layer);
+    else render(layer);
+  });
+}

package/src/utils/onPMTileAdd.js

@@ -0,0 +1,15 @@
+import { attach } from './attach.js';
+import { setRasterTerrain, updateRasterTiles } from './rasterTiles.js';
+
+export function onPMTileAdd(backend, map) {
+  if (!backend.location) backend.location = map.getCenter();
+  const attached = attach(backend, map);
+  attached.then(() => {
+    backend._added.resolve();
+    setRasterTerrain(backend, map._terrain3D);
+  })
+    .catch(error => backend.fire('error', { error }));
+  Promise.all([attached, backend.ready]).then(() => {
+    if (backend._map === map && map.hasLayer(backend)) updateRasterTiles(backend);
+  }).catch(error => backend.fire('error', { error }));
+}

package/src/utils/onPMTileRemove.js

@@ -0,0 +1,8 @@
+import { releaseRasterTiles } from './rasterTiles.js';
+import { onRemove3DLayer } from './onRemove3DLayer.js';
+
+export function onPMTileRemove(backend, map) {
+  releaseRasterTiles(backend);
+  backend._terrain3D = null;
+  onRemove3DLayer(backend, map);
+}

package/src/utils/onPointerLeave.js

@@ -0,0 +1,11 @@
+import { setHighlight } from './setHighlight.js';
+import { showFeature } from './showFeature.js';
+
+/** Clear hover, highlight and tooltip without retaining a selected feature. */
+
+export function onPointerLeave(layer) {
+  layer.hoveredFeature = null;
+  setHighlight(layer, null);
+  showFeature(layer, null);
+  layer.fire('featurehover', { feature: null });
+}

package/src/utils/onPointerMove.js

@@ -0,0 +1,15 @@
+import { findFeature } from './findFeature.js';
+import { setHighlight } from './setHighlight.js';
+import { showFeature } from './showFeature.js';
+
+/** Hover is transient; featurehover also reports misses with feature:null. */
+
+export function onPointerMove(layer, event) {
+  layer.hoveredFeature = findFeature(layer, event);
+  setHighlight(layer, layer.hoveredFeature);
+  showFeature(layer, layer.hoveredFeature, event);
+  layer.fire('featurehover', {
+    feature: layer.hoveredFeature,
+    originalEvent: event
+  });
+}

package/src/utils/onRemove3DLayer.js

@@ -0,0 +1,78 @@
+import * as destroyTexture from './destroyTexture.js';
+import * as endZoom from './endZoom.js';
+import * as onMapChange from './onMapChange.js';
+import * as onPointerLeave from './onPointerLeave.js';
+import * as onZoomAnim from './onZoomAnim.js';
+import * as releaseArea from './releaseArea.js';
+import { setParent } from './setParent.js';
+import * as startZoom from './startZoom.js';
+import * as update from './update.js';
+
+/** Release source meshes/UI; retain manually added objects and model CPU data. */
+export function onRemove3DLayer(backend, map) {
+  backend._added = Promise.withResolvers();
+  if (backend.container) {
+    onPointerLeave.onPointerLeave(backend);
+    L.DomEvent.off(backend.container, backend._pointerEvents);
+    backend.container = null;
+  }
+  for (const area of backend._areas.values()) releaseArea.releaseArea(backend, area);
+  backend._areas.clear();
+  backend._tooltip?.remove();
+  backend._tooltip = null;
+  if (backend.url || backend._geojson) releaseArea.updateStatus(backend, false);
+  const shared = backend._shared;
+  if (!shared) return;
+  setParent(backend.root, null);
+  shared._layers.delete(backend);
+  if (shared === backend) {
+    map.off('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange.onMapChange, backend);
+    map.off('zoomstart', startZoom.startZoom, backend);
+    map.off('zoomanim', onZoomAnim.onZoomAnim, backend);
+    map.off('zoomend', endZoom.endZoom, backend);
+    cancelAnimationFrame(backend._frame);
+    backend._frame = null;
+    backend._queued = false;
+    if (backend._layers.size) {
+      // Keep the original scene origin and GPU resources when ownership changes.
+      const next = backend._layers.values().next().value;
+      for (const key of ['_layers', '_sceneOrigin', '_size', '_zoomLevel', '_zoomTransitions', '_zoomView', '_cursor', '_roofRaster']) {
+        next[key] = backend[key];
+        delete backend[key];
+      }
+      for (const layer of next._layers) layer._shared = next;
+      L.Layer._renderers.set(map, next);
+      map.on('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange.onMapChange, next);
+      map.on('zoomstart', startZoom.startZoom, next);
+      map.on('zoomanim', onZoomAnim.onZoomAnim, next);
+      map.on('zoomend', endZoom.endZoom, next);
+      update.update(next);
+    } else {
+      if (backend._roofRaster) destroyTexture.destroyTexture(backend, backend._roofRaster.texture.texture);
+      backend._roofRaster = null;
+      for (const animation of backend._zoomTransitions?.keys() || []) animation.play();
+      backend._zoomTransitions = null;
+      backend._zoomView = null;
+      delete map._cameraView;
+      map.getContainer().classList.remove('leaflet-camera-zoom');
+      const renderer = backend.renderer;
+      renderer.canvas.remove();
+      renderer.device.queue.onSubmittedWorkDone()
+        .then(() => {
+          renderer.depthTexture?.destroy();
+          renderer.roofFallbackTexture?.texture?.destroy();
+          renderer.uniformBuffer?.destroy();
+          renderer.sunlight?.texture?.destroy();
+          renderer.sunlight?.buffer?.destroy();
+          renderer.sunlight?.lights?.destroy();
+          renderer.device.destroy();
+        }, error => {
+          backend.fire('error', { error });
+          renderer.device.destroy();
+        });
+      L.Layer._renderers.delete(map);
+      for (const key of ['_layers', '_sceneOrigin', '_size', '_zoomLevel', '_cursor']) delete backend[key];
+    }
+  } else update.update(shared);
+  backend._shared = backend.renderer = backend.scene = backend.camera = null;
+}

package/src/utils/onRemoveSun.js

@@ -0,0 +1,3 @@
+export function onRemoveSun(layer) {
+  layer.control.remove();
+}

package/src/utils/onTerrainAdd.js

@@ -0,0 +1,18 @@
+import { loadTerrain } from "./loadTerrain.js";
+import { setRasterTerrain } from "./rasterTiles.js";
+import { onAdd3DLayer } from './onAdd3DLayer.js';
+
+export function onTerrainAdd(backend, map) {
+  if (map._terrain3D && map._terrain3D !== backend) {
+    throw new Error('Only one terrain layer can be active per map');
+  }
+  map._terrain3D = backend;
+  onAdd3DLayer(backend, map);
+  backend._terrainPromise = backend.root
+    ? loadTerrain(backend)
+    : new Promise(resolve => backend.once('ready', () => loadTerrain(backend).then(resolve), backend));
+  map.eachLayer(layer => {
+    if (layer._type === 'pmtiles') setRasterTerrain(layer, backend);
+  });
+  map.fire('terrainchange');
+}

package/src/utils/onTerrainChange.js

@@ -0,0 +1,13 @@
+import { releaseArea } from "./releaseArea.js";
+import { updateArea } from "./updateArea.js";
+
+/** GeoJSON source areas: loading, building and releasing. */
+
+export function onTerrainChange(layer) {
+  if (!layer._map) return;
+  for (const area of layer._areas.values()) {
+    releaseArea(layer, area);
+  }
+  layer._areas.clear();
+  updateArea(layer);
+}

package/src/utils/onTerrainRemove.js

@@ -0,0 +1,40 @@
+import { destroyTexture } from './destroyTexture.js';
+import { conformModelToTerrain } from './conformModelToTerrain.js';
+import { disposeMesh } from './disposeMesh.js';
+import { setRasterTerrain } from './rasterTiles.js';
+import { removeRasterTile } from './removeRasterTile.js';
+import { setTerrainHeight } from './setTerrainHeight.js';
+import { onRemove3DLayer } from './onRemove3DLayer.js';
+
+export function onTerrainRemove(layer, map) {
+  layer._terrainController?.abort();
+  layer._terrainLoading = false;
+  layer._terrainReady = false;
+  map.eachLayer(layer => {
+    if (layer._type === 'pmtiles') setRasterTerrain(layer, null);
+  });
+  for (const tile of layer._rasterTiles.keys()) removeRasterTile(layer, tile);
+  if (map._terrain3D === layer) delete map._terrain3D;
+  for (const l of Object.values(map._layers)) {
+    conformModelToTerrain(l, null);
+    setTerrainHeight(l);
+  }
+  map.fire('terrainchange');
+  layer._terrainTiles.clear();
+  layer._terrainOriginElevation = 0;
+  layer._terrainPromise = null;
+  if (layer._rasterProgram) {
+    layer._rasterProgram.pipelineCache.clear();
+  }
+  layer._rasterProgram = null;
+  if (layer._dem) destroyTexture(layer, layer._dem.texture);
+  layer._dem = null;
+  for (const grid of layer._terrainGrids?.values() || []) {
+    for (const attribute of Object.values(grid)) destroyTexture(layer, attribute.buffer);
+  }
+  layer._terrainGrids = null;
+  layer._bridges = null;
+  disposeMesh(layer, layer._bridgeMesh);
+  layer._bridgeMesh = null;
+  onRemove3DLayer(layer, map);
+}

package/src/utils/onZoomAnim.js

@@ -0,0 +1,14 @@
+import { render } from "./render.js";
+
+
+export function onZoomAnim(event) {
+  const map = this._map;
+  if (event && !this._zoomView) {
+    this._zoomView = { from: map.getCenter(), zoom: map.getZoom(), to: event.center,
+      targetZoom: event.zoom, start: performance.now() };
+    map.getContainer().classList.add('leaflet-camera-zoom');
+  }
+  queueMicrotask(() => {
+    if (this._shared === this && this.renderer) render(this);
+  });
+}

package/src/utils/paints.js

@@ -0,0 +1,10 @@
+// Built-in vehicles for the 'traffic' type. Models are [ring of [x, z], bottom, top, rgb, topRing?] convex prisms in metres;
+// forward is -z, right is +x. `topRing` (same length as `ring`) tapers the prism; rgb components above 1 are self-lit lamps.
+export const paints = [
+  [0.86, 0.86, 0.88],
+  [0.1, 0.1, 0.12],
+  [0.5, 0.53, 0.57],
+  [0.65, 0.1, 0.08],
+  [0.12, 0.25, 0.55],
+  [0.85, 0.7, 0.15]
+];

package/src/utils/parseColor.js

@@ -0,0 +1,42 @@
+import { toSRGB } from "./toSRGB.js";
+import { channel } from "./channel.js";
+
+/**
+ * HSL inputs are linear-space to preserve the original building styling.
+ * Numeric/CSS/RGB inputs are already sRGB; CSS alpha is not used for extrusion.
+ * @param {number|string|Object} value 0xRRGGBB, CSS color, {r,g,b}, or {h,s,l} in 0..1.
+ * @returns {Object} sRGB {r,g,b} components in 0..1.
+ */
+
+export function parseColor(value) {
+  if (value && typeof value === 'object' && 'h' in value) {
+    const a = value.s * Math.min(value.l, 1 - value.l);
+    return {
+      r: toSRGB(channel(0, value.h, value.l, a)),
+      g: toSRGB(channel(8, value.h, value.l, a)),
+      b: toSRGB(channel(4, value.h, value.l, a))
+    };
+  }
+  if (value && typeof value === 'object' && 'r' in value) {
+    return value;
+  }
+  if (typeof value === 'number') {
+    return {
+      r: (value >> 16 & 255) / 255,
+      g: (value >> 8 & 255) / 255,
+      b: (value & 255) / 255,
+    };
+  }
+  if (typeof value !== 'string' || !CSS.supports('color', value)) {
+    throw new Error('Invalid 3D color');
+  }
+  const context = document.createElement('canvas').getContext('2d');
+  context.fillStyle = value;
+  context.fillRect(0, 0, 1, 1);
+  const [r, g, b] = context.getImageData(0, 0, 1, 1).data;
+  return {
+    r: r / 255,
+    g: g / 255,
+    b: b / 255
+  };
+}

package/src/utils/parts.js

@@ -0,0 +1,16 @@
+import { box } from "./box.js";
+import { trousers, shirt, skin, dark } from "./skin.js";
+
+
+export const parts = {
+  body: [
+    [box(-0.17, 0.17, -0.1, 0.1), 0.82, 0.95, trousers],
+    [box(-0.19, 0.19, -0.11, 0.11), 0.95, 1.44, shirt],
+    [box(-0.05, 0.05, -0.05, 0.05), 1.44, 1.5, skin],
+    [box(-0.1, 0.1, -0.11, 0.1), 1.5, 1.72, skin],
+    [box(-0.105, 0.105, -0.06, 0.115), 1.58, 1.77, dark],
+    [box(-0.105, 0.105, -0.115, -0.06), 1.7, 1.77, dark],
+  ],
+  leg: [[box(-0.07, 0.07, -0.07, 0.07), -0.82, 0, trousers], [box(-0.07, 0.07, -0.17, 0.07), -0.9, -0.82, dark]],
+  arm: [[box(-0.05, 0.05, -0.05, 0.05), -0.55, 0, shirt], [box(-0.045, 0.045, -0.045, 0.045), -0.66, -0.55, skin]],
+};

package/src/utils/projectCelestialBody.js

@@ -0,0 +1,13 @@
+/** Perspective projection of a celestial direction; null when behind the camera. */
+
+export function projectCelestialBody(dir, size, pitch, bearing) {
+  const [x, y, z] = dir;
+  const forward = -x * Math.sin(bearing) * Math.sin(pitch) - y * Math.cos(pitch) - z * Math.cos(bearing) * Math.sin(pitch);
+  if (forward > 0) {
+    return {
+      left: size.x / 2 + size.y * 1.5 * (x * Math.cos(bearing) - z * Math.sin(bearing)) / forward,
+      top:  size.y / 2 - size.y * 1.5 * (-x * Math.sin(bearing) * Math.cos(pitch) + y * Math.sin(pitch) - z * Math.cos(bearing) * Math.cos(pitch)) / forward
+    };
+  }
+  return null;
+}

package/src/{scene/sources.js → utils/pump.js}

@@ -1,73 +1,58 @@
-import { parseColor, triangulate, isClockWise, treeGeometry, lightGeometry, lampPostGeometry } from '../utils/geometry.js';
-import { emptyNode } from '../utils/scene.js';
+import { emptyNode } from "./emptyNode.js";
+import { isClockWise } from "./isClockWise.js";
+import { lampPostGeometry } from "./lampPostGeometry.js";
+import { lightGeometry } from "./lightGeometry.js";
+import { parseColor } from "./parseColor.js";
+import { treeGeometry } from "./treeGeometry.js";
+import { triangulate } from "./triangulate.js";
+import { createProgram } from './createProgram.js';
+import { updateStatus } from "./releaseArea.js";
+import { loadSource } from './loadSource.js';
+import { setParent } from './setParent.js';
+import { update } from './update.js';
+import { getElevation } from "./getElevation.js";
 
-/** GeoJSON source areas: loading, building and releasing. */
-export function onTerrainChange(backend) {
-  if (!backend._map) return;
-  for (const area of backend._areas.values()) backend._releaseArea(area);
-  backend._areas.clear();
-  backend._updateArea();
-}
-
-/** Cover the visible ground bounds and one bordering block, clipped to the archive. */
-export function updateArea(backend) {
-  if (!backend._map || !backend.header) return;
-  const z = backend.header.minZoom;
-  const center = backend._map.project(backend._map.getCenter(), z).divideBy(256).floor();
-  const bounds = backend._map.getBounds();
-  const nw = backend._map.project(bounds.getNorthWest(), z).divideBy(256).floor();
-  const se = backend._map.project(bounds.getSouthEast(), z).divideBy(256).floor();
-  const archiveNW = backend._map.project([backend.header.maxLat, backend.header.minLon], z).divideBy(256).floor();
-  const archiveSE = backend._map.project([backend.header.minLat, backend.header.maxLon], z).divideBy(256).floor();
-  const wanted = new Map();
-  for (let x = Math.max(0, nw.x - 1, archiveNW.x); x <= Math.min(2 ** z - 1, se.x + 1, archiveSE.x); x++) {
-    for (let y = Math.max(0, nw.y - 1, archiveNW.y); y <= Math.min(2 ** z - 1, se.y + 1, archiveSE.y); y++) {
-      wanted.set(`${x}/${y}`, { z, x, y });
-    }
-  }
-  for (const [key, area] of backend._areas) {
-    if (!wanted.has(key)) {
-      backend._releaseArea(area);
-      backend._areas.delete(key);
-    }
-  }
-  // Load the nearest new blocks first without rebuilding retained geometry.
-  for (const [key, coords] of [...wanted].sort(([, a], [, b]) =>
-    Math.hypot(a.x - center.x, a.y - center.y) - Math.hypot(b.x - center.x, b.y - center.y))) {
-    if (!backend._areas.has(key)) backend._areas.set(key, { coords, request: new AbortController() });
-  }
-  backend._pump();
-}
-
-export async function loadSource(backend, area) {
-  const { z, x, y } = area.coords;
-  const result = await backend.getZxy(z, x, y, area.request.signal);
-  return result ? JSON.parse(new TextDecoder().decode(result.data))
-    : { type: 'FeatureCollection', features: [] };
-}
+/** Share four load/build slots across source layers, nearest ground blocks first. */
 
-/** Start at most two load/build tasks; cancelled tasks still free their slot in finally. */
-export function pump(backend) {
+export function pump(backend, map = backend._map) {
   // Meshes need the shared renderer; _attach() re-runs _updateArea() once it exists.
-  if (!backend._map || !backend._shared) return;
-  for (const area of backend._areas.values()) {
-    if (backend._inflight >= 2) break;
-    if (area.started) continue;
+  const shared = map && L.Layer._renderers.get(map);
+  if (!shared) return;
+  const layers = [...shared._layers].filter(layer =>
+    Number.isFinite(layer._inflight) && layer._areas && (layer.url || layer._geojson));
+  const pending = layers.flatMap(layer => [...layer._areas.values()]
+    .filter(area => !area.started && !area.request.signal.aborted)
+    .map(area => {
+      const center = area.coords && map.project(map.getCenter(), area.coords.z).divideBy(256);
+      return { layer, area, distance: center
+        ? Math.hypot(area.coords.x + 0.5 - center.x, area.coords.y + 0.5 - center.y) / 2 ** area.coords.z : 0 };
+    })).sort((a, b) => a.distance - b.distance);
+  let inflight = layers.reduce((sum, layer) => sum + layer._inflight, 0);
+  for (const { layer: backend, area } of pending) {
+    if (inflight >= 4) break;
+    if (backend._inflight >= 2) continue;
     area.started = true;
     backend._inflight++;
+    inflight++;
     (async () => {
       try {
+        // Let ground requests start first, and avoid rebuilding flat geometry when the DEM arrives.
+        await new Promise(requestAnimationFrame);
+        await map._terrain3D?._terrainPromise;
+        if (area.request.signal.aborted) return;
         const coords = area.coords;
-        const data = await backend._loadSource(area);
+        const data = await loadSource(backend, area);
         if (area.request.signal.aborted) return;
         if (data?.type !== 'FeatureCollection' || !Array.isArray(data.features)) {
           throw new Error('Invalid GeoJSON response');
         }
+        if (backend._geojson && typeof backend.options.style !== 'function') {
+          throw new Error('style must be a function');
+        }
         const features = data.features;
         const positions = [], normals = [], colors = [], uvs = [], featureFaces = [], lights = [];
         const supports = new Set();
         let skipped = 0;
-        const map = backend._map;
         const crs = map.options.crs;
         const origin = crs.project(backend.location);
         const metres = Math.cos(backend.location.lat * Math.PI / 180);
@@ -87,13 +72,13 @@ export function pump(backend) {
           colors.push(color.r, color.g, color.b, color.r, color.g, color.b, color.r, color.g, color.b);
           if (backend.options.nightLight) uvs.push(...a.uv, ...b.uv, ...c.uv);
         };
-        let deadline = performance.now() + 8;
+        let deadline = performance.now() + 4;
         for (const feature of features) {
           if (area.request.signal.aborted) return;
           if (performance.now() >= deadline) {
             await new Promise(requestAnimationFrame);
             if (area.request.signal.aborted) return;
-            deadline = performance.now() + 8;
+            deadline = performance.now() + 4;
           }
           const geometry = feature?.geometry;
           const isTree = geometry?.type === 'Point';
@@ -107,12 +92,12 @@ export function pump(backend) {
             // Overlapping archive blocks may contain the same polygon; its first vertex owns it.
             if (Math.floor(anchor.x / 256) !== coords.x || Math.floor(anchor.y / 256) !== coords.y) continue;
           }
-          const style = backend.options.featureStyle(feature);
+          const style = backend.options.style(feature);
           if (style === null) {
             skipped++;
             continue;
           }
-          if (!style || typeof style !== 'object') throw new Error('featureStyle must return an extrusion style or null');
+          if (!style || typeof style !== 'object') throw new Error('style must return an extrusion style or null');
           const { top, bottom = 0, color = 0xd9b38c } = style;
           if (!Number.isFinite(top) || !Number.isFinite(bottom) || bottom < 0 || top <= bottom) {
             throw new Error('Invalid extrusion heights: expected top > bottom >= 0');
@@ -121,7 +106,7 @@ export function pump(backend) {
           const vertexStart = positions.length / 3;
           if (isTree) {
             const point = crs.project(new L.LatLng(lat, lon));
-            const elevation = map._terrain3D?._getElevation([lat, lon]);
+            const elevation = map._terrain3D ? getElevation(map._terrain3D, [lat, lon]) : undefined;
             const projected = {
               x: (point.x - origin.x) * metres, y: (point.y - origin.y) * metres,
               ground: Number.isFinite(elevation) && Number.isFinite(backend.root.position[1])
@@ -149,7 +134,7 @@ export function pump(backend) {
               return ring.slice(0, -1).map(([lng, lat]) => {
                 if (!Number.isFinite(lng) || !Number.isFinite(lat)) throw new Error('Invalid GeoJSON coordinates');
                 const point = crs.project(new L.LatLng(lat, lng));
-                const elevation = backend._map._terrain3D?._getElevation([lat, lng]);
+                const elevation = backend._map._terrain3D ? getElevation(backend._map._terrain3D, [lat, lng]) : undefined;
                 return {
                   x: (point.x - origin.x) * metres,
                   y: (point.y - origin.y) * metres,
@@ -190,8 +175,8 @@ export function pump(backend) {
         const device = backend.renderer.device;
         const attributes = {
           position: { size: 3, data: new Float32Array(positions) },
-          normal:   { size: 3, data: new Float32Array(normals) },
-          color:    { size: 3, data: new Float32Array(colors) },
+          normal: { size: 3, data: new Float32Array(normals) },
+          color: { size: 3, data: new Float32Array(colors) },
         };
         if (backend.options.nightLight) attributes.uv = { size: 2, data: new Float32Array(uvs) };
         for (const [name, attribute] of Object.entries(attributes)) {
@@ -211,18 +196,22 @@ export function pump(backend) {
           mesh: {
             ...emptyNode(),
             device,
-            geometry:    meshGeometry,
-            program:     backend._createProgram({ vertexColors: true, roofTexture: Boolean(backend.options.roofTexture),
-              ...(backend.options.nightLight ? { nightLight: true, alphaMode: 'BLEND', doubleSided: true } : {}) }),
-            id:          L.Layer.types['3d']._nextId++,
+            geometry: meshGeometry,
+            program: createProgram(backend, {
+              vertexColors: true, roofTexture: Boolean(backend.options.roofTexture),
+              ...(backend.options.nightLight ? { nightLight: true, alphaMode: 'BLEND', doubleSided: true } : {})
+            }),
+            id: L.Layer._nextId++,
             renderOrder: 0,
-            extras:      { featureFaces, lights },
+            fadeDuration: 250,
+            extras: { featureFaces, lights },
           },
           buildings: featureFaces.length,
           skipped,
           done: true
         });
-        backend.add(area.mesh);
+        setParent(area.mesh, backend.root);
+        update(backend);
       } catch (error) {
         if (area.request.signal.aborted) return;
         area.error = error.message;
@@ -230,36 +219,8 @@ export function pump(backend) {
       }
     })().finally(() => {
       backend._inflight--;
-      backend._pump();
+      pump(backend, map);
     });
   }
-  backend._updateStatus();
-}
-
-/** Cancel pending work and dispose this block's GPU data, including any hover highlight. */
-export function releaseArea(backend, area) {
-  area.request.abort();
-  if (area.mesh) {
-    if (backend.highlightedFeature?.mesh === area.mesh) {
-      backend._setHighlight(null);
-      backend.hoveredFeature = null;
-      backend._showFeature(null);
-    }
-    backend.remove(area.mesh);
-    const geometry = area.mesh.geometry;
-    for (const attribute of Object.values(geometry.attributes)) attribute.buffer.destroy();
-    backend._removeProgram(area.mesh.program);
-  }
-}
-
-/** Emit a snapshot for consumers; ready does not wait for all neighborhood tasks. */
-export function updateStatus(backend, enabled = true) {
-  const progress = { enabled, loaded: 0, skipped: 0, pending: 0, errors: [] };
-  for (const area of backend._areas.values()) {
-    if (area.error) progress.errors.push(area.error);
-    else if (!area.done) progress.pending++;
-    progress.loaded += area.buildings ?? 0;
-    progress.skipped += area.skipped ?? 0;
-  }
-  backend.fire('progress', progress);
+  for (const layer of layers) updateStatus(layer);
 }