leaflet-city-mapper 0.0.5 → 0.0.7

package/src/vector-tiles/rotateVectorLabel.js

@@ -0,0 +1,12 @@
+import { radians } from '../globals/radians.js';
+import { markerSetRotation } from '../core/markerSetRotation.js';
+
+export function rotateVectorLabel(map, marker, label) {
+  if (!label.along) return;
+  const a = map.latLngToContainerPoint(label.along[0]), b = map.latLngToContainerPoint(label.along[1]);
+  let angle = Math.atan2(b.y - a.y, b.x - a.x) / radians;
+  if (angle > 90) angle -= 180;
+  else if (angle < -90) angle += 180;
+  if (marker.options.rotation === angle * radians) return;
+  markerSetRotation(marker, angle * radians);
+}

package/src/vector-tiles/rotateVectorLabels.js

@@ -0,0 +1,6 @@
+import { rotateVectorLabel } from './rotateVectorLabel.js';
+
+export function rotateVectorLabels() {
+  let marker;
+  for (marker of this.labels.values()) if (marker._mvtLabel) rotateVectorLabel(this._map, marker, marker._mvtLabel);
+}

package/src/vector-tiles/simplifyVectorPath.js

@@ -0,0 +1,21 @@
+export function simplifyVectorPath(path, tolerance) {
+  if (path.length < 3) return path;
+  const keep = /* alloc */ new Uint8Array(path.length);
+  const stack = /* alloc */ [/* alloc */ [0, path.length - 1]], output = /* alloc */ [];
+  keep[0] = keep[path.length - 1] = 1;
+  let start, end, a, b, dx, dy, length, index, distance, i, p, t, squared;
+  while (stack.length) {
+    [start, end] = stack.pop(); a = path[start]; b = path[end];
+    dx = b[0] - a[0]; dy = b[1] - a[1]; length = dx * dx + dy * dy;
+    index = -1; distance = tolerance * tolerance;
+    for (i = start + 1; i < end; i++) {
+      p = path[i];
+      t = length ? Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / length)) : 0;
+      squared = (p[0] - a[0] - t * dx) ** 2 + (p[1] - a[1] - t * dy) ** 2;
+      if (squared > distance) { distance = squared; index = i; }
+    }
+    if (index >= 0) { keep[index] = 1; stack.push(/* alloc */ [start, index], /* alloc */ [index, end]); }
+  }
+  for (i = 0; i < path.length; i++) if (keep[i]) output.push(path[i]);
+  return output;
+}

package/src/vector-tiles/updateVectorLabelMarker.js

@@ -0,0 +1,27 @@
+import { L } from '../globals/L.js';
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { vectorLabelIcon } from './vectorLabelIcon.js';
+import { rotateVectorLabel } from './rotateVectorLabel.js';
+import { forwardVectorTileError } from './forwardVectorTileError.js';
+
+export function updateVectorLabelMarker(owner, label, key) {
+  const appearance = JSON.stringify(/* alloc */ [label.size, label.color, label.halo, label.haloWidth, label.icon]);
+  const sheet = vectorTileOptionsByLayer.get(owner).spriteSheet;
+  let marker = owner.labels.get(key);
+  if (marker) {
+    marker._mvtLabel = label;
+    if (marker._mvtLabelStyle === appearance) { rotateVectorLabel(owner._map, marker, label); return false; }
+    marker.setIcon(vectorLabelIcon(label, sheet));
+  } else {
+    const { pane } = vectorTileOptionsByLayer.get(owner);
+    marker = /* alloc */ new L.Marker(label.latlng, /* alloc */ {
+      icon: vectorLabelIcon(label, sheet), pane: `${pane}-${label.order}`, title: label.text,
+      alt: label.text, interactive: false, keyboard: false, rotateWithView: false,
+    }).on('error', forwardVectorTileError, owner).addTo(owner._map);
+    owner.labels.set(key, marker);
+  }
+  marker._mvtLabelStyle = appearance;
+  marker._mvtLabel = label;
+  rotateVectorLabel(owner._map, marker, label);
+  return true;
+}

package/src/vector-tiles/updateVectorTileLabels.js

