leaflet-city-mapper 0.0.3 → 0.0.5

package/src/sources/updateArea.js

@@ -1,45 +1,56 @@
-import { pump } from "./pump.js";
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
+
+
+import { pump } from "./pumpSourceAreas.js";
 import { releaseArea } from './releaseArea.js';
 import { compareAreaDistance } from './compareAreaDistance.js';
 
 /** Cover the visible ground bounds and one bordering block, clipped to the archive. */
 
-export function updateArea(backend) {
-  if (!backend._map || !backend._shared) return;
-  if (backend._geojson) {
-    if (!backend._areas.has('geojson')) {
-      backend._areas.set('geojson', { request: new AbortController() });
+export function updateArea(layer) {
+  if (!layer._map || !sharedByLayer.get(layer)) return;
+  if (geojsonByLayer.get(layer)) {
+    if (!areasByLayer.get(layer).has('geojson')) {
+      areasByLayer.get(layer).set('geojson', /* alloc */ { request: /* alloc */ new AbortController() });
     }
-    pump(backend);
+    pump(layer);
     return;
   }
-  if (!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();
+  if (!headerByLayer.get(layer)) return;
+  const z = headerByLayer.get(layer).minZoom;
+  const center = layer._map.project(layer._map.getCenter(), z).divideBy(256).floor();
+  const bounds = layer._map.getBounds();
+  const nw = layer._map.project(bounds.getNorthWest(), z).divideBy(256).floor();
+  const se = layer._map.project(bounds.getSouthEast(), z).divideBy(256).floor();
+  const archiveNW = layer._map.project(/* alloc */ [headerByLayer.get(layer).maxLat, headerByLayer.get(layer).minLon], z).divideBy(256).floor();
+  const archiveSE = layer._map.project(/* alloc */ [headerByLayer.get(layer).minLat, headerByLayer.get(layer).maxLon], z).divideBy(256).floor();
+  const wanted = /* alloc */ new Map();
   let x, y, key, area, coords;
   for (x = Math.max(0, nw.x - 1, archiveNW.x); x <= Math.min(2 ** z - 1, se.x + 1, archiveSE.x); x++) {
     for (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 });
+      wanted.set(`${x}/${y}`, /* alloc */ { z, x, y });
     }
   }
-  for ([key, area] of backend._areas) {
+  for ([key, area] of areasByLayer.get(layer)) {
     if (!wanted.has(key)) {
-      releaseArea(backend, area);
-      backend._areas.delete(key);
+      releaseArea(layer, area);
+      areasByLayer.get(layer).delete(key);
     }
   }
   // Load the nearest new blocks first without rebuilding retained geometry.
-  const areas = [];
-  for ([key, coords] of wanted) areas.push([key, coords, center]);
+  const areas = /* alloc */ [];
+  for ([key, coords] of wanted) {
+    coords.distance = Math.hypot(coords.x + 0.5 - center.x, coords.y + 0.5 - center.y) / 2 ** z;
+    areas.push(coords);
+  }
   areas.sort(compareAreaDistance);
-  for ([key, coords] of areas) {
-    if (!backend._areas.has(key)) backend._areas.set(key, { coords, request: new AbortController() });
+  for (coords of areas) {
+    key = `${coords.x}/${coords.y}`;
+    if (!areasByLayer.get(layer).has(key)) areasByLayer.get(layer).set(key, /* alloc */ { coords, request: /* alloc */ new AbortController() });
   }
-  pump(backend);
+  pump(layer);
 }

package/src/sources/updateSourceStatus.js

@@ -0,0 +1,16 @@
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+
+
+
+/** Emit a snapshot for consumers; ready does not wait for all neighborhood tasks. */
+export function updateStatus(layer, enabled = true) {
+  const progress = /* alloc */ { enabled, loaded: 0, skipped: 0, pending: 0, errors: /* alloc */ [] };
+  let area;
+  for (area of areasByLayer.get(layer).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;
+  }
+  layer.fire('progress', progress);
+}

package/src/sunlight/{addTo.js → addTimeControlToMap.js}

@@ -1,4 +1,5 @@
-import { underEntry } from '../scene/underEntry.js';
+import { L } from '../globals/L.js';
+import { underEntry } from '../layer-controls/underEntry.js';
 import { styleTimeControl } from './styleTimeControl.js';
 
 export function addTo(map) {

package/src/sunlight/addTimeLayer.js

@@ -1,3 +1,7 @@
+import { controlByLayer } from '../weakmaps/controlByLayer.js';
+
+
+
 export function addTimeLayer(map) {
-  return this.control.addTo(map);
+  return controlByLayer.get(this).addTo(map);
 }

package/src/sunlight/atmosphere.js

@@ -1,18 +1,15 @@
+import { atmosphereStops } from '../globals/atmosphereStops.js';
+import { atmosphereColor } from '../globals/atmosphereColor.js';
+
+import { mix } from '../colors/mixColor.js';
+import { rgb } from '../colors/formatRGB.js';
 
-import { mix } from './mix.js';
-import { rgb } from './rgb.js';
 
 export function atmosphere(altitude) {
   if (!Number.isFinite(altitude)) {
-    throw new Error('Invalid solar altitude');
+    throw /* alloc */ new Error('Invalid solar altitude');
   }
-  const stops = [
-    [-18, [3, 7, 20], [17, 28, 54], [0.025, 0.04, 0.09]],
-    [-6, [37, 53, 84], [182, 106, 86], [0.12, 0.10, 0.14]],
-    [0, [101, 131, 171], [246, 170, 115], [0.38, 0.24, 0.18]],
-    [10, [74, 147, 208], [197, 221, 237], [0.80, 0.75, 0.68]],
-    [25, [53, 144, 213], [223, 238, 250], [1, 1, 1]],
-  ];
+  const stops = atmosphereStops;
   let upper = -1;
   let i;
   for (i = 0; i < stops.length; i++) {
@@ -21,8 +18,8 @@ export function atmosphere(altitude) {
   const b = stops[upper < 0 ? stops.length - 1 : upper],
         a = stops[Math.max(0, upper - 1)];
   const t = a === b || upper < 0 ? 1 : (altitude - a[0]) / (b[0] - a[0]);
-  return {
-    background: `linear-gradient(${rgb(mix(a[1], b[1], t))}, ${rgb(mix(a[2], b[2], t))})`,
+  return /* alloc */ {
+    background: `linear-gradient(${rgb(mix(a[1], b[1], t, atmosphereColor))}, ${rgb(mix(a[2], b[2], t, atmosphereColor))})`,
     tint: mix(a[3], b[3], t),
   };
 }

package/src/sunlight/createSun.js

@@ -0,0 +1,54 @@
+import { L } from '../globals/L.js';
+import { updateSky } from './updateSky.js';
+import { updateSun } from './updateSun.js';
+import { useLiveTime } from './useLiveTime.js';
+import { useSelectedTime } from './useSelectedTime.js';
+
+export function createSun(map) {
+  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 container = L.DomUtil.create('div', 'sunlight-control');
+  container.style.cssText = 'color:#222;width:min(200px,calc(100vw - 60px));font:12px/1.4 sans-serif;';
+  const date = document.createElement('input');
+  date.type = 'date';
+  date.style.cssText = 'width:100%;box-sizing:border-box;';
+  date.setAttribute('aria-label', 'Solar date (UTC)');
+  const 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)');
+  const 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';
+  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);
+  const 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);
+  const state = /* alloc */ {
+    control: null, map, originalSky: '', container, sunDisc, moonDisc, date, slider, output, status,
+    projection: /* alloc */ { left: 0, top: 0 },
+  };
+  state.update = updateSun.bind(null, state);
+  state.updateSky = updateSky.bind(null, state);
+  now.onclick = useLiveTime.bind(null, state);
+  date.onchange = slider.oninput = useSelectedTime.bind(null, state);
+  L.DomEvent.disableClickPropagation(container);
+  L.DomEvent.disableScrollPropagation(container);
+  return state;
+}

package/src/sunlight/initSunlight.js

@@ -1,14 +1,17 @@
+import { L } from '../globals/L.js';
 import { onAddSun } from './onAddSun.js';
-import { underEntry } from '../scene/underEntry.js';
-import { initialize } from './initialize.js';
-import { onAdd } from './onAdd.js';
-import { addTo } from './addTo.js';
-import { remove } from './remove.js';
+import { underEntry } from '../layer-controls/underEntry.js';
+import { initialize } from './initializeTimeControl.js';
+import { onAdd } from './onAddTimeControl.js';
+import { addTo } from './addTimeControlToMap.js';
+import { remove } from './removeTimeControl.js';
+import { onRemoveSun } from './onRemoveSun.js';
 
 L.Control.Time = L.Control.extend({
   options: { position: 'bottomright' },
   initialize,
   onAdd,
+  onRemove: onRemoveSun,
   addTo,
   remove,
 });

package/src/sunlight/initializeTimeControl.js

@@ -0,0 +1,16 @@
+import { controlByLayer } from '../weakmaps/controlByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
+import { L } from '../globals/L.js';
+
+
+import { addTimeLayer } from './addTimeLayer.js';
+import { removeTimeLayer } from './removeTimeLayer.js';
+
+export function initialize(options) {
+  L.Util.setOptions(this, options);
+  this.live = true;
+  this.layer = /* alloc */ new L.Layer();
+  controlByLayer.set(this.layer, this);
+  kindByLayer.set(this.layer, 'time');
+}

package/src/sunlight/onAddSun.js

@@ -1,66 +1,28 @@
-import { cityMapper } from '../constants/cityMapper.js';
-import { update as updateScene } from '../scene/update.js';
-import { atmosphere } from './atmosphere.js';
-import { moonPosition } from './moonPosition.js';
-import { projectCelestialBody } from './projectCelestialBody.js';
-import { solarPosition } from './solarPosition.js';
-import { updateSky } from './updateSky.js';
-import { render } from './render.js';
-import { updateSun } from './updateSun.js';
-import { useLiveTime } from './useLiveTime.js';
-import { useSelectedTime } from './useSelectedTime.js';
-import { tickSun } from './tickSun.js';
-import { removeSun } from './removeSun.js';
+import { timeControlByMap } from '../weakmaps/timeControlByMap.js';
 
-export function onAddSun(control, map) {
-  map._timeControl = control;
-  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 container = L.DomUtil.create('div', 'sunlight-control');
-  container.style.cssText = 'color:#222;width:min(200px,calc(100vw - 60px));font:12px/1.4 sans-serif;';
-  const date = document.createElement('input');
-  date.type = 'date';
-  date.style.cssText = 'width:100%;box-sizing:border-box;';
-  date.setAttribute('aria-label', 'Solar date (UTC)');
-  const 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)');
-  const 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';
-  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);
-  const 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);
-  const state = { control, map, originalSky, sunDisc, moonDisc, date, slider, output, status };
-  state.update = updateSun.bind(null, state);
-  state.updateSky = updateSky.bind(null, state);
-  now.onclick = useLiveTime.bind(null, state);
-  date.onchange = slider.oninput = useSelectedTime.bind(null, state);
-  L.DomEvent.disableClickPropagation(container);
-  L.DomEvent.disableScrollPropagation(container);
-  state.update();
-  state.timer = setInterval(tickSun, 60000, state);
-  map.on('moveend', state.update);
-  map.on('move rotate pitch resize', state.updateSky);
-  control.onRemove = removeSun.bind(null, state);
-  return container;
-}
+import { sunlightByControl } from '../weakmaps/sunlightByControl.js';
+import { sunByMap } from '../weakmaps/sunByMap.js';
+import { createSun } from './createSun.js';
+import { tickSun } from './tickSun.js';
+
+export function onAddSun(control, map) {
+  let state = sunByMap.get(map);
+  if (state?.control && state.control !== control) {
+    control._map = null;
+    if (control.layer._map === map) map.removeLayer(control.layer);
+    throw /* alloc */ new Error('Only one Time control can be active per map');
+  }
+  if (!state) {
+    state = createSun(map);
+    sunByMap.set(map, state);
+  }
+  state.control = control;
+  state.originalSky = map.getContainer().style.getPropertyValue('--leaflet-sky-background');
+  timeControlByMap.set(map, control);
+  sunlightByControl.set(control, state);
+  state.update();
+  state.timer = setInterval(tickSun, 60000, state);
+  map.on('moveend', state.update);
+  map.on('move rotate pitch resize', state.updateSky);
+  return state.container;
+}

package/src/sunlight/onRemoveSun.js

@@ -0,0 +1,10 @@
+import { sunlightByControl } from '../weakmaps/sunlightByControl.js';
+
+import { removeSun } from './removeSun.js';
+
+export function onRemoveSun() {
+  const sunlight = sunlightByControl.get(this);
+  if (!sunlight) return;
+  removeSun(sunlight);
+  sunlightByControl.delete(this);
+}

package/src/sunlight/removeSun.js

@@ -1,15 +1,23 @@
-import { render } from './render.js';
+import { sunlightByMap } from '../weakmaps/sunlightByMap.js';
+import { timeControlByMap } from '../weakmaps/timeControlByMap.js';
+
+import { sunByMap } from '../weakmaps/sunByMap.js';
+
+
+import { render } from './requestSunlightRender.js';
 import { updateSky } from './updateSky.js';
 
 export function removeSun(state) {
   const { map, timer, sunDisc, moonDisc } = state;
+  const shared = sunByMap.get(map);
   clearInterval(timer);
-  delete map._timeControl;
-  map.fire('simulationtimechange', { time: null, live: false });
+  timeControlByMap.delete(map);
+  map.fire('simulationtimechange', /* alloc */ { time: null, live: false });
   map.off('moveend', state.update);
   map.off('move rotate pitch resize', state.updateSky);
-  delete map._sunlight;
+  sunlightByMap.delete(map);
   updateSky(state);
   sunDisc.remove(); moonDisc.remove();
   render(map);
+  if (shared === state) shared.control = null;
 }

package/src/sunlight/{remove.js → removeTimeControl.js}

@@ -1,3 +1,4 @@
+import { L } from '../globals/L.js';
 export function remove() {
   if (this._map?.hasLayer(this.layer)) {
     this._map.removeLayer(this.layer);

package/src/sunlight/removeTimeLayer.js

@@ -1,3 +1,8 @@
+import { controlByLayer } from '../weakmaps/controlByLayer.js';
+
+import { L } from '../globals/L.js';
+
+
 export function removeTimeLayer() {
-  return L.Control.prototype.remove.call(this.control);
+  return L.Control.prototype.remove.call(controlByLayer.get(this));
 }

package/src/sunlight/requestSunlightRender.js

@@ -0,0 +1,9 @@
+import { renderers } from '../weakmaps/renderers.js';
+
+
+import { update as updateScene } from '../scene/scheduleSceneUpdate.js';
+
+export function render(map) {
+  const renderer = renderers.get(map);
+  if (renderer) updateScene(renderer);
+}

package/src/sunlight/styleTimeControl.js

@@ -1,7 +1,7 @@
 export function styleTimeControl(container, nested) {
   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: '' });
+  container.style.background = nested ? '' : '#fff';
+  container.style.padding = nested ? '2px 0 6px 20px' : '8px';
+  container.style.margin = nested ? '0' : '';
 }

package/src/sunlight/updateCelestialDisc.js

@@ -0,0 +1,12 @@
+import { projectCelestialBody } from '../projections/projectCelestialBody.js';
+
+export function updateCelestialDisc(disc, body, sky, size, pitch, bearing, projection) {
+  disc.hidden = true;
+  if (!sky || !body || body.altitude <= 0) return;
+  if (disc.parentNode !== sky) sky.append(disc);
+  const point = projectCelestialBody(body.direction, size, pitch, bearing, projection);
+  if (!point) return;
+  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`;
+}

package/src/sunlight/updateSky.js

@@ -1,20 +1,19 @@
-import { projectCelestialBody } from './projectCelestialBody.js';
+import { pitchSkyByMap } from '../weakmaps/pitchSkyByMap.js';
+import { sunlightByMap } from '../weakmaps/sunlightByMap.js';
 
-export function updateSky({ map, originalSky, sunDisc, moonDisc }) {
-  const sun = map._sunlight, sky = map._pitchSky;
+import { radians } from '../globals/radians.js';
+
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+import { updateCelestialDisc } from './updateCelestialDisc.js';
+
+export function updateSky({ map, originalSky, sunDisc, moonDisc, projection }) {
+  const sun = sunlightByMap.get(map), sky = pitchSkyByMap.get(map);
   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;
-  let disc, body, point, left, top;
-  for ([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);
-    point = projectCelestialBody(body.direction, size, pitch, bearing);
-    if (!point) continue;
-    ({ 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 size = map.getSize(), pitch = mapGetPitch(map) * radians, bearing = mapGetBearing(map) * radians;
+  updateCelestialDisc(sunDisc, sun, sky, size, pitch, bearing, projection);
+  updateCelestialDisc(moonDisc, sun?.moon, sky, size, pitch, bearing, projection);
 }

package/src/sunlight/updateSun.js

@@ -1,19 +1,24 @@
+import { sunlightByMap } from '../weakmaps/sunlightByMap.js';
+
+
+
 import { atmosphere } from './atmosphere.js';
-import { moonPosition } from './moonPosition.js';
-import { solarPosition } from './solarPosition.js';
-import { render } from './render.js';
+import { moonPosition } from '../astronomy/moonPosition.js';
+import { solarPosition } from '../astronomy/solarPosition.js';
+import { render } from './requestSunlightRender.js';
 import { updateSky } from './updateSky.js';
 
 export function updateSun(state) {
   const { control, map, date, slider, output, status } = state;
   try {
-    if (control.live) control.time = new Date();
+    if (control.live) control.time = /* alloc */ 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);
+    const sun = solarPosition(control.time, center.lat, center.lng);
+    sunlightByMap.set(map, sun);
     Object.assign(sun, atmosphere(sun.altitude));
     sun.moon = moonPosition(control.time, center.lat, center.lng);
     status.textContent = sun.altitude <= 0
@@ -21,11 +26,14 @@ export function updateSun(state) {
       : sun.altitude < 3
         ? 'Low sun · shadows paused'
         : `Sun altitude ${sun.altitude.toFixed(1)}°`;
-    map.fire('simulationtimechange', { time: new Date(control.time), live: control.live });
+    map.fire('simulationtimechange', /* alloc */ {
+      time: /* alloc */ new Date(control.time),
+      live: control.live,
+    });
     updateSky(state);
     render(map);
   } catch (error) {
-    delete map._sunlight;
+    sunlightByMap.delete(map);
     updateSky(state);
     render(map);
     status.textContent = `Error: ${error.message}`;

package/src/sunlight/useSelectedTime.js

@@ -1,4 +1,8 @@
-import { render } from './render.js';
+import { sunlightByMap } from '../weakmaps/sunlightByMap.js';
+
+
+
+import { render } from './requestSunlightRender.js';
 import { updateSky } from './updateSky.js';
 import { updateSun } from './updateSun.js';
 
@@ -6,15 +10,15 @@ export function useSelectedTime(state) {
   const { control, map, date, slider, status } = state;
   control.live = false;
   if (!date.value || !date.validity.valid) {
-    control.time = new Date(NaN);
-    map.fire('simulationtimechange', { time: null, live: false });
-    delete map._sunlight;
+    control.time = /* alloc */ new Date(NaN);
+    map.fire('simulationtimechange', /* alloc */ { time: null, live: false });
+    sunlightByMap.delete(map);
     updateSky(state);
     render(map);
     status.textContent = 'Error: choose a valid solar date';
     return;
   }
-  control.time = new Date(`${date.value}T00:00:00Z`);
+  control.time = /* alloc */ new Date(`${date.value}T00:00:00Z`);
   control.time.setUTCMinutes(Number(slider.value));
   updateSun(state);
 }

package/src/terrain/applyTerrain.js

@@ -0,0 +1,24 @@
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { terrainOriginElevationByLayer } from '../weakmaps/terrainOriginElevationByLayer.js';
+import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
+
+import { addBridges } from '../geometry/addBridges.js';
+import { conformModelToTerrain } from '../geometry/conformModelToTerrain.js';
+import { getElevation } from './getElevation.js';
+import { setTerrainHeight } from './setTerrainHeight.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
+
+export function applyTerrain(layer, map, bridges) {
+
+  terrainReadyByLayer.set(layer, true);
+  terrainOriginElevationByLayer.set(layer, getElevation(layer, locationByLayer.get(layer)) ?? 0);
+  let mapLayer;
+  for (mapLayer of Object.values(map._layers)) {
+    setTerrainHeight(mapLayer);
+    conformModelToTerrain(mapLayer, layer);
+  }
+  if (bridges) addBridges(layer, bridges);
+  map.fire('terrainchange');
+  update(layer);
+  layer.fire('terrainready');
+}

package/src/terrain/clearLayerTerrain.js

@@ -1,5 +1,9 @@
-import { setRasterTerrain } from '../raster/setRasterTerrain.js';
-
-export function clearLayerTerrain(layer) {
-  if (layer._type === 'pmtiles') setRasterTerrain(layer, null);
-}
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
+
+
+import { setRasterTerrain } from '../raster/setRasterTerrain.js';
+
+export function clearLayerTerrain(layer) {
+  if (kindByLayer.get(layer) === 'raster') setRasterTerrain(layer, null);
+}

package/src/terrain/copyTerrainTile.js

@@ -0,0 +1,12 @@
+export function copyTerrainTile(atlas, values, start, columns) {
+  let row, column, value;
+  for (row = 0; row < 256; row++) {
+    for (column = 0; column < 256; column++) {
+      value = values[row * 256 + column];
+      if (!Number.isFinite(value) || value <= -1000) continue;
+      atlas.elevations[start + row * columns * 256 + column] = value;
+      atlas.low = Math.min(atlas.low, value);
+      atlas.high = Math.max(atlas.high, value);
+    }
+  }
+}

package/src/terrain/getElevation.js

@@ -1,10 +1,18 @@
+import { bridgesByLayer } from '../weakmaps/bridgesByLayer.js';
+import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
+import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
+import { terrainZoomByLayer } from '../weakmaps/terrainZoomByLayer.js';
+
+import { L } from '../globals/L.js';
+
+
 import { bridgeElevation } from '../geometry/bridgeElevation.js';
 import { terrainElevation } from './terrainElevation.js';
 
 /** @param {L.LatLng|L.Point} location LatLng, or a pixel point at the terrain zoom. */
 
-export function getElevation(backend, location) {
-  if (!backend._map || !backend._terrainReady) return null;
-  const point = location instanceof L.Point ? location : backend._map.project(location, backend._terrainZoom);
-  return bridgeElevation(point, backend._bridges) ?? terrainElevation(point, backend._terrainTiles);
+export function getElevation(layer, location) {
+  if (!layer._map || !terrainReadyByLayer.get(layer)) return null;
+  const point = location instanceof L.Point ? location : layer._map.project(location, terrainZoomByLayer.get(layer));
+  return bridgeElevation(point, bridgesByLayer.get(layer)) ?? terrainElevation(point, terrainTilesByLayer.get(layer));
 }