leaflet-city-mapper 0.0.2 → 0.0.3

package/src/utils/onAddSun.js

@@ -1,147 +0,0 @@
-import { underEntry } from './underEntry.js';
-import { update as updateScene } from "./update.js";
-import { atmosphere } from './atmosphere.js';
-import { moonPosition } from './moonPosition.js';
-import { projectCelestialBody } from './projectCelestialBody.js';
-import { solarPosition } from './solarPosition.js';
-
-export function onAddSun(layer, map) {
-  if (!layer.control) {
-    const control = new L.Control({ position: 'bottomright' });
-    control.live = true;
-    let date, slider, output, status, timer;
-    const originalSky = map.getContainer().style.getPropertyValue('--leaflet-sky-background');
-    const disc = 'position:absolute;width:18px;height:18px;border-radius:50%;transform:translate(-50%,-50%);pointer-events:none;';
-    const sunDisc = L.DomUtil.create('div', 'sunlight-sun');
-    const moonDisc = L.DomUtil.create('div', 'sunlight-moon');
-    sunDisc.style.cssText = disc + 'background:#fff3bd;box-shadow:0 0 18px 7px #ffd27699;';
-    moonDisc.style.cssText = disc + 'background:#dce5f2;box-shadow:0 0 10px 2px #cbdcff55;';
-    sunDisc.setAttribute('role', 'img'); sunDisc.setAttribute('aria-label', 'Sun');
-    moonDisc.setAttribute('role', 'img'); moonDisc.setAttribute('aria-label', 'Moon');
-    const updateSky = () => {
-      const sun = map._sunlight, sky = map._pitchSky;
-      if (sun) map.getContainer().style.setProperty('--leaflet-sky-background', sun.background);
-      else if (originalSky) map.getContainer().style.setProperty('--leaflet-sky-background', originalSky);
-      else map.getContainer().style.removeProperty('--leaflet-sky-background');
-      const size = map.getSize(), pitch = map.getPitch() * Math.PI / 180, bearing = map.getBearing() * Math.PI / 180;
-      for (const [disc, body] of [[sunDisc, sun], [moonDisc, sun?.moon]]) {
-        disc.hidden = true;
-        if (!sky || !body || body.altitude <= 0 || !sun) continue;
-        if (disc.parentNode !== sky) sky.append(disc);
-        const point = projectCelestialBody(body.direction, size, pitch, bearing);
-        if (!point) continue;
-        const { left, top } = point;
-        disc.hidden = left < 0 || left > size.x || top < 0 || top > sky.clientHeight || sky.style.display === 'none';
-        disc.style.left = `${left}px`; disc.style.top = `${top}px`;
-      }
-    };
-    const render = () => {
-      const renderer = L.Layer._renderers.get(map);
-      if (renderer) updateScene(renderer);
-    };
-    const update = () => {
-      try {
-        if (control.live) control.time = new Date();
-        const time = control.time.toISOString();
-        date.value = time.slice(0, 10);
-        slider.value = String(control.time.getUTCHours() * 60 + control.time.getUTCMinutes());
-        output.textContent = `${time.slice(11, 16)} UTC${control.live ? ' · now' : ''}`;
-        const center = map.getCenter();
-        const sun = map._sunlight = solarPosition(control.time, center.lat, center.lng);
-        Object.assign(sun, atmosphere(sun.altitude));
-        sun.moon = moonPosition(control.time, center.lat, center.lng);
-        status.textContent = sun.altitude <= 0
-          ? 'Night · no direct sunlight'
-          : sun.altitude < 3
-            ? 'Low sun · shadows paused'
-            : `Sun altitude ${sun.altitude.toFixed(1)}°`;
-        map.fire('simulationtimechange', { time: new Date(control.time), live: control.live });
-        updateSky();
-        render();
-      } catch (error) {
-        delete map._sunlight;
-        updateSky();
-        render();
-        status.textContent = `Error: ${error.message}`;
-        console.error('Solar simulation', error);
-      }
-    };
-    control.onAdd = () => {
-      const container = L.DomUtil.create('div', 'sunlight-control');
-      container.style.cssText = 'color:#222;width:min(200px,calc(100vw - 60px));font:12px/1.4 sans-serif;';
-      date = document.createElement('input');
-      date.type = 'date';
-      date.style.cssText = 'width:100%;box-sizing:border-box;';
-      date.setAttribute('aria-label', 'Solar date (UTC)');
-      slider = document.createElement('input');
-      slider.type = 'range';
-      slider.style.cssText = 'width:100%;box-sizing:border-box;margin:10px 0 4px;cursor:pointer;';
-      slider.min = '0'; slider.max = '1439'; slider.step = '1';
-      slider.setAttribute('aria-label', 'Time of day (UTC)');
-      output = document.createElement('output');
-      output.style.cssText = 'font-weight:bold;font-variant-numeric:tabular-nums;';
-      output.setAttribute('aria-live', 'off');
-      const now = document.createElement('button');
-      now.type = 'button'; now.textContent = 'Now';
-      now.onclick = () => { control.live = true; update(); };
-      const timeRow = document.createElement('div');
-      timeRow.className = 'sunlight-time';
-      timeRow.style.cssText = 'display:flex;justify-content:space-between;align-items:center;';
-      timeRow.append(output, now);
-      status = document.createElement('div');
-      status.className = 'sunlight-status';
-      status.style.marginTop = '5px';
-      status.setAttribute('role', 'status');
-      const note = document.createElement('small');
-      note.style.color = '#555';
-      note.textContent = 'Indicative · loaded geometry only. Streetlight illumination is estimated, not measured lux.';
-      container.append(date, slider, timeRow, status, note);
-      date.onchange = slider.oninput = () => {
-        control.live = false;
-        if (!date.value || !date.validity.valid) {
-          control.time = new Date(NaN);
-          map.fire('simulationtimechange', { time: null, live: false });
-          delete map._sunlight;
-          updateSky();
-          render();
-          status.textContent = 'Error: choose a valid solar date';
-          return;
-        }
-        control.time = new Date(`${date.value}T00:00:00Z`);
-        control.time.setUTCMinutes(Number(slider.value));
-        update();
-      };
-      L.DomEvent.disableClickPropagation(container);
-      L.DomEvent.disableScrollPropagation(container);
-      update();
-      timer = setInterval(() => { if (control.live) update(); }, 60000);
-      map.on('moveend', update);
-      map.on('move rotate pitch resize', updateSky);
-      return container;
-    };
-    control.onRemove = () => {
-      clearInterval(timer);
-      map.fire('simulationtimechange', { time: null, live: false });
-      map.off('moveend', update);
-      map.off('move rotate pitch resize', updateSky);
-      delete map._sunlight;
-      updateSky();
-      sunDisc.remove(); moonDisc.remove();
-      render();
-    };
-    layer.control = control;
-  }
-  if (!layer.control._map) {
-    layer.control.addTo(map);
-  }
-  // Shown under this layer's entry in the layers control; a standalone control without one.
-  const container = layer.control.getContainer(), nested = underEntry(layer, container);
-  container.classList.toggle('leaflet-control', !nested);
-  container.classList.toggle('leaflet-bar', !nested);
-  Object.assign(
-    container.style,
-    nested
-      ? { background: '', padding: '2px 0 6px 20px', margin: '0' }
-      : { background: '#fff', padding: '8px', margin: '' }
-  );
-}