@@ -0,0 +1,28 @@
+import { vectorLabelCandidates } from './vectorLabelCandidates.js';
+import { vectorLabelCells } from './vectorLabelCells.js';
+import { reserveVectorLabelCells } from './reserveVectorLabelCells.js';
+import { updateVectorLabelMarker } from './updateVectorLabelMarker.js';
+import { vectorTilesIdle } from './vectorTilesIdle.js';
+import { yieldTask } from '../utils/yieldTask.js';
+
+export async function updateVectorTileLabels() {
+  const session = this.session, revision = this.labelRevision = (this.labelRevision || 0) + 1;
+  this.labelsReady = false;
+  const candidates = vectorLabelCandidates(this), size = this._map.getSize();
+  const occupied = /* alloc */ new Set(), retained = /* alloc */ new Set();
+  let visited = 0, label, key, cells, marker;
+  for (label of candidates) {
+    if (++visited % 128 === 0) await yieldTask();
+    if (!vectorTilesIdle(this, session) || this.labelRevision !== revision) return;
+    cells = vectorLabelCells(this, label, size);
+    if (!cells || !label.allowOverlap && !reserveVectorLabelCells(cells, occupied)) continue;
+    key = `${label.text}${label.icon || ''}:${label.latlng.join(':')}`;
+    retained.add(key);
+    if (updateVectorLabelMarker(this, label, key)) await yieldTask();
+  }
+  for ([key, marker] of this.labels) {
+    if (!vectorTilesIdle(this, session) || this.labelRevision !== revision) return;
+    if (!retained.has(key)) { marker.remove(); this.labels.delete(key); await yieldTask(); }
+  }
+  this.labelsReady = true;
+}

package/src/vector-tiles/updateVectorTilePaint.js

@@ -0,0 +1,20 @@
+import { paintVectorTileBatch } from './paintVectorTileBatch.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { vectorTilesIdle } from './vectorTilesIdle.js';
+import { yieldTask } from '../utils/yieldTask.js';
+
+export async function updateVectorTilePaint() {
+  const zoom = vectorStyleZoom(this), session = this.session;
+  if (this.paintZoom === zoom) return;
+  const revision = this.paintRevision = (this.paintRevision || 0) + 1;
+  let updated = 0, tile, batch;
+  for (tile of this.tiles.values()) {
+    if (!tile.rendered) continue;
+    for (batch of tile.rendered) {
+      if (!vectorTilesIdle(this, session) || this.paintRevision !== revision || vectorStyleZoom(this) !== zoom) return;
+      paintVectorTileBatch(batch, zoom);
+      if (++updated % 32 === 0) await yieldTask();
+    }
+  }
+  this.paintZoom = zoom;
+}

package/src/vector-tiles/updateVectorTiles.js

@@ -0,0 +1,29 @@
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { reportError } from '../scene/reportLayerError.js';
+
+export function updateVectorTiles() {
+  if (!this.session) return;
+  const { minNativeZoom, maxNativeZoom } = vectorTileOptionsByLayer.get(this);
+  const z = Math.max(minNativeZoom, Math.min(maxNativeZoom, Math.floor(vectorStyleZoom(this))));
+  const bounds = this._map.getBounds(), count = 2 ** z;
+  const nw = this._map.project(bounds.getNorthWest(), z).divideBy(256);
+  const se = this._map.project(bounds.getSouthEast(), z).divideBy(256);
+  let tile, x, y, key;
+  for (tile of this.tiles.values()) tile.needed = false;
+  for (x = Math.floor(nw.x); x <= Math.floor(se.x); x++) {
+    for (y = Math.max(0, Math.floor(nw.y)); y <= Math.min(count - 1, Math.floor(se.y)); y++) {
+      key = `${z}/${x}/${y}`;
+      tile = this.tiles.get(key);
+      if (!tile) {
+        tile = /* alloc */ { key, coords: /* alloc */ { z, x, y }, controller: /* alloc */ new AbortController() };
+        this.tiles.set(key, tile);
+      }
+      tile.needed = true;
+    }
+  }
+  this.prune();
+  this.pump();
+  this.updatePaint().catch(reportError.bind(null, this));
+  this.updateLabels().catch(reportError.bind(null, this));
+}

