@tileflow/core 0.1.0-alpha.35 → 0.1.0-alpha.36

package/dist/browser.js

@@ -933,9 +933,9 @@ var init_sun = __esm({
       azimuth: 210,
       altitude: 60,
       color: "#ffffff",
-      intensity: 0.5,
+      intensity: 0.2,
       shadowIntensity: 1,
-      ambient: Object.freeze({ color: "#ffffff", intensity: 0.5 })
+      ambient: Object.freeze({ color: "#ffffff", intensity: 0.8 })
     });
     degrees = Math.PI / 180;
   }
@@ -4466,6 +4466,159 @@ function withAlpha(color, alpha) {
   return `rgba(${value >> 16}, ${value >> 8 & 255}, ${value & 255}, ${alpha})`;
 }
 
+// src/boundary-areas/schema.ts
+var tileflowBoundaryClasses = [
+  "country",
+  "dependency",
+  "region",
+  "province_or_county",
+  "municipality",
+  "district",
+  "neighbourhood"
+];
+var tileflowBoundaryClassTiers = ["primary", "secondary"];
+var tileflowBoundaryAreasV1Schema = Object.freeze({
+  classes: tileflowBoundaryClasses,
+  /** First zoom at which each class appears, by tier. */
+  classMinzoom: Object.freeze({
+    country: Object.freeze({ primary: 0, secondary: 0 }),
+    dependency: Object.freeze({ primary: 0, secondary: 0 }),
+    region: Object.freeze({ primary: 3, secondary: 3 }),
+    province_or_county: Object.freeze({ primary: 6, secondary: 7 }),
+    municipality: Object.freeze({ primary: 8, secondary: 8 }),
+    district: Object.freeze({ primary: 10, secondary: 10 }),
+    neighbourhood: Object.freeze({ primary: 11, secondary: 11 })
+  }),
+  fields: Object.freeze({
+    adminDepth: "admin_depth",
+    adminLevel: "admin_level",
+    class: "class",
+    classTier: "class_tier",
+    iso31661: "iso_3166_1",
+    iso31662: "iso_3166_2",
+    name: "name",
+    nuts: "nuts",
+    ref: "ref",
+    wikidata: "wikidata"
+  }),
+  layers: Object.freeze({ areas: "boundary_area", labels: "boundary_label" }),
+  /** Properties present on `boundary_area` polygons. */
+  areaProperties: Object.freeze([
+    "class",
+    "class_tier",
+    "admin_level",
+    "admin_depth",
+    "ref",
+    "iso_3166_1"
+  ]),
+  maxzoom: 12,
+  minzoom: 0,
+  product: "boundaries-v1",
+  schemaVersion: 1,
+  tiers: tileflowBoundaryClassTiers
+});
+var tileflowBoundaryFamilies = Object.freeze({
+  boundaries: Object.freeze({
+    attribution: "\xA9 OpenStreetMap contributors",
+    license: "ODbL-1.0",
+    path: "/tiles/boundaries/tiles.json",
+    sourceId: "tileflow-boundaries"
+  })
+});
+function isTileflowBoundaryFamily(value) {
+  return typeof value === "string" && Object.hasOwn(tileflowBoundaryFamilies, value);
+}
+
+// src/boundary-areas/feature-state.ts
+function createBoundaryFeatureState(map, options = {}) {
+  const family = options.family ?? "boundaries";
+  if (!isTileflowBoundaryFamily(family)) {
+    throw new Error(`Unknown Tileflow Boundaries family: ${String(family)}.`);
+  }
+  const source = tileflowBoundaryFamilies[family].sourceId;
+  const stateKey = options.state?.trim() || "value";
+  const sourceLayers = [
+    tileflowBoundaryAreasV1Schema.layers.areas,
+    ...options.labels ? [tileflowBoundaryAreasV1Schema.layers.labels] : []
+  ];
+  let applied = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const write = (id, value) => {
+    for (const sourceLayer of sourceLayers) {
+      map.setFeatureState({ id, source, sourceLayer }, { [stateKey]: value });
+    }
+  };
+  const erase = (id) => {
+    for (const sourceLayer of sourceLayers) {
+      map.removeFeatureState({ id, source, sourceLayer }, stateKey);
+    }
+  };
+  const sourceReady = () => map.getSource(source) !== void 0;
+  let pendingReload = false;
+  const onStyleData = () => {
+    if (!sourceReady()) {
+      pendingReload = true;
+      return;
+    }
+    if (!pendingReload) return;
+    pendingReload = false;
+    for (const [id, value] of applied) write(id, value);
+  };
+  map.on("styledata", onStyleData);
+  const assertOpen = () => {
+    if (disposed) throw new Error("This Boundaries feature-state controller was disposed.");
+  };
+  return Object.freeze({
+    clear() {
+      assertOpen();
+      if (sourceReady()) for (const id of applied.keys()) erase(id);
+      applied = /* @__PURE__ */ new Map();
+    },
+    dispose() {
+      if (disposed) return;
+      if (sourceReady()) for (const id of applied.keys()) erase(id);
+      applied = /* @__PURE__ */ new Map();
+      map.off("styledata", onStyleData);
+      disposed = true;
+    },
+    set(values) {
+      assertOpen();
+      const featureKey = promotedKey(map, source) ?? "id";
+      if (values.joinBy !== featureKey) {
+        throw new Error(
+          `Boundaries feature-state is keyed by ${featureKey}; join the rows to ${featureKey} first with joinBoundaryRows.`
+        );
+      }
+      const next = /* @__PURE__ */ new Map();
+      for (const row of values.rows) {
+        if (row.value === null) continue;
+        if (featureKey === "id") {
+          if (typeof row.key !== "number" || !Number.isSafeInteger(row.key) || row.key < 0) {
+            throw new Error("Boundaries feature-state rows keyed by id need integer keys.");
+          }
+        } else if (typeof row.key !== "string" || !row.key) {
+          throw new Error("Boundaries feature-state rows keyed by ref need string keys.");
+        }
+        next.set(row.key, row.value);
+      }
+      if (sourceReady()) {
+        for (const id of applied.keys()) if (!next.has(id)) erase(id);
+        for (const [id, value] of next) if (applied.get(id) !== value) write(id, value);
+      } else {
+        pendingReload = true;
+      }
+      applied = next;
+    }
+  });
+}
+function promotedKey(map, source) {
+  const definition = map.getStyle?.()?.sources?.[source];
+  const promoteId = definition?.promoteId;
+  if (promoteId === void 0) return void 0;
+  const value = typeof promoteId === "string" ? promoteId : promoteId[tileflowBoundaryAreasV1Schema.layers.areas];
+  return value === "ref" ? "ref" : void 0;
+}
+
 // src/line-progress.ts
 var epsilon = 5e-4;
 var transparent = "rgba(0, 0, 0, 0)";