package/src/utils/onMapChange.js

@@ -1,16 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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/onRemove3DLayer.js

@@ -1,78 +0,0 @@
-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

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

package/src/utils/onTerrainAdd.js

@@ -1,18 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/parts.js

@@ -1,16 +0,0 @@
-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/pump.js

@@ -1,226 +0,0 @@
-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";
-
-/** Share four load/build slots across source layers, nearest ground blocks first. */
-
-export function pump(backend, map = backend._map) {
-  // Meshes need the shared renderer; _attach() re-runs _updateArea() once it exists.
-  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 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 crs = map.options.crs;
-        const origin = crs.project(backend.location);
-        const metres = Math.cos(backend.location.lat * Math.PI / 180);
-        const groundOffset = point => point.ground || 0;
-        const addTriangle = (a, ah, b, bh, c, ch, nx, ny, nz, color) => {
-          const ux = b.x - a.x, uy = bh - ah, uz = a.y - b.y;
-          const vx = c.x - a.x, vy = ch - ah, vz = a.y - c.y;
-          // Orient the triangle to its intended outward normal after flipping north to -z.
-          if ((uy * vz - uz * vy) * nx + (uz * vx - ux * vz) * ny + (ux * vy - uy * vx) * nz < 0) {
-            const point = b, height = bh;
-            b = c; bh = ch; c = point; ch = height;
-          }
-          positions.push(a.x, ah + groundOffset(a), -a.y,
-            b.x, bh + groundOffset(b), -b.y,
-            c.x, ch + groundOffset(c), -c.y);
-          normals.push(nx, ny, nz, nx, ny, nz, nx, ny, nz);
-          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() + 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() + 4;
-          }
-          const geometry = feature?.geometry;
-          const isTree = geometry?.type === 'Point';
-          if (backend.options.nightLight && !isTree) throw new Error('Night lights require Point geometry');
-          const polygons = geometry?.type === 'Polygon' ? [geometry.coordinates] : geometry?.type === 'MultiPolygon' ? geometry.coordinates : null;
-          if (!polygons && !isTree) throw new Error('Unsupported GeoJSON geometry');
-          const [lon, lat] = (isTree ? geometry.coordinates : polygons[0]?.[0]?.[0]) ?? [];
-          if (!Number.isFinite(lon) || !Number.isFinite(lat)) throw new Error('Invalid GeoJSON coordinates');
-          if (coords) {
-            const anchor = map.project(new L.LatLng(lat, lon), coords.z);
-            // 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.style(feature);
-          if (style === null) {
-            skipped++;
-            continue;
-          }
-          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');
-          }
-          const baseColor = parseColor(color);
-          const vertexStart = positions.length / 3;
-          if (isTree) {
-            const point = crs.project(new L.LatLng(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])
-                ? elevation - backend.root.position[1] : 0,
-            };
-            if (backend.options.nightLight) {
-              if (!Number.isFinite(style.lightFlux) || style.lightFlux <= 0) throw new Error('Invalid light flux');
-              const support = feature.properties?.cod_ouvrag || `${lon},${lat}`;
-              if (style.poleRadius > 0 && !supports.has(support)) {
-                lampPostGeometry(projected, style, addTriangle);
-                supports.add(support);
-              }
-              lightGeometry(projected, style, addTriangle);
-              lights.push({
-                position: [projected.x, projected.ground + top, -projected.y],
-                radius: Math.hypot(top, style.lightRadius), color: [baseColor.r, baseColor.g, baseColor.b],
-                flux: style.lightFlux,
-              });
-            } else treeGeometry(projected, style, addTriangle);
-          }
-          for (const rings of polygons || []) {
-            if (!rings.length) throw new Error('Empty GeoJSON polygon');
-            const paths = rings.map(ring => {
-              if (ring.length < 4) throw new Error('Invalid GeoJSON polygon ring');
-              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(backend._map._terrain3D, [lat, lng]) : undefined;
-                return {
-                  x: (point.x - origin.x) * metres,
-                  y: (point.y - origin.y) * metres,
-                  ground: Number.isFinite(elevation) && Number.isFinite(backend.root.position[1])
-                    ? elevation - backend.root.position[1] : 0,
-                };
-              });
-            });
-            const points = paths.flat();
-            for (const [a, b, c] of triangulate(paths[0], paths.slice(1))) {
-              addTriangle(points[a], top, points[b], top, points[c], top, 0, 1, 0, baseColor);
-              if (bottom > 0) addTriangle(points[a], bottom, points[b], bottom, points[c], bottom, 0, -1, 0, baseColor);
-            }
-            paths.forEach((path, index) => {
-              // Interior walls face into the courtyard; exterior walls face away from the building.
-              const sign = isClockWise(path) === (index === 0) ? -1 : 1;
-              for (let i = 0; i < path.length; i++) {
-                const a = path[i], b = path[(i + 1) % path.length];
-                const length = Math.hypot(b.x - a.x, b.y - a.y);
-                if (!length) continue;
-                const nx = sign * (b.y - a.y) / length, nz = sign * (b.x - a.x) / length;
-                addTriangle(a, bottom, b, bottom, b, top, nx, 0, nz, baseColor);
-                addTriangle(a, bottom, b, top, a, top, nx, 0, nz, baseColor);
-              }
-            });
-          }
-          const vertexEnd = positions.length / 3;
-          featureFaces.push({
-            id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
-            properties: feature.properties, baseColor,
-            faceStart: vertexStart / 3, faceEnd: vertexEnd / 3, vertexStart, vertexEnd,
-          });
-        }
-        if (!positions.length) {
-          Object.assign(area, { mesh: null, buildings: 0, skipped, done: true });
-          return;
-        }
-        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) },
-        };
-        if (backend.options.nightLight) attributes.uv = { size: 2, data: new Float32Array(uvs) };
-        for (const [name, attribute] of Object.entries(attributes)) {
-          attribute.count = attribute.data.length / attribute.size;
-          attribute.buffer = device.createBuffer({
-            size: Math.max(4, attribute.data.byteLength),
-            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-          });
-          device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-        }
-        const meshGeometry = {
-          device,
-          attributes,
-          drawRange: { start: 0, count: attributes.position.count },
-        };
-        Object.assign(area, {
-          mesh: {
-            ...emptyNode(),
-            device,
-            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,
-            fadeDuration: 250,
-            extras: { featureFaces, lights },
-          },
-          buildings: featureFaces.length,
-          skipped,
-          done: true
-        });
-        setParent(area.mesh, backend.root);
-        update(backend);
-      } catch (error) {
-        if (area.request.signal.aborted) return;
-        area.error = error.message;
-        backend.fire('error', { error });
-      }
-    })().finally(() => {
-      backend._inflight--;
-      pump(backend, map);
-    });
-  }
-  for (const layer of layers) updateStatus(layer);
-}