package/src/vector-tiles/validateVectorTileZooms.js

@@ -0,0 +1,6 @@
+export function validateVectorTileZooms(minNativeZoom, maxNativeZoom, maxZoom) {
+  if (!Number.isInteger(minNativeZoom) || !Number.isInteger(maxNativeZoom) || !Number.isInteger(maxZoom) ||
+      minNativeZoom < 0 || maxNativeZoom < minNativeZoom || maxZoom < maxNativeZoom || maxZoom > 24) {
+    throw /* alloc */ new Error('Invalid vector tile zoom range');
+  }
+}

package/src/vector-tiles/vectorFeaturePaint.js

@@ -0,0 +1,15 @@
+import { vectorPaint } from '../vector-style/vectorPaint.js';
+import { visibleStyle } from '../vector-style/visibleStyle.js';
+
+export function vectorFeaturePaint(entry, feature, sampleZoom, maxZoom) {
+  if (entry.type === 'fill') return feature.type === 3 ? vectorPaint(entry, feature.properties, sampleZoom) : null;
+  if (entry.type !== 'line' || feature.type !== 2) return null;
+  let paint = vectorPaint(entry, feature.properties, sampleZoom), candidate;
+  if (paint.weight > 0 && paint.opacity > 0) return paint;
+  for (candidate = maxZoom; candidate >= 0; candidate--) {
+    if (!visibleStyle(entry, feature.properties, candidate)) continue;
+    paint = vectorPaint(entry, feature.properties, candidate);
+    if (paint.weight > 0 && paint.opacity > 0) return paint;
+  }
+  return null;
+}

package/src/vector-tiles/vectorFeaturePaths.js

@@ -0,0 +1,16 @@
+import { projectVectorTriangles } from './projectVectorTriangles.js';
+import { projectVectorPaths } from './projectVectorPaths.js';
+import { vectorTolerance } from './vectorTolerance.js';
+
+export function vectorFeaturePaths(job, layer, entry, feature) {
+  const cache = entry.type === 'fill' ? job.triangles : job.projected;
+  let paths = cache.get(feature);
+  if (!paths) {
+    const tolerance = vectorTolerance(job, layer);
+    paths = entry.type === 'fill'
+      ? projectVectorTriangles(feature.geometry, job.coords, layer.extent, tolerance)
+      : projectVectorPaths(feature.geometry, job.coords, layer.extent, tolerance);
+    cache.set(feature, paths);
+  }
+  return paths;
+}

package/src/vector-tiles/vectorFeatureZoom.js

@@ -0,0 +1,8 @@
+import { visibleStyle } from '../vector-style/visibleStyle.js';
+
+export function vectorFeatureZoom(entry, properties, zoom, maxZoom) {
+  if (visibleStyle(entry, properties, zoom)) return zoom;
+  zoom = maxZoom;
+  while (zoom >= 0 && !visibleStyle(entry, properties, zoom)) zoom--;
+  return zoom;
+}

package/src/vector-tiles/vectorLabelAnchors.js

@@ -0,0 +1,24 @@
+import { vectorStraightRun } from './vectorStraightRun.js';
+
+/** Anchors evenly spread along a path: each is a point on a segment plus that segment's ends. */
+export function vectorLabelAnchors(path, spacing) {
+  const anchors = /* alloc */ [];
+  let length = 0, i, walked, target, count, k, segment, t, point;
+  for (i = 1; i < path.length; i++) length += Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]);
+  count = Math.max(1, Math.floor(length / spacing));
+  i = 1; walked = 0;
+  for (k = 0; k < count; k++) {
+    target = (k + 0.5) * length / count;
+    while (i < path.length - 1 && walked + Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]) < target) {
+      walked += Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]); i++;
+    }
+    segment = Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]);
+    t = segment ? Math.min(1, Math.max(0, (target - walked) / segment)) : 0;
+    point = /* alloc */ [
+      path[i - 1][0] + (path[i][0] - path[i - 1][0]) * t, path[i - 1][1] + (path[i][1] - path[i - 1][1]) * t,
+    ];
+    anchors.push(/* alloc */ { point, a: path[i - 1], b: path[i],
+      length: vectorStraightRun(path, i, point, 1) + vectorStraightRun(path, i, point, -1) });
+  }
+  return anchors;
+}