@@ -4808,13 +4961,14 @@ var tileflowDefaultBuildings3DDesign = Object.freeze({
   layers: Object.freeze({ building: "building", places: "poi" }),
   color: "#d8d0c0",
   edges: 0,
-  lighting: "style",
+  edgeRadius: 0.8,
+  lighting: "sun",
   colorVariation: 0,
   verticalGradient: true,
   nightLight: 0,
   windows: false,
-  shadows: false,
-  occlusion: false
+  shadows: true,
+  occlusion: true
 });
 function readTileflowBuildings3D(metadata) {
   if (!isRecord6(metadata)) return void 0;
@@ -4825,6 +4979,7 @@ function readTileflowBuildings3D(metadata) {
     return void 0;
   if (typeof color !== "string" && !Array.isArray(color)) return void 0;
   const within = (number, high, fallback) => typeof number === "number" && number >= 0 && number <= high ? number : fallback;
+  const defaults = tileflowDefaultBuildings3DDesign;
   return {
     source,
     layers: {
@@ -4833,14 +4988,15 @@ function readTileflowBuildings3D(metadata) {
     },
     color,
     edges: within(value.edges, 1, 0),
-    lighting: value.lighting === "sun" ? "sun" : "style",
+    edgeRadius: within(value.edgeRadius, 1, defaults.edgeRadius),
+    lighting: value.lighting === "style" ? "style" : defaults.lighting,
     colorVariation: within(value.colorVariation, 1, 0),
     verticalGradient: value.verticalGradient !== false,
     ...typeof value.edgeColor === "string" ? { edgeColor: value.edgeColor } : {},
     nightLight: within(value.nightLight, 2, 0),
     windows: value.windows === true,
-    shadows: value.shadows === true,
-    occlusion: value.occlusion === true,
+    shadows: typeof value.shadows === "boolean" ? value.shadows : defaults.shadows,
+    occlusion: typeof value.occlusion === "boolean" ? value.occlusion : defaults.occlusion,
     ...modelsOf(value.models),
     ...modelColorsOf(value.modelColors),
     ...landmarksOf(value.landmarks)
@@ -5829,10 +5985,12 @@ function meshTileflowBuildings(layer, options) {
   const scale = tileflowBuildingExtent / layer.extent;
   const metresPerUnit = options.tileMetres / tileflowBuildingExtent;
   const fallback = options.defaultHeight ?? 5;
+  const edgeRadius = Number.isFinite(options.edgeRadius) ? Math.max(0, Math.min(1, options.edgeRadius)) / metresPerUnit : 0;
   const vertices = new VertexWriter();
   const roofs = new IndexWriter();
   const walls = new IndexWriter();
   const features = [];
+  const parts = [];
   let tallest = 0;
   const uses = nightUsesOf(layer, options);
   for (const [featureIndex, feature] of layer.features.entries()) {
@@ -5848,16 +6006,35 @@ function meshTileflowBuildings(layer, options) {
     const index = features.length;
     let used = false;
     for (const polygon of polygonsOf(feature.geometry, scale)) {
-      const rings = polygon.map(clip).filter((ring) => ring.length >= 6);
+      let rings = polygon.map(clip).filter((ring) => ring.length >= 6);
       if (rings.length === 0 || area2(rings[0]) === 0) continue;
       const [cx, cy] = centroid(rings[0]);
       if (options.masks?.length && (tileflowInsideRings(options.masks, cx, cy) || tileflowRingsOverlap(rings, options.masks, maskMargin / metresPerUnit)))
         continue;
+      const part = {
+        cell: Math.min(7, Math.max(0, Math.floor(cy / 1024))) * 8 + Math.min(7, Math.max(0, Math.floor(cx / 1024))),
+        bounds: [Infinity, Infinity, -Infinity, -Infinity, height + 0.1],
+        roofsFrom: roofs.length,
+        roofsCount: 0,
+        wallsFrom: walls.length,
+        wallsCount: 0
+      };
+      for (const ring of rings)
+        for (let at = 0; at < ring.length; at += 2) {
+          part.bounds[0] = Math.min(part.bounds[0], ring[at] - 1);
+          part.bounds[1] = Math.min(part.bounds[1], ring[at + 1] - 1);
+          part.bounds[2] = Math.max(part.bounds[2], ring[at] + 1);
+          part.bounds[3] = Math.max(part.bounds[3], ring[at + 1] + 1);
+        }
       used = true;
       tallest = Math.max(tallest, height);
       const seed = hash(cx * 0.0731 + cy * 0.19137 + index * 1.618);
       const jitter = rings[0].some((value) => value <= 0 || value >= tileflowBuildingExtent) ? hash(height * 7.31 + base * 3.17 + tone) : seed;
       const building = { base, top: height, jitter, seed, tone, group, use, cx, cy, index };
+      const rounded = rings.map(
+        (ring, at) => roundCorners(ring, at, edgeRadius, options.cornerAngle)
+      );
+      rings = rounded.map(({ ring }) => ring);
       const roof = polygon.length === 1 && rings.length === 1 ? tileflowRoofOf(
         polygon[0],
         rings[0],
@@ -5869,6 +6046,7 @@ function meshTileflowBuildings(layer, options) {
       ) : void 0;
       if (roof) {
         tallest = Math.max(tallest, roof.ridge);
+        part.bounds[4] = Math.max(part.bounds[4], roof.ridge + 0.1);
         writeRoof(roof, building, vertices, roofs);
       } else {
         writeFlatRoof(rings, building, vertices, roofs);
@@ -5902,6 +6080,14 @@ function meshTileflowBuildings(layer, options) {
           if (length === 0 || onBorder(ax, ay, bx, by)) continue;
           const normalX = -(by - ay) / length * outward;
           const normalY = (bx - ax) / length * outward;
+          const startNormal = rounded[ringIndex].normals[at] ?? [normalX, normalY];
+          const endNormal = rounded[ringIndex].normals[(at + 1) % points] ?? [normalX, normalY];
+          const normalAt = (share3) => {
+            const x3 = startNormal[0] + (endNormal[0] - startNormal[0]) * share3;
+            const y2 = startNormal[1] + (endNormal[1] - startNormal[1]) * share3;
+            const length2 = Math.hypot(x3, y2) || 1;
+            return [x3 / length2, y2 / length2];
+          };
           const shares = [0, ...roof ? roof.breaks(ax, ay, bx, by) : [], 1];
           for (let piece = 0; piece + 1 < shares.length; piece += 1) {
             const first = piece === 0;
@@ -5914,6 +6100,8 @@ function meshTileflowBuildings(layer, options) {
             const corners = (first && tight(at) ? 1 : 0) | (last && tight(at + 1) ? 2 : 0) | (ringIndex > 0 ? 4 : 0);
             const cut = (first && onEdge(ax, ay) ? 1 : 0) | (last && onEdge(bx, by) ? 2 : 0);
             const end = along + metres;
+            const sn = normalAt(shares[piece]);
+            const en = normalAt(shares[piece + 1]);
             const startTop = topAt(sx, sy);
             const endTop = topAt(ex, ey);
             const v2 = vertices.write(
@@ -5921,8 +6109,8 @@ function meshTileflowBuildings(layer, options) {
               sx,
               sy,
               0,
-              normalX,
-              normalY,
+              sn[0],
+              sn[1],
               1,
               along,
               corners,
@@ -5936,8 +6124,8 @@ function meshTileflowBuildings(layer, options) {
               ex,
               ey,
               0,
-              normalX,
-              normalY,
+              en[0],
+              en[1],
               1,
               end,
               corners,
@@ -5951,8 +6139,8 @@ function meshTileflowBuildings(layer, options) {
               sx,
               sy,
               1,
-              normalX,
-              normalY,
+              sn[0],
+              sn[1],
               1,
               along,
               corners,
@@ -5966,8 +6154,8 @@ function meshTileflowBuildings(layer, options) {
               ex,
               ey,
               1,
-              normalX,
-              normalY,
+              en[0],
+              en[1],
               1,
               end,
               corners,
@@ -5981,14 +6169,44 @@ function meshTileflowBuildings(layer, options) {
           }
         }
       }
+      part.roofsCount = roofs.length - part.roofsFrom;
+      part.wallsCount = walls.length - part.wallsFrom;
+      parts.push(part);
     }
     if (used) features.push(properties);
   }
   if (vertices.count === 0) return void 0;
   const indices = new Uint32Array(roofs.length + walls.length);
-  indices.set(roofs.values());
-  indices.set(walls.values(), roofs.length);
+  const groups = [];
+  let roofAt = 0;
+  let wallAt = roofs.length;
+  const roofIndices = roofs.values();
+  const wallIndices = walls.values();
+  parts.sort((a, b2) => a.cell - b2.cell);
+  let cell = -1;
+  for (const part of parts) {
+    if (part.cell !== cell) {
+      cell = part.cell;
+      groups.push({
+        bounds: [...part.bounds],
+        roofsFrom: roofAt,
+        roofsCount: 0,
+        wallsFrom: wallAt,
+        wallsCount: 0
+      });
+    }
+    const group = groups.at(-1);
+    for (let axis = 0; axis < 5; axis += 1)
+      group.bounds[axis] = axis < 2 ? Math.min(group.bounds[axis], part.bounds[axis]) : Math.max(group.bounds[axis], part.bounds[axis]);
+    indices.set(roofIndices.subarray(part.roofsFrom, part.roofsFrom + part.roofsCount), roofAt);
+    indices.set(wallIndices.subarray(part.wallsFrom, part.wallsFrom + part.wallsCount), wallAt);
+    roofAt += part.roofsCount;
+    wallAt += part.wallsCount;
+    group.roofsCount += part.roofsCount;
+    group.wallsCount += part.wallsCount;
+  }
   return {
+    groups,
     vertices: vertices.bytes(),
     indices,
     wallsFrom: roofs.length,
@@ -6075,6 +6293,68 @@ function writeRoof(roof, building, vertices, roofs) {
     }
   }
 }
+function roundCorners(ring, ringIndex, radius, cornerAngle = Math.PI / 6) {
+  if (radius < 1) return { ring, normals: [] };
+  const points = ring.length / 2;
+  const left = area2(ring) > 0;
+  const outward = ringIndex === 0 ? left ? -1 : 1 : left ? 1 : -1;
+  const result = [];
+  const normals = [];
+  const append = (x3, y2, normal) => {
+    x3 = clampUnit(x3);
+    y2 = clampUnit(y2);
+    if (result.at(-2) === x3 && result.at(-1) === y2) return;
+    result.push(x3, y2);
+    normals.push(normal);
+  };
+  for (let at = 0; at < points; at += 1) {
+    const before = (at + points - 1) % points;
+    const after = (at + 1) % points;
+    const [px, py] = [ring[before * 2], ring[before * 2 + 1]];
+    const [x3, y2] = [ring[at * 2], ring[at * 2 + 1]];
+    const [nx, ny] = [ring[after * 2], ring[after * 2 + 1]];
+    const incoming = Math.hypot(x3 - px, y2 - py);
+    const outgoing = Math.hypot(nx - x3, ny - y2);
+    if (!incoming || !outgoing || onEdge(x3, y2) || onBorder(px, py, x3, y2) || onBorder(x3, y2, nx, ny)) {
+      append(x3, y2);
+      continue;
+    }
+    const [ix, iy] = [(x3 - px) / incoming, (y2 - py) / incoming];
+    const [ox, oy] = [(nx - x3) / outgoing, (ny - y2) / outgoing];
+    const turn = Math.atan2(ix * oy - iy * ox, ix * ox + iy * oy);
+    if (turn * outward >= -0.08 || Math.abs(turn) > Math.PI * 0.85) {
+      append(x3, y2);
+      continue;
+    }
+    const tangent = Math.tan(Math.abs(turn) / 2);
+    const reach = Math.min(radius * tangent, incoming * 0.2, outgoing * 0.2);
+    const actualRadius = reach / tangent;
+    if (actualRadius < 1) {
+      append(x3, y2);
+      continue;
+    }
+    const [normalX, normalY] = [-iy * outward, ix * outward];
+    const [cx, cy] = [
+      x3 - ix * reach - normalX * actualRadius,
+      y2 - iy * reach - normalY * actualRadius
+    ];
+    const start = Math.atan2(normalY, normalX);
+    const steps = Math.max(
+      cornerAngle <= Math.PI / 6 ? 2 : 1,
+      Math.ceil(Math.abs(turn) / Math.max(Math.PI / 6, Math.min(Math.PI / 3, cornerAngle)))
+    );
+    for (let step = 0; step <= steps; step += 1) {
+      const angle = start + turn * step / steps;
+      const normal = [Math.cos(angle), Math.sin(angle)];
+      append(cx + normal[0] * actualRadius, cy + normal[1] * actualRadius, normal);
+    }
+  }
+  if (result[0] === result.at(-2) && result[1] === result.at(-1)) {
+    result.splice(-2);
+    normals.pop();
+  }
+  return result.length >= 6 ? { ring: result, normals } : { ring, normals: [] };
+}
 var VertexWriter = class {
   #buffer = new ArrayBuffer(4096 * tileflowBuildingVertexBytes);
   #view = new DataView(this.#buffer);
@@ -6293,6 +6573,330 @@ function hash(value) {
   return s - Math.floor(s);
 }
 
+// src/buildings-3d-mesher.ts
+function browserWorker() {
+  if (typeof Worker === "undefined" || false)
+    return;
+  const url = URL.createObjectURL(
+    new Blob(['"use strict";(()=>{var An=new Set,Dn=!1;function kn(n,e,t=2){let s=e&&e.length,o=s?e[0]*t:n.length;An.size&&An.clear();let r=he(n,0,o,t,!0),i=[];if(!r||r.next===r.prev)return i;let u=0,l=0,c=0;if(s&&(r=_e(n,e,r,t)),n.length>80*t){u=n[0],l=n[1];let a=u,f=l;for(let h=t;h<o;h+=t){let m=n[h],b=n[h+1];m<u&&(u=m),b<l&&(l=b),m>a&&(a=m),b>f&&(f=b)}c=Math.max(a-u,f-l),c=c!==0?32767/c:0}return Wn(r,i,u,l,c),i}function he(n,e,t,s,o){let r=null;if(o===Ye(n,e,t,s)>0)for(let i=e;i<t;i+=s)r=fe(i/s|0,n[i],n[i+1],r);else for(let i=t-s;i>=e;i-=s)r=fe(i/s|0,n[i],n[i+1],r);return r&&In(r,r.next)&&(Tn(r),r=r.next),r}function fn(n,e=n){let t=e===n,s=n,o;do o=!1,s!==s.next&&(An.size===0||!An.has(s))&&(In(s,s.next)||O(s.prev,s,s.next)===0)?((t||s===e)&&(e=s.prev),Dn=!0,Tn(s),s=s.prev,o=!0):(t||s!==e)&&(s=s.next,o=!t);while(o||s!==e);return e}function Wn(n,e,t,s,o){o&&Se(n,t,s,o);let r=n,i=!1;for(;n.prev!==n.next;){let u=n.prev,l=n.next;if(O(u,n,l)<0&&(o?ke(n,t,s,o):Te(n))){e.push(u.i,n.i,l.i),Tn(n),n=l,r=l;continue}if(n=l,n===r){if(Dn=!1,n=fn(n),Dn){r=n;continue}if(!i){n=Be(n,e),r=n,i=!0;continue}Fe(n,e,t,s,o);break}}}function Te(n){let e=n.prev,t=n,s=n.next,o=e.x,r=t.x,i=s.x,u=e.y,l=t.y,c=s.y,a=Math.min(o,r,i),f=Math.min(u,l,c),h=Math.max(o,r,i),m=Math.max(u,l,c),b=s.next;for(;b!==e;){if(b.x>=a&&b.x<=h&&b.y>=f&&b.y<=m&&!(o===b.x&&u===b.y)&&Vn(o,u,r,l,i,c,b.x,b.y)&&O(b.prev,b,b.next)>=0)return!1;b=b.next}return!0}function ke(n,e,t,s){let o=n.prev,r=n,i=n.next,u=o.x,l=r.x,c=i.x,a=o.y,f=r.y,h=i.y,m=Math.min(u,l,c),b=Math.min(a,f,h),d=Math.max(u,l,c),x=Math.max(a,f,h),I=$n(m,b,e,t,s),B=$n(d,x,e,t,s),M=n.prevZ;for(;M&&M.z>=I;){if(M.x>=m&&M.x<=d&&M.y>=b&&M.y<=x&&M!==i&&!(u===M.x&&a===M.y)&&Vn(u,a,l,f,c,h,M.x,M.y)&&O(M.prev,M,M.next)>=0)return!1;M=M.prevZ}let y=n.nextZ;for(;y&&y.z<=B;){if(y.x>=m&&y.x<=d&&y.y>=b&&y.y<=x&&y!==i&&!(u===y.x&&a===y.y)&&Vn(u,a,l,f,c,h,y.x,y.y)&&O(y.prev,y,y.next)>=0)return!1;y=y.nextZ}return!0}function Be(n,e){let t=n,s=!1;do{let o=t.prev,r=t.next.next;xe(o,t,t.next,r,!1)&&Un(o,r)&&Un(r,o)&&(e.push(o.i,t.i,r.i),Tn(t),Tn(t.next),t=n=r,s=!0),t=t.next}while(t!==n);return s?fn(t):t}function Fe(n,e,t,s,o){let r=n;do{let i=r.next.next;for(;i!==r.prev;){if(r.i!==i.i&&He(r,i)){let u=de(r,i);r=fn(r,r.next),u=fn(u,u.next),Wn(r,e,t,s,o),Wn(u,e,t,s,o);return}i=i.next}r=r.next}while(r!==n)}var Kn=!1;function _e(n,e,t,s){let o=[];for(let r=0,i=e.length;r<i;r++){let u=e[r]*s,l=r<i-1?e[r+1]*s:n.length,c=he(n,u,l,s,!1);c===c.next&&An.add(c),o.push(Ee(c))}o.sort(Pe),Le(n.length/s,e.length),be(t,t),Kn=!0;for(let r=0;r<o.length;r++)t=Oe(o[r],t);return Kn=!1,fn(t)}function Pe(n,e){return n.x-e.x||n.y-e.y||(n.next.y-n.y)/(n.next.x-n.x)-(e.next.y-e.y)/(e.next.x-e.x)}function Oe(n,e){let t=ze(n,e);if(!t)return e;let s=de(t,n),o=s.next;return be(t,o.next),fn(s,s.next),fn(t,t.next)}var me=16,_=new Float64Array(0),Nn=0,Jn=[],Qn=[];function Le(n,e){let t=Math.ceil((n+2*e)/me)+e+2;_.length<t*4&&(_=new Float64Array(t*4)),Nn=0}function be(n,e){let t=n;do{let s=Nn++;Jn[s]=t;let o=t.x,r=t.y,i=t.x,u=t.y,l=0;do{let a=t.next;t.z=s,a.x<o&&(o=a.x),a.x>i&&(i=a.x),a.y<r&&(r=a.y),a.y>u&&(u=a.y),t=a}while(++l<me&&t!==e);Qn[s]=t;let c=s*4;_[c]=o,_[c+1]=r,_[c+2]=i,_[c+3]=u}while(t!==e)}function Ce(n,e){let t=n.z*4;e.x<_[t]&&(_[t]=e.x),e.y<_[t+1]&&(_[t+1]=e.y),e.x>_[t+2]&&(_[t+2]=e.x),e.y>_[t+3]&&(_[t+3]=e.y)}function ce(n){let e=Qn[n];for(;e.prev.next!==e;)e=e.next;return Qn[n]=e,e}function ae(n){let e=Jn[n];for(;e.prev.next!==e;)e=e.next;return Jn[n]=e,e}function ze(n,e){let t=e,s=n.x,o=n.y,r=-1/0,i;if(In(n,t))return t;for(let h=0,m=0;h<Nn;h++,m+=4){if(o<_[m+1]||o>_[m+3]||_[m]>s||_[m+2]<=r)continue;let b=ce(h);t=ae(h);do{if(t.prev.next===t){if(In(n,t.next))return t.next;if(o<=t.y&&o>=t.next.y&&t.next.y!==t.y){let d=t.x+(o-t.y)*(t.next.x-t.x)/(t.next.y-t.y);if(d<=s&&d>r&&(r=d,i=t.x<t.next.x?t:t.next,d===s))return i}}t=t.next}while(t!==b)}if(!i)return null;let u=i.x,l=i.y,c=Math.min(o,l),a=Math.max(o,l),f=1/0;for(let h=0,m=0;h<Nn;h++,m+=4){if(_[m+2]<u||_[m]>s||_[m+3]<c||_[m+1]>a)continue;let b=ce(h);t=ae(h);do{if(t.prev.next===t&&s>=t.x&&t.x>=u&&s!==t.x&&Vn(o<l?s:r,o,u,l,o<l?r:s,o,t.x,t.y)){let d=Math.abs(o-t.y)/(s-t.x);(Un(t,n)||t.y===o&&t.next.y===o&&t.next.x>s)&&(d<f||d===f&&(t.x>i.x||t.x===i.x&&Ze(i,t)))&&(i=t,f=d)}t=t.next}while(t!==b)}return i}function Ze(n,e){return O(n.prev,n,e.prev)<0&&O(e.next,n,n.next)<0}var K=[],dn=[],an=new Uint32Array(0),vn=new Uint32Array(0),Rn=new Uint32Array(256);function Se(n,e,t,s){let o=n,r=0;do o.z=$n(o.x,o.y,e,t,s),K[r++]=o,o=o.next;while(o!==n);je(r);let i=null;for(let u=0;u<r;u++){let l=K[u];l.prevZ=i,i&&(i.nextZ=l),i=l}i.nextZ=null,K.fill(null,0,r),dn.fill(null,0,r)}function je(n){if(n<=32){for(let e=1;e<n;e++){let t=K[e],s=t.z,o=e-1;for(;o>=0&&K[o].z>s;)K[o+1]=K[o],o--;K[o+1]=t}return}an.length<n&&(an=new Uint32Array(n),vn=new Uint32Array(n),dn=new Array(n));for(let e=0;e<n;e++)an[e]=K[e].z;En(n,K,an,dn,vn,0),En(n,dn,vn,K,an,8),En(n,K,an,dn,vn,16),En(n,dn,vn,K,an,24)}function En(n,e,t,s,o,r){Rn.fill(0);for(let u=0;u<n;u++)Rn[t[u]>>>r&255]++;let i=0;for(let u=0;u<256;u++){let l=Rn[u];Rn[u]=i,i+=l}for(let u=0;u<n;u++){let l=t[u],c=Rn[l>>>r&255]++;s[c]=e[u],o[c]=l}}function $n(n,e,t,s,o){return n=(n-t)*o|0,e=(e-s)*o|0,n=(n|n<<8)&16711935,n=(n|n<<4)&252645135,n=(n|n<<2)&858993459,n=(n|n<<1)&1431655765,e=(e|e<<8)&16711935,e=(e|e<<4)&252645135,e=(e|e<<2)&858993459,e=(e|e<<1)&1431655765,n|e<<1}function Ee(n){let e=n,t=n;do(e.x<t.x||e.x===t.x&&e.y<t.y)&&(t=e),e=e.next;while(e!==n);return t}function Vn(n,e,t,s,o,r,i,u){return(o-i)*(e-u)>=(n-i)*(r-u)&&(n-i)*(s-u)>=(t-i)*(e-u)&&(t-i)*(r-u)>=(o-i)*(s-u)}function He(n,e){let t=In(n,e)&&O(n.prev,n,n.next)>0&&O(e.prev,e,e.next)>0;return n.next.i!==e.i&&(t||Un(n,e)&&Un(e,n)&&(O(n.prev,n,e.prev)!==0||O(n,e.prev,e)!==0))&&!Ne(n,e)&&(t||Ve(n,e))}function O(n,e,t){return(e.y-n.y)*(t.x-e.x)-(e.x-n.x)*(t.y-e.y)}function In(n,e){return n.x===e.x&&n.y===e.y}function xe(n,e,t,s,o=!0){let r=O(n,e,t),i=O(n,e,s),u=O(t,s,n),l=O(t,s,e);return(r>0&&i<0||r<0&&i>0)&&(u>0&&l<0||u<0&&l>0)?!0:o?!!(r===0&&Hn(n,t,e)||i===0&&Hn(n,s,e)||u===0&&Hn(t,n,s)||l===0&&Hn(t,e,s)):!1}function Hn(n,e,t){return e.x<=Math.max(n.x,t.x)&&e.x>=Math.min(n.x,t.x)&&e.y<=Math.max(n.y,t.y)&&e.y>=Math.min(n.y,t.y)}function Ne(n,e){let t=Math.min(n.x,e.x),s=Math.max(n.x,e.x),o=Math.min(n.y,e.y),r=Math.max(n.y,e.y),i=n;do{let u=i.next;if(i.x>s&&u.x>s||i.x<t&&u.x<t||i.y>r&&u.y>r||i.y<o&&u.y<o){i=u;continue}if(i.i!==n.i&&u.i!==n.i&&i.i!==e.i&&u.i!==e.i&&xe(i,u,n,e))return!0;i=u}while(i!==n);return!1}function Un(n,e){return O(n.prev,n,n.next)<0?O(n,e,n.next)>=0&&O(n,n.prev,e)>=0:O(n,e,n.prev)<0||O(n,n.next,e)<0}function Ve(n,e){let t=n,s=!1,o=(n.x+e.x)/2,r=(n.y+e.y)/2;do{let i=t.next;t.y>r!=i.y>r&&o<(i.x-t.x)*(r-t.y)/(i.y-t.y)+t.x&&(s=!s),t=i}while(t!==n);return s}function de(n,e){let t=qn(n.i,n.x,n.y),s=qn(e.i,e.x,e.y),o=n.next,r=e.prev;return n.next=e,e.prev=n,t.next=o,o.prev=t,s.next=t,t.prev=s,r.next=s,s.prev=r,s}function fe(n,e,t,s){let o=qn(n,e,t);return s?(o.next=s.next,o.prev=s,s.next.prev=o,s.next=o):(o.prev=o,o.next=o),o}function Tn(n){n.next.prev=n.prev,n.prev.next=n.next,n.prevZ&&(n.prevZ.nextZ=n.nextZ),n.nextZ&&(n.nextZ.prevZ=n.prevZ),Kn&&Ce(n.prev,n.next)}function qn(n,e,t){return{i:n,x:e,y:t,prev:null,next:null,z:0,prevZ:null,nextZ:null}}function Ye(n,e,t,s){let o=0;for(let r=e,i=t-s;r<t;r+=s)o+=(n[i]-n[r])*(n[r+1]+n[i+1]),i=r;return o}var Xe=.7,Ge=Math.tan(Math.PI/6),De=Math.tan(35*Math.PI/180),We=Math.tan(Math.PI/18),Bn=.65,Fn=.4;function Me(n,e,t,s,o,r,i){let u=String(t.roof_shape??"");if(!u||u==="flat"||u==="sawtooth"||qe(n,i))return;let l=Qe(n);if(!l||Math.abs(ne(n))<Xe*4*l.halfU*l.halfV)return;let c=l.u,a=l.v,f=l.halfU*r,h=l.halfV*r;f<h&&([c,a,f,h]=[a,c,h,f]);let m=ge(t.roof_direction),b=m===void 0?void 0:[Math.sin(m*Math.PI/180),-Math.cos(m*Math.PI/180)];(b!==void 0?Math.abs(b[0]*c[0]+b[1]*c[1])>Math.abs(b[0]*a[0]+b[1]*a[1]):t.roof_orientation==="across")&&u!=="skillion"&&([c,a,f,h]=[a,c,h,f]);let x=Je(u,f,h,b&&[pe(b,c),pe(b,a)]);if(!x)return;let I=Math.max(0,o-s),B=ge(t.roof_height),M,y;if(B!==void 0&&B>0)y=o,M=Math.max(s+Math.min(2,I/2),o-B);else{let p=Math.min(Ke(u,h),I*.6,30);t.height_source==="height"?(y=o,M=o-p):(M=o,y=o+p)}let k=y-M;if(!(k>=.3))return;let[R,N]=l.centre,F=(p,A)=>{let v=(p-R)*r,g=(A-N)*r;return[v*c[0]+g*c[1],v*a[0]+g*a[1]]},S=(p,A)=>[R+(p*c[0]+A*a[0])/r,N+(p*c[1]+A*a[1])/r],J=(p,A)=>{let v=1/0;for(let[g,E,H]of x)v=Math.min(v,g*p+E*A+H);return Math.max(0,v)},Q=(p,A)=>M+k*J(...F(p,A)),L=[];for(let p=0;p+1<e.length;p+=2)L.push(...F(e[p],e[p+1]));ne(L)<0&&nt(L);let C=1.01,$=[-f*C,-h*C,f*C,-h*C,f*C,h*C,-f*C,h*C],V=[];for(let[p,A]of x.entries()){let v=$;for(let[T,j]of x.entries()){if(T===p)continue;let z=A[0]-j[0],nn=A[1]-j[1],en=A[2]-j[2];if(Math.abs(z)+Math.abs(nn)+Math.abs(en)<1e-9){T<p&&(v=[]);continue}if(v=ye(v,z,nn,en),v.length<6)break}if(v.length<6)continue;let g=L,E=v.length/2;for(let T=0;T<E&&g.length>=6;T+=1){let[j,z]=[v[T*2],v[T*2+1]],[nn,en]=[v[(T+1)%E*2],v[(T+1)%E*2+1]];g=ye(g,en-z,j-nn,-(en-z)*j-(j-nn)*z)}if(g.length<6||Math.abs(ne(g))<1e-6)continue;let H=[];for(let T=0;T<g.length;T+=2)H.push(...S(g[T],g[T+1]));let q=kn(H);if(q.length===0)continue;let on=k*A[0],Y=k*A[1],w=on*c[0]+Y*a[0],U=on*c[1]+Y*a[1],rn=Math.hypot(w,U,1);V.push({ring:H,triangles:q,normal:[-w/rn,-U/rn]})}if(V.length!==0)return{eaves:M,ridge:y,faces:V,heightAt:Q,breaks(p,A,v,g){let[E,H]=F(p,A),[q,on]=F(v,g),Y=[];for(let w=0;w<x.length;w+=1)for(let U=w+1;U<x.length;U+=1){let rn=(Z,P)=>(x[w][0]-x[U][0])*Z+(x[w][1]-x[U][1])*P+(x[w][2]-x[U][2]),T=rn(E,H),j=rn(q,on);if(T===j||T*j>0)continue;let z=T/(T-j);if(z<=1e-4||z>=1-1e-4)continue;let nn=E+(q-E)*z,en=H+(on-H)*z;x[w][0]*nn+x[w][1]*en+x[w][2]<=J(nn,en)+1e-6&&Y.push(z)}return[...new Set(Y.map(w=>Math.round(w*1e6)/1e6))].sort((w,U)=>w-U)}}}function Ke(n,e){switch(n){case"skillion":return 2*e*We;case"pyramidal":return e*De;case"gambrel":case"mansard":return e*.8;case"dome":case"onion":case"round":return e;default:return e*Ge}}function Je(n,e,t,s){let o=e,r=t,i=[[0,-1/r,1],[0,1/r,1]],u=c=>c.flatMap(a=>[1,-1].flatMap(f=>{let h=a==="v"?r:o,m=Bn/(Fn*r)*f,b=(1-Bn)/((1-Fn)*r)*f,d=x=>a==="v"?[0,-x]:[-x,0];return[[...d(m),Bn/(Fn*r)*h],[...d(b),Bn+(1-Bn)/((1-Fn)*r)*(h-Fn*r)]]})),l=[.99,.8,.5,.2];switch(n){case"gabled":return i;case"saltbox":{let c=r/3;return[[0,-1/(r-c),1+c/(r-c)],[0,1/(r+c),1-c/(r+c)]]}case"hipped":return[...i,[-1/r,0,o/r],[1/r,0,o/r]];case"half_hipped":return[...i,[-1/r,0,.5+o/r],[1/r,0,.5+o/r]];case"pyramidal":return[...i,[-1/o,0,1],[1/o,0,1]];case"gambrel":return u(["v"]);case"mansard":return u(["v","u"]);case"skillion":{let[c,a]=s??[0,1],f=Math.abs(c)*o+Math.abs(a)*r;return f>0?[[-c/(2*f),-a/(2*f),.5]]:void 0}case"round":return[[0,0,1],...l.flatMap(c=>{let a=Math.sqrt(1-c*c);return[1,-1].map(f=>[0,-f*c/(r*a),1/a])})];case"dome":case"onion":return[[0,0,1],...l.flatMap(c=>{let a=Math.sqrt(1-c*c);return Array.from({length:12},(f,h)=>{let m=h*Math.PI/6;return[-c*Math.cos(m)/(o*a),-c*Math.sin(m)/(r*a),1/a]})})];default:return}}function ye(n,e,t,s){let o=n.length/2,r=[];for(let i=0;i<o;i+=1){let u=n[i*2],l=n[i*2+1],c=n[(i+1)%o*2],a=n[(i+1)%o*2+1],f=e*u+t*l+s,h=e*c+t*a+s;if(f<=0&&r.push(u,l),f<0&&h>0||f>0&&h<0){let m=f/(f-h);r.push(u+(c-u)*m,l+(a-l)*m)}}return r}function Qe(n){let e=$e(n);if(e.length<3)return;let t,s=1/0;for(let o=0;o<e.length;o+=1){let[r,i]=e[o],[u,l]=e[(o+1)%e.length],c=Math.hypot(u-r,l-i);if(c===0)continue;let a=[(u-r)/c,(l-i)/c],f=[-a[1],a[0]],[h,m,b,d]=[1/0,-1/0,1/0,-1/0];for(let[I,B]of e){let M=I*a[0]+B*a[1],y=I*f[0]+B*f[1];h=Math.min(h,M),m=Math.max(m,M),b=Math.min(b,y),d=Math.max(d,y)}let x=(m-h)*(d-b);if(x<s){s=x;let I=(h+m)/2,B=(b+d)/2;t={centre:[I*a[0]+B*f[0],I*a[1]+B*f[1]],u:a,v:f,halfU:(m-h)/2,halfV:(d-b)/2}}}return t&&t.halfU>0&&t.halfV>0?t:void 0}function $e(n){let e=[];for(let r=0;r+1<n.length;r+=2)e.push([n[r],n[r+1]]);e.sort((r,i)=>r[0]-i[0]||r[1]-i[1]);let t=(r,i,u)=>(i[0]-r[0])*(u[1]-r[1])-(i[1]-r[1])*(u[0]-r[0]),s=[];for(let r of e){for(;s.length>=2&&t(s.at(-2),s.at(-1),r)<=0;)s.pop();s.push(r)}let o=[];for(let r of e.reverse()){for(;o.length>=2&&t(o.at(-2),o.at(-1),r)<=0;)o.pop();o.push(r)}return[...s.slice(0,-1),...o.slice(0,-1)]}function qe(n,e){let[t,s,o,r]=[1/0,-1/0,1/0,-1/0];for(let u=0;u+1<n.length;u+=2)t=Math.min(t,n[u]),s=Math.max(s,n[u]),o=Math.min(o,n[u+1]),r=Math.max(r,n[u+1]);let i=n.length/2;for(let u=0;u<i;u+=1){let l=n[u*2],c=n[u*2+1],a=n[(u+1)%i*2],f=n[(u+1)%i*2+1];if(t<0&&l===t&&a===t||s>e&&l===s&&a===s||o<0&&c===o&&f===o||r>e&&c===r&&f===r)return!0}return!1}function ne(n){let e=0,t=n.length/2;for(let s=0;s<t;s+=1){let o=(s+1)%t;e+=n[s*2]*n[o*2+1]-n[o*2]*n[s*2+1]}return e/2}function nt(n){let e=[];for(let t=0;t<n.length;t+=2)e.push([n[t],n[t+1]]);e.reverse(),n.splice(0,n.length,...e.flat())}function pe(n,e){return n[0]*e[0]+n[1]*e[1]}function ge(n){let e=typeof n=="string"?Number(n):n;return typeof e=="number"&&Number.isFinite(e)?e:void 0}var gt=Object.freeze({surface:0,secondary:1,glass:2,accent:3,roof:4}),Mt=Object.freeze({levels:3,vertices:2e5,triangles:2e5,footprintPoints:4096,radius:2e3,height:1e3,models:512,bytes:16*1024*1024});function ee(n,e,t){for(let s of n){let o=!1;for(let r=0,i=s.length-2;r<s.length;i=r,r+=2){let u=s[r],l=s[r+1],c=s[i],a=s[i+1];l>t!=a>t&&e<(c-u)*(t-l)/(a-l)+u&&(o=!o)}if(o)return!0}return!1}function Re(n,e,t){for(let s of e){let[o,r,i,u]=ve(s);for(let l of n){let[c,a,f,h]=ve(l);if(!(c>i-t||f<o+t||a>u-t||h<r+t)&&(we(l,s,t)||we(s,l,t)))return!0}}return!1}function we(n,e,t){let s=(o,r)=>ee([e],o,r)&&tt(e,o,r)>t;for(let o=0;o+1<n.length;o+=2)if(s(n[o],n[o+1]))return!0;for(let o=0,r=n.length-2;o<n.length;r=o,o+=2){let[i,u,l,c]=[n[r],n[r+1],n[o],n[o+1]],a=[0,1];for(let f=0,h=e.length-2;f<e.length;h=f,f+=2){let m=et(i,u,l,c,e[h],e[h+1],e[f],e[f+1]);m!==void 0&&a.push(m)}if(a.length!==2){a.sort((f,h)=>f-h);for(let f=1;f<a.length;f+=1){let h=(a[f-1]+a[f])/2;if(s(i+(l-i)*h,u+(c-u)*h))return!0}}}return!1}function et(n,e,t,s,o,r,i,u){let l=t-n,c=s-e,a=i-o,f=u-r,h=l*f-c*a;if(h===0)return;let m=((o-n)*f-(r-e)*a)/h,b=((o-n)*c-(r-e)*l)/h;return m>0&&m<1&&b>=0&&b<=1?m:void 0}function tt(n,e,t){let s=1/0;for(let o=0,r=n.length-2;o<n.length;r=o,o+=2){let[i,u,l,c]=[n[r],n[r+1],n[o],n[o+1]],a=(l-i)**2+(c-u)**2,f=a>0?Math.max(0,Math.min(1,((e-i)*(l-i)+(t-u)*(c-u))/a)):0;s=Math.min(s,Math.hypot(e-(i+(l-i)*f),t-(u+(c-u)*f)))}return s}function ve(n){let[e,t,s,o]=[1/0,1/0,-1/0,-1/0];for(let r=0;r+1<n.length;r+=2)e=Math.min(e,n[r]),s=Math.max(s,n[r]),t=Math.min(t,n[r+1]),o=Math.max(o,n[r+1]);return[e,t,s,o]}var tn=8192,te=28,ot={commercial:1,active:2,destination:3},rt={residential:1,...Object.fromEntries(["civic","commercial","education","entertainment","medical","transportation"].map(n=>[n,2])),...Object.fromEntries(["agricultural","industrial","military","outbuilding","religious","service"].map(n=>[n,3]))},st={dining:1,entertainment:2,nightlife:3},oe={...Object.fromEntries(["alcoholic_beverage_venue","bar","beer","biergarten","brewery","casino","cocktail_bar","dance_club","karaoke","lounge","music_venue","night_club","nightclub","pub","wine_bar"].map(n=>[n,3])),...Object.fromEntries(["arts_centre","bowling_alley","cinema","comedy_club","concert_hall","movie_theater","opera","performing_arts_venue","theater","theatre","theatre_venue"].map(n=>[n,2])),...Object.fromEntries(["casual_eatery","fast_food","fast_food_restaurant","food_court","restaurant"].map(n=>[n,1]))},ut=6,it=.5,lt=.5;function Ue(n,e){let t=tn/n.extent,s=e.tileMetres/tn,o=e.defaultHeight??5,r=Number.isFinite(e.edgeRadius)?Math.max(0,Math.min(1,e.edgeRadius))/s:0,i=new re,u=new Yn,l=new Yn,c=[],a=[],f=0,h=ht(n,e);for(let[y,k]of n.features.entries()){if(k.type!=="Polygon"||c.length>=65535)continue;let R=k.properties,N=R.hide_3d;if(N===!0||N===1||N==="1"||N==="true")continue;let F=Math.min(6e3,Ae(R.render_height)??o),S=Math.min(F,Ae(R.render_min_height)??0),J=ot[String(R.building_tone??"")]??0,Q=rt[String(R.class??"")]??0,L=h.get(y)??0,C=c.length,$=!1;for(let V of mt(k.geometry,t)){let p=V.map(xt).filter(w=>w.length>=6);if(p.length===0||Xn(p[0])===0)continue;let[A,v]=bt(p[0]);if(e.masks?.length&&(ee(e.masks,A,v)||Re(p,e.masks,lt/s)))continue;let g={cell:Math.min(7,Math.max(0,Math.floor(v/1024)))*8+Math.min(7,Math.max(0,Math.floor(A/1024))),bounds:[1/0,1/0,-1/0,-1/0,F+.1],roofsFrom:u.length,roofsCount:0,wallsFrom:l.length,wallsCount:0};for(let w of p)for(let U=0;U<w.length;U+=2)g.bounds[0]=Math.min(g.bounds[0],w[U]-1),g.bounds[1]=Math.min(g.bounds[1],w[U+1]-1),g.bounds[2]=Math.max(g.bounds[2],w[U]+1),g.bounds[3]=Math.max(g.bounds[3],w[U+1]+1);$=!0,f=Math.max(f,F);let E=Ie(A*.0731+v*.19137+C*1.618),H=p[0].some(w=>w<=0||w>=tn)?Ie(F*7.31+S*3.17+J):E,q={base:S,top:F,jitter:H,seed:E,tone:J,group:Q,use:L,cx:A,cy:v,index:C},on=p.map((w,U)=>ft(w,U,r,e.cornerAngle));p=on.map(({ring:w})=>w);let Y=V.length===1&&p.length===1?Me(V[0],p[0],R,S,F,s,tn):void 0;Y?(f=Math.max(f,Y.ridge),g.bounds[4]=Math.max(g.bounds[4],Y.ridge+.1),at(Y,q,i,u)):ct(p,q,i,u);for(let[w,U]of p.entries()){let rn=Xn(U)>0,T=w===0?rn?-1:1:rn?1:-1,j=U.length/2,z=Z=>{let P=(Z%j+j)%j;return[U[P*2],U[P*2+1]]},nn=Z=>{let[P,D]=z(Z-1),[X,G]=z(Z),[un,mn]=z(Z+1);if(hn(P,D,X,G)||hn(X,G,un,mn))return!1;let bn=Math.hypot(X-P,G-D),ln=Math.hypot(un-X,mn-G);if(!bn||!ln)return!1;let _n=-(G-D)/bn*T,Pn=(X-P)/bn*T;return(_n*(un-X)+Pn*(mn-G))/ln>it},en=(Z,P)=>Y?Y.heightAt(Z,P):F,pn=0;for(let Z=0;Z<j;Z+=1){let[P,D]=z(Z),[X,G]=z(Z+1),un=Math.hypot(X-P,G-D);if(un===0||hn(P,D,X,G))continue;let mn=-(G-D)/un*T,bn=(X-P)/un*T,ln=on[w].normals[Z]??[mn,bn],_n=on[w].normals[(Z+1)%j]??[mn,bn],Pn=W=>{let gn=ln[0]+(_n[0]-ln[0])*W,Mn=ln[1]+(_n[1]-ln[1])*W,cn=Math.hypot(gn,Mn)||1;return[gn/cn,Mn/cn]},sn=[0,...Y?Y.breaks(P,D,X,G):[],1];for(let W=0;W+1<sn.length;W+=1){let gn=W===0,Mn=W+2===sn.length,cn=P+(X-P)*sn[W],On=D+(G-D)*sn[W],Ln=P+(X-P)*sn[W+1],Cn=D+(G-D)*sn[W+1],wn=Math.hypot(Ln-cn,Cn-On)/tn*e.tileMetres,zn=(gn&&nn(Z)?1:0)|(Mn&&nn(Z+1)?2:0)|(w>0?4:0),Zn=(gn&&se(P,D)?1:0)|(Mn&&se(X,G)?2:0),Gn=pn+wn,Sn=Pn(sn[W]),jn=Pn(sn[W+1]),ie=en(cn,On),le=en(Ln,Cn),xn=i.write(q,cn,On,0,Sn[0],Sn[1],1,pn,zn,wn,0,Zn,ie);i.write(q,Ln,Cn,0,jn[0],jn[1],1,Gn,zn,wn,1,Zn,le),i.write(q,cn,On,1,Sn[0],Sn[1],1,pn,zn,wn,0,Zn,ie),i.write(q,Ln,Cn,1,jn[0],jn[1],1,Gn,zn,wn,1,Zn,le),l.push(xn,xn+1,xn+2,xn+1,xn+3,xn+2),pn=Gn}}}g.roofsCount=u.length-g.roofsFrom,g.wallsCount=l.length-g.wallsFrom,a.push(g)}$&&c.push(R)}if(i.count===0)return;let m=new Uint32Array(u.length+l.length),b=[],d=0,x=u.length,I=u.values(),B=l.values();a.sort((y,k)=>y.cell-k.cell);let M=-1;for(let y of a){y.cell!==M&&(M=y.cell,b.push({bounds:[...y.bounds],roofsFrom:d,roofsCount:0,wallsFrom:x,wallsCount:0}));let k=b.at(-1);for(let R=0;R<5;R+=1)k.bounds[R]=R<2?Math.min(k.bounds[R],y.bounds[R]):Math.max(k.bounds[R],y.bounds[R]);m.set(I.subarray(y.roofsFrom,y.roofsFrom+y.roofsCount),d),m.set(B.subarray(y.wallsFrom,y.wallsFrom+y.wallsCount),x),d+=y.roofsCount,x+=y.wallsCount,k.roofsCount+=y.roofsCount,k.wallsCount+=y.wallsCount}return{groups:b,vertices:i.bytes(),indices:m,wallsFrom:u.length,top:f,features:c}}function ct(n,e,t,s){let o=[],r=[];for(let l of n)r.push(o.length/2),o.push(...l);r.push(o.length/2);let i=(l,c)=>{let a=r.findIndex((d,x)=>l>=d&&l<r[x+1]),[f,h]=[r[a],r[a+1]-1];if(c<f||c>h)return!1;let[m,b]=l<c?[l,c]:[c,l];return b-m!==1&&!(m===f&&b===h)?!1:!hn(o[l*2],o[l*2+1],o[c*2],o[c*2+1])},u=kn(o,r.slice(1,-1),2);for(let l=0;l+2<u.length;l+=3){let c=[u[l],u[l+1],u[l+2]],a=0;for(let f=0;f<3;f+=1)i(c[(f+1)%3],c[(f+2)%3])&&(a|=1<<f);for(let[f,h]of c.entries())s.push(t.write(e,o[h*2],o[h*2+1],1,0,0,0,0,0,0,f,a))}}function at(n,e,t,s){for(let o of n.faces){let r=o.ring,i=r.length/2,u=(l,c)=>{let[a,f]=l<c?[l,c]:[c,l];return f-a!==1&&!(a===0&&f===i-1)?!1:!hn(r[l*2],r[l*2+1],r[c*2],r[c*2+1])};for(let l=0;l+2<o.triangles.length;l+=3){let c=[o.triangles[l],o.triangles[l+1],o.triangles[l+2]],a=0;for(let f=0;f<3;f+=1)u(c[(f+1)%3],c[(f+2)%3])&&(a|=1<<f);for(let[f,h]of c.entries()){let m=r[h*2],b=r[h*2+1];s.push(t.write(e,m,b,1,o.normal[0],o.normal[1],0,0,0,0,f,a,n.heightAt(m,b)))}}}}function ft(n,e,t,s=Math.PI/6){if(t<1)return{ring:n,normals:[]};let o=n.length/2,r=Xn(n)>0,i=e===0?r?-1:1:r?1:-1,u=[],l=[],c=(a,f,h)=>{a=yn(a),f=yn(f),!(u.at(-2)===a&&u.at(-1)===f)&&(u.push(a,f),l.push(h))};for(let a=0;a<o;a+=1){let f=(a+o-1)%o,h=(a+1)%o,[m,b]=[n[f*2],n[f*2+1]],[d,x]=[n[a*2],n[a*2+1]],[I,B]=[n[h*2],n[h*2+1]],M=Math.hypot(d-m,x-b),y=Math.hypot(I-d,B-x);if(!M||!y||se(d,x)||hn(m,b,d,x)||hn(d,x,I,B)){c(d,x);continue}let[k,R]=[(d-m)/M,(x-b)/M],[N,F]=[(I-d)/y,(B-x)/y],S=Math.atan2(k*F-R*N,k*N+R*F);if(S*i>=-.08||Math.abs(S)>Math.PI*.85){c(d,x);continue}let J=Math.tan(Math.abs(S)/2),Q=Math.min(t*J,M*.2,y*.2),L=Q/J;if(L<1){c(d,x);continue}let[C,$]=[-R*i,k*i],[V,p]=[d-k*Q-C*L,x-R*Q-$*L],A=Math.atan2($,C),v=Math.max(s<=Math.PI/6?2:1,Math.ceil(Math.abs(S)/Math.max(Math.PI/6,Math.min(Math.PI/3,s))));for(let g=0;g<=v;g+=1){let E=A+S*g/v,H=[Math.cos(E),Math.sin(E)];c(V+H[0]*L,p+H[1]*L,H)}}return u[0]===u.at(-2)&&u[1]===u.at(-1)&&(u.splice(-2),l.pop()),u.length>=6?{ring:u,normals:l}:{ring:n,normals:[]}}var re=class{#n=new ArrayBuffer(4096*te);#e=new DataView(this.#n);count=0;write(e,t,s,o,r,i,u,l,c,a,f=0,h=0,m=e.top){let b=te;if((this.count+1)*b>this.#n.byteLength){let I=new ArrayBuffer(this.#n.byteLength*2);new Uint8Array(I).set(new Uint8Array(this.#n)),this.#n=I,this.#e=new DataView(I)}let d=this.#e,x=this.count*b;return d.setUint16(x,yn(t),!0),d.setUint16(x+2,yn(s),!0),d.setUint16(x+4,Math.min(65535,Math.round(e.base*10)),!0),d.setUint16(x+6,Math.min(65535,Math.max(0,Math.round(m*10))),!0),d.setInt8(x+8,Math.round(r*127)),d.setInt8(x+9,Math.round(i*127)),d.setUint8(x+10,o),d.setUint8(x+11,u),d.setUint16(x+12,Math.round(l*10)%65536,!0),d.setUint8(x+14,Math.round(e.jitter*255)),d.setUint8(x+15,Math.round(e.seed*255)),d.setUint16(x+16,yn(e.cx),!0),d.setUint16(x+18,yn(e.cy),!0),d.setUint8(x+20,e.tone+4*e.group),d.setUint8(x+21,e.use),d.setUint8(x+22,c),d.setUint8(x+23,Math.min(255,Math.round(a))),d.setUint16(x+24,e.index,!0),d.setUint8(x+26,f),d.setUint8(x+27,h),this.count+=1,this.count-1}bytes(){return new Uint8Array(this.#n.slice(0,this.count*te))}},Yn=class{#n=new Uint32Array(8192);length=0;push(...e){if(this.length+e.length>this.#n.length){let t=new Uint32Array(Math.max(this.length+e.length,this.#n.length*2));t.set(this.#n),this.#n=t}for(let t of e)this.#n[this.length++]=t}values(){return this.#n.subarray(0,this.length)}};function ht(n,e){let t=new Map;if(n.features.some(u=>u.properties.night_use!==void 0)){for(let[u,l]of n.features.entries()){let c=st[String(l.properties.night_use??"")];c&&t.set(u,c)}return t}let s=e.places;if(!s||s.features.length===0)return t;let o=ut/e.tileMetres*n.extent,r=[];for(let[u,l]of n.features.entries()){if(l.type!=="Polygon")continue;let c=l.properties.hide_3d;if(c===!0||c===1||c==="1"||c==="true")continue;let a=[1/0,1/0,-1/0,-1/0];for(let f of l.geometry)for(let h=0;h+1<f.length;h+=2)a[0]=Math.min(a[0],f[h]),a[1]=Math.min(a[1],f[h+1]),a[2]=Math.max(a[2],f[h]),a[3]=Math.max(a[3],f[h+1]);r.push({index:u,rings:l.geometry,box:a})}let i=n.extent/s.extent;for(let u of s.features){if(u.type!=="Point")continue;let l=u.properties,c=oe[String(l.type??"")]??oe[String(l.subclass??"")]??oe[String(l.class??"")];if(c)for(let a of u.geometry)for(let f=0;f+1<a.length;f+=2){let h=a[f]*i,m=a[f+1]*i,b,d,x=o;for(let B of r){let[M,y,k,R]=B.box;if(h<M-o||h>k+o||m<y-o||m>R+o)continue;let N=!1;for(let F of B.rings)for(let S=0,J=F.length-2;S+1<F.length;J=S,S+=2){let Q=F[J],L=F[J+1],C=F[S],$=F[S+1];$>m!=L>m&&h<(Q-C)*(m-$)/(L-$)+C&&(N=!N);let V=C-Q,p=$-L,A=V*V+p*p,v=A?Math.min(1,Math.max(0,((h-Q)*V+(m-L)*p)/A)):0,g=Math.hypot(h-Q-v*V,m-L-v*p);g<x&&(x=g,d=B.index)}if(N){b=B.index;break}}let I=b??d;I!==void 0&&t.set(I,Math.max(t.get(I)??0,c))}}return t}function yn(n){return Math.min(tn,Math.max(0,Math.round(n)))}function Ae(n){let e=Number(n);return Number.isFinite(e)&&e>0?e:void 0}function mt(n,e){let t=[],s;for(let o of n){let r=[];for(let u=0;u+1<o.length;u+=2){let l=o[u]*e,c=o[u+1]*e;r.length&&l===r.at(-2)&&c===r.at(-1)||r.push(l,c)}if(r.length>=6&&r[0]===r.at(-2)&&r[1]===r.at(-1)&&(r.length-=2),r.length<6)continue;let i=Math.sign(Xn(r));i&&(s??=i,i===s||t.length===0?t.push([r]):t.at(-1).push(r))}return t}function Xn(n){let e=0,t=n.length/2;for(let s=0;s<t;s+=1){let o=(s+1)%t;e+=n[s*2]*n[o*2+1]-n[o*2]*n[s*2+1]}return e}function bt(n){let e=0,t=0,s=n.length/2;for(let o=0;o<s;o+=1)e+=n[o*2],t+=n[o*2+1];return[e/s,t/s]}function se(n,e){return n<=0||e<=0||n>=tn||e>=tn}function hn(n,e,t,s){let o=tn;return n<=0&&t<=0||n>=o&&t>=o||e<=0&&s<=0||e>=o&&s>=o}function xt(n){let e=tn,t=[...n],s=[[0,0,o=>o>=0],[0,e,o=>o<=e],[1,0,o=>o>=0],[1,e,o=>o<=e]];for(let[o,r,i]of s){let u=[],l=t.length/2;for(let c=0;c<l;c+=1){let a=[t[c*2],t[c*2+1]],f=[t[(c+1)%l*2],t[(c+1)%l*2+1]],h=i(a[o]),m=i(f[o]);if(h&&u.push(a[0],a[1]),h!==m){let b=(r-a[o])/(f[o]-a[o]);u.push(a[0]+(f[0]-a[0])*b,a[1]+(f[1]-a[1])*b)}}if(t=u,t.length<6)return[]}return t}function Ie(n){let e=Math.sin(n*12.9898+78.233)*43758.5453;return e-Math.floor(e)}var ue=globalThis;ue.onmessage=({data:n})=>{try{let e=Ue(n.layer,n.options);ue.postMessage({mesh:e},e?[e.vertices.buffer,e.indices.buffer]:[])}catch(e){ue.postMessage({error:String(e)})}};})();\n'], { type: "text/javascript" })
+  );
+  try {
+    return new Worker(url, { name: "tileflow-buildings" });
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+function createBuildingMesher(createWorker = browserWorker) {
+  let worker2;
+  let unavailable = false;
+  let disposed = false;
+  let finish;
+  let tail = Promise.resolve();
+  return {
+    build(layer, options, signal) {
+      const result = tail.then(async () => {
+        if (disposed || signal.aborted) throw new Error("Building mesh cancelled");
+        if (!worker2 && !unavailable) {
+          try {
+            worker2 = createWorker();
+          } catch {
+          }
+          if (!worker2) unavailable = true;
+        }
+        if (!worker2) return meshTileflowBuildings(layer, options);
+        const active = worker2;
+        return new Promise((resolve, reject) => {
+          const cleanup = () => {
+            clearTimeout(timeout);
+            finish = void 0;
+            active.onmessage = null;
+            active.onerror = null;
+          };
+          const fallback = () => {
+            cleanup();
+            active.terminate();
+            worker2 = void 0;
+            unavailable = true;
+            if (disposed || signal.aborted) {
+              reject(new Error("Building mesh cancelled"));
+              return;
+            }
+            try {
+              resolve(meshTileflowBuildings(layer, options));
+            } catch (error) {
+              reject(error);
+            }
+          };
+          const timeout = setTimeout(fallback, 15e3);
+          finish = () => {
+            cleanup();
+            reject(new Error("Building mesher disposed"));
+          };
+          active.onerror = (event) => {
+            event.preventDefault();
+            fallback();
+          };
+          active.onmessage = ({
+            data
+          }) => {
+            cleanup();
+            if (disposed || signal.aborted) reject(new Error("Building mesh cancelled"));
+            else if (data.error) reject(new Error(data.error));
+            else resolve(data.mesh);
+          };
+          try {
+            active.postMessage({ layer, options });
+          } catch {
+            fallback();
+          }
+        });
+      });
+      tail = result.then(
+        () => {
+        },
+        () => {
+        }
+      );
+      return result;
+    },
+    dispose() {
+      disposed = true;
+      finish?.();
+      worker2?.terminate();
+      worker2 = void 0;
+    }
+  };
+}
+
+// src/buildings-3d-occlusion.ts
+var tileflowBuildingOcclusion = {
+  ground: 3,
+  groundStrength: 0.16,
+  wall: 0.14,
+  wallRadius: 3,
+  corner: 3
+};
+function buildingContactSegments(mesh) {
+  const count = (mesh.indices.length - mesh.wallsFrom) / 6;
+  const bytes = new Uint8Array(count * 16);
+  for (let wall = 0; wall < count; wall += 1) {
+    const index = mesh.wallsFrom + wall * 6;
+    const start = mesh.indices[index] * tileflowBuildingVertexBytes;
+    const end = mesh.indices[index + 1] * tileflowBuildingVertexBytes;
+    bytes.set(mesh.vertices.subarray(start, start + 4), wall * 16);
+    bytes.set(mesh.vertices.subarray(end, end + 4), wall * 16 + 4);
+    bytes.set(mesh.vertices.subarray(start + 4, start + 8), wall * 16 + 8);
+    bytes[wall * 16 + 12] = mesh.vertices[start + 14];
+    bytes[wall * 16 + 13] = mesh.vertices[start + 27];
+  }
+  return bytes;
+}
+function createBuildingContactVao(gl, mesh) {
+  const vao = gl.createVertexArray();
+  const vbo = gl.createBuffer();
+  gl.bindVertexArray(vao);
+  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+  const segments = buildingContactSegments(mesh);
+  gl.bufferData(gl.ARRAY_BUFFER, segments, gl.STATIC_DRAW);
+  const offset = (first) => {
+    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+    for (const [location, size, type, normalised, byte2] of [
+      [0, 2, gl.UNSIGNED_SHORT, false, 0],
+      [1, 2, gl.UNSIGNED_SHORT, false, 4],
+      [2, 2, gl.UNSIGNED_SHORT, false, 8],
+      [3, 1, gl.UNSIGNED_BYTE, true, 12],
+      [4, 1, gl.UNSIGNED_BYTE, false, 13]
+    ]) {
+      gl.enableVertexAttribArray(location);
+      gl.vertexAttribPointer(location, size, type, normalised, 16, first * 16 + byte2);
+      gl.vertexAttribDivisor(location, 1);
+    }
+  };
+  offset(0);
+  gl.bindVertexArray(null);
+  return { vao, vbo, count: segments.length / 16, offset };
+}
+var buildingContactVertex = (projected) => `#version 300 es
+${projected}
+layout(location=0) in vec2 a_start;
+layout(location=1) in vec2 a_end;
+layout(location=2) in vec2 a_heights;
+layout(location=3) in float a_seed;
+layout(location=4) in float a_cuts;
+uniform float u_scale;
+uniform float u_metres;
+uniform float u_band;
+out vec2 v_point;
+flat out float v_length;
+flat out float v_strength;
+void main() {
+  float p = clamp(u_scale * 1.25 - a_seed * 0.25, 0.0, 1.0);
+  if (p <= 0.0 || a_heights.x > 5.0 || a_heights.y <= a_heights.x) {
+    gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+    return;
+  }
+  vec2 edge = (a_end - a_start) * u_metres;
+  v_length = length(edge);
+  vec2 tangent = edge / max(v_length, 0.0001);
+  // A tile cut continues in its neighbour; do not round that artificial endpoint.
+  float startCap = mod(a_cuts, 2.0) < 0.5 ? u_band : 0.0;
+  float endCap = a_cuts < 2.0 ? u_band : 0.0;
+  v_point = vec2((gl_VertexID & 1) == 0 ? -startCap : v_length + endCap,
+    gl_VertexID < 2 ? -u_band : u_band);
+  vec2 point = a_start + (tangent * v_point.x + vec2(-tangent.y, tangent.x) * v_point.y) / u_metres;
+  gl_Position = projectTileFor3D(point, 0.0);
+  v_strength = p * p * (3.0 - 2.0 * p);
+}`;
+var buildingContactFragment = `#version 300 es
+precision highp float;
+in vec2 v_point;
+flat in float v_length;
+flat in float v_strength;
+uniform float u_band;
+uniform float u_band_strength;
+out vec4 fragColor;
+void main() {
+  float distance = length(v_point - vec2(clamp(v_point.x, 0.0, v_length), 0.0));
+  float near = 1.0 - smoothstep(0.0, u_band, distance);
+  float shade = 1.0 - u_band_strength * near * near * v_strength;
+  fragColor = vec4(vec3(shade), 1.0);
+}`;
+var buildingContactCompositeFragment = `#version 300 es
+precision highp float;
+uniform highp sampler2D u_contact;
+out vec4 fragColor;
+void main() {
+  float shade = texelFetch(u_contact, ivec2(gl_FragCoord.xy), 0).r;
+  fragColor = vec4(vec3(shade), 1.0);
+}`;
+function createBuildingContactMask() {
+  let target;
+  function release(gl) {
+    if (!target) return;
+    gl.deleteTexture(target.texture);
+    gl.deleteFramebuffer(target.framebuffer);
+    target = void 0;
+  }
+  return {
+    release,
+    render(gl, draw) {
+      const framebuffer = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+      const depth = gl.isEnabled(gl.DEPTH_TEST);
+      const stencil = gl.isEnabled(gl.STENCIL_TEST);
+      const cull = gl.isEnabled(gl.CULL_FACE);
+      const scissor = gl.isEnabled(gl.SCISSOR_TEST);
+      const equation = gl.getParameter(gl.BLEND_EQUATION_RGB);
+      const alphaEquation = gl.getParameter(gl.BLEND_EQUATION_ALPHA);
+      const clear = gl.getParameter(gl.COLOR_CLEAR_VALUE);
+      try {
+        const width = gl.drawingBufferWidth;
+        const height = gl.drawingBufferHeight;
+        if (!target || target.width !== width || target.height !== height) {
+          release(gl);
+          const texture = gl.createTexture();
+          gl.activeTexture(gl.TEXTURE2);
+          gl.bindTexture(gl.TEXTURE_2D, texture);
+          gl.texStorage2D(gl.TEXTURE_2D, 1, gl.R8, width, height);
+          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+          const next = gl.createFramebuffer();
+          gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, next);
+          gl.framebufferTexture2D(
+            gl.DRAW_FRAMEBUFFER,
+            gl.COLOR_ATTACHMENT0,
+            gl.TEXTURE_2D,
+            texture,
+            0
+          );
+          target = { texture, framebuffer: next, width, height };
+        }
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, target.framebuffer);
+        gl.disable(gl.DEPTH_TEST);
+        gl.disable(gl.STENCIL_TEST);
+        gl.disable(gl.CULL_FACE);
+        gl.disable(gl.SCISSOR_TEST);
+        gl.clearColor(1, 1, 1, 1);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+        gl.blendEquation(gl.MIN);
+        draw();
+        return target.texture;
+      } finally {
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, framebuffer);
+        gl.blendEquationSeparate(equation, alphaEquation);
+        gl.clearColor(clear[0], clear[1], clear[2], clear[3]);
+        for (const [capability, enabled] of [
+          [gl.DEPTH_TEST, depth],
+          [gl.STENCIL_TEST, stencil],
+          [gl.CULL_FACE, cull],
+          [gl.SCISSOR_TEST, scissor]
+        ]) {
+          if (enabled) gl.enable(capability);
+          else gl.disable(capability);
+        }
+      }
+    }
+  };
+}
+
+// src/buildings-3d-opacity.ts
+function drawBuildingOpacity(gl, opacity, draw) {
+  if (opacity <= 0) return;
+  if (opacity >= 1) {
+    draw();
+    return;
+  }
+  const colourMask = gl.getParameter(gl.COLOR_WRITEMASK);
+  const depthMask = gl.getParameter(gl.DEPTH_WRITEMASK);
+  const depthFunc = gl.getParameter(gl.DEPTH_FUNC);
+  const blending = gl.isEnabled(gl.BLEND);
+  const blendColour = gl.getParameter(gl.BLEND_COLOR);
+  const blend = [gl.BLEND_SRC_RGB, gl.BLEND_DST_RGB, gl.BLEND_SRC_ALPHA, gl.BLEND_DST_ALPHA].map(
+    (name) => gl.getParameter(name)
+  );
+  const equations = [gl.BLEND_EQUATION_RGB, gl.BLEND_EQUATION_ALPHA].map(
+    (name) => gl.getParameter(name)
+  );
+  try {
+    gl.colorMask(false, false, false, false);
+    gl.depthMask(true);
+    gl.depthFunc(gl.LEQUAL);
+    gl.disable(gl.BLEND);
+    draw();
+    gl.colorMask(...colourMask);
+    gl.depthMask(false);
+    gl.depthFunc(gl.EQUAL);
+    gl.enable(gl.BLEND);
+    gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD);
+    gl.blendColor(0, 0, 0, opacity);
+    gl.blendFuncSeparate(gl.CONSTANT_ALPHA, gl.ONE_MINUS_CONSTANT_ALPHA, gl.ZERO, gl.ONE);
+    draw();
+  } finally {
+    gl.colorMask(...colourMask);
+    gl.depthMask(depthMask);
+    gl.depthFunc(depthFunc);
+    gl.blendColor(...Array.from(blendColour));
+    gl.blendFuncSeparate(blend[0], blend[1], blend[2], blend[3]);
+    gl.blendEquationSeparate(equations[0], equations[1]);
+    if (blending) gl.enable(gl.BLEND);
+    else gl.disable(gl.BLEND);
+  }
+}
+
+// src/scene-3d-shaders.ts
+var tileflowShadowLookup = `
+uniform highp sampler2DShadow u_shadow_map;
+uniform float u_shadow;
+uniform float u_depth_unit;
+
+float visibility(vec3 c, float bias) {
+  if (u_shadow <= 0.0 || c.x <= 0.0 || c.y <= 0.0 || c.x >= 1.0 || c.y >= 1.0 || c.z >= 1.0)
+    return 1.0;
+  float z = c.z - bias * u_depth_unit;
+  // The depth texture uses LINEAR comparison; an extra multi-tap kernel would
+  // spread distant texels into metres of soft shadow.
+  return texture(u_shadow_map, vec3(c.xy, z));
+}`;
+
 // src/buildings-3d-shaders.ts
 var tileflowBuildingAttributes = [
   ["a_pos", 2, "UNSIGNED_SHORT", false, 0],
@@ -6365,24 +6969,6 @@ vec3 shopOf(float use, float seed) {
   return vec3(0.0);
 }
 `;
-var shadowLookup = `
-uniform highp sampler2DShadow u_shadow_map;
-uniform vec2 u_shadow_texel;
-uniform float u_shadow; // how dark shadows fall, 0 for none
-uniform float u_depth_unit; // the depth of a metre
-
-float visibility(vec3 c, float bias) {
-  if (u_shadow <= 0.0 || c.x <= 0.0 || c.y <= 0.0 || c.x >= 1.0 || c.y >= 1.0 || c.z >= 1.0)
-    return 1.0;
-  float z = c.z - bias * u_depth_unit;
-  vec2 o = u_shadow_texel * 0.75;
-  return 0.25 * (
-    texture(u_shadow_map, vec3(c.xy + vec2(-o.x, -o.y), z)) +
-    texture(u_shadow_map, vec3(c.xy + vec2(o.x, -o.y), z)) +
-    texture(u_shadow_map, vec3(c.xy + vec2(-o.x, o.y), z)) +
-    texture(u_shadow_map, vec3(c.xy + vec2(o.x, o.y), z)));
-}
-`;
 var tileflowBuildingDepthVertex = `#version 300 es
 ${attributes}
 uniform mat4 u_light_matrix;
@@ -6415,12 +7001,8 @@ uniform vec2 u_palette_themes; // the themes either side of the blend position
 uniform float u_palette_mix;
 uniform float u_variation; // how far buildings' brightness strays from their colour, either way
 ${growth}
-uniform vec3 u_style_light_position;
-uniform vec3 u_style_light_colour;
-uniform float u_style_light_intensity;
-uniform float u_style_gradient;
-out vec3 v_style_colour;
 out vec3 v_colour;
+out float v_base;
 out vec3 v_facade; // metres along the wall, metres up as built, the building's top
 out vec4 v_building; // seed, tone and class group, wall, night use
 out vec3 v_normal;
@@ -6435,22 +7017,6 @@ vec3 paletteColour(float theme) {
   return texelFetch(u_palette, ivec2(int(column), int(row)), 0).rgb;
 }
 
-// MapLibre GL JS 6.13 fill-extrusion lighting, adapted to this mesh's normals and heights.
-// Copyright MapLibre contributors and Mapbox; BSD-3-Clause, see THIRD_PARTY_NOTICES.md.
-vec3 styleColour(vec3 colour, vec3 normal, float base, float top) {
-  float luminance = dot(colour, vec3(0.2126, 0.7152, 0.0722));
-  float facing = clamp(dot(normal * vec3(1.0, -1.0, 1.0), u_style_light_position), 0.0, 1.0);
-  float brightness = mix(1.0 - u_style_light_intensity,
-    max(1.0 - luminance + u_style_light_intensity, 1.0), facing);
-  if (a_flags.y > 0.5) {
-    float gradient = clamp((a_flags.x + base) * sqrt(top / 150.0),
-      mix(0.7, 0.98, 1.0 - u_style_light_intensity), 1.0);
-    brightness *= mix(1.0, gradient, u_style_gradient);
-  }
-  return clamp((colour + 0.03) * brightness * u_style_light_colour,
-    0.3 * (1.0 - u_style_light_colour), vec3(1.0));
-}
-
 void main() {
   float base = a_height.x * 0.1;
   float top = a_height.y * 0.1;
@@ -6476,7 +7042,7 @@ void main() {
     : u_colour;
   // Neighbours of one colour stay apart: each building a little lighter or darker than its colour.
   v_colour *= 1.0 + (a_wave.x - 0.5) * 2.0 * u_variation;
-  v_style_colour = styleColour(v_colour, normal, base, top);
+  v_base = base;
   v_edge = wall > 0.5 ? vec3(a_edge.x, 0.0, 0.0) : vec3(equal(vec3(a_edge.x), vec3(0.0, 1.0, 2.0)));
   v_outline = a_edge.y;
   v_facade = vec3(a_along * 0.1, own, top);
@@ -6486,7 +7052,12 @@ void main() {
 var tileflowBuildingFragment = `#version 300 es
 precision highp float;
 in vec3 v_colour;
-in vec3 v_style_colour;
+in float v_base;
+uniform vec3 u_style_light_position;
+uniform vec3 u_style_light_colour;
+uniform float u_style_light_intensity;
+uniform float u_style_gradient;
+uniform float u_edge_radius;
 uniform float u_sun_lighting;
 in vec3 v_facade;
 in vec4 v_building;
@@ -6499,6 +7070,7 @@ uniform vec3 u_sun_dir;
 uniform vec3 u_sun_light;
 uniform vec3 u_sky_light;
 uniform float u_occlusion;
+uniform float u_occlusion_radius;
 uniform float u_corner;
 uniform float u_night; // 0 by day, 1 at night
 uniform float u_windows; // whether to draw night windows
@@ -6508,13 +7080,48 @@ uniform float u_edge_width; // their width, in the drawing buffer's pixels
 uniform vec3 u_edge_colour; // the application's colour for them
 uniform float u_edge_own; // how much of them takes the application's colour, from 0 to 1
 ${nightLight}
-${shadowLookup}
+${tileflowShadowLookup}
 out vec4 fragColor;
 
 float hash(vec2 p) {
   return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
 }
 
+// The contact shade rises gradually up the facade, in world metres. Use one bounded shade
+// for the authored gradient, ground contact and inner corners, rather than multiplying them.
+float facadeShade() {
+  if (v_building.z < 0.5) return 1.0;
+  float reach = min(3.0, max((v_facade.z - v_base) * 0.5, 0.1));
+  float gradient = 0.1 * u_style_gradient * (1.0 - smoothstep(0.0, reach, v_facade.y - v_base));
+  // Exponential attenuation leaves a soft tail above the first floor, without a band ending
+  // at its radius. Height above ground also keeps raised parts from acquiring a dark lower rim.
+  float up = max(v_facade.y, 0.0);
+  float contact = u_occlusion * exp(-up / max(u_occlusion_radius, 0.001));
+  float along = v_facade.x - v_wall.x;
+  float corner = 0.0;
+  if (mod(v_wall.y, 2.0) >= 1.0) corner = 1.0 - smoothstep(0.0, u_corner, along);
+  if (mod(floor(v_wall.y / 2.0), 2.0) >= 1.0)
+    corner = max(corner, 1.0 - smoothstep(0.0, u_corner, v_wall.z - along));
+  float inner = u_occlusion * 0.7 * corner * mix(1.0, 0.5, clamp(up / 30.0, 0.0, 1.0));
+  return 1.0 - max(gradient, max(contact, inner));
+}
+
+// MapLibre GL JS 6.13 fill-extrusion light, evaluated per fragment for curved corner normals.
+// Copyright MapLibre contributors and Mapbox; BSD-3-Clause, see THIRD_PARTY_NOTICES.md.
+vec3 styleColour(vec3 colour, vec3 normal) {
+  float luminance = dot(colour, vec3(0.2126, 0.7152, 0.0722));
+  float facing = clamp(dot(normal * vec3(1.0, -1.0, 1.0), u_style_light_position), 0.0, 1.0);
+  float brightness = mix(1.0 - u_style_light_intensity,
+    max(1.0 - luminance + u_style_light_intensity, 1.0), facing);
+  if (v_building.z > 0.5) {
+    float wallLight = clamp((1.0 + v_base) * sqrt(v_facade.z / 150.0),
+      mix(0.7, 0.98, 1.0 - u_style_light_intensity), 1.0);
+    brightness *= mix(1.0, mix(wallLight, 1.0, normal.z), u_style_gradient);
+  }
+  return clamp((colour + 0.03) * brightness * u_style_light_colour,
+    0.3 * (1.0 - u_style_light_colour), vec3(1.0));
+}
+
 // A surface's light over the light a sunlit roof takes, in the map's colours: a sunlit roof keeps
 // its colour, a wall turned to a low sun glows, and shade takes the sky's colour. A wall sees half
 // the sky; by day the ground's light makes up some of the rest, at night little does.
@@ -6548,9 +7155,17 @@ float edgeOf() {
 
 void main() {
   vec3 normal = normalize(v_normal);
+  // A narrow lighting transition softens the roof/wall junction without moving the roof
+  // or adding a bright outline. Exterior vertical corners are rounded in the mesh itself.
+  if (v_building.z > 0.5 && u_edge_radius > 0.0) {
+    float radius = min(u_edge_radius, max((v_facade.z - v_base) * 0.25, 0.01));
+    float rim = 1.0 - smoothstep(0.0, radius, v_facade.z - v_facade.y);
+    normal = normalize(mix(normal, vec3(0.0, 0.0, 1.0), rim));
+  }
   float lit = dot(normal, u_sun_dir) > 0.0 ? visibility(v_shadow, 0.3) : 0.0;
-  vec3 colour = mix(v_style_colour * (1.0 - u_shadow * (1.0 - lit)),
+  vec3 colour = mix(styleColour(v_colour, normal) * (1.0 - u_shadow * (1.0 - lit)),
     v_colour * shade(normal, lit), u_sun_lighting);
+  colour *= facadeShade();
   // Roof outlines and outer corners catch the light, so where one building ends and the next starts
   // stays legible, at night most of all.
   float edge = u_edge > 0.0 ? edgeOf() * u_edge : 0.0;
@@ -6560,13 +7175,6 @@ void main() {
     float up = v_facade.y;
     float top = v_facade.z;
     float seed = v_building.x;
-    float foot = 1.0 - u_occlusion * pow(1.0 - clamp(up / 9.0, 0.0, 1.0), 2.0);
-    float along = v_facade.x - v_wall.x;
-    float corner = 0.0;
-    if (mod(v_wall.y, 2.0) >= 1.0) corner = 1.0 - smoothstep(0.0, u_corner, along);
-    if (mod(floor(v_wall.y / 2.0), 2.0) >= 1.0)
-      corner = max(corner, 1.0 - smoothstep(0.0, u_corner, v_wall.z - along));
-    colour *= foot * (1.0 - u_occlusion * 0.7 * corner * mix(1.0, 0.5, clamp(up / 30.0, 0.0, 1.0)));
     // Sheds, barns, factories and churches have no rows of windows; homes light more of theirs at
     // night than offices, in a warm light, and offices more of theirs in a cool one.
     float group = groupOf(v_building.y);
@@ -6649,7 +7257,7 @@ var tileflowBuildingGroundFragment = `#version 300 es
 precision highp float;
 in vec3 v_shadow;
 uniform vec3 u_ground_shadow;
-${shadowLookup}
+${tileflowShadowLookup}
 out vec4 fragColor;
 void main() {
   float shaded = u_shadow * (1.0 - visibility(v_shadow, 0.15));
@@ -6681,18 +7289,6 @@ void main() {
   v_out = a_flags.x;
   v_strength = p;
 }`;
-var tileflowBuildingBandFragment = `#version 300 es
-precision highp float;
-in float v_out;
-in float v_strength;
-in vec3 v_flood;
-in vec3 v_shop;
-uniform float u_band_strength;
-out vec4 fragColor;
-void main() {
-  float near = 1.0 - v_out;
-  fragColor = vec4(vec3(1.0 - u_band_strength * near * near * v_strength), 1.0);
-}`;
 var tileflowBuildingFloodFragment = `#version 300 es
 precision highp float;
 in float v_out;
@@ -6707,6 +7303,50 @@ void main() {
   fragColor = vec4((v_flood * 0.35 * near * near + v_shop * 0.12 * close) * u_flood * v_strength, 0.0);
 }`;
 
+// src/buildings-3d-view.ts
+function buildingBoxVisible(matrix, bounds) {
+  for (let axis = 0; axis < 3; axis += 1)
+    for (const sign of [-1, 1]) {
+      const a = matrix[3] + sign * matrix[axis];
+      const b2 = matrix[7] + sign * matrix[axis + 4];
+      const c = matrix[11] + sign * matrix[axis + 8];
+      const d2 = matrix[15] + sign * matrix[axis + 12];
+      const distance = a * bounds[a < 0 ? 0 : 3] + b2 * bounds[b2 < 0 ? 1 : 4] + c * bounds[c < 0 ? 2 : 5] + d2;
+      if (!Number.isFinite(distance)) return true;
+      if (distance < -1e-7) return false;
+    }
+  return true;
+}
+function buildingDrawRanges(mesh, visible, wallsOnly = false) {
+  if (!mesh.groups)
+    return [
+      {
+        from: wallsOnly ? mesh.wallsFrom : 0,
+        count: mesh.indices.length - (wallsOnly ? mesh.wallsFrom : 0)
+      }
+    ];
+  const groups = mesh.groups.filter(visible);
+  const ranges = [];
+  const append = (from, count) => {
+    if (!count) return;
+    const last = ranges.at(-1);
+    if (last && last.from + last.count === from) last.count += count;
+    else ranges.push({ from, count });
+  };
+  if (!wallsOnly) for (const group of groups) append(group.roofsFrom, group.roofsCount);
+  for (const group of groups) append(group.wallsFrom, group.wallsCount);
+  return ranges;
+}
+function buildingCornerDetail(zoom, latitude = 40.42, radius = 0.8, pitch = 0, previous) {
+  if (pitch > 70) return 2;
+  const metresPerPixel = 40075016686e-3 * Math.max(0.01, Math.cos(latitude * Math.PI / 180)) / (512 * 2 ** zoom);
+  const pixels = radius / metresPerPixel * (1 + Math.sin(Math.max(0, pitch) * Math.PI / 180));
+  if (previous === 0 && pixels < 0.66) return 0;
+  if (previous === 1 && pixels >= 0.54 && pixels < 3.3) return 1;
+  if (previous === 2 && pixels >= 2.7) return 2;
+  return pixels < 0.6 ? 0 : pixels < 3 ? 1 : 2;
+}
+
 // ../../node_modules/.pnpm/fflate@0.8.3/node_modules/fflate/esm/browser.js
 var u8 = Uint8Array;
 var u16 = Uint16Array;
@@ -8202,7 +8842,7 @@ function createCameraTiles(options) {
         tiles.set(key, entry);
       }
       entry.used = now;
-      if (!entry.value && !entry.loading && (entry.retryAt ?? 0) <= now)
+      if ((!entry.value || entry.retryAt !== void 0) && !entry.loading && (entry.retryAt ?? 0) <= now)
         load(source, key, entry, tileMetres);
     }
     evict();
@@ -8211,17 +8851,26 @@ function createCameraTiles(options) {
   function load(source, key, entry, tileMetres) {
     const controller = new AbortController();
     entry.loading = controller;
+    entry.retryAt = void 0;
     source.readTile({ z: zoom, x: entry.x, y: entry.y }, { signal: controller.signal }).then((tile) => {
-      entry.loading = void 0;
-      if (disposed || tiles.get(key) !== entry) return;
+      if (disposed || tiles.get(key) !== entry || entry.loading !== controller) return;
       if (!tile) {
         if (entry.value && entry.value !== options.empty) options.release(entry.value);
         entry.value = options.empty;
+        entry.loading = void 0;
+        options.changed();
+        map.triggerRepaint();
         return;
       }
-      queue.push({ key, tile, metres: tileMetres });
+      for (let at = queue.length - 1; at >= 0; at -= 1) {
+        const queued = queue[at];
+        if (queued.entry.loading !== queued.controller || queued.controller.signal.aborted)
+          queue.splice(at, 1);
+      }
+      queue.push({ key, entry, controller, tile, metres: tileMetres });
       drain();
     }).catch(() => {
+      if (disposed || entry.loading !== controller) return;
       entry.loading = void 0;
       entry.retryAt = performance.now() + 15e3;
     });
@@ -8229,29 +8878,46 @@ function createCameraTiles(options) {
   function drain() {
     if (building || disposed) return;
     building = true;
-    const step = () => {
+    const step = async () => {
       const started = performance.now();
       let built = false;
-      while (queue.length && performance.now() - started < buildBudgetMs) {
-        const { key, tile, metres: tileMetres } = queue.shift();
-        const entry = tiles.get(key);
-        if (!entry) continue;
-        const previous = entry.value;
+      while (!disposed && queue.length && performance.now() - started < buildBudgetMs) {
+        const { key, entry, controller, tile, metres: tileMetres } = queue.shift();
+        const current = () => !disposed && tiles.get(key) === entry && entry.loading === controller && !controller.signal.aborted;
+        if (!current()) continue;
+        let value;
         try {
-          entry.value = options.build(tile, tileMetres);
+          value = await options.build(tile, tileMetres, controller.signal);
         } catch {
-          entry.value = options.empty;
+          if (current()) {
+            entry.loading = void 0;
+            entry.retryAt = performance.now() + 15e3;
+          }
+          continue;
         }
-        if (previous && previous !== options.empty && previous !== entry.value)
-          options.release(previous);
+        if (!current()) {
+          if (value !== options.empty) options.release(value);
+          continue;
+        }
+        const previous = entry.value;
+        entry.value = value;
+        entry.loading = void 0;
+        if (previous && previous !== options.empty && previous !== value) options.release(previous);
         built = true;
       }
-      if (built) options.changed();
-      map.triggerRepaint();
-      if (queue.length && !disposed) cameraFrame(step);
+      if (built && !disposed) {
+        options.changed();
+        map.triggerRepaint();
+      }
+      if (queue.length && !disposed)
+        cameraFrame(() => {
+          void step();
+        });
       else building = false;
     };
-    cameraFrame(step);
+    cameraFrame(() => {
+      void step();
+    });
   }
   function evict() {
     const keep = new Set(wanted);
@@ -8910,23 +9576,8 @@ uniform vec3 u_sun_dir;
 uniform vec3 u_sun_light;
 uniform vec3 u_sky_light;
 uniform float u_night;
-uniform highp sampler2DShadow u_shadow_map;
-uniform vec2 u_shadow_texel;
-uniform float u_shadow;
-uniform float u_depth_unit;
 out vec4 fragColor;
-
-float visibility(vec3 c, float bias) {
-  if (u_shadow <= 0.0 || c.x <= 0.0 || c.y <= 0.0 || c.x >= 1.0 || c.y >= 1.0 || c.z >= 1.0)
-    return 1.0;
-  float z = c.z - bias * u_depth_unit;
-  vec2 o = u_shadow_texel * 0.75;
-  return 0.25 * (
-    texture(u_shadow_map, vec3(c.xy + vec2(-o.x, -o.y), z)) +
-    texture(u_shadow_map, vec3(c.xy + vec2(o.x, -o.y), z)) +
-    texture(u_shadow_map, vec3(c.xy + vec2(-o.x, o.y), z)) +
-    texture(u_shadow_map, vec3(c.xy + vec2(o.x, o.y), z)));
-}
+${tileflowShadowLookup}
 
 // The buildings' light: a sunlit roof keeps its colour, a face turned to a low sun glows, and shade
 // takes the sky's colour; a face that looks down sees little sky.
@@ -9356,10 +10007,9 @@ function releaseBuffers(context, entry) {
 
 // src/scene-3d-browser.ts
 var tileflowSceneExtent = 8192;
-var tileflowSceneShadowFloor = 3;
-var shadowFade = [0.5, 7];
+var tileflowSceneShadowFloor = 15;
 function tileflowSceneLight(sun, shadows = true) {
-  const linear = (value) => value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  const linear = (value) => value ** 2.2;
   const sunLight = sun.rgb.map((channel) => linear(channel) * sun.intensity);
   const skyLight = sun.ambient.rgb.map((channel) => linear(channel) * sun.ambient.intensity);
   const up = sun.direction[2];
@@ -9374,11 +10024,7 @@ function tileflowSceneLight(sun, shadows = true) {
     Math.cos(azimuth) * Math.cos(floor),
     Math.sin(floor)
   ];
-  const low = Math.min(
-    1,
-    Math.max(0, (sun.altitude - shadowFade[0]) / (shadowFade[1] - shadowFade[0]))
-  );
-  const strength = shadows ? Math.min(1, sun.shadowIntensity) * Math.min(1, sun.intensity * 4) * low * low * (3 - 2 * low) : 0;
+  const strength = shadows && sun.intensity > 0 ? Math.min(1, sun.shadowIntensity) : 0;
   const night = Math.min(1, Math.max(0, (0.14 - sun.brightness) / 0.09));
   return {
     direction: sun.direction,
@@ -9394,12 +10040,12 @@ var scenes = /* @__PURE__ */ new WeakMap();
 function tileflowScene3D(map) {
   let scene = scenes.get(map);
   if (!scene) {
-    scene = createScene();
+    scene = createScene(map);
     scenes.set(map, scene);
   }
   return scene;
 }
-function createScene() {
+function createScene(map) {
   const casters = /* @__PURE__ */ new Set();
   let target;
   let key;
@@ -9439,6 +10085,7 @@ function createScene() {
     return target;
   }
   function prepare(context, light, metres) {
+    if (light.strength <= 0) return;
     const shadow = ensureTarget(context);
     if (shadow.failed) return;
     const casting = [];
@@ -9446,7 +10093,6 @@ function createScene() {
       const bounds = caster.bounds();
       if (bounds) casting.push({ caster, bounds });
     }
-    if (light.strength <= 0) return;
     if (casting.length === 0) {
       frame = void 0;
       key = void 0;
@@ -9463,6 +10109,21 @@ function createScene() {
       tallest = Math.max(tallest, bounds.tallest);
     }
     const origin = [left, top];
+    const scale = metres;
+    const unit2 = tileflowSceneExtent * scale;
+    const lightView = tileflowSunLightMatrix(
+      light.shadowDirection,
+      {
+        min: [0, -(bottom + 1 - top) * unit2, 0],
+        max: [(right + 1 - left) * unit2, 0, tallest]
+      },
+      {
+        receivers: viewportReceivers(map, zoom, origin, scale, tallest),
+        resolution: shadow.size,
+        origin: [origin[0] * unit2, -origin[1] * unit2, 0],
+        gridScale: unit2 * 2 ** zoom
+      }
+    );
     const next = [
       ...light.shadowDirection.map((value) => value.toFixed(5)),
       zoom,
@@ -9471,15 +10132,11 @@ function createScene() {
       right,
       bottom,
       tallest.toFixed(2),
+      scale,
+      ...lightView.matrix,
       ...casting.map(({ caster }) => caster.key())
     ].join();
     if (next === key && frame) return;
-    const scale = metres;
-    const unit2 = tileflowSceneExtent * scale;
-    const lightView = tileflowSunLightMatrix(light.shadowDirection, {
-      min: [0, -(bottom + 1 - top) * unit2, 0],
-      max: [(right + 1 - left) * unit2, 0, tallest]
-    });
     const offsetOf = (tile, tileZoom = zoom) => {
       const factor = 2 ** (zoom - tileZoom);
       return [
@@ -9542,18 +10199,22 @@ function createScene() {
       const on = strength > 0 && frame && target && !target.failed;
       context.activeTexture(context.TEXTURE0);
       context.bindTexture(context.TEXTURE_2D, target?.texture ?? null);
-      context.uniform1i(uniforms.u_shadow_map, 0);
-      context.uniform1f(uniforms.u_shadow, on ? strength : 0);
+      context.uniform1i(uniforms.u_shadow_map ?? null, 0);
+      context.uniform1f(uniforms.u_shadow ?? null, on ? strength : 0);
       if (!on || !frame || !target) return;
-      context.uniformMatrix4fv(uniforms.u_light_matrix, false, frame.light.matrix);
-      context.uniform2f(uniforms.u_shadow_texel, 1 / target.size, 1 / target.size);
-      context.uniform1f(uniforms.u_depth_unit, 1 / frame.light.depth);
-      context.uniform1f(uniforms.u_normal_offset, frame.light.extent / target.size * 1.2);
+      context.uniformMatrix4fv(uniforms.u_light_matrix ?? null, false, frame.light.matrix);
+      context.uniform1f(uniforms.u_depth_unit ?? null, 1 / frame.light.depth);
+      context.uniform1f(
+        uniforms.u_normal_offset ?? null,
+        Math.min(0.15, Math.max(0.02, frame.light.extent / target.size * 0.5))
+      );
     },
     drawsGround(caster) {
       let first;
-      for (const entry of casters)
+      for (const entry of casters) {
+        if (!entry.bounds()) continue;
         if (!first || entry.groundOrder < first.groundOrder) first = entry;
+      }
       return first === caster;
     },
     release(context) {
@@ -9564,9 +10225,86 @@ function createScene() {
       frame = void 0;
       key = void 0;
     }
-  };
+  };
+}
+function viewportReceivers(input, zoom, origin, metres, tallest) {
+  const map = input;
+  try {
+    if (typeof map.getCanvas !== "function" || typeof map.getCenter !== "function" || typeof map.getBearing !== "function" || typeof map.getPitch !== "function" || typeof map.getZoom !== "function" || typeof map.getVerticalFieldOfView !== "function" || typeof map.project !== "function" || typeof map.unproject !== "function")
+      return void 0;
+    if (map.getTerrain?.()) return void 0;
+    if (map.getCenterElevation && Math.abs(map.getCenterElevation()) > 1e-5) return void 0;
+    const { clientWidth: width, clientHeight: height } = map.getCanvas();
+    const pitch = map.getPitch();
+    const fov = map.getVerticalFieldOfView();
+    if (!(width > 0 && height > 0 && fov > 0 && fov < 90 && pitch >= 0 && pitch + fov / 2 < 85))
+      return void 0;
+    const count = 2 ** zoom;
+    const unit2 = tileflowSceneExtent * metres;
+    const centre = map.getCenter();
+    const centreX = (centre.lng + 180) / 360 * count;
+    const point = ({ lng, lat }) => {
+      if (!Number.isFinite(lng) || !Number.isFinite(lat) || Math.abs(lat) >= 85.051129)
+        throw new Error("Unprojected shadow receiver is outside Mercator.");
+      const x3 = (lng + 180) / 360 * count;
+      const wrappedX = x3 + Math.round((centreX - x3) / count) * count;
+      const phi = lat * Math.PI / 180;
+      const y2 = (1 - Math.log(Math.tan(phi) + 1 / Math.cos(phi)) / Math.PI) / 2 * count;
+      return [(wrappedX - origin[0]) * unit2, -(y2 - origin[1]) * unit2, 0];
+    };
+    const pixels = [
+      [0, 0],
+      [width, 0],
+      [width, height],
+      [0, height]
+    ];
+    const ground = pixels.map((pixel2) => point(map.unproject(pixel2)));
+    const centrePoint = point(centre);
+    const pixel = unit2 / (512 * 2 ** (map.getZoom() - zoom));
+    const distance = height * pixel / (2 * Math.tan(fov * Math.PI / 360));
+    const angle = pitch * Math.PI / 180;
+    const bearing = map.getBearing() * Math.PI / 180;
+    const elevation = distance * Math.cos(angle);
+    if (!(elevation > 0.1 && Number.isFinite(elevation))) return void 0;
+    const camera = [
+      centrePoint[0] - distance * Math.sin(angle) * Math.sin(bearing),
+      centrePoint[1] - distance * Math.sin(angle) * Math.cos(bearing),
+      elevation
+    ];
+    const screenCentre = map.project(centre);
+    const right = [Math.cos(bearing), -Math.sin(bearing), 0];
+    const forward = [
+      Math.sin(bearing) * Math.sin(angle),
+      Math.cos(bearing) * Math.sin(angle),
+      -Math.cos(angle)
+    ];
+    const up = [
+      Math.sin(bearing) * Math.cos(angle),
+      Math.cos(bearing) * Math.cos(angle),
+      Math.sin(angle)
+    ];
+    const dot3 = (a, b2) => a.reduce((sum, value, index) => sum + value * b2[index], 0);
+    for (const [index, corner] of ground.entries()) {
+      const ray = corner.map((value, axis) => value - camera[axis]);
+      const depth = dot3(ray, forward);
+      if (!(depth > 0)) return void 0;
+      const x3 = screenCentre.x + dot3(ray, right) / depth * (distance / pixel);
+      const y2 = screenCentre.y - dot3(ray, up) / depth * (distance / pixel);
+      if (!Number.isFinite(x3) || !Number.isFinite(y2) || Math.abs(x3 - pixels[index][0]) > Math.max(2, width * 5e-3) || Math.abs(y2 - pixels[index][1]) > Math.max(2, height * 5e-3))
+        return void 0;
+    }
+    const fraction2 = Math.min(Math.max(0, tallest) / elevation, 1);
+    return [
+      ...ground,
+      ...ground.map(
+        (corner) => corner.map((value, index) => value + (camera[index] - value) * fraction2)
+      )
+    ];
+  } catch {
+    return void 0;
+  }
 }
-function tileflowSunLightMatrix(direction, box) {
+function tileflowSunLightMatrix(direction, box, view = {}) {
   const length = Math.hypot(direction[0], direction[1], direction[2]) || 1;
   const towards = direction.map((value) => value / length);
   const forward = towards.map((value) => -value);
@@ -9583,24 +10321,44 @@ function tileflowSunLightMatrix(direction, box) {
   const right = normalize2(cross(forward, hint));
   const up = cross(right, forward);
   const dot3 = (a, b2) => a[0] * b2[0] + a[1] * b2[1] + a[2] * b2[2];
-  const range = (axis) => {
+  const corners = [];
+  for (const x3 of [box.min[0], box.max[0]])
+    for (const y2 of [box.min[1], box.max[1]])
+      for (const z2 of [box.min[2], box.max[2]]) corners.push([x3, y2, z2]);
+  const range = (axis, points) => {
     let low = Infinity;
     let high = -Infinity;
-    for (const x3 of [box.min[0], box.max[0]])
-      for (const y2 of [box.min[1], box.max[1]])
-        for (const z2 of [box.min[2], box.max[2]]) {
-          const value = dot3([x3, y2, z2], axis);
-          low = Math.min(low, value);
-          high = Math.max(high, value);
-        }
+    for (const point of points) {
+      const value = dot3(point, axis);
+      low = Math.min(low, value);
+      high = Math.max(high, value);
+    }
     return [low, high];
   };
   const pad = ([low, high], extra) => [low - extra, high + extra];
-  const [u0, u1] = range(right);
-  const [v0, v1] = range(up);
-  const [a0, a1] = pad([u0, u1], (u1 - u0) * 0.01 + 2);
-  const [b0, b1] = pad([v0, v1], (v1 - v0) * 0.01 + 2);
-  const [c0, c1] = pad(range(forward), 10);
+  const receivers = view.receivers?.length ? view.receivers : corners;
+  const fit = (axis) => {
+    const [low, high] = range(axis, receivers);
+    const extra = (high - low) * 0.01 + 2;
+    if (!(view.resolution && view.resolution >= 1)) return pad([low, high], extra);
+    const span = high - low + extra * 2;
+    const gridScale = view.gridScale && view.gridScale > 0 ? view.gridScale : 1;
+    const gridSpan = span / gridScale;
+    const quantum = 2 ** Math.floor(Math.log2(gridSpan)) / 16;
+    const extent5 = Math.ceil(gridSpan / quantum) * quantum * gridScale;
+    const texel = extent5 / view.resolution;
+    const offset = dot3(view.origin ?? [0, 0, 0], axis);
+    const centre = Math.round(((low + high) / 2 + offset) / texel) * texel - offset;
+    return [centre - extent5 / 2, centre + extent5 / 2];
+  };
+  const [a0, a1] = fit(right);
+  const [b0, b1] = fit(up);
+  const endpoints = towards[2] > 1e-5 ? corners.map(([x3, y2, z2]) => [
+    x3 - z2 * towards[0] / towards[2],
+    y2 - z2 * towards[1] / towards[2],
+    0
+  ]) : [];
+  const [c0, c1] = pad(range(forward, [...corners, ...endpoints, ...receivers]), 10);
   const hu = (a1 - a0) / 2;
   const hv = (b1 - b0) / 2;
   const hd = (c1 - c0) / 2;
@@ -9616,13 +10374,19 @@ function tileflowSunLightMatrix(direction, box) {
   return { matrix, depth: hd * 2, extent: Math.max(hu, hv) * 2 };
 }
 
+// src/scene-3d-visibility.ts
+var tileflowSceneMinzoom = 15;
+var tileflowSceneFadeZooms = 0.25;
+function tileflowSceneOpacity(zoom, minzoom = tileflowSceneMinzoom) {
+  return Math.min(1, Math.max(0, (zoom - minzoom) / tileflowSceneFadeZooms));
+}
+
 // src/buildings-3d-browser.ts
 init_sun();
 init_theme_blend();
 var tileflowBuildings3DLayerId = "tileflow-buildings-3d";
 var preferredZoom = 15;
 var defaultTransition = 0;
-var occlusion = { ground: 8, groundStrength: 0.42, wall: 0.36, corner: 3 };
 var flood = { reach: 10, colour: [1, 0.7, 0.4] };
 var edgeLine = { width: 1, day: 0.5 };
 var paletteWidth = 256;
@@ -9636,15 +10400,17 @@ var derivedParts = {
 };
 function createTileflowBuildings3D(options) {
   const { map } = options;
-  const minzoom = options.minzoom ?? 14.5;
+  const minzoom = options.minzoom ?? tileflowSceneMinzoom;
   const maxTiles = Math.round(options.maxTiles ?? 25);
   if (!Number.isFinite(minzoom) || minzoom < 0 || minzoom > 24)
     throw new RangeError("Tileflow 3D buildings minzoom must be a zoom from 0 to 24.");
   if (!(maxTiles >= 1 && maxTiles <= 64))
     throw new RangeError("Tileflow 3D buildings maxTiles must be from 1 to 64.");
-  let scale = 0;
+  const mesher = createBuildingMesher();
+  let detail = buildingCornerDetail(map.getZoom());
+  let scale = 1;
   let opacity = 1;
-  let target = 0;
+  let target = 1;
   let blank;
   let motion;
   let gl;
@@ -9652,6 +10418,7 @@ function createTileflowBuildings3D(options) {
   let variant;
   let linking;
   let ground;
+  const contactMask = createBuildingContactMask();
   let disposed = false;
   const scene = tileflowScene3D(map);
   let generation = 0;
@@ -9705,6 +10472,7 @@ function createTileflowBuildings3D(options) {
         context.deleteVertexArray(ground.vao);
         context.deleteBuffer(ground.vbo);
       }
+      contactMask.release(context);
       if (blank) context.deleteTexture(blank);
       blank = void 0;
       programs = {};
@@ -9740,12 +10508,15 @@ function createTileflowBuildings3D(options) {
       } catch {
         return;
       }
-      if (visibleScale() <= 0) return;
-      upload(context);
+      if (target > 0 || scale > 0) upload(context);
+      if (visibleScale() <= 0) {
+        contactMask.release(context);
+        return;
+      }
       draw(context, args);
     }
   };
-  const makeCamera = (layers, source) => createCameraTiles({
+  const makeCamera = (layers, source, edgeRadius = 0) => createCameraTiles({
     map,
     source,
     layers: [layers.building, ...layers.places ? [layers.places] : []],
@@ -9754,16 +10525,22 @@ function createTileflowBuildings3D(options) {
     maxTiles,
     ...options.transformRequest ? { transformRequest: options.transformRequest } : {},
     active: () => target > 0 || scale > 0,
-    build(tile, tileMetres) {
+    async build(tile, tileMetres, signal) {
       const decoded = tile.layers[layers.building];
       if (!decoded) return emptyTile;
       const places = layers.places ? tile.layers[layers.places] : void 0;
       const masks = models.masksIn(tile, tileflowBuildingExtent);
-      const mesh = meshTileflowBuildings(decoded, {
-        tileMetres,
-        ...places ? { places } : {},
-        ...masks ? { masks } : {}
-      });
+      const mesh = await mesher.build(
+        decoded,
+        {
+          tileMetres,
+          edgeRadius: detail === 0 ? 0 : edgeRadius,
+          cornerAngle: detail === 1 ? Math.PI / 3 : Math.PI / 6,
+          ...places ? { places } : {},
+          ...masks ? { masks } : {}
+        },
+        signal
+      );
       return mesh ? { mesh } : emptyTile;
     },
     empty: emptyTile,
@@ -9776,26 +10553,45 @@ function createTileflowBuildings3D(options) {
   });
   let cameraKey = JSON.stringify([
     tileflowDefaultBuildings3DDesign.source,
-    tileflowDefaultBuildings3DDesign.layers
+    tileflowDefaultBuildings3DDesign.layers,
+    0
   ]);
   let camera = makeCamera(
     tileflowDefaultBuildings3DDesign.layers,
     tileflowDefaultBuildings3DDesign.source
   );
   function ensureCamera() {
-    const { source, layers } = design();
-    const key = JSON.stringify([source, layers]);
-    if (key === cameraKey) return;
+    const { source, layers, edgeRadius = 0 } = design();
+    const key = JSON.stringify([source, layers, edgeRadius]);
+    const nextDetail = buildingCornerDetail(
+      map.getZoom(),
+      map.getCenter().lat,
+      edgeRadius,
+      map.getPitch(),
+      detail
+    );
+    if (key === cameraKey) {
+      if (nextDetail !== detail && (target > 0 || scale > 0)) {
+        detail = nextDetail;
+        if (edgeRadius > 0) camera.refresh(() => true);
+      }
+      return;
+    }
+    detail = nextDetail;
     for (const entry of camera.all()) if (entry.value && gl) release(gl, entry.value);
     camera.dispose();
     cameraKey = key;
-    camera = makeCamera(layers, source);
+    camera = makeCamera(layers, source, edgeRadius);
     generation += 1;
     if (target > 0) camera.update();
   }
   function release(context, tile) {
     if (tile.gl) {
       context.deleteVertexArray(tile.gl.vao);
+      if (tile.gl.contact) {
+        context.deleteVertexArray(tile.gl.contact.vao);
+        context.deleteBuffer(tile.gl.contact.vbo);
+      }
       context.deleteBuffer(tile.gl.vbo);
       context.deleteBuffer(tile.gl.ibo);
       tile.gl = void 0;
@@ -9806,7 +10602,9 @@ function createTileflowBuildings3D(options) {
     }
   }
   function upload(context) {
+    const modelKey = models.key();
     models.upload(context);
+    if (modelKey !== models.key()) map.triggerRepaint();
     let budget = 2;
     for (const { value: entry } of camera.ready()) {
       if (entry.gl) continue;
@@ -9839,14 +10637,18 @@ function createTileflowBuildings3D(options) {
       context.bindVertexArray(null);
       entry.gl = { vao, vbo, ibo };
       generation += 1;
+      map.triggerRepaint();
     }
   }
+  let fallbackStyle;
+  let fallbackSun;
+  function standaloneStyle() {
+    return fallbackStyle ??= map.getStyle() ?? {};
+  }
   let designs;
   function designsOnScreen() {
     const read = options.controller?.getThemeMetadata?.(tileflowBuildingsMetadataKey) ?? {
-      values: [
-        map.getStyle()?.metadata?.[tileflowBuildingsMetadataKey]
-      ],
+      values: [standaloneStyle().metadata?.[tileflowBuildingsMetadataKey]],
       position: 0
     };
     if (!designs || designs.values.length !== read.values.length || designs.values.some((value, index) => value !== read.values[index])) {
@@ -9970,14 +10772,17 @@ function createTileflowBuildings3D(options) {
     return [...rgbOf2(typeof text2 === "string" ? text2 : "#d8d0c0") ?? [0.85, 0.82, 0.76]];
   }
   function sunNow() {
-    return options.controller?.getSun?.() ?? resolveTileflowSun(tileflowDefaultSunPreset);
+    return options.controller?.getSun?.() ?? (fallbackSun ??= resolveTileflowSun(tileflowStyleSunPreset(standaloneStyle())));
   }
   function lighting() {
-    return tileflowSceneLight(sunNow(), design().shadows);
+    const light = tileflowSceneLight(sunNow(), design().shadows);
+    return { ...light, strength: light.strength * visibleOpacity() };
   }
   function visibleScale() {
-    const fade = Math.min(1, Math.max(0, (map.getZoom() - (minzoom - 0.5)) / 0.5));
-    return scale * fade;
+    return visibleOpacity() > 0 ? scale : 0;
+  }
+  function visibleOpacity() {
+    return opacity * tileflowSceneOpacity(map.getZoom(), minzoom);
   }
   function drawn() {
     return camera.ready().filter((entry) => entry.value.gl);
@@ -10013,19 +10818,45 @@ function createTileflowBuildings3D(options) {
       const program = programs.depth;
       if (!program) return;
       context.useProgram(program.program);
-      context.uniform1f(program.uniforms.u_preview_opacity ?? null, opacity);
       context.uniform1f(program.uniforms.u_scale, visibleScale());
       context.uniform1f(program.uniforms.u_metres, frame.metres);
       context.uniformMatrix4fv(program.uniforms.u_light_matrix, false, frame.light.matrix);
       for (const { x: x3, y: y2, value } of drawn()) {
-        context.uniform2f(program.uniforms.u_offset, ...frame.offsetOf({ x: x3, y: y2 }, camera.zoom));
+        const offset = frame.offsetOf({ x: x3, y: y2 }, camera.zoom);
+        if (!buildingBoxVisible(frame.light.matrix, [
+          (offset[0] - 1) * frame.metres,
+          -(offset[1] + tileflowBuildingExtent + 1) * frame.metres,
+          0,
+          (offset[0] + tileflowBuildingExtent + 1) * frame.metres,
+          -(offset[1] - 1) * frame.metres,
+          value.mesh.top + 0.1
+        ]))
+          continue;
+        const ranges = buildingDrawRanges(
+          value.mesh,
+          ({ bounds: [left, top, right, bottom, height] }) => buildingBoxVisible(frame.light.matrix, [
+            (left + offset[0]) * frame.metres,
+            -(bottom + offset[1]) * frame.metres,
+            0,
+            (right + offset[0]) * frame.metres,
+            -(top + offset[1]) * frame.metres,
+            height
+          ])
+        );
+        if (!ranges.length) continue;
+        context.uniform2f(program.uniforms.u_offset, ...offset);
         context.bindVertexArray(value.gl.vao);
-        context.drawElements(context.TRIANGLES, value.mesh.indices.length, context.UNSIGNED_INT, 0);
+        for (const range of ranges)
+          context.drawElements(
+            context.TRIANGLES,
+            range.count,
+            context.UNSIGNED_INT,
+            range.from * 4
+          );
       }
       const modelDepth = programs.modelDepth;
       if (!modelDepth) return;
       context.useProgram(modelDepth.program);
-      context.uniform1f(modelDepth.uniforms.u_preview_opacity ?? null, opacity);
       context.uniformMatrix4fv(modelDepth.uniforms.u_light_matrix, false, frame.light.matrix);
       context.uniform1f(modelDepth.uniforms.u_scale, visibleScale());
       context.uniform1f(modelDepth.uniforms.u_metres, frame.metres);
@@ -10102,6 +10933,46 @@ function createTileflowBuildings3D(options) {
     context.uniform1f(uniforms.u_projection_transition, data.projectionTransition);
     context.uniformMatrix4fv(uniforms.u_projection_fallback_matrix, false, data.fallbackMatrix);
   }
+  function viewRanges(args, tile, margin = 0, wallsOnly = false) {
+    const data = args.getProjectionData({
+      tileID: { canonical: { x: tile.x, y: tile.y, z: camera.zoom }, wrap: 0 }
+    });
+    const mercator = args.shaderData.variantName === "mercator";
+    const reach = margin / camera.metres + 1;
+    if (mercator && !buildingBoxVisible(data.mainMatrix, [
+      -reach,
+      -reach,
+      0,
+      tileflowBuildingExtent + reach,
+      tileflowBuildingExtent + reach,
+      tile.value.mesh.top + 0.1
+    ]))
+      return [];
+    return buildingDrawRanges(
+      tile.value.mesh,
+      ({ bounds: [left, top, right, bottom, height] }) => !mercator || buildingBoxVisible(data.mainMatrix, [
+        left - reach,
+        top - reach,
+        0,
+        right + reach,
+        bottom + reach,
+        height
+      ]),
+      wallsOnly
+    );
+  }
+  function groundVisible(args, x3, y2) {
+    if (args.shaderData.variantName !== "mercator") return true;
+    const data = args.getProjectionData({ tileID: { canonical: { x: x3, y: y2, z: camera.zoom }, wrap: 0 } });
+    return buildingBoxVisible(data.mainMatrix, [
+      0,
+      0,
+      0,
+      tileflowBuildingExtent,
+      tileflowBuildingExtent,
+      0
+    ]);
+  }
   function pixelRatio2(context) {
     const canvas = context.canvas;
     const width = canvas.clientWidth;
@@ -10117,90 +10988,105 @@ function createTileflowBuildings3D(options) {
     const nightLight2 = mixed2((entry) => entry.nightLight);
     const edges = mixed2((entry) => entry.edges);
     const { occlusion: occlusionOn, windows: windowsOn } = design();
-    const buildings = programs.buildings;
-    const u = buildings.uniforms;
-    context.useProgram(buildings.program);
-    context.uniform1f(buildings.uniforms.u_preview_opacity ?? null, opacity);
-    context.uniform1f(u.u_scale, shown);
-    context.uniform1f(u.u_metres, placed2(0, 0).metres);
-    context.uniform3fv(u.u_colour, themeColour());
-    context.uniform3fv(u.u_sun_dir, [...light.direction]);
-    context.uniform3fv(u.u_shadow_dir, light.shadowDirection);
-    context.uniform3fv(u.u_sun_light, light.sunLight);
-    context.uniform3fv(u.u_sky_light, light.skyLight);
-    context.uniform1f(u.u_occlusion, occlusionOn ? occlusion.wall : 0);
-    context.uniform1f(u.u_corner, occlusion.corner);
-    context.uniform1f(u.u_night, light.night);
-    context.uniform1f(u.u_windows, windowsOn ? 1 : 0);
-    context.uniform1f(u.u_flood, light.night * nightLight2);
-    context.uniform3fv(u.u_flood_colour, flood.colour);
-    context.uniform1f(
-      u.u_variation,
-      mixed2((entry) => entry.colorVariation)
-    );
-    const styleLight = tileflowBuildingStyleLight(
-      map.getLight?.() ?? fallbackStyleLight,
-      map.getBearing()
-    );
-    context.uniform3fv(u.u_style_light_position, styleLight.position);
-    context.uniform3fv(u.u_style_light_colour, styleLight.colour);
-    context.uniform1f(u.u_style_light_intensity, styleLight.intensity);
-    context.uniform1f(
-      u.u_style_gradient,
-      mixed2((entry) => entry.verticalGradient ? 1 : 0)
-    );
-    context.uniform1f(
-      u.u_sun_lighting,
-      mixed2((entry) => entry.lighting === "sun" ? 1 : 0)
-    );
-    const edgeColour = edgeColourNow();
-    const lightEdge = edges * (edgeLine.day + (1 - edgeLine.day) * light.night);
-    context.uniform1f(u.u_edge, lightEdge + (edges - lightEdge) * edgeColour.share);
-    context.uniform3fv(u.u_edge_colour, edgeColour.rgb);
-    context.uniform1f(u.u_edge_own, edgeColour.share);
-    context.uniform1f(u.u_edge_width, edgeLine.width * pixelRatio2(context));
-    scene.bindShadow(context, u, light.strength);
-    for (const { x: x3, y: y2, value: entry } of entries) {
-      project(context, buildings, args, x3, y2);
-      context.uniform2f(u.u_offset, ...placed2(x3, y2).offset);
-      const palette = themes ? paletteOf(context, entry, themes.themes) : void 0;
-      context.uniform1f(u.u_palette_on, palette ? 1 : 0);
-      context.activeTexture(context.TEXTURE1);
-      context.bindTexture(context.TEXTURE_2D, palette?.texture ?? blank ?? null);
-      context.uniform1i(u.u_palette, 1);
-      if (palette && themes) {
-        context.uniform2f(u.u_palette_rows, palette.rows, paletteWidth);
-        context.uniform2f(u.u_palette_themes, themes.lower, themes.upper);
-        context.uniform1f(u.u_palette_mix, themes.mix);
-      }
-      context.bindVertexArray(entry.gl.vao);
-      context.drawElements(context.TRIANGLES, entry.mesh.indices.length, context.UNSIGNED_INT, 0);
-    }
-    const model = programs.model;
-    if (model && standing.length > 0) {
-      const m = model.uniforms;
-      context.useProgram(model.program);
-      context.uniform1f(model.uniforms.u_preview_opacity ?? null, opacity);
-      context.disable(context.CULL_FACE);
-      context.uniform1f(m.u_scale, shown);
-      context.uniform3fv(m.u_sun_dir, [...light.direction]);
-      context.uniform3fv(m.u_shadow_dir, light.shadowDirection);
-      context.uniform3fv(m.u_sun_light, light.sunLight);
-      context.uniform3fv(m.u_sky_light, light.skyLight);
-      context.uniform1f(m.u_night, light.night);
-      context.uniform3fv(m.u_part_colours, partColoursNow());
-      scene.bindShadow(context, m, light.strength);
-      const centre = map.getCenter();
-      for (const entry of standing) {
-        const stand = standOf(entry);
-        project(context, model, args, stand.tileX, stand.tileY);
-        const at = placed2(stand.tileX, stand.tileY);
-        context.uniform2f(m.u_offset, ...at.offset);
-        context.uniform1f(m.u_metres, at.metres);
-        setPlacement(context, model, entry, stand);
-        drawModel(context, model, entry, models.levelOf(entry, centre));
+    context.enable(context.DEPTH_TEST);
+    context.depthFunc(context.LEQUAL);
+    context.depthMask(true);
+    context.disable(context.BLEND);
+    drawBuildingOpacity(context, visibleOpacity(), () => {
+      const buildings = programs.buildings;
+      const u = buildings.uniforms;
+      context.useProgram(buildings.program);
+      context.uniform1f(u.u_scale, shown);
+      context.uniform1f(u.u_metres, placed2(0, 0).metres);
+      context.uniform3fv(u.u_colour, themeColour());
+      context.uniform3fv(u.u_sun_dir, [...light.direction]);
+      context.uniform3fv(u.u_shadow_dir, light.shadowDirection);
+      context.uniform3fv(u.u_sun_light, light.sunLight);
+      context.uniform3fv(u.u_sky_light, light.skyLight);
+      context.uniform1f(u.u_occlusion, occlusionOn ? tileflowBuildingOcclusion.wall : 0);
+      context.uniform1f(u.u_occlusion_radius, tileflowBuildingOcclusion.wallRadius);
+      context.uniform1f(u.u_corner, tileflowBuildingOcclusion.corner);
+      context.uniform1f(u.u_night, light.night);
+      context.uniform1f(u.u_windows, windowsOn ? 1 : 0);
+      context.uniform1f(u.u_flood, light.night * nightLight2);
+      context.uniform3fv(u.u_flood_colour, flood.colour);
+      context.uniform1f(
+        u.u_variation,
+        mixed2((entry) => entry.colorVariation)
+      );
+      const styleLight = tileflowBuildingStyleLight(
+        map.getLight?.() ?? fallbackStyleLight,
+        map.getBearing()
+      );
+      context.uniform3fv(u.u_style_light_position, styleLight.position);
+      context.uniform3fv(u.u_style_light_colour, styleLight.colour);
+      context.uniform1f(u.u_style_light_intensity, styleLight.intensity);
+      context.uniform1f(u.u_edge_radius, design().edgeRadius ?? 0);
+      context.uniform1f(
+        u.u_style_gradient,
+        mixed2((entry) => entry.verticalGradient ? 1 : 0)
+      );
+      context.uniform1f(
+        u.u_sun_lighting,
+        mixed2((entry) => entry.lighting === "sun" ? 1 : 0)
+      );
+      const edgeColour = edgeColourNow();
+      const lightEdge = edges * (edgeLine.day + (1 - edgeLine.day) * light.night);
+      context.uniform1f(u.u_edge, lightEdge + (edges - lightEdge) * edgeColour.share);
+      context.uniform3fv(u.u_edge_colour, edgeColour.rgb);
+      context.uniform1f(u.u_edge_own, edgeColour.share);
+      context.uniform1f(u.u_edge_width, edgeLine.width * pixelRatio2(context));
+      scene.bindShadow(context, u, light.strength);
+      for (const tile of entries) {
+        const { x: x3, y: y2, value: entry } = tile;
+        const ranges = viewRanges(args, tile);
+        if (!ranges.length) continue;
+        project(context, buildings, args, x3, y2);
+        context.uniform2f(u.u_offset, ...placed2(x3, y2).offset);
+        const palette = themes ? paletteOf(context, entry, themes.themes) : void 0;
+        context.uniform1f(u.u_palette_on, palette ? 1 : 0);
+        context.activeTexture(context.TEXTURE1);
+        context.bindTexture(context.TEXTURE_2D, palette?.texture ?? blank ?? null);
+        context.uniform1i(u.u_palette, 1);
+        if (palette && themes) {
+          context.uniform2f(u.u_palette_rows, palette.rows, paletteWidth);
+          context.uniform2f(u.u_palette_themes, themes.lower, themes.upper);
+          context.uniform1f(u.u_palette_mix, themes.mix);
+        }
+        context.bindVertexArray(entry.gl.vao);
+        for (const range of ranges)
+          context.drawElements(
+            context.TRIANGLES,
+            range.count,
+            context.UNSIGNED_INT,
+            range.from * 4
+          );
       }
-    }
+      const model = programs.model;
+      if (model && standing.length > 0) {
+        const m = model.uniforms;
+        context.useProgram(model.program);
+        context.disable(context.CULL_FACE);
+        context.uniform1f(m.u_scale, shown);
+        context.uniform3fv(m.u_sun_dir, [...light.direction]);
+        context.uniform3fv(m.u_shadow_dir, light.shadowDirection);
+        context.uniform3fv(m.u_sun_light, light.sunLight);
+        context.uniform3fv(m.u_sky_light, light.skyLight);
+        context.uniform1f(m.u_night, light.night);
+        context.uniform3fv(m.u_part_colours, partColoursNow());
+        scene.bindShadow(context, m, light.strength);
+        const centre = map.getCenter();
+        for (const entry of standing) {
+          const stand = standOf(entry);
+          project(context, model, args, stand.tileX, stand.tileY);
+          const at = placed2(stand.tileX, stand.tileY);
+          context.uniform2f(m.u_offset, ...at.offset);
+          context.uniform1f(m.u_metres, at.metres);
+          setPlacement(context, model, entry, stand);
+          drawModel(context, model, entry, models.levelOf(entry, centre));
+        }
+      }
+    });
     context.depthMask(false);
     context.enable(context.BLEND);
     context.blendFuncSeparate(context.DST_COLOR, context.ZERO, context.ZERO, context.ONE);
@@ -10208,7 +11094,6 @@ function createTileflowBuildings3D(options) {
     if (light.strength > 0 && frame && frame.zoom === camera.zoom && ground && scene.drawsGround(caster)) {
       const program = programs.ground;
       context.useProgram(program.program);
-      context.uniform1f(program.uniforms.u_preview_opacity ?? null, opacity);
       context.uniform1f(program.uniforms.u_metres, frame.metres);
       context.uniform3fv(program.uniforms.u_ground_shadow, light.groundShadow);
       scene.bindShadow(context, program.uniforms, light.strength);
@@ -10223,45 +11108,80 @@ function createTileflowBuildings3D(options) {
       const [left, top, right, bottom] = frame.tiles;
       for (let x3 = left - margin; x3 <= right + margin; x3 += 1)
         for (let y2 = top - margin; y2 <= bottom + margin; y2 += 1) {
+          if (!groundVisible(args, x3, y2)) continue;
           project(context, program, args, x3, y2);
           context.uniform2f(program.uniforms.u_offset, ...frame.offsetOf({ x: x3, y: y2 }));
           context.drawArrays(context.TRIANGLE_STRIP, 0, 4);
         }
     }
     const walls = (program) => {
-      for (const { x: x3, y: y2, value } of entries) {
+      for (const tile of entries) {
+        const { x: x3, y: y2, value } = tile;
         const mesh = value.mesh;
         if (mesh.indices.length <= mesh.wallsFrom) continue;
         project(context, program, args, x3, y2);
         context.uniform2f(program.uniforms.u_offset, ...camera.offsetOf({ x: x3, y: y2 }));
         context.bindVertexArray(value.gl.vao);
-        context.drawElements(
-          context.TRIANGLES,
-          mesh.indices.length - mesh.wallsFrom,
-          context.UNSIGNED_INT,
-          mesh.wallsFrom * 4
-        );
+        for (const range of viewRanges(args, tile, flood.reach, true))
+          context.drawElements(
+            context.TRIANGLES,
+            range.count,
+            context.UNSIGNED_INT,
+            range.from * 4
+          );
       }
     };
-    if (occlusionOn) {
-      const program = programs.band;
-      context.useProgram(program.program);
-      context.uniform1f(program.uniforms.u_preview_opacity ?? null, opacity);
-      context.uniform1f(program.uniforms.u_scale, shown);
-      context.uniform1f(program.uniforms.u_metres, camera.metres);
-      context.uniform1f(program.uniforms.u_band, occlusion.ground);
-      context.uniform1f(program.uniforms.u_band_strength, occlusion.groundStrength);
-      walls(program);
+    if (occlusionOn && entries.length > 0 && ground) {
+      const program = programs.contact;
+      const texture = contactMask.render(context, () => {
+        context.useProgram(program.program);
+        context.uniform1f(program.uniforms.u_scale, shown);
+        context.uniform1f(program.uniforms.u_metres, camera.metres);
+        context.uniform1f(program.uniforms.u_band, tileflowBuildingOcclusion.ground);
+        context.uniform1f(
+          program.uniforms.u_band_strength,
+          tileflowBuildingOcclusion.groundStrength * visibleOpacity()
+        );
+        for (const tile of entries) {
+          const { x: x3, y: y2, value } = tile;
+          const ranges = viewRanges(args, tile, tileflowBuildingOcclusion.ground, true);
+          if (!ranges.length) continue;
+          const buffers = value.gl;
+          buffers.contact ??= createBuildingContactVao(context, value.mesh);
+          project(context, program, args, x3, y2);
+          context.bindVertexArray(buffers.contact.vao);
+          for (const range of ranges) {
+            buffers.contact.offset((range.from - value.mesh.wallsFrom) / 6);
+            context.drawArraysInstanced(context.TRIANGLE_STRIP, 0, 4, range.count / 6);
+          }
+        }
+      });
+      const composite = programs.contactComposite;
+      context.useProgram(composite.program);
+      context.activeTexture(context.TEXTURE2);
+      context.bindTexture(context.TEXTURE_2D, texture);
+      context.uniform1i(composite.uniforms.u_contact, 2);
+      context.bindVertexArray(ground.vao);
+      const xs = entries.map(({ x: x3 }) => x3);
+      const ys = entries.map(({ y: y2 }) => y2);
+      for (let x3 = Math.min(...xs) - 1; x3 <= Math.max(...xs) + 1; x3 += 1)
+        for (let y2 = Math.min(...ys) - 1; y2 <= Math.max(...ys) + 1; y2 += 1) {
+          if (!groundVisible(args, x3, y2)) continue;
+          project(context, composite, args, x3, y2);
+          context.drawArrays(context.TRIANGLE_STRIP, 0, 4);
+        }
+      context.bindTexture(context.TEXTURE_2D, null);
+    } else {
+      contactMask.release(context);
     }
     if (nightLight2 > 0 && light.night > 0.01) {
       const program = programs.flood;
       context.useProgram(program.program);
-      context.uniform1f(program.uniforms.u_preview_opacity ?? null, opacity);
       context.blendFuncSeparate(context.ONE, context.ONE, context.ZERO, context.ONE);
       context.uniform1f(program.uniforms.u_scale, shown);
       context.uniform1f(program.uniforms.u_metres, camera.metres);
       context.uniform1f(program.uniforms.u_band, flood.reach);
-      context.uniform1f(program.uniforms.u_flood, light.night * nightLight2);
+      context.uniform1f(program.uniforms.u_flood, light.night * nightLight2 * visibleOpacity());
       context.uniform3fv(program.uniforms.u_flood_colour, flood.colour);
       walls(program);
     }
@@ -10275,7 +11195,8 @@ ${shaderData.define}`;
     const sources = {
       buildings: [tileflowBuildingVertex(projected), tileflowBuildingFragment],
       ground: [tileflowBuildingGroundVertex(projected), tileflowBuildingGroundFragment],
-      band: [tileflowBuildingBandVertex(projected), tileflowBuildingBandFragment],
+      contact: [buildingContactVertex(projected), buildingContactFragment],
+      contactComposite: [tileflowBuildingGroundVertex(projected), buildingContactCompositeFragment],
       flood: [tileflowBuildingBandVertex(projected), tileflowBuildingFloodFragment]
     };
     sources.model = [tileflowModelVertex(projected), tileflowModelFragment];
@@ -10292,11 +11213,7 @@ ${shaderData.define}`;
       };
       const program = context.createProgram();
       const vertex = shader(context.VERTEX_SHADER, vertexText);
-      const fadeFragment = name.toLowerCase().includes("depth") ? fragmentText : fragmentText.replace(
-        "void main() {",
-        "uniform float u_preview_opacity;\nvoid main() {\n  if (u_preview_opacity < 1.0 && fract(sin(dot(floor(gl_FragCoord.xy), vec2(12.9898, 78.233))) * 43758.5453) >= u_preview_opacity) discard;"
-      );
-      const fragment = shader(context.FRAGMENT_SHADER, fadeFragment);
+      const fragment = shader(context.FRAGMENT_SHADER, fragmentText);
       context.attachShader(program, vertex);
       context.attachShader(program, fragment);
       const bound = name === "model" || name === "modelDepth" ? tileflowModelAttributes : tileflowBuildingAttributes;
@@ -10380,13 +11297,15 @@ ${shaderData.define}`;
   }
   let fallbackStyleLight;
   const onStyle = () => {
-    if (!map.getLight)
-      fallbackStyleLight = map.getStyle()?.light;
+    fallbackStyle = void 0;
+    fallbackSun = void 0;
+    if (!map.getLight) fallbackStyleLight = standaloneStyle().light;
     attach();
   };
   map.on("styledata", onStyle);
   map.on("idle", onStyle);
   onStyle();
+  camera.update();
   function grow(goal, change) {
     if (disposed) return Promise.resolve();
     if (!Number.isFinite(goal))
@@ -10508,6 +11427,7 @@ ${shaderData.define}`;
       } catch {
       }
       camera.dispose();
+      mesher.dispose();
     }
   };
 }
@@ -10831,11 +11751,12 @@ function createTileflowStreetLights(options) {
   let corners;
   let disposed = false;
   let lastUpdate = 0;
+  let fallbackMetadata;
   let designs;
   function designsOnScreen() {
     const read = options.controller?.getThemeMetadata?.(tileflowStreetLightsMetadataKey) ?? {
       values: [
-        map.getStyle()?.metadata?.[tileflowStreetLightsMetadataKey]
+        (fallbackMetadata ??= map.getStyle()?.metadata ?? {})[tileflowStreetLightsMetadataKey]
       ],
       position: 0
     };
@@ -10845,7 +11766,9 @@ function createTileflowStreetLights(options) {
       );
       designs = {
         values: read.values,
-        parsed: parsed.map((entry) => entry ?? tileflowDefaultStreetLightsDesign),
+        parsed: parsed.map(
+          (entry) => options.enabled === false ? disabledStreetLightsDesign : entry ?? (options.enabled === true ? tileflowDefaultStreetLightsDesign : disabledStreetLightsDesign)
+        ),
         declared: parsed.some((entry) => entry !== void 0)
       };
     }
@@ -10929,6 +11852,7 @@ function createTileflowStreetLights(options) {
     return options.controller?.getSun?.() ?? resolveTileflowSun(tileflowDefaultSunPreset);
   }
   function onNow() {
+    if (appearance().intensity <= 0) return 0;
     const brightness = sunNow().brightness;
     return Math.min(1, Math.max(0, (switchOn[1] - brightness) / (switchOn[1] - switchOn[0])));
   }
@@ -11106,13 +12030,22 @@ ${shaderData.define}`;
     return style?.layers?.find((entry) => entry.type === "symbol")?.id;
   }
   function attach() {
-    if (disposed || map.getLayer(tileflowStreetLightsLayerId) || !map.isStyleLoaded()) return;
+    if (disposed || !map.isStyleLoaded()) return;
+    const enabled = designsOnScreen().themes.some((theme) => theme.intensity > 0);
+    if (!enabled) {
+      if (map.getLayer(tileflowStreetLightsLayerId)) map.removeLayer(tileflowStreetLightsLayerId);
+      return;
+    }
+    if (map.getLayer(tileflowStreetLightsLayerId)) return;
     try {
       map.addLayer(layer, beforeId());
     } catch {
     }
   }
-  const onStyle = () => attach();
+  const onStyle = () => {
+    fallbackMetadata = void 0;
+    attach();
+  };
   map.on("styledata", onStyle);
   map.on("idle", onStyle);
   attach();
@@ -11148,6 +12081,10 @@ ${shaderData.define}`;
     }
   };
 }
+var disabledStreetLightsDesign = Object.freeze({
+  ...tileflowDefaultStreetLightsDesign,
+  intensity: 0
+});
 var emptyTile2 = Object.freeze({
   placement: Object.freeze({ lamps: new Uint8Array(0), mapped: 0, estimated: 0 })
 });
@@ -11265,7 +12202,9 @@ var tileflowWorldTreeFields = Object.freeze({
   canopyRank: "rank",
   canopyClearance: "clearance_px_z15",
   canopyCover: "cover_pct",
-  canopyHeight: "height_m"
+  canopyHeight: "height_m",
+  subclass: "subclass",
+  hedge: "hedge"
 });
 var tileflowDefaultUnknownTreeForms = Object.freeze({
   round: 1,
@@ -11289,6 +12228,11 @@ function tileflowTreeFormProportion(form) {
 }
 var heightBounds = [2, 45];
 var crownBounds = [1, 25];
+var hedgeSpacing = 1.2;
+var hedgeLength = 1.5;
+var hedgeHeight = 1.3;
+var hedgeBank = 1;
+var hedgeBounds = [0.3, 10];
 var palms = /* @__PURE__ */ new Set([
   "acoelorrhaphe",
   "adonidia",
@@ -11586,6 +12530,49 @@ function placeTileflowTrees(layers, options) {
         }
     }
   }
+  const hedges = [];
+  const barriers = layers.hedges;
+  if (barriers) {
+    const scale = extent3 / barriers.extent;
+    const step = hedgeSpacing / (tileMetres / barriers.extent);
+    for (const feature of barriers.features) {
+      if (feature.type === "Point" || feature.properties[fields.subclass] !== "hedge") continue;
+      const bank = feature.properties[fields.hedge] === "hedge_bank" ? hedgeBank : 0;
+      const height = (measured(feature.properties[fields.height], hedgeBounds) ?? hedgeHeight) + bank;
+      for (const points2 of feature.geometry) {
+        let next = step / 2;
+        let along = 0;
+        for (let index = 0; index + 3 < points2.length; index += 2) {
+          const [ax, ay, bx, by] = [
+            points2[index],
+            points2[index + 1],
+            points2[index + 2],
+            points2[index + 3]
+          ];
+          const length = Math.hypot(bx - ax, by - ay);
+          const turn = (Math.atan2(ay - by, bx - ax) / (Math.PI * 2) + 1) % 1;
+          while (next <= along + length) {
+            const t = length > 0 ? (next - along) / length : 0;
+            const px = ax + (bx - ax) * t;
+            const py = ay + (by - ay) * t;
+            if (px >= 0 && py >= 0 && px < barriers.extent && py < barriers.extent) {
+              const seed = hash3(tile.x * extent3 + px * scale, tile.y * extent3 + py * scale, 17);
+              hedges.push({
+                x: px * scale,
+                y: py * scale,
+                height,
+                turn,
+                shade: unit(seed, 5),
+                seed: unit(seed, 7)
+              });
+            }
+            next += step;
+          }
+          along += length;
+        }
+      }
+    }
+  }
   const variantsOf = (form) => clamp(Math.floor(options.variants?.[tileflowTreeForms[form]] ?? 1), [1, 4]);
   const variant = (tree) => Math.min(
     variantsOf(tree.form) - 1,
@@ -11630,7 +12617,20 @@ function placeTileflowTrees(layers, options) {
     count(ranges, index, tree.rank);
     count(ranges.variants[variants[from]], index, tree.rank);
   });
-  return { trees: bytes, forms, tallest, mapped, canopy };
+  const hedgeBytes = new Uint8Array(hedges.length * tileflowTreeBytes);
+  const hedgeView = new DataView(hedgeBytes.buffer);
+  hedges.forEach((piece, index) => {
+    const at = index * tileflowTreeBytes;
+    hedgeView.setUint16(at, Math.min(extent3 - 1, Math.round(piece.x)), true);
+    hedgeView.setUint16(at + 2, Math.min(extent3 - 1, Math.round(piece.y)), true);
+    hedgeView.setUint16(at + 4, Math.round(piece.height * 10), true);
+    hedgeView.setUint16(at + 6, Math.round(hedgeLength * 10), true);
+    hedgeBytes[at + 8] = Math.round(piece.turn * 256) & 255;
+    hedgeBytes[at + 9] = Math.floor(piece.shade * 256) & 255;
+    hedgeBytes[at + 12] = Math.floor(piece.seed * 256) & 255;
+    tallest = Math.max(tallest, piece.height);
+  });
+  return { trees: bytes, forms, hedges: hedgeBytes, tallest, mapped, canopy };
 }
 function broadleafOf(mix2) {
   const broad = { round: mix2.round ?? 0, open: mix2.open ?? 0, tall: mix2.tall ?? 0 };
@@ -11688,6 +12688,7 @@ function readTileflowVegetation3D(metadata) {
   const conifer = palette(colors.conifer);
   const palm = palette(colors.palm) ?? broadleaf;
   if (!broadleaf || !conifer || !palm) return void 0;
+  const hedge = palette(colors.hedge) ?? broadleaf.slice(0, 2);
   const scale = (number) => typeof number === "number" && number > 0 && number <= 10 ? number : 1;
   const mix2 = tileflowTreeFormMixProblem(unknownForms) === void 0 ? unknownForms : void 0;
   const models = Object.fromEntries(
@@ -11731,10 +12732,11 @@ function readTileflowVegetation3D(metadata) {
     source,
     layers: {
       tree: layers.tree,
-      ...typeof layers.canopy === "string" ? { canopy: layers.canopy } : {}
+      ...typeof layers.canopy === "string" ? { canopy: layers.canopy } : {},
+      ...typeof layers.hedge === "string" ? { hedge: layers.hedge } : {}
     },
     fields: named,
-    colors: { bark: colors.bark, broadleaf, conifer, palm },
+    colors: { bark: colors.bark, broadleaf, conifer, palm, hedge },
     heightScale: scale(heightScale),
     crownScale: scale(crownScale),
     forms,
@@ -11774,6 +12776,75 @@ function tileflowTreeMeshes() {
     ])
   );
 }
+function tileflowHedgeMesh() {
+  const out = {
+    positions: [],
+    normals: [],
+    rounds: [],
+    parts: [],
+    shades: [],
+    occlusion: []
+  };
+  const half = 0.275;
+  const profile = [
+    [-half, 0],
+    [-half, 0.78],
+    [-half * 0.62, 1],
+    [half * 0.62, 1],
+    [half, 0.78],
+    [half, 0]
+  ];
+  const round2 = ([y2, z2]) => normalize([0, y2 / half, Math.max(0, z2 - 0.45) / 0.55]);
+  const shaded = (z2) => 0.55 + 0.45 * z2;
+  for (let index = 0; index + 1 < profile.length; index += 1) {
+    const [y0, z0] = profile[index];
+    const [y1, z1] = profile[index + 1];
+    let facet = normalize([0, z1 - z0, -(y1 - y0)]);
+    if (facet[1] * (y0 + y1) + facet[2] * (z0 + z1 - 0.9) < 0)
+      facet = [-facet[0], -facet[1], -facet[2]];
+    const quad = [
+      [-0.5, y0, z0],
+      [0.5, y0, z0],
+      [0.5, y1, z1],
+      [-0.5, y1, z1]
+    ];
+    const rounds = [round2([y0, z0]), round2([y0, z0]), round2([y1, z1]), round2([y1, z1])];
+    for (const [a, b2, c] of [
+      [0, 1, 2],
+      [0, 2, 3]
+    ])
+      triangle(
+        out,
+        [quad[a], quad[b2], quad[c]],
+        [facet, facet, facet],
+        tileflowTreeParts.leaves,
+        0,
+        [shaded(quad[a][2]), shaded(quad[b2][2]), shaded(quad[c][2])],
+        [rounds[a], rounds[b2], rounds[c]]
+      );
+  }
+  for (const x3 of [-0.5, 0.5]) {
+    const facet = [Math.sign(x3), 0, 0];
+    const centre = [x3, 0, 0.5];
+    for (let index = 0; index + 1 < profile.length; index += 1) {
+      const points = [
+        centre,
+        [x3, ...profile[index]],
+        [x3, ...profile[index + 1]]
+      ];
+      triangle(
+        out,
+        points,
+        [facet, facet, facet],
+        tileflowTreeParts.leaves,
+        0,
+        [shaded(0.5), shaded(points[1][2]), shaded(points[2][2])],
+        points.map((point) => normalize([Math.sign(x3), point[1] / half, point[2] - 0.45]))
+      );
+    }
+  }
+  return pack(out);
+}
 function tileflowTreeModelMeshOf(model) {
   const out = {
     positions: [],
@@ -11971,12 +13042,12 @@ function lobe(out, centre, radii, seed, shade, crownBase, shape = "icosa") {
     if (dot2(facet, outward) < 0) facet = [-facet[0], -facet[1], -facet[2]];
     const normals = [facet, facet, facet];
     const rounds = [a, b2, c].map((index) => round2[index]);
-    const occlusion2 = points.map((point) => {
+    const occlusion = points.map((point) => {
       const height = smooth2(crownBase, 1, point[2]);
       const outward2 = Math.min(1, Math.hypot(point[0], point[1]) / 0.45);
       return 0.5 + 0.32 * height + 0.18 * outward2;
     });
-    triangle(out, points, normals, tileflowTreeParts.leaves, shade, occlusion2, rounds);
+    triangle(out, points, normals, tileflowTreeParts.leaves, shade, occlusion, rounds);
   }
 }
 function cone(out, z0, z1, radius, sides, shade, closed) {
@@ -12071,7 +13142,7 @@ function palmTrunk(out, rings, sides) {
         ringAt.z
       ];
       const normal = (angle) => normalize([Math.cos(angle), Math.sin(angle), 0.05]);
-      const occlusion2 = [
+      const occlusion = [
         0.7 + 0.3 * (a.z / palmTop[2]),
         0.7 + 0.3 * (a.z / palmTop[2]),
         0.7 + 0.3 * (b2.z / palmTop[2])
@@ -12082,7 +13153,7 @@ function palmTrunk(out, rings, sides) {
         [normal(a0), normal(a1), normal(a1)],
         tileflowTreeParts.stem,
         shade,
-        occlusion2
+        occlusion
       );
       triangle(
         out,
@@ -12090,7 +13161,7 @@ function palmTrunk(out, rings, sides) {
         [normal(a0), normal(a1), normal(a0)],
         tileflowTreeParts.stem,
         shade,
-        [occlusion2[0], occlusion2[2], occlusion2[2]]
+        [occlusion[0], occlusion[2], occlusion[2]]
       );
     }
   }
@@ -12126,7 +13197,7 @@ function fronds(out, count, segments, tier) {
         ];
       };
       const [a, b2] = [spine[step], spine[step + 1]];
-      const occlusion2 = [0.72 + 0.28 * t0, 0.72 + 0.28 * t1, 0.72 + 0.28 * t1];
+      const occlusion = [0.72 + 0.28 * t0, 0.72 + 0.28 * t1, 0.72 + 0.28 * t1];
       for (const sign of [-1, 1]) {
         const quad = [a, b2, edge(b2, t1, sign), edge(a, t0, sign)];
         let facet = faceNormal([quad[0], quad[1], quad[2]]);
@@ -12138,7 +13209,7 @@ function fronds(out, count, segments, tier) {
           [normal, normal, normal],
           tileflowTreeParts.fronds,
           shade,
-          occlusion2
+          occlusion
         );
         triangle(
           out,
@@ -12146,13 +13217,13 @@ function fronds(out, count, segments, tier) {
           [normal, normal, normal],
           tileflowTreeParts.fronds,
           shade,
-          [occlusion2[0], occlusion2[2], occlusion2[0]]
+          [occlusion[0], occlusion[2], occlusion[0]]
         );
       }
     }
   }
 }
-function triangle(out, points, normals, part, shade, occlusion2, rounds = normals) {
+function triangle(out, points, normals, part, shade, occlusion, rounds = normals) {
   const facing = dot2(faceNormal(points), [
     normals[0][0] + normals[1][0] + normals[2][0],
     normals[0][1] + normals[1][1] + normals[2][1],
@@ -12165,7 +13236,7 @@ function triangle(out, points, normals, part, shade, occlusion2, rounds = normal
     out.rounds.push(...rounds[index]);
     out.parts.push(part);
     out.shades.push(shade);
-    out.occlusion.push(Math.min(1, Math.max(0, occlusion2[index])));
+    out.occlusion.push(Math.min(1, Math.max(0, occlusion[index])));
   }
 }
 function pack(out) {
@@ -12322,7 +13393,7 @@ function decodeTileflowTreeModel(text2, level) {
   const normals = [];
   const parts = [];
   const shades = [];
-  const occlusion2 = [];
+  const occlusion = [];
   for (let index = 0; index < count; index += 1) {
     const at = headerBytes + index * vertexBytes;
     for (let axis = 0; axis < 3; axis += 1) {
@@ -12332,7 +13403,7 @@ function decodeTileflowTreeModel(text2, level) {
     if (bytes[at + 9] >= partCount2) return void 0;
     parts.push(bytes[at + 9]);
     shades.push(bytes[at + 10] / 255 * 2 - 1);
-    occlusion2.push(bytes[at + 11] / 255);
+    occlusion.push(bytes[at + 11] / 255);
   }
   const indices = [];
   const indexAt = headerBytes + count * vertexBytes;
@@ -12341,7 +13412,7 @@ function decodeTileflowTreeModel(text2, level) {
     if (vertex >= count) return void 0;
     indices.push(vertex);
   }
-  return { proportion, positions, normals, parts, shades, occlusion: occlusion2, indices };
+  return { proportion, positions, normals, parts, shades, occlusion, indices };
 }
 
 // src/trees-3d-shaders.ts
@@ -12404,9 +13475,20 @@ vec3 sceneOf(vec3 local) {
   return vec3((a_tree_pos + u_offset) * u_metres * vec2(1.0, -1.0), 0.0) + local;
 }
 `;
+var treeDither = `
+// An ordered dither shared by visible and depth passes, so faded trees cast faded shadows.
+float dither(vec2 p) {
+  ivec2 i = ivec2(mod(p, 4.0));
+  int index = i.x + i.y * 4;
+  float table[16] = float[16](0.0, 8.0, 2.0, 10.0, 12.0, 4.0, 14.0, 6.0, 3.0, 11.0, 1.0, 9.0, 15.0, 7.0, 13.0, 5.0);
+  return (table[index] + 0.5) / 16.0;
+}`;
 var tileflowTreeDepthVertex = `#version 300 es
 ${attributes3}
 uniform mat4 u_light_matrix;
+uniform vec2 u_centre;
+uniform vec2 u_reach;
+out float v_fade;
 ${placement2}
 void main() {
   float growth = growthOf();
@@ -12415,10 +13497,17 @@ void main() {
     return;
   }
   gl_Position = u_light_matrix * vec4(sceneOf(standing(growth)), 1.0);
+  float distance = length((a_tree_pos - u_centre) * u_metres);
+  v_fade = 1.0 - smoothstep(u_reach.x, u_reach.y, distance);
 }`;
 var tileflowTreeDepthFragment = `#version 300 es
 precision highp float;
-void main() {}`;
+in float v_fade;
+uniform float u_fade;
+${treeDither}
+void main() {
+  if (v_fade * u_fade < dither(gl_FragCoord.xy)) discard;
+}`;
 var tileflowTreeVertex = (projected) => `#version 300 es
 ${projected}
 ${attributes3}
@@ -12468,31 +13557,10 @@ uniform float u_toon; // 1 for light in bands, as a drawing has it
 uniform vec3 u_bark;
 uniform vec3 u_leaves[4]; // the form's colours, sunlit
 uniform float u_leaf_count;
-uniform highp sampler2DShadow u_shadow_map;
-uniform vec2 u_shadow_texel;
-uniform float u_shadow;
-uniform float u_depth_unit;
 out vec4 fragColor;
+${tileflowShadowLookup}
 
-float visibility(vec3 c, float bias) {
-  if (u_shadow <= 0.0 || c.x <= 0.0 || c.y <= 0.0 || c.x >= 1.0 || c.y >= 1.0 || c.z >= 1.0)
-    return 1.0;
-  float z = c.z - bias * u_depth_unit;
-  vec2 o = u_shadow_texel * 0.75;
-  return 0.25 * (
-    texture(u_shadow_map, vec3(c.xy + vec2(-o.x, -o.y), z)) +
-    texture(u_shadow_map, vec3(c.xy + vec2(o.x, -o.y), z)) +
-    texture(u_shadow_map, vec3(c.xy + vec2(-o.x, o.y), z)) +
-    texture(u_shadow_map, vec3(c.xy + vec2(o.x, o.y), z)));
-}
-
-// An ordered dither, so a fading tree thins out instead of turning see-through.
-float dither(vec2 p) {
-  ivec2 i = ivec2(mod(p, 4.0));
-  int index = i.x + i.y * 4;
-  float table[16] = float[16](0.0, 8.0, 2.0, 10.0, 12.0, 4.0, 14.0, 6.0, 3.0, 11.0, 1.0, 9.0, 15.0, 7.0, 13.0, 5.0);
-  return (table[index] + 0.5) / 16.0;
-}
+${treeDither}
 
 vec3 leafColour() {
   float count = max(u_leaf_count, 1.0);
@@ -12536,9 +13604,10 @@ void main() {
   vec3 roof = u_sky_light + u_sun_light * max(u_sun_dir.z, 0.0);
   vec3 colour = base * min(pow(light / max(roof, vec3(1e-4)), vec3(1.0 / 2.2)), vec3(1.5));
   // At night the tops of crowns keep near their theme's colour, as a night theme draws them, so
-  // trees stay apart from the dark ground.
+  // trees stay apart from the dark ground. The lift is neutral: colour comes from the material
+  // and scene illumination, so a grey tree in neutral light stays grey.
   float crownTop = bark ? 0.0 : smoothstep(0.1, 0.9, normal.z);
-  colour = mix(colour, base * 0.95 + vec3(0.02, 0.03, 0.04), u_night * 0.45 * crownTop);
+  colour = mix(colour, base * 0.95 + vec3(0.03), u_night * 0.45 * crownTop);
   fragColor = vec4(colour, 1.0);
 }`;
 var tileflowTreeEdgeVertex = (projected) => `#version 300 es
@@ -12589,6 +13658,40 @@ void main() {
   fragColor = vec4(u_edge_colour, 1.0);
 }`;
 
+// src/trees-3d-view.ts
+function tileflowTreeView(camera) {
+  const n = 2 ** camera.tileZoom;
+  const phi = camera.lat * Math.PI / 180;
+  const centre = [
+    (camera.lng + 180) / 360 * n,
+    (1 - Math.log(Math.tan(phi) + 1 / Math.cos(phi)) / Math.PI) / 2 * n
+  ];
+  const tileMetres = 40075016686e-3 * Math.cos(phi) / n;
+  const far = Math.min(
+    3e3,
+    Math.max(500, 900 * 2 ** (16 - camera.zoom) * (1 + camera.pitch / 90))
+  );
+  const reach = [far * 0.7, far];
+  const base = camera.zoom >= 16.5 ? 15 : camera.zoom >= 16 ? 12 : camera.zoom >= 15.5 ? 9 : 7;
+  return {
+    centre,
+    metres: tileMetres / 8192,
+    reach,
+    // Camera movement changes instance density, mesh selection and the per-tree fade.
+    key: `${centre.join()}:${reach.join()}:${base}`,
+    tile(x3, y2) {
+      const [cx, cy] = centre;
+      const distance = Math.hypot(Math.max(x3, Math.min(cx, x3 + 1)) - cx, Math.max(y2, Math.min(cy, y2 + 1)) - cy) * tileMetres;
+      if (distance > far) return void 0;
+      const fall = distance > reach[0] ? Math.ceil((distance - reach[0]) / (far - reach[0]) * 6) : 0;
+      return {
+        level: distance < reach[0] * 0.45 ? "near" : "far",
+        rank: Math.max(2, Math.min(15, base - fall))
+      };
+    }
+  };
+}
+
 // src/trees-3d-browser.ts
 var tileflowTrees3DLayerId = "tileflow-trees-3d";
 var preferredZoom3 = 15;
@@ -12598,7 +13701,7 @@ var leafSlots = 4;
 var finishes = { faceted: { round: 0.5 }, smooth: { round: 1 }, toon: { round: 0.3 } };
 function createTileflowTrees3D(options) {
   const { map } = options;
-  const minzoom = options.minzoom ?? 15;
+  const minzoom = options.minzoom ?? tileflowSceneMinzoom;
   const maxTiles = Math.round(options.maxTiles ?? 25);
   if (!Number.isFinite(minzoom) || minzoom < 0 || minzoom > 24)
     throw new RangeError("Tileflow 3D trees minzoom must be a zoom from 0 to 24.");
@@ -12610,7 +13713,14 @@ function createTileflowTrees3D(options) {
   let gl;
   let programs = {};
   let variant;
+  const programVariants = /* @__PURE__ */ new Map();
+  let fallbackStyle;
+  let fallbackSun;
+  function standaloneStyle() {
+    return fallbackStyle ??= map.getStyle() ?? {};
+  }
   let meshes;
+  let hedgeMesh;
   const modelMeshes = /* @__PURE__ */ new Map();
   let ground;
   let disposed = false;
@@ -12623,9 +13733,7 @@ function createTileflowTrees3D(options) {
   let design;
   function vegetationOnScreen() {
     const read = options.controller?.getThemeMetadata?.(tileflowVegetationMetadataKey) ?? {
-      values: [
-        map.getStyle()?.metadata?.[tileflowVegetationMetadataKey]
-      ],
+      values: [standaloneStyle().metadata?.[tileflowVegetationMetadataKey]],
       position: 0
     };
     if (!design || design.values.length !== read.values.length || design.values.some((value, index) => value !== read.values[index]))
@@ -12669,7 +13777,7 @@ function createTileflowTrees3D(options) {
     const make = (source, layers) => createCameraTiles({
       map,
       source,
-      layers: [layers.tree, layers.canopy].filter((name) => !!name),
+      layers: [layers.tree, layers.canopy, layers.hedge].filter((name) => !!name),
       zoom: preferredZoom3,
       minzoom,
       maxTiles,
@@ -12678,9 +13786,10 @@ function createTileflowTrees3D(options) {
       build(tile, tileMetres) {
         const trees = layers.tree ? tile.layers[layers.tree] : void 0;
         const canopy = layers.canopy ? tile.layers[layers.canopy] : void 0;
-        if (!trees && !canopy) return emptyTile3;
+        const hedges = layers.hedge ? tile.layers[layers.hedge] : void 0;
+        if (!trees && !canopy && !hedges) return emptyTile3;
         const placement3 = placeTileflowTrees(
-          { ...trees ? { trees } : {}, ...canopy ? { canopy } : {} },
+          { ...trees ? { trees } : {}, ...canopy ? { canopy } : {}, ...hedges ? { hedges } : {} },
           {
             tile,
             tileMetres,
@@ -12695,7 +13804,7 @@ function createTileflowTrees3D(options) {
             )
           }
         );
-        return placement3.trees.length > 0 ? { placement: placement3 } : emptyTile3;
+        return placement3.trees.length > 0 || placement3.hedges.length > 0 ? { placement: placement3 } : emptyTile3;
       },
       empty: emptyTile3,
       release(value) {
@@ -12709,7 +13818,8 @@ function createTileflowTrees3D(options) {
     tiles.push(
       make(described.source, {
         tree: described.layers.tree,
-        ...canopyElsewhere || !described.layers.canopy ? {} : { canopy: described.layers.canopy }
+        ...canopyElsewhere || !described.layers.canopy ? {} : { canopy: described.layers.canopy },
+        ...described.layers.hedge ? { hedge: described.layers.hedge } : {}
       })
     );
     if (canopyElsewhere)
@@ -12721,6 +13831,10 @@ function createTileflowTrees3D(options) {
     if (!tile.gl) return;
     for (const { vao } of tile.gl.vaos.values()) context.deleteVertexArray(vao);
     context.deleteBuffer(tile.gl.vbo);
+    if (tile.gl.hedge) {
+      context.deleteVertexArray(tile.gl.hedge.vao);
+      context.deleteBuffer(tile.gl.hedge.vbo);
+    }
     tile.gl = void 0;
   }
   function drawn() {
@@ -12731,11 +13845,12 @@ function createTileflowTrees3D(options) {
     return entries;
   }
   function upload(context) {
-    if (!meshes) return;
+    if (!meshes || !hedgeMesh) return;
     let budget = 2;
     for (const set of tiles)
       for (const { value: tile } of set.ready()) {
-        if (tile.gl || tile.placement.trees.length === 0) continue;
+        if (tile.gl || tile.placement.trees.length === 0 && tile.placement.hedges.length === 0)
+          continue;
         if (budget-- <= 0) {
           map.triggerRepaint();
           return;
@@ -12758,9 +13873,21 @@ function createTileflowTrees3D(options) {
               vaos.set(`${form}:${model}:${level}`, { vao, count: mesh.count, crown });
             }
           });
+        let hedge;
+        if (tile.placement.hedges.length > 0) {
+          const hedgeVbo = context.createBuffer();
+          context.bindBuffer(context.ARRAY_BUFFER, hedgeVbo);
+          context.bufferData(context.ARRAY_BUFFER, tile.placement.hedges, context.STATIC_DRAW);
+          const vao = context.createVertexArray();
+          context.bindVertexArray(vao);
+          bindMesh(context, hedgeMesh.buffer);
+          bindTrees(context, hedgeVbo, 0);
+          hedge = { vao, vbo: hedgeVbo, count: hedgeMesh.count, crown: 1 };
+        }
         context.bindVertexArray(null);
-        tile.gl = { vbo, vaos };
+        tile.gl = { vbo, vaos, ...hedge ? { hedge } : {} };
         generation += 1;
+        map.triggerRepaint();
       }
   }
   function modelOf(context, form, model, level) {
@@ -12811,7 +13938,7 @@ function createTileflowTrees3D(options) {
     instance(7, 2, context.UNSIGNED_BYTE, true, 12);
   }
   function sunNow() {
-    return options.controller?.getSun?.() ?? resolveTileflowSun(tileflowDefaultSunPreset);
+    return options.controller?.getSun?.() ?? (fallbackSun ??= resolveTileflowSun(tileflowStyleSunPreset(standaloneStyle())));
   }
   const parsedColours = /* @__PURE__ */ new Map();
   function rgb(colour) {
@@ -12854,6 +13981,7 @@ function createTileflowTrees3D(options) {
       broadleaf: slots(theme?.colors.broadleaf ?? ["#6f9a5b"]),
       conifer: slots(theme?.colors.conifer ?? ["#557f52"]),
       palm: slots(theme?.colors.palm ?? ["#7fa45f"]),
+      hedge: slots(theme?.colors.hedge ?? ["#5f8a55"]),
       size: [[theme?.heightScale ?? 1, theme?.crownScale ?? 1, 0]],
       forms: tileflowTreeForms.map((form) => [
         theme?.forms[form]?.heightScale ?? 1,
@@ -12872,6 +14000,7 @@ function createTileflowTrees3D(options) {
       broadleaf: mixList(x3.broadleaf, y2.broadleaf),
       conifer: mixList(x3.conifer, y2.conifer),
       palm: mixList(x3.palm, y2.palm),
+      hedge: mixList(x3.hedge, y2.hedge),
       size,
       /** Each form's height and crown scale: the map's times the form's own. */
       sizes: Object.fromEntries(
@@ -12890,27 +14019,22 @@ function createTileflowTrees3D(options) {
     return scale;
   }
   function fadeIn() {
-    const t = Math.min(1, Math.max(0, (map.getZoom() - minzoom) / 0.8));
-    return t * t * (3 - 2 * t);
-  }
-  function reach() {
-    const zoom = map.getZoom();
-    const far = Math.min(3e3, Math.max(500, 900 * 2 ** (16 - zoom) * (1 + map.getPitch() / 90)));
-    return [far * 0.7, far];
-  }
-  function rankOf(distance) {
-    const zoom = map.getZoom();
-    const base = zoom >= 16.5 ? 15 : zoom >= 16 ? 12 : zoom >= 15.5 ? 9 : 7;
-    const [start, end] = reach();
-    const fall = distance > start ? Math.ceil((distance - start) / (end - start) * 6) : 0;
-    return Math.max(2, Math.min(15, base - fall));
+    return tileflowSceneOpacity(map.getZoom(), minzoom);
+  }
+  function view() {
+    return tileflowTreeView({
+      ...map.getCenter(),
+      zoom: map.getZoom(),
+      pitch: map.getPitch(),
+      tileZoom: preferredZoom3
+    });
   }
   const caster = {
     groundOrder: 1,
     bounds() {
       const shown = visibleScale();
       const entries = drawn();
-      if (shown <= 0 || entries.length === 0 || map.getZoom() < minzoom) return void 0;
+      if (shown <= 0 || entries.length === 0 || fadeIn() <= 0) return void 0;
       let [left, top, right, bottom, tallest] = [Infinity, Infinity, -Infinity, -Infinity, 0];
       for (const { x: x3, y: y2, set, value } of entries) {
         if (set.zoom !== preferredZoom3) continue;
@@ -12928,8 +14052,8 @@ function createTileflowTrees3D(options) {
         tallest: tallest * shown * size[0]
       };
     },
-    // The shadow map is drawn again only when the trees it holds or their size change.
-    key: () => `trees:${visibleScale().toFixed(4)}:${generation}:${programs.depth ? 1 : 0}:${Object.values(
+    // Camera-dependent density, detail and fading also change the trees casting shadows.
+    key: () => `trees:${view().key}:${fadeIn().toFixed(4)}:${visibleScale().toFixed(4)}:${generation}:${programs.depth ? 1 : 0}:${Object.values(
       colours().sizes
     ).flat().map((value) => value.toFixed(3)).join()}:${drawn().map(({ x: x3, y: y2 }) => `${x3}/${y2}`).join(";")}`,
     drawDepth(context, frame) {
@@ -12941,16 +14065,38 @@ function createTileflowTrees3D(options) {
       context.uniform1f(u.u_metres, frame.metres);
       context.uniformMatrix4fv(u.u_light_matrix, false, frame.light.matrix);
       const sizes = colours().sizes;
+      const camera = view();
+      context.uniform1f(u.u_fade, 1);
+      context.uniform2fv(u.u_reach, [...camera.reach]);
       for (const { x: x3, y: y2, set, value } of drawn()) {
+        const selection = camera.tile(x3, y2);
+        if (!selection) continue;
         context.uniform2f(u.u_offset, ...frame.offsetOf({ x: x3, y: y2 }, set.zoom));
+        context.uniform2f(
+          u.u_centre,
+          (camera.centre[0] - x3) * tileflowSceneExtent,
+          (camera.centre[1] - y2) * tileflowSceneExtent
+        );
         for (const form of tileflowTreeForms)
           value.placement.forms[form].variants.forEach((range, model) => {
-            const drawing = value.gl.vaos.get(`${form}:${model}:far`);
-            if (range.count === 0 || !drawing) return;
+            const instances = range.upTo[selection.rank] ?? 0;
+            const drawing = value.gl.vaos.get(`${form}:${model}:${selection.level}`);
+            if (instances === 0 || !drawing) return;
             context.uniform2f(u.u_size_scale, sizes[form][0], sizes[form][1] * drawing.crown);
             context.bindVertexArray(drawing.vao);
-            context.drawArraysInstanced(context.TRIANGLES, 0, drawing.count, range.count);
+            context.drawArraysInstanced(context.TRIANGLES, 0, drawing.count, instances);
           });
+        const hedge = value.gl.hedge;
+        if (hedge) {
+          context.uniform2f(u.u_size_scale, 1, 1);
+          context.bindVertexArray(hedge.vao);
+          context.drawArraysInstanced(
+            context.TRIANGLES,
+            0,
+            hedge.count,
+            value.placement.hedges.length / tileflowTreeBytes
+          );
+        }
       }
     }
   };
@@ -12968,17 +14114,13 @@ function createTileflowTrees3D(options) {
     drawnLast = 0;
     if (entries.length === 0 || !meshes || !programs.trees) return;
     const sun = sunNow();
-    const light = tileflowSceneLight(sun);
+    const sunLight = tileflowSceneLight(sun);
+    const light = { ...sunLight, strength: sunLight.strength * fadeIn() };
     const palette2 = colours();
     const frame = scene.frame();
-    const centre = map.getCenter();
-    const zoom = preferredZoom3;
-    const n = 2 ** zoom;
-    const cx = (centre.lng + 180) / 360 * n;
-    const phi = centre.lat * Math.PI / 180;
-    const cy = (1 - Math.log(Math.tan(phi) + 1 / Math.cos(phi)) / Math.PI) / 2 * n;
-    const metres = frame?.metres ?? 40075016686e-3 * Math.cos(phi) / n / tileflowSceneExtent;
-    const [near, far] = reach();
+    const camera = view();
+    const [cx, cy] = camera.centre;
+    const metres = frame?.metres ?? camera.metres;
     const program = programs.trees;
     const u = program.uniforms;
     context.useProgram(program.program);
@@ -12997,7 +14139,7 @@ function createTileflowTrees3D(options) {
     context.uniform3fv(u.u_sky_light, light.skyLight);
     context.uniform1f(u.u_night, light.night);
     context.uniform1f(u.u_fade, fadeIn());
-    context.uniform2fv(u.u_reach, reach());
+    context.uniform2fv(u.u_reach, [...camera.reach]);
     context.uniform3fv(u.u_bark, palette2.bark);
     context.uniform1f(u.u_leaf_count, leafSlots);
     scene.bindShadow(context, u, light.strength);
@@ -13012,10 +14154,9 @@ function createTileflowTrees3D(options) {
         (cx - x3) * tileflowSceneExtent,
         (cy - y2) * tileflowSceneExtent
       );
-      const distance = Math.hypot(Math.max(x3, Math.min(cx, x3 + 1)) - cx, Math.max(y2, Math.min(cy, y2 + 1)) - cy) * tileflowSceneExtent * metres;
-      if (distance > far) continue;
-      const level = distance < near * 0.45 ? "near" : "far";
-      const rank = rankOf(distance);
+      const selection = camera.tile(x3, y2);
+      if (!selection) continue;
+      const { level, rank } = selection;
       for (const form of tileflowTreeForms) {
         const leaves = form === "palm" ? palette2.palm : form === "conifer" || form === "columnar" ? palette2.conifer : palette2.broadleaf;
         value.placement.forms[form].variants.forEach((range, model) => {
@@ -13023,14 +14164,26 @@ function createTileflowTrees3D(options) {
           const drawing = value.gl.vaos.get(`${form}:${model}:${level}`);
           if (instances === 0 || !drawing) return;
           context.uniform3fv(u.u_leaves, leaves.flat());
-          const size = palette2.sizes[form];
-          context.uniform2f(u.u_size_scale, size[0], size[1] * drawing.crown);
+          const size = [
+            palette2.sizes[form][0],
+            palette2.sizes[form][1] * drawing.crown
+          ];
+          context.uniform2f(u.u_size_scale, ...size);
           context.bindVertexArray(drawing.vao);
           context.drawArraysInstanced(context.TRIANGLES, 0, drawing.count, instances);
           count += instances;
-          draws.push({ x: x3, y: y2, offset, form, instances, drawing });
+          draws.push({ x: x3, y: y2, offset, leaves, size, instances, drawing });
         });
       }
+      const hedge = value.gl.hedge;
+      if (hedge) {
+        const instances = value.placement.hedges.length / tileflowTreeBytes;
+        context.uniform3fv(u.u_leaves, palette2.hedge.flat());
+        context.uniform2f(u.u_size_scale, 1, 1);
+        context.bindVertexArray(hedge.vao);
+        context.drawArraysInstanced(context.TRIANGLES, 0, hedge.count, instances);
+        draws.push({ x: x3, y: y2, offset, leaves: palette2.hedge, size: [1, 1], instances, drawing: hedge });
+      }
     }
     drawnLast = count;
     const edges = palette2.edges;
@@ -13044,7 +14197,7 @@ function createTileflowTrees3D(options) {
       context.uniform1f(e.u_metres, metres);
       context.uniform1f(e.u_round, finishes[palette2.finish].round);
       context.uniform1f(e.u_fade, fadeIn());
-      context.uniform2fv(e.u_reach, reach());
+      context.uniform2fv(e.u_reach, [...camera.reach]);
       context.uniform2f(e.u_viewport, context.drawingBufferWidth, context.drawingBufferHeight);
       context.uniform1f(e.u_edge_width, edges * 1.5 * pixelRatio(context));
       let tile = "";
@@ -13059,16 +14212,14 @@ function createTileflowTrees3D(options) {
             (cy - draw2.y) * tileflowSceneExtent
           );
         }
-        const leaves = draw2.form === "palm" ? palette2.palm : draw2.form === "conifer" || draw2.form === "columnar" ? palette2.conifer : palette2.broadleaf;
         const own = palette2.ownEdge;
         context.uniform3fv(
           e.u_edge_colour,
           [0, 1, 2].map(
-            (channel) => palette2.edgeColor[channel] * own + leaves[0][channel] * 0.4 * (1 - own)
+            (channel) => palette2.edgeColor[channel] * own + draw2.leaves[0][channel] * 0.4 * (1 - own)
           )
         );
-        const size = palette2.sizes[draw2.form];
-        context.uniform2f(e.u_size_scale, size[0], size[1] * draw2.drawing.crown);
+        context.uniform2f(e.u_size_scale, ...draw2.size);
         context.bindVertexArray(draw2.drawing.vao);
         context.drawArraysInstanced(context.TRIANGLES, 0, draw2.drawing.count, draw2.instances);
       }
@@ -13138,40 +14289,56 @@ function createTileflowTrees3D(options) {
   function link(context, shaderData) {
     const projected = `${shaderData.vertexShaderPrelude}
 ${shaderData.define}`;
-    const next = {
-      trees: compile(
+    const cached = programVariants.get(projected);
+    if (cached) {
+      programVariants.delete(projected);
+      programVariants.set(projected, cached);
+      programs = cached;
+      variant = projected;
+      return;
+    }
+    const next = {};
+    try {
+      next.trees = compile(
         context,
         tileflowTreeVertex(projected),
         tileflowTreeFragment,
         tileflowTreeAttributes
-      ),
-      ground: compile(
+      );
+      next.ground = compile(
         context,
         tileflowBuildingGroundVertex(projected),
         tileflowBuildingGroundFragment,
         ["a_pos"]
-      ),
-      edges: compile(
-        context,
-        tileflowTreeEdgeVertex(projected),
-        tileflowTreeEdgeFragment,
-        tileflowTreeAttributes
-      ),
-      depth: programs.depth ?? compile(
+      );
+      next.depth = programs.depth ?? compile(
         context,
         tileflowTreeDepthVertex,
         tileflowTreeDepthFragment,
         tileflowTreeAttributes
-      )
-    };
-    for (const name of ["trees", "ground", "edges"]) {
-      const previous = programs[name];
-      if (previous) context.deleteProgram(previous.program);
+      );
+    } catch (error) {
+      for (const name of ["trees", "ground"])
+        if (next[name]) context.deleteProgram(next[name].program);
+      throw error;
+    }
+    programVariants.set(projected, next);
+    if (programVariants.size > 4) {
+      const oldest = programVariants.keys().next().value;
+      const expired = programVariants.get(oldest);
+      for (const name of ["trees", "ground", "edges"])
+        if (expired[name]) context.deleteProgram(expired[name].program);
+      programVariants.delete(oldest);
     }
     programs = next;
-    variant = shaderData.variantName;
+    variant = projected;
   }
   function createMeshes(context) {
+    const hedge = tileflowHedgeMesh();
+    const hedgeBuffer = context.createBuffer();
+    context.bindBuffer(context.ARRAY_BUFFER, hedgeBuffer);
+    context.bufferData(context.ARRAY_BUFFER, hedge.vertices, context.STATIC_DRAW);
+    hedgeMesh = { buffer: hedgeBuffer, count: hedge.count };
     const built = tileflowTreeMeshes();
     meshes = Object.fromEntries(
       tileflowTreeForms.map((form) => [
@@ -13220,19 +14387,20 @@ ${shaderData.define}`;
     onAdd(_2, context) {
       if (!isWebGL23(context)) return;
       gl = context;
-      createMeshes(context);
     },
     onRemove(_2, context) {
       if (!isWebGL23(context)) return;
       for (const set of tiles)
         for (const entry of set.all()) if (entry.value) release(context, entry.value);
-      for (const program of Object.values(programs))
-        if (program) context.deleteProgram(program.program);
+      const owned = new Set([...programVariants.values()].flatMap((value) => Object.values(value)));
+      for (const program of owned) if (program) context.deleteProgram(program.program);
+      programVariants.clear();
       if (meshes)
         for (const levels of Object.values(meshes))
           for (const mesh of Object.values(levels)) context.deleteBuffer(mesh.buffer);
       for (const mesh of modelMeshes.values()) if (mesh) context.deleteBuffer(mesh.buffer);
       modelMeshes.clear();
+      if (hedgeMesh) context.deleteBuffer(hedgeMesh.buffer);
       if (ground) {
         context.deleteVertexArray(ground.vao);
         context.deleteBuffer(ground.vbo);
@@ -13242,6 +14410,7 @@ ${shaderData.define}`;
       scene.release(context);
       programs = {};
       meshes = void 0;
+      hedgeMesh = void 0;
       ground = void 0;
       variant = void 0;
       gl = void 0;
@@ -13257,13 +14426,23 @@ ${shaderData.define}`;
     },
     render(context, args) {
       if (!isWebGL23(context)) return;
-      try {
-        if (variant !== args.shaderData.variantName) link(context, args.shaderData);
-      } catch {
+      if (visibleScale() <= 0 || fadeIn() <= 0) {
+        drawnLast = 0;
         return;
       }
-      if (visibleScale() <= 0 || map.getZoom() < minzoom) {
-        drawnLast = 0;
+      try {
+        const projected = `${args.shaderData.vertexShaderPrelude}
+${args.shaderData.define}`;
+        if (variant !== projected) link(context, args.shaderData);
+        if (colours().edges > 0.01 && !programs.edges)
+          programs.edges = compile(
+            context,
+            tileflowTreeEdgeVertex(projected),
+            tileflowTreeEdgeFragment,
+            tileflowTreeAttributes
+          );
+        if (!meshes) createMeshes(context);
+      } catch {
         return;
       }
       ensureTiles();
@@ -13308,6 +14487,8 @@ ${shaderData.define}`;
     }
   }
   const onStyle = () => {
+    fallbackStyle = void 0;
+    fallbackSun = void 0;
     attach();
     if (target > 0) {
       standIn(true);
@@ -13315,7 +14496,7 @@ ${shaderData.define}`;
     }
   };
   map.on("styledata", onStyle);
-  map.on("idle", onStyle);
+  map.on("idle", attach);
   attach();
   function grow(goal, change) {
     if (disposed) return Promise.resolve();
@@ -13376,20 +14557,20 @@ ${shaderData.define}`;
           const model = described.models[id];
           const decoded = model ? decodeTileflowTreeModel(model.near, "near") : void 0;
           const mesh = decoded ? tileflowTreeModelMeshOf(decoded) : built[form].near;
-          const view = new DataView(
+          const view2 = new DataView(
             mesh.vertices.buffer,
             mesh.vertices.byteOffset,
             mesh.vertices.byteLength
           );
           const indices = Array.from({ length: mesh.count }, (_2, i2) => i2);
           const preview = inspectModelTriangles(indices, (index) => [
-            view.getFloat32(index * 24, true),
-            view.getFloat32(index * 24 + 4, true),
-            view.getFloat32(index * 24 + 8, true)
+            view2.getFloat32(index * 24, true),
+            view2.getFloat32(index * 24 + 4, true),
+            view2.getFloat32(index * 24 + 8, true)
           ]);
           const colors = [];
           for (let i2 = 0; i2 < mesh.count; i2 += 3) {
-            const part = view.getUint8(i2 * 24 + 15);
+            const part = view2.getUint8(i2 * 24 + 15);
             const palette2 = described.colors[form === "conifer" ? "conifer" : form === "palm" ? "palm" : "broadleaf"];
             colors.push(part === 0 || part === 3 ? described.colors.bark : palette2[0]);
           }
@@ -13420,13 +14601,15 @@ ${shaderData.define}`;
       let trees = 0;
       let mapped = 0;
       let canopy = 0;
+      let hedges = 0;
       for (const set of tiles)
         for (const { value } of set.ready()) {
-          if (value.placement.trees.length === 0) continue;
+          if (value.placement.trees.length === 0 && value.placement.hedges.length === 0) continue;
           count += 1;
           trees += value.placement.trees.length / tileflowTreeBytes;
           mapped += value.placement.mapped;
           canopy += value.placement.canopy;
+          hedges += value.placement.hedges.length / tileflowTreeBytes;
         }
       return {
         declared: vegetation() !== void 0,
@@ -13434,6 +14617,7 @@ ${shaderData.define}`;
         trees,
         mapped,
         canopy,
+        hedges,
         drawn: drawnLast
       };
     },
@@ -13443,7 +14627,7 @@ ${shaderData.define}`;
       motion?.done();
       standIn(false);
       map.off("styledata", onStyle);
-      map.off("idle", onStyle);
+      map.off("idle", attach);
       unregister();
       try {
         if (map.getLayer(tileflowTrees3DLayerId)) map.removeLayer(tileflowTrees3DLayerId);
@@ -13460,6 +14644,7 @@ var emptyTile3 = Object.freeze({
     forms: Object.fromEntries(
       tileflowTreeForms.map((form) => [form, { start: 0, count: 0, upTo: new Array(16).fill(0) }])
     ),
+    hedges: new Uint8Array(0),
     tallest: 0,
     mapped: 0,
     canopy: 0
@@ -15015,6 +16200,19 @@ function createTileflowThemeController(options) {
   const blendMetadata = /* @__PURE__ */ new WeakMap();
   let nextStyleIdentity = 0;
   let current = options.initial;
+  let metadataStyle;
+  const invalidateMetadata = () => {
+    metadataStyle = void 0;
+  };
+  const releaseMetadata = () => {
+    options.map.off("styledata", invalidateMetadata);
+    options.map.off("style.load", invalidateMetadata);
+    options.map.off("remove", releaseMetadata);
+    invalidateMetadata();
+  };
+  options.map.on("styledata", invalidateMetadata);
+  options.map.on("style.load", invalidateMetadata);
+  options.map.on("remove", releaseMetadata);
   let shown = { style: options.initial.style };
   let activeBlend;
   let pendingBlend;
@@ -15060,6 +16258,7 @@ function createTileflowThemeController(options) {
   return {
     dispose() {
       disposed = true;
+      releaseMetadata();
       images?.dispose();
       requestId += 1;
       activeBlend?.blender.dispose();
@@ -15109,7 +16308,7 @@ function createTileflowThemeController(options) {
       const blended = activeBlend && blendMetadata.get(activeBlend.plan);
       if (activeBlend && blended)
         return { values: blended.map(read), position: activeBlend.blender.position };
-      const style = typeof current.style === "string" ? shownStyleDocument() : current.style;
+      const style = typeof current.style === "string" ? metadataStyle ??= shownStyleDocument() : current.style;
       return { values: [read(style?.metadata)], position: 0 };
     },
     getSun() {
@@ -15308,7 +16507,9 @@ function createTileflowThemeController(options) {
     const styleInput = target.kind === "theme" ? target.style.style : target.plan.styleAt(target.position());
     try {
       if (target.kind === "blend") images?.assertBlend(target.plan.images);
+      invalidateMetadata();
       await applyMapStyle(options.map, styleInput, timeoutMs);
+      invalidateMetadata();
       if (disposed) {
         cover?.cancel();
         return { status: "superseded", theme: targetTheme };
@@ -16283,6 +17484,7 @@ export {
   attachTileflowAtmosphere,
   attachTileflowFairUseNotice,
   attachTileflowMapLifecycle,
+  createBoundaryFeatureState,
   createTileflowBuildings3D,
   createTileflowDepthMarkers,
   createTileflowGroundLayers,