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

package/dist/build.js

@@ -45,6 +45,25 @@ function compileTileflowSky(options) {
   };
 }
 
+// src/buildings-3d-design.ts
+var tileflowBuildingsMetadataKey = "tileflow:buildings";
+var tileflowDefaultBuildings3DDesign = Object.freeze({
+  source: "tileflow",
+  layers: Object.freeze({ building: "building", places: "poi" }),
+  color: "#d8d0c0",
+  edges: 0,
+  lighting: "style",
+  colorVariation: 0,
+  verticalGradient: true,
+  nightLight: 0,
+  windows: false,
+  shadows: false,
+  occlusion: false
+});
+function tileflowBuildingsMetadata(design) {
+  return { version: 1, ...design };
+}
+
 // src/data/world-generation.ts
 var tileflowWorldGeneration = "v1";
 
@@ -135,6 +154,7 @@ var canonicalFields = {
   markings: "markings",
   minHeight: "min_height",
   minZoom: "min_zoom",
+  mode: "mode",
   mtbScale: "mtb_scale",
   name: "name",
   nameEnglish: "name:en",
@@ -635,7 +655,16 @@ var tileflowBathymetrySourceId = "tileflow-bathymetry";
 var tileflowBathymetryDemSourceId = "tileflow-bathymetry-dem";
 var tileflowNauticalSourceId = "tileflow-nautical";
 var tileflowBathymetryV1Schema = Object.freeze({
-  fields: Object.freeze({ minDepth: "min_depth", sortKey: "sort_key" }),
+  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",
@@ -700,6 +729,7 @@ var tileflowNauticalV1Schema = Object.freeze({
   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") {
@@ -739,6 +769,7 @@ function resolveBathymetry(input, apiBaseUrl) {
     ...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({
@@ -850,98 +881,6 @@ function cloneJson(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
-// 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 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 splitBandPlacement(placement) {
-  const separator = placement.indexOf("-");
-  return [
-    placement.slice(0, separator),
-    placement.slice(separator + 1)
-  ];
-}
-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", ...cloneJson2(options) };
-}
-function cloneJson2(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";
 
@@ -997,20 +936,20 @@ function createTileflowLineBackgroundFontStack(source, metrics = {}) {
   return stack;
 }
 function parseTileflowLineBackgroundFontStack(stack) {
-  const match2 = STACK_PATTERN.exec(stack);
-  if (!match2 || stack.length > MAX_STACK_LENGTH || !SOURCE_PATTERN.test(match2[1]))
+  const match3 = STACK_PATTERN.exec(stack);
+  if (!match3 || stack.length > MAX_STACK_LENGTH || !SOURCE_PATTERN.test(match3[1]))
     return void 0;
   const metrics = {
-    letterSpacing: Number(match2[2]) / 1e3,
-    lineHeight: Number(match2[3]) / 1e3,
-    padding: Number(match2[4]) / 1e3
+    letterSpacing: Number(match3[2]) / 1e3,
+    lineHeight: Number(match3[3]) / 1e3,
+    padding: Number(match3[4]) / 1e3
   };
   try {
     const normalized = normalizeTileflowLineBackgroundMetrics(metrics);
-    if (`lines-v1-t${thousandths(normalized.letterSpacing)}-l${thousandths(normalized.lineHeight)}-p${thousandths(normalized.padding)}` !== stack.slice(match2[1].length + 1)) {
+    if (`lines-v1-t${thousandths(normalized.letterSpacing)}-l${thousandths(normalized.lineHeight)}-p${thousandths(normalized.padding)}` !== stack.slice(match3[1].length + 1)) {
       return void 0;
     }
-    return { metrics: normalized, source: match2[1] };
+    return { metrics: normalized, source: match3[1] };
   } catch {
     return void 0;
   }
@@ -1169,11 +1108,11 @@ var zoom = {
 };
 function expression(value) {
   validateExpressionArray(value, "expression");
-  return { kind: "expression", value: cloneJson3(value) };
+  return { kind: "expression", value: cloneJson2(value) };
 }
 function toMapLibreStyleValue(value) {
   if (isTileflowExpression(value)) {
-    return cloneJson3(value.value);
+    return cloneJson2(value.value);
   }
   if (isTileflowZoomValue(value)) {
     if (value.interpolation === "step") {
@@ -1181,8 +1120,8 @@ function toMapLibreStyleValue(value) {
       return [
         "step",
         ["zoom"],
-        cloneJson3(firstValue),
-        ...rest.flatMap(([stop, stopValue]) => [stop, cloneJson3(stopValue)])
+        cloneJson2(firstValue),
+        ...rest.flatMap(([stop, stopValue]) => [stop, cloneJson2(stopValue)])
       ];
     }
     const interpolation = value.interpolation === "exponential" ? ["exponential", value.base] : [value.interpolation];
@@ -1190,13 +1129,13 @@ function toMapLibreStyleValue(value) {
       "interpolate",
       interpolation,
       ["zoom"],
-      ...value.stops.flatMap(([stop, stopValue]) => [stop, cloneJson3(stopValue)])
+      ...value.stops.flatMap(([stop, stopValue]) => [stop, cloneJson2(stopValue)])
     ];
   }
   if (isTileflowThemeValueNode(value)) {
     throw new Error("Tileflow theme values must be resolved before MapLibre style compilation.");
   }
-  return cloneJson3(value);
+  return cloneJson2(value);
 }
 function isTileflowExpression(value) {
   return isRecord(value) && value.kind === "expression" && Array.isArray(value.value);
@@ -1233,7 +1172,7 @@ function createZoomValue(interpolation, stops, base) {
       throw new Error("Tileflow zoom stops must be strictly increasing.");
     }
     previous = stop;
-    return [stop, cloneJson3(value)];
+    return [stop, cloneJson2(value)];
   });
   return {
     kind: "zoom",
@@ -1249,9 +1188,9 @@ function validateExpressionArray(value, name) {
   if (!isMapLibreExpressionOperator(value[0])) {
     throw new Error(`Unknown MapLibre expression operator: ${value[0]}`);
   }
-  cloneJson3(value);
+  cloneJson2(value);
 }
-function cloneJson3(value) {
+function cloneJson2(value) {
   const serialized = JSON.stringify(value);
   if (serialized === void 0) {
     throw new Error("Tileflow style values must be JSON-serializable.");
@@ -1571,30 +1510,30 @@ function asRecord(value) {
 
 // src/cartography/merge.ts
 function mergeTileflowDesign(base, ...overlays) {
-  let resolved = cloneJson4(base);
+  let resolved = cloneJson3(base);
   for (const overlay of overlays) {
     resolved = mergeValue(resolved, overlay);
   }
   return resolved;
 }
 function mergeValue(base, overlay) {
-  if (overlay === void 0) return cloneJson4(base);
+  if (overlay === void 0) return cloneJson3(base);
   if (Array.isArray(overlay) || isTileflowExpression(overlay) || isTileflowThemeValueNode(overlay) || isTileflowZoomValue(overlay) || !isRecord2(overlay)) {
-    return cloneJson4(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] = cloneJson4(baseRecord[key]);
+      if (key in baseRecord) result[key] = cloneJson3(baseRecord[key]);
       continue;
     }
     result[key] = mergeValue(baseRecord[key], overlayValue);
   }
   return result;
 }
-function cloneJson4(value) {
+function cloneJson3(value) {
   if (value === void 0) return value;
   return JSON.parse(JSON.stringify(value));
 }
@@ -1602,6 +1541,306 @@ 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 };
+}
+
+// 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 } : {}
+    },
+    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: []
+  };
+}
+
+// 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 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 splitBandPlacement(placement) {
+  const separator = placement.indexOf("-");
+  return [
+    placement.slice(0, separator),
+    placement.slice(separator + 1)
+  ];
+}
+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) };
+}
+function cloneJson4(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/modules/addresses/compiler.ts
 function compileAddresses(request, context) {
   if (request?.enabled === false) return [];
@@ -2068,7 +2307,21 @@ function buildingColorExpression(context) {
     colors.destination,
     ["==", ["coalesce", ["get", fields.buildingTone], ""], "commercial"],
     colors.commercial,
-    colors.generic
+    // Without a tone, World's use class: housing, shops and offices, public buildings and works
+    // each take their theme colour; a shed, a garage or an unknown use the generic one.
+    [
+      "match",
+      ["coalesce", ["get", fields.class], ""],
+      "residential",
+      colors.residential,
+      "commercial",
+      colors.commercial,
+      ["civic", "education", "entertainment", "medical", "military", "religious", "transportation"],
+      colors.civic,
+      ["agricultural", "industrial", "service"],
+      colors.industrial,
+      colors.generic
+    ]
   ];
 }
 function buildingVisibilityFilter() {
@@ -2332,6 +2585,9 @@ function cloneJson9(value) {
 function labelField(language, context) {
   return expression(labelFieldExpression(language, context));
 }
+function labelNameFields(language, context) {
+  return labelFieldExpression(language, context).slice(1).map((entry) => entry[1]);
+}
 function labelFieldExpression(language, context) {
   const fields = context.data.schema.fields;
   if (language === "local") {
@@ -3189,12 +3445,12 @@ function compileLand(request, context) {
     if (name === "recreation") continue;
     appendLanduse(name, classes);
   }
-  for (const [name, match2] of landcoverClasses) {
+  for (const [name, match3] of landcoverClasses) {
     const style = config.landcover?.[name];
     if (!style) continue;
     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, match2);
+    const filter = protectedSource && schema.semantics.parkLayer === "protected-only" ? void 0 : landcoverFilter(classField, subclassField, match3);
     for (const area of createAreaLayers(
       {
         id: `tileflow-landcover-${name}`,
@@ -3250,11 +3506,11 @@ function compileLand(request, context) {
 function classFilter2(field2, classes) {
   return ["match", ["get", field2], classes, true, false];
 }
-function landcoverFilter(classField, subclassField, match2) {
-  const filter = classFilter2(classField, match2.class);
-  if (match2.subclass) return ["all", filter, classFilter2(subclassField, match2.subclass)];
-  if (match2.excludeSubclass) {
-    return ["all", filter, ["!", classFilter2(subclassField, match2.excludeSubclass)]];
+function landcoverFilter(classField, subclassField, match3) {
+  const filter = classFilter2(classField, match3.class);
+  if (match3.subclass) return ["all", filter, classFilter2(subclassField, match3.subclass)];
+  if (match3.excludeSubclass) {
+    return ["all", filter, ["!", classFilter2(subclassField, match3.excludeSubclass)]];
   }
   return filter;
 }
@@ -3963,149 +4219,557 @@ var tileflowPoiImageRoles = Object.freeze({
   transport: { fallback: "major-transit", token: "poi.transport" },
   "visitor-amenity": { fallback: "services", token: "poi.visitor-amenity" }
 });
+var tileflowPoiIconOnlyTypes = Object.freeze([
+  "parking",
+  "parking_garage",
+  "parking_lot",
+  "public_restroom"
+]);
 function poi(options = {}) {
   return { type: "poi", ...cloneJson13(options) };
 }
-function resolvePoi(request) {
-  return {
-    categories: [...new Set(request?.categories ?? tileflowPoiCategories)],
-    color: request?.color ?? "uniform",
-    density: request?.density ?? 3,
-    icons: request?.icons ?? true,
-    labels: request?.labels ?? true,
-    minZoom: request?.minZoom ?? 0,
-    placement: {
-      coupleIconAndLabel: request?.placement?.coupleIconAndLabel ?? false,
-      iconPadding: request?.placement?.iconPadding ?? 2,
-      textPadding: request?.placement?.textPadding ?? 2
+function resolvePoi(request) {
+  return {
+    categories: [...new Set(request?.categories ?? tileflowPoiCategories)],
+    color: request?.color ?? "uniform",
+    density: request?.density ?? 3,
+    icons: request?.icons ?? true,
+    labels: request?.labels ?? true,
+    minZoom: request?.minZoom ?? 0,
+    placement: {
+      coupleIconAndLabel: request?.placement?.coupleIconAndLabel ?? false,
+      iconOnlyTypes: [...request?.placement?.iconOnlyTypes ?? tileflowPoiIconOnlyTypes],
+      iconPadding: request?.placement?.iconPadding ?? 2,
+      order: request?.placement?.order ?? "importance",
+      ...request?.placement?.prominentRank === void 0 ? {} : { prominentRank: request.placement.prominentRank },
+      textPadding: request?.placement?.textPadding ?? 2
+    }
+  };
+}
+function cloneJson13(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/poi/placement.ts
+var tileflowPoiFeatureVaryingProperties = Object.freeze({
+  circle: Object.freeze({
+    "circle-blur": 0,
+    "circle-color": "#000000",
+    "circle-opacity": 1,
+    "circle-radius": 5,
+    "circle-sort-key": void 0,
+    "circle-stroke-color": "#000000",
+    "circle-stroke-opacity": 1,
+    "circle-stroke-width": 0
+  }),
+  symbol: Object.freeze({
+    "icon-anchor": "center",
+    "icon-color": "#000000",
+    "icon-halo-blur": 0,
+    "icon-halo-color": "rgba(0, 0, 0, 0)",
+    "icon-halo-width": 0,
+    // An empty image draws no icon, so a category without one stays text-only.
+    "icon-image": "",
+    "icon-offset": [0, 0],
+    "icon-opacity": 1,
+    "icon-padding": [2],
+    "icon-rotate": 0,
+    "icon-size": 1,
+    "symbol-sort-key": void 0,
+    "text-anchor": "center",
+    "text-color": "#000000",
+    "text-field": "",
+    // MapLibre can vary `text-font` per feature, but Tileflow prepares glyphs for a static font
+    // stack, so the font stays a layer-wide property.
+    "text-halo-blur": 0,
+    "text-halo-color": "rgba(0, 0, 0, 0)",
+    "text-halo-width": 0,
+    "text-justify": "center",
+    "text-letter-spacing": 0,
+    "text-max-width": 10,
+    "text-offset": [0, 0],
+    "text-opacity": 1,
+    "text-radial-offset": 0,
+    "text-rotate": 0,
+    "text-size": 16,
+    "text-transform": "none",
+    "text-variable-anchor-offset": void 0
+  })
+});
+var tileflowPoiLayerPropertyDefaults = Object.freeze({
+  "circle-pitch-alignment": "viewport",
+  "circle-pitch-scale": "map",
+  "circle-translate": [0, 0],
+  "circle-translate-anchor": "map",
+  "icon-allow-overlap": false,
+  "icon-ignore-placement": false,
+  "icon-keep-upright": false,
+  "icon-optional": false,
+  "icon-pitch-alignment": "auto",
+  "icon-rotation-alignment": "auto",
+  "icon-text-fit": "none",
+  "icon-text-fit-padding": [0, 0, 0, 0],
+  "symbol-avoid-edges": false,
+  "symbol-placement": "point",
+  "symbol-spacing": 250,
+  "symbol-z-order": "auto",
+  "text-allow-overlap": false,
+  "text-ignore-placement": false,
+  "text-keep-upright": true,
+  "text-line-height": 1.2,
+  "text-max-angle": 45,
+  "text-optional": false,
+  "text-padding": 2,
+  "text-pitch-alignment": "auto",
+  "text-rotation-alignment": "auto",
+  visibility: "visible"
+});
+var TileflowPoiPlacementError = class extends Error {
+  code = "TILEFLOW_POI_PLACEMENT_CONFLICT";
+  constructor(message) {
+    super(message);
+    this.name = "TileflowPoiPlacementError";
+  }
+};
+function mergePoiCategoryLayers(entries, options) {
+  const [first] = entries;
+  if (!first) throw new TileflowPoiPlacementError("A POI placement layer needs a category.");
+  const kind = first.layer.type === "circle" ? "circle" : "symbol";
+  const varying = tileflowPoiFeatureVaryingProperties[kind];
+  const categories = entries.map(({ category }) => category);
+  for (const property of ["type", "source", "source-layer", "minzoom", "maxzoom"]) {
+    requireShared(entries, property, (layer) => layer[property]);
+  }
+  const result = {
+    ...first.layer,
+    id: options.id,
+    filter: options.filter
+  };
+  for (const part of ["layout", "paint"]) {
+    const records = entries.map(({ layer }) => asRecord2(layer[part]));
+    const properties2 = [...new Set(records.flatMap((record3) => Object.keys(record3)))].sort();
+    const merged = {};
+    for (const property of properties2) {
+      const fallback = Object.hasOwn(varying, property) ? varying[property] : tileflowPoiLayerPropertyDefaults[property];
+      const values = records.map(
+        (record3) => Object.hasOwn(record3, property) ? record3[property] : fallback
+      );
+      if (values.every((value) => sameJson(value, values[0]))) {
+        if (values[0] !== void 0) merged[property] = values[0];
+        continue;
+      }
+      if (!Object.hasOwn(varying, property)) {
+        throw conflict(entries, property, (layer) => asRecord2(layer[part])[property]);
+      }
+      if (values.some((value) => value === void 0)) {
+        throw new TileflowPoiPlacementError(
+          `POI categories ${categories.join(", ")} set ${property} for only some categories, and MapLibre has no default to fill in for the rest. Set it for every category.`
+        );
+      }
+      merged[property] = matchByCategory(
+        property,
+        categories.map((category, index) => [category, values[index]]),
+        ["get", options.categoryField]
+      );
+    }
+    if (Object.keys(merged).length) result[part] = merged;
+    else delete result[part];
+  }
+  return result;
+}
+function requireShared(entries, property, read) {
+  const value = read(entries[0].layer);
+  if (entries.every(({ layer }) => sameJson(read(layer), value))) return;
+  throw conflict(entries, property, read);
+}
+function conflict(entries, property, read) {
+  const described = entries.map(({ category, layer }) => `${category}: ${JSON.stringify(read(layer)) ?? "unset"}`).join("; ");
+  return new TileflowPoiPlacementError(
+    `POI categories need different ${property} values (${described}), but MapLibre keeps ${property} constant within one layer. Give them the same ${property}, or set placement.order to 'categories' to place each category in its own layer.`
+  );
+}
+function matchByCategory(property, values, input) {
+  const curves = values.map(([, value]) => zoomCurve(value));
+  const present = curves.filter((curve) => curve !== void 0);
+  if (present.length === 0) return match(input, values);
+  const reference = present[0];
+  for (const curve of present) {
+    if (curve.kind !== reference.kind || curve.kind === "interpolate" && reference.kind === "interpolate" && (curve.operator !== reference.operator || !sameJson(curve.interpolation, reference.interpolation))) {
+      throw new TileflowPoiPlacementError(
+        `POI categories use different kinds of zoom curve for ${property}. Use one kind of curve (linear, the same exponential base, or step) for every category, or set placement.order to 'categories'.`
+      );
     }
-  };
+  }
+  const stops = [...new Set(present.flatMap((curve) => curve.stops.map(([zoom3]) => zoom3)))].sort(
+    (left, right) => left - right
+  );
+  const at = (zoom3) => match(
+    input,
+    values.map(([category, value], index) => [
+      category,
+      curves[index] ? evaluateCurve(property, curves[index], zoom3) : value
+    ])
+  );
+  if (reference.kind === "step") {
+    const base = match(
+      input,
+      values.map(([category, value], index) => {
+        const curve = curves[index];
+        return [category, curve?.kind === "step" ? curve.base : value];
+      })
+    );
+    return ["step", ["zoom"], base, ...stops.flatMap((zoom3) => [zoom3, at(zoom3)])];
+  }
+  return [
+    reference.operator,
+    reference.interpolation,
+    ["zoom"],
+    ...stops.flatMap((zoom3) => [zoom3, at(zoom3)])
+  ];
 }
-function cloneJson13(value) {
-  return JSON.parse(JSON.stringify(value));
+function match(input, values) {
+  const groups = [];
+  for (const [category, value] of values) {
+    const group = groups.find((candidate) => sameJson(candidate.value, value));
+    if (group) group.categories.push(category);
+    else groups.push({ categories: [category], value });
+  }
+  if (groups.length === 1) return groups[0].value;
+  const fallback = groups.reduce(
+    (largest, group) => group.categories.length > largest.categories.length ? group : largest
+  );
+  return [
+    "match",
+    input,
+    ...groups.filter((group) => group !== fallback).flatMap((group) => [
+      group.categories.length === 1 ? group.categories[0] : group.categories,
+      expressionValue(group.value)
+    ]),
+    expressionValue(fallback.value)
+  ];
+}
+function zoomCurve(value) {
+  if (!Array.isArray(value)) return void 0;
+  const [operator] = value;
+  if ((operator === "interpolate" || operator === "interpolate-hcl" || operator === "interpolate-lab") && isZoomInput3(value[2])) {
+    return {
+      kind: "interpolate",
+      operator,
+      interpolation: value[1],
+      stops: pairs(value.slice(3))
+    };
+  }
+  if (operator === "step" && isZoomInput3(value[1])) {
+    return { kind: "step", base: value[2], stops: pairs(value.slice(3)) };
+  }
+  return void 0;
+}
+function evaluateCurve(property, curve, zoom3) {
+  const { stops } = curve;
+  if (curve.kind === "step") {
+    let value2 = curve.base;
+    for (const [stop, output] of stops) if (stop <= zoom3) value2 = output;
+    return value2;
+  }
+  const exact = stops.find(([stop]) => stop === zoom3);
+  if (exact) return exact[1];
+  if (zoom3 < stops[0][0]) return stops[0][1];
+  if (zoom3 > stops.at(-1)[0]) return stops.at(-1)[1];
+  const upperIndex = stops.findIndex(([stop]) => stop > zoom3);
+  const [lowerZoom, lower] = stops[upperIndex - 1];
+  const [upperZoom, upper] = stops[upperIndex];
+  const t = interpolationFactor(curve.interpolation, zoom3, lowerZoom, upperZoom);
+  const value = interpolateOutput(lower, upper, t);
+  if (value === void 0) {
+    throw new TileflowPoiPlacementError(
+      `POI categories interpolate ${property} between values Tileflow cannot evaluate at zoom ${zoom3}. Give every category the same zoom stops for ${property}, or set placement.order to 'categories'.`
+    );
+  }
+  return value;
+}
+function interpolationFactor(interpolation, zoom3, lower, upper) {
+  const progress = zoom3 - lower;
+  const range2 = upper - lower;
+  if (Array.isArray(interpolation) && interpolation[0] === "exponential") {
+    const base = Number(interpolation[1]);
+    if (base !== 1) return (base ** progress - 1) / (base ** range2 - 1);
+  }
+  return progress / range2;
+}
+function interpolateOutput(lower, upper, t) {
+  if (typeof lower === "number" && typeof upper === "number") {
+    return roundOutput(lower + (upper - lower) * t);
+  }
+  const lowerArray = numericArray(lower);
+  const upperArray = numericArray(upper);
+  if (lowerArray && upperArray && lowerArray.length === upperArray.length) {
+    return [
+      "literal",
+      lowerArray.map((value, index) => roundOutput(value + (upperArray[index] - value) * t))
+    ];
+  }
+  if (isNumericOutput(lower) && isNumericOutput(upper)) {
+    return ["+", lower, ["*", roundOutput(t), ["-", upper, lower]]];
+  }
+  return void 0;
+}
+function isNumericOutput(value) {
+  if (typeof value === "number") return true;
+  if (!Array.isArray(value) || typeof value[0] !== "string") return false;
+  return isMapLibreExpressionOperator(value[0]) && !["literal", "array"].includes(value[0]);
+}
+function numericArray(value) {
+  const array = Array.isArray(value) && value[0] === "literal" && Array.isArray(value[1]) ? value[1] : value;
+  return Array.isArray(array) && array.every((entry) => typeof entry === "number") ? array : void 0;
+}
+function roundOutput(value) {
+  return Math.round(value * 1e6) / 1e6;
+}
+function expressionValue(value) {
+  if (!Array.isArray(value)) return value;
+  if (typeof value[0] === "string" && isMapLibreExpressionOperator(value[0])) return value;
+  return ["literal", value];
+}
+function pairs(values) {
+  const result = [];
+  for (let index = 0; index + 1 < values.length; index += 2) {
+    result.push([values[index], values[index + 1]]);
+  }
+  return result;
+}
+function isZoomInput3(value) {
+  return Array.isArray(value) && value.length === 1 && value[0] === "zoom";
+}
+function sameJson(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
 // src/modules/poi/compiler.ts
+var representationOrder = {
+  marker: 0,
+  combined: 1,
+  icon: 1,
+  label: 2
+};
 function compilePoi(request, context, language = "auto") {
   if (request?.enabled === false) return [];
   const semantics = resolvePoi(request);
-  const result = [];
+  const selection2 = createPoiSelection(semantics, context, language);
+  const parts = semantics.categories.flatMap(
+    (category) => compileCategory(category, request, semantics, context, language, selection2)
+  );
+  if (semantics.placement.order === "categories") {
+    return parts.map((part) => {
+      const rank = semantics.categories.length - 1 - semantics.categories.indexOf(part.category);
+      const suffix = part.representation === "combined" ? "" : `.${part.representation}`;
+      return poiContribution(
+        `${part.category}${suffix}`,
+        rank * 4 + representationOrder[part.representation],
+        {
+          ...part.layer,
+          id: `tileflow-poi-${part.category}${suffix.replace(".", "-")}`,
+          filter: selection2.filter([part.category], part.representation)
+        }
+      );
+    });
+  }
+  const { prominentRank } = semantics.placement;
+  const filterRank = numericPoiField(context.data.schema.fields.poiFilterRank, 6);
+  return ["marker", "combined", "icon", "label"].flatMap((representation) => {
+    const entries = parts.filter((part) => part.representation === representation);
+    if (entries.length === 0) return [];
+    const suffix = representation === "combined" ? "" : `.${representation}`;
+    const filter = selection2.filter(
+      entries.map(({ category }) => category),
+      representation
+    );
+    const layer = mergePoiCategoryLayers(entries, {
+      categoryField: context.data.schema.fields.poiCategory,
+      filter,
+      id: `tileflow-poi${suffix.replace(".", "-")}`
+    });
+    if (prominentRank === void 0 || representation === "marker") {
+      return [poiContribution(suffix.slice(1), representationOrder[representation], layer)];
+    }
+    return [
+      poiContribution(suffix.slice(1), representationOrder[representation], {
+        ...layer,
+        filter: [...filter, [">", filterRank, prominentRank]]
+      }),
+      poiContribution(`prominent${suffix}`, 400 + representationOrder[representation], {
+        ...layer,
+        id: `tileflow-poi-prominent${suffix.replace(".", "-")}`,
+        filter: [...filter, ["<=", filterRank, prominentRank]]
+      })
+    ];
+  });
+}
+function compileCategory(category, request, semantics, context, language, selection2) {
   const { sourceId: source, schema } = context.data;
-  for (const [index, category] of semantics.categories.entries()) {
-    const requestedCategoryStyle = request?.styles?.[category];
-    const categoryDensity = requestedCategoryStyle?.density ?? semantics.density;
-    const { density: _density, ...categoryStyle } = requestedCategoryStyle ?? {};
-    const categoryColor = semantics.color === "category" ? context.colors.poi[category] ?? context.colors.poi.label : context.colors.poi.label;
-    const defaults4 = {
+  const coupled = semantics.placement.coupleIconAndLabel;
+  const categoryColor = semantics.color === "category" ? context.colors.poi[category] ?? context.colors.poi.label : context.colors.poi.label;
+  const defaults4 = {
+    icon: {
+      optional: !coupled,
+      padding: semantics.placement.iconPadding,
+      size: semantics.minZoom < 17 ? zoom.linear([
+        [semantics.minZoom, 0.85],
+        [17, 1]
+      ]) : 1
+    },
+    text: poiTextStyle(context, {
+      color: categoryColor,
+      field: labelField(language, context),
+      // A coupled POI is its pictogram and its name: it is placed only when both fit.
+      optional: !coupled,
+      padding: semantics.placement.textPadding,
+      size: semantics.minZoom < 17 ? zoom.linear([
+        [semantics.minZoom, 10],
+        [17, 12]
+      ]) : 12
+    })
+  };
+  let style = mergeTileflowDesign(defaults4, request?.styles?.[category] ?? {});
+  const markerStyle = style.marker ? resolveMarkerStyle(style) : void 0;
+  const hidden = style.visible === false;
+  const showText = !hidden && semantics.labels && style.text.visible !== false;
+  const showIcon = !hidden && semantics.icons && style.icon.visible !== false;
+  style = {
+    ...withoutVisibility(style),
+    icon: withoutVisibility(style.icon),
+    text: withoutVisibility(style.text)
+  };
+  if (showIcon && style.icon.image === void 0) {
+    style = {
+      ...style,
       icon: {
-        optional: !semantics.placement.coupleIconAndLabel,
-        padding: semantics.placement.iconPadding,
-        size: semantics.minZoom < 17 ? zoom.linear([
-          [semantics.minZoom, 0.85],
-          [17, 1]
-        ]) : 1
-      },
-      text: poiTextStyle(context, {
-        color: categoryColor,
-        field: labelField(language, context),
-        padding: semantics.placement.textPadding,
-        size: semantics.minZoom < 17 ? zoom.linear([
-          [semantics.minZoom, 10],
-          [17, 12]
-        ]) : 12
-      })
+        ...style.icon,
+        image: resolvePoiImage(category, context, schema.fields.poiIcon)
+      }
     };
-    let style = mergeTileflowDesign(defaults4, categoryStyle);
-    const markerStyle = style.marker ? resolveMarkerStyle(style) : void 0;
-    const showText = semantics.labels && style.text.visible !== false;
-    const showIcon = semantics.icons && style.icon.visible !== false;
-    if (showIcon && style.icon.image === void 0) {
-      style = {
-        ...style,
-        icon: {
-          ...style.icon,
-          image: resolvePoiImage(category, context, schema.fields.poiIcon)
-        }
-      };
-    }
-    style = withPoiTextClearance(style, showText && showIcon);
-    const symbolStyle2 = withoutMarker2(style);
-    if (markerStyle && markerStyle.visible !== false) {
-      const base = createPoiLayer({
-        category,
-        categoryField: schema.fields.poiCategory,
-        density: categoryDensity,
-        filterRankField: schema.fields.poiFilterRank,
-        id: `tileflow-poi-${category}-marker`,
-        minZoom: semantics.minZoom,
-        sizeRankField: schema.fields.poiSizeRank,
-        source,
-        sourceLayer: schema.layers.poi
-      });
-      const markerLayer = applyCircleStyle(
+  }
+  style = withPoiTextClearance(style, showText && showIcon);
+  const symbolStyle2 = withoutMarker2(style);
+  const base = () => ({
+    id: `tileflow-poi-${category}`,
+    type: "symbol",
+    source,
+    "source-layer": schema.layers.poi,
+    minzoom: semantics.minZoom,
+    layout: { "symbol-sort-key": poiSortKey(schema.fields.poiFilterRank, schema.fields.poiSizeRank) }
+  });
+  const parts = [];
+  selection2.register(category, { icon: showIcon, text: showText });
+  if (!hidden && markerStyle && markerStyle.visible !== false) {
+    const markerBase = base();
+    parts.push({
+      category,
+      representation: "marker",
+      layer: applyCircleStyle(
         {
-          ...base,
+          ...markerBase,
           type: "circle",
           layout: {
             "circle-sort-key": poiSortKey(schema.fields.poiFilterRank, schema.fields.poiSizeRank)
           }
         },
         markerStyle
-      );
-      result.push(poiContribution(`${category}.marker`, index * 4, markerLayer));
-    }
-    if (semantics.placement.coupleIconAndLabel && showText && showIcon) {
-      let layer = createPoiLayer({
-        category,
-        categoryField: schema.fields.poiCategory,
-        density: categoryDensity,
-        filterRankField: schema.fields.poiFilterRank,
-        id: `tileflow-poi-${category}`,
-        minZoom: semantics.minZoom,
-        sizeRankField: schema.fields.poiSizeRank,
-        source,
-        sourceLayer: schema.layers.poi
-      });
-      layer = applySymbolStyle(layer, symbolStyle2);
-      result.push(poiContribution(category, index * 4 + 1, layer));
-      continue;
-    }
-    if (showIcon) {
-      const layer = applySymbolStyle(
-        createPoiLayer({
-          category,
-          categoryField: schema.fields.poiCategory,
-          density: categoryDensity,
-          filterRankField: schema.fields.poiFilterRank,
-          id: `tileflow-poi-${category}-icon`,
-          minZoom: semantics.minZoom,
-          sizeRankField: schema.fields.poiSizeRank,
-          source,
-          sourceLayer: schema.layers.poi
-        }),
-        { ...symbolStyle2, text: void 0 }
-      );
-      result.push(poiContribution(`${category}.icon`, index * 4 + 1, layer));
-    }
-    if (showText) {
-      const layer = applySymbolStyle(
-        createPoiLayer({
-          category,
-          categoryField: schema.fields.poiCategory,
-          density: categoryDensity,
-          filterRankField: schema.fields.poiFilterRank,
-          id: `tileflow-poi-${category}-label`,
-          minZoom: semantics.minZoom,
-          sizeRankField: schema.fields.poiSizeRank,
-          source,
-          sourceLayer: schema.layers.poi
-        }),
-        { ...symbolStyle2, icon: void 0 }
-      );
-      result.push(poiContribution(`${category}.label`, index * 4 + 2, layer));
-    }
+      )
+    });
   }
-  return result;
+  const combined = coupled && (semantics.placement.order === "importance" ? semantics.icons && semantics.labels && (showIcon || showText) : showIcon && showText);
+  if (combined) {
+    const combinedStyle = {
+      ...symbolStyle2,
+      icon: showIcon ? symbolStyle2.icon : { image: "" },
+      text: showText ? { ...symbolStyle2.text, field: selection2.textField(symbolStyle2.text.field) } : { field: "" }
+    };
+    parts.push({
+      category,
+      representation: "combined",
+      layer: applySymbolStyle(base(), combinedStyle)
+    });
+    return parts;
+  }
+  if (showIcon) {
+    parts.push({
+      category,
+      representation: "icon",
+      layer: applySymbolStyle(base(), { ...symbolStyle2, text: void 0 })
+    });
+  }
+  if (showText) {
+    parts.push({
+      category,
+      representation: "label",
+      layer: applySymbolStyle(base(), { ...symbolStyle2, icon: void 0 })
+    });
+  }
+  return parts;
+}
+function createPoiSelection(semantics, context, language) {
+  const { fields } = context.data.schema;
+  const shown = /* @__PURE__ */ new Map();
+  const iconOnlyTypes = [...new Set(semantics.placement.iconOnlyTypes)];
+  const iconOnly = () => iconOnlyTypes.length ? ["match", ["get", fields.poiType], iconOnlyTypes, true, false] : ["literal", false];
+  const inCategories = (categories) => categories.length === 1 ? ["==", ["get", fields.poiCategory], categories[0]] : ["match", ["get", fields.poiCategory], [...categories], true, false];
+  const named = () => [
+    "any",
+    ...labelNameFields(language, context).map((field2) => ["has", field2])
+  ];
+  return {
+    register(category, parts) {
+      shown.set(category, parts);
+    },
+    textField(field2) {
+      if (!iconOnlyTypes.length || field2 === void 0) return field2;
+      return expression([
+        "match",
+        ["get", fields.poiType],
+        iconOnlyTypes,
+        "",
+        fieldValue(field2)
+      ]);
+    },
+    filter(categories, representation) {
+      const filterRank = numericPoiField(fields.poiFilterRank, 6);
+      const sizeRank = numericPoiField(fields.poiSizeRank, 17);
+      const result = [
+        "all",
+        inCategories(categories),
+        ["has", fields.poiFilterRank],
+        [">=", filterRank, 0],
+        ["<=", filterRank, poiRankThreshold(semantics.density)],
+        ["has", fields.poiSizeRank],
+        [">=", sizeRank, 0],
+        ["<=", sizeRank, 16]
+      ];
+      if (!semantics.icons || !semantics.labels) return result;
+      const textless = categories.filter((category) => !shown.get(category)?.text);
+      const iconless = categories.filter((category) => !shown.get(category)?.icon);
+      if (representation === "label") {
+        if (iconless.length === categories.length || !iconOnlyTypes.length) return result;
+        const keep = ["!", iconOnly()];
+        return [...result, iconless.length ? ["any", inCategories(iconless), keep] : keep];
+      }
+      if (textless.length === categories.length) return result;
+      return [
+        ...result,
+        [
+          "any",
+          named(),
+          ...iconOnlyTypes.length ? [iconOnly()] : [],
+          ...textless.length ? [inCategories(textless)] : []
+        ]
+      ];
+    }
+  };
+}
+function fieldValue(field2) {
+  return typeof field2 === "object" && field2 !== null && "kind" in field2 && field2.kind === "expression" ? field2.value : field2;
 }
 function resolvePoiImage(category, context, iconField) {
   const role = `poi.${category}`;
@@ -4128,28 +4792,6 @@ function resolveMarkerStyle(style) {
     style.marker
   );
 }
-function createPoiLayer(options) {
-  const filterRank = numericPoiField(options.filterRankField, 6);
-  const sizeRank = numericPoiField(options.sizeRankField, 17);
-  return {
-    id: options.id,
-    type: "symbol",
-    source: options.source,
-    "source-layer": options.sourceLayer,
-    minzoom: options.minZoom,
-    filter: [
-      "all",
-      ["==", ["get", options.categoryField], options.category],
-      ["has", options.filterRankField],
-      [">=", filterRank, 0],
-      ["<=", filterRank, poiRankThreshold(options.density)],
-      ["has", options.sizeRankField],
-      [">=", sizeRank, 0],
-      ["<=", sizeRank, 16]
-    ],
-    layout: { "symbol-sort-key": poiSortKey(options.filterRankField, options.sizeRankField) }
-  };
-}
 function poiRankThreshold(density) {
   return ["+", ["step", ["zoom"], 0, 16, 1, 17, 2], density];
 }
@@ -4166,7 +4808,7 @@ function poiContribution(target, localOrder, layer) {
     localOrder: 1e3 + localOrder,
     owner: "poi",
     slot: "symbols",
-    target: `poi.${target}`
+    target: target ? `poi.${target}` : "poi"
   };
 }
 function poiTextStyle(context, overrides) {
@@ -4176,8 +4818,7 @@ function poiTextStyle(context, overrides) {
       color: context.colors.poi.label,
       ...typographyTextStyle(context.typography.poi),
       haloColor: context.colors.poi.halo,
-      haloWidth: 1,
-      optional: true
+      haloWidth: 1
     },
     overrides
   );
@@ -4200,6 +4841,10 @@ function withoutMarker2(style) {
   delete result.marker;
   return result;
 }
+function withoutVisibility(value) {
+  const { visible: _visible, ...rest } = value;
+  return rest;
+}
 
 // src/portable-identity-rules.ts
 var tileflowPortableIdMaximumLength = 64;
@@ -4211,6 +4856,56 @@ function isTileflowThemeName(value) {
   return isTileflowPortableId(value) && value !== "system";
 }
 
+// src/time-of-day.ts
+var tileflowTimesOfDay = ["day", "dawn", "dusk", "night"];
+function isTileflowTimeOfDay(value) {
+  return typeof value === "string" && tileflowTimesOfDay.includes(value);
+}
+function validateTileflowTimeOfDayVariants(variants, themes) {
+  const issues = [];
+  const owners = /* @__PURE__ */ new Map();
+  const families = Object.entries(variants);
+  for (const [family, moments] of families) {
+    if (!isTileflowThemeName(family) || !Object.hasOwn(themes, family)) {
+      issues.push({ path: [family], message: "Time-of-day family must name an existing theme" });
+    }
+    if (!Object.values(moments).includes(family)) {
+      issues.push({ path: [family], message: "A family must include its own theme in its presets" });
+    }
+    for (const [moment, name] of Object.entries(moments)) {
+      if (name === void 0) continue;
+      if (!isTileflowTimeOfDay(moment) || !isTileflowThemeName(name) || !Object.hasOwn(themes, name)) {
+        issues.push({
+          path: [family, moment],
+          message: "Expected a supported moment and an existing theme"
+        });
+      }
+      const owner = owners.get(name);
+      if (owner !== void 0 && owner !== family) {
+        issues.push({
+          path: [family, moment],
+          message: `Theme "${name}" already belongs to family "${owner}"`
+        });
+      }
+      owners.set(name, family);
+    }
+  }
+  return issues;
+}
+function resolveTileflowTimeOfDayTheme(variants, theme, timeOfDay) {
+  if (timeOfDay === void 0 || variants === void 0) return theme;
+  if (!isTileflowTimeOfDay(timeOfDay)) throw new TypeError("Expected day, dawn, dusk, or night");
+  const family = Object.hasOwn(variants, theme) ? variants[theme] : Object.values(variants).find((moments) => Object.values(moments).includes(theme));
+  if (!family) return theme;
+  const result = family[timeOfDay];
+  if (result === void 0) {
+    throw new Error(
+      `Theme "${theme}" does not offer timeOfDay="${timeOfDay}". Available: ${Object.keys(family).join(", ")}.`
+    );
+  }
+  return result;
+}
+
 // src/sun.ts
 var tileflowSunMetadataKey = "tileflow:sun";
 var tileflowDefaultSunPreset = Object.freeze({
@@ -4433,7 +5128,7 @@ function resolveThemeValues(value, theme, path = "value") {
   if (errors.length > 0) throw new TileflowThemeAuditError(errors);
   return resolved;
 }
-function resolveThemeSelection(map, requested) {
+function resolveThemeSelection(map, requested, timeOfDay) {
   const name = requested ?? map.defaultTheme;
   if (name === "system") {
     throw new Error(
@@ -4450,7 +5145,8 @@ function resolveThemeSelection(map, requested) {
     const available = Object.keys(map.themes).sort().join(", ") || "<none>";
     throw new Error(`Unknown Tileflow theme "${name}"; available themes: ${available}.`);
   }
-  return { name, theme };
+  const resolvedName = resolveTileflowTimeOfDayTheme(map.timeOfDay, name, timeOfDay);
+  return { name: resolvedName, theme: map.themes[resolvedName] };
 }
 function auditTileflowThemeValues(value, path = "value", context = inferAuditContext(path)) {
   const diagnostics = [];
@@ -5757,7 +6453,8 @@ function resolveColors(overrides = {}, defaults4 = defaultColors, moduleOverride
           resolved.landcover.grass,
           resolved.landcover.meadow
         ],
-        conifer: [resolved.landcover.protected, resolved.landcover.scrub, resolved.landcover.wood]
+        conifer: [resolved.landcover.protected, resolved.landcover.scrub, resolved.landcover.wood],
+        palm: [resolved.landcover.urbanPark, resolved.landcover.grass, resolved.landcover.meadow]
       }
     }
   };
@@ -5924,6 +6621,11 @@ function resolveThemeColors(theme) {
           optionalColor("vegetation.tree.conifer.a", colors.vegetation.tree.conifer[0]),
           optionalColor("vegetation.tree.conifer.b", colors.vegetation.tree.conifer[1]),
           optionalColor("vegetation.tree.conifer.c", colors.vegetation.tree.conifer[2])
+        ],
+        palm: [
+          optionalColor("vegetation.tree.palm.a", colors.vegetation.tree.palm[0]),
+          optionalColor("vegetation.tree.palm.b", colors.vegetation.tree.palm[1]),
+          optionalColor("vegetation.tree.palm.c", colors.vegetation.tree.palm[2])
         ]
       }
     }
@@ -6513,9 +7215,10 @@ function compileRoundabouts(request, context, contributions) {
     contributions.push({
       kind: "layer",
       layer: applyCircleStyle({ ...base, id: "tileflow-road-circular-casing" }, config.casing),
-      localOrder: 10,
+      localOrder: 900,
       owner: "roads",
-      slot: "transport-symbols",
+      // Approach fills must cover the circular casing where the roads meet.
+      slot: "transport-surface-casing",
       target: "roads.roundabouts.casing"
     });
   }
@@ -6523,9 +7226,9 @@ function compileRoundabouts(request, context, contributions) {
     contributions.push({
       kind: "layer",
       layer: applyCircleStyle({ ...base, id: "tileflow-road-circular-fill" }, config.fill),
-      localOrder: 20,
+      localOrder: 900,
       owner: "roads",
-      slot: "transport-symbols",
+      slot: "transport-surface-fill",
       target: "roads.roundabouts.fill"
     });
   }
@@ -6590,7 +7293,7 @@ var circularRoadBorderTotalWidth = 1;
 function circularRoadInnerRadius(fields, casing) {
   const values = circularRoadValues(fields);
   const stops = [];
-  for (let level = 15; level <= 22; level += 1) {
+  for (let level = 15; level <= 24; level += 1) {
     const centerlineRadius = level === 15 ? values.radiusAtZoom15 : ["*", values.radiusAtZoom15, 2 ** (level - 15)];
     const physicalInnerRadius = [
       "*",
@@ -6607,13 +7310,13 @@ function circularRoadInnerRadius(fields, casing) {
       casing ? ["-", innerRadius, circularRoadBorderTotalWidth / 2] : innerRadius
     ]);
   }
-  return ["interpolate", ["linear"], ["zoom"], ...stops];
+  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 <= 22; level += 1) {
+  for (let level = 15; level <= 24; level += 1) {
     const centerlineRadius = level === 15 ? values.radiusAtZoom15 : ["*", values.radiusAtZoom15, 2 ** (level - 15)];
     const physicalWidth = [
       "*",
@@ -6628,7 +7331,7 @@ function circularRoadStrokeWidth(fields, casing) {
       casing ? ["+", fallbackWidth, circularRoadBorderTotalWidth] : fallbackWidth
     ]);
   }
-  return ["interpolate", ["linear"], ["zoom"], ...stops];
+  return ["interpolate", ["exponential", 2], ["zoom"], ...stops];
 }
 function circularRoadBaseWidth(classField) {
   return [
@@ -6792,6 +7495,10 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
       return value === void 0 ? [] : [{ condition, resolve: () => expressionOutput(value) }];
     });
     if (branches.length > 0) {
+      if (property === "dash" && isSolidRoadDash(result[property] ?? treatmentPaintDefaults.dash) && branches.every(({ resolve }) => isSolidRoadDash(resolve()))) {
+        delete result[property];
+        continue;
+      }
       result[property] = conditionalStyleValue(
         result[property],
         branches,
@@ -6808,9 +7515,21 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
       widthScales,
       treatmentPaintDefaults.width
     );
+    if (result.gapWidth !== void 0 && result.gapWidth !== 0) {
+      result.gapWidth = conditionalWidthScaleValue(
+        result.gapWidth,
+        widthScales,
+        treatmentPaintDefaults.gapWidth
+      );
+    }
   }
   return result;
 }
+function isSolidRoadDash(value) {
+  const output = expressionOutput(value);
+  const dash = Array.isArray(output) && output[0] === "literal" ? output[1] : output;
+  return Array.isArray(dash) && dash.length === 2 && dash[0] === 1 && dash[1] === 0;
+}
 function roadTreatmentPhaseConditions(treatments, structure, phase) {
   return treatments.flatMap(
     ({ condition, style }) => style[structure]?.[phase] === void 0 ? [] : [condition]
@@ -6895,10 +7614,10 @@ function isExpressionOutput(value) {
 }
 function rewriteZoomOutputs(value, rewrite) {
   if (!Array.isArray(value)) return rewrite(value);
-  if (value[0] === "interpolate" && isZoomInput3(value[2])) {
+  if (value[0] === "interpolate" && isZoomInput4(value[2])) {
     return value.map((entry, index) => index >= 4 && index % 2 === 0 ? rewrite(entry) : entry);
   }
-  if (value[0] === "step" && isZoomInput3(value[1])) {
+  if (value[0] === "step" && isZoomInput4(value[1])) {
     return value.map(
       (entry, index) => index === 2 || index >= 4 && index % 2 === 0 ? rewrite(entry) : entry
     );
@@ -6908,7 +7627,7 @@ function rewriteZoomOutputs(value, rewrite) {
 function expressionOutput(value) {
   return Array.isArray(value) && typeof value[0] !== "string" ? ["literal", value] : value;
 }
-function isZoomInput3(value) {
+function isZoomInput4(value) {
   return Array.isArray(value) && value.length === 1 && value[0] === "zoom";
 }
 function restrictedAccessFilter(field2) {
@@ -7243,105 +7962,35 @@ function railHatchingStyle(color2, opacity) {
   };
 }
 function serviceRailStyle(color2, opacity) {
-  return {
-    color: color2,
-    minZoom: 12,
-    opacity,
-    width: zoom.linear([
-      [12, 0.35],
-      [16, 1.4]
-    ])
-  };
-}
-function structureFilter2(field2, structure) {
-  return structure === "surface" ? ["match", ["get", field2], ["tunnel", "bridge"], false, true] : ["==", ["get", field2], structure];
-}
-function modalFilter(classField, subclassField, modes) {
-  return [
-    "any",
-    ["match", ["get", classField], modes, true, false],
-    ["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/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,
-        crownScale: 1,
-        heightScale: 1
-      }
-    },
-    request
-  );
-  if (config.enabled === false || !context.data.schema.layers.tree) return [];
-  const resolvedMode = config.mode ?? "3d";
-  const threeDimensional = config.threeDimensional;
+  return {
+    color: color2,
+    minZoom: 12,
+    opacity,
+    width: zoom.linear([
+      [12, 0.35],
+      [16, 1.4]
+    ])
+  };
+}
+function structureFilter2(field2, structure) {
+  return structure === "surface" ? ["match", ["get", field2], ["tunnel", "bridge"], false, true] : ["==", ["get", field2], structure];
+}
+function modalFilter(classField, subclassField, modes) {
   return [
-    {
-      kind: "layer",
-      layer: applyCircleStyle(
-        {
-          id: "tileflow-vegetation-trees",
-          type: "circle",
-          source: context.data.sourceId,
-          "source-layer": context.data.schema.layers.tree,
-          metadata: {
-            "tileflow:vegetation-mode": resolvedMode,
-            ...resolvedMode === "3d" ? { "tileflow:vegetation-fallback": "flat-circle" } : {},
-            "tileflow:tree-bark-color": threeDimensional.barkColor,
-            "tileflow:tree-broadleaf-colors": threeDimensional.broadleafColors,
-            "tileflow:tree-conifer-colors": threeDimensional.coniferColors,
-            "tileflow:tree-crown-field": context.data.schema.fields.diameterCrown,
-            "tileflow:tree-crown-scale": threeDimensional.crownScale,
-            "tileflow:tree-genus-field": context.data.schema.fields.genus,
-            "tileflow:tree-height-field": context.data.schema.fields.height,
-            "tileflow:tree-height-scale": threeDimensional.heightScale,
-            "tileflow:tree-leaf-type-field": context.data.schema.fields.leafType,
-            "tileflow:tree-species-field": context.data.schema.fields.species
-          }
-        },
-        config.flat ?? {}
-      ),
-      localOrder: 1,
-      owner: "vegetation",
-      slot: "vegetation",
-      target: "vegetation.trees"
-    }
+    "any",
+    ["match", ["get", classField], modes, true, false],
+    ["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/water/index.ts
 function water(options = {}) {
   return { type: "water", ...cloneJson17(options) };
@@ -7357,7 +8006,7 @@ var waterwayClasses = {
   river: ["river"],
   stream: ["stream"]
 };
-function compileWater(request, context) {
+function compileWater(request, context, language = "auto") {
   const config = mergeTileflowDesign(
     {
       type: "water",
@@ -7509,8 +8158,11 @@ function compileWater(request, context) {
     appendBathymetryRelief(contributions, bathymetryProduct.relief, context);
   }
   const productContours = bathymetryProduct?.contours;
+  const nativeContours = sidecarBathymetry && bathymetryProduct?.vectorLayers?.contours === true;
+  const contourLayer = nativeContours ? tileflowBathymetryV1Schema.layers.contours : bathymetryLayer;
+  const contourDepthField = nativeContours ? tileflowBathymetryV1Schema.fields.depth : bathymetryDepthField;
   const contourRequest = productContours === false ? void 0 : productContours === void 0 ? request?.bathymetryContours : mergeTileflowDesign(productContours, request?.bathymetryContours);
-  if (contourRequest !== void 0 && bathymetryLayer && bathymetryDepthField) {
+  if (contourRequest !== void 0 && contourLayer && contourDepthField) {
     const bathymetryContours = mergeTileflowDesign(
       {
         color: context.colors.hydro.label,
@@ -7533,12 +8185,12 @@ function compileWater(request, context) {
             id: "tileflow-bathymetry-contours",
             type: "line",
             source: bathymetrySource,
-            "source-layer": bathymetryLayer,
+            "source-layer": contourLayer,
             filter: [
               "all",
-              ["==", ["geometry-type"], "Polygon"],
-              ["has", bathymetryDepthField],
-              ["<", ["to-number", ["get", bathymetryDepthField], 0], 0]
+              ["==", ["geometry-type"], nativeContours ? "LineString" : "Polygon"],
+              ["has", contourDepthField],
+              ["<", ["to-number", ["get", contourDepthField], 0], 0]
             ]
           },
           bathymetryContours
@@ -7552,19 +8204,19 @@ function compileWater(request, context) {
   }
   const productLabels = bathymetryProduct?.labels;
   const labelRequest = productLabels === false ? void 0 : productLabels === void 0 ? request?.bathymetryLabels : mergeTileflowDesign(productLabels, request?.bathymetryLabels);
-  if (labelRequest !== void 0 && bathymetryLayer && bathymetryDepthField) {
+  if (labelRequest !== void 0 && contourLayer && contourDepthField) {
     const bathymetryLabels = mergeTileflowDesign(
       {
         maxZoom: 10,
         minZoom: 3,
-        placement: "point",
+        placement: nativeContours ? "line" : "point",
         priority: 5,
         text: {
           allowOverlap: false,
           color: context.colors.hydro.label,
           field: expression([
             "to-string",
-            ["abs", ["to-number", ["get", bathymetryDepthField], 0]]
+            ["abs", ["to-number", ["get", contourDepthField], 0]]
           ]),
           ...typographyTextStyle(context.typography.water),
           haloColor: context.colors.hydro.water,
@@ -7585,8 +8237,13 @@ function compileWater(request, context) {
             id: "tileflow-bathymetry-labels",
             type: "symbol",
             source: bathymetrySource,
-            "source-layer": bathymetryLayer,
-            filter: ["all", ["==", ["geometry-type"], "Polygon"], ["has", bathymetryDepthField]]
+            "source-layer": contourLayer,
+            filter: [
+              "all",
+              ["==", ["geometry-type"], nativeContours ? "LineString" : "Polygon"],
+              ["has", contourDepthField],
+              ...nativeContours ? [["<", ["to-number", ["get", contourDepthField], 0], 0]] : []
+            ]
           },
           bathymetryLabels
         ),
@@ -7597,6 +8254,37 @@ function compileWater(request, context) {
       });
     }
   }
+  if (sidecarBathymetry) {
+    const { layers: marineLayers } = tileflowBathymetryV1Schema;
+    const landforms2 = bathymetryProduct?.vectorLayers?.landforms;
+    const waterNames = bathymetryProduct?.vectorLayers?.waterNames;
+    if (landforms2) {
+      appendBathymetryNames(contributions, {
+        availability: landforms2,
+        context,
+        language,
+        localOrder: -300,
+        source: sidecarBathymetry.sourceId,
+        sourceLayer: marineLayers.landforms,
+        style: config.bathymetryLandforms,
+        target: "water.bathymetryLandforms",
+        id: "tileflow-bathymetry-landforms"
+      });
+    }
+    if (waterNames) {
+      appendBathymetryNames(contributions, {
+        availability: waterNames,
+        context,
+        language,
+        localOrder: -150,
+        source: sidecarBathymetry.sourceId,
+        sourceLayer: marineLayers.waterNames,
+        style: config.bathymetryWaterNames,
+        target: "water.bathymetryWaterNames",
+        id: "tileflow-bathymetry-water-names"
+      });
+    }
+  }
   let localOrder = 10;
   for (const [name, classes] of Object.entries(waterwayClasses)) {
     const style = config.waterways?.[name];
@@ -7660,6 +8348,99 @@ function compileWater(request, context) {
   }
   return contributions;
 }
+function appendBathymetryNames(contributions, options) {
+  const { context, language } = options;
+  const { fields } = tileflowBathymetryV1Schema;
+  const localName = ["to-string", ["coalesce", ["get", fields.name], ""]];
+  const name = language === "auto" || language === "local" ? localName : [
+    "case",
+    ["!=", ["to-string", ["coalesce", ["get", `name:${language}`], ""]], ""],
+    ["to-string", ["get", `name:${language}`]],
+    localName
+  ];
+  const style = mergeTileflowDesign(
+    {
+      minZoom: 0,
+      placement: "point",
+      priority: expression(["to-number", ["get", fields.sortKey], 0]),
+      priorityOrder: "lower-first",
+      text: {
+        ...typographyTextStyle(context.typography.water),
+        allowOverlap: false,
+        ignorePlacement: false,
+        color: context.colors.hydro.label,
+        field: expression(name),
+        haloColor: context.colors.hydro.water,
+        haloWidth: 1,
+        optional: false,
+        padding: 12,
+        size: 11
+      }
+    },
+    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(
+    (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(
+      {
+        ...layer,
+        id: `${options.id}-cohort-${index}`,
+        minzoom,
+        maxzoom,
+        filter: [
+          ...baseFilter,
+          ["==", sourceMinimum, range2.minZoom],
+          ["==", sourceMaximum, range2.maxZoom]
+        ]
+      },
+      `${options.target}.cohort${index}`,
+      index
+    );
+  }
+}
 function appendBathymetryRelief(contributions, relief, context) {
   const { sourceId, style } = relief;
   const opacity = resolvedNumber(style.opacity, 0.22, "bathymetry relief opacity");
@@ -7868,12 +8649,6 @@ var tileflowSemanticDomainRegistry = Object.freeze([
     dependencies: {},
     name: "land"
   }),
-  defineDomain({
-    compile: ({ context, module }) => compileWater(module, context),
-    defaultModule: water(),
-    dependencies: {},
-    name: "water"
-  }),
   defineDomain({
     compile: ({ context, module }) => compileNautical(module, context),
     defaultModule: nautical(),
@@ -7962,6 +8737,12 @@ var tileflowSemanticDomainRegistry = Object.freeze([
     provides: ["language"],
     resolveServices: ({ module }) => ({ language: resolveLabels(module).language })
   }),
+  defineDomain({
+    compile: ({ context, dependencies, module }) => compileWater(module, context, dependencies.service("language")),
+    defaultModule: water(),
+    dependencies: { services: ["language"] },
+    name: "water"
+  }),
   defineDomain({
     compile: ({ context, dependencies, module }) => compileLandforms(module, dependencies.service("language"), context),
     defaultModule: landforms(),
@@ -8080,7 +8861,7 @@ function createTileflowCompilerProvenance(owner, slot, target) {
   return [{ operations: [], owner, slot, target }];
 }
 function readTileflowCompilerProvenance(layer) {
-  const metadata = asRecord2(layer.metadata);
+  const metadata = asRecord3(layer.metadata);
   const raw = metadata[tileflowCompilerProvenanceMetadataKey];
   if (Array.isArray(raw)) {
     const parsed = raw.flatMap((value) => {
@@ -8108,7 +8889,7 @@ function createTileflowStyleInspection(map, theme, layers) {
   };
 }
 function parseContribution(value) {
-  const input = asRecord2(value);
+  const input = asRecord3(value);
   const owner = requireLayerDomain(input.owner);
   const slot = requireLayerSlot(input.slot);
   const target = input.target;
@@ -8122,7 +8903,7 @@ function parseContribution(value) {
   return { operations, owner, slot, target };
 }
 function parseRenderOperation(value) {
-  const input = asRecord2(value);
+  const input = asRecord3(value);
   const owner = requireLayerDomain(input.owner);
   const target = input.target;
   if (input.kind !== "pass" && input.kind !== "refinement" || !owner || typeof target !== "string" || !tileflowSemanticTargetPattern.test(target)) {
@@ -8136,7 +8917,7 @@ function requireLayerDomain(value) {
 function requireLayerSlot(value) {
   return typeof value === "string" && tileflowLayerSlots.includes(value) ? value : void 0;
 }
-function asRecord2(value) {
+function asRecord3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
@@ -8183,6 +8964,7 @@ var classicManifestSchemaOperations = {
     return z3.enum(values);
   },
   literal: (value) => z3.literal(value),
+  union: (left, right) => z3.union([classic(left), classic(right)]),
   tuplePair(left, right) {
     return z3.tuple([classic(left), classic(right)]);
   },
@@ -8505,7 +9287,7 @@ function not(value) {
 function has(reference) {
   return make(["has", reference]);
 }
-function match(input, branches, fallback) {
+function match2(input, branches, fallback) {
   validateBranchCount(branches.length, "expr.match");
   validateMatchLabels(branches);
   return make([
@@ -8603,7 +9385,7 @@ function limitError(message) {
   return new Error(site ? `${message} Called at ${site}.` : message);
 }
 function authoringCallSite(stack) {
-  const locations = (stack ?? "").split("\n").slice(1).map((line) => /\(?([^()\s]+?):(\d+):(\d+)\)?$/.exec(line.trim())).filter((match2) => match2 !== null).map(([, file, line, column]) => ({ file: file.replace(/^file:\/\//, ""), line, column }));
+  const locations = (stack ?? "").split("\n").slice(1).map((line) => /\(?([^()\s]+?):(\d+):(\d+)\)?$/.exec(line.trim())).filter((match3) => match3 !== null).map(([, file, line, column]) => ({ file: file.replace(/^file:\/\//, ""), line, column }));
   const own = locations[0]?.file;
   const site = locations.find(({ file }) => file !== own && !file.startsWith("node:"));
   return site ? `${site.file}:${site.line}:${site.column}` : void 0;
@@ -8988,7 +9770,7 @@ var expr = Object.freeze({
   literal,
   lt: (left, right) => compare("<", left, right),
   lte: (left, right) => compare("<=", left, right),
-  match,
+  match: match2,
   max: maximum,
   min: minimum,
   modulo,
@@ -9012,6 +9794,12 @@ var tileflowSemanticFieldNames = Object.freeze(
 var tileflowSemanticLayerNames = Object.freeze(
   Object.keys(completeSemanticDataContract.layers).sort(compareCodeUnits5)
 );
+var auxiliaryFieldBindings = Object.freeze({
+  bathymetryContourDepth: tileflowBathymetryV1Schema.fields.depth
+});
+var tileflowSemanticExpressionFieldNames = Object.freeze(
+  [...tileflowSemanticFieldNames, ...Object.keys(auxiliaryFieldBindings)].sort(compareCodeUnits5)
+);
 function field(name) {
   return Object.freeze({ kind: "tileflow-data-field", name });
 }
@@ -9043,6 +9831,9 @@ function bindSemanticReferences(value, data) {
 }
 function bindSemanticValue(value, schema, sourceId) {
   if (isDataFieldReference2(value)) {
+    if (Object.hasOwn(auxiliaryFieldBindings, value.name)) {
+      return auxiliaryFieldBindings[value.name];
+    }
     const binding = schema.fields[value.name];
     if (!binding) throw new Error(`Tileflow data schema does not provide field ${value.name}.`);
     return binding;
@@ -9247,72 +10038,77 @@ function emitLayer(family, resolvePhysicalId) {
 function physicalLayerIdForSemanticKey(semanticKey) {
   const exact = exactPhysicalLayerIds[semanticKey];
   if (exact) return exact;
-  let match2 = /^([A-Za-z0-9_-]+)\.render\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(
+  let match3 = /^([A-Za-z0-9_-]+)\.render\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(
     semanticKey
   );
-  if (match2) return `tileflow-${match2[1]}-render-${match2[2].replaceAll(".", "-")}`;
-  match2 = /^roads\.classes\.([^.]+)\.(tunnel|surface|bridge)\.(shadow|casing|fill|hatch)$/u.exec(
+  if (match3) return `tileflow-${match3[1]}-render-${match3[2].replaceAll(".", "-")}`;
+  match3 = /^roads\.classes\.([^.]+)\.(tunnel|surface|bridge)\.(shadow|casing|fill|hatch)$/u.exec(
     semanticKey
   );
-  if (match2) return `tileflow-road-${match2[2]}-${match2[1]}-${match2[3]}`;
-  match2 = /^roads\.cohorts\.(tunnel|surface|bridge)\.([^.]+)\.(shadow|casing|fill)$/u.exec(
+  if (match3) return `tileflow-road-${match3[2]}-${match3[1]}-${match3[3]}`;
+  match3 = /^roads\.cohorts\.(tunnel|surface|bridge)\.([^.]+)\.(shadow|casing|fill)$/u.exec(
     semanticKey
   );
-  if (match2) return `tileflow-road-${match2[1]}-highzoom-${match2[2]}-${match2[3]}`;
-  match2 = /^roads\.cohorts\.(tunnel|surface|bridge)\.hatch$/u.exec(semanticKey);
-  if (match2) return `tileflow-road-${match2[1]}-hatch`;
-  match2 = /^roads\.areas\.(road|pedestrian|pier)\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) {
-    const base = match2[1] === "road" ? "tileflow-road-area" : `tileflow-road-${match2[1]}-area`;
-    return match2[2] === "fill" ? base : `${base}-outline`;
-  }
-  match2 = /^land\.(landcover|landuse)\.([^.]+)\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) {
-    const base = `tileflow-${match2[1]}-${match2[2]}`;
-    return match2[3] === "fill" ? base : `${base}-outline`;
-  }
-  match2 = /^land\.compatibility\.legacyPark\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) {
-    return match2[1] === "fill" ? "tileflow-landcover-legacy-park" : "tileflow-landcover-legacy-park-outline";
-  }
-  match2 = /^land\.cohorts\.(landcover|landuse)(?:\.cohort(\d+))?$/u.exec(semanticKey);
-  if (match2) return `tileflow-${match2[1]}${match2[2] === void 0 ? "" : `-${match2[2]}`}`;
-  match2 = /^water\.(intermittent\.)?bodies\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) {
-    const base = `tileflow-water${match2[1] ? "-intermittent" : ""}`;
-    return match2[2] === "fill" ? base : `${base}-outline`;
-  }
-  match2 = /^water\.(intermittent\.)?waterways\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-waterway-${match2[2]}${match2[1] ? "-intermittent" : ""}`;
-  match2 = /^buildings\.(businessCorridor|flat)\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) {
-    const base = match2[1] === "businessCorridor" ? "tileflow-business-corridor" : "tileflow-buildings-fill";
-    return match2[2] === "fill" ? base : `${base}-outline`;
-  }
-  match2 = /^aeroways\.area\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) return match2[1] === "fill" ? "tileflow-aeroway-area" : "tileflow-aeroway-area-outline";
-  match2 = /^aeroways\.(taxiway|runway)\.(shadow|casing|fill)$/u.exec(semanticKey);
-  if (match2) return `tileflow-aeroway-${match2[1]}-${match2[2]}`;
-  match2 = /^transit\.([A-Za-z0-9_-]+)(?:\.(tunnel|surface|bridge))?$/u.exec(semanticKey);
-  if (match2) return `tileflow-transit-${match2[1]}${match2[2] ? `-${match2[2]}` : ""}`;
-  match2 = /^boundaries\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(semanticKey);
-  if (match2) return `tileflow-boundary-${match2[1].replaceAll(".", "-")}`;
-  match2 = /^labels\.places\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-place-${match2[1]}`;
-  match2 = /^labels\.roads\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-road-${match2[1]}`;
-  match2 = /^labels\.shields\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-road-shield-${match2[1]}`;
-  match2 = /^labels\.water\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-water-${match2[1]}`;
-  match2 = /^labels\.cohorts\.roads\.(major|local)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-road-${match2[1]}`;
-  match2 = /^labels\.cohorts\.roads\.cohort(\d+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-road-cohort-${match2[1]}`;
-  match2 = /^landforms\.classes\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-landform-${match2[1]}`;
-  match2 = /^poi\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(semanticKey);
-  if (match2) return `tileflow-poi-${match2[1].replaceAll(".", "-")}`;
+  if (match3) return `tileflow-road-${match3[1]}-highzoom-${match3[2]}-${match3[3]}`;
+  match3 = /^roads\.cohorts\.(tunnel|surface|bridge)\.hatch$/u.exec(semanticKey);
+  if (match3) return `tileflow-road-${match3[1]}-hatch`;
+  match3 = /^roads\.areas\.(road|pedestrian|pier)\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) {
+    const base = match3[1] === "road" ? "tileflow-road-area" : `tileflow-road-${match3[1]}-area`;
+    return match3[2] === "fill" ? base : `${base}-outline`;
+  }
+  match3 = /^land\.(landcover|landuse)\.([^.]+)\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) {
+    const base = `tileflow-${match3[1]}-${match3[2]}`;
+    return match3[3] === "fill" ? base : `${base}-outline`;
+  }
+  match3 = /^land\.compatibility\.legacyPark\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) {
+    return match3[1] === "fill" ? "tileflow-landcover-legacy-park" : "tileflow-landcover-legacy-park-outline";
+  }
+  match3 = /^land\.cohorts\.(landcover|landuse)(?:\.cohort(\d+))?$/u.exec(semanticKey);
+  if (match3) return `tileflow-${match3[1]}${match3[2] === void 0 ? "" : `-${match3[2]}`}`;
+  match3 = /^water\.(intermittent\.)?bodies\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) {
+    const base = `tileflow-water${match3[1] ? "-intermittent" : ""}`;
+    return match3[2] === "fill" ? base : `${base}-outline`;
+  }
+  match3 = /^water\.(intermittent\.)?waterways\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-waterway-${match3[2]}${match3[1] ? "-intermittent" : ""}`;
+  match3 = /^buildings\.(businessCorridor|flat)\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) {
+    const base = match3[1] === "businessCorridor" ? "tileflow-business-corridor" : "tileflow-buildings-fill";
+    return match3[2] === "fill" ? base : `${base}-outline`;
+  }
+  match3 = /^aeroways\.area\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) return match3[1] === "fill" ? "tileflow-aeroway-area" : "tileflow-aeroway-area-outline";
+  match3 = /^aeroways\.(taxiway|runway)\.(shadow|casing|fill)$/u.exec(semanticKey);
+  if (match3) return `tileflow-aeroway-${match3[1]}-${match3[2]}`;
+  match3 = /^transit\.([A-Za-z0-9_-]+)(?:\.(tunnel|surface|bridge))?$/u.exec(semanticKey);
+  if (match3) return `tileflow-transit-${match3[1]}${match3[2] ? `-${match3[2]}` : ""}`;
+  match3 = /^boundaries\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(semanticKey);
+  if (match3) return `tileflow-boundary-${match3[1].replaceAll(".", "-")}`;
+  match3 = /^labels\.places\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-place-${match3[1]}`;
+  match3 = /^labels\.roads\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-road-${match3[1]}`;
+  match3 = /^labels\.shields\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-road-shield-${match3[1]}`;
+  match3 = /^labels\.water\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-water-${match3[1]}`;
+  match3 = /^labels\.cohorts\.roads\.(major|local)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-road-${match3[1]}`;
+  match3 = /^labels\.cohorts\.roads\.cohort(\d+)$/u.exec(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);
+  if (match3) {
+    const base = match3[1] === "bathymetryLandforms" ? "landforms" : "water-names";
+    return `tileflow-bathymetry-${base}-cohort-${match3[2]}`;
+  }
+  match3 = /^poi\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(semanticKey);
+  if (match3) return `tileflow-poi-${match3[1].replaceAll(".", "-")}`;
   const nautical2 = nauticalPhysicalLayerId(semanticKey);
   if (nautical2) return nautical2;
   throw new TileflowDomainIRError(
@@ -9329,6 +10125,7 @@ var exactPhysicalLayerIds = Object.freeze({
   "labels.junctions": "tileflow-label-road-junction",
   "land.background": "tileflow-background",
   "land.globalLandcover": "tileflow-global-landcover",
+  poi: "tileflow-poi",
   "landforms.classes": "tileflow-landforms",
   "roads.crossings": "tileflow-road-crossing",
   "roads.oneWayMarkers": "tileflow-road-oneway",
@@ -9345,6 +10142,8 @@ var exactPhysicalLayerIds = Object.freeze({
   "water.bathymetry": "tileflow-bathymetry",
   "water.bathymetryContours": "tileflow-bathymetry-contours",
   "water.bathymetryLabels": "tileflow-bathymetry-labels",
+  "water.bathymetryLandforms": "tileflow-bathymetry-landforms",
+  "water.bathymetryWaterNames": "tileflow-bathymetry-water-names",
   "water.bathymetryRelief.color": "tileflow-bathymetry-color-relief",
   "water.bathymetryRelief.hillshade": "tileflow-bathymetry-relief"
 });
@@ -9369,15 +10168,15 @@ var nauticalPhysicalBases = Object.freeze({
 function nauticalPhysicalLayerId(semanticKey) {
   const direct = nauticalPhysicalBases[semanticKey];
   if (direct) return direct;
-  const match2 = /^(nautical\.[A-Za-z0-9_.-]+)\.(fill|outline|marker|symbol)$/u.exec(semanticKey);
-  if (!match2) return void 0;
-  const base = nauticalPhysicalBases[match2[1]];
+  const match3 = /^(nautical\.[A-Za-z0-9_.-]+)\.(fill|outline|marker|symbol)$/u.exec(semanticKey);
+  if (!match3) return void 0;
+  const base = nauticalPhysicalBases[match3[1]];
   if (!base) return void 0;
-  if (match2[2] === "fill" || match2[2] === "symbol") return base;
-  return `${base}-${match2[2]}`;
+  if (match3[2] === "fill" || match3[2] === "symbol") return base;
+  return `${base}-${match3[2]}`;
 }
 function publicMetadata(value) {
-  const metadata = { ...asRecord3(value) };
+  const metadata = { ...asRecord4(value) };
   delete metadata[tileflowCompilerProvenanceMetadataKey];
   for (const key of Object.values(tileflowCompilerMetadataKeys)) delete metadata[key];
   return Object.keys(metadata).length > 0 ? cloneJson20(metadata) : void 0;
@@ -9424,7 +10223,7 @@ function isSemanticSourceReference(value) {
 function cloneJson20(value) {
   return JSON.parse(JSON.stringify(value));
 }
-function asRecord3(value) {
+function asRecord4(value) {
   return isRecord5(value) ? value : {};
 }
 function isRecord5(value) {
@@ -9898,8 +10697,8 @@ function applyRendererStyle(layer, renderer, style) {
   if (!visibilityGroup) return result;
   return {
     ...result,
-    layout: { ...asRecord4(result.layout), visibility: "none" },
-    metadata: { ...asRecord4(result.metadata), "tileflow:3d-toggle": visibilityGroup }
+    layout: { ...asRecord5(result.layout), visibility: "none" },
+    metadata: { ...asRecord5(result.metadata), "tileflow:3d-toggle": visibilityGroup }
   };
 }
 function lowerSelector(selector, data) {
@@ -10381,7 +11180,7 @@ function compareCodeUnits6(left, right) {
 function cloneJson21(value) {
   return JSON.parse(JSON.stringify(value));
 }
-function asRecord4(value) {
+function asRecord5(value) {
   return isRecord6(value) ? value : {};
 }
 function isRecord6(value) {
@@ -10579,6 +11378,19 @@ function isLoopbackHostname(hostname) {
   return normalized === "localhost" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1" || /^127(?:\.\d{1,3}){3}$/u.test(normalized);
 }
 
+// src/time-of-day-schema.ts
+function createTileflowTimeOfDaySchema(operations, themeName) {
+  return operations.record(
+    themeName,
+    operations.object({
+      day: operations.optional(themeName),
+      dawn: operations.optional(themeName),
+      dusk: operations.optional(themeName),
+      night: operations.optional(themeName)
+    })
+  );
+}
+
 // src/resolved-map-schema.ts
 var TileflowResolvedMapValidationError = class extends Error {
   code = "CONFIG_INVALID";
@@ -10726,7 +11538,7 @@ function validateExpressionFieldNames(value, context, path) {
   }
   if (!value || typeof value !== "object") return;
   const candidate = value;
-  if (candidate.kind === "tileflow-data-field" && (typeof candidate.name !== "string" || !Object.hasOwn(fieldBindingsSchema.shape, candidate.name))) {
+  if (candidate.kind === "tileflow-data-field" && (typeof candidate.name !== "string" || !tileflowSemanticExpressionFieldNames.some((name) => name === candidate.name))) {
     context.addIssue({
       code: "custom",
       message: "Expected a registered semantic field name.",
@@ -10880,12 +11692,12 @@ var hexColorSchema = z5.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a
   message: "Expected a hex color like #F6F7F3 or #F6F7F3FF"
 });
 var rgbColorSchema = z5.string().refine((value) => {
-  const match2 = value.match(
+  const match3 = value.match(
     /^rgba?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)(?:\s*,\s*(\d+(?:\.\d+)?))?\s*\)$/iu
   );
-  if (!match2) return false;
-  const channels = match2.slice(1, 4).map(Number);
-  const alpha2 = Number(match2[4] ?? 1);
+  if (!match3) return false;
+  const channels = match3.slice(1, 4).map(Number);
+  const alpha2 = Number(match3[4] ?? 1);
   return channels.every((channel) => channel >= 0 && channel <= 255) && alpha2 >= 0 && alpha2 <= 1;
 }, "Expected a Tileflow hex, rgb(), or rgba() color");
 var terrainColorLiteralSchema = z5.union([hexColorSchema, rgbColorSchema]);
@@ -11162,9 +11974,7 @@ var symbolStyleSchema = z5.object({
   text: textStyleSchema.optional()
 }).strict();
 var markerSymbolStyleSchema = symbolStyleSchema.extend({ marker: circleStyleSchema.optional() }).strict();
-var poiCategoryStyleSchema = markerSymbolStyleSchema.omit({ priority: true, priorityOrder: true }).extend({
-  density: z5.union([z5.literal(1), z5.literal(2), z5.literal(3), z5.literal(4), z5.literal(5)]).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");
 var renderStackOperationNameSchema = z5.string().regex(
@@ -11397,6 +12207,8 @@ var waterModuleSchema = z5.object({
   bathymetry: fillStyleSchema.optional(),
   bathymetryContours: lineStyleSchema.optional(),
   bathymetryLabels: symbolStyleSchema.optional(),
+  bathymetryLandforms: symbolStyleSchema.optional(),
+  bathymetryWaterNames: symbolStyleSchema.optional(),
   bodies: areaStyleSchema.optional(),
   enabled: z5.boolean().optional(),
   intermittent: z5.object({ bodies: areaStyleSchema.optional(), waterways: lineStyleSchema.optional() }).strict().optional(),
@@ -11408,6 +12220,17 @@ var waterModuleSchema = z5.object({
     stream: lineStyleSchema.optional()
   }).strict().optional()
 }).strict();
+function boundedThemeNumberSchema(min, max) {
+  return z5.union([
+    z5.number().finite().min(min).max(max),
+    themeNumberReferenceSchema,
+    z5.object({
+      kind: z5.literal("theme-fixed"),
+      reason: z5.string().trim().min(1),
+      value: z5.number().finite().min(min).max(max)
+    }).strict()
+  ]);
+}
 var buildingsModuleSchema = z5.object({
   type: z5.literal("buildings"),
   businessCorridor: areaStyleSchema.optional(),
@@ -11415,7 +12238,46 @@ var buildingsModuleSchema = z5.object({
   extrusion: extrusionStyleSchema.optional(),
   flat: areaStyleSchema.optional(),
   mode: z5.enum(["3d", "flat"]).optional(),
-  renderStack: renderStackSchema.optional()
+  renderStack: renderStackSchema.optional(),
+  threeDimensional: z5.object({
+    lighting: z5.enum(["style", "sun"]).optional(),
+    colorVariation: boundedThemeNumberSchema(0, 1).optional(),
+    edges: boundedThemeNumberSchema(0, 1).optional(),
+    edgeColor: themeColorValueSchema.optional(),
+    nightLight: boundedThemeNumberSchema(0, 2).optional(),
+    occlusion: z5.boolean().optional(),
+    shadows: z5.boolean().optional(),
+    windows: z5.boolean().optional(),
+    models: z5.array(
+      z5.object({
+        model: z5.string().max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u),
+        at: z5.tuple([z5.number().min(-180).max(180), z5.number().min(-85).max(85)]),
+        heading: z5.number().finite().optional(),
+        url: z5.url().max(2048).refine((value) => new URL(value).protocol === "https:", {
+          message: "A model served elsewhere has an HTTPS address."
+        }).optional()
+      }).strict()
+    ).max(256).optional(),
+    modelColors: z5.object({
+      surface: themeColorValueSchema.optional(),
+      secondary: themeColorValueSchema.optional(),
+      glass: themeColorValueSchema.optional(),
+      accent: themeColorValueSchema.optional(),
+      roof: themeColorValueSchema.optional()
+    }).strict().optional(),
+    landmarks: z5.union([
+      z5.boolean(),
+      z5.object({
+        url: z5.url().max(2048).refine(
+          (value) => {
+            const url = new URL(value);
+            return url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+          },
+          { message: "A landmarks tileset has an HTTPS address, or a local one." }
+        )
+      }).strict()
+    ]).optional()
+  }).strict().optional()
 }).strict();
 var addressesModuleSchema = z5.object({
   type: z5.literal("addresses"),
@@ -11528,6 +12390,12 @@ var roadsModuleSchema = z5.object({
     pattern: fillStyleSchema.optional(),
     surface: fillStyleSchema.optional()
   }).strict().optional(),
+  streetLights: z5.object({
+    color: themeColorValueSchema.optional(),
+    enabled: z5.boolean().optional(),
+    estimate: z5.enum(["lit", "streets", "none"]).optional(),
+    intensity: boundedThemeNumberSchema(0, 2).optional()
+  }).strict().optional(),
   structures: roadStructureMapSchema.optional(),
   weight: z5.enum(["thin", "regular", "bold"]).optional(),
   widthScale: z5.partialRecord(roadClassSchema, themeNumberValueSchema).optional()
@@ -11587,7 +12455,10 @@ var poiModuleSchema = z5.object({
   minZoom: zoomNumberSchema.optional(),
   placement: z5.object({
     coupleIconAndLabel: z5.boolean().optional(),
+    iconOnlyTypes: z5.array(z5.string().regex(/^[a-z0-9]+(?:_[a-z0-9]+)*$/u, "Expected a World POI type")).max(64).optional(),
     iconPadding: z5.number().finite().min(0).optional(),
+    order: z5.enum(["categories", "importance"]).optional(),
+    prominentRank: z5.number().int().min(0).max(5).optional(),
     textPadding: z5.number().finite().min(0).optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional(),
@@ -11616,6 +12487,16 @@ var nauticalModuleSchema = z5.object({
   wreckAreas: areaStyleSchema.optional(),
   wrecks: markerSymbolStyleSchema.optional()
 }).strict();
+var treeFormMixSchema = z5.object({
+  round: z5.number().finite().min(0).optional(),
+  open: z5.number().finite().min(0).optional(),
+  tall: z5.number().finite().min(0).optional(),
+  conifer: z5.number().finite().min(0).optional(),
+  columnar: z5.number().finite().min(0).optional(),
+  palm: z5.number().finite().min(0).optional()
+}).strict().refine((mix2) => Object.values(mix2).some((weight) => (weight ?? 0) > 0), {
+  message: "Expected at least one tree form with a weight above 0"
+});
 var modulesSchema = z5.object({
   addresses: addressesModuleSchema.optional(),
   aeroways: aerowaysModuleSchema.optional(),
@@ -11632,12 +12513,47 @@ var modulesSchema = z5.object({
     type: z5.literal("vegetation"),
     enabled: z5.boolean().optional(),
     flat: circleStyleSchema.optional(),
-    mode: z5.enum(["3d", "flat"]).optional(),
+    mode: z5.enum(["3d", "flat", "auto"]).optional(),
+    fallback: z5.enum(["flat", "none"]).optional(),
+    visible: z5.boolean().optional(),
     renderStack: renderStackSchema.optional(),
     threeDimensional: z5.object({
       barkColor: themeColorValueSchema.optional(),
       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(),
+      finish: z5.enum(["faceted", "smooth", "toon"]).optional(),
+      edges: boundedThemeNumberSchema(0, 1).optional(),
+      edgeColor: themeColorValueSchema.optional(),
+      forms: z5.partialRecord(
+        z5.enum(["round", "open", "tall", "conifer", "columnar", "palm"]),
+        z5.object({
+          crownScale: boundedThemeNumberSchema(0.1, 10).optional(),
+          heightScale: boundedThemeNumberSchema(0.1, 10).optional(),
+          models: z5.array(
+            z5.string().max(64).regex(
+              tileflowTreeModelIdPattern,
+              "Expected a model id: its .glb file name in lowercase letters, digits and hyphens"
+            )
+          ).min(1).max(4).refine((ids) => new Set(ids).size === ids.length, {
+            message: "Expected each model once"
+          }).optional()
+        }).strict()
+      ).optional(),
+      unknownForms: treeFormMixSchema.optional(),
+      regions: z5.array(
+        z5.object({
+          bounds: z5.tuple([
+            z5.number().finite().min(-180).max(180),
+            z5.number().finite().min(-90).max(90),
+            z5.number().finite().min(-180).max(180),
+            z5.number().finite().min(-90).max(90)
+          ]).refine(([, south, , north]) => south <= north, {
+            message: "Expected bounds as [west, south, east, north] with south below north"
+          }),
+          unknownForms: treeFormMixSchema
+        }).strict()
+      ).max(16).optional(),
       crownScale: z5.union([
         z5.number().finite().positive().max(10),
         themeNumberReferenceSchema,
@@ -11736,6 +12652,7 @@ var fieldBindingsSchema = z5.object({
   markings: z5.string().trim().min(1),
   minHeight: z5.string().trim().min(1),
   minZoom: z5.string().trim().min(1),
+  mode: z5.string().trim().min(1),
   mtbScale: z5.string().trim().min(1),
   name: z5.string().trim().min(1),
   nameEnglish: z5.string().trim().min(1),
@@ -11839,6 +12756,32 @@ var bathymetryReliefSchema = z5.object({
     });
   }
 });
+var bathymetryNameLayerSchema = z5.union([
+  z5.boolean(),
+  z5.object({
+    zoomRanges: z5.array(z5.object({ minZoom: zoomNumberSchema, maxZoom: zoomNumberSchema }).strict()).min(1).max(tileflowBathymetryNameLayerLimits.maxZoomRanges).superRefine((ranges, context) => {
+      const seen = /* @__PURE__ */ new Set();
+      for (const [index, range2] of ranges.entries()) {
+        if (range2.minZoom >= range2.maxZoom) {
+          context.addIssue({
+            code: "custom",
+            message: "Expected minZoom < maxZoom",
+            path: [index, "maxZoom"]
+          });
+        }
+        const key = `${range2.minZoom}/${range2.maxZoom}`;
+        if (seen.has(key)) {
+          context.addIssue({
+            code: "custom",
+            message: "Expected unique nominal zoom ranges",
+            path: [index]
+          });
+        }
+        seen.add(key);
+      }
+    })
+  }).strict()
+]);
 var bathymetryConfigSchema = z5.object({
   ...marineSourceSchema.shape,
   bands: z5.union([z5.literal(false), fillStyleSchema]).optional(),
@@ -11846,7 +12789,12 @@ var bathymetryConfigSchema = z5.object({
   display: z5.enum(["bands", "relief", "hybrid"]).optional(),
   labels: z5.union([z5.literal(false), symbolStyleSchema]).optional(),
   relief: z5.union([z5.literal(false), bathymetryReliefSchema]).optional(),
-  type: z5.literal("bathymetry")
+  type: z5.literal("bathymetry"),
+  vectorLayers: z5.object({
+    contours: z5.boolean().optional(),
+    landforms: bathymetryNameLayerSchema.optional(),
+    waterNames: bathymetryNameLayerSchema.optional()
+  }).strict().optional()
 }).strict();
 var marineSchema = z5.union([
   z5.enum(["none", "bathymetry", "nautical", "chart"]),
@@ -11970,6 +12918,7 @@ var iconDirectoriesSchema = z5.array(
   }
 });
 var fontDirectoriesSchema = z5.array(assetDirectorySchema).max(16);
+var modelDirectoriesSchema = z5.array(assetDirectorySchema).max(16);
 var fontStacksSchema = z5.array(
   z5.string().min(1).max(200).refine(
     (value) => value === value.trim() && value === value.normalize("NFC") && !/[\p{Cc}\\/]/u.test(value),
@@ -12191,6 +13140,7 @@ var resolvedTileflowMapSchema = z5.object({
   icons: iconDirectoriesSchema.optional(),
   id: tileflowMapIdSchema,
   marine: marineSchema.optional(),
+  models: modelDirectoriesSchema.optional(),
   modules: modulesSchema.optional(),
   name: z5.string().trim().min(1),
   overlays: overlaysSchema.optional(),
@@ -12199,6 +13149,10 @@ var resolvedTileflowMapSchema = z5.object({
   systemThemes: systemThemesSchema.optional(),
   terrain: terrainSchema.optional(),
   themes: themesSchema,
+  timeOfDay: createTileflowTimeOfDaySchema(
+    classicManifestSchemaOperations,
+    tileflowThemeNameSchema
+  ).optional(),
   version: z5.number().int().positive(),
   view: viewSchema.optional()
 }).strict().superRefine((map, context) => {
@@ -12223,6 +13177,15 @@ var resolvedTileflowMapSchema = z5.object({
       path: ["defaultTheme"]
     });
   }
+  if (map.timeOfDay) {
+    for (const issue of validateTileflowTimeOfDayVariants(map.timeOfDay, map.themes)) {
+      context.addIssue({
+        code: "custom",
+        message: issue.message,
+        path: ["timeOfDay", ...issue.path]
+      });
+    }
+  }
   const themeEntries = Object.entries(map.themes).sort(
     ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
   );
@@ -12445,6 +13408,23 @@ function tileflowRouteMetadata(inks) {
   return Object.freeze({ version: 1, ...inks });
 }
 
+// src/street-lights.ts
+var tileflowStreetLightsMetadataKey = "tileflow:street-lights";
+var tileflowDefaultStreetLightsDesign = Object.freeze({
+  source: "tileflow",
+  layers: Object.freeze({
+    streetFurniture: "street_furniture",
+    transportation: "transportation",
+    sidewalk: "sidewalk"
+  }),
+  estimate: "lit",
+  color: "#ffcf8f",
+  intensity: 1
+});
+function tileflowStreetLightsMetadata(design) {
+  return { version: 1, ...design };
+}
+
 // src/terrain/index.ts
 function resolveTerrain(terrain, apiBaseUrl) {
   if (!terrain || terrain === "none") return void 0;
@@ -12623,7 +13603,7 @@ function terrainContribution(target, localOrder, layer) {
   };
 }
 function applyLayerRange2(layer, range2) {
-  const layout = { ...asRecord5(layer.layout) };
+  const layout = { ...asRecord6(layer.layout) };
   if (range2.visible !== void 0) layout.visibility = range2.visible ? "visible" : "none";
   return {
     ...layer,
@@ -12632,10 +13612,13 @@ function applyLayerRange2(layer, range2) {
     ...Object.keys(layout).length === 0 ? {} : { layout }
   };
 }
-function asRecord5(value) {
+function asRecord6(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
+// src/vegetation-display.ts
+var tileflowVegetationDisplayMetadataKey = "tileflow:vegetation-display";
+
 // src/cartography/compilation-report.ts
 var tileflowCompilationReportSchemaVersion = 1;
 var tileflowCompilationPhases = Object.freeze([
@@ -13007,14 +13990,16 @@ function defaultPaint(image, key, names, appearances, ids) {
 
 // src/cartography/interaction-manifest.ts
 var tileflowInteractionManifestMetadataKey = "tileflow:interaction-manifest";
-var tileflowInteractionManifestVersion = 2;
+var tileflowInteractionManifestVersion = 3;
 function createTileflowInteractionManifest(layers, fields) {
   const poiLayers = layers.flatMap((layer, priority) => {
     const id2 = typeof layer.id === "string" ? layer.id : void 0;
     const source = typeof layer.source === "string" ? layer.source : void 0;
     const sourceLayer = typeof layer["source-layer"] === "string" ? layer["source-layer"] : void 0;
     const target = semanticTarget(layer);
-    if (!id2 || !source || !sourceLayer || !target?.startsWith("poi.")) return [];
+    if (!id2 || !source || !sourceLayer || target !== "poi" && !target?.startsWith("poi.")) {
+      return [];
+    }
     const parsed = parsePoiTarget(target);
     if (!parsed) return [];
     return [
@@ -13062,7 +14047,7 @@ function assertTileflowInteractionManifestLayers(manifest, layers) {
     );
   }
   for (const layer of poiLayers) {
-    if (!isTileflowPoiCategory(layer.category) || !isSafeArtifactName(layer.layerId) || !isSafeArtifactName(layer.source) || !isSafeArtifactName(layer.sourceLayer)) {
+    if (!isSafeArtifactName(layer.layerId) || !isSafeArtifactName(layer.source) || !isSafeArtifactName(layer.sourceLayer)) {
       throw new Error("Tileflow interaction manifest contains an invalid physical POI lookup.");
     }
     const finalized = layersById.get(layer.layerId);
@@ -13085,15 +14070,16 @@ function assertTileflowInteractionManifestLayers(manifest, layers) {
 }
 function parsePoiTarget(target) {
   const segments = target.split(".");
-  if (segments[0] !== "poi" || segments.length < 2 || segments.length > 3) return void 0;
-  const category = segments[1];
-  if (!isTileflowPoiCategory(category)) return void 0;
-  const suffix = segments[2];
-  if (suffix === void 0) return { category, representation: "combined" };
-  if (suffix === "icon" || suffix === "label" || suffix === "marker") {
-    return { category, representation: suffix };
-  }
-  return void 0;
+  if (segments[0] !== "poi" || segments.length > 3) return void 0;
+  const [, first, second] = segments;
+  if (first === void 0) return { representation: "combined" };
+  if (segments.length === 2 && isRepresentationPart(first)) return { representation: first };
+  if (first !== "prominent" && !isTileflowPoiCategory(first)) return void 0;
+  if (second === void 0) return { representation: "combined" };
+  return isRepresentationPart(second) ? { representation: second } : void 0;
+}
+function isRepresentationPart(value) {
+  return value === "icon" || value === "label" || value === "marker";
 }
 function isTileflowPoiCategory(value) {
   return typeof value === "string" && tileflowPoiCategories.includes(value);
@@ -13827,7 +14813,7 @@ function conditionalExpression(entries, fallback) {
     ];
   }
   const classMatches = entries.map(({ condition }) => splitClassMatch(condition));
-  if (classMatches.every((match2) => match2 !== void 0) && allEqual(classMatches.map((match2) => match2?.field)) && allEqual(classMatches.map((match2) => match2?.remainder)) && classMatchLabelsAreDisjoint(classMatches.map((match2) => match2.labels))) {
+  if (classMatches.every((match3) => match3 !== void 0) && allEqual(classMatches.map((match3) => match3?.field)) && allEqual(classMatches.map((match3) => match3?.remainder)) && classMatchLabelsAreDisjoint(classMatches.map((match3) => match3.labels))) {
     return [
       "match",
       ["get", classMatches[0].field],
@@ -13991,6 +14977,114 @@ function stableSerialize(value) {
   return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableSerialize(entry)}`).join(",")}}`;
 }
 
+// src/cartography/scene-3d-metadata.ts
+var colourSources = [
+  ["tileflow-buildings-render-extrusion", "fill-extrusion-color"],
+  ["tileflow-buildings-3d", "fill-extrusion-color"],
+  ["tileflow-buildings-fill", "fill-color"]
+];
+function tileflowBuildings3DDesignOf(module, context, layers, buildingModels, tileflowLandmarks) {
+  const config = isRecord8(module) ? module : {};
+  if (config.enabled === false) return void 0;
+  const style = config.threeDimensional ?? {};
+  let color2;
+  let verticalGradient = true;
+  for (const [id2, property] of colourSources) {
+    const value = layers.find((layer) => layer.id === id2)?.paint?.[property];
+    if (typeof value === "string" || Array.isArray(value)) {
+      color2 = value;
+      verticalGradient = layers.find((layer) => layer.id === id2)?.paint?.["fill-extrusion-vertical-gradient"] !== false;
+      break;
+    }
+  }
+  const number = (value, fallback) => {
+    const resolved = value === void 0 ? void 0 : toMapLibreStyleValue(value);
+    return typeof resolved === "number" ? resolved : fallback;
+  };
+  const edgeColor = style.edgeColor === void 0 ? void 0 : toMapLibreStyleValue(style.edgeColor);
+  return {
+    source: context.data.sourceId,
+    layers: {
+      building: context.data.schema.layers.building,
+      ...context.data.schema.layers.poi ? { places: context.data.schema.layers.poi } : {}
+    },
+    color: color2 ?? context.colors.buildings.generic,
+    lighting: style.lighting === "sun" ? "sun" : "style",
+    colorVariation: number(style.colorVariation, 0),
+    verticalGradient,
+    edges: number(style.edges, 0),
+    ...typeof edgeColor === "string" ? { edgeColor } : {},
+    nightLight: number(style.nightLight, 0),
+    windows: style.windows === true,
+    shadows: style.shadows === true,
+    occlusion: style.occlusion === true,
+    ...placedModels(style.models, buildingModels),
+    ...modelColours(style.modelColors),
+    ...landmarksOf(style.landmarks, tileflowLandmarks)
+  };
+}
+function landmarksOf(value, tileflowLandmarks) {
+  if (value === false) return {};
+  if (isRecord8(value) && typeof value.url === "string") return { landmarks: { url: value.url } };
+  return tileflowLandmarks ? { landmarks: { url: tileflowLandmarks } } : {};
+}
+function placedModels(value, served) {
+  if (!Array.isArray(value) || value.length === 0) return {};
+  const placements = value;
+  const missing = [
+    ...new Set(
+      placements.filter((entry) => !entry.url).map((entry) => entry.model).filter((id2) => !served?.[id2])
+    )
+  ].sort();
+  if (missing.length > 0)
+    throw new Error(
+      `The buildings module places missing 3D models: ${missing.join(", ")}. Add ${missing.map((id2) => `${id2}.glb`).join(
+        ", "
+      )} to a map.models directory, with materials named surface, secondary, glass, accent or roof, and run the Node build so the directories are prepared.`
+    );
+  return {
+    models: placements.map((entry) => ({
+      model: entry.model,
+      url: entry.url ?? served[entry.model],
+      at: [entry.at[0], entry.at[1]],
+      heading: ((entry.heading ?? 0) % 360 + 360) % 360
+    }))
+  };
+}
+function modelColours(value) {
+  if (!isRecord8(value)) return {};
+  const colours = {};
+  for (const [part, colour] of Object.entries(value)) {
+    const resolved = colour === void 0 ? void 0 : toMapLibreStyleValue(colour);
+    if (typeof resolved === "string") colours[part] = resolved;
+  }
+  return Object.keys(colours).length > 0 ? { modelColors: colours } : {};
+}
+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)
+    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);
+  const estimate = style.estimate;
+  return {
+    source: context.data.sourceId,
+    layers: {
+      streetFurniture: layers.streetFurniture,
+      transportation: layers.road,
+      ...layers.sidewalk ? { sidewalk: layers.sidewalk } : {}
+    },
+    estimate: estimate === "streets" || estimate === "none" || estimate === "lit" ? estimate : "lit",
+    color: typeof color2 === "string" ? color2 : tileflowDefaultStreetLightsDesign.color,
+    intensity: typeof intensity === "number" ? intensity : 1
+  };
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/cartography/semantic-compiler.ts
 var tileflowSemanticCompilerIdentity = Object.freeze({
   name: "tileflow-semantic",
@@ -14021,7 +15115,10 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     suggestion,
     ...target ? { target } : {}
   }));
-  const selected = runCompilationPhase("theme", () => resolveThemeSelection(input, options.theme));
+  const selected = runCompilationPhase(
+    "theme",
+    () => resolveThemeSelection(input, options.theme, options.timeOfDay)
+  );
   const resolvedTheme = runCompilationPhase("theme", () => resolveTileflowTheme(selected.theme));
   const { overlays, themes: _themes, ...themeableConfig } = input;
   const resolvedThemeConfig = runCompilationPhase(
@@ -14127,8 +15224,19 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     "domains",
     () => compileSemanticDomains(modules, context)
   );
+  const vegetation3D = runCompilationPhase(
+    "domains",
+    () => withPreparedTreeModels(
+      tileflowVegetationDescription(
+        modules.vegetation,
+        context
+      ),
+      config,
+      options.preparedAssets
+    )
+  );
   const renderStackModules = Object.values(modules).filter(
-    (module) => isRecord8(module) && module.enabled !== false && "renderStack" in module && isRecord8(module.renderStack)
+    (module) => isRecord9(module) && module.enabled !== false && "renderStack" in module && isRecord9(module.renderStack)
   );
   const renderOperations = runCompilationPhase(
     "render-stack",
@@ -14288,6 +15396,17 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     () => createTileflowOverlayPlacementManifest(plannedLayers)
   );
   const layers = runCompilationPhase("finalization", () => finalizeTileflowLayers(plannedLayers));
+  const buildings3D = tileflowBuildings3DDesignOf(
+    modules.buildings,
+    context,
+    layers,
+    options.preparedAssets?.buildingModels,
+    data.kind === "tileflow-world" ? `${apiBaseUrl}/landmarks/tiles.json` : void 0
+  );
+  const streetLights = tileflowStreetLightsDesignOf(
+    modules.roads,
+    context
+  );
   runCompilationPhase(
     "finalization",
     () => assertTileflowInteractionManifestLayers(interactionManifest, layers)
@@ -14335,6 +15454,24 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       layers
     })
   );
+  const flatVegetationLayers = layers.filter((layer) => {
+    const metadata = layer.metadata;
+    return metadata?.["tileflow:vegetation-mode"] !== void 0 || metadata?.["tileflow:domain"] === "vegetation";
+  });
+  const vegetationDisplay = flatVegetationLayers.length || vegetation3D ? {
+    version: 1,
+    mode: modules.vegetation?.mode ?? "3d",
+    fallback: modules.vegetation?.fallback ?? "flat",
+    visible: modules.vegetation?.visible ?? true,
+    flatLayers: flatVegetationLayers.map((layer) => ({
+      id: String(layer.id),
+      visible: layer.layout?.visibility !== "none"
+    }))
+  } : void 0;
+  if (vegetationDisplay && (!vegetationDisplay.visible || vegetationDisplay.mode === "3d" && vegetationDisplay.fallback === "none")) {
+    for (const layer of flatVegetationLayers)
+      layer.layout = { ...layer.layout, visibility: "none" };
+  }
   const atmosphere = resolveTileflowAtmosphere(config.atmosphere);
   const style = {
     ...atmosphere ? { sky: compileTileflowSky(atmosphere) } : {},
@@ -14360,13 +15497,31 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       "tileflow:colorScheme": resolvedTheme.colorScheme,
       [tileflowRouteMetadataKey]: tileflowRouteMetadata(resolveTileflowRouteInks(resolvedTheme)),
       ...resolvedTheme.sun ? { [tileflowSunMetadataKey]: tileflowSunMetadata(resolvedTheme.sun) } : {},
+      ...buildings3D ? {
+        [tileflowBuildingsMetadataKey]: tileflowBuildingsMetadata(
+          bindSemanticReferences(buildings3D, semanticData)
+        )
+      } : {},
+      ...streetLights ? {
+        [tileflowStreetLightsMetadataKey]: tileflowStreetLightsMetadata(
+          bindSemanticReferences(streetLights, semanticData)
+        )
+      } : {},
+      ...vegetation3D ? {
+        [tileflowVegetationMetadataKey]: tileflowVegetationMetadata({
+          ...bindSemanticReferences(vegetation3D, semanticData),
+          // The layers that draw the trees flat: the module's own and its render passes.
+          flatLayers: flatVegetationLayers.map((layer) => String(layer.id))
+        })
+      } : {},
+      ...vegetationDisplay ? { [tileflowVegetationDisplayMetadataKey]: vegetationDisplay } : {},
       "tileflow:data": data.identity,
       "tileflow:sources": sourceIdentities,
       ...Object.keys(loweredOverlays.identities).length > 0 ? { "tileflow:overlays": loweredOverlays.identities } : {},
       "tileflow:sourceRequirements": sourceRequirements,
       ...interactionManifest ? { [tileflowInteractionManifestMetadataKey]: interactionManifest } : {},
       [tileflowOverlayPlacementManifestMetadataKey]: overlayPlacementManifest,
-      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord8(module) || module.enabled !== false).map(([name]) => name).sort(),
+      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord9(module) || module.enabled !== false).map(([name]) => name).sort(),
       ...config.view ? { "tileflow:view": config.view } : {}
     }
   };
@@ -14418,7 +15573,7 @@ function finalizeTileflowLayers(input) {
     if (typeof minimum2 === "number" && typeof maximum2 === "number" && minimum2 > maximum2) {
       throw new Error(`Compiled Tileflow layer ${id2} requires minzoom <= maxzoom.`);
     }
-    const metadata = isRecord8(layer.metadata) ? { ...layer.metadata } : void 0;
+    const metadata = isRecord9(layer.metadata) ? { ...layer.metadata } : void 0;
     if (metadata) {
       const owner = metadata[tileflowCompilerMetadataKeys.owner];
       delete metadata[tileflowCompilerProvenanceMetadataKey];
@@ -14452,13 +15607,32 @@ function assertMapLibreStyle(style, mapId) {
     }
   );
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function resolveGlyphs(config) {
   if (config.fonts !== void 0) return void 0;
   return config.glyphs?.url;
 }
+function withPreparedTreeModels(vegetation2, config, prepared) {
+  if (!vegetation2) return void 0;
+  const referenced = [
+    ...new Set(Object.values(vegetation2.forms).flatMap((form) => form?.models ?? []))
+  ].sort();
+  if (referenced.length === 0) return vegetation2;
+  const available = prepared?.models ?? {};
+  const missing = referenced.filter((id2) => !Object.hasOwn(available, id2));
+  if (missing.length > 0) {
+    const authoring = config.models?.length ? `Add ${missing.map((id2) => `${id2}.glb`).join(", ")} to a map.models directory, or run the Node build so the directories are prepared.` : "Declare map.models with directories containing those .glb files.";
+    throw new Error(
+      `Tileflow map "${config.id}" draws missing 3D models: ${missing.join(", ")}. ${authoring}`
+    );
+  }
+  return {
+    ...vegetation2,
+    models: Object.fromEntries(referenced.map((id2) => [id2, available[id2]]))
+  };
+}
 function assertPreparedIconReferences(style, config, prepared) {
   const references = collectStyleImageReferences(style);
   if (references.size === 0) return;
@@ -14473,8 +15647,8 @@ function assertPreparedIconReferences(style, config, prepared) {
 function collectStyleImageReferences(style) {
   const result = /* @__PURE__ */ new Set();
   for (const layer of style.layers) {
-    const layout = isRecord8(layer.layout) ? layer.layout : {};
-    const paint = isRecord8(layer.paint) ? layer.paint : {};
+    const layout = isRecord9(layer.layout) ? layer.layout : {};
+    const paint = isRecord9(layer.paint) ? layer.paint : {};
     const layerId = typeof layer.id === "string" ? layer.id : "<unknown>";
     for (const [property, value] of [
       ["icon-image", layout["icon-image"]],
@@ -14563,7 +15737,7 @@ function assertGlyphFontStacks(style, config) {
   const declared = new Set(config.glyphs.fontStacks);
   const missing = /* @__PURE__ */ new Set();
   for (const layer of style.layers) {
-    const layout = isRecord8(layer.layout) ? layer.layout : void 0;
+    const layout = isRecord9(layer.layout) ? layer.layout : void 0;
     const font = layout?.["text-font"];
     if (!Array.isArray(font) || !font.every((entry) => typeof entry === "string")) continue;
     const stack = font.join(",");
@@ -14579,7 +15753,7 @@ function assertGlyphFontStacks(style, config) {
 function assertTextAssets(style, config) {
   const textLayers = [];
   for (const layer of style.layers) {
-    const layout = isRecord8(layer.layout) ? layer.layout : void 0;
+    const layout = isRecord9(layer.layout) ? layer.layout : void 0;
     if (layout?.["text-field"] === void 0) continue;
     textLayers.push(typeof layer.id === "string" ? layer.id : "<unknown>");
     const font = layout["text-font"];
@@ -14592,7 +15766,7 @@ function assertTextAssets(style, config) {
   if (textLayers.length === 0) return;
   if (config.fonts !== void 0) {
     const backed = style.layers.find((layer) => {
-      const font = isRecord8(layer.layout) ? layer.layout["text-font"] : void 0;
+      const font = isRecord9(layer.layout) ? layer.layout["text-font"] : void 0;
       return Array.isArray(font) && font.length === 1 && typeof font[0] === "string" && parseTileflowLineBackgroundFontStack(font[0]) !== void 0;
     });
     if (backed) {
@@ -14618,7 +15792,7 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record3 = isRecord8(error) ? error : {};
+  const record3 = isRecord9(error) ? error : {};
   if (typeof record3.phase === "string") return error;
   if (error instanceof Error && Object.isExtensible(error)) {
     Object.defineProperty(error, "phase", { configurable: true, enumerable: true, value: phase });
@@ -14721,12 +15895,24 @@ function createTileflowRuntimeManifestSchema(primitives, operations, identities
         })
       ),
       themes: operations.record(tileflowThemeNameSchema2, manifestThemeSchema),
+      timeOfDay: operations.optional(
+        createTileflowTimeOfDaySchema(operations, tileflowThemeNameSchema2)
+      ),
       usageMode: operations.optional(operations.literal("session")),
       view: operations.optional(viewSchema3),
       worldGeneration: operations.optional(operations.literal("v1"))
     }),
     (entry, context) => {
       const names = Object.keys(entry.themes);
+      if (entry.timeOfDay) {
+        for (const issue of validateTileflowTimeOfDayVariants(entry.timeOfDay, entry.themes)) {
+          context.addIssue({
+            code: "custom",
+            message: issue.message,
+            path: ["timeOfDay", ...issue.path]
+          });
+        }
+      }
       if (names.length === 0) {
         context.addIssue({
           code: "custom",
@@ -14780,10 +15966,23 @@ function createTileflowRuntimeManifestSchema(primitives, operations, identities
     operations.object({
       apiUrl: operations.optional(apiOriginSchema),
       maps: operations.record(tileflowPortableIdSchema2, manifestMapSchema),
-      version: operations.literal(tileflowRuntimeManifestVersion)
+      version: operations.union(
+        operations.literal(tileflowRuntimeManifestVersion),
+        operations.literal(2)
+      )
     }),
     (manifest, context) => {
       const mapCount = Object.keys(manifest.maps).length;
+      if (manifest.version === 1) {
+        for (const [name, map] of Object.entries(manifest.maps)) {
+          if (map.timeOfDay !== void 0)
+            context.addIssue({
+              code: "custom",
+              message: "timeOfDay requires manifest version 2",
+              path: ["maps", name, "timeOfDay"]
+            });
+        }
+      }
       if (mapCount === 0) {
         context.addIssue({ code: "custom", message: "Expected at least one map", path: ["maps"] });
       }
@@ -15178,6 +16377,7 @@ var tileflowMapMergeStrategies = {
   icons: "icons",
   id: "identity",
   marine: "atomic",
+  models: "atomic",
   modules: "modules",
   name: "identity",
   overlays: "keyed-resources",
@@ -15188,6 +16388,7 @@ var tileflowMapMergeStrategies = {
   systemThemes: "atomic",
   terrain: "atomic",
   themes: "atomic",
+  timeOfDay: "atomic",
   version: "identity",
   view: "deep"
 };
@@ -15202,7 +16403,10 @@ function resolveMap(map, options = {}) {
   for (let index = lineage.length - 1; index >= 0; index -= 1) {
     const current = lineage[index];
     const currentId = current.id;
-    if (current.themes !== void 0) delete design.systemThemes;
+    if (current.themes !== void 0) {
+      delete design.systemThemes;
+      delete design.timeOfDay;
+    }
     for (const key of Object.keys(current)) {
       const value = current[key];
       const strategy = tileflowMapMergeStrategies[key];
@@ -15523,11 +16727,11 @@ function cloneDesign(value) {
 function describeMap(value) {
   return typeof value.id === "string" && value.id ? value.id : "<anonymous>";
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord4(value) {
-  if (!isRecord9(value)) return false;
+  if (!isRecord10(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -15980,6 +17184,7 @@ async function createTileflowMapBuildManifest(maps, options = {}) {
           semanticCompiler: { ...tileflowSemanticCompilerIdentity },
           sourceAssets,
           ...map.systemThemes ? { systemThemes: { ...map.systemThemes } } : {},
+          ...map.timeOfDay && Object.keys(map.timeOfDay).length ? { timeOfDay: map.timeOfDay } : {},
           themes
         }
       ];
@@ -16045,6 +17250,7 @@ async function hashTileflowMapRevision(input, sourceAssets) {
   const {
     fonts: _fonts,
     icons: _icons,
+    models: _models,
     id: _id,
     name: _name,
     version: _version,
@@ -16140,10 +17346,26 @@ function normalizeSourceAssets(input) {
   if (new Set(fonts.map(fontIdentity)).size !== fonts.length) {
     throw new Error("Effective Tileflow font source identities must have unique faces.");
   }
+  const models = [...input.models ?? []].map((model) => {
+    assertSha256(model.sha256, `model ${model.id}`);
+    if (model.level !== "near" && model.level !== "mid" && model.level !== "far")
+      throw new Error(`Tileflow model ${model.id} is near, mid or far.`);
+    return { id: model.id, level: model.level, sha256: model.sha256 };
+  }).sort(
+    (left, right) => compareCodeUnits8(`${left.id}\0${left.level}`, `${right.id}\0${right.level}`)
+  );
+  if (new Set(models.map((model) => `${model.id}\0${model.level}`)).size !== models.length) {
+    throw new Error("Effective Tileflow model source identities must be unique.");
+  }
   const iconComposition = input.iconComposition === void 0 ? void 0 : parseTileflowIconComposition(input.iconComposition);
   if (icons.some((icon) => icon.kind === "rendered-icon") && !iconComposition)
     throw new Error("Rendered icon identities require an explicit composition receipt");
-  return { fonts, icons, ...iconComposition ? { iconComposition } : {} };
+  return {
+    fonts,
+    icons,
+    ...iconComposition ? { iconComposition } : {},
+    ...models.length > 0 ? { models } : {}
+  };
 }
 function fontIdentity(font) {
   return `${font.family}\0${font.style}\0${font.weight}`;
@@ -24909,7 +26131,7 @@ function createNativeUrlPolicy(parse) {
     const resourcePath = resolved.href.slice(resolved.origin.length);
     const suffix = resourcePath.replace(
       new RegExp(`${prefix}(\\d+)__`, "gu"),
-      (match2, index) => placeholders[Number(index)] ?? match2
+      (match3, index) => placeholders[Number(index)] ?? match3
     );
     const result = resolved.origin + suffix;
     assertUrlText(result, "resourceUrl");
@@ -24927,8 +26149,8 @@ function createNativeUrlPolicy(parse) {
     if (value === void 0) return void 0;
     try {
       assertUrlText(value, "developmentOrigin");
-      const match2 = /^(http:\/\/[^/?#]+)\/?$/iu.exec(value);
-      if (!match2 || /[{}@*]/u.test(value)) throw new Error();
+      const match3 = /^(http:\/\/[^/?#]+)\/?$/iu.exec(value);
+      if (!match3 || /[{}@*]/u.test(value)) throw new Error();
       const url = parseUrl(value, "developmentOrigin");
       if (url.protocol !== "http:" || url.pathname !== "/" || url.search || url.hash || url.hostname.includes("*")) {
         throw new Error();
@@ -25339,11 +26561,11 @@ function parserIssuePointer(key, style) {
   let path = "";
   while (rest) {
     if (Array.isArray(value)) {
-      const match2 = /^\[(\d+)\]/u.exec(rest);
-      if (!match2 || Number(match2[1]) >= value.length) return path;
-      path = nativePointer(path, match2[1]);
-      value = value[Number(match2[1])];
-      rest = rest.slice(match2[0].length).replace(/^\./u, "");
+      const match3 = /^\[(\d+)\]/u.exec(rest);
+      if (!match3 || Number(match3[1]) >= value.length) return path;
+      path = nativePointer(path, match3[1]);
+      value = value[Number(match3[1])];
+      rest = rest.slice(match3[0].length).replace(/^\./u, "");
     } else if (record2(value)) {
       const matches = Object.keys(value).filter(
         (name2) => rest === name2 || rest.startsWith(`${name2}.`) || rest.startsWith(`${name2}[`)
@@ -25436,7 +26658,11 @@ var mapBuildSchema = z15.object({
   semanticCompiler: z15.object({ name: z15.literal("tileflow-semantic"), version: z15.literal(1) }).strict(),
   sourceAssets: sourceAssetsSchema,
   systemThemes: z15.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
-  themes: z15.record(tileflowThemeNameSchema, themeBuildSchema)
+  themes: z15.record(tileflowThemeNameSchema, themeBuildSchema),
+  timeOfDay: createTileflowTimeOfDaySchema(
+    classicManifestSchemaOperations,
+    tileflowThemeNameSchema
+  ).optional()
 }).strict();
 var buildManifestSchema = z15.object({
   schemaVersion: z15.literal(1),
@@ -25498,6 +26724,8 @@ var tileflowRendererDeploymentArtifactSchema = z15.object({
     const themes = Object.keys(map.themes).sort();
     if (!themes.length || themes.length > tileflowRendererDeploymentLimits.maximumThemes || !equal(themes, Object.keys(family.styles).sort()) || !themes.includes(map.defaultTheme) || map.lineage[0]?.id !== artifact.mapId || map.lineage[0]?.mapVersion !== map.mapVersion || Boolean(map.sourceAssets.iconComposition) !== (map.mapRevisionSchemaVersion === 2))
       fail();
+    if (map.timeOfDay && validateTileflowTimeOfDayVariants(map.timeOfDay, map.themes).length)
+      fail();
     for (const scheme of ["light", "dark"]) {
       if (map.systemThemes && map.themes[map.systemThemes[scheme]]?.colorScheme !== scheme)
         fail();
@@ -25613,7 +26841,7 @@ var artifactName = z15.string().min(1).max(256).refine(
   })
 );
 var semanticSchema = z15.object({
-  version: z15.literal(2),
+  version: z15.literal(3),
   domains: z15.object({
     poi: z15.object({
       deduplication: z15.object({
@@ -25645,7 +26873,6 @@ var semanticSchema = z15.object({
       layers: z15.array(
         z15.object({
           anchor: z15.literal("pointer-coordinate"),
-          category: z15.enum(tileflowPoiCategories),
           layerId: artifactName,
           priority: z15.number().int().min(0).max(4095),
           representation: z15.enum(["combined", "icon", "label", "marker"]),
@@ -25817,6 +27044,7 @@ function createManifest(catalog, options = {}) {
           defaultTheme: resolved.defaultTheme,
           ...resolved.systemThemes ? { systemThemes: resolved.systemThemes } : {},
           themes,
+          ...options.manifestVersion !== 1 && resolved.timeOfDay && Object.keys(resolved.timeOfDay).length ? { timeOfDay: resolved.timeOfDay } : {},
           ...resolved.view ? { view: resolved.view } : {}
         }
       ];
@@ -25824,7 +27052,7 @@ function createManifest(catalog, options = {}) {
   );
   const manifest = {
     maps,
-    version: tileflowRuntimeManifestVersion
+    version: options.manifestVersion ?? (Object.values(maps).some((map) => map.timeOfDay) ? 2 : tileflowRuntimeManifestVersion)
   };
   return parseTileflowRuntimeManifest(manifest);
 }