package/src/vector-tiles/vectorLabelCandidates.js

@@ -0,0 +1,11 @@
+import { compareVectorLabelPriority } from './compareVectorLabelPriority.js';
+
+export function vectorLabelCandidates(layer) {
+  const candidates = /* alloc */ [];
+  let tile, label;
+  for (tile of layer.tiles.values()) {
+    if (!tile.needed || !tile.labelCandidates) continue;
+    for (label of tile.labelCandidates) candidates.push(label);
+  }
+  return candidates.sort(compareVectorLabelPriority);
+}

package/src/vector-tiles/vectorLabelCells.js

@@ -0,0 +1,26 @@
+import { evaluateStyle } from '../vector-style/evaluateStyle.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { visibleStyle } from '../vector-style/visibleStyle.js';
+
+export function vectorLabelCells(layer, label, size) {
+  const map = layer._map, zoom = vectorStyleZoom(layer);
+  if (!visibleStyle(label.entry, label.properties, zoom)) return null;
+  label.size = evaluateStyle(label.entry.layout?.['text-size'] ?? 12, label.properties, zoom);
+  if (!(label.size > 0)) return null;
+  if (label.icon && !vectorTileOptionsByLayer.get(layer).spriteSheet?.index[label.icon]) return null;
+  label.color = evaluateStyle(label.entry.paint?.['text-color'] ?? '#000', label.properties, zoom);
+  label.halo = evaluateStyle(label.entry.paint?.['text-halo-color'] ?? '#fff', label.properties, zoom);
+  label.haloWidth = evaluateStyle(label.entry.paint?.['text-halo-width'] ?? 0, label.properties, zoom);
+  if (label.along && label.pixelBase * 2 ** map.getZoom() < label.text.length * label.size * 0.6) return null;
+  const point = map.latLngToContainerPoint(label.latlng);
+  if (point.x < 0 || point.y < 0 || point.x > size.x || point.y > size.y) return null;
+  const width = label.text.length * label.size * 0.65 + 16, cells = /* alloc */ [];
+  let x, y;
+  for (x = Math.floor((point.x - width / 2) / 32); x <= Math.floor((point.x + width / 2) / 32); x++) {
+    for (y = Math.floor((point.y - label.size) / 24); y <= Math.floor((point.y + label.size) / 24); y++) {
+      cells.push(`${x}:${y}`);
+    }
+  }
+  return cells;
+}

package/src/vector-tiles/vectorLabelIcon.js

@@ -0,0 +1,30 @@
+import { L } from '../globals/L.js';
+import { vectorSpriteIcon } from './vectorSpriteIcon.js';
+import { wrapVectorLabel } from './wrapVectorLabel.js';
+
+export function vectorLabelIcon(label, sheet) {
+  if (label.icon) return vectorSpriteIcon(label, sheet);
+  const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+  const lines = label.along ? [label.text] : wrapVectorLabel(label.text);
+  let longest = 0, line, key, text, index;
+  for (line of lines) longest = Math.max(longest, Array.from(line).length);
+  const width = Math.max(40, longest * label.size * 0.65 + 12);
+  const lineHeight = label.size * 1.2, height = lines.length * lineHeight + 12;
+  svg.setAttribute('width', width); svg.setAttribute('height', height);
+  const attributes = /* alloc */ {
+    x: width / 2, 'text-anchor': 'middle',
+    'font-family': 'sans-serif', 'font-size': label.size,
+    fill: label.color, stroke: label.halo, 'stroke-width': label.haloWidth * 2, 'paint-order': 'stroke',
+  };
+  for (index = 0; index < lines.length; index++) {
+    text = document.createElementNS(svg.namespaceURI, 'text');
+    for (key of Object.keys(attributes)) text.setAttribute(key, attributes[key]);
+    text.setAttribute('y', height / 2 + (index - (lines.length - 1) / 2) * lineHeight + label.size * 0.35);
+    text.textContent = lines[index];
+    svg.append(text);
+  }
+  return /* alloc */ new L.Icon(/* alloc */ {
+    iconUrl: `data:image/svg+xml;charset=utf-8,${encodeURIComponent((/* alloc */ new XMLSerializer()).serializeToString(svg))}`,
+    iconSize: /* alloc */ [width, height], iconAnchor: /* alloc */ [width / 2, height / 2],
+  });
+}

