@tileflow/core 0.1.0-alpha.34 → 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({
@@ -905,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;
   }
@@ -1655,7 +1686,7 @@ function compileVegetation(request, context) {
 }
 function tileflowVegetationDescription(request, context) {
   const { schema } = context.data;
-  if (request?.enabled === false || (request?.mode ?? "3d") !== "3d" || !schema.layers.tree)
+  if (request?.enabled === false || request?.mode === "flat" || !schema.layers.tree)
     return void 0;
   const tree = context.colors.vegetation.tree;
   const style = request?.threeDimensional ?? {};
@@ -1718,102 +1749,6 @@ function tileflowVegetationDescription(request, context) {
   };
 }
 
-// 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: 1,
-  nightLight: 1,
-  windows: false,
-  shadows: true,
-  occlusion: true
-});
-function tileflowBuildingsMetadata(design) {
-  return { version: 1, ...design };
-}
-
-// 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/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) {
-  const config = isRecord3(module) ? module : {};
-  if (config.enabled === false) return void 0;
-  const style = config.threeDimensional ?? {};
-  let color2;
-  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;
-      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,
-    edges: number(style.edges, 1),
-    ...typeof edgeColor === "string" ? { edgeColor } : {},
-    nightLight: number(style.nightLight, 1),
-    windows: style.windows === true,
-    shadows: style.shadows !== false,
-    occlusion: style.occlusion !== false
-  };
-}
-function tileflowStreetLightsDesignOf(module, context) {
-  const config = isRecord3(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 isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 // src/cartography/contributions.ts
 var tileflowLayerSlots = [
   "background",
@@ -2372,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() {
@@ -2636,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") {
@@ -3493,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}`,
@@ -3554,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;
 }
@@ -4267,6 +4219,12 @@ 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) };
 }
@@ -4280,7 +4238,10 @@ function resolvePoi(request) {
     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
     }
   };
@@ -4289,127 +4250,526 @@ 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 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}`;
@@ -4432,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];
 }
@@ -4470,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) {
@@ -4480,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
   );
@@ -4499,22 +4836,76 @@ function withPoiTextClearance(style, besideIcon) {
     }
   };
 }
