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

package/dist/build.js

@@ -52,13 +52,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 tileflowBuildingsMetadata(design) {
   return { version: 1, ...design };
@@ -212,6 +213,7 @@ function tileflowWorldV1Schema(options = {}) {
     ...options,
     capabilities: { ...options.capabilities, bathymetry: true, globalLandcover: true },
     fields: {
+      hedge: "hedge",
       shieldKind: "shield_kind",
       shieldLineLengthMeters: "shield_line_length_m",
       shieldNetwork: "shield_network",
@@ -225,6 +227,7 @@ function tileflowWorldV1Schema(options = {}) {
       roadShield: "transportation_shield",
       sidewalk: "sidewalk",
       streetFurniture: "street_furniture",
+      trafficControl: "traffic_control",
       ...options.layers
     },
     semantics: { ...options.semantics, parkLayer: "protected-only" }
@@ -650,237 +653,98 @@ function compareCodeUnits(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
-// src/marine/index.ts
-var tileflowBathymetrySourceId = "tileflow-bathymetry";
-var tileflowBathymetryDemSourceId = "tileflow-bathymetry-dem";
-var tileflowNauticalSourceId = "tileflow-nautical";
-var tileflowBathymetryV1Schema = Object.freeze({
-  fields: Object.freeze({
-    class: "class",
-    depth: "depth",
-    id: "id",
-    maxZoom: "max_zoom",
-    minDepth: "min_depth",
-    minZoom: "min_zoom",
-    name: "name",
-    sortKey: "sort_key"
-  }),
-  layer: "bathymetry",
-  layers: Object.freeze({
-    bands: "bathymetry",
-    contours: "bathymetry_contour",
-    coverage: "bathymetry_coverage",
-    landforms: "seafloor_landform",
-    waterNames: "water_name"
-  }),
-  optionalLayers: Object.freeze(["contours", "coverage", "landforms", "waterNames"]),
-  product: "bathymetry-v1",
-  requiredLayers: Object.freeze(["bands"]),
-  schemaVersion: 1,
-  sources: Object.freeze({
-    dem: Object.freeze({
-      encoding: "terrarium",
-      sourceId: tileflowBathymetryDemSourceId,
-      tileSize: 512
-    }),
-    vector: Object.freeze({ sourceId: tileflowBathymetrySourceId })
-  })
-});
-var tileflowNauticalV1Schema = Object.freeze({
-  fields: Object.freeze({
-    cell: "cell",
-    character: "character",
-    class: "class",
-    color: "color",
-    coverage: "coverage",
-    depth: "depth",
-    direction: "direction",
-    edition: "edition",
-    licence: "licence",
-    name: "name",
-    provider: "provider",
-    provenance: "provenance",
-    quality: "quality",
-    rangeNm: "range_nm",
-    scale: "scale",
-    subclass: "subclass",
-    update: "update"
-  }),
-  geometryTypes: Object.freeze({
-    aids: Object.freeze(["Point"]),
-    coverage: Object.freeze(["Polygon"]),
-    hazards: Object.freeze(["Point", "Polygon"]),
-    lights: Object.freeze(["Point"]),
-    navigationAreas: Object.freeze(["Polygon"]),
-    reefs: Object.freeze(["Polygon"]),
-    soundings: Object.freeze(["Point"]),
-    wrecks: Object.freeze(["Point", "Polygon"])
-  }),
-  layers: Object.freeze({
-    aids: "aid",
-    coverage: "coverage",
-    hazards: "hazard",
-    lights: "light",
-    navigationAreas: "navigation_area",
-    reefs: "reef",
-    soundings: "sounding",
-    wrecks: "wreck"
-  }),
-  product: "nautical-v1",
-  schemaVersion: 1
-});
-var tileflowBathymetryNameLayerLimits = Object.freeze({ maxZoomRanges: 128 });
-function resolveMarine(marine, apiBaseUrl = "https://api.tileflow.dev") {
-  if (marine === void 0) return void 0;
-  if (typeof marine === "string") {
-    switch (marine) {
-      case "none":
-        return {};
-      case "bathymetry":
-        return { bathymetry: resolveBathymetry({}, apiBaseUrl) };
-      case "nautical":
-        return { nautical: resolveNauticalSource({}, apiBaseUrl) };
-      case "chart":
-        return {
-          bathymetry: resolveBathymetry({}, apiBaseUrl),
-          nautical: resolveNauticalSource({}, apiBaseUrl)
-        };
-    }
-  }
-  return {
-    ...marine.bathymetry === false ? {} : { bathymetry: resolveBathymetry(marine.bathymetry ?? {}, apiBaseUrl) },
-    ...marine.nautical === false ? {} : { nautical: resolveNauticalSource(marine.nautical ?? {}, apiBaseUrl) }
-  };
-}
-function resolveBathymetry(input, apiBaseUrl) {
-  const advanced = "type" in input && input.type === "bathymetry" ? input : void 0;
-  const display = advanced?.display ?? "bands";
-  const usesVector = display === "bands" || display === "hybrid";
-  const usesRelief = display === "relief" || display === "hybrid";
-  const vectorConfig = {
-    ...input.attribution === void 0 ? {} : { attribution: input.attribution },
-    ...input.sourceId === void 0 ? {} : { sourceId: input.sourceId },
-    ...input.url === void 0 ? {} : { url: input.url }
-  };
-  const reliefConfig = advanced?.relief === false ? void 0 : advanced?.relief;
-  const reliefVisible = usesRelief && reliefConfig?.visible !== false && !(typeof reliefConfig?.opacity === "number" && reliefConfig.opacity === 0);
-  return {
-    ...advanced?.bands === void 0 ? {} : { bands: advanced.bands },
-    ...advanced?.contours === void 0 ? {} : { contours: advanced.contours },
-    display,
-    ...advanced?.labels === void 0 ? {} : { labels: advanced.labels },
-    ...advanced?.vectorLayers === void 0 ? {} : { vectorLayers: cloneJson(advanced.vectorLayers) },
-    ...reliefVisible ? { relief: resolveBathymetryRelief(reliefConfig ?? {}, apiBaseUrl) } : {},
-    ...usesVector ? {
-      vector: resolveMarineSource({
-        config: vectorConfig,
-        defaultPath: "/tiles/bathymetry/tiles.json",
-        defaultSourceId: tileflowBathymetrySourceId,
-        kind: "tileflow-bathymetry",
-        product: tileflowBathymetryV1Schema.product,
-        apiBaseUrl
-      })
-    } : {}
-  };
-}
-function resolveBathymetryRelief(style, apiBaseUrl) {
-  const sourceId = validateSourceId(style.sourceId ?? tileflowBathymetryDemSourceId);
-  const url = validateBathymetryDemUrl(
-    style.url ?? new URL("/tiles/bathymetry/dem/tiles.json", normalizeApiBaseUrl2(apiBaseUrl)).toString()
-  );
-  const encoding = style.encoding ?? "terrarium";
-  const tileSize = style.tileSize ?? 512;
-  return {
-    identity: {
-      encoding,
-      kind: "tileflow-bathymetry-dem",
-      product: tileflowBathymetryV1Schema.product,
-      schemaVersion: 1,
-      sourceId,
-      tileSize,
-      url
-    },
-    source: {
-      ...style.attribution ? { attribution: validateAttribution(style.attribution) } : {},
-      encoding,
-      tileSize,
-      type: "raster-dem",
-      url
-    },
-    sourceId,
-    style: cloneJson(style)
-  };
-}
-function resolveNauticalSource(config, apiBaseUrl) {
-  return resolveMarineSource({
-    config,
-    defaultPath: "/tiles/nautical/tiles.json",
-    defaultSourceId: tileflowNauticalSourceId,
-    kind: "tileflow-nautical",
-    product: tileflowNauticalV1Schema.product,
-    apiBaseUrl
-  });
-}
-function resolveMarineSource(options) {
-  const sourceId = validateSourceId(options.config.sourceId ?? options.defaultSourceId);
-  const url = validatePublicVectorUrl(
-    options.config.url ?? new URL(options.defaultPath, normalizeApiBaseUrl2(options.apiBaseUrl)).toString()
-  );
-  const identity = {
-    kind: options.kind,
-    product: options.product,
-    schemaVersion: 1,
-    sourceId,
-    url
-  };
-  return {
-    identity,
-    source: {
-      ...options.config.attribution ? { attribution: validateAttribution(options.config.attribution) } : {},
-      type: "vector",
-      url
-    },
-    sourceId
-  };
-}
-function validateSourceId(value) {
-  const normalized = value.trim();
-  if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u.test(normalized) || normalized !== value) {
-    throw new Error(
-      "Tileflow marine sourceId must be a portable identifier of at most 64 characters."
-    );
-  }
-  return normalized;
+// src/cartography/contributions.ts
+var tileflowLayerSlots = [
+  "background",
+  "land",
+  "terrain",
+  "hydro",
+  "building-areas",
+  "transport-areas",
+  "transport-tunnel-shadow",
+  "transport-tunnel-casing",
+  "transport-tunnel-fill",
+  "transport-pedestrian-areas",
+  "aeroways",
+  "transport-surface-shadow",
+  "transport-surface-casing",
+  "transport-surface-fill",
+  "transport-bridge-shadow",
+  "transport-bridge-casing",
+  "transport-bridge-fill",
+  "transport-symbols",
+  "boundaries",
+  "buildings",
+  "vegetation",
+  "symbols"
+];
+var tileflowLayerBands = [
+  "land",
+  "relief",
+  "water",
+  "roads",
+  "boundaries",
+  "buildings",
+  "vegetation",
+  "labels"
+];
+var bandSlots = {
+  land: ["background", "land"],
+  relief: ["terrain", "terrain"],
+  water: ["hydro", "hydro"],
+  roads: ["transport-areas", "transport-symbols"],
+  boundaries: ["boundaries", "boundaries"],
+  buildings: ["buildings", "buildings"],
+  vegetation: ["vegetation", "vegetation"],
+  labels: ["symbols", "symbols"]
+};
+var tileflowBandPlacements = tileflowLayerBands.flatMap(
+  (band) => [`below-${band}`, `above-${band}`]
+);
+function tileflowBandPlacementSlot(placement) {
+  const [side, band] = splitBandPlacement(placement);
+  return bandSlots[band][side === "below" ? 0 : 1];
 }
-function validateAttribution(value) {
-  const normalized = value.trim();
-  if (!normalized || normalized !== value || normalized.length > 2048) {
-    throw new Error(
-      "Tileflow marine attribution must be non-empty, trimmed, and at most 2048 characters."
-    );
-  }
-  return normalized;
+function tileflowBandPlacementIndex(slotRanks, placement) {
+  const [side, band] = splitBandPlacement(placement);
+  const [first, last] = bandSlots[band];
+  const threshold = side === "below" ? tileflowLayerSlots.indexOf(first) : tileflowLayerSlots.indexOf(last) + 1;
+  const index = slotRanks.findIndex((rank) => rank !== void 0 && rank >= threshold);
+  return index < 0 ? slotRanks.length : index;
 }
-function validateBathymetryDemUrl(value) {
-  const url = validatePublicVectorUrl(value);
-  if (url.startsWith("pmtiles://")) {
-    throw new Error(
-      "Tileflow bathymetry DEM TileJSON must use HTTPS, loopback HTTP, or a root-relative URL."
-    );
-  }
-  return url;
+function splitBandPlacement(placement) {
+  const separator = placement.indexOf("-");
+  return [
+    placement.slice(0, separator),
+    placement.slice(separator + 1)
+  ];
 }
-function normalizeApiBaseUrl2(value) {
-  const url = new URL(value);
-  if (url.username || url.password) {
-    throw new Error("Tileflow API base URL must not contain user information.");
-  }
-  return url.toString();
+var tileflowSemanticTargetPattern = /^[a-z][a-z0-9-]*(?:\.[A-Za-z0-9_-]+)*$/u;
+var tileflowRenderStackOperationNamePattern = /^[a-z][A-Za-z0-9_-]*$/u;
+var tileflowCompilerMetadataKeys = Object.freeze({
+  owner: "tileflow:compiler-owner",
+  slot: "tileflow:compiler-slot",
+  target: "tileflow:compiler-target"
+});
+
+// src/modules/addresses/index.ts
+function addresses(options = {}) {
+  return { type: "addresses", ...cloneJson(options) };
 }
 function cloneJson(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
+// src/cartography/context.ts
+function typographyTextStyle(typography) {
+  return {
+    font: typography.font,
+    ...typography.fallbacks ? { fallbacks: typography.fallbacks } : {},
+    ...typography.letterSpacing === void 0 ? {} : { letterSpacing: typography.letterSpacing },
+    ...typography.transform === void 0 ? {} : { transform: typography.transform }
+  };
+}
+
 // src/cartography/layer-style.ts
 import { Color as Color2 } from "@maplibre/maplibre-gl-style-spec";
 
@@ -1351,494 +1215,194 @@ function applyIconStyle(layer, style) {
   setPaint(paint, "icon-color", style.color);
   setPaint(paint, "icon-halo-blur", style.haloBlur);
   setPaint(paint, "icon-halo-color", style.haloColor);
-  setPaint(paint, "icon-halo-width", style.haloWidth);
-  setPaint(paint, "icon-opacity", style.opacity);
-  return applyLayerRange(withLayerParts(layer, layout, paint), style);
-}
-function applySymbolPlacement(layer, style) {
-  const layout = { ...asRecord(layer.layout) };
-  if (style.placement !== void 0) layout["symbol-placement"] = style.placement;
-  if (style.priority !== void 0) {
-    layout["symbol-sort-key"] = resolvePriority(style.priority, style.priorityOrder);
-  }
-  setLayout(layout, "symbol-spacing", style.spacing);
-  if (style.zOrder !== void 0) layout["symbol-z-order"] = style.zOrder;
-  return applyLayerRange(withLayerParts(layer, layout), style);
-}
-function applySymbolStyle(layer, style) {
-  const range2 = resolveSymbolRange(style);
-  let result = applySymbolPlacement(layer, withoutRange(style));
-  if (style.text) result = applyTextStyle(result, withoutRange(style.text));
-  if (style.icon) result = applyIconStyle(result, withoutRange(style.icon));
-  return applyLayerRange(result, range2);
-}
-function createAreaLayers(base, style) {
-  const layers = [];
-  if (style.fill && style.fill.visible !== false) {
-    layers.push({
-      layer: applyFillStyle({ ...base, type: "fill" }, style.fill),
-      phase: "fill"
-    });
-  }
-  if (style.outline && style.outline.visible !== false) {
-    layers.push({
-      layer: applyLineStyle({ ...base, id: `${base.id}-outline`, type: "line" }, style.outline),
-      phase: "outline"
-    });
-  }
-  return layers;
-}
-function applyCircleStyle(layer, style) {
-  const paint = { ...asRecord(layer.paint) };
-  const layout = { ...asRecord(layer.layout) };
-  setPaint(paint, "circle-blur", style.blur);
-  setPaint(paint, "circle-color", style.color);
-  setPaint(paint, "circle-opacity", style.opacity);
-  if (style.pitchAlignment !== void 0) {
-    paint["circle-pitch-alignment"] = style.pitchAlignment;
-  }
-  if (style.pitchScale !== void 0) paint["circle-pitch-scale"] = style.pitchScale;
-  if (style.priority !== void 0) {
-    layout["circle-sort-key"] = resolvePriority(style.priority, style.priorityOrder);
-  }
-  setPaint(paint, "circle-radius", style.radius);
-  setPaint(paint, "circle-stroke-color", style.strokeColor);
-  setPaint(paint, "circle-stroke-opacity", style.strokeOpacity);
-  setPaint(paint, "circle-stroke-width", style.strokeWidth);
-  setPaint(paint, "circle-translate", style.translate);
-  if (style.translateAnchor !== void 0) {
-    paint["circle-translate-anchor"] = style.translateAnchor;
-  }
-  return applyLayerRange(withLayerParts(layer, layout, paint), style);
-}
-function applyExtrusionStyle(layer, style) {
-  const paint = { ...asRecord(layer.paint) };
-  setPaint(paint, "fill-extrusion-base", style.base);
-  setPaint(paint, "fill-extrusion-color", style.color);
-  setPaint(paint, "fill-extrusion-height", style.height);
-  setPaint(paint, "fill-extrusion-opacity", style.opacity);
-  setPaint(paint, "fill-extrusion-pattern", style.pattern);
-  if (style.verticalGradient !== void 0) {
-    paint["fill-extrusion-vertical-gradient"] = style.verticalGradient;
-  }
-  return applyLayerRange(withLayerParts(layer, void 0, paint), style);
-}
-function applyLayerRange(layer, range2) {
-  const layout = { ...asRecord(layer.layout) };
-  if (range2.visible !== void 0) layout.visibility = range2.visible ? "visible" : "none";
-  return {
-    ...layer,
-    ...range2.minZoom === void 0 ? {} : { minzoom: range2.minZoom },
-    ...range2.maxZoom === void 0 ? {} : { maxzoom: range2.maxZoom },
-    ...Object.keys(layout).length ? { layout } : {}
-  };
-}
-function withLayerParts(layer, layout, paint) {
-  return {
-    ...layer,
-    ...layout && Object.keys(layout).length ? { layout } : {},
-    ...paint && Object.keys(paint).length ? { paint } : {}
-  };
-}
-function resolveSymbolRange(style) {
-  const ranges = [style, style.text, style.icon].filter(
-    (value) => value !== void 0
-  );
-  const result = {};
-  for (const property of ["maxZoom", "minZoom", "visible"]) {
-    const values = ranges.flatMap(
-      (range2) => range2[property] === void 0 ? [] : [range2[property]]
-    );
-    if (new Set(values).size > 1) {
-      throw new Error(
-        `Tileflow symbol range conflict for ${property}; placement, text, and icon share one MapLibre layer.`
-      );
-    }
-    if (values.length > 0) result[property] = values[0];
-  }
-  return result;
-}
-function withoutRange(value) {
-  const { maxZoom: _maxZoom, minZoom: _minZoom, visible: _visible, ...rest } = value;
-  return rest;
-}
-function setOverlap(layout, part, style) {
-  if (style.overlap !== void 0) layout[`${part}-overlap`] = style.overlap;
-  else if (style.allowOverlap !== void 0) layout[`${part}-allow-overlap`] = style.allowOverlap;
-  if (layout[`${part}-overlap`] !== void 0) delete layout[`${part}-allow-overlap`];
+  setPaint(paint, "icon-halo-width", style.haloWidth);
+  setPaint(paint, "icon-opacity", style.opacity);
+  return applyLayerRange(withLayerParts(layer, layout, paint), style);
 }
-function withoutGovernedAllowOverlap(layout) {
-  const result = { ...layout };
-  for (const part of ["icon", "text"]) {
-    if (result[`${part}-overlap`] !== void 0) delete result[`${part}-allow-overlap`];
+function applySymbolPlacement(layer, style) {
+  const layout = { ...asRecord(layer.layout) };
+  if (style.placement !== void 0) layout["symbol-placement"] = style.placement;
+  if (style.priority !== void 0) {
+    layout["symbol-sort-key"] = resolvePriority(style.priority, style.priorityOrder);
   }
-  return result;
-}
-function setPaint(paint, property, value) {
-  if (value !== void 0) paint[property] = toMapLibreStyleValue(value);
+  setLayout(layout, "symbol-spacing", style.spacing);
+  if (style.zOrder !== void 0) layout["symbol-z-order"] = style.zOrder;
+  return applyLayerRange(withLayerParts(layer, layout), style);
 }
-function setLayout(layout, property, value) {
-  if (value !== void 0) layout[property] = toMapLibreStyleValue(value);
+function applySymbolStyle(layer, style) {
+  const range2 = resolveSymbolRange(style);
+  let result = applySymbolPlacement(layer, withoutRange(style));
+  if (style.text) result = applyTextStyle(result, withoutRange(style.text));
+  if (style.icon) result = applyIconStyle(result, withoutRange(style.icon));
+  return applyLayerRange(result, range2);
 }
-function invertPriority(value) {
-  const resolved = toMapLibreStyleValue(value);
-  if (typeof resolved === "number") return -resolved;
-  if (Array.isArray(resolved) && resolved[0] === "interpolate" && isZoomInput2(resolved[2])) {
-    return resolved.map(
-      (entry, index) => index >= 4 && index % 2 === 0 ? negateExpressionOutput(entry) : entry
-    );
+function createAreaLayers(base, style) {
+  const layers = [];
+  if (style.fill && style.fill.visible !== false) {
+    layers.push({
+      layer: applyFillStyle({ ...base, type: "fill" }, style.fill),
+      phase: "fill"
+    });
   }
-  if (Array.isArray(resolved) && resolved[0] === "step" && isZoomInput2(resolved[1])) {
-    return resolved.map(
-      (entry, index) => index === 2 || index >= 4 && index % 2 === 0 ? negateExpressionOutput(entry) : entry
-    );
+  if (style.outline && style.outline.visible !== false) {
+    layers.push({
+      layer: applyLineStyle({ ...base, id: `${base.id}-outline`, type: "line" }, style.outline),
+      phase: "outline"
+    });
   }
-  return ["*", -1, resolved];
-}
-function resolvePriority(value, order) {
-  return order === "lower-first" ? toMapLibreStyleValue(value) : invertPriority(value);
-}
-function negateExpressionOutput(value) {
-  return typeof value === "number" ? -value : ["*", -1, value];
-}
-function isZoomInput2(value) {
-  return Array.isArray(value) && value.length === 1 && value[0] === "zoom";
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  return layers;
 }
-
-// src/cartography/merge.ts
-function mergeTileflowDesign(base, ...overlays) {
-  let resolved = cloneJson3(base);
-  for (const overlay of overlays) {
-    resolved = mergeValue(resolved, overlay);
+function applyCircleStyle(layer, style) {
+  const paint = { ...asRecord(layer.paint) };
+  const layout = { ...asRecord(layer.layout) };
+  setPaint(paint, "circle-blur", style.blur);
+  setPaint(paint, "circle-color", style.color);
+  setPaint(paint, "circle-opacity", style.opacity);
+  if (style.pitchAlignment !== void 0) {
+    paint["circle-pitch-alignment"] = style.pitchAlignment;
   }
-  return resolved;
-}
-function mergeValue(base, overlay) {
-  if (overlay === void 0) return cloneJson3(base);
-  if (Array.isArray(overlay) || isTileflowExpression(overlay) || isTileflowThemeValueNode(overlay) || isTileflowZoomValue(overlay) || !isRecord2(overlay)) {
-    return cloneJson3(overlay);
+  if (style.pitchScale !== void 0) paint["circle-pitch-scale"] = style.pitchScale;
+  if (style.priority !== void 0) {
+    layout["circle-sort-key"] = resolvePriority(style.priority, style.priorityOrder);
   }
-  const baseRecord = isRecord2(base) ? base : {};
-  const result = {};
-  for (const key of /* @__PURE__ */ new Set([...Object.keys(baseRecord), ...Object.keys(overlay)])) {
-    const overlayValue = overlay[key];
-    if (overlayValue === void 0) {
-      if (key in baseRecord) result[key] = cloneJson3(baseRecord[key]);
-      continue;
-    }
-    result[key] = mergeValue(baseRecord[key], overlayValue);
+  setPaint(paint, "circle-radius", style.radius);
+  setPaint(paint, "circle-stroke-color", style.strokeColor);
+  setPaint(paint, "circle-stroke-opacity", style.strokeOpacity);
+  setPaint(paint, "circle-stroke-width", style.strokeWidth);
+  setPaint(paint, "circle-translate", style.translate);
+  if (style.translateAnchor !== void 0) {
+    paint["circle-translate-anchor"] = style.translateAnchor;
   }
-  return result;
-}
-function cloneJson3(value) {
-  if (value === void 0) return value;
-  return JSON.parse(JSON.stringify(value));
-}
-function isRecord2(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
-// src/trees-3d.ts
-var tileflowWorldTreeFields = Object.freeze({
-  height: "height",
-  diameterCrown: "diameter_crown",
-  circumference: "circumference",
-  genus: "genus",
-  species: "species",
-  leafType: "leaf_type",
-  taxon: "taxon",
-  canopyRank: "rank",
-  canopyClearance: "clearance_px_z15",
-  canopyCover: "cover_pct",
-  canopyHeight: "height_m"
-});
-var tileflowDefaultUnknownTreeForms = Object.freeze({
-  round: 1,
-  open: 1,
-  tall: 1
-});
-var broadleaves = Object.freeze({
-  ...Object.fromEntries(
-    [
-      "acacia",
-      "albizia",
-      "arbutus",
-      "bursera",
-      "ceratonia",
-      "delonix",
-      "ficus",
-      "gleditsia",
-      "jacaranda",
-      "olea",
-      "quercus",
-      "robinia",
-      "schinus",
-      "sophora",
-      "styphnolobium",
-      "tamarix"
-    ].map((genus) => [genus, "open"])
-  ),
-  ...Object.fromEntries(
-    [
-      "betula",
-      "celtis",
-      "fraxinus",
-      "ginkgo",
-      "liquidambar",
-      "liriodendron",
-      "magnolia",
-      "platanus",
-      "populus",
-      "pyrus",
-      "ulmus",
-      "zelkova"
-    ].map((genus) => [genus, "tall"])
-  ),
-  ...Object.fromEntries(
-    [
-      "acer",
-      "aesculus",
-      "carpinus",
-      "castanea",
-      "catalpa",
-      "cercis",
-      "citrus",
-      "fagus",
-      "lagerstroemia",
-      "malus",
-      "melia",
-      "morus",
-      "prunus",
-      "sorbus",
-      "tilia"
-    ].map((genus) => [genus, "round"])
-  )
-});
-var tileflowTreeModelIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
-var tileflowVegetationMetadataKey = "tileflow:vegetation";
-function tileflowVegetationMetadata(vegetation2) {
-  return { version: 1, ...vegetation2 };
+  return applyLayerRange(withLayerParts(layer, layout, paint), style);
 }
-
-// src/modules/vegetation/compiler.ts
-function compileVegetation(request, context) {
-  const minZoom = request?.flat?.minZoom ?? 16;
-  const mode = request?.mode ?? "3d";
-  const config = mergeTileflowDesign(
-    {
-      type: "vegetation",
-      enabled: true,
-      flat: {
-        color: context.colors.landcover.wood,
-        minZoom,
-        opacity: mode === "3d" ? 0.82 : 0.9,
-        pitchAlignment: "map",
-        pitchScale: "map",
-        radius: minZoom < 24 ? zoom.linear([
-          [minZoom, 2.2],
-          [minZoom < 20 ? 20 : 24, 8]
-        ]) : 2.2,
-        strokeColor: context.colors.park,
-        strokeOpacity: 0.55,
-        strokeWidth: 0.8
-      },
-      mode,
-      threeDimensional: {
-        barkColor: context.colors.vegetation.tree.bark,
-        broadleafColors: context.colors.vegetation.tree.broadleaf,
-        coniferColors: context.colors.vegetation.tree.conifer,
-        palmColors: context.colors.vegetation.tree.palm,
-        crownScale: 1,
-        heightScale: 1
-      }
-    },
-    request
-  );
-  if (config.enabled === false || !context.data.schema.layers.tree) return [];
-  const resolvedMode = config.mode ?? "3d";
-  return [
-    {
-      kind: "layer",
-      layer: applyCircleStyle(
-        {
-          id: "tileflow-vegetation-trees",
-          type: "circle",
-          source: context.data.sourceId,
-          "source-layer": context.data.schema.layers.tree,
-          // The layer also holds rows of trees as lines; a circle on each vertex would misdraw them.
-          filter: ["==", ["geometry-type"], "Point"],
-          metadata: {
-            "tileflow:vegetation-mode": resolvedMode,
-            ...resolvedMode === "3d" ? { "tileflow:vegetation-fallback": "flat-circle" } : {}
-          }
-        },
-        config.flat ?? {}
-      ),
-      localOrder: 1,
-      owner: "vegetation",
-      slot: "vegetation",
-      target: "vegetation.trees"
-    }
-  ];
+function applyExtrusionStyle(layer, style) {
+  const paint = { ...asRecord(layer.paint) };
+  setPaint(paint, "fill-extrusion-base", style.base);
+  setPaint(paint, "fill-extrusion-color", style.color);
+  setPaint(paint, "fill-extrusion-height", style.height);
+  setPaint(paint, "fill-extrusion-opacity", style.opacity);
+  setPaint(paint, "fill-extrusion-pattern", style.pattern);
+  if (style.verticalGradient !== void 0) {
+    paint["fill-extrusion-vertical-gradient"] = style.verticalGradient;
+  }
+  return applyLayerRange(withLayerParts(layer, void 0, paint), style);
 }
-function tileflowVegetationDescription(request, context) {
-  const { schema } = context.data;
-  if (request?.enabled === false || request?.mode === "flat" || !schema.layers.tree)
-    return void 0;
-  const tree = context.colors.vegetation.tree;
-  const style = request?.threeDimensional ?? {};
-  const colours = (value, fallback) => Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string") ? value : [...fallback];
-  const number = (value) => {
-    const resolved = value === void 0 ? void 0 : toMapLibreStyleValue(value);
-    return typeof resolved === "number" && resolved > 0 ? resolved : 1;
+function applyLayerRange(layer, range2) {
+  const layout = { ...asRecord(layer.layout) };
+  if (range2.visible !== void 0) layout.visibility = range2.visible ? "visible" : "none";
+  return {
+    ...layer,
+    ...range2.minZoom === void 0 ? {} : { minzoom: range2.minZoom },
+    ...range2.maxZoom === void 0 ? {} : { maxzoom: range2.maxZoom },
+    ...Object.keys(layout).length ? { layout } : {}
   };
-  const field2 = (name, fallback) => schema.fields[name] ?? fallback;
+}
+function withLayerParts(layer, layout, paint) {
   return {
-    source: context.data.sourceId,
-    layers: {
-      tree: schema.layers.tree,
-      ...schema.layers.canopy ? { canopy: schema.layers.canopy } : {}
-    },
-    fields: {
-      ...tileflowWorldTreeFields,
-      height: field2("height", tileflowWorldTreeFields.height),
-      diameterCrown: field2("diameterCrown", tileflowWorldTreeFields.diameterCrown),
-      genus: field2("genus", tileflowWorldTreeFields.genus),
-      species: field2("species", tileflowWorldTreeFields.species),
-      leafType: field2("leafType", tileflowWorldTreeFields.leafType),
-      canopyRank: field2("canopyRank", tileflowWorldTreeFields.canopyRank),
-      canopyClearance: field2("canopyClearanceAtZoom15", tileflowWorldTreeFields.canopyClearance),
-      canopyCover: field2("canopyCoverPercent", tileflowWorldTreeFields.canopyCover)
-    },
-    colors: {
-      bark: typeof style.barkColor === "string" ? style.barkColor : tree.bark,
-      broadleaf: colours(style.broadleafColors, tree.broadleaf),
-      conifer: colours(style.coniferColors, tree.conifer),
-      palm: colours(style.palmColors, tree.palm)
-    },
-    heightScale: number(style.heightScale),
-    crownScale: number(style.crownScale),
-    forms: Object.fromEntries(
-      Object.entries(style.forms ?? {}).map(([form, own]) => [
-        form,
-        {
-          heightScale: number(own?.heightScale),
-          crownScale: number(own?.crownScale),
-          ...own?.models?.length ? { models: [...own.models] } : {}
-        }
-      ])
-    ),
-    // Filled by the compiler from the map's prepared models.
-    models: {},
-    finish: style.finish ?? "faceted",
-    edges: (() => {
-      const edges = toMapLibreStyleValue(style.edges ?? 0);
-      return typeof edges === "number" ? edges : 0;
-    })(),
-    ...(() => {
-      const edgeColor = style.edgeColor === void 0 ? void 0 : toMapLibreStyleValue(style.edgeColor);
-      return typeof edgeColor === "string" ? { edgeColor } : {};
-    })(),
-    unknownForms: style.unknownForms ?? tileflowDefaultUnknownTreeForms,
-    regions: style.regions ?? [],
-    // Filled by the compiler once the style's layers are final.
-    flatLayers: []
+    ...layer,
+    ...layout && Object.keys(layout).length ? { layout } : {},
+    ...paint && Object.keys(paint).length ? { paint } : {}
   };
 }
-
-// src/cartography/contributions.ts
-var tileflowLayerSlots = [
-  "background",
-  "land",
-  "terrain",
-  "hydro",
-  "building-areas",
-  "transport-areas",
-  "transport-tunnel-shadow",
-  "transport-tunnel-casing",
-  "transport-tunnel-fill",
-  "transport-pedestrian-areas",
-  "aeroways",
-  "transport-surface-shadow",
-  "transport-surface-casing",
-  "transport-surface-fill",
-  "transport-bridge-shadow",
-  "transport-bridge-casing",
-  "transport-bridge-fill",
-  "transport-symbols",
-  "boundaries",
-  "buildings",
-  "vegetation",
-  "symbols"
-];
-var tileflowLayerBands = [
-  "land",
-  "relief",
-  "water",
-  "roads",
-  "boundaries",
-  "buildings",
-  "vegetation",
-  "labels"
-];
-var bandSlots = {
-  land: ["background", "land"],
-  relief: ["terrain", "terrain"],
-  water: ["hydro", "hydro"],
-  roads: ["transport-areas", "transport-symbols"],
-  boundaries: ["boundaries", "boundaries"],
-  buildings: ["buildings", "buildings"],
-  vegetation: ["vegetation", "vegetation"],
-  labels: ["symbols", "symbols"]
-};
-var tileflowBandPlacements = tileflowLayerBands.flatMap(
-  (band) => [`below-${band}`, `above-${band}`]
-);
-function tileflowBandPlacementSlot(placement) {
-  const [side, band] = splitBandPlacement(placement);
-  return bandSlots[band][side === "below" ? 0 : 1];
+function resolveSymbolRange(style) {
+  const ranges = [style, style.text, style.icon].filter(
+    (value) => value !== void 0
+  );
+  const result = {};
+  for (const property of ["maxZoom", "minZoom", "visible"]) {
+    const values = ranges.flatMap(
+      (range2) => range2[property] === void 0 ? [] : [range2[property]]
+    );
+    if (new Set(values).size > 1) {
+      throw new Error(
+        `Tileflow symbol range conflict for ${property}; placement, text, and icon share one MapLibre layer.`
+      );
+    }
+    if (values.length > 0) result[property] = values[0];
+  }
+  return result;
 }
-function tileflowBandPlacementIndex(slotRanks, placement) {
-  const [side, band] = splitBandPlacement(placement);
-  const [first, last] = bandSlots[band];
-  const threshold = side === "below" ? tileflowLayerSlots.indexOf(first) : tileflowLayerSlots.indexOf(last) + 1;
-  const index = slotRanks.findIndex((rank) => rank !== void 0 && rank >= threshold);
-  return index < 0 ? slotRanks.length : index;
+function withoutRange(value) {
+  const { maxZoom: _maxZoom, minZoom: _minZoom, visible: _visible, ...rest } = value;
+  return rest;
 }
-function splitBandPlacement(placement) {
-  const separator = placement.indexOf("-");
-  return [
-    placement.slice(0, separator),
-    placement.slice(separator + 1)
-  ];
+function setOverlap(layout, part, style) {
+  if (style.overlap !== void 0) layout[`${part}-overlap`] = style.overlap;
+  else if (style.allowOverlap !== void 0) layout[`${part}-allow-overlap`] = style.allowOverlap;
+  if (layout[`${part}-overlap`] !== void 0) delete layout[`${part}-allow-overlap`];
+}
+function withoutGovernedAllowOverlap(layout) {
+  const result = { ...layout };
+  for (const part of ["icon", "text"]) {
+    if (result[`${part}-overlap`] !== void 0) delete result[`${part}-allow-overlap`];
+  }
+  return result;
+}
+function setPaint(paint, property, value) {
+  if (value !== void 0) paint[property] = toMapLibreStyleValue(value);
+}
+function setLayout(layout, property, value) {
+  if (value !== void 0) layout[property] = toMapLibreStyleValue(value);
+}
+function invertPriority(value) {
+  const resolved = toMapLibreStyleValue(value);
+  if (typeof resolved === "number") return -resolved;
+  if (Array.isArray(resolved) && resolved[0] === "interpolate" && isZoomInput2(resolved[2])) {
+    return resolved.map(
+      (entry, index) => index >= 4 && index % 2 === 0 ? negateExpressionOutput(entry) : entry
+    );
+  }
+  if (Array.isArray(resolved) && resolved[0] === "step" && isZoomInput2(resolved[1])) {
+    return resolved.map(
+      (entry, index) => index === 2 || index >= 4 && index % 2 === 0 ? negateExpressionOutput(entry) : entry
+    );
+  }
+  return ["*", -1, resolved];
+}
+function resolvePriority(value, order) {
+  return order === "lower-first" ? toMapLibreStyleValue(value) : invertPriority(value);
+}
+function negateExpressionOutput(value) {
+  return typeof value === "number" ? -value : ["*", -1, value];
+}
+function isZoomInput2(value) {
+  return Array.isArray(value) && value.length === 1 && value[0] === "zoom";
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-var tileflowSemanticTargetPattern = /^[a-z][a-z0-9-]*(?:\.[A-Za-z0-9_-]+)*$/u;
-var tileflowRenderStackOperationNamePattern = /^[a-z][A-Za-z0-9_-]*$/u;
-var tileflowCompilerMetadataKeys = Object.freeze({
-  owner: "tileflow:compiler-owner",
-  slot: "tileflow:compiler-slot",
-  target: "tileflow:compiler-target"
-});
 
-// src/modules/addresses/index.ts
-function addresses(options = {}) {
-  return { type: "addresses", ...cloneJson4(options) };
+// src/cartography/merge.ts
+function mergeTileflowDesign(base, ...overlays) {
+  let resolved = cloneJson3(base);
+  for (const overlay of overlays) {
+    resolved = mergeValue(resolved, overlay);
+  }
+  return resolved;
 }
-function cloneJson4(value) {
+function mergeValue(base, overlay) {
+  if (overlay === void 0) return cloneJson3(base);
+  if (Array.isArray(overlay) || isTileflowExpression(overlay) || isTileflowThemeValueNode(overlay) || isTileflowZoomValue(overlay) || !isRecord2(overlay)) {
+    return cloneJson3(overlay);
+  }
+  const baseRecord = isRecord2(base) ? base : {};
+  const result = {};
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(baseRecord), ...Object.keys(overlay)])) {
+    const overlayValue = overlay[key];
+    if (overlayValue === void 0) {
+      if (key in baseRecord) result[key] = cloneJson3(baseRecord[key]);
+      continue;
+    }
+    result[key] = mergeValue(baseRecord[key], overlayValue);
+  }
+  return result;
+}
+function cloneJson3(value) {
+  if (value === void 0) return value;
   return JSON.parse(JSON.stringify(value));
 }
-
-// src/cartography/context.ts
-function typographyTextStyle(typography) {
-  return {
-    font: typography.font,
-    ...typography.fallbacks ? { fallbacks: typography.fallbacks } : {},
-    ...typography.letterSpacing === void 0 ? {} : { letterSpacing: typography.letterSpacing },
-    ...typography.transform === void 0 ? {} : { transform: typography.transform }
-  };
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
 // src/modules/addresses/compiler.ts
@@ -1893,9 +1457,9 @@ function compileAddresses(request, context) {
 
 // src/modules/aeroways/index.ts
 function aeroways(options = {}) {
-  return { type: "aeroways", ...cloneJson5(options) };
+  return { type: "aeroways", ...cloneJson4(options) };
 }
-function cloneJson5(value) {
+function cloneJson4(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -2053,9 +1617,9 @@ function compileAeroways(request, context) {
 
 // src/modules/boundaries/index.ts
 function boundaries(options = {}) {
-  return { type: "boundaries", ...cloneJson6(options) };
+  return { type: "boundaries", ...cloneJson5(options) };
 }
-function cloneJson6(value) {
+function cloneJson5(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -2169,9 +1733,9 @@ function compileBoundaries(request, context) {
 
 // src/modules/buildings/index.ts
 function buildings(options = {}) {
-  return { type: "buildings", ...cloneJson7(options) };
+  return { type: "buildings", ...cloneJson6(options) };
 }
-function cloneJson7(value) {
+function cloneJson6(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -2448,6 +2012,7 @@ var defaults2 = {
   hierarchy: "clear",
   oneWayMarkers: false,
   outline: "subtle",
+  rampOrder: "below-roads",
   weight: "regular"
 };
 var defaultRoadWidthScale = {
@@ -2492,7 +2057,7 @@ function visibleRoadClasses(options) {
   ].filter((roadClass) => !disabled.has(roadClass));
 }
 function roads(options = {}) {
-  return { type: "roads", ...cloneJson8(options) };
+  return { type: "roads", ...cloneJson7(options) };
 }
 function resolveRoads(request) {
   return {
@@ -2504,6 +2069,7 @@ function resolveRoads(request) {
     hierarchy: request?.hierarchy ?? defaults2.hierarchy,
     oneWayMarkers: request?.oneWayMarkers ?? defaults2.oneWayMarkers,
     outline: request?.outline ?? defaults2.outline,
+    rampOrder: request?.rampOrder ?? defaults2.rampOrder,
     weight: request?.weight ?? defaults2.weight,
     ...request?.widthScale ? {
       widthScale: {
@@ -2540,7 +2106,7 @@ function roadStyleMetrics(options) {
     weightScale: { thin: 0.78, regular: 1, bold: 1.24 }[options.weight]
   };
 }
-function cloneJson8(value) {
+function cloneJson7(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -2551,12 +2117,13 @@ var defaults3 = {
   language: "auto",
   junctions: true,
   places: "major",
+  roadPlacement: "foreground",
   roads: "major",
   shields: "major",
   water: "major"
 };
 function labels(options = {}) {
-  return { type: "labels", ...cloneJson9(options) };
+  return { type: "labels", ...cloneJson8(options) };
 }
 function resolveLabels(request) {
   return {
@@ -2566,6 +2133,7 @@ function resolveLabels(request) {
     junctions: request?.junctions ?? defaults3.junctions,
     places: request?.places ?? defaults3.places,
     ...request?.roadClasses ? { roadClasses: [...request.roadClasses] } : {},
+    roadPlacement: request?.roadPlacement ?? defaults3.roadPlacement,
     roads: request?.roads ?? defaults3.roads,
     shields: request?.shields ?? defaults3.shields,
     water: request?.water ?? defaults3.water
@@ -2577,7 +2145,7 @@ function visibleRoadLabelClasses(detail, roads2, explicitClasses) {
   const eligible = explicit ? tileflowRoadClasses.filter((roadClass) => explicit.has(roadClass)) : roadClassesWithPaths(detail, detail === "all" && roads2.extras.paths);
   return eligible.filter((roadClass) => visibleGeometry.has(roadClass));
 }
-function cloneJson9(value) {
+function cloneJson8(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -2634,6 +2202,7 @@ var placeLabelOrder = [
 function compileLabels(request, roadRequest, context) {
   if (request?.enabled === false) return [];
   const semantics = resolveLabels(request);
+  const groundRoadNames = semantics.roadPlacement === "ground";
   const roads2 = resolveRoads(roadRequest);
   const { colors } = context;
   const rankField = context.data.schema.fields.rank;
@@ -2722,6 +2291,7 @@ function compileLabels(request, roadRequest, context) {
           color: colors.labels.road,
           minZoom: ["motorway", "trunk", "primary"].includes(roadClass) ? 10 : ["pathway", "footway", "cycleway", "steps", "pedestrian"].includes(roadClass) ? 15 : 13,
           placement: "line",
+          ...groundRoadNames ? { pitchAlignment: "map", rotationAlignment: "map" } : {},
           size: zoom.linear([
             [10, 10],
             [16, 14]
@@ -2840,7 +2410,7 @@ function compileLabels(request, roadRequest, context) {
     result.push(
       symbolContribution(
         `labels.roads.${roadClass}`,
-        (navigationPriority ? 1200 : 200) + order++,
+        (groundRoadNames ? -1e3 : navigationPriority ? 1200 : 200) + order++,
         applySymbolStyle(
           {
             id: id2,
@@ -2855,7 +2425,7 @@ function compileLabels(request, roadRequest, context) {
           },
           mergeTileflowDesign(style, { text: { field: field2 } })
         ),
-        "symbols",
+        groundRoadNames ? "buildings" : "symbols",
         { group: "roads", kind: "road-label", member: roadClass }
       )
     );
@@ -3248,13 +2818,18 @@ function symbolContribution(target, localOrder, layer, slot = "symbols", family)
 
 // src/modules/land/index.ts
 function land(options = {}) {
-  return { type: "land", ...cloneJson10(options) };
+  return { type: "land", ...cloneJson9(options) };
 }
-function cloneJson10(value) {
+function cloneJson9(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
 // src/modules/land/compiler.ts
+var barrierClasses = [
+  "fence",
+  "wall",
+  "hedge"
+];
 var landuseClasses = {
   cemetery: ["cemetery"],
   civic: ["community_centre", "place_of_worship", "social_facility"],
@@ -3281,20 +2856,26 @@ var typedGrassSubclasses = [
 var protectedLandcoverMatch = { class: ["protected_area"] };
 var landcoverClasses = [
   ["farmland", { class: ["farmland"] }],
-  ["grass", { class: ["grass"], excludeSubclass: typedGrassSubclasses }],
   ["ice", { class: ["ice", "glacier"] }],
-  ["meadow", { class: ["grass"], subclass: ["meadow"] }],
   ["rock", { class: ["rock"] }],
   ["sand", { class: ["sand", "beach"] }],
-  ["scrub", { class: ["grass"], subclass: ["scrub"] }],
   ["wetland", { class: ["wetland"] }],
   ["wood", { class: ["wood", "forest"] }],
   ["protected", protectedLandcoverMatch],
   ["urbanPark", { class: ["grass"], subclass: ["park", "garden"] }],
   ["recreationGround", { class: ["grass"], subclass: ["recreation_ground"] }],
   ["villageGreen", { class: ["grass"], subclass: ["village_green"] }],
+  ["grass", { class: ["grass"], excludeSubclass: typedGrassSubclasses }],
+  ["meadow", { class: ["grass"], subclass: ["meadow"] }],
+  ["scrub", { class: ["grass"], subclass: ["scrub"] }],
   ["flowerbed", { class: ["grass"], subclass: ["flowerbed"] }]
 ];
+var detailedLandcover = /* @__PURE__ */ new Set([
+  "grass",
+  "meadow",
+  "scrub",
+  "flowerbed"
+]);
 function compileLand(request, context) {
   const colors = context.colors;
   const schema = context.data.schema;
@@ -3442,12 +3023,12 @@ function compileLand(request, context) {
     }
   };
   for (const [name, classes] of Object.entries(landuseClasses)) {
-    if (name === "recreation") continue;
+    if (name === "recreation" || name === "parking") continue;
     appendLanduse(name, classes);
   }
-  for (const [name, match3] of landcoverClasses) {
+  const appendLandcover = (name, match3) => {
     const style = config.landcover?.[name];
-    if (!style) continue;
+    if (!style) return;
     const protectedSource = name === "protected";
     const sourceLayer = protectedSource ? schema.layers.park : schema.layers.landcover;
     const filter = protectedSource && schema.semantics.parkLayer === "protected-only" ? void 0 : landcoverFilter(classField, subclassField, match3);
@@ -3478,6 +3059,9 @@ function compileLand(request, context) {
         target: `land.landcover.${name}.${area.phase}`
       });
     }
+  };
+  for (const [name, match3] of landcoverClasses) {
+    if (!detailedLandcover.has(name)) appendLandcover(name, match3);
   }
   if (schema.semantics.parkLayer === "mixed" && config.landcover?.urbanPark) {
     for (const area of createAreaLayers(
@@ -3500,7 +3084,56 @@ function compileLand(request, context) {
       });
     }
   }
+  for (const [name, match3] of landcoverClasses) {
+    if (detailedLandcover.has(name)) appendLandcover(name, match3);
+  }
+  appendLanduse("parking", landuseClasses.parking);
   appendLanduse("recreation", landuseClasses.recreation);
+  const barrierLayer = schema.layers.trafficControl;
+  for (const name of barrierLayer ? barrierClasses : []) {
+    const style = config.barriers?.[name];
+    const kind = ["==", ["get", subclassField], name];
+    if (style?.area) {
+      contributions.push({
+        kind: "layer",
+        layer: applyFillStyle(
+          {
+            id: `tileflow-barrier-${name}-area`,
+            type: "fill",
+            source,
+            "source-layer": barrierLayer,
+            filter: ["all", ["==", ["geometry-type"], "Polygon"], kind]
+          },
+          style.area
+        ),
+        localOrder: localOrder++,
+        owner: "land",
+        slot: "land",
+        target: `land.barriers.${name}.area`
+      });
+    }
+    for (const phase of ["shadow", "line"]) {
+      const line = style?.[phase];
+      if (!line) continue;
+      contributions.push({
+        kind: "layer",
+        layer: applyLineStyle(
+          {
+            id: `tileflow-barrier-${name}${phase === "shadow" ? "-shadow" : ""}`,
+            type: "line",
+            source,
+            "source-layer": barrierLayer,
+            filter: kind
+          },
+          line
+        ),
+        localOrder: localOrder++,
+        owner: "land",
+        slot: "land",
+        target: `land.barriers.${name}.${phase}`
+      });
+    }
+  }
   return contributions;
 }
 function classFilter2(field2, classes) {
@@ -3525,9 +3158,9 @@ var tileflowLandformClasses = [
   "arete"
 ];
 function landforms(options = {}) {
-  return { type: "landforms", ...cloneJson11(options) };
+  return { type: "landforms", ...cloneJson10(options) };
 }
-function cloneJson11(value) {
+function cloneJson10(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -3618,44 +3251,275 @@ function compileLandforms(request, language, context) {
     ];
   });
 }
-function landformFilter(fields, classes) {
-  const classFilter4 = classes.length === 1 ? ["==", ["get", fields.class], classes[0]] : ["match", ["get", fields.class], classes, true, false];
-  const classZoom = [
-    "match",
-    ["get", fields.class],
-    "volcano",
-    [">=", ["zoom"], 9],
-    "peak",
-    [">=", ["zoom"], 10],
-    "saddle",
-    [">=", ["zoom"], 13],
-    ["ridge", "cliff", "arete"],
-    [">=", ["zoom"], 14],
-    false
-  ];
-  return [
-    "all",
-    ["==", ["geometry-type"], "Point"],
-    ["has", fields.name],
-    classFilter4,
-    classZoom,
-    ["<=", ["to-number", ["get", fields.rank], 99], ["step", ["zoom"], 3, 12, 10, 14, 99]]
-  ];
+function landformFilter(fields, classes) {
+  const classFilter4 = classes.length === 1 ? ["==", ["get", fields.class], classes[0]] : ["match", ["get", fields.class], classes, true, false];
+  const classZoom = [
+    "match",
+    ["get", fields.class],
+    "volcano",
+    [">=", ["zoom"], 9],
+    "peak",
+    [">=", ["zoom"], 10],
+    "saddle",
+    [">=", ["zoom"], 13],
+    ["ridge", "cliff", "arete"],
+    [">=", ["zoom"], 14],
+    false
+  ];
+  return [
+    "all",
+    ["==", ["geometry-type"], "Point"],
+    ["has", fields.name],
+    classFilter4,
+    classZoom,
+    ["<=", ["to-number", ["get", fields.rank], 99], ["step", ["zoom"], 3, 12, 10, 14, 99]]
+  ];
+}
+function landformContribution(target, localOrder, layer) {
+  return {
+    kind: "layer",
+    layer,
+    localOrder,
+    owner: "landforms",
+    slot: "symbols",
+    target
+  };
+}
+
+// src/modules/nautical/index.ts
+function nautical(options = {}) {
+  return { type: "nautical", ...cloneJson11(options) };
+}
+function cloneJson11(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/marine/index.ts
+var tileflowBathymetrySourceId = "tileflow-bathymetry";
+var tileflowBathymetryDemSourceId = "tileflow-bathymetry-dem";
+var tileflowNauticalSourceId = "tileflow-nautical";
+var tileflowBathymetryV1Schema = Object.freeze({
+  fields: Object.freeze({
+    class: "class",
+    depth: "depth",
+    id: "id",
+    maxZoom: "max_zoom",
+    minDepth: "min_depth",
+    minZoom: "min_zoom",
+    name: "name",
+    sortKey: "sort_key"
+  }),
+  layer: "bathymetry",
+  layers: Object.freeze({
+    bands: "bathymetry",
+    contours: "bathymetry_contour",
+    coverage: "bathymetry_coverage",
+    landforms: "seafloor_landform",
+    waterNames: "water_name"
+  }),
+  optionalLayers: Object.freeze(["contours", "coverage", "landforms", "waterNames"]),
+  product: "bathymetry-v1",
+  requiredLayers: Object.freeze(["bands"]),
+  schemaVersion: 1,
+  sources: Object.freeze({
+    dem: Object.freeze({
+      encoding: "terrarium",
+      sourceId: tileflowBathymetryDemSourceId,
+      tileSize: 512
+    }),
+    vector: Object.freeze({ sourceId: tileflowBathymetrySourceId })
+  })
+});
+var tileflowNauticalV1Schema = Object.freeze({
+  fields: Object.freeze({
+    cell: "cell",
+    character: "character",
+    class: "class",
+    color: "color",
+    coverage: "coverage",
+    depth: "depth",
+    direction: "direction",
+    edition: "edition",
+    licence: "licence",
+    name: "name",
+    provider: "provider",
+    provenance: "provenance",
+    quality: "quality",
+    rangeNm: "range_nm",
+    scale: "scale",
+    subclass: "subclass",
+    update: "update"
+  }),
+  geometryTypes: Object.freeze({
+    aids: Object.freeze(["Point"]),
+    coverage: Object.freeze(["Polygon"]),
+    hazards: Object.freeze(["Point", "Polygon"]),
+    lights: Object.freeze(["Point"]),
+    navigationAreas: Object.freeze(["Polygon"]),
+    reefs: Object.freeze(["Polygon"]),
+    soundings: Object.freeze(["Point"]),
+    wrecks: Object.freeze(["Point", "Polygon"])
+  }),
+  layers: Object.freeze({
+    aids: "aid",
+    coverage: "coverage",
+    hazards: "hazard",
+    lights: "light",
+    navigationAreas: "navigation_area",
+    reefs: "reef",
+    soundings: "sounding",
+    wrecks: "wreck"
+  }),
+  product: "nautical-v1",
+  schemaVersion: 1
+});
+var tileflowBathymetryNameLayerLimits = Object.freeze({ maxZoomRanges: 128 });
+function resolveMarine(marine, apiBaseUrl = "https://api.tileflow.dev") {
+  if (marine === void 0) return void 0;
+  if (typeof marine === "string") {
+    switch (marine) {
+      case "none":
+        return {};
+      case "bathymetry":
+        return { bathymetry: resolveBathymetry({}, apiBaseUrl) };
+      case "nautical":
+        return { nautical: resolveNauticalSource({}, apiBaseUrl) };
+      case "chart":
+        return {
+          bathymetry: resolveBathymetry({}, apiBaseUrl),
+          nautical: resolveNauticalSource({}, apiBaseUrl)
+        };
+    }
+  }
+  return {
+    ...marine.bathymetry === false ? {} : { bathymetry: resolveBathymetry(marine.bathymetry ?? {}, apiBaseUrl) },
+    ...marine.nautical === false ? {} : { nautical: resolveNauticalSource(marine.nautical ?? {}, apiBaseUrl) }
+  };
+}
+function resolveBathymetry(input, apiBaseUrl) {
+  const advanced = "type" in input && input.type === "bathymetry" ? input : void 0;
+  const display = advanced?.display ?? "bands";
+  const usesVector = display === "bands" || display === "hybrid";
+  const usesRelief = display === "relief" || display === "hybrid";
+  const vectorConfig = {
+    ...input.attribution === void 0 ? {} : { attribution: input.attribution },
+    ...input.sourceId === void 0 ? {} : { sourceId: input.sourceId },
+    ...input.url === void 0 ? {} : { url: input.url }
+  };
+  const reliefConfig = advanced?.relief === false ? void 0 : advanced?.relief;
+  const reliefVisible = usesRelief && reliefConfig?.visible !== false && !(typeof reliefConfig?.opacity === "number" && reliefConfig.opacity === 0);
+  return {
+    ...advanced?.bands === void 0 ? {} : { bands: advanced.bands },
+    ...advanced?.contours === void 0 ? {} : { contours: advanced.contours },
+    display,
+    ...advanced?.labels === void 0 ? {} : { labels: advanced.labels },
+    ...advanced?.vectorLayers === void 0 ? {} : { vectorLayers: cloneJson12(advanced.vectorLayers) },
+    ...reliefVisible ? { relief: resolveBathymetryRelief(reliefConfig ?? {}, apiBaseUrl) } : {},
+    ...usesVector ? {
+      vector: resolveMarineSource({
+        config: vectorConfig,
+        defaultPath: "/tiles/bathymetry/tiles.json",
+        defaultSourceId: tileflowBathymetrySourceId,
+        kind: "tileflow-bathymetry",
+        product: tileflowBathymetryV1Schema.product,
+        apiBaseUrl
+      })
+    } : {}
+  };
+}
+function resolveBathymetryRelief(style, apiBaseUrl) {
+  const sourceId = validateSourceId(style.sourceId ?? tileflowBathymetryDemSourceId);
+  const url = validateBathymetryDemUrl(
+    style.url ?? new URL("/tiles/bathymetry/dem/tiles.json", normalizeApiBaseUrl2(apiBaseUrl)).toString()
+  );
+  const encoding = style.encoding ?? "terrarium";
+  const tileSize = style.tileSize ?? 512;
+  return {
+    identity: {
+      encoding,
+      kind: "tileflow-bathymetry-dem",
+      product: tileflowBathymetryV1Schema.product,
+      schemaVersion: 1,
+      sourceId,
+      tileSize,
+      url
+    },
+    source: {
+      ...style.attribution ? { attribution: validateAttribution(style.attribution) } : {},
+      encoding,
+      tileSize,
+      type: "raster-dem",
+      url
+    },
+    sourceId,
+    style: cloneJson12(style)
+  };
+}
+function resolveNauticalSource(config, apiBaseUrl) {
+  return resolveMarineSource({
+    config,
+    defaultPath: "/tiles/nautical/tiles.json",
+    defaultSourceId: tileflowNauticalSourceId,
+    kind: "tileflow-nautical",
+    product: tileflowNauticalV1Schema.product,
+    apiBaseUrl
+  });
 }
-function landformContribution(target, localOrder, layer) {
+function resolveMarineSource(options) {
+  const sourceId = validateSourceId(options.config.sourceId ?? options.defaultSourceId);
+  const url = validatePublicVectorUrl(
+    options.config.url ?? new URL(options.defaultPath, normalizeApiBaseUrl2(options.apiBaseUrl)).toString()
+  );
+  const identity = {
+    kind: options.kind,
+    product: options.product,
+    schemaVersion: 1,
+    sourceId,
+    url
+  };
   return {
-    kind: "layer",
-    layer,
-    localOrder,
-    owner: "landforms",
-    slot: "symbols",
-    target
+    identity,
+    source: {
+      ...options.config.attribution ? { attribution: validateAttribution(options.config.attribution) } : {},
+      type: "vector",
+      url
+    },
+    sourceId
   };
 }
-
-// src/modules/nautical/index.ts
-function nautical(options = {}) {
-  return { type: "nautical", ...cloneJson12(options) };
+function validateSourceId(value) {
+  const normalized = value.trim();
+  if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u.test(normalized) || normalized !== value) {
+    throw new Error(
+      "Tileflow marine sourceId must be a portable identifier of at most 64 characters."
+    );
+  }
+  return normalized;
+}
+function validateAttribution(value) {
+  const normalized = value.trim();
+  if (!normalized || normalized !== value || normalized.length > 2048) {
+    throw new Error(
+      "Tileflow marine attribution must be non-empty, trimmed, and at most 2048 characters."
+    );
+  }
+  return normalized;
+}
+function validateBathymetryDemUrl(value) {
+  const url = validatePublicVectorUrl(value);
+  if (url.startsWith("pmtiles://")) {
+    throw new Error(
+      "Tileflow bathymetry DEM TileJSON must use HTTPS, loopback HTTP, or a root-relative URL."
+    );
+  }
+  return url;
+}
+function normalizeApiBaseUrl2(value) {
+  const url = new URL(value);
+  if (url.username || url.password) {
+    throw new Error("Tileflow API base URL must not contain user information.");
+  }
+  return url.toString();
 }
 function cloneJson12(value) {
   return JSON.parse(JSON.stringify(value));
@@ -4846,6 +4710,29 @@ function withoutVisibility(value) {
   return rest;
 }
 
+// src/maps/operations.ts
+var resetValue = deepFreeze({ $tileflow: "reset" });
+var disableValue = deepFreeze({ op: "disable" });
+function isTileflowReset(value) {
+  if (!isPlainRecord(value)) return false;
+  return value.$tileflow === "reset" && Object.keys(value).length === 1;
+}
+function isTileflowModuleOperation(value) {
+  if (!isPlainRecord(value) || typeof value.op !== "string") return false;
+  return value.op === "disable" || value.op === "refine";
+}
+function deepFreeze(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const child of Object.values(value)) deepFreeze(child);
+  return value;
+}
+function isPlainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
 // src/portable-identity-rules.ts
 var tileflowPortableIdMaximumLength = 64;
 var tileflowPortableIdPattern = /^[a-z][a-z0-9-]{0,63}$/u;
@@ -4856,6 +4743,38 @@ function isTileflowThemeName(value) {
   return isTileflowPortableId(value) && value !== "system";
 }
 
+// src/sun.ts
+var tileflowSunMetadataKey = "tileflow:sun";
+var tileflowDefaultSunPreset = Object.freeze({
+  azimuth: 210,
+  altitude: 60,
+  color: "#ffffff",
+  intensity: 0.2,
+  shadowIntensity: 1,
+  ambient: Object.freeze({ color: "#ffffff", intensity: 0.8 })
+});
+var degrees = Math.PI / 180;
+function normalizeTileflowAzimuth(azimuth) {
+  const turned = azimuth % 360;
+  return turned < 0 ? turned + 360 : turned === 0 ? 0 : turned;
+}
+function tileflowSunMetadata(preset) {
+  return Object.freeze({ version: 1, ...preset });
+}
+function tileflowSunLight(direction, base) {
+  const radial = base?.position?.[0] ?? 1.15;
+  return {
+    ...base ?? {},
+    anchor: "map",
+    position: [
+      radial,
+      Number(normalizeTileflowAzimuth(direction.azimuth).toFixed(3)),
+      // MapLibre lights the extrusions from above the horizon only.
+      Number(Math.min(90, Math.max(0, 90 - direction.altitude)).toFixed(3))
+    ]
+  };
+}
+
 // src/time-of-day.ts
 var tileflowTimesOfDay = ["day", "dawn", "dusk", "night"];
 function isTileflowTimeOfDay(value) {
@@ -4906,38 +4825,6 @@ function resolveTileflowTimeOfDayTheme(variants, theme, timeOfDay) {
   return result;
 }
 
-// src/sun.ts
-var tileflowSunMetadataKey = "tileflow:sun";
-var tileflowDefaultSunPreset = Object.freeze({
-  azimuth: 210,
-  altitude: 60,
-  color: "#ffffff",
-  intensity: 0.5,
-  shadowIntensity: 1,
-  ambient: Object.freeze({ color: "#ffffff", intensity: 0.5 })
-});
-var degrees = Math.PI / 180;
-function normalizeTileflowAzimuth(azimuth) {
-  const turned = azimuth % 360;
-  return turned < 0 ? turned + 360 : turned === 0 ? 0 : turned;
-}
-function tileflowSunMetadata(preset) {
-  return Object.freeze({ version: 1, ...preset });
-}
-function tileflowSunLight(direction, base) {
-  const radial = base?.position?.[0] ?? 1.15;
-  return {
-    ...base ?? {},
-    anchor: "map",
-    position: [
-      radial,
-      Number(normalizeTileflowAzimuth(direction.azimuth).toFixed(3)),
-      // MapLibre lights the extrusions from above the horizon only.
-      Number(Math.min(90, Math.max(0, 90 - direction.altitude)).toFixed(3))
-    ]
-  };
-}
-
 // src/themes/visual-semantics.ts
 var visualNumberProperties = /* @__PURE__ */ new Set([
   "angle",
@@ -5865,9 +5752,11 @@ function assertThemeTypographyStyleFields(style, path) {
     throw themeTypeError(`${path}.transform`, "text transform", style.transform);
   }
 }
-function assertThemeLighting(value, path) {
-  const lighting = assertPlainThemeRecord(value, path);
-  assertExactThemeKeys(lighting, path, themeLightingKeys);
+function assertThemeLighting(value, path, allowReset = false) {
+  if (allowReset && isTileflowReset(value)) return;
+  const authored = assertPlainThemeRecord(value, path);
+  assertExactThemeKeys(authored, path, themeLightingKeys);
+  const lighting = allowReset ? Object.fromEntries(Object.entries(authored).filter(([, entry]) => !isTileflowReset(entry))) : authored;
   if (Object.hasOwn(lighting, "sun")) {
     const sun = assertPlainThemeRecord(lighting.sun, `${path}.sun`);
     assertExactThemeKeys(sun, `${path}.sun`, themeSunKeys);
@@ -5979,7 +5868,7 @@ function assertThemeColorOperationNode(operation, path) {
   throw themeTypeError(`${path}.operation`, "alpha or mix", operation.operation);
 }
 function assertPlainThemeRecord(value, path) {
-  if (!isPlainRecord(value)) throw themeTypeError(path, "plain object", value);
+  if (!isPlainRecord2(value)) throw themeTypeError(path, "plain object", value);
   return value;
 }
 function assertExactThemeKeys(value, path, allowedKeys) {
@@ -6260,7 +6149,7 @@ function cloneJson14(value) {
 function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function isPlainRecord(value) {
+function isPlainRecord2(value) {
   if (!isRecord3(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
@@ -6459,35 +6348,47 @@ function resolveColors(overrides = {}, defaults4 = defaultColors, moduleOverride
     }
   };
 }
-function resolveThemeColors(theme) {
+var baseThemeColorRoles = {
+  background: "surface.background",
+  boundary: "boundaries.default",
+  building: "surface.building",
+  land: "surface.land",
+  park: "surface.park",
+  road: "roads.default",
+  roadCasing: "roads.casing",
+  roadMajor: "roads.major",
+  text: "labels.primary",
+  textHalo: "labels.halo",
+  textMuted: "labels.muted",
+  water: "surface.water"
+};
+var tileflowRequiredThemeColorRoles = Object.freeze(Object.values(baseThemeColorRoles));
+var baseThemeColorRoleSet = new Set(tileflowRequiredThemeColorRoles);
+function resolveThemeColors(theme, onDecision) {
   const tokens = resolveTileflowTheme(theme).tokens.color;
   const requireColor = (name) => {
     const value = tokens[name];
-    if (value !== void 0) return value;
+    if (value !== void 0) {
+      onDecision?.({ role: name, source: "theme", value: cssColor(value) });
+      return value;
+    }
     throw new Error(
       `Tileflow semantic compiler requires color token "${name}" in theme "${theme.id}".`
     );
   };
-  const optionalGroup = (group, keys) => Object.fromEntries(
-    keys.flatMap((key) => {
-      const value = tokens[`${group}.${key}`];
-      return value === void 0 ? [] : [[key, value]];
-    })
-  );
-  const base = {
-    background: requireColor("surface.background"),
-    boundary: requireColor("boundaries.default"),
-    building: requireColor("surface.building"),
-    land: requireColor("surface.land"),
-    park: requireColor("surface.park"),
-    road: requireColor("roads.default"),
-    roadCasing: requireColor("roads.casing"),
-    roadMajor: requireColor("roads.major"),
-    text: requireColor("labels.primary"),
-    textHalo: requireColor("labels.halo"),
-    textMuted: requireColor("labels.muted"),
-    water: requireColor("surface.water")
+  const groupRoles = [];
+  const optionalGroup = (group, keys) => {
+    if (onDecision) groupRoles.push({ group, keys });
+    return Object.fromEntries(
+      keys.flatMap((key) => {
+        const value = tokens[`${group}.${key}`];
+        return value === void 0 ? [] : [[key, value]];
+      })
+    );
   };
+  const base = Object.fromEntries(
+    Object.entries(baseThemeColorRoles).map(([key, role]) => [key, requireColor(role)])
+  );
   const modules = {
     boundaries: optionalGroup("boundaries", ["admin", "disputed", "major", "maritime"]),
     buildings: optionalGroup("buildings", [
@@ -6583,7 +6484,24 @@ function resolveThemeColors(theme) {
     ])
   };
   const colors = resolveColors({}, base, {}, modules);
-  const optionalColor = (name, fallback) => cssColor(tokens[name] ?? fallback);
+  if (onDecision) {
+    for (const { group, keys } of groupRoles) {
+      for (const key of keys) {
+        const role = `${group}.${key}`;
+        if (baseThemeColorRoleSet.has(role)) continue;
+        onDecision({
+          role,
+          source: tokens[role] === void 0 ? "derived" : "theme",
+          value: colors[group][key]
+        });
+      }
+    }
+  }
+  const optionalColor = (name, fallback) => {
+    const value = cssColor(tokens[name] ?? fallback);
+    onDecision?.({ role: name, source: tokens[name] === void 0 ? "derived" : "theme", value });
+    return value;
+  };
   return {
     ...colors,
     hydro: {
@@ -6721,19 +6639,272 @@ function hexToRgba(hex) {
     b: Number.parseInt(normalized.slice(4, 6), 16)
   };
 }
-function cssColor(hex) {
-  const value = hex.replace("#", "");
-  if (value.length !== 4 && value.length !== 8) {
-    return hex;
+function cssColor(hex) {
+  const value = hex.replace("#", "");
+  if (value.length !== 4 && value.length !== 8) {
+    return hex;
+  }
+  const { a, b, g, r } = hexToRgba(hex);
+  return `rgba(${r}, ${g}, ${b}, ${a})`;
+}
+function roundAlpha(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function rgbToHex(r, g, b) {
+  return `#${[r, g, b].map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
+
+// src/modules/roads/roundabouts.ts
+function compileRoundabouts(request, surfaces, context, contributions) {
+  const { fields, layers } = context.data.schema;
+  if (!layers.circularFeature) return;
+  const drawn = surfaces.filter(({ fill }) => fill && fill.visible !== false);
+  if (!drawn.length) return;
+  const values = (resolve) => drawn.map((surface) => ({
+    condition: tileflowRoadClassFilter(fields, surface.roadClass),
+    value: toMapLibreStyleValue(resolve(surface))
+  }));
+  const widths = values(({ fill }) => fill?.width ?? 1);
+  const casings = values(({ casing }) => casing?.width ?? 0);
+  const gaps = values(({ casing }) => casing?.gapWidth ?? 0);
+  const fallbackWidth = request?.fallbackWidth === void 0 ? void 0 : toMapLibreStyleValue(request.fallbackWidth);
+  const borderWidth = request?.borderWidth === void 0 ? void 0 : toMapLibreStyleValue(request.borderWidth);
+  const radiusAt15 = ["to-number", ["get", fields.circularRadiusAtZoom15], 0];
+  const radiusMeters = ["to-number", ["get", fields.circularRadiusMeters], 0];
+  const innerMeters = ["to-number", ["get", fields.circularInnerRadiusMeters], 0];
+  const outerMeters = ["to-number", ["get", fields.circularOuterRadiusMeters], 0];
+  const physical = [
+    "all",
+    [">", radiusMeters, 0],
+    [">=", innerMeters, 0],
+    [">", outerMeters, innerMeters]
+  ];
+  const geometryLevels = zoomLevels([
+    ...fallbackWidth === void 0 ? widths.map(({ value }) => value) : [fallbackWidth],
+    ...borderWidth === void 0 ? [...widths, ...casings, ...gaps].map(({ value }) => value) : [borderWidth]
+  ]);
+  const borderAt = (level) => borderWidth === void 0 ? select(
+    values(({ casing, fill }) => {
+      if (!casing || casing.visible === false) return 0;
+      const casingWidth = atZoom(toMapLibreStyleValue(casing.width ?? 0), level);
+      const gap = atZoom(toMapLibreStyleValue(casing.gapWidth ?? 0), level);
+      const fillWidth = atZoom(toMapLibreStyleValue(fill?.width ?? 1), level);
+      return [
+        "max",
+        0,
+        [
+          "case",
+          [">", gap, 0],
+          ["-", ["+", gap, ["*", 2, casingWidth]], fillWidth],
+          ["-", casingWidth, fillWidth]
+        ]
+      ];
+    }),
+    0
+  ) : atZoom(borderWidth, level);
+  const geometry = (casing, width) => expression([
+    "interpolate",
+    ["exponential", 2],
+    ["zoom"],
+    ...geometryLevels.flatMap((level) => {
+      const centerline = ["*", radiusAt15, 2 ** (level - 15)];
+      const fallback = fallbackWidth === void 0 ? select(
+        widths.map(({ condition, value }) => ({ condition, value: atZoom(value, level) })),
+        0
+      ) : atZoom(fallbackWidth, level);
+      const inner = [
+        "case",
+        physical,
+        ["*", centerline, ["/", innerMeters, radiusMeters]],
+        ["-", centerline, ["/", fallback, 2]]
+      ];
+      const fillWidth = [
+        "case",
+        physical,
+        ["*", centerline, ["/", ["-", outerMeters, innerMeters], radiusMeters]],
+        fallback
+      ];
+      const border = casing ? borderAt(level) : 0;
+      return [
+        level,
+        width ? ["max", 0, ["+", fillWidth, border]] : ["max", 0, ["-", inner, ["/", border, 2]]]
+      ];
+    })
+  ]);
+  const phaseStyle = (phase) => ({
+    color: "rgba(0, 0, 0, 0)",
+    minZoom: 15,
+    pitchAlignment: "map",
+    pitchScale: "map",
+    radius: geometry(phase === "casing", false),
+    strokeWidth: geometry(phase === "casing", true),
+    strokeColor: phase === "casing" ? context.colors.roads.casing : expression([
+      "match",
+      ["coalesce", ["get", fields.class], "minor"],
+      "motorway",
+      context.colors.roads.motorway,
+      "trunk",
+      context.colors.roads.trunk,
+      "primary",
+      context.colors.roads.primary,
+      ["secondary", "tertiary"],
+      context.colors.roads.secondary,
+      context.colors.roads.minor
+    ]),
+    strokeOpacity: phaseVisibility(drawn, phase, fields)
+  });
+  for (const phase of ["casing", "fill"]) {
+    const style = mergeTileflowDesign(phaseStyle(phase), request?.[phase]);
+    if (style.visible === false) continue;
+    const eligible = drawn.filter(
+      (surface) => request?.[phase] !== void 0 || surface[phase] && surface[phase]?.visible !== false
+    );
+    if (!eligible.length) continue;
+    contributions.push({
+      kind: "layer",
+      layer: applyCircleStyle(
+        {
+          id: `tileflow-road-circular-${phase}`,
+          type: "circle",
+          source: context.data.sourceId,
+          "source-layer": layers.circularFeature,
+          filter: [
+            "all",
+            ["==", ["get", fields.circularKind], "road_ring"],
+            [
+              "any",
+              ...eligible.map((surface) => tileflowRoadClassFilter(fields, surface.roadClass))
+            ]
+          ]
+        },
+        style
+      ),
+      localOrder: 900,
+      owner: "roads",
+      // Approach fills cover the ring's border where the two meet.
+      slot: phase === "casing" ? "transport-surface-casing" : "transport-surface-fill",
+      target: `roads.roundabouts.${phase}`
+    });
+  }
+}
+function select(values, fallback) {
+  if (!values.length) return fallback;
+  const serialized = JSON.stringify(values[0].value);
+  if (values.every(({ value }) => JSON.stringify(value) === serialized)) return values[0].value;
+  return ["case", ...values.flatMap(({ condition, value }) => [condition, value]), fallback];
+}
+function phaseVisibility(surfaces, phase, fields) {
+  const levels = [
+    ...new Set(
+      surfaces.flatMap((surface) => {
+        const style = surface[phase];
+        return [style?.minZoom, style?.maxZoom].filter(
+          (value) => value !== void 0
+        );
+      })
+    )
+  ].sort((left, right) => left - right);
+  if (!levels.length) return 1;
+  const at = (level) => select(
+    surfaces.map((surface) => {
+      const style = surface[phase];
+      return {
+        condition: tileflowRoadClassFilter(fields, surface.roadClass),
+        value: (style?.minZoom === void 0 || level >= style.minZoom) && (style?.maxZoom === void 0 || level < style.maxZoom) ? 1 : 0
+      };
+    }),
+    0
+  );
+  return expression([
+    "step",
+    ["zoom"],
+    at(-1),
+    ...levels.flatMap((level) => [level, at(level)])
+  ]);
+}
+function zoomLevels(values) {
+  const levels = new Set(Array.from({ length: 10 }, (_, index) => index + 15));
+  for (const value of values) {
+    if (!isZoomCurve(value)) continue;
+    for (let index = 3; index < value.length - 1; index += 2) {
+      const level = value[index];
+      if (level < 15 || level > 24) continue;
+      levels.add(level);
+      if (value[0] === "step" && level > 15) {
+        const previous = index > 3 ? value[index - 2] : 15;
+        levels.add(level - Math.min(1e-6, (level - Math.max(15, previous)) / 2));
+      }
+    }
+    if (value[0] !== "interpolate") continue;
+    const interpolation = value[1];
+    if (interpolation[0] === "exponential" && interpolation[1] === 2) continue;
+    for (let index = 3; index < value.length - 3; index += 2) {
+      let refine2 = function(left, right) {
+        if (right - left <= 1 / 32) return;
+        const factor = (level) => interpolationFactor2(interpolation, level - lower, upper - lower);
+        const leftFactor = factor(left);
+        const rightFactor = factor(right);
+        const error = Math.max(
+          ...[0.25, 0.5, 0.75].map((fraction) => {
+            const level = left + (right - left) * fraction;
+            const sampled = leftFactor + (rightFactor - leftFactor) * interpolationFactor2(["exponential", 2], level - left, right - left);
+            return Math.abs((factor(level) - sampled) * difference);
+          })
+        );
+        if (error <= 0.1) return;
+        const middle = (left + right) / 2;
+        levels.add(middle);
+        refine2(left, middle);
+        refine2(middle, right);
+      };
+      var refine = refine2;
+      const lower = value[index];
+      const upper = value[index + 2];
+      const from = value[index + 1];
+      const to = value[index + 3];
+      if (typeof from !== "number" || typeof to !== "number" || from === to) continue;
+      const difference = to - from;
+      const start = Math.max(15, lower);
+      const end = Math.min(24, upper);
+      if (start >= end) continue;
+      const knots = [start, ...levels].filter((level) => level >= start && level < end);
+      knots.push(end);
+      knots.sort((left, right) => left - right);
+      for (let knot = 0; knot < knots.length - 1; knot++) {
+        refine2(knots[knot], knots[knot + 1]);
+      }
+    }
   }
-  const { a, b, g, r } = hexToRgba(hex);
-  return `rgba(${r}, ${g}, ${b}, ${a})`;
+  return [...levels].sort((left, right) => left - right);
 }
-function roundAlpha(value) {
-  return Math.round(value * 1e3) / 1e3;
+function interpolationFactor2(interpolation, distance, span) {
+  if (interpolation[0] === "linear" || interpolation[1] === 1) return distance / span;
+  if (interpolation[0] !== "exponential") return Number.NaN;
+  const logarithm = Math.log(interpolation[1]);
+  return Math.expm1(logarithm * distance) / Math.expm1(logarithm * span);
 }
-function rgbToHex(r, g, b) {
-  return `#${[r, g, b].map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+function isZoomCurve(value) {
+  return Array.isArray(value) && (value[0] === "interpolate" && isZoom(value[2]) || value[0] === "step" && isZoom(value[1]));
+}
+function isZoom(value) {
+  return Array.isArray(value) && value.length === 1 && value[0] === "zoom";
+}
+function atZoom(value, level) {
+  if (!Array.isArray(value) || value[0] === "literal") return value;
+  if (isZoom(value)) return level;
+  if (!isZoomCurve(value)) return value.map((entry) => atZoom(entry, level));
+  const stops = [];
+  for (let index = 3; index < value.length - 1; index += 2) {
+    stops.push({ level: value[index], value: value[index + 1] });
+  }
+  const exact = stops.find((stop) => stop.level === level);
+  if (exact) return exact.value;
+  const lower = [...stops].reverse().find((stop) => stop.level < level);
+  const upper = stops.find((stop) => stop.level > level);
+  if (value[0] === "step") return lower?.value ?? value[2];
+  if (!lower) return upper?.value ?? 0;
+  if (!upper) return lower.value;
+  return ["interpolate", value[1], level, lower.level, lower.value, upper.level, upper.value];
 }
 
 // src/modules/roads/compiler.ts
@@ -6789,6 +6960,7 @@ function compileRoads(request, context) {
   const metrics = roadStyleMetrics(semantics);
   const defaults4 = defaultClassStyles(context, metrics, semantics);
   const contributions = [];
+  const roundaboutSurfaces = [];
   const { sourceId: source, schema } = context.data;
   for (const [classIndex, roadClass] of roadClassOrder.entries()) {
     if (!visible.has(roadClass) || request?.classes?.[roadClass]?.enabled === false) continue;
@@ -6803,6 +6975,8 @@ function compileRoads(request, context) {
       request?.classes?.[roadClass]
     );
     const treatments = resolveRoadTreatments(request, schema.fields, roadClass);
+    const roundaboutSurface = { roadClass };
+    roundaboutSurfaces.push(roundaboutSurface);
     for (const structure of ["tunnel", "surface", "bridge"]) {
       const structureConfig = classConfig[structure];
       if (!structureConfig) continue;
@@ -6825,7 +6999,7 @@ function compileRoads(request, context) {
           phase,
           phaseDefaults.color
         );
-        contributions.push({
+        const contribution = {
           family: roadLinePhysicalFamily(roadClass, structure, phase),
           kind: "layer",
           layer: applyLineStyle(
@@ -6853,7 +7027,30 @@ function compileRoads(request, context) {
           owner: "roads",
           slot: structureSlots[structure][phase],
           target: `roads.classes.${roadClass}.${structure}.${phase}`
-        });
+        };
+        if (structure === "surface" && phase !== "shadow") {
+          roundaboutSurface[phase] = treatedStyle;
+        }
+        if (phase === "fill" && !isTileflowPathRoadClass(roadClass) && semantics.rampOrder === "below-roads") {
+          const rampFilter = flagFilter(schema.fields.ramp);
+          contributions.push({
+            ...contribution,
+            family: {
+              ...roadLinePhysicalFamily(roadClass, structure, "fill"),
+              group: `${structure}:rampFill:${roadPhysicalCohort(roadClass)}`,
+              outputKey: `roads.cohorts.${structure}.${roadPhysicalCohort(roadClass)}.rampFill`
+            },
+            layer: {
+              ...contribution.layer,
+              id: `tileflow-road-${structure}-${roadClass}-rampFill`,
+              filter: ["all", contribution.layer.filter, rampFilter]
+            },
+            localOrder: -1e3 + classIndex,
+            target: `roads.classes.${roadClass}.${structure}.rampFill`
+          });
+          contribution.layer.filter = ["all", contribution.layer.filter, ["!", rampFilter]];
+        }
+        contributions.push(contribution);
       }
       const hatch = structureConfig.hatch;
       const fill = structureConfig.fill;
@@ -7033,7 +7230,7 @@ function compileRoads(request, context) {
     }
   }
   compileSidewalks(request?.sidewalks, areaStyles.pedestrian?.fill?.color, context, contributions);
-  compileRoundabouts(request?.roundabouts, context, contributions);
+  compileRoundabouts(request?.roundabouts, roundaboutSurfaces, context, contributions);
   compileCrossings(request?.crossings, context, contributions);
   if (semantics.oneWayMarkers && visible.size > 0) {
     contributions.push({
@@ -7158,81 +7355,6 @@ function compileSidewalks(request, pedestrianAreaColor, context, contributions)
     });
   }
 }
-function compileRoundabouts(request, context, contributions) {
-  const { fields, layers } = context.data.schema;
-  if (!layers.circularFeature) return;
-  const circularFields = {
-    circularInnerRadiusMeters: fields.circularInnerRadiusMeters,
-    circularOuterRadiusMeters: fields.circularOuterRadiusMeters,
-    circularRadiusAtZoom15: fields.circularRadiusAtZoom15,
-    circularRadiusMeters: fields.circularRadiusMeters,
-    class: fields.class
-  };
-  const radius = expression(circularRoadInnerRadius(circularFields, false));
-  const casingRadius = expression(circularRoadInnerRadius(circularFields, true));
-  const config = mergeTileflowDesign(
-    {
-      casing: {
-        color: "rgba(0, 0, 0, 0)",
-        minZoom: 15,
-        pitchAlignment: "map",
-        pitchScale: "map",
-        radius: casingRadius,
-        strokeColor: context.colors.roads.casing,
-        strokeWidth: expression(circularRoadStrokeWidth(circularFields, true))
-      },
-      fill: {
-        color: "rgba(0, 0, 0, 0)",
-        minZoom: 15,
-        pitchAlignment: "map",
-        pitchScale: "map",
-        radius,
-        strokeColor: expression([
-          "match",
-          ["coalesce", ["get", fields.class], "minor"],
-          "motorway",
-          context.colors.roads.motorway,
-          "trunk",
-          context.colors.roads.trunk,
-          "primary",
-          context.colors.roads.primary,
-          ["secondary", "tertiary"],
-          context.colors.roads.secondary,
-          context.colors.roads.minor
-        ]),
-        strokeWidth: expression(circularRoadStrokeWidth(circularFields, false))
-      }
-    },
-    request
-  );
-  const base = {
-    type: "circle",
-    source: context.data.sourceId,
-    "source-layer": layers.circularFeature,
-    filter: ["==", ["get", fields.circularKind], "road_ring"]
-  };
-  if (config.casing && config.casing.visible !== false) {
-    contributions.push({
-      kind: "layer",
-      layer: applyCircleStyle({ ...base, id: "tileflow-road-circular-casing" }, config.casing),
-      localOrder: 900,
-      owner: "roads",
-      // Approach fills must cover the circular casing where the roads meet.
-      slot: "transport-surface-casing",
-      target: "roads.roundabouts.casing"
-    });
-  }
-  if (config.fill && config.fill.visible !== false) {
-    contributions.push({
-      kind: "layer",
-      layer: applyCircleStyle({ ...base, id: "tileflow-road-circular-fill" }, config.fill),
-      localOrder: 900,
-      owner: "roads",
-      slot: "transport-surface-fill",
-      target: "roads.roundabouts.fill"
-    });
-  }
-}
 function compileCrossings(request, context, contributions) {
   const { fields, layers } = context.data.schema;
   if (!request || !layers.streetFurniture) return;
@@ -7289,94 +7411,6 @@ function compileCrossings(request, context, contributions) {
     target: "roads.crossings"
   });
 }
-var circularRoadBorderTotalWidth = 1;
-function circularRoadInnerRadius(fields, casing) {
-  const values = circularRoadValues(fields);
-  const stops = [];
-  for (let level = 15; level <= 24; level += 1) {
-    const centerlineRadius = level === 15 ? values.radiusAtZoom15 : ["*", values.radiusAtZoom15, 2 ** (level - 15)];
-    const physicalInnerRadius = [
-      "*",
-      centerlineRadius,
-      ["/", values.innerRadiusMeters, values.radiusMeters]
-    ];
-    const baseWidth = circularRoadBaseWidth(fields.class);
-    const fallbackWidth = level === 15 ? baseWidth : ["*", baseWidth, circularRoadFallbackScale(level)];
-    const fallbackInnerRadius = ["-", centerlineRadius, ["/", fallbackWidth, 2]];
-    const innerRadius = ["case", values.hasPhysicalRadii, physicalInnerRadius, fallbackInnerRadius];
-    stops.push(level, [
-      "max",
-      0,
-      casing ? ["-", innerRadius, circularRoadBorderTotalWidth / 2] : innerRadius
-    ]);
-  }
-  return ["interpolate", ["exponential", 2], ["zoom"], ...stops];
-}
-function circularRoadStrokeWidth(fields, casing) {
-  const values = circularRoadValues(fields);
-  const baseWidth = circularRoadBaseWidth(fields.class);
-  const stops = [];
-  for (let level = 15; level <= 24; level += 1) {
-    const centerlineRadius = level === 15 ? values.radiusAtZoom15 : ["*", values.radiusAtZoom15, 2 ** (level - 15)];
-    const physicalWidth = [
-      "*",
-      centerlineRadius,
-      ["/", ["-", values.outerRadiusMeters, values.innerRadiusMeters], values.radiusMeters]
-    ];
-    const fallbackWidth = level === 15 ? baseWidth : ["*", baseWidth, circularRoadFallbackScale(level)];
-    stops.push(level, [
-      "case",
-      values.hasPhysicalRadii,
-      casing ? ["+", physicalWidth, circularRoadBorderTotalWidth] : physicalWidth,
-      casing ? ["+", fallbackWidth, circularRoadBorderTotalWidth] : fallbackWidth
-    ]);
-  }
-  return ["interpolate", ["exponential", 2], ["zoom"], ...stops];
-}
-function circularRoadBaseWidth(classField) {
-  return [
-    "match",
-    ["coalesce", ["get", classField], "minor"],
-    "motorway",
-    6,
-    "trunk",
-    5.5,
-    "primary",
-    5,
-    "secondary",
-    4.5,
-    "tertiary",
-    4,
-    "service",
-    2.5,
-    "track",
-    2,
-    3
-  ];
-}
-function circularRoadValues(fields) {
-  const radiusAtZoom15 = ["to-number", ["get", fields.circularRadiusAtZoom15], 0];
-  const radiusMeters = ["to-number", ["get", fields.circularRadiusMeters], 0];
-  const outerRadiusMeters = ["to-number", ["get", fields.circularOuterRadiusMeters], 0];
-  const innerRadiusMeters = ["to-number", ["get", fields.circularInnerRadiusMeters], 0];
-  return {
-    hasPhysicalRadii: [
-      "all",
-      [">", radiusMeters, 0],
-      [">", outerRadiusMeters, innerRadiusMeters],
-      [">=", innerRadiusMeters, 0]
-    ],
-    innerRadiusMeters,
-    outerRadiusMeters,
-    radiusAtZoom15,
-    radiusMeters
-  };
-}
-function circularRoadFallbackScale(level) {
-  const interpolationBase = 1.35;
-  const progress = (interpolationBase ** (level - 15) - 1) / (interpolationBase ** (22 - 15) - 1);
-  return 1 + progress * 1.2;
-}
 function widthMatchedHatchPattern(pattern, widths, renderedWidth, minZoom, maxZoom) {
   if (typeof pattern !== "string") {
     throw new Error("Road hatch patternWidths requires a literal pattern prefix");
@@ -7492,7 +7526,12 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
   for (const property of paintProperties) {
     const branches = treatments.flatMap(({ condition, style }) => {
       const value = style[structure]?.[phase]?.[property];
-      return value === void 0 ? [] : [{ condition, resolve: () => expressionOutput(value) }];
+      return value === void 0 ? [] : [
+        {
+          condition,
+          resolve: () => expressionOutput(toMapLibreStyleValue(value))
+        }
+      ];
     });
     if (branches.length > 0) {
       if (property === "dash" && isSolidRoadDash(result[property] ?? treatmentPaintDefaults.dash) && branches.every(({ resolve }) => isSolidRoadDash(resolve()))) {
@@ -7982,13 +8021,227 @@ function modalFilter(classField, subclassField, modes) {
     ["match", ["get", subclassField], modes, true, false]
   ];
 }
-
-// src/modules/vegetation/index.ts
-function vegetation(options = {}) {
-  return { type: "vegetation", ...cloneJson16(options) };
-}
-function cloneJson16(value) {
-  return JSON.parse(JSON.stringify(value));
+
+// src/modules/vegetation/index.ts
+function vegetation(options = {}) {
+  return { type: "vegetation", ...cloneJson16(options) };
+}
+function cloneJson16(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/trees-3d.ts
+var tileflowWorldTreeFields = Object.freeze({
+  height: "height",
+  diameterCrown: "diameter_crown",
+  circumference: "circumference",
+  genus: "genus",
+  species: "species",
+  leafType: "leaf_type",
+  taxon: "taxon",
+  canopyRank: "rank",
+  canopyClearance: "clearance_px_z15",
+  canopyCover: "cover_pct",
+  canopyHeight: "height_m",
+  subclass: "subclass",
+  hedge: "hedge"
+});
+var tileflowDefaultUnknownTreeForms = Object.freeze({
+  round: 1,
+  open: 1,
+  tall: 1
+});
+var broadleaves = Object.freeze({
+  ...Object.fromEntries(
+    [
+      "acacia",
+      "albizia",
+      "arbutus",
+      "bursera",
+      "ceratonia",
+      "delonix",
+      "ficus",
+      "gleditsia",
+      "jacaranda",
+      "olea",
+      "quercus",
+      "robinia",
+      "schinus",
+      "sophora",
+      "styphnolobium",
+      "tamarix"
+    ].map((genus) => [genus, "open"])
+  ),
+  ...Object.fromEntries(
+    [
+      "betula",
+      "celtis",
+      "fraxinus",
+      "ginkgo",
+      "liquidambar",
+      "liriodendron",
+      "magnolia",
+      "platanus",
+      "populus",
+      "pyrus",
+      "ulmus",
+      "zelkova"
+    ].map((genus) => [genus, "tall"])
+  ),
+  ...Object.fromEntries(
+    [
+      "acer",
+      "aesculus",
+      "carpinus",
+      "castanea",
+      "catalpa",
+      "cercis",
+      "citrus",
+      "fagus",
+      "lagerstroemia",
+      "malus",
+      "melia",
+      "morus",
+      "prunus",
+      "sorbus",
+      "tilia"
+    ].map((genus) => [genus, "round"])
+  )
+});
+var tileflowTreeModelIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var tileflowVegetationMetadataKey = "tileflow:vegetation";
+function tileflowVegetationMetadata(vegetation2) {
+  return { version: 1, ...vegetation2 };
+}
+
+// src/modules/vegetation/compiler.ts
+function compileVegetation(request, context) {
+  const minZoom = request?.flat?.minZoom ?? 16;
+  const mode = request?.mode ?? "3d";
+  const config = mergeTileflowDesign(
+    {
+      type: "vegetation",
+      enabled: true,
+      flat: {
+        color: context.colors.landcover.wood,
+        minZoom,
+        opacity: mode === "3d" ? 0.82 : 0.9,
+        pitchAlignment: "map",
+        pitchScale: "map",
+        radius: minZoom < 24 ? zoom.linear([
+          [minZoom, 2.2],
+          [minZoom < 20 ? 20 : 24, 8]
+        ]) : 2.2,
+        strokeColor: context.colors.park,
+        strokeOpacity: 0.55,
+        strokeWidth: 0.8
+      },
+      mode,
+      threeDimensional: {
+        barkColor: context.colors.vegetation.tree.bark,
+        broadleafColors: context.colors.vegetation.tree.broadleaf,
+        coniferColors: context.colors.vegetation.tree.conifer,
+        palmColors: context.colors.vegetation.tree.palm,
+        crownScale: 1,
+        heightScale: 1
+      }
+    },
+    request
+  );
+  if (config.enabled === false || !context.data.schema.layers.tree) return [];
+  const resolvedMode = config.mode ?? "3d";
+  return [
+    {
+      kind: "layer",
+      layer: applyCircleStyle(
+        {
+          id: "tileflow-vegetation-trees",
+          type: "circle",
+          source: context.data.sourceId,
+          "source-layer": context.data.schema.layers.tree,
+          // The layer also holds rows of trees as lines; a circle on each vertex would misdraw them.
+          filter: ["==", ["geometry-type"], "Point"],
+          metadata: {
+            "tileflow:vegetation-mode": resolvedMode,
+            ...resolvedMode === "3d" ? { "tileflow:vegetation-fallback": "flat-circle" } : {}
+          }
+        },
+        config.flat ?? {}
+      ),
+      localOrder: 1,
+      owner: "vegetation",
+      slot: "vegetation",
+      target: "vegetation.trees"
+    }
+  ];
+}
+function tileflowVegetationDescription(request, context) {
+  const { schema } = context.data;
+  if (request?.enabled === false || request?.mode === "flat" || !schema.layers.tree)
+    return void 0;
+  const tree = context.colors.vegetation.tree;
+  const style = request?.threeDimensional ?? {};
+  const colours = (value, fallback) => Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string") ? value : [...fallback];
+  const number = (value) => {
+    const resolved = value === void 0 ? void 0 : toMapLibreStyleValue(value);
+    return typeof resolved === "number" && resolved > 0 ? resolved : 1;
+  };
+  const field2 = (name, fallback) => schema.fields[name] ?? fallback;
+  return {
+    source: context.data.sourceId,
+    layers: {
+      tree: schema.layers.tree,
+      ...schema.layers.canopy ? { canopy: schema.layers.canopy } : {},
+      ...schema.layers.trafficControl && style.hedges !== false ? { hedge: schema.layers.trafficControl } : {}
+    },
+    fields: {
+      ...tileflowWorldTreeFields,
+      height: field2("height", tileflowWorldTreeFields.height),
+      diameterCrown: field2("diameterCrown", tileflowWorldTreeFields.diameterCrown),
+      genus: field2("genus", tileflowWorldTreeFields.genus),
+      species: field2("species", tileflowWorldTreeFields.species),
+      leafType: field2("leafType", tileflowWorldTreeFields.leafType),
+      canopyRank: field2("canopyRank", tileflowWorldTreeFields.canopyRank),
+      canopyClearance: field2("canopyClearanceAtZoom15", tileflowWorldTreeFields.canopyClearance),
+      canopyCover: field2("canopyCoverPercent", tileflowWorldTreeFields.canopyCover),
+      subclass: field2("subclass", tileflowWorldTreeFields.subclass),
+      hedge: field2("hedge", tileflowWorldTreeFields.hedge)
+    },
+    colors: {
+      bark: typeof style.barkColor === "string" ? style.barkColor : tree.bark,
+      broadleaf: colours(style.broadleafColors, tree.broadleaf),
+      conifer: colours(style.coniferColors, tree.conifer),
+      palm: colours(style.palmColors, tree.palm),
+      hedge: colours(style.hedgeColors, tree.broadleaf.slice(0, 2))
+    },
+    heightScale: number(style.heightScale),
+    crownScale: number(style.crownScale),
+    forms: Object.fromEntries(
+      Object.entries(style.forms ?? {}).map(([form, own]) => [
+        form,
+        {
+          heightScale: number(own?.heightScale),
+          crownScale: number(own?.crownScale),
+          ...own?.models?.length ? { models: [...own.models] } : {}
+        }
+      ])
+    ),
+    // Filled by the compiler from the map's prepared models.
+    models: {},
+    finish: style.finish ?? "faceted",
+    edges: (() => {
+      const edges = toMapLibreStyleValue(style.edges ?? 0);
+      return typeof edges === "number" ? edges : 0;
+    })(),
+    ...(() => {
+      const edgeColor = style.edgeColor === void 0 ? void 0 : toMapLibreStyleValue(style.edgeColor);
+      return typeof edgeColor === "string" ? { edgeColor } : {};
+    })(),
+    unknownForms: style.unknownForms ?? tileflowDefaultUnknownTreeForms,
+    regions: style.regions ?? [],
+    // Filled by the compiler once the style's layers are final.
+    flatLayers: []
+  };
 }
 
 // src/modules/water/index.ts
@@ -8256,6 +8509,9 @@ function compileWater(request, context, language = "auto") {
   }
   if (sidecarBathymetry) {
     const { layers: marineLayers } = tileflowBathymetryV1Schema;
+    const splitPlacement = Boolean(
+      config.bathymetryLandforms?.placementByGeometry || config.bathymetryWaterNames?.placementByGeometry
+    );
     const landforms2 = bathymetryProduct?.vectorLayers?.landforms;
     const waterNames = bathymetryProduct?.vectorLayers?.waterNames;
     if (landforms2) {
@@ -8263,7 +8519,7 @@ function compileWater(request, context, language = "auto") {
         availability: landforms2,
         context,
         language,
-        localOrder: -300,
+        localOrder: splitPlacement ? -900 : -300,
         source: sidecarBathymetry.sourceId,
         sourceLayer: marineLayers.landforms,
         style: config.bathymetryLandforms,
@@ -8276,7 +8532,7 @@ function compileWater(request, context, language = "auto") {
         availability: waterNames,
         context,
         language,
-        localOrder: -150,
+        localOrder: splitPlacement ? -450 : -150,
         source: sidecarBathymetry.sourceId,
         sourceLayer: marineLayers.waterNames,
         style: config.bathymetryWaterNames,
@@ -8380,65 +8636,80 @@ function appendBathymetryNames(contributions, options) {
     options.style
   );
   if (style.visible === false || style.text?.visible === false) return;
-  const layer = applySymbolStyle(
-    {
-      id: options.id,
-      type: "symbol",
-      source: options.source,
-      "source-layer": options.sourceLayer,
-      filter: [
-        "all",
-        ["match", ["geometry-type"], ["Point", "LineString", "Polygon"], true, false],
-        ["!=", name, ""]
-      ]
-    },
-    style
-  );
   const sourceMinimum = ["to-number", ["coalesce", ["get", fields.minZoom], 0], 0];
   const sourceMaximum = ["to-number", ["coalesce", ["get", fields.maxZoom], 24], 24];
-  const baseFilter = layer.filter;
-  const append = (result, target, order = 0) => {
-    contributions.push({
-      kind: "layer",
-      layer: result,
-      localOrder: options.localOrder + order,
-      owner: "water",
-      slot: "symbols",
-      target
-    });
-  };
-  if (options.availability === true) {
-    append(
-      {
-        ...layer,
-        filter: [...baseFilter, [">=", ["zoom"], sourceMinimum], ["<", ["zoom"], sourceMaximum]]
-      },
-      options.target
-    );
-    return;
-  }
-  const ranges = [...options.availability.zoomRanges].sort(
+  const ranges = options.availability === true ? void 0 : [...options.availability.zoomRanges].sort(
     (left, right) => left.minZoom - right.minZoom || left.maxZoom - right.maxZoom
   );
-  for (const [index, range2] of ranges.entries()) {
-    const minzoom = Math.max(Number(layer.minzoom ?? 0), range2.minZoom);
-    const maxzoom = Math.min(Number(layer.maxzoom ?? 24), range2.maxZoom);
-    if (minzoom >= maxzoom) continue;
-    append(
+  const policy = style.placementByGeometry;
+  const geometryFamilies = [
+    ["Point", policy?.point],
+    ["LineString", policy?.line],
+    ["Polygon", policy?.polygon]
+  ];
+  const groups = policy ? ["point", "line", "line-center"].flatMap((placement) => {
+    const geometries = geometryFamilies.filter(([, value]) => value === placement).map(([geometry]) => geometry);
+    return geometries.length ? [{ placement, geometries }] : [];
+  }) : [{ placement: style.placement, geometries: ["Point", "LineString", "Polygon"] }];
+  for (const [groupIndex, group] of groups.entries()) {
+    const suffix = policy ? `-placement-${group.placement}` : "";
+    const placementTarget = group.placement === "line-center" ? "LineCenter" : group.placement === "line" ? "Line" : "Point";
+    const target = policy ? `${options.target}.placement${placementTarget}` : options.target;
+    const layer = applySymbolStyle(
       {
-        ...layer,
-        id: `${options.id}-cohort-${index}`,
-        minzoom,
-        maxzoom,
+        id: `${options.id}${suffix}`,
+        type: "symbol",
+        source: options.source,
+        "source-layer": options.sourceLayer,
         filter: [
-          ...baseFilter,
-          ["==", sourceMinimum, range2.minZoom],
-          ["==", sourceMaximum, range2.maxZoom]
+          "all",
+          ["match", ["geometry-type"], group.geometries, true, false],
+          ["!=", name, ""]
         ]
       },
-      `${options.target}.cohort${index}`,
-      index
+      { ...style, placement: group.placement }
     );
+    const baseFilter = layer.filter;
+    const append = (result, rangeTarget, order = 0) => {
+      contributions.push({
+        kind: "layer",
+        layer: result,
+        localOrder: options.localOrder + order * (policy ? 3 : 1) + groupIndex,
+        owner: "water",
+        slot: "symbols",
+        target: rangeTarget
+      });
+    };
+    if (!ranges) {
+      append(
+        {
+          ...layer,
+          filter: [...baseFilter, [">=", ["zoom"], sourceMinimum], ["<", ["zoom"], sourceMaximum]]
+        },
+        target
+      );
+      continue;
+    }
+    for (const [index, range2] of ranges.entries()) {
+      const minzoom = Math.max(Number(layer.minzoom ?? 0), range2.minZoom);
+      const maxzoom = Math.min(Number(layer.maxzoom ?? 24), range2.maxZoom);
+      if (minzoom >= maxzoom) continue;
+      append(
+        {
+          ...layer,
+          id: `${layer.id}-cohort-${index}`,
+          minzoom,
+          maxzoom,
+          filter: [
+            ...baseFilter,
+            ["==", sourceMinimum, range2.minZoom],
+            ["==", sourceMaximum, range2.maxZoom]
+          ]
+        },
+        `${target}.cohort${index}`,
+        index
+      );
+    }
   }
 }
 function appendBathymetryRelief(contributions, relief, context) {
@@ -9018,7 +9289,7 @@ var tileflowOverlayPlacements = [
 ];
 var tileflowHostedSourceLimit = 16;
 function isTileflowRemoveOperation(value) {
-  return isPlainRecord2(value) && value.op === "remove" && Object.keys(value).length === 1;
+  return isPlainRecord3(value) && value.op === "remove" && Object.keys(value).length === 1;
 }
 var TileflowOverlayCompilationError = class extends Error {
   code;
@@ -9112,7 +9383,7 @@ function insertTileflowOverlays(input) {
         ...cloneJson18(layer),
         source: overlay.source,
         metadata: {
-          ...isPlainRecord2(layer.metadata) ? cloneJson18(layer.metadata) : {},
+          ...isPlainRecord3(layer.metadata) ? cloneJson18(layer.metadata) : {},
           "tileflow:overlay": overlayId
         }
       };
@@ -9150,7 +9421,7 @@ function isSafeLocalPmtilesPath(value) {
 }
 function cloneJson18(value) {
   if (Array.isArray(value)) return value.map(cloneJson18);
-  if (!isPlainRecord2(value)) return value;
+  if (!isPlainRecord3(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([key, child]) => [key, cloneJson18(child)])
   );
@@ -9167,12 +9438,202 @@ function tileflowOverlayInsertionIndex(layers, placement) {
 function compareCodeUnits4(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
-function isPlainRecord2(value) {
+function isPlainRecord3(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
 
+// 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/choropleth.ts
+var maxScaleStops = 64;
+var maxCategories = 256;
+var choroplethScale = Object.freeze({
+  categories(categories) {
+    const entries = Object.entries(categories);
+    if (entries.length < 1 || entries.length > maxCategories) {
+      throw new Error(`A category scale needs between 1 and ${maxCategories} categories.`);
+    }
+    for (const [category, color2] of entries) {
+      if (!category) throw new Error("Category scale keys must not be empty.");
+      assertColor2(color2);
+    }
+    return Object.freeze({ categories: Object.freeze({ ...categories }), kind: "categories" });
+  },
+  linear(stops) {
+    if (stops.length < 2) throw new Error("A linear scale needs at least two stops.");
+    return Object.freeze({ kind: "linear", stops: validateStops(stops) });
+  },
+  step(base, stops) {
+    assertColor2(base);
+    if (stops.length < 1) throw new Error("A step scale needs at least one stop.");
+    return Object.freeze({ base, kind: "step", stops: validateStops(stops) });
+  }
+});
+var tileflowBoundaryChoroplethMetadataKey = "tileflow:boundaryChoropleth";
+function validateStops(stops) {
+  if (stops.length > maxScaleStops) {
+    throw new Error(`A choropleth scale accepts at most ${maxScaleStops} stops.`);
+  }
+  let previous = -Infinity;
+  for (const [value, color2] of stops) {
+    if (!Number.isFinite(value) || value <= previous) {
+      throw new Error("Choropleth scale stops must be finite and strictly increasing.");
+    }
+    assertColor2(color2);
+    previous = value;
+  }
+  return Object.freeze(stops.map((stop) => Object.freeze([stop[0], stop[1]])));
+}
+function assertColor2(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("Choropleth colors must be non-empty CSS color strings.");
+  }
+}
+
+// src/boundary-areas/source.ts
+function resolveBoundaryAreas(config, apiBaseUrl = "https://api.tileflow.dev") {
+  if (config === void 0 || config === false) return void 0;
+  if (!isTileflowBoundaryFamily(config.family)) {
+    throw new Error(
+      `Unknown Tileflow Boundaries family: ${String(config.family)}. Expected one of: ${Object.keys(
+        tileflowBoundaryFamilies
+      ).join(", ")}.`
+    );
+  }
+  if (config.promoteId !== void 0 && config.promoteId !== "ref") {
+    throw new Error('Tileflow Boundaries promoteId must be "ref" when set.');
+  }
+  const family = tileflowBoundaryFamilies[config.family];
+  const url = validatePublicVectorUrl(
+    config.url ?? new URL(family.path, normalizeApiBaseUrl3(apiBaseUrl)).toString()
+  );
+  const { areas, labels: labels2 } = tileflowBoundaryAreasV1Schema.layers;
+  return Object.freeze({
+    identity: Object.freeze({
+      family: config.family,
+      kind: "tileflow-boundaries",
+      product: tileflowBoundaryAreasV1Schema.product,
+      ...config.promoteId ? { promoteId: config.promoteId } : {},
+      schemaVersion: tileflowBoundaryAreasV1Schema.schemaVersion,
+      sourceId: family.sourceId,
+      url
+    }),
+    source: Object.freeze({
+      attribution: family.attribution,
+      ...config.promoteId ? { promoteId: Object.freeze({ [areas]: config.promoteId, [labels2]: config.promoteId }) } : {},
+      type: "vector",
+      url
+    }),
+    sourceId: family.sourceId
+  });
+}
+function normalizeApiBaseUrl3(value) {
+  const url = new URL(value);
+  if (url.username || url.password) {
+    throw new Error("Tileflow API base URL must not contain user information.");
+  }
+  return url.toString();
+}
+
+// src/boundary-areas/compile.ts
+function validateBoundaryChoroplethOverlays(mapId, overlays, boundaryAreas) {
+  const entries = Object.entries(overlays ?? {});
+  for (const [overlayId, overlay] of entries) {
+    for (const layer of overlay.layers) {
+      const metadata = layer.metadata?.[tileflowBoundaryChoroplethMetadataKey];
+      if (!metadata) continue;
+      const path = `map.${mapId}.overlays.${overlayId}`;
+      if (!boundaryAreas || boundaryAreas.identity.family !== metadata.family) {
+        throw new TileflowOverlayCompilationError(
+          "TF_BOUNDARY_AREAS_REQUIRED",
+          path,
+          `Boundary choropleth "${overlayId}" needs the map to declare boundaryAreas with family "${metadata.family}".`,
+          `Add boundaryAreas: {family: '${metadata.family}'} to the map.`
+        );
+      }
+      if (overlay.source !== tileflowBoundaryFamilies[metadata.family].sourceId) {
+        throw new TileflowOverlayCompilationError(
+          "TF_BOUNDARY_CHOROPLETH_SOURCE",
+          `${path}.source`,
+          `Boundary choropleth "${overlayId}" must draw from ${tileflowBoundaryFamilies[metadata.family].sourceId}.`
+        );
+      }
+      if (metadata.joinBy === "id" && boundaryAreas.identity.promoteId === "ref") {
+        throw new TileflowOverlayCompilationError(
+          "TF_BOUNDARY_CHOROPLETH_JOIN",
+          path,
+          `Boundary choropleth "${overlayId}" joins by id, but boundaryAreas promotes ref as the feature ID.`,
+          "Join the values by ref, or remove promoteId from boundaryAreas."
+        );
+      }
+    }
+  }
+  return overlays;
+}
+
 // src/resolved-map-schema.ts
 import { Color as Color3 } from "@maplibre/maplibre-gl-style-spec";
 import { z as z5 } from "zod";
@@ -9310,7 +9771,7 @@ function caseValue(branches, fallback) {
 }
 function step(input, fallback, stops) {
   validateStopCount(stops.length, "expr.step");
-  validateStops(stops, "expr.step");
+  validateStops2(stops, "expr.step");
   return make([
     "step",
     node(input),
@@ -9320,7 +9781,7 @@ function step(input, fallback, stops) {
 }
 function interpolate2(interpolation, input, stops) {
   validateStopCount(stops.length, "expr.interpolate");
-  validateStops(stops, "expr.interpolate");
+  validateStops2(stops, "expr.interpolate");
   const method = interpolationMethod(interpolation);
   return make([
     "interpolate",
@@ -9347,7 +9808,7 @@ function interpolationMethod(interpolation) {
     }
   }
 }
-function validateStops(stops, api) {
+function validateStops2(stops, api) {
   let previous = -Infinity;
   for (const [stop] of stops) {
     if (!Number.isFinite(stop) || stop <= previous) {
@@ -10042,11 +10503,11 @@ function physicalLayerIdForSemanticKey(semanticKey) {
     semanticKey
   );
   if (match3) return `tileflow-${match3[1]}-render-${match3[2].replaceAll(".", "-")}`;
-  match3 = /^roads\.classes\.([^.]+)\.(tunnel|surface|bridge)\.(shadow|casing|fill|hatch)$/u.exec(
+  match3 = /^roads\.classes\.([^.]+)\.(tunnel|surface|bridge)\.(shadow|casing|fill|hatch|rampFill)$/u.exec(
     semanticKey
   );
   if (match3) return `tileflow-road-${match3[2]}-${match3[1]}-${match3[3]}`;
-  match3 = /^roads\.cohorts\.(tunnel|surface|bridge)\.([^.]+)\.(shadow|casing|fill)$/u.exec(
+  match3 = /^roads\.cohorts\.(tunnel|surface|bridge)\.([^.]+)\.(shadow|casing|fill|rampFill)$/u.exec(
     semanticKey
   );
   if (match3) return `tileflow-road-${match3[1]}-highzoom-${match3[2]}-${match3[3]}`;
@@ -10062,6 +10523,8 @@ function physicalLayerIdForSemanticKey(semanticKey) {
     const base = `tileflow-${match3[1]}-${match3[2]}`;
     return match3[3] === "fill" ? base : `${base}-outline`;
   }
+  match3 = /^land\.barriers\.(fence|hedge|wall)\.(area|shadow|line)$/u.exec(semanticKey);
+  if (match3) return `tileflow-barrier-${match3[1]}${match3[2] === "line" ? "" : `-${match3[2]}`}`;
   match3 = /^land\.compatibility\.legacyPark\.(fill|outline)$/u.exec(semanticKey);
   if (match3) {
     return match3[1] === "fill" ? "tileflow-landcover-legacy-park" : "tileflow-landcover-legacy-park-outline";
@@ -10102,10 +10565,14 @@ function physicalLayerIdForSemanticKey(semanticKey) {
   if (match3) return `tileflow-label-road-cohort-${match3[1]}`;
   match3 = /^landforms\.classes\.([^.]+)$/u.exec(semanticKey);
   if (match3) return `tileflow-landform-${match3[1]}`;
-  match3 = /^water\.(bathymetryLandforms|bathymetryWaterNames)\.cohort(\d+)$/u.exec(semanticKey);
+  match3 = /^water\.(bathymetryLandforms|bathymetryWaterNames)(?:\.placement(Point|Line|LineCenter))?(?:\.cohort(\d+))?$/u.exec(
+    semanticKey
+  );
   if (match3) {
     const base = match3[1] === "bathymetryLandforms" ? "landforms" : "water-names";
-    return `tileflow-bathymetry-${base}-cohort-${match3[2]}`;
+    const placement = match3[2] ? `-placement-${match3[2] === "LineCenter" ? "line-center" : match3[2].toLowerCase()}` : "";
+    const cohort = match3[3] === void 0 ? "" : `-cohort-${match3[3]}`;
+    return `tileflow-bathymetry-${base}${placement}${cohort}`;
   }
   match3 = /^poi\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(semanticKey);
   if (match3) return `tileflow-poi-${match3[1].replaceAll(".", "-")}`;
@@ -11624,6 +12091,12 @@ var numberValueSchema = z5.union([
   numberExpressionSchema,
   numberZoomValueSchema
 ]);
+var nonnegativeNumberLiteralSchema = terrainNumberValueSchema(z5.number().finite().min(0));
+var nonnegativeNumberValueSchema = z5.union([
+  nonnegativeNumberLiteralSchema,
+  numberExpressionSchema,
+  zoomValueSchemaFor(nonnegativeNumberLiteralSchema)
+]);
 var structuralNumberValueSchema = z5.union([
   z5.number().finite(),
   structuralExpressionSchema,
@@ -11974,6 +12447,13 @@ var symbolStyleSchema = z5.object({
   text: textStyleSchema.optional()
 }).strict();
 var markerSymbolStyleSchema = symbolStyleSchema.extend({ marker: circleStyleSchema.optional() }).strict();
+var bathymetryNameStyleSchema = symbolStyleSchema.extend({
+  placementByGeometry: z5.object({
+    point: z5.literal("point"),
+    line: z5.enum(["line", "line-center", "point"]),
+    polygon: z5.enum(["line", "line-center", "point"])
+  }).strict().optional()
+}).strict();
 var poiCategoryStyleSchema = markerSymbolStyleSchema.omit({ priority: true, priorityOrder: true }).strict();
 var renderScalarSchema = z5.union([z5.boolean(), z5.number().finite(), z5.string()]);
 var renderTargetSchema = z5.string().regex(tileflowSemanticTargetPattern, "Expected a semantic target");
@@ -12165,9 +12645,19 @@ var roadTreatmentStyleSchema = z5.object({
   tunnel: roadTreatmentLayerStyleSchema.optional(),
   widthScale: themeNumberValueSchema.optional()
 }).strict();
+var barrierStyleSchema = z5.object({
+  area: fillStyleSchema.optional(),
+  shadow: lineStyleSchema.optional(),
+  line: lineStyleSchema.optional()
+}).strict();
 var landModuleSchema = z5.object({
   type: z5.literal("land"),
   background: backgroundStyleSchema.optional(),
+  barriers: z5.object({
+    fence: barrierStyleSchema.optional(),
+    hedge: barrierStyleSchema.optional(),
+    wall: barrierStyleSchema.optional()
+  }).strict().optional(),
   enabled: z5.boolean().optional(),
   globalLandcover: fillStyleSchema.optional(),
   landcover: z5.object({
@@ -12207,8 +12697,8 @@ var waterModuleSchema = z5.object({
   bathymetry: fillStyleSchema.optional(),
   bathymetryContours: lineStyleSchema.optional(),
   bathymetryLabels: symbolStyleSchema.optional(),
-  bathymetryLandforms: symbolStyleSchema.optional(),
-  bathymetryWaterNames: symbolStyleSchema.optional(),
+  bathymetryLandforms: bathymetryNameStyleSchema.optional(),
+  bathymetryWaterNames: bathymetryNameStyleSchema.optional(),
   bodies: areaStyleSchema.optional(),
   enabled: z5.boolean().optional(),
   intermittent: z5.object({ bodies: areaStyleSchema.optional(), waterways: lineStyleSchema.optional() }).strict().optional(),
@@ -12243,6 +12733,7 @@ var buildingsModuleSchema = z5.object({
     lighting: z5.enum(["style", "sun"]).optional(),
     colorVariation: boundedThemeNumberSchema(0, 1).optional(),
     edges: boundedThemeNumberSchema(0, 1).optional(),
+    edgeRadius: z5.number().min(0).max(1).optional(),
     edgeColor: themeColorValueSchema.optional(),
     nightLight: boundedThemeNumberSchema(0, 2).optional(),
     occlusion: z5.boolean().optional(),
@@ -12369,6 +12860,9 @@ var roadsModuleSchema = z5.object({
   }).strict().optional(),
   oneWayMarkers: z5.boolean().optional(),
   outline: z5.enum(["none", "subtle", "strong"]).optional(),
+  rampOrder: z5.enum(["below-roads", "by-class"]).describe(
+    "Ramp fills draw below receiving roads by default. Use by-class to keep ramp fills in their road class order."
+  ).optional(),
   restrictions: z5.object({
     access: roadTreatmentStyleSchema.optional(),
     bicycle: roadTreatmentStyleSchema.optional(),
@@ -12377,7 +12871,16 @@ var roadsModuleSchema = z5.object({
     toll: roadTreatmentStyleSchema.optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional(),
-  roundabouts: z5.object({ casing: circleStyleSchema.optional(), fill: circleStyleSchema.optional() }).strict().optional(),
+  roundabouts: z5.object({
+    borderWidth: nonnegativeNumberValueSchema.describe(
+      "Extra casing width in pixels, split across both edges. Defaults to the effective road border width."
+    ).optional(),
+    casing: circleStyleSchema.optional(),
+    fallbackWidth: nonnegativeNumberValueSchema.describe(
+      "Road width in pixels used only when metric radii are absent. Defaults to the effective surface fill width."
+    ).optional(),
+    fill: circleStyleSchema.optional()
+  }).strict().optional(),
   serviceTypes: z5.object({
     alley: roadTreatmentStyleSchema.optional(),
     crossover: roadTreatmentStyleSchema.optional(),
@@ -12425,6 +12928,9 @@ var labelsModuleSchema = z5.object({
   language: z5.string().trim().min(1).optional(),
   places: z5.enum(["none", "major", "all"]).optional(),
   roadClasses: z5.array(roadClassSchema).min(1).optional(),
+  roadPlacement: z5.enum(["ground", "foreground"]).describe(
+    "Street names draw in the foreground by default. Ground names draw below buildings, use map-aligned text by default, and yield collisions to foreground symbols. Shields and junction numbers stay in the foreground."
+  ).optional(),
   renderStack: renderStackSchema.optional(),
   roads: z5.enum(["none", "highways", "major", "streets", "all"]).optional(),
   styles: z5.object({
@@ -12522,6 +13028,8 @@ var modulesSchema = z5.object({
       broadleafColors: z5.array(themeColorValueSchema).min(1).max(8).optional(),
       coniferColors: z5.array(themeColorValueSchema).min(1).max(8).optional(),
       palmColors: z5.array(themeColorValueSchema).min(1).max(8).optional(),
+      hedges: z5.boolean().optional(),
+      hedgeColors: z5.array(themeColorValueSchema).min(1).max(8).optional(),
       finish: z5.enum(["faceted", "smooth", "toon"]).optional(),
       edges: boundedThemeNumberSchema(0, 1).optional(),
       edgeColor: themeColorValueSchema.optional(),
@@ -12598,6 +13106,7 @@ var layerBindingsSchema = z5.object({
   roadShield: z5.string().trim().min(1).optional(),
   sidewalk: z5.string().trim().min(1).optional(),
   streetFurniture: z5.string().trim().min(1).optional(),
+  trafficControl: z5.string().trim().min(1).optional(),
   tree: z5.string().trim().min(1).optional(),
   water: z5.string().trim().min(1),
   waterName: z5.string().trim().min(1),
@@ -12633,6 +13142,7 @@ var fieldBindingsSchema = z5.object({
   elevationFeet: z5.string().trim().min(1),
   expressway: z5.string().trim().min(1),
   foot: z5.string().trim().min(1),
+  hedge: z5.string().trim().min(1).optional(),
   height: z5.string().trim().min(1),
   hasParts: z5.string().trim().min(1),
   hide3d: z5.string().trim().min(1),
@@ -12803,6 +13313,14 @@ var marineSchema = z5.union([
     nautical: z5.union([z5.literal(false), marineSourceSchema]).optional()
   }).strict()
 ]);
+var boundaryAreasSchema = z5.union([
+  z5.literal(false),
+  z5.object({
+    family: z5.enum(["boundaries"]),
+    promoteId: z5.literal("ref").optional(),
+    url: publicVectorUrlSchema.optional()
+  }).strict()
+]);
 var directVectorDataSchema = z5.object({
   ...vectorDataShape,
   bounds: z5.tuple([
@@ -13077,10 +13595,32 @@ var terrainSchema = z5.union([
     encoding: z5.enum(["mapbox", "terrarium"]).optional(),
     exaggeration: z5.number().finite().min(0).max(10).optional(),
     hillshade: terrainHillshadeSchema.optional(),
+    tiles: z5.array(
+      z5.string().refine(
+        isSafeTileflowDemUrlTemplate,
+        "Expected an HTTP(S) DEM template containing {z}, {x}, and {y}"
+      )
+    ).min(1).max(8).optional(),
+    tileSize: z5.union([z5.literal(256), z5.literal(512)]).optional(),
+    minZoom: z5.number().int().min(0).max(24).optional(),
+    maxZoom: z5.number().int().min(0).max(24).optional(),
     mode: z5.enum(["none", "hillshade", "3d"]).optional(),
     sourceId: z5.string().trim().min(1).optional(),
     url: z5.string().trim().min(1).optional()
-  }).strict()
+  }).strict().superRefine((value, context) => {
+    if (value.tiles && value.url)
+      context.addIssue({
+        code: "custom",
+        message: "Terrain accepts tiles or url, not both",
+        path: ["tiles"]
+      });
+    if ((value.minZoom ?? 0) > (value.maxZoom ?? 24))
+      context.addIssue({
+        code: "custom",
+        message: "Terrain maxZoom must be at least minZoom",
+        path: ["maxZoom"]
+      });
+  })
 ]);
 var atmosphereColorLiteralSchema = z5.string().refine((value) => Color3.parse(value)?.a === 1, "Expected an opaque color");
 var atmosphereColorSchema = z5.union([
@@ -13133,6 +13673,7 @@ var themesSchema = z5.record(tileflowThemeNameSchema, tileflowThemeSchema).super
 var systemThemesSchema = z5.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict();
 var resolvedTileflowMapSchema = z5.object({
   atmosphere: atmosphereSchema.optional(),
+  boundaryAreas: boundaryAreasSchema.optional(),
   data: dataSchema.optional(),
   defaultTheme: tileflowThemeNameSchema,
   fonts: fontDirectoriesSchema.optional(),
@@ -13557,7 +14098,10 @@ function resolveRaster(terrain, apiBaseUrl, encoding) {
       ...terrain.attribution ? { attribution: terrain.attribution } : {},
       encoding,
       type: "raster-dem",
-      url
+      ...terrain.tiles ? { tiles: [...terrain.tiles] } : { url },
+      ...terrain.minZoom === void 0 ? {} : { minzoom: terrain.minZoom },
+      ...terrain.maxZoom === void 0 ? {} : { maxzoom: terrain.maxZoom },
+      ...terrain.tileSize === void 0 ? {} : { tileSize: terrain.tileSize }
     }
   };
 }
@@ -13645,6 +14189,91 @@ var tileflowCompilationPlannerStages = Object.freeze([
   "lowering"
 ]);
 
+// src/cartography/design-decisions.ts
+function describeTileflowDesignDecisions(input) {
+  const { map, modules, theme, buildings: buildings2 } = input;
+  const decisions = input.colors.map(
+    ({ role, source, value }) => ({
+      path: `themes.${theme}.tokens.color.${role}`,
+      source,
+      value,
+      reason: source === "theme" ? "The selected theme defines this role, including any authored token expression." : "The compiler derives this optional role from the selected theme color roles.",
+      override: `Set tokens.color[${JSON.stringify(role)}] in defineTheme(); an explicit role replaces this derivation.`
+    })
+  );
+  const policy = (domain, key, value, reason) => {
+    const path = `modules.${domain}.${key}`;
+    const authored = key.split(".").reduce(
+      (node2, part) => node2 && typeof node2 === "object" ? node2[part] : void 0,
+      map.modules?.[domain]
+    );
+    decisions.push({
+      path,
+      value,
+      source: authored === void 0 ? "default" : "map",
+      reason,
+      override: `Set ${path} with ${domain}(...) or refine(...); reset() restores the SDK default. Render-stack refinements apply after module policies.`
+    });
+  };
+  if (modules.roads.enabled !== false) {
+    const roads2 = resolveRoads(modules.roads);
+    policy(
+      "roads",
+      "rampOrder",
+      roads2.rampOrder,
+      "Below-roads draws ramp fills before receiving carriageways; by-class keeps each fill with its road class."
+    );
+    policy(
+      "roads",
+      "detail",
+      roads2.detail,
+      "Road detail selects the initial classes; explicit class settings and disabled classes refine that selection."
+    );
+  }
+  if (modules.labels.enabled !== false) {
+    const labels2 = resolveLabels(modules.labels);
+    policy(
+      "labels",
+      "roadPlacement",
+      labels2.roadPlacement,
+      "Ground names draw below buildings and yield in collisions to foreground symbols; foreground names draw above buildings."
+    );
+    policy(
+      "labels",
+      "collisionPriority",
+      labels2.collisionPriority,
+      "Navigation prioritizes structural road classes within their drawing stack; it does not decouple collision priority from depth."
+    );
+  }
+  if (buildings2) {
+    policy(
+      "buildings",
+      "threeDimensional.edgeRadius",
+      buildings2.edgeRadius,
+      "Radius in metres rounds building corners; zero retains sharp corners."
+    );
+    policy(
+      "buildings",
+      "threeDimensional.lighting",
+      buildings2.lighting,
+      "Sun lighting shares scene illumination; style lighting uses the alternate building shading mode."
+    );
+    policy(
+      "buildings",
+      "threeDimensional.shadows",
+      buildings2.shadows,
+      "Cast shadows follow scene light; false disables them independently of contact occlusion."
+    );
+    policy(
+      "buildings",
+      "threeDimensional.occlusion",
+      buildings2.occlusion,
+      "Contact occlusion separates buildings from the ground and shades lower walls; false disables it independently."
+    );
+  }
+  return decisions;
+}
+
 // src/cartography/graph.ts
 function assembleTileflowLayerFamilies(families, extraConstraints = []) {
   const slotOrder = resolveSlotOrder(extraConstraints);
@@ -14127,7 +14756,7 @@ function diagnoseFractionalLayoutZoomSteps(layers) {
 function fractionalZoomSteps(value) {
   if (!Array.isArray(value)) return [];
   const stops = [];
-  if (value[0] === "step" && isZoom(value[1])) {
+  if (value[0] === "step" && isZoom2(value[1])) {
     for (let index = 3; index < value.length; index += 2) {
       const stop = value[index];
       if (typeof stop === "number" && !Number.isInteger(stop)) stops.push(stop);
@@ -14136,7 +14765,7 @@ function fractionalZoomSteps(value) {
   for (const entry of value) stops.push(...fractionalZoomSteps(entry));
   return stops;
 }
-function isZoom(value) {
+function isZoom2(value) {
   return Array.isArray(value) && value.length === 1 && value[0] === "zoom";
 }
 
@@ -14265,6 +14894,7 @@ function canMergeRoadLines(layers) {
 function mergeRoadLineGroup(key, layers) {
   const first = layers[0];
   const conditions = layers.map((layer) => asFilter(layer.selector));
+  if (conditions.some(containsZoom)) return void 0;
   const paint = {};
   const paintKeys = new Set(layers.flatMap((layer) => Object.keys(layer.style.appearance ?? {})));
   for (const key2 of paintKeys) {
@@ -14911,7 +15541,7 @@ function sameLayerSource(left, right) {
 }
 function sameTopLevelProperties(left, right, additionallyIgnored = []) {
   const ignored = new Set(additionallyIgnored);
-  const select = (layer) => ({
+  const select2 = (layer) => ({
     annotations: layer.annotations,
     feature: layer.feature,
     properties: layer.properties,
@@ -14920,7 +15550,7 @@ function sameTopLevelProperties(left, right, additionallyIgnored = []) {
     ),
     renderer: layer.renderer
   });
-  return allEqual([select(left), select(right)]);
+  return allEqual([select2(left), select2(right)]);
 }
 function isOrderedRenderPass(layer) {
   return layer.origins.some(({ operations }) => operations.some(({ kind }) => kind === "pass"));
@@ -14987,6 +15617,7 @@ function tileflowBuildings3DDesignOf(module, context, layers, buildingModels, ti
   const config = isRecord8(module) ? module : {};
   if (config.enabled === false) return void 0;
   const style = config.threeDimensional ?? {};
+  const defaults4 = tileflowDefaultBuildings3DDesign;
   let color2;
   let verticalGradient = true;
   for (const [id2, property] of colourSources) {
@@ -15009,15 +15640,16 @@ function tileflowBuildings3DDesignOf(module, context, layers, buildingModels, ti
       ...context.data.schema.layers.poi ? { places: context.data.schema.layers.poi } : {}
     },
     color: color2 ?? context.colors.buildings.generic,
-    lighting: style.lighting === "sun" ? "sun" : "style",
+    lighting: style.lighting === "style" ? "style" : defaults4.lighting,
     colorVariation: number(style.colorVariation, 0),
     verticalGradient,
     edges: number(style.edges, 0),
+    edgeRadius: number(style.edgeRadius, defaults4.edgeRadius),
     ...typeof edgeColor === "string" ? { edgeColor } : {},
     nightLight: number(style.nightLight, 0),
     windows: style.windows === true,
-    shadows: style.shadows === true,
-    occlusion: style.occlusion === true,
+    shadows: typeof style.shadows === "boolean" ? style.shadows : defaults4.shadows,
+    occlusion: typeof style.occlusion === "boolean" ? style.occlusion : defaults4.occlusion,
     ...placedModels(style.models, buildingModels),
     ...modelColours(style.modelColors),
     ...landmarksOf(style.landmarks, tileflowLandmarks)
@@ -15064,7 +15696,7 @@ function tileflowStreetLightsDesignOf(module, context) {
   const config = isRecord8(module) ? module : {};
   const layers = context.data.schema.layers;
   const style = config.streetLights ?? {};
-  if (config.enabled === false || style.enabled === false || !layers.streetFurniture)
+  if (config.enabled === false || style.enabled !== true || !layers.streetFurniture)
     return void 0;
   const color2 = style.color === void 0 ? void 0 : toMapLibreStyleValue(style.color);
   const intensity = style.intensity === void 0 ? void 0 : toMapLibreStyleValue(style.intensity);
@@ -15137,6 +15769,10 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   const data = runCompilationPhase("data", () => resolveTileflowData(config.data, { apiBaseUrl }));
   const marine = runCompilationPhase("data", () => resolveMarine(config.marine, apiBaseUrl));
   const terrain = runCompilationPhase("data", () => resolveTerrain(config.terrain, apiBaseUrl));
+  const boundaryAreas = runCompilationPhase(
+    "data",
+    () => resolveBoundaryAreas(config.boundaryAreas, apiBaseUrl)
+  );
   const terrainSources = [terrain?.raster, terrain?.contours].filter(
     (source) => source !== void 0
   );
@@ -15177,11 +15813,17 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       }
       marineSourceIds.add(source.sourceId);
     }
+    if (boundaryAreas && (boundaryAreas.sourceId === data.sourceId || terrainSourceIds.has(boundaryAreas.sourceId) || marineSourceIds.has(boundaryAreas.sourceId))) {
+      throw new Error(
+        `Boundaries source ID "${boundaryAreas.sourceId}" conflicts with another Tileflow source.`
+      );
+    }
   });
   const platformSourceIds = [
     data.sourceId,
     ...terrainSources.map(({ sourceId }) => sourceId),
-    ...marineSources.map(({ sourceId }) => sourceId)
+    ...marineSources.map(({ sourceId }) => sourceId),
+    ...boundaryAreas ? [boundaryAreas.sourceId] : []
   ];
   const hostedSources = runCompilationPhase(
     "data",
@@ -15209,7 +15851,14 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     "data",
     () => createSemanticDataView(semanticData)
   );
-  const colors = runCompilationPhase("theme", () => resolveThemeColors(selected.theme));
+  const colorDecisions = [];
+  const colors = runCompilationPhase(
+    "theme",
+    () => resolveThemeColors(
+      selected.theme,
+      onReport ? (decision) => colorDecisions.push(decision) : void 0
+    )
+  );
   const images = runCompilationPhase("theme", () => resolveThemeImages(selected.theme));
   const typography = resolvedTheme.typography;
   const context = {
@@ -15278,8 +15927,11 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     () => insertTileflowOverlays({
       basemapLayers,
       mapId: config.id,
-      overlays: config.overlays,
-      sourceIds: Object.keys(hostedSources.definitions)
+      overlays: validateBoundaryChoroplethOverlays(config.id, config.overlays, boundaryAreas),
+      sourceIds: [
+        ...Object.keys(hostedSources.definitions),
+        ...boundaryAreas ? [boundaryAreas.sourceId] : []
+      ]
     })
   );
   const plannedLayers = loweredOverlays.layers;
@@ -15436,6 +16088,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     ...marine?.nautical ? { [marine.nautical.sourceId]: marine.nautical.source } : {},
     ...terrain?.raster ? { [terrain.raster.sourceId]: terrain.raster.source } : {},
     ...terrain?.contours ? { [terrain.contours.sourceId]: terrain.contours.source } : {},
+    ...boundaryAreas ? { [boundaryAreas.sourceId]: boundaryAreas.source } : {},
     ...hostedSources.definitions
   };
   const sourceIdentities = {
@@ -15443,6 +16096,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     ...marine?.bathymetry?.vector ? { [marine.bathymetry.vector.sourceId]: marine.bathymetry.vector.identity } : {},
     ...marine?.bathymetry?.relief ? { [marine.bathymetry.relief.sourceId]: marine.bathymetry.relief.identity } : {},
     ...marine?.nautical ? { [marine.nautical.sourceId]: marine.nautical.identity } : {},
+    ...boundaryAreas ? { [boundaryAreas.sourceId]: boundaryAreas.identity } : {},
     ...hostedSources.identities
   };
   const sourceRequirements = runCompilationPhase(
@@ -15527,6 +16181,15 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   };
   const report = {
     ...partialReport,
+    ...onReport ? {
+      decisions: describeTileflowDesignDecisions({
+        map: input,
+        modules,
+        theme: selected.name,
+        colors: colorDecisions,
+        ...buildings3D ? { buildings: buildings3D } : {}
+      })
+    } : {},
     requirements: sourceRequirements
   };
   onReport?.(report);
@@ -16330,29 +16993,6 @@ function checkShotTiming(shot, context) {
   }
 }
 
-// src/maps/operations.ts
-var resetValue = deepFreeze({ $tileflow: "reset" });
-var disableValue = deepFreeze({ op: "disable" });
-function isTileflowReset(value) {
-  if (!isPlainRecord3(value)) return false;
-  return value.$tileflow === "reset" && Object.keys(value).length === 1;
-}
-function isTileflowModuleOperation(value) {
-  if (!isPlainRecord3(value) || typeof value.op !== "string") return false;
-  return value.op === "disable" || value.op === "refine";
-}
-function deepFreeze(value) {
-  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
-  Object.freeze(value);
-  for (const child of Object.values(value)) deepFreeze(child);
-  return value;
-}
-function isPlainRecord3(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-
 // src/maps/resolve.ts
 var tileflowMapDefaultMaxDepth = 64;
 var TileflowMapResolutionError = class extends Error {
@@ -16369,6 +17009,7 @@ var TileflowMapResolutionError = class extends Error {
 };
 var tileflowMapMergeStrategies = {
   atmosphere: "atomic",
+  boundaryAreas: "atomic",
   data: "atomic",
   defaultTheme: "atomic",
   extends: "lineage",