package/src/vector-tiles/vectorLabelProperty.js

@@ -0,0 +1,3 @@
+export function vectorLabelProperty(properties, match, key) {
+  return properties[key] ?? '';
+}

package/src/vector-tiles/vectorSpriteIcon.js

@@ -0,0 +1,11 @@
+import { L } from '../globals/L.js';
+
+export function vectorSpriteIcon(label, sheet) {
+  const { x, y, width, height } = sheet.index[label.icon], [dx, dy] = label.iconOffset;
+  return /* alloc */ new L.DivIcon(/* alloc */ {
+    className: '',
+    html: `<div style="width:${width}px;height:${height}px;background:url(${sheet.url}) -${x}px -${y}px"></div>`,
+    iconSize: /* alloc */ [width, height],
+    iconAnchor: /* alloc */ [width / 2 - dx, height / 2 - dy],
+  });
+}

package/src/vector-tiles/vectorStraightRun.js

@@ -0,0 +1,14 @@
+/** Distance from a point on segment (i-1, i) along the path until it turns more than ~45 degrees from that segment. */
+export function vectorStraightRun(path, i, point, step) {
+  const base = Math.atan2(path[i][1] - path[i - 1][1], path[i][0] - path[i - 1][0]);
+  let j = step > 0 ? i : i - 1, previous = point, run = 0, next;
+  while (j >= 0 && j < path.length) {
+    run += Math.hypot(path[j][0] - previous[0], path[j][1] - previous[1]);
+    previous = path[j];
+    next = j + step;
+    if (next < 0 || next >= path.length) break;
+    if (Math.cos(Math.atan2(path[next][1] - path[j][1], path[next][0] - path[j][0]) - base + (step < 0 ? Math.PI : 0)) < 0.7) break;
+    j = next;
+  }
+  return run;
+}

package/src/vector-tiles/vectorStyleDependencies.js

@@ -0,0 +1,15 @@
+export function vectorStyleDependencies(entry) {
+  const dependencies = /* alloc */ new Set();
+  const expressions = /* alloc */ [entry.paint, entry.filter];
+  let value, child;
+  while (expressions.length) {
+    value = expressions.pop();
+    if (!value || typeof value !== 'object') continue;
+    if (Array.isArray(value) && typeof value[1] === 'string' &&
+        /* alloc */ ['get', 'has', '==', '!=', '<', '>', '<=', '>=', 'in', '!in'].includes(value[0])) {
+      dependencies.add(value[1]);
+    }
+    for (child of Object.values(value)) expressions.push(child);
+  }
+  return dependencies;
+}

package/src/vector-tiles/vectorStyleValue.js

@@ -0,0 +1,5 @@
+import { evaluateStyle } from '../vector-style/evaluateStyle.js';
+
+export function vectorStyleValue(object, key, fallback, properties, zoom) {
+  return object?.[key] === undefined ? fallback : evaluateStyle(object[key], properties, zoom);
+}

package/src/vector-tiles/vectorStyleZoom.js

@@ -0,0 +1,6 @@
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+
+// Style zooms are authored for 512px tiles (MapLibre): `styleZoomOffset: -1` maps Leaflet's 256px zoom onto them.
+export function vectorStyleZoom(layer) {
+  return layer._map.getZoom() + (vectorTileOptionsByLayer.get(layer).styleZoomOffset ?? 0);
+}

package/src/vector-tiles/vectorTileAwaited.js

@@ -0,0 +1,9 @@
+import { vectorTileOverlaps } from './vectorTileOverlaps.js';
+
+export function vectorTileAwaited(layer, stale) {
+  let tile;
+  for (tile of layer.tiles.values()) {
+    if (tile.needed && !tile.group && vectorTileOverlaps(tile.coords, stale.coords)) return true;
+  }
+  return false;
+}

package/src/vector-tiles/vectorTileOverlaps.js

