leaflet-city-mapper 0.0.6 → 0.0.7

package/src/projections/projectCameraPoint.js

@@ -3,7 +3,7 @@ import { pointOf } from './toPoint.js';
 import { angles } from './cameraAngles.js';
 
 
-export function project(map, point, inverse = false, limit = false) {
+export function project(map, point, inverse = false, limit = false, height = 0) {
   const size = map.getSize(), halfX = size.x / 2, halfY = size.y / 2, distance = size.y * 1.5;
   const result = pointOf(point);
   if (!distance) return result;
@@ -12,16 +12,17 @@ export function project(map, point, inverse = false, limit = false) {
   if (inverse) {
     const far = size.y * map.options.pitchMaxDistance;
     const denominator = tilt * distance + rise * y;
-    let v = denominator * tilt > 0 ? y * distance / denominator : -far;
+    let v = denominator * tilt > 0
+      ? (y * (distance - tilt * height) + distance * rise * height) / denominator : -far;
     if (limit) v = Math.max(-far, Math.min(far, v));
-    const u = x * (distance - rise * v) / distance;
+    const u = x * (distance - rise * v - tilt * height) / distance;
     result.x = cos * u + sin * v + halfX;
     result.y = -sin * u + cos * v + halfY;
     return result;
   }
   const u = cos * x - sin * y, v = sin * x + cos * y;
-  const scale = distance / (distance - rise * v);
+  const scale = distance / (distance - rise * v - tilt * height);
   result.x = u * scale + halfX;
-  result.y = tilt * v * scale + halfY;
+  result.y = (tilt * v - rise * height) * scale + halfY;
   return result;
 }

package/src/rendering/collectVisibleMesh.js

@@ -1,4 +1,5 @@
 import { computeBounds } from '../geometry/computeBounds.js';
+import { nativeStrokeExpansion } from './nativeStrokeExpansion.js';
 
 export function collectVisibleMesh(mesh, projection, frustum, frustumLengths, candidates) {
   if (!mesh.geometry.bounds) computeBounds(mesh.geometry);
@@ -12,16 +13,18 @@ export function collectVisibleMesh(mesh, projection, frustum, frustumLengths, ca
     sphere.x = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];
     sphere.y = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];
     sphere.z = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];
-    sphere.radius = bounds.radius * Math.max(
+    sphere.scale = Math.max(
       Math.hypot(world[0], world[1], world[2]),
       Math.hypot(world[4], world[5], world[6]),
       Math.hypot(world[8], world[9], world[10])
     );
+    sphere.radius = bounds.radius * sphere.scale;
     sphere.bounds = bounds;
     sphere.matrix = world;
     sphere.version = mesh._worldMatrixVersion;
   }
-  const { x, y, z, radius } = sphere;
+  const { x, y, z } = sphere;
+  const radius = sphere.radius + nativeStrokeExpansion(mesh) * sphere.scale;
   const clipZ = projection[2] * x + projection[6] * y + projection[10] * z + projection[14];
   const clipW = projection[3] * x + projection[7] * y + projection[11] * z + projection[15];
   mesh._sortDepth = clipZ / clipW;

package/src/rendering/drawSceneMeshes.js

@@ -9,11 +9,13 @@ import { drawGeometry } from './drawGeometry.js';
 export function drawSceneMeshes(layer, encoder, meshes) {
   const renderer = rendererByLayer.get(layer);
   const pass = encoder.beginRenderPass((
-    scenePass.colorAttachments[0].view = renderer.context.getCurrentTexture().createView(),
+    scenePass.colorAttachments[0].view = renderer.colorTexture.createView(),
+    scenePass.colorAttachments[0].resolveTarget = renderer.context.getCurrentTexture().createView(),
     scenePass.depthStencilAttachment.view = renderer.depthTexture.createView(),
     scenePass
   ));
   scenePass.colorAttachments[0].view = null;
+  scenePass.colorAttachments[0].resolveTarget = null;
   scenePass.depthStencilAttachment.view = null;
   pass.setViewport(0, 0, renderer.canvas.width, renderer.canvas.height, 0, 1);
   pass.setBindGroup(1, renderer.sunlight.bindGroup);

package/src/rendering/nativeStrokeExpansion.js

@@ -0,0 +1,4 @@
+export function nativeStrokeExpansion(mesh) {
+  const strokeScale = mesh.program?.uniforms?.strokeScale?.value ?? 1;
+  return Math.max(0, strokeScale - 1) * (mesh.geometry.nativeStrokeRadius || 0);
+}

package/src/rendering/prepareMeshUniforms.js

@@ -20,6 +20,8 @@ export function prepareMeshUniforms(renderer, mesh) {
   data[base + 34] = mesh.program.nightSparkle ? data[55] : 0;
   data[base + 35] = mesh.ground ? 1 : mesh._appearance ?? 1;
   prepareMeshCutout(renderer, mesh, base);
+  data[base + 40] = uniforms.strokeScale?.value ?? 1;
+  data[base + 41] = data[base + 42] = data[base + 43] = 0;
   return offset;
 }
 import { prepareMeshCutout } from '../materials/prepareMeshCutout.js';

package/src/rendering/resizeRenderer.js

@@ -2,6 +2,7 @@ import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
 import { sizeByLayer } from '../weakmaps/sizeByLayer.js';
 
 import { depthTexture as sharedDepthTexture } from '../globals/depthTexture.js';
+import { colorTexture as sharedColorTexture } from '../globals/colorTexture.js';
 
 
 import { destroyTexture } from '../textures/destroyTexture.js';
@@ -15,6 +16,14 @@ export function resizeRenderer(layer, size) {
     rendererByLayer.get(layer).canvas.style.width = `${size.x}px`;
     rendererByLayer.get(layer).canvas.style.height = `${size.y}px`;
     if (rendererByLayer.get(layer).depthTexture) destroyTexture(layer, rendererByLayer.get(layer).depthTexture);
+    rendererByLayer.get(layer).colorTexture?.destroy();
+    rendererByLayer.get(layer).colorTexture = rendererByLayer.get(layer).device.createTexture((
+      sharedColorTexture.size[0] = rendererByLayer.get(layer).canvas.width,
+      sharedColorTexture.size[1] = rendererByLayer.get(layer).canvas.height,
+      sharedColorTexture.format = rendererByLayer.get(layer).format,
+      sharedColorTexture.usage = GPUTextureUsage.RENDER_ATTACHMENT,
+      sharedColorTexture
+    ));
     rendererByLayer.get(layer).depthTexture = rendererByLayer.get(layer).device.createTexture((
       sharedDepthTexture.size[0] = rendererByLayer.get(layer).canvas.width,
       sharedDepthTexture.size[1] = rendererByLayer.get(layer).canvas.height,

package/src/scene/initializerFor.js

@@ -1,14 +1,12 @@
-import { initializeGeoJSON } from '../sources/initializeGeoJSON.js';
 import { initRaster } from '../raster/initRaster.js';
 import { initTerrain } from '../terrain/initTerrain.js';
 import { initTraffic } from '../traffic/initTraffic.js';
 import { initCog } from '../cog/initCog.js';
 
-export function initializerFor(type) {
+export function initializerFor(type, options = {}) {
   switch (type) {
-    case 'geojson': return initializeGeoJSON;
-    case 'pmtiles': return initRaster;
-    case 'cog': return initCog;
+    case 'raster': return options.asset !== undefined || /\.tiff?(?:[?#]|$)/i.test(options.url)
+      ? initCog : initRaster;
     case 'terrain': return initTerrain;
     case 'traffic': return initTraffic;
     default: return null;

package/src/scene/layerInitialize.js

@@ -12,6 +12,9 @@ import { loading } from '../globals/loading.js';
 
 
 import { init3D } from './init3D.js';
+import { initializeGeoJSON } from '../sources/initializeGeoJSON.js';
+import { isVectorTileSource } from '../sources/isVectorTileSource.js';
+import { initVectorTiles } from '../sources/initVectorTiles.js';
 import { noOperation } from '../utils/noOperation.js';
 import { resolveNextInitialization } from './resolveNextInitialization.js';
 import { initializeLayer } from './initializeLayer.js';
@@ -25,21 +28,20 @@ export function layerInitialize(options = sceneEmptyOptions) {
     L.Util.setOptions(this, options);
     return;
   }
-  const {
-    source: {
-      type = options.source.data?.type === 'FeatureCollection'
-        ? 'geojson'
-        : /\.pmtiles(?:[?#]|$)/i.test(options.source.url) ? 'pmtiles'
-        : /\.tiff?(?:[?#]|$)/i.test(options.source.url) ? 'cog' : '3d',
-      ...source
-    },
-    ...core
-  } = options;
+  const { source: { type = /\.pmtiles(?:[?#]|$)|\.tiff?(?:[?#]|$)/i.test(options.source.url)
+    ? 'raster' : 'vector', ...source }, ...core } = options;
   const settings = /* alloc */ { ...source, ...core };
   L.Util.setOptions(this, core);
   typeByLayer.set(this, type);
-  if (type === '3d') {
-    init3D(this, settings);
+  if (type === 'vector') {
+    if (isVectorTileSource(settings)) {
+      initVectorTiles(this, settings);
+    } else if (settings.data !== undefined ||
+        settings.url && !/\.(?:pmtiles|glb|gltf)(?:[?#]|$)/i.test(settings.url)) {
+      initializeGeoJSON(this, settings);
+    } else {
+      init3D(this, settings);
+    }
     return;
   }
   kindByLayer.set(this, 'pending');

package/src/scene/resolveNextInitialization.js

@@ -5,7 +5,7 @@ import { initializerFor } from './initializerFor.js';
 
 export function resolveNextInitialization() {
   const task = pendingInitializations.shift();
-  task.initialize = initializerFor(task.type);
+  task.initialize = initializerFor(task.type, task.settings);
   if (!task.initialize) {
     task.error = /* alloc */ new Error(`Unknown layer type: ${task.type}`);
   }

package/src/shaders/materialShaders.js

@@ -30,6 +30,7 @@ export function materialShaders(material = defaultMaterial, sparkle = false, ele
       terrain: vec4<f32>,
       highlight: vec4<f32>,
       cutout: vec4<f32>,
+      nativeStroke: vec4<f32>,
     };
     struct Frame {
       viewMatrix: mat4x4<f32>,

package/src/shaders/materialVertexShader.js

@@ -1,7 +1,9 @@
 import { roofVertexShader } from './roofVertexShader.js';
+import { nativeStrokeShader } from './nativeStrokeShader.js';
 
 export function materialVertexShader(material, sparkle, elevationWGSL, hasTerrain, textured, hasRoof) {
   const instanceOffset = material.instanced ? ' + input.instanceOffset.xyz' : '';
+  const stroke = nativeStrokeShader(material);
   return /* wgsl */ `
     struct Mesh {
       worldMatrix: mat4x4<f32>,
@@ -11,6 +13,7 @@ export function materialVertexShader(material, sparkle, elevationWGSL, hasTerrai
       terrain: vec4<f32>,
       highlight: vec4<f32>,
       cutout: vec4<f32>,
+      nativeStroke: vec4<f32>,
     };
     struct Frame {
       viewMatrix: mat4x4<f32>,
@@ -46,6 +49,7 @@ export function materialVertexShader(material, sparkle, elevationWGSL, hasTerrai
     @vertex fn vertexMain(input: VertexInput, @builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
       var output: VertexOutput;
       var position = input.position${instanceOffset};
+      ${stroke.position}
       ${hasTerrain ? 'position.y = elevation(u.terrain.xy + input.uv * u.terrain.z, u.terrain.w) - u.terrain.w;' : ''}
       let featureVertex = f32(vertexIndex)${material.instanced ? ' + input.instanceOffset.w' : ''};
       let highlighted = featureVertex >= u.highlight.x && featureVertex < u.highlight.y;
@@ -54,8 +58,9 @@ export function materialVertexShader(material, sparkle, elevationWGSL, hasTerrai
       : 'u.baseColor.rgb'};
       // Inverse-transpose from cofactors; the camera view matrix is orthonormal.
       let m = mat3x3<f32>(u.worldMatrix[0].xyz, u.worldMatrix[1].xyz, u.worldMatrix[2].xyz);
-      let normal = (cross(m[1], m[2]) * input.normal.x + cross(m[2], m[0]) * input.normal.y +
-        cross(m[0], m[1]) * input.normal.z) / determinant(m);
+      ${stroke.normal}
+      let normal = (cross(m[1], m[2]) * sourceNormal.x + cross(m[2], m[0]) * sourceNormal.y +
+        cross(m[0], m[1]) * sourceNormal.z) / determinant(m);
       output.normal = (frame.viewMatrix * vec4<f32>(normal, 0.0)).xyz;
       let world = u.worldMatrix * vec4<f32>(position, 1.0);
       output.shadowPosition = solar.matrix * world;

package/src/shaders/nativeStrokeShader.js

@@ -0,0 +1,6 @@
+export function nativeStrokeShader(material) {
+  return /* alloc */ {
+    position: material.nativeStroke ? 'position = input.normal + (input.position - input.normal) * u.nativeStroke.x;' : '',
+    normal: material.nativeStroke ? 'let sourceNormal = vec3<f32>(0.0, 1.0, 0.0);' : 'let sourceNormal = input.normal;',
+  };
+}

package/src/sources/attachAreaMesh.js

@@ -9,7 +9,6 @@ import { createProgram } from '../materials/createProgram.js';
 
 import { setParent } from '../scene/setParent.js';
 import { update } from '../scene/scheduleSceneUpdate.js';
-import { instanceAreaGeometry } from '../geometry/instanceAreaGeometry.js';
 
 export function attachAreaMesh(context) {
   const { backend: layer, area } = context;
@@ -18,15 +17,15 @@ export function attachAreaMesh(context) {
     return;
   }
   const device = rendererByLayer.get(layer).device;
-  const data = context.preparedGeometry || instanceAreaGeometry(context);
+  const data = context.preparedGeometry;
   const attributes = /* alloc */ {
-    position: /* alloc */ { size: 3, data: data.positions instanceof Float32Array ? data.positions : /* alloc */ new Float32Array(data.positions) },
-    normal: /* alloc */ { size: 3, data: data.normals instanceof Float32Array ? data.normals : /* alloc */ new Float32Array(data.normals) },
-    color: /* alloc */ { size: 3, data: data.colors instanceof Float32Array ? data.colors : /* alloc */ new Float32Array(data.colors) },
+    position: /* alloc */ { size: 3, data: data.positions },
+    normal: /* alloc */ { size: 3, data: data.normals },
+    color: /* alloc */ { size: 3, data: data.colors },
   };
   if (data.instanceOffsets) attributes.instanceOffset = /* alloc */ { size: 4, data: data.instanceOffsets };
   if (layer.options.nightLight) attributes.uv = /* alloc */ {
-    size: 2, data: context.uvs instanceof Float32Array ? context.uvs : /* alloc */ new Float32Array(context.uvs),
+    size: 2, data: data.uvs,
   };
   let name, attribute;
   for (name in attributes) {

package/src/sources/buildArea.js

@@ -23,14 +23,13 @@ export async function buildArea(layer, area, map) {
     if (geojsonByLayer.get(layer) && typeof layer.options.style !== 'function') {
       throw /* alloc */ new Error('style must be a function');
     }
-    const context = sourceAreaContext(layer, area, map);
-    // ponytail: feature-count cutoff avoids startup overhead; count vertices if giant single polygons matter.
-    if (layer.options.worker !== false && typeof Worker !== 'undefined' && data.features.length >= 64) {
-      context.jobs = /* alloc */ [];
+    if (layer.options.worker === false) {
+      throw /* alloc */ new Error('worker: false is no longer supported; GeoJSON geometry requires Web Workers');
     }
+    const context = sourceAreaContext(layer, area, map);
     await buildAreaFeatures(context, area, data.features);
     if (area.request.signal.aborted) return;
-    if (context.jobs) await buildAreaInWorker(context, area.request.signal);
+    await buildAreaInWorker(context, area.request.signal);
     if (area.request.signal.aborted) return;
     attachAreaMesh(context);
   } catch (error) {

package/src/sources/buildAreaFeature.js

@@ -1,5 +1,3 @@
-import { buildAreaPoint } from './buildAreaPoint.js';
-import { buildAreaPolygon } from '../geometry/buildExtrudedPolygon.js';
 import { parseColor } from '../colors/parseColor.js';
 import { featureAnchor } from './featureAnchor.js';
 import { extrusionStyle } from './extrusionStyle.js';
@@ -10,7 +8,7 @@ export function buildAreaFeature(context, feature) {
   const { backend: layer, area, map } = context;
   const coords = area.coords;
   const coordinates = featureAnchor(feature, layer.options.nightLight);
-  const geometry = feature.geometry, isTree = geometry.type === 'Point';
+  const geometry = feature.geometry;
   const lon = coordinates[0], lat = coordinates[1];
   if (!matchesAreaTile(map, coords, lon, lat)) return;
   const style = extrusionStyle(layer, feature);
@@ -18,25 +16,11 @@ export function buildAreaFeature(context, feature) {
     context.skipped++;
     return;
   }
-  const { top, bottom = 0, color = 0xd9b38c } = style;
+  const { color = 0xd9b38c } = style;
   const baseColor = parseColor(color);
-  if (context.jobs) {
-    prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor);
-    context.featureFaces.push(/* alloc */ {
-      id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
-      properties: feature.properties, baseColor,
-    });
-    return;
-  }
-  const vertexStart = context.positions.length / 3;
-  if (isTree) buildAreaPoint(context, feature, lon, lat, style, baseColor);
-  let polygon;
-  if (geometry.type === 'Polygon') buildAreaPolygon(context, geometry.coordinates, top, bottom, baseColor);
-  else if (geometry.type === 'MultiPolygon') for (polygon of geometry.coordinates) buildAreaPolygon(context, polygon, top, bottom, baseColor);
-  const vertexEnd = context.positions.length / 3;
+  prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor);
   context.featureFaces.push(/* alloc */ {
     id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
     properties: feature.properties, baseColor,
-    faceStart: vertexStart / 3, faceEnd: vertexEnd / 3, vertexStart, vertexEnd,
   });
 }

package/src/sources/initVectorTiles.js

@@ -0,0 +1,15 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+import { configureVectorTileLayer } from '../vector-tiles/configureVectorTileLayer.js';
+import { readyVectorTiles } from './readyVectorTiles.js';
+import { reportError } from '../raster/reportRasterError.js';
+import { noOperation } from '../utils/noOperation.js';
+
+export function initVectorTiles(layer, options) {
+  kindByLayer.set(layer, 'pending');
+  const ready = configureVectorTileLayer(layer, options)
+    .then(readyVectorTiles.bind(null, layer))
+    .catch(reportError.bind(null, layer));
+  readyByLayer.set(layer, ready);
+  ready.catch(noOperation);
+}

package/src/sources/isVectorTileSource.js

@@ -0,0 +1,4 @@
+export function isVectorTileSource(options) {
+  return options.data === undefined && (options.tileJSON !== undefined ||
+    typeof options.url === 'string' && /\{[zxy]\}|%7B[zxy]%7D/i.test(options.url));
+}

package/src/sources/readyVectorTiles.js

@@ -0,0 +1,10 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
+export function readyVectorTiles(layer) {
+  const map = layer._map;
+  map?.removeLayer(layer);
+  kindByLayer.delete(layer);
+  map?.addLayer(layer);
+  layer.fire('ready');
+  return layer;
+}

package/src/sources/sourceAreaContext.js

@@ -8,13 +8,8 @@ export function sourceAreaContext(layer, area, map) {
   return /* alloc */ {
     backend: layer, area, map, crs, origin,
     metres: Math.cos(locationByLayer.get(layer).lat * radians),
-    positions: /* alloc */ [],
-    normals: /* alloc */ [],
-    colors: /* alloc */ [],
-    uvs: /* alloc */ [],
+    jobs: /* alloc */ [],
     featureFaces: /* alloc */ [],
-    lights: /* alloc */ [],
-    supports: /* alloc */ new Set(),
     skipped: 0,
   };
 }

package/src/sunlight/createSun.js

@@ -38,7 +38,6 @@ export function createSun(map) {
   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,

package/src/terrain/initTerrain.js

@@ -3,6 +3,7 @@ import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
 import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
 import { terrainSourceByLayer } from '../weakmaps/terrainSourceByLayer.js';
 import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
+import { streamTerrainByLayer } from '../weakmaps/streamTerrainByLayer.js';
 
 
 
@@ -12,10 +13,14 @@ import { init3D } from '../scene/init3D.js';
 
 /**
  * Renders Float32 DEM tiles and archived raster basemaps in the shared WebGPU scene.
- * Source options: `url` (single-zoom Float32 PMTiles or supported COG DEM);
+ * Source options: `url` (single-zoom Float32 PMTiles or supported COG DEM),
+ * or `getTile(z, x, y, signal)` for streamed 256px Float32 elevations;
  * `bridges` (optional GeoJSON deck polygons with Z, see _addBridges).
  */
 export function initTerrain(layer, options) {
+  if (options.getTile !== undefined && typeof options.getTile !== 'function') {
+    throw /* alloc */ new Error('Streamed terrain requires a getTile function');
+  }
   const terrainSource = options.url;
   const layerOptions = /* alloc */ { ...options };
   delete layerOptions.url;
@@ -24,5 +29,6 @@ export function initTerrain(layer, options) {
   terrainTilesByLayer.set(layer, /* alloc */ new Map());
   rasterTilesByLayer.set(layer, /* alloc */ new Map());
   terrainReadyByLayer.set(layer, false);
+  if (options.getTile) streamTerrainByLayer.set(layer, true);
   kindByLayer.set(layer, 'terrain');
 }

package/src/terrain/loadTerrain.js

@@ -5,6 +5,7 @@ import { terrainControllerByLayer } from '../weakmaps/terrainControllerByLayer.j
 import { terrainLoadingByLayer } from '../weakmaps/terrainLoadingByLayer.js';
 import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
 import { terrainSourceByLayer } from '../weakmaps/terrainSourceByLayer.js';
+import { workerMapByLayer } from '../weakmaps/workerMapByLayer.js';
 
 import { createLayer } from '../scene/createLayer.js';
 
@@ -23,9 +24,11 @@ export async function loadTerrain(layer) {
   try {
     if (!terrainSourceByLayer.get(layer)) throw /* alloc */ new Error('Terrain layer requires a PMTiles or COG elevation archive');
     const archive = createLayer(/* alloc */ { source: /* alloc */ {
-      type: layer.options.asset !== undefined || /\.tiff?(?:[?#]|$)/i.test(terrainSourceByLayer.get(layer)) ? 'cog' : 'pmtiles',
+      type: 'raster',
       url: terrainSourceByLayer.get(layer), archive: layer.options.archive, asset: layer.options.asset,
+      workerUrl: layer.options.workerUrl,
     } });
+    workerMapByLayer.set(archive, layer._map);
     terrainArchiveByLayer.set(layer, archive);
     await readyByLayer.get(archive);
     const header = headerByLayer.get(archive);

package/src/terrain/mapElevationOf.js

@@ -1,7 +1,11 @@
 import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+import { streamTerrainByMap } from '../weakmaps/streamTerrainByMap.js';
 import { getElevation } from './getElevation.js';
+import { gridTerrainElevation } from '../native/gridTerrainElevation.js';
 
 export function mapElevationOf(map, location) {
   const terrain = terrain3DByMap.get(map);
-  return terrain && getElevation(terrain, location);
+  if (terrain) return getElevation(terrain, location);
+  const stream = streamTerrainByMap.get(map);
+  return stream && gridTerrainElevation(stream, location);
 }

package/src/terrain/onTerrainAdd.js

@@ -1,6 +1,8 @@
 import { rootByLayer } from '../weakmaps/rootByLayer.js';
 import { terrainPromiseByLayer } from '../weakmaps/terrainPromiseByLayer.js';
 import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+import { streamTerrainByMap } from '../weakmaps/streamTerrainByMap.js';
+import { streamTerrainByLayer } from '../weakmaps/streamTerrainByLayer.js';
 
 
 
@@ -13,9 +15,17 @@ import { setLayerTerrain } from './setLayerTerrain.js';
 
 export function onTerrainAdd(layer, map) {
 
-  if (terrain3DByMap.get(map) && terrain3DByMap.get(map) !== layer) {
+  if (streamTerrainByMap.get(map) || terrain3DByMap.get(map) && terrain3DByMap.get(map) !== layer) {
     throw /* alloc */ new Error('Only one terrain layer can be active per map');
   }
+  if (streamTerrainByLayer.get(layer)) {
+    streamTerrainByMap.set(map, /* alloc */ {
+      layer, map, terrainCache: /* alloc */ new Map(), terrainController: /* alloc */ new AbortController(),
+    });
+    onAdd3DLayer(layer, map);
+    map.fire('terrainchange');
+    return;
+  }
   terrain3DByMap.set(map, layer);
   onAdd3DLayer(layer, map);
   if (rootByLayer.get(layer)) terrainPromiseByLayer.set(layer, loadTerrain(layer));

package/src/terrain/onTerrainRemove.js

@@ -11,6 +11,7 @@ import { terrainPromiseByLayer } from '../weakmaps/terrainPromiseByLayer.js';
 import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
 import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
 import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+import { streamTerrainByMap } from '../weakmaps/streamTerrainByMap.js';
 
 
 import { renderEmpty } from '../globals/renderEmpty.js';
@@ -25,7 +26,15 @@ import { onRemove3DLayer } from '../scene/onRemove3DLayer.js';
 import { clearLayerTerrain } from './clearLayerTerrain.js';
 
 export function onTerrainRemove(layer, map) {
-
+  const stream = streamTerrainByMap.get(map);
+  if (stream?.layer === layer) {
+    streamTerrainByMap.delete(map);
+    stream.terrainController.abort();
+    stream.terrainCache.clear();
+    map.fire('terrainchange');
+    onRemove3DLayer(layer, map);
+    return;
+  }
   terrainControllerByLayer.get(layer)?.abort();
   terrainLoadingByLayer.set(layer, false);
   terrainReadyByLayer.set(layer, false);

package/src/utils/yieldTask.js

@@ -0,0 +1,5 @@
+export function yieldTask(delay = 0) {
+  const task = Promise.withResolvers();
+  setTimeout(task.resolve, delay);
+  return task.promise;
+}

package/src/vector-style/appendQuotedStyleCharacter.js

@@ -0,0 +1,22 @@
+export function appendQuotedStyleCharacter(char, state) {
+  if (state.quoted) {
+    if (state.escaped) {
+      state.escaped = false;
+      return char === "'" ? char : '\\' + char;
+    }
+    if (char === '\\') {
+      state.escaped = true;
+      return '';
+    }
+    if (char === state.quoted) {
+      state.quoted = '';
+      return '"';
+    }
+    return char === '"' ? '\\"' : char;
+  }
+  if (char === '"' || char === "'") {
+    state.quoted = char;
+    return '"';
+  }
+  return undefined;
+}

package/src/vector-style/arrayContainsRange.js

@@ -0,0 +1,8 @@
+export function arrayContainsRange(values, start, end, target) {
+  let i = 0, value = null;
+  for (i = start; i < end; i++) {
+    value = values[i];
+    if (value === target || (value !== value && target !== target)) return true;
+  }
+  return false;
+}

package/src/vector-style/evaluateBoolean.js

@@ -0,0 +1,18 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateBoolean(op, args, properties, zoom, legacy) {
+  let i = 0;
+  if (op === 'all') {
+    for (i = 0; i < args.length; i++) {
+      if (!evaluateStyle(args[i], properties, zoom, legacy)) return false;
+    }
+    return true;
+  }
+  if (op === 'any') {
+    for (i = 0; i < args.length; i++) {
+      if (evaluateStyle(args[i], properties, zoom, legacy)) return true;
+    }
+    return false;
+  }
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/evaluateCoalesceOrCase.js

@@ -0,0 +1,21 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateCoalesceOrCase(op, args, properties, zoom, legacy) {
+  let i = 0, result = null;
+  if (op === 'coalesce') {
+    for (i = 0; i < args.length; i++) {
+      result = evaluateStyle(args[i], properties, zoom);
+      if (result !== null && result !== undefined) return result;
+    }
+    return null;
+  }
+  if (op === 'case') {
+    for (i = 0; i < args.length - 1; i += 2) {
+      if (evaluateStyle(args[i], properties, zoom)) {
+        return evaluateStyle(args[i + 1], properties, zoom);
+      }
+    }
+    return evaluateStyle(args[args.length - 1], properties, zoom);
+  }
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/evaluateComparison.js

@@ -0,0 +1,16 @@
+import { evaluateInput } from './evaluateInput.js';
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateComparison(op, args, properties, zoom, legacy) {
+  const left = evaluateInput(args[0], properties, zoom, legacy);
+  const right = evaluateStyle(args[1], properties, zoom);
+  switch (op) {
+    case '==': return left === right;
+    case '!=': return left !== right;
+    case '<=': return left <= right;
+    case '>=': return left >= right;
+    case '<': return left < right;
+    case '>': return left > right;
+      default: throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+  }
+}

package/src/vector-style/evaluateIExpression.js

@@ -0,0 +1,8 @@
+import { evaluateInterpolate } from './evaluateInterpolate.js';
+import { evaluateMembership } from './evaluateMembership.js';
+
+export function evaluateIExpression(op, args, properties, zoom, legacy) {
+  if (op === 'in') return evaluateMembership(op, args, properties, zoom, legacy);
+  if (op === 'interpolate') return evaluateInterpolate(args, properties, zoom);
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/evaluateInput.js

@@ -0,0 +1,6 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateInput(value, properties, zoom, legacy) {
+  if (legacy && typeof value === 'string') return properties[value];
+  return evaluateStyle(value, properties, zoom);
+}