-function withoutMarker2(style) {
-  const result = { ...style };
-  delete result.marker;
+function withoutMarker2(style) {
+  const result = { ...style };
+  delete result.marker;
+  return result;
+}
+function withoutVisibility(value) {
+  const { visible: _visible, ...rest } = value;
+  return rest;
+}
+
+// src/portable-identity-rules.ts
+var tileflowPortableIdMaximumLength = 64;
+var tileflowPortableIdPattern = /^[a-z][a-z0-9-]{0,63}$/u;
+function isTileflowPortableId(value) {
+  return typeof value === "string" && value.length <= tileflowPortableIdMaximumLength && tileflowPortableIdPattern.test(value) && !["constructor", "prototype"].includes(value) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(value);
+}
+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/portable-identity-rules.ts
-var tileflowPortableIdMaximumLength = 64;
-var tileflowPortableIdPattern = /^[a-z][a-z0-9-]{0,63}$/u;
-function isTileflowPortableId(value) {
-  return typeof value === "string" && value.length <= tileflowPortableIdMaximumLength && tileflowPortableIdPattern.test(value) && !["constructor", "prototype"].includes(value) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(value);
-}
-function isTileflowThemeName(value) {
-  return isTileflowPortableId(value) && value !== "system";
-}
-
 // src/sun.ts
 var tileflowSunMetadataKey = "tileflow:sun";
 var tileflowDefaultSunPreset = Object.freeze({
@@ -4737,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(
@@ -4754,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 = [];
@@ -4767,7 +5159,7 @@ function auditTileflowThemeValues(value, path = "value", context = inferAuditCon
   return diagnostics.sort(compareAuditDiagnostics);
 }
 function auditTileflowMapThemeValues(map) {
-  const modules = isRecord4(map.modules) ? map.modules : void 0;
+  const modules = isRecord3(map.modules) ? map.modules : void 0;
   const moduleDiagnostics = modules ? Object.keys(modules).sort(compareCodeUnits2).flatMap(
     (owner) => auditTileflowThemeValues(modules[owner], `modules.${owner}`, {
       owner,
@@ -4870,7 +5262,7 @@ function isThemePrimitiveForCategory(value, category) {
   return category === "number" ? typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every((entry) => typeof entry === "number" && Number.isFinite(entry)) : typeof value === "string" && value.length > 0;
 }
 function isThemeValueCandidate(value) {
-  return isRecord4(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
+  return isRecord3(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
 }
 function visitAuditableValue(value, path, category, state, intentRequired = false) {
   if (isThemeStructuralPath(path)) category = void 0;
@@ -4886,7 +5278,7 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     visitAuditableArray(value, path, category, state, false, intentRequired);
     return;
   }
-  if (!isRecord4(value)) return;
+  if (!isRecord3(value)) return;
   if (value.kind === "expression" && Array.isArray(value.value)) {
     visitAuditableArray(value.value, `${path}.value`, category, state, true, intentRequired);
     return;
@@ -5201,7 +5593,7 @@ var ThemeValueResolver = class {
     if (Array.isArray(value)) {
       return value.map((entry, index) => this.resolveTree(entry, `${path}[${index}]`, category));
     }
-    if (!isRecord4(value)) return value;
+    if (!isRecord3(value)) return value;
     if (value.kind === "expression" && Array.isArray(value.value)) {
       return {
         ...value,
@@ -5513,7 +5905,7 @@ function assertThemeLighting(value, path) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord4(value)) {
+  if (!isRecord3(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -5865,11 +6257,11 @@ function cloneJson14(value) {
   if (serialized === void 0) throw new Error("Tileflow themes must be JSON-serializable.");
   return JSON.parse(serialized);
 }
-function isRecord4(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord(value) {
-  if (!isRecord4(value)) return false;
+  if (!isRecord3(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -6823,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"
     });
   }
@@ -6833,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"
     });
   }
@@ -6900,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 = [
       "*",
@@ -6917,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 = [
       "*",
@@ -6938,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 [
@@ -7102,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,
@@ -7118,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]
@@ -7205,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
     );
@@ -7218,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) {
@@ -7597,7 +8006,7 @@ var waterwayClasses = {
   river: ["river"],
   stream: ["stream"]
 };
-function compileWater(request, context) {
+function compileWater(request, context, language = "auto") {
   const config = mergeTileflowDesign(
     {
       type: "water",
@@ -7749,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,
@@ -7773,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
@@ -7792,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,
@@ -7825,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
         ),
@@ -7837,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];
@@ -7900,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");
@@ -8108,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(),
@@ -8202,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(),
@@ -8320,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) => {
@@ -8348,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;
@@ -8362,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)) {
@@ -8376,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 : {};
 }
 
@@ -8423,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)]);
   },
@@ -8745,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([
@@ -8843,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;
@@ -9228,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,
@@ -9252,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 });
 }
@@ -9283,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;
@@ -9294,21 +9845,21 @@ function bindSemanticValue(value, schema, sourceId) {
   }
   if (isDataSourceReference(value)) return sourceId;
   if (Array.isArray(value)) return value.map((item) => bindSemanticValue(item, schema, sourceId));
-  if (!isRecord5(value)) return value;
+  if (!isRecord4(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([key, item]) => [key, bindSemanticValue(item, schema, sourceId)])
   );
 }
 function isDataFieldReference2(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
+  return isRecord4(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
 }
 function isDataLayerReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
+  return isRecord4(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
 }
 function isDataSourceReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-source" && value.name === "primary";
+  return isRecord4(value) && value.kind === "tileflow-data-source" && value.name === "primary";
 }
-function isRecord5(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compareCodeUnits5(left, right) {
@@ -9412,8 +9963,8 @@ function createTileflowLayerTemplateIR(layer, semanticKey) {
     renderer: type,
     ...filter === void 0 ? {} : { selector: cloneJson20(filter) },
     style: Object.freeze({
-      ...isRecord6(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
-      ...isRecord6(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
+      ...isRecord5(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
+      ...isRecord5(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
     })
   });
 }
@@ -9487,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(
@@ -9569,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",
@@ -9585,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"
 });
@@ -9609,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;
@@ -9653,21 +10212,21 @@ function visitReferences(value, counts, visited = /* @__PURE__ */ new WeakSet())
   }
 }
 function isSemanticFieldReference(value) {
-  return isRecord6(value) && value.kind === "tileflow-data-field";
+  return isRecord5(value) && value.kind === "tileflow-data-field";
 }
 function isSemanticLayerReference(value) {
-  return isRecord6(value) && value.kind === "tileflow-data-layer";
+  return isRecord5(value) && value.kind === "tileflow-data-layer";
 }
 function isSemanticSourceReference(value) {
-  return isRecord6(value) && value.kind === "tileflow-data-source";
+  return isRecord5(value) && value.kind === "tileflow-data-source";
 }
 function cloneJson20(value) {
   return JSON.parse(JSON.stringify(value));
 }
-function asRecord3(value) {
-  return isRecord6(value) ? value : {};
+function asRecord4(value) {
+  return isRecord5(value) ? value : {};
 }
-function isRecord6(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -9719,7 +10278,7 @@ function validateTileflowRenderSelectorConstraints(input) {
   };
   while (pending.length > 0) {
     const current = pending.pop();
-    if (!isRecord7(current.selector) || typeof current.selector.kind !== "string") {
+    if (!isRecord6(current.selector) || typeof current.selector.kind !== "string") {
       addIssue(
         "invalid-selector",
         "a render selector must be a semantic selector node",
@@ -9780,7 +10339,7 @@ function validateTileflowRenderSelectorConstraints(input) {
         }
         for (const [index, branch] of current.selector.branches.entries()) {
           const branchPath = [...branchesPath, index];
-          if (!isRecord7(branch)) {
+          if (!isRecord6(branch)) {
             addIssue("invalid-selector", "match selector branch must be an object", branchPath);
             continue;
           }
@@ -9811,14 +10370,14 @@ function validateTileflowRenderSelectorConstraints(input) {
         for (let index = current.selector.stops.length - 1; index >= 0; index -= 1) {
           const stop = current.selector.stops[index];
           const stopPath = [...stopsPath, index];
-          if (!isRecord7(stop)) {
+          if (!isRecord6(stop)) {
             addIssue("invalid-selector", "step selector stop must be an object", stopPath);
             continue;
           }
           pushChild(stop.selector, current.depth + 1, [...stopPath, "selector"]);
         }
         for (const [index, stop] of current.selector.stops.entries()) {
-          if (!isRecord7(stop)) continue;
+          if (!isRecord6(stop)) continue;
           const zoom3 = stop.zoom;
           const zoomPath = [...stopsPath, index, "zoom"];
           if (typeof zoom3 !== "number" || !Number.isFinite(zoom3) || zoom3 < 0 || zoom3 > 24) {
@@ -10138,12 +10697,12 @@ 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) {
-  if (!isRecord7(selector) || typeof selector.kind !== "string") {
+  if (!isRecord6(selector) || typeof selector.kind !== "string") {
     throw renderStackError(
       "invalid-selector",
       "A render selector must be a semantic selector node."
@@ -10346,7 +10905,7 @@ function requireRenderer(value) {
 function requirePlacement(value) {
   if (typeof value === "string") {
     if (tileflowBandPlacements.includes(value)) return;
-  } else if (isRecord7(value)) {
+  } else if (isRecord6(value)) {
     const keys = Object.keys(value);
     if (keys.length === 1 && (keys[0] === "above" || keys[0] === "below")) {
       requirePortableTarget(value[keys[0]], "render placement target");
@@ -10373,7 +10932,7 @@ function validateRefinementShape(operation) {
   validateStyle(operation.renderer, operation.style);
 }
 function validateStyle(renderer, style) {
-  if (!isRecord7(style)) {
+  if (!isRecord6(style)) {
     throw renderStackError(
       "invalid-style",
       `A ${renderer} render operation requires a style object.`
@@ -10475,7 +11034,7 @@ function normalizeRequirements(requirements) {
   return [...requirements];
 }
 function requireRenderStackEntries(stack) {
-  if (!isRecord7(stack)) {
+  if (!isRecord6(stack)) {
     throw renderStackError("invalid-stack", "A render stack must be a named operation record.");
   }
   const entries = Object.entries(stack);
@@ -10621,10 +11180,10 @@ function compareCodeUnits6(left, right) {
 function cloneJson21(value) {
   return JSON.parse(JSON.stringify(value));
 }
-function asRecord4(value) {
-  return isRecord7(value) ? value : {};
+function asRecord5(value) {
+  return isRecord6(value) ? value : {};
 }
-function isRecord7(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -10819,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";
@@ -10966,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.",
@@ -11120,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]);
@@ -11402,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(
@@ -11637,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(),
@@ -11668,12 +12240,43 @@ var buildingsModuleSchema = z5.object({
   mode: z5.enum(["3d", "flat"]).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()
+    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({
@@ -11852,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(),
@@ -11907,7 +12513,9 @@ 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(),
@@ -12044,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),
@@ -12147,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(),
@@ -12154,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"]),
@@ -12509,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) => {
@@ -12533,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
   );
@@ -12755,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;
@@ -12933,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,
@@ -12942,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([
@@ -13317,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 [
@@ -13372,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);
@@ -13395,25 +14070,26 @@ 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);
 }
 function semanticTarget(layer) {
-  if (!isRecord8(layer.metadata)) return void 0;
+  if (!isRecord7(layer.metadata)) return void 0;
   const value = layer.metadata[tileflowCompilerMetadataKeys.target];
   return typeof value === "string" ? value : void 0;
 }
-function isRecord8(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSafeArtifactName(value) {
@@ -14137,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],
@@ -14301,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",
@@ -14331,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(
@@ -14612,7 +15399,9 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   const buildings3D = tileflowBuildings3DDesignOf(
     modules.buildings,
     context,
-    layers
+    layers,
+    options.preparedAssets?.buildingModels,
+    data.kind === "tileflow-world" ? `${apiBaseUrl}/landmarks/tiles.json` : void 0
   );
   const streetLights = tileflowStreetLightsDesignOf(
     modules.roads,
@@ -14665,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) } : {},
@@ -14704,12 +15511,10 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
         [tileflowVegetationMetadataKey]: tileflowVegetationMetadata({
           ...bindSemanticReferences(vegetation3D, semanticData),
           // The layers that draw the trees flat: the module's own and its render passes.
-          flatLayers: layers.filter((layer) => {
-            const metadata = layer.metadata;
-            return metadata?.["tileflow:vegetation-mode"] !== void 0 || metadata?.["tileflow:domain"] === "vegetation";
-          }).map((layer) => String(layer.id))
+          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 } : {},
@@ -15090,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",
@@ -15149,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"] });
       }
@@ -15558,6 +16388,7 @@ var tileflowMapMergeStrategies = {
   systemThemes: "atomic",
   terrain: "atomic",
   themes: "atomic",
+  timeOfDay: "atomic",
   version: "identity",
   view: "deep"
 };
@@ -15572,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];
@@ -16350,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
         }
       ];
@@ -16513,8 +17348,8 @@ function normalizeSourceAssets(input) {
   }
   const models = [...input.models ?? []].map((model) => {
     assertSha256(model.sha256, `model ${model.id}`);
-    if (model.level !== "near" && model.level !== "far")
-      throw new Error(`Tileflow model ${model.id} is near or far.`);
+    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}`)
@@ -25296,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");
@@ -25314,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();
@@ -25726,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}[`)
@@ -25823,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),
@@ -25885,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();
@@ -26000,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({
@@ -26032,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"]),
@@ -26204,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 } : {}
         }
       ];
@@ -26211,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);
 }