@@ -0,0 +1,4 @@
+export function vectorTileOverlaps(a, b) {
+  const shift = a.z - b.z;
+  return shift >= 0 ? a.x >> shift === b.x && a.y >> shift === b.y : b.x >> -shift === a.x && b.y >> -shift === a.y;
+}

package/src/vector-tiles/vectorTilePaint.js

@@ -0,0 +1,10 @@
+import { vectorPaint } from '../vector-style/vectorPaint.js';
+import { visibleStyle } from '../vector-style/visibleStyle.js';
+
+export function vectorTilePaint(batch, zoom) {
+  const paint = vectorPaint(batch.entry, batch.properties, zoom);
+  if (!visibleStyle(batch.entry, batch.properties, zoom)) {
+    paint.opacity = 0; paint.fillOpacity = 0;
+  }
+  return paint;
+}

package/src/vector-tiles/vectorTileSettings.js

@@ -0,0 +1,17 @@
+import { readTileJSON } from './readTileJSON.js';
+import { readVectorStyle } from './readVectorStyle.js';
+import { validateVectorTileZooms } from './validateVectorTileZooms.js';
+
+export async function vectorTileSettings(options) {
+  if (!options || typeof options !== 'object') throw /* alloc */ new TypeError('Vector tiles require source options');
+  if (options.tileJSON) options = await readTileJSON(options);
+  let { url, style, minNativeZoom = 0, maxNativeZoom = 14, maxZoom = 19 } = options;
+  let key;
+  if (typeof url === 'string') url = url.replaceAll(/%7B([zxy])%7D/gi, '{$1}');
+  for (key of /* alloc */ ['{z}', '{x}', '{y}']) {
+    if (typeof url !== 'string' || !url.includes(key)) throw /* alloc */ new Error('Vector tiles require an XYZ URL template');
+  }
+  validateVectorTileZooms(minNativeZoom, maxNativeZoom, maxZoom);
+  style = await readVectorStyle(style);
+  return /* alloc */ { ...options, url, style, minNativeZoom, maxNativeZoom, maxZoom };
+}

package/src/vector-tiles/vectorTilesIdle.js

@@ -0,0 +1,3 @@
+export function vectorTilesIdle(layer, session) {
+  return layer.session === session && performance.now() - (layer.changedAt || 0) >= 180;
+}

package/src/vector-tiles/vectorTolerance.js

@@ -0,0 +1,4 @@
+/** Simplification tolerance in tile units: about 0.7 screen pixels at the displayed scale. */
+export function vectorTolerance(job, layer) {
+  return layer.extent / 256 / 2 ** Math.max(-1, job.mapZoom - job.coords.z) * 0.7;
+}

package/src/vector-tiles/wrapVectorLabel.js

@@ -0,0 +1,11 @@
+/** Greedy word wrap at 10 ems (MapLibre's default text-max-width), estimating glyph width at 0.52 em. */
+export function wrapVectorLabel(text) {
+  const limit = Math.floor(10 / 0.52), lines = /* alloc */ [];
+  let line = '', word;
+  for (word of text.split(' ')) {
+    if (line && Array.from(`${line} ${word}`).length > limit) { lines.push(line); line = word; }
+    else line = line ? `${line} ${word}` : word;
+  }
+  lines.push(line);
+  return lines;
+}

package/src/walk/animateWalker.js

@@ -9,14 +9,10 @@ import { moves } from '../globals/moves.js';
 import * as createMesh from '../rendering/createMesh.js';
 import { build } from '../geometry/buildGeometryParts.js';
 
-import { wrap } from '../utils/wrap.js';
 import { local } from '../projections/walkerLocalPosition.js';
-import { place } from './placeWalker.js';
-import { land } from './landWalker.js';
-import { moveWalker } from './moveWalker.js';
 import { stepWalkerHeight } from './stepWalkerHeight.js';
-import { updateWalkerView } from './updateWalkerView.js';
 import { resolveWalkerPosition } from './resolveWalkerPosition.js';
+import { updateWalkerFrame } from './updateWalkerFrame.js';
 
 export function step(now) {
   const layer = this.layer;
@@ -41,12 +37,5 @@ export function step(now) {
   let forward = 0, turn = 0;
   for (key of this.keys) { forward += moves[key]?.[0] || 0; turn += moves[key]?.[1] || 0; }
   forward = Math.sign(forward); turn = Math.sign(turn);
-  if (turn) { this.state.heading = wrap(this.state.heading + turn * 2.5 * dt); changed = true; }
-  if (forward) {
-    moveWalker.call(this, forward, dt);
-    changed = true;
-  }
-  if (changed) land.call(this, previousY);
-  if (updateWalkerView.call(this, forward, turn, dt)) changed = true;
-  if (changed) place.call(this);
+  updateWalkerFrame(this, previousY, forward, turn, dt, changed);
 }

package/src/walk/updateWalkerFrame.js

@@ -0,0 +1,19 @@
+import { wrap } from '../utils/wrap.js';
+import { place } from './placeWalker.js';
+import { land } from './landWalker.js';
+import { moveWalker } from './moveWalker.js';
+import { updateWalkerView } from './updateWalkerView.js';
+
+export function updateWalkerFrame(walker, previousY, forward, turn, dt, changed) {
+  if (turn) {
+    walker.state.heading = wrap(walker.state.heading + turn * 2.5 * dt);
+    changed = true;
+  }
+  if (forward) {
+    moveWalker.call(walker, forward, dt);
+    changed = true;
+  }
+  if (changed) land.call(walker, previousY);
+  if (updateWalkerView.call(walker, forward, turn, dt)) changed = true;
+  if (changed) place.call(walker);
+}

package/src/weakmaps/nativeProgramsByRenderer.js

@@ -0,0 +1 @@
+export const nativeProgramsByRenderer = new WeakMap();

package/src/weakmaps/streamTerrainByLayer.js

@@ -0,0 +1 @@
+export const streamTerrainByLayer = new WeakMap();

package/src/weakmaps/streamTerrainByMap.js

@@ -0,0 +1 @@
+export const streamTerrainByMap = new WeakMap();

package/src/weakmaps/vectorTileOptionsByLayer.js

@@ -0,0 +1 @@
+export const vectorTileOptionsByLayer = new WeakMap();

package/src/weakmaps/vectorWorkerByLayer.js

@@ -0,0 +1 @@
+export const vectorWorkerByLayer = new WeakMap();

package/src/weakmaps/workerMapByLayer.js

@@ -0,0 +1 @@
+export const workerMapByLayer = new WeakMap();

package/src/workers/acquireGeometryWorker.js

@@ -1,5 +1,6 @@
 import { geometryWorkersByMap } from '../weakmaps/geometryWorkersByMap.js';
 import { closeGeometryWorkers } from './closeGeometryWorkers.js';
+import { createGeometryWorker } from './createGeometryWorker.js';
 
 export function acquireGeometryWorker(map, url) {
   let pool = map && geometryWorkersByMap.get(map);
@@ -24,9 +25,5 @@ export function acquireGeometryWorker(map, url) {
       pool.entries.delete(entry);
     }
   }
-  entry = /* alloc */ {
-    url, pool, worker: /* alloc */ new Worker(url, /* alloc */ { type: 'module' }),
-  };
-  if (pool) pool.entries.add(entry);
-  return entry;
+  return createGeometryWorker(url, pool);
 }

package/src/workers/buildAreaInWorker.js

@@ -1,36 +1,16 @@
-import { geometryWorkerUrl } from '../globals/geometryWorkerUrl.js';
-import { startGeometryWorker } from './startGeometryWorker.js';
-import { acquireGeometryWorker } from './acquireGeometryWorker.js';
+import { runSourceWorker } from './runSourceWorker.js';
 
 export async function buildAreaInWorker(context, signal) {
-  const entry = acquireGeometryWorker(context.map || context.backend._map, context.backend.options.workerUrl || geometryWorkerUrl);
-  const { worker, pool } = entry;
-  const task = /* alloc */ {
-    worker, signal,
-    input: /* alloc */ { jobs: context.jobs, nightLight: Boolean(context.backend.options.nightLight) },
-  };
-  entry.task = task;
-  let completed = false;
   try {
-    const data = await /* alloc */ new Promise(startGeometryWorker.bind(null, task));
+    const data = await runSourceWorker(context.map || context.backend._map, context.backend.options.workerUrl,
+      /* alloc */ { jobs: context.jobs, nightLight: Boolean(context.backend.options.nightLight) }, signal);
     let i;
     for (i = 0; i < data.ranges.length; i++) Object.assign(context.featureFaces[i], data.ranges[i]);
     context.positions = data.positions;
     context.uvs = data.uvs;
     context.lights = data.lights;
     context.preparedGeometry = data;
-    completed = true;
   } finally {
-    worker.removeEventListener('message', task.onEvent);
-    worker.removeEventListener('error', task.onEvent);
-    worker.removeEventListener('messageerror', task.onEvent);
-    signal.removeEventListener('abort', task.onEvent);
-    entry.task = null;
-    if (completed && pool && !pool.closed && !signal.aborted) pool.idle.push(entry);
-    else {
-      if (!entry.closed) worker.terminate();
-      if (pool) pool.entries.delete(entry);
-    }
     context.jobs = null;
   }
 }

package/src/workers/cogWorker.js

@@ -0,0 +1,21 @@
+import { openCog } from '../cog/openCog.js';
+import { workerCogSource } from '../globals/workerCogSource.js';
+
+export async function onCogMessage({ data }) {
+  try {
+    const key = JSON.stringify(/* alloc */ [data.url, data.asset]);
+    // ponytail: one cached COG per worker; use a bounded per-source cache if interleaved archives cause churn.
+    if (workerCogSource.key !== key) {
+      workerCogSource.key = key;
+      workerCogSource.archive = openCog(data.url, data.asset);
+    }
+    const archive = await workerCogSource.archive;
+    const result = data.z === undefined ? await archive.getHeader() : await archive.getZxy(data.z, data.x, data.y);
+    const transfers = /* alloc */ [];
+    if (result?.data) transfers.push(result.data);
+    if (result?.image) transfers.push(result.image);
+    self.postMessage(result, transfers);
+  } catch (error) {
+    self.postMessage(/* alloc */ { error: /* alloc */ { name: error.name, message: error.message } });
+  }
+}

package/src/workers/createGeometryWorker.js

@@ -0,0 +1,20 @@
+export function createGeometryWorker(url, pool) {
+  if (typeof Worker === 'undefined') throw /* alloc */ new Error('Web Workers are required to prepare source geometry');
+  let workerUrl = url, blobUrl, worker;
+  if (globalThis.location) {
+    const resolved = /* alloc */ new URL(url, location.href);
+    if ((resolved.protocol === 'https:' || resolved.protocol === 'http:') && resolved.origin !== location.origin) {
+      blobUrl = URL.createObjectURL(/* alloc */ new Blob(/* alloc */ [`import ${JSON.stringify(resolved.href)};`],
+        /* alloc */ { type: 'text/javascript' }));
+      workerUrl = blobUrl;
+    }
+  }
+  try {
+    worker = /* alloc */ new Worker(workerUrl, /* alloc */ { type: 'module' });
+  } finally {
+    if (!worker && blobUrl) URL.revokeObjectURL(blobUrl);
+  }
+  const entry = /* alloc */ { url, pool, worker, blobUrl };
+  if (pool) pool.entries.add(entry);
+  return entry;
+}

package/src/workers/geometryWorker.js

@@ -1,6 +1,21 @@
 import { assembleAreaGeometry } from '../geometry/assembleAreaGeometry.js';
+import { onVectorTileMessage } from './vectorTileWorker.js';
+import { onCogMessage } from './cogWorker.js';
+import { onModelMessage } from './modelWorker.js';
 
 export function onGeometryMessage(event) {
+  if (event.data.type === 'model') {
+    onModelMessage(event);
+    return;
+  }
+  if (event.data.type === 'cog') {
+    onCogMessage(event);
+    return;
+  }
+  if (event.data.type === 'vector') {
+    onVectorTileMessage(event);
+    return;
+  }
   try {
     const data = assembleAreaGeometry(event.data);
     const transfers = /* alloc */ [data.positions.buffer, data.normals.buffer, data.colors.buffer, data.uvs.buffer];