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

package/dist/build.js

@@ -45,6 +45,112 @@ function compileTileflowSky(options) {
   };
 }
 
+// src/models-3d-model.ts
+var tileflowModelParts = Object.freeze({
+  surface: 0,
+  secondary: 1,
+  glass: 2,
+  accent: 3,
+  roof: 4
+});
+var tileflowModelLightingRoles = Object.freeze({
+  unclassified: 0,
+  wall: 1,
+  door: 2,
+  roof: 3,
+  window: 4,
+  lamp: 5,
+  logo: 6
+});
+var tileflowModelDefaultLightingRoles = Object.freeze([1, 1, 4, 1, 3]);
+var tileflowModelLimits = Object.freeze({
+  /** Levels of detail, nearest first. */
+  levels: 3,
+  /** Vertices of one level. */
+  vertices: 2e5,
+  /** Triangles of one level. */
+  triangles: 2e5,
+  /** Points of the footprint's rings, together. */
+  footprintPoints: 4096,
+  /** Half the model's widest extent, in metres. */
+  radius: 2e3,
+  /** The model's height, in metres. */
+  height: 1e3,
+  /** Models in one prepared file, as a landmark tile holds them. */
+  models: 512,
+  /** Bytes of one prepared file. */
+  bytes: 16 * 1024 * 1024
+});
+
+// src/building-illumination.ts
+var defaultBuildingFloodLight = Object.freeze({
+  intensity: 0,
+  brightnessScale: 1,
+  color: "#f5cfa8",
+  groundRadius: [30, 100],
+  minGroundHeight: 30,
+  minWallHeight: 200,
+  wallHeightRatio: 1 / 3
+});
+var defaultModelEmissionGradient = [0, 1, 1, 1, 0];
+function readBuildingFloodLight(value) {
+  if (!record(value)) return void 0;
+  const defaults4 = defaultBuildingFloodLight;
+  const radius = value.groundRadius;
+  return {
+    intensity: bounded(value.intensity, 0, 1, 0),
+    brightnessScale: bounded(value.brightnessScale, 0, 16, 1),
+    color: typeof value.color === "string" ? value.color : defaults4.color,
+    groundRadius: Array.isArray(radius) && radius.length === 2 && radius.every((v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 2048) && radius[0] <= radius[1] ? [radius[0], radius[1]] : defaults4.groundRadius,
+    minGroundHeight: bounded(value.minGroundHeight, 0, 6e3, defaults4.minGroundHeight),
+    minWallHeight: bounded(value.minWallHeight, 0, 6e3, defaults4.minWallHeight),
+    wallHeightRatio: bounded(value.wallHeightRatio, 0, 1, defaults4.wallHeightRatio)
+  };
+}
+function readModelRoleLighting(value) {
+  if (!record(value)) return void 0;
+  const result = {};
+  for (const role of Object.keys(tileflowModelLightingRoles)) {
+    const entry = value[role];
+    if (!record(entry)) continue;
+    const gradient = entry.emissiveHeight;
+    result[role] = {
+      emissiveStrength: bounded(entry.emissiveStrength, 0, 5, 0),
+      ...entry.emissiveVariation === void 0 ? {} : { emissiveVariation: bounded(entry.emissiveVariation, 0, 1, 0) },
+      ...typeof entry.emissiveColor === "string" ? { emissiveColor: entry.emissiveColor } : {},
+      ...typeof entry.color === "string" ? { color: entry.color } : {},
+      ...entry.colorMix === void 0 ? {} : { colorMix: bounded(entry.colorMix, 0, 1, 1) },
+      ...entry.metallic === void 0 ? {} : { metallic: bounded(entry.metallic, 0, 1, 0) },
+      ...entry.roughness === void 0 ? {} : { roughness: bounded(entry.roughness, 0, 1, 1) },
+      ...readRoleColorVariation(entry.colorVariation),
+      emissiveHeight: Array.isArray(gradient) && gradient.length === 5 && gradient.every(
+        (v, i) => typeof v === "number" && Number.isFinite(v) && v <= 1 && v >= (i === 4 ? -1 : 0)
+      ) ? gradient : defaultModelEmissionGradient
+    };
+  }
+  return Object.keys(result).length ? result : void 0;
+}
+function readRoleColorVariation(value) {
+  if (!record(value)) return {};
+  for (const [key, max] of [
+    ["hue", 360],
+    ["saturation", 100],
+    ["lightness", 100]
+  ]) {
+    const range2 = value[key];
+    if (!Array.isArray(range2) || range2.length !== 2 || range2[0] > range2[1] || !range2.every((v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= max))
+      return {};
+  }
+  if (value.space !== void 0 && value.space !== "srgb" && value.space !== "linear") return {};
+  return { colorVariation: value };
+}
+function bounded(value, min, max, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= min && value <= max ? value : fallback;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/buildings-3d-design.ts
 var tileflowBuildingsMetadataKey = "tileflow:buildings";
 var tileflowDefaultBuildings3DDesign = Object.freeze({
@@ -59,11 +165,22 @@ var tileflowDefaultBuildings3DDesign = Object.freeze({
   nightLight: 0,
   windows: false,
   shadows: true,
-  occlusion: true
+  occlusion: true,
+  modelOcclusion: 0.75
 });
 function tileflowBuildingsMetadata(design) {
   return { version: 1, ...design };
 }
+function readTileflowBuildingsEntrance(value) {
+  if (!isRecord(value)) return {};
+  const band = (entry) => Array.isArray(entry) && entry.length === 2 && entry.every((zoom3) => typeof zoom3 === "number" && zoom3 >= 0 && zoom3 <= 24) && entry[0] < entry[1] ? [entry[0], entry[1]] : void 0;
+  const buildings2 = band(value.buildings);
+  const models = band(value.models);
+  return buildings2 || models ? { entrance: { ...buildings2 ? { buildings: buildings2 } : {}, ...models ? { models } : {} } } : {};
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // src/data/world-generation.ts
 var tileflowWorldGeneration = "v1";
@@ -183,26 +300,26 @@ var canonicalFields = {
 };
 var worldAttribution = '<a href="https://tileflow.dev/copyright">\xA9 Tileflow</a> <a href="https://www.openmaptiles.org/">\xA9 OpenMapTiles</a> <a href="https://www.openstreetmap.org/copyright">\xA9 OpenStreetMap</a>';
 function openMapTiles(options = {}) {
-  const layers = { ...canonicalLayers, ...options.layers };
-  const fields = { ...canonicalFields, ...options.fields };
-  if (options.capabilities?.businessCorridor === false) delete layers.businessCorridor;
+  const layers2 = { ...canonicalLayers, ...options.layers };
+  const fields2 = { ...canonicalFields, ...options.fields };
+  if (options.capabilities?.businessCorridor === false) delete layers2.businessCorridor;
   if (options.capabilities?.bathymetry === true) {
-    layers.bathymetry ??= "bathymetry";
-    fields.bathymetryMinDepth ??= "min_depth";
-    fields.bathymetrySortKey ??= "sort_key";
+    layers2.bathymetry ??= "bathymetry";
+    fields2.bathymetryMinDepth ??= "min_depth";
+    fields2.bathymetrySortKey ??= "sort_key";
   } else {
-    delete layers.bathymetry;
-    delete fields.bathymetryMinDepth;
-    delete fields.bathymetrySortKey;
+    delete layers2.bathymetry;
+    delete fields2.bathymetryMinDepth;
+    delete fields2.bathymetrySortKey;
   }
-  if (options.capabilities?.canopy === false) delete layers.canopy;
-  if (options.capabilities?.globalLandcover === false) delete layers.globalLandcover;
-  if (options.capabilities?.tree === false) delete layers.tree;
+  if (options.capabilities?.canopy === false) delete layers2.canopy;
+  if (options.capabilities?.globalLandcover === false) delete layers2.globalLandcover;
+  if (options.capabilities?.tree === false) delete layers2.tree;
   return {
     type: "openmaptiles",
     contractVersion: openMapTilesContractVersion,
-    fields,
-    layers,
+    fields: fields2,
+    layers: layers2,
     semantics: {
       parkLayer: options.semantics?.parkLayer ?? "mixed"
     }
@@ -228,6 +345,7 @@ function tileflowWorldV1Schema(options = {}) {
       sidewalk: "sidewalk",
       streetFurniture: "street_furniture",
       trafficControl: "traffic_control",
+      transportationOutline: "transportation_outline",
       ...options.layers
     },
     semantics: { ...options.semantics, parkLayer: "protected-only" }
@@ -496,25 +614,25 @@ function inferTileflowDataRequirements(style, options = {}) {
   for (const [index, layer] of (style.layers ?? []).entries()) {
     if (layer.source !== sourceId || typeof layer["source-layer"] !== "string") continue;
     const sourceLayer = layer["source-layer"];
-    const fields = getOrCreate(fieldsByLayer, sourceLayer);
+    const fields2 = getOrCreate(fieldsByLayer, sourceLayer);
     const filter = layer.filter === void 0 ? void 0 : convertFilter(layer.filter);
-    collectFieldAccesses(filter, fields, dynamicAccesses, `layers[${index}].filter`);
+    collectFieldAccesses(filter, fields2, dynamicAccesses, `layers[${index}].filter`);
     for (const key of ["layout", "paint"]) {
-      collectFieldAccesses(layer[key], fields, dynamicAccesses, `layers[${index}].${key}`);
+      collectFieldAccesses(layer[key], fields2, dynamicAccesses, `layers[${index}].${key}`);
     }
   }
   for (const requirement of options.additional ?? []) {
     requirePortableName(requirement.id, "additional source layer");
-    const fields = getOrCreate(fieldsByLayer, requirement.id);
+    const fields2 = getOrCreate(fieldsByLayer, requirement.id);
     for (const field2 of requirement.fields) {
       requirePortableName(field2.name, `additional field on ${requirement.id}`);
-      const existing = fields.get(field2.name);
+      const existing = fields2.get(field2.name);
       if (existing !== void 0 && field2.type !== void 0 && existing !== field2.type) {
         throw new TypeError(
           `Conflicting manual data types for ${requirement.id}.${field2.name}: ${existing} and ${field2.type}.`
         );
       }
-      fields.set(field2.name, field2.type ?? existing);
+      fields2.set(field2.name, field2.type ?? existing);
     }
   }
   return {
@@ -522,8 +640,8 @@ function inferTileflowDataRequirements(style, options = {}) {
     dynamicAccesses: [...dynamicAccesses].sort(compareCodeUnits),
     schemaVersion: 1,
     sourceId,
-    sourceLayers: [...fieldsByLayer].sort(([left], [right]) => compareCodeUnits(left, right)).map(([id2, fields]) => ({
-      fields: [...fields].sort(([left], [right]) => compareCodeUnits(left, right)).map(([name, type]) => ({ name, ...type === void 0 ? {} : { type } })),
+    sourceLayers: [...fieldsByLayer].sort(([left], [right]) => compareCodeUnits(left, right)).map(([id2, fields2]) => ({
+      fields: [...fields2].sort(([left], [right]) => compareCodeUnits(left, right)).map(([name, type]) => ({ name, ...type === void 0 ? {} : { type } })),
       id: id2
     }))
   };
@@ -598,40 +716,40 @@ function validateTileflowDataCompatibility(requirements, contract) {
   }
   return issues;
 }
-function collectFieldAccesses(value, fields, dynamicAccesses, path) {
+function collectFieldAccesses(value, fields2, dynamicAccesses, path) {
   if (Array.isArray(value)) {
     const operator = value[0];
     if (operator === "literal") return;
     if (operator === "get" || operator === "has") {
       const featureProperties = value.length === 2 || isPropertiesExpression(value[2]);
       if (featureProperties) {
-        if (typeof value[1] === "string") fields.set(value[1], fields.get(value[1]));
+        if (typeof value[1] === "string") fields2.set(value[1], fields2.get(value[1]));
         else dynamicAccesses.add(`${path}[1]`);
       }
       if (typeof value[1] !== "string") {
-        collectFieldAccesses(value[1], fields, dynamicAccesses, `${path}[1]`);
+        collectFieldAccesses(value[1], fields2, dynamicAccesses, `${path}[1]`);
       }
       if (!featureProperties) {
-        collectFieldAccesses(value[2], fields, dynamicAccesses, `${path}[2]`);
+        collectFieldAccesses(value[2], fields2, dynamicAccesses, `${path}[2]`);
       }
       for (let index = 3; index < value.length; index += 1) {
-        collectFieldAccesses(value[index], fields, dynamicAccesses, `${path}[${index}]`);
+        collectFieldAccesses(value[index], fields2, dynamicAccesses, `${path}[${index}]`);
       }
       return;
     }
     if (operator === "properties") dynamicAccesses.add(path);
     for (let index = 1; index < value.length; index += 1) {
-      collectFieldAccesses(value[index], fields, dynamicAccesses, `${path}[${index}]`);
+      collectFieldAccesses(value[index], fields2, dynamicAccesses, `${path}[${index}]`);
     }
     return;
   }
   if (!value || typeof value !== "object") return;
-  const record3 = value;
-  if (typeof record3.property === "string" && Array.isArray(record3.stops)) {
-    fields.set(record3.property, fields.get(record3.property));
+  const record4 = value;
+  if (typeof record4.property === "string" && Array.isArray(record4.stops)) {
+    fields2.set(record4.property, fields2.get(record4.property));
   }
-  for (const [key, child] of Object.entries(record3)) {
-    collectFieldAccesses(child, fields, dynamicAccesses, `${path}.${key}`);
+  for (const [key, child] of Object.entries(record4)) {
+    collectFieldAccesses(child, fields2, dynamicAccesses, `${path}.${key}`);
   }
 }
 function isPropertiesExpression(value) {
@@ -1002,26 +1120,26 @@ function toMapLibreStyleValue(value) {
   return cloneJson2(value);
 }
 function isTileflowExpression(value) {
-  return isRecord(value) && value.kind === "expression" && Array.isArray(value.value);
+  return isRecord2(value) && value.kind === "expression" && Array.isArray(value.value);
 }
 function isTileflowZoomValue(value) {
-  return isRecord(value) && value.kind === "zoom" && Array.isArray(value.stops);
+  return isRecord2(value) && value.kind === "zoom" && Array.isArray(value.stops);
 }
 function isTileflowThemeTokenReference(value) {
-  return isRecord(value) && hasExactOwnKeys(value, ["category", "kind", "token"]) && value.kind === "theme-token" && typeof value.token === "string" && /^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)*$/.test(value.token) && tileflowThemeTokenCategories.includes(value.category);
+  return isRecord2(value) && hasExactOwnKeys(value, ["category", "kind", "token"]) && value.kind === "theme-token" && typeof value.token === "string" && /^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)*$/.test(value.token) && tileflowThemeTokenCategories.includes(value.category);
 }
 function isTileflowFixedValue(value) {
-  return isRecord(value) && hasExactOwnKeys(value, ["kind", "reason", "value"]) && value.kind === "theme-fixed" && typeof value.reason === "string" && Boolean(value.reason.trim()) && Object.hasOwn(value, "value");
+  return isRecord2(value) && hasExactOwnKeys(value, ["kind", "reason", "value"]) && value.kind === "theme-fixed" && typeof value.reason === "string" && Boolean(value.reason.trim()) && Object.hasOwn(value, "value");
 }
 function isTileflowThemeColorOperation(value) {
-  if (!isRecord(value) || value.kind !== "theme-color") return false;
+  if (!isRecord2(value) || value.kind !== "theme-color") return false;
   if (value.operation === "alpha") {
     return hasExactOwnKeys(value, ["color", "kind", "opacity", "operation"]) && Object.hasOwn(value, "color") && Object.hasOwn(value, "opacity");
   }
   return value.operation === "mix" && hasExactOwnKeys(value, ["amount", "from", "kind", "operation", "space", "to"]) && value.space === "oklch" && Object.hasOwn(value, "amount") && Object.hasOwn(value, "from") && Object.hasOwn(value, "to");
 }
 function isTileflowThemeValueNode(value) {
-  return isRecord(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
+  return isRecord2(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
 }
 function createZoomValue(interpolation, stops, base) {
   if (stops.length === 0) {
@@ -1061,7 +1179,7 @@ function cloneJson2(value) {
   }
   return JSON.parse(serialized);
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function hasExactOwnKeys(value, expectedKeys) {
@@ -1094,7 +1212,7 @@ function applyLineStyle(layer, style) {
   const layout = { ...asRecord(layer.layout) };
   setPaint(paint, "line-blur", style.blur);
   setPaint(paint, "line-color", style.color);
-  setPaint(paint, "line-dasharray", style.dash);
+  if (!isSolidDash(style.dash)) setPaint(paint, "line-dasharray", style.dash);
   setPaint(paint, "line-gap-width", style.gapWidth);
   setPaint(paint, "line-offset", style.offset);
   setPaint(paint, "line-opacity", style.opacity);
@@ -1237,20 +1355,20 @@ function applySymbolStyle(layer, style) {
   return applyLayerRange(result, range2);
 }
 function createAreaLayers(base, style) {
-  const layers = [];
+  const layers2 = [];
   if (style.fill && style.fill.visible !== false) {
-    layers.push({
+    layers2.push({
       layer: applyFillStyle({ ...base, type: "fill" }, style.fill),
       phase: "fill"
     });
   }
   if (style.outline && style.outline.visible !== false) {
-    layers.push({
+    layers2.push({
       layer: applyLineStyle({ ...base, id: `${base.id}-outline`, type: "line" }, style.outline),
       phase: "outline"
     });
   }
-  return layers;
+  return layers2;
 }
 function applyCircleStyle(layer, style) {
   const paint = { ...asRecord(layer.paint) };
@@ -1338,6 +1456,12 @@ function withoutGovernedAllowOverlap(layout) {
   }
   return result;
 }
+function isSolidDash(value) {
+  if (value === void 0) return false;
+  const dash = toMapLibreStyleValue(value);
+  const array = Array.isArray(dash) && dash[0] === "literal" ? dash[1] : dash;
+  return Array.isArray(array) && array.length === 2 && array[0] === 1 && array[1] === 0;
+}
 function setPaint(paint, property, value) {
   if (value !== void 0) paint[property] = toMapLibreStyleValue(value);
 }
@@ -1382,10 +1506,10 @@ function mergeTileflowDesign(base, ...overlays) {
 }
 function mergeValue(base, overlay) {
   if (overlay === void 0) return cloneJson3(base);
-  if (Array.isArray(overlay) || isTileflowExpression(overlay) || isTileflowThemeValueNode(overlay) || isTileflowZoomValue(overlay) || !isRecord2(overlay)) {
+  if (Array.isArray(overlay) || isTileflowExpression(overlay) || isTileflowThemeValueNode(overlay) || isTileflowZoomValue(overlay) || !isRecord3(overlay)) {
     return cloneJson3(overlay);
   }
-  const baseRecord = isRecord2(base) ? base : {};
+  const baseRecord = isRecord3(base) ? base : {};
   const result = {};
   for (const key of /* @__PURE__ */ new Set([...Object.keys(baseRecord), ...Object.keys(overlay)])) {
     const overlayValue = overlay[key];
@@ -1401,7 +1525,7 @@ function cloneJson3(value) {
   if (value === void 0) return value;
   return JSON.parse(JSON.stringify(value));
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -1860,22 +1984,37 @@ function compileBuildings(request, context) {
   }
   return contributions;
 }
+var buildingTargetsByMode = {
+  flat: ["buildings.flat.fill", "buildings.flat.outline"],
+  "3d": ["buildings.extrusion"]
+};
+function buildingTargetsOfOtherModes(request) {
+  const activeMode = request?.mode ?? "flat";
+  const targets = /* @__PURE__ */ new Map();
+  for (const [mode, modeTargets] of Object.entries(buildingTargetsByMode)) {
+    if (mode === activeMode) continue;
+    for (const target of modeTargets) {
+      targets.set(target, { activeMode, mode, owner: "buildings" });
+    }
+  }
+  return targets;
+}
 function buildingColorExpression(context) {
-  const fields = context.data.schema.fields;
+  const fields2 = context.data.schema.fields;
   const colors = context.colors.buildings;
   return [
     "case",
-    ["==", ["coalesce", ["get", fields.buildingTone], ""], "active"],
+    ["==", ["coalesce", ["get", fields2.buildingTone], ""], "active"],
     colors.active,
-    ["==", ["coalesce", ["get", fields.buildingTone], ""], "destination"],
+    ["==", ["coalesce", ["get", fields2.buildingTone], ""], "destination"],
     colors.destination,
-    ["==", ["coalesce", ["get", fields.buildingTone], ""], "commercial"],
+    ["==", ["coalesce", ["get", fields2.buildingTone], ""], "commercial"],
     colors.commercial,
     // 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], ""],
+      ["coalesce", ["get", fields2.class], ""],
       "residential",
       colors.residential,
       "commercial",
@@ -1899,7 +2038,7 @@ function businessCorridorVisibilityFilter(context) {
   ];
 }
 function buildingHeightExpression(context) {
-  const fields = context.data.schema.fields;
+  const fields2 = context.data.schema.fields;
   return [
     "max",
     0,
@@ -1907,7 +2046,7 @@ function buildingHeightExpression(context) {
       "to-number",
       [
         "coalesce",
-        ["get", fields.renderHeight],
+        ["get", fields2.renderHeight],
         // V8.14 materializes this fallback in the tile. Keep the defensive
         // value only for malformed or legacy third-party sources.
         5
@@ -1917,11 +2056,11 @@ function buildingHeightExpression(context) {
   ];
 }
 function buildingBaseExpression(context, height) {
-  const fields = context.data.schema.fields;
+  const fields2 = context.data.schema.fields;
   return [
     "max",
     0,
-    ["min", ["to-number", ["coalesce", ["get", fields.renderMinHeight], 0], 0], height]
+    ["min", ["to-number", ["coalesce", ["get", fields2.renderMinHeight], 0], 0], height]
   ];
 }
 
@@ -1976,30 +2115,24 @@ var tileflowRoadConstructionClasses = [
 function isTileflowPathRoadClass(roadClass) {
   return tileflowPathRoadClasses.includes(roadClass);
 }
-function tileflowRoadClassFilter(fields, roadClass) {
+function tileflowRoadClassFilter(fields2, roadClass) {
+  const classes = tileflowRoadClassValues(roadClass);
   if (isTileflowPathRoadClass(roadClass)) {
     return [
       "all",
-      ["match", ["get", fields.class], ["path", ...constructionClasses[roadClass]], true, false],
-      ["match", ["get", fields.subclass], pathSubclasses[roadClass], true, false]
+      ["match", ["get", fields2.class], classes, true, false],
+      ["match", ["get", fields2.subclass], pathSubclasses[roadClass], true, false]
     ];
   }
-  const classes = roadClass === "minor" ? [
-    "minor",
-    "residential",
-    "unclassified",
-    ...compatibleRoadClasses[roadClass] ?? [],
-    ...constructionClasses[roadClass]
-  ] : roadClass === "service" ? [
-    "service",
-    ...compatibleRoadClasses[roadClass] ?? [],
-    ...constructionClasses[roadClass]
-  ] : [
-    roadClass,
+  return ["match", ["get", fields2.class], classes, true, false];
+}
+function tileflowRoadClassValues(roadClass) {
+  if (isTileflowPathRoadClass(roadClass)) return ["path", ...constructionClasses[roadClass]];
+  return [
+    ...roadClass === "minor" ? ["minor", "residential", "unclassified"] : [roadClass],
     ...compatibleRoadClasses[roadClass] ?? [],
     ...constructionClasses[roadClass]
   ];
-  return ["match", ["get", fields.class], classes, true, false];
 }
 
 // src/modules/roads/index.ts
@@ -2157,25 +2290,25 @@ function labelNameFields(language, context) {
   return labelFieldExpression(language, context).slice(1).map((entry) => entry[1]);
 }
 function labelFieldExpression(language, context) {
-  const fields = context.data.schema.fields;
+  const fields2 = context.data.schema.fields;
   if (language === "local") {
     return [
       "coalesce",
-      ["get", fields.name],
-      ["get", fields.nameLatin],
-      ["get", fields.nameEnglish]
+      ["get", fields2.name],
+      ["get", fields2.nameLatin],
+      ["get", fields2.nameEnglish]
     ];
   }
   if (language === "auto") {
     return [
       "coalesce",
-      ["get", fields.nameLatin],
-      ["get", fields.name],
-      ["get", fields.nameEnglish]
+      ["get", fields2.nameLatin],
+      ["get", fields2.name],
+      ["get", fields2.nameEnglish]
     ];
   }
-  const requestedField = language === "en" ? fields.nameEnglish : `name:${language}`;
-  return ["coalesce", ["get", requestedField], ["get", fields.nameLatin], ["get", fields.name]];
+  const requestedField = language === "en" ? fields2.nameEnglish : `name:${language}`;
+  return ["coalesce", ["get", requestedField], ["get", fields2.nameLatin], ["get", fields2.name]];
 }
 
 // src/modules/labels/compiler.ts
@@ -2712,8 +2845,8 @@ function classFilter(field2, classes) {
 function aerodromeLabelExpression(detail, language, context) {
   const name = labelFieldExpression(language, context);
   if (detail === "none") return name;
-  const fields = context.data.schema.fields;
-  const code = detail === "all" ? ["coalesce", ["get", fields.iata], ["get", fields.icao], ""] : ["coalesce", ["get", fields.iata], ""];
+  const fields2 = context.data.schema.fields;
+  const code = detail === "all" ? ["coalesce", ["get", fields2.iata], ["get", fields2.icao], ""] : ["coalesce", ["get", fields2.iata], ""];
   return [
     "case",
     ["!=", ["to-string", code], ""],
@@ -2801,8 +2934,8 @@ function placePriority(rankField, base, capitals = false, capitalField = "capita
 function capitalFilter(capitalField) {
   return [">", ["to-number", ["get", capitalField], 0], 0];
 }
-function roadClassesFilter(fields, roadClasses) {
-  return roadClasses.length === 1 ? tileflowRoadClassFilter(fields, roadClasses[0]) : ["any", ...roadClasses.map((roadClass) => tileflowRoadClassFilter(fields, roadClass))];
+function roadClassesFilter(fields2, roadClasses) {
+  return roadClasses.length === 1 ? tileflowRoadClassFilter(fields2, roadClasses[0]) : ["any", ...roadClasses.map((roadClass) => tileflowRoadClassFilter(fields2, roadClass))];
 }
 function symbolContribution(target, localOrder, layer, slot = "symbols", family) {
   return {
@@ -3251,11 +3384,11 @@ function compileLandforms(request, language, context) {
     ];
   });
 }
-function landformFilter(fields, classes) {
-  const classFilter4 = classes.length === 1 ? ["==", ["get", fields.class], classes[0]] : ["match", ["get", fields.class], classes, true, false];
+function landformFilter(fields2, classes) {
+  const classFilter4 = classes.length === 1 ? ["==", ["get", fields2.class], classes[0]] : ["match", ["get", fields2.class], classes, true, false];
   const classZoom = [
     "match",
-    ["get", fields.class],
+    ["get", fields2.class],
     "volcano",
     [">=", ["zoom"], 9],
     "peak",
@@ -3269,10 +3402,10 @@ function landformFilter(fields, classes) {
   return [
     "all",
     ["==", ["geometry-type"], "Point"],
-    ["has", fields.name],
+    ["has", fields2.name],
     classFilter4,
     classZoom,
-    ["<=", ["to-number", ["get", fields.rank], 99], ["step", ["zoom"], 3, 12, 10, 14, 99]]
+    ["<=", ["to-number", ["get", fields2.rank], 99], ["step", ["zoom"], 3, 12, 10, 14, 99]]
   ];
 }
 function landformContribution(target, localOrder, layer) {
@@ -3287,6 +3420,25 @@ function landformContribution(target, localOrder, layer) {
 }
 
 // src/modules/nautical/index.ts
+var tileflowNauticalImageRoles = Object.freeze({
+  aids: Object.freeze({ default: "nautical.aid" }),
+  beacons: Object.freeze({ default: "nautical.beacon" }),
+  buoys: Object.freeze({
+    cardinal: "nautical.buoy.cardinal",
+    default: "nautical.buoy",
+    port: "nautical.buoy.port",
+    starboard: "nautical.buoy.starboard"
+  }),
+  harbours: Object.freeze({ default: "nautical.harbour" }),
+  lighthouses: Object.freeze({ default: "nautical.lighthouse" }),
+  lights: Object.freeze({ default: "nautical.light" }),
+  ports: Object.freeze({ default: "nautical.port" }),
+  wrecks: Object.freeze({ default: "nautical.wreck" })
+});
+var tileflowNauticalNotice = Object.freeze({
+  id: "nautical-not-for-navigation",
+  text: "Not for navigation"
+});
 function nautical(options = {}) {
   return { type: "nautical", ...cloneJson11(options) };
 }
@@ -3332,30 +3484,51 @@ var tileflowBathymetryV1Schema = Object.freeze({
 });
 var tileflowNauticalV1Schema = Object.freeze({
   fields: Object.freeze({
+    category: "category",
     cell: "cell",
     character: "character",
     class: "class",
     color: "color",
+    colorPattern: "color_pattern",
+    country: "country",
     coverage: "coverage",
     depth: "depth",
-    direction: "direction",
     edition: "edition",
+    families: "families",
+    group: "group",
+    heightM: "height_m",
+    label: "label",
     licence: "licence",
+    lit: "lit",
+    minZoom: "min_zoom",
     name: "name",
-    provider: "provider",
+    orientation: "orientation",
+    periodS: "period_s",
+    position: "position",
     provenance: "provenance",
-    quality: "quality",
+    provider: "provider",
     rangeNm: "range_nm",
+    rank: "rank",
+    reference: "reference",
+    restriction: "restriction",
     scale: "scale",
+    sectorEnd: "sector_end",
+    sectorStart: "sector_start",
+    shape: "shape",
+    size: "size",
     subclass: "subclass",
-    update: "update"
+    system: "system",
+    topmark: "topmark",
+    unlocode: "unlocode",
+    update: "update",
+    waterLevel: "water_level"
   }),
   geometryTypes: Object.freeze({
     aids: Object.freeze(["Point"]),
     coverage: Object.freeze(["Polygon"]),
-    hazards: Object.freeze(["Point", "Polygon"]),
+    hazards: Object.freeze(["Point", "LineString", "Polygon"]),
     lights: Object.freeze(["Point"]),
-    navigationAreas: Object.freeze(["Polygon"]),
+    navigationAreas: Object.freeze(["Point", "LineString", "Polygon"]),
     reefs: Object.freeze(["Polygon"]),
     soundings: Object.freeze(["Point"]),
     wrecks: Object.freeze(["Point", "Polygon"])
@@ -3526,490 +3699,832 @@ function cloneJson12(value) {
 }
 
 // src/modules/nautical/compiler.ts
+var { fields, layers } = tileflowNauticalV1Schema;
+var markColours = Object.freeze({
+  amber: "#F2A10A",
+  black: "#1F2328",
+  blue: "#2D6CDF",
+  brown: "#8A5A2E",
+  green: "#1E9E57",
+  grey: "#8C939A",
+  magenta: "#C2398F",
+  orange: "#EF7D1A",
+  pink: "#EE8AB8",
+  red: "#D3313A",
+  violet: "#8456C9",
+  white: "#FFFFFF",
+  yellow: "#F5C518"
+});
+var lightColours = Object.freeze({
+  ...markColours,
+  white: "#F7D046"
+});
+var floatingAidClasses = ["buoy", "light-float", "light-vessel"];
+var fixedAidClasses = ["beacon", "daymark"];
+var portLateralCategories = ["port", "preferred-channel-port", "waterway-left"];
+var starboardLateralCategories = [
+  "preferred-channel-starboard",
+  "starboard",
+  "waterway-right"
+];
+var exposedWaterLevels = ["above-mean-water", "awash", "covers", "dry"];
+var dangerousWreckClasses = ["dangerous", "hull-showing", "mast-showing"];
+var operationalAreaClasses = [
+  "anchor-berth",
+  "anchorage",
+  "dumping-ground",
+  "military",
+  "restricted",
+  "traffic-separation"
+];
+var routeClasses = ["route", "traffic-separation"];
+var cableClasses = ["cable", "cable-area", "pipeline", "pipeline-area"];
+var portSizes = ["large", "medium", "small", "very-small"];
 function compileNautical(request, context) {
   const nauticalSource = context.marine?.nautical;
   if (!nauticalSource || request?.enabled === false) return [];
   const colors = context.colors;
-  const { fields, layers } = tileflowNauticalV1Schema;
+  const ink = colors.hydro.label;
+  const halo = colors.hydro.water;
+  const accent = colors.poi.transport;
   const chartText = {
     ...typographyTextStyle(context.typography.water),
-    color: colors.hydro.label,
-    haloColor: colors.hydro.water,
+    color: ink,
+    haloColor: halo,
     haloWidth: 1.2
   };
-  const config = mergeTileflowDesign(
-    {
-      type: "nautical",
-      enabled: true,
-      soundings: {
-        minZoom: 12,
-        placement: "point",
-        priority: 92,
+  const markText = {
+    ...typographyTextStyle(context.typography.poi),
+    color: ink,
+    haloColor: halo,
+    haloWidth: 1.2,
+    transform: "none"
+  };
+  const images = themedImages(context);
+  const rankPriority = {
+    priority: expression(["coalesce", ["get", fields.rank], 9]),
+    priorityOrder: "lower-first"
+  };
+  const nameFrom = (minZoom) => expression(["step", ["zoom"], "", minZoom, ["coalesce", ["get", fields.name], ""]]);
+  const sideLabel = { anchor: "left", offset: [0.85, 0], optional: true };
+  const belowLabel = { anchor: "top", offset: [0, 0.75], optional: true };
+  const markColour = expression(colourMatch(firstColour(fields.color), markColours, ink));
+  const markStroke = expression(colourMatch(secondColour(fields.color), markColours, ink));
+  const flareColour = expression(
+    colourMatch(firstColour(fields.color), lightColours, lightColours.white)
+  );
+  const iconPaint = { color: markColour, haloColor: ink, haloWidth: 1 };
+  const defaults4 = {
+    type: "nautical",
+    enabled: true,
+    // Coverage cells are square tiles; a faint seamless tint before marks appear avoids a grid.
+    coverage: {
+      fill: {
+        antialias: false,
+        color: ink,
+        maxZoom: 8,
+        opacity: zoom.linear([
+          [0, 0.06],
+          [5, 0.045],
+          [8, 0]
+        ])
+      }
+    },
+    navigationAreas: {
+      fill: {
+        color: accent,
+        minZoom: 7,
+        opacity: expression([
+          "match",
+          ["get", fields.class],
+          "traffic-separation",
+          0.08,
+          ["military", "restricted", "dumping-ground"],
+          0.05,
+          0
+        ])
+      },
+      outline: {
+        color: expression([
+          "match",
+          ["get", fields.class],
+          [...operationalAreaClasses],
+          accent,
+          ink
+        ]),
+        dash: [4, 2],
+        minZoom: 7,
+        opacity: expression([
+          "interpolate",
+          ["linear"],
+          ["zoom"],
+          7,
+          ["match", ["get", fields.class], [...operationalAreaClasses], 0.55, 0],
+          10,
+          ["match", ["get", fields.class], [...operationalAreaClasses], 0.75, 0],
+          12,
+          ["match", ["get", fields.class], [...operationalAreaClasses], 0.85, 0.4]
+        ]),
+        width: zoom.linear([
+          [7, 0.6],
+          [14, 1.2]
+        ])
+      }
+    },
+    reefs: {
+      fill: { color: colors.landcover.sand, minZoom: 6, opacity: 0.32 },
+      outline: { color: ink, dash: [1.5, 1.5], minZoom: 6, opacity: 0.6, width: 0.8 }
+    },
+    cables: {
+      color: accent,
+      dash: [2, 2],
+      minZoom: 8,
+      opacity: zoom.linear([
+        [8, 0.3],
+        [12, 0.6]
+      ]),
+      width: zoom.linear([
+        [8, 0.6],
+        [14, 1]
+      ])
+    },
+    routes: {
+      color: expression([
+        "match",
+        ["get", fields.class],
+        "traffic-separation",
+        accent,
+        ink
+      ]),
+      dash: [5, 3],
+      minZoom: 8,
+      opacity: 0.72,
+      width: zoom.linear([
+        [8, 0.6],
+        [14, 1.3]
+      ])
+    },
+    hazardAreas: {
+      fill: { color: accent, minZoom: 10, opacity: 0.08 },
+      outline: { color: accent, dash: [1, 1], minZoom: 10, opacity: 0.7, width: 0.8 }
+    },
+    wreckAreas: {
+      fill: { color: ink, minZoom: 11, opacity: 0.08 },
+      outline: { color: ink, dash: [2, 1], minZoom: 11, opacity: 0.6, width: 0.75 }
+    },
+    soundings: {
+      minZoom: 12,
+      placement: "point",
+      text: {
+        ...chartText,
+        allowOverlap: false,
+        field: expression(["to-string", ["get", fields.depth]]),
+        optional: false,
+        padding: 5,
+        size: zoom.linear([
+          [12, 9],
+          [16, 11]
+        ]),
+        transform: "none"
+      }
+    },
+    hazards: {
+      minZoom: 8,
+      placement: "point",
+      marker: {
+        color: expression([
+          "match",
+          ["get", fields.class],
+          "offshore-platform",
+          ink,
+          "rgba(0, 0, 0, 0)"
+        ]),
+        radius: zoom.linear([
+          [8, 2.2],
+          [16, 3.6]
+        ]),
+        strokeColor: ink,
+        strokeWidth: 1.1
+      },
+      text: {
+        ...markText,
+        field: expression([
+          "match",
+          ["get", fields.waterLevel],
+          [...exposedWaterLevels],
+          "*",
+          "+"
+        ]),
+        haloWidth: 1,
+        offset: expression([
+          "match",
+          ["get", fields.waterLevel],
+          [...exposedWaterLevels],
+          ["literal", [0, 0.25]],
+          ["literal", [0, 0]]
+        ]),
+        optional: false,
+        padding: 1,
+        size: zoom.linear([
+          [12, 11],
+          [16, 14]
+        ])
+      }
+    },
+    wrecks: {
+      minZoom: 11,
+      placement: "point",
+      ...images.wrecks ? {
+        icon: {
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.wrecks,
+          opacity: expression([
+            "match",
+            ["get", fields.class],
+            [...dangerousWreckClasses],
+            1,
+            0.65
+          ]),
+          size: zoom.linear([
+            [11, 1],
+            [16, 1.4]
+          ])
+        },
+        text: { ...markText, ...sideLabel, field: nameFrom(14), padding: 4, size: 9 }
+      } : {
         text: {
-          ...chartText,
-          allowOverlap: false,
-          field: expression(["to-string", ["get", fields.depth]]),
+          ...markText,
+          color: expression([
+            "match",
+            ["get", fields.class],
+            [...dangerousWreckClasses],
+            accent,
+            ink
+          ]),
+          field: "Wk",
           optional: false,
-          padding: 5,
+          padding: 3,
+          size: 10
+        }
+      }
+    },
+    harbours: {
+      minZoom: 11,
+      placement: "point",
+      ...images.harbours ? {
+        icon: {
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.harbours,
           size: zoom.linear([
-            [12, 9],
-            [16, 11]
+            [11, 0.9],
+            [16, 1.3]
           ])
         }
+      } : {
+        marker: {
+          color: ink,
+          radius: zoom.linear([
+            [11, 2.2],
+            [16, 3.6]
+          ]),
+          strokeColor: halo,
+          strokeWidth: 1
+        }
       },
-      aids: {
-        minZoom: 10,
-        placement: "point",
-        priority: 98,
+      text: { ...markText, ...belowLabel, field: nameFrom(12), padding: 4, size: 10 }
+    },
+    aids: {
+      minZoom: 11,
+      placement: "point",
+      ...rankPriority,
+      ...images.aids ? {
+        icon: {
+          ...iconPaint,
+          image: images.aids,
+          size: zoom.linear([
+            [11, 0.8],
+            [16, 1.2]
+          ])
+        }
+      } : {
         marker: {
-          color: colors.hydro.water,
+          color: halo,
           radius: zoom.linear([
-            [10, 2.6],
-            [16, 4.2]
+            [11, 1.8],
+            [16, 3]
           ]),
-          strokeColor: colors.hydro.label,
-          strokeWidth: 1.2
-        },
-        text: {
-          ...chartText,
-          field: expression([
-            "coalesce",
-            ["get", fields.name],
-            ["get", fields.subclass],
-            ["get", fields.class]
+          strokeColor: ink,
+          strokeWidth: 1
+        }
+      },
+      text: { ...markText, ...sideLabel, field: nameFrom(15), padding: 3, size: 9 }
+    },
+    beacons: {
+      minZoom: 11,
+      placement: "point",
+      ...rankPriority,
+      ...images.beacons ? {
+        icon: {
+          ...iconPaint,
+          image: images.beacons,
+          size: zoom.linear([
+            [11, 0.8],
+            [16, 1.2]
+          ])
+        }
+      } : {
+        marker: {
+          color: markColour,
+          radius: zoom.linear([
+            [11, 1.8],
+            [16, 3.4]
           ]),
-          offset: [0, 1.1],
-          optional: true,
-          padding: 4,
-          size: 10
+          strokeColor: markStroke,
+          strokeWidth: 1
         }
       },
-      lighthouses: {
-        minZoom: 10,
-        placement: "point",
-        priority: 99,
+      text: { ...markText, ...sideLabel, field: nameFrom(14), padding: 3, size: 9 }
+    },
+    lights: {
+      minZoom: 6,
+      placement: "point",
+      ...rankPriority,
+      ...images.lights ? {
+        icon: {
+          allowOverlap: true,
+          color: flareColour,
+          haloColor: halo,
+          haloWidth: 0.5,
+          ignorePlacement: true,
+          image: images.lights,
+          opacity: 0.9,
+          size: byClassAndZoom([
+            [6, 0.9, 0.65],
+            [14, 1.6, 1.15]
+          ])
+        }
+      } : {
         marker: {
-          color: colors.hydro.water,
+          color: flareColour,
+          opacity: 0.55,
+          radius: byClassAndZoom([
+            [6, 3.2, 1.8],
+            [14, 7, 4.5]
+          ])
+        }
+      },
+      text: {
+        ...markText,
+        ...sideLabel,
+        field: expression([
+          "step",
+          ["zoom"],
+          "",
+          10,
+          [
+            "case",
+            ["==", ["get", fields.class], "major"],
+            ["coalesce", ["get", fields.label], ""],
+            ""
+          ],
+          13,
+          ["coalesce", ["get", fields.label], ""]
+        ]),
+        padding: 3,
+        size: zoom.linear([
+          [10, 9],
+          [16, 10.5]
+        ])
+      }
+    },
+    buoys: {
+      minZoom: 8,
+      placement: "point",
+      ...rankPriority,
+      ...images.buoys ? {
+        icon: {
+          ...iconPaint,
+          // Dense harbours thin out by rank at low zooms instead of piling up.
+          image: images.buoys,
+          padding: 1,
+          size: zoom.linear([
+            [11, 1],
+            [16, 1.5]
+          ])
+        }
+      } : {
+        marker: {
+          color: markColour,
           radius: zoom.linear([
-            [10, 3],
+            [8, 2.4],
             [16, 4.6]
           ]),
-          strokeColor: colors.hydro.label,
+          strokeColor: markStroke,
           strokeWidth: 1.4
-        },
-        text: {
-          ...chartText,
-          field: expression([
-            "case",
-            ["has", fields.name],
-            ["to-string", ["get", fields.name]],
-            "Lighthouse"
-          ]),
-          offset: [0, 1.2],
-          optional: true,
-          padding: 4,
-          size: 10
         }
       },
-      lights: {
-        minZoom: 11,
-        placement: "point",
-        priority: 96,
+      text: { ...markText, ...sideLabel, field: nameFrom(14), padding: 3, size: 9 }
+    },
+    lighthouses: {
+      minZoom: 8,
+      placement: "point",
+      ...rankPriority,
+      ...images.lighthouses ? {
+        icon: {
+          allowOverlap: true,
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.lighthouses,
+          size: zoom.linear([
+            [8, 1],
+            [16, 1.6]
+          ])
+        }
+      } : {
         marker: {
-          color: colors.poi.transport,
-          opacity: 0.24,
+          color: ink,
           radius: zoom.linear([
-            [11, 4],
-            [16, 7]
+            [8, 2.6],
+            [16, 4.8]
           ]),
-          strokeColor: colors.poi.transport,
-          strokeWidth: 1
-        },
-        text: {
-          ...chartText,
-          color: colors.poi.transport,
-          field: lightLabel(fields),
-          offset: [0, 1.25],
-          optional: true,
-          padding: 5,
-          size: 9
+          strokeColor: halo,
+          strokeWidth: 1.2
+        }
+      },
+      text: {
+        ...markText,
+        ...belowLabel,
+        field: nameFrom(10),
+        padding: 4,
+        size: zoom.linear([
+          [10, 9.5],
+          [16, 11.5]
+        ])
+      }
+    },
+    ports: {
+      minZoom: 3,
+      placement: "point",
+      ...rankPriority,
+      ...images.ports ? {
+        icon: {
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.ports,
+          size: byPortSizeAndZoom([
+            [3, [1.05, 0.95, 0.85, 0.75]],
+            [12, [1.45, 1.35, 1.25, 1.15]]
+          ])
+        }
+      } : {
+        marker: {
+          color: ink,
+          radius: byPortSizeAndZoom([
+            [3, [3.2, 2.8, 2.4, 2]],
+            [12, [5, 4.5, 4, 3.5]]
+          ]),
+          strokeColor: halo,
+          strokeWidth: 1.2
         }
       },
+      text: {
+        ...markText,
+        ...belowLabel,
+        field: expression(["coalesce", ["get", fields.name], ""]),
+        padding: 6,
+        size: byPortSizeAndZoom([
+          [3, [11, 10, 9.5, 9]],
+          [12, [12.5, 11.5, 11, 10.5]]
+        ])
+      }
+    },
+    labels: {
+      coverage: {
+        maxZoom: 9,
+        minZoom: 4,
+        placement: "point",
+        visible: false,
+        text: { ...chartText, field: expression(["get", fields.provider]), size: 8 }
+      },
       hazards: {
         minZoom: 11,
         placement: "point",
-        priority: 95,
-        text: {
-          ...chartText,
-          color: colors.poi.transport,
-          field: nameAndDepthWithPrefix(fields.name, fields.depth, "X"),
-          optional: false,
-          padding: 5,
-          size: 12
-        }
+        text: { ...markText, color: accent, field: expression(["get", fields.name]) }
       },
-      wrecks: {
+      navigationAreas: {
         minZoom: 11,
         placement: "point",
-        priority: 94,
         text: {
-          ...chartText,
-          field: nameAndDepthWithPrefix(fields.name, fields.depth, "Wrk"),
-          optional: false,
-          padding: 5,
-          size: 9
+          ...markText,
+          color: expression([
+            "match",
+            ["get", fields.class],
+            [...operationalAreaClasses],
+            accent,
+            ink
+          ]),
+          field: expression(["get", fields.name]),
+          optional: true,
+          padding: 8,
+          size: 9.5
         }
       },
       reefs: {
-        fill: { color: colors.landcover.sand, minZoom: 7, opacity: 0.34 },
-        outline: {
-          color: colors.hydro.label,
-          dash: [1.5, 1.5],
-          minZoom: 7,
-          opacity: 0.62,
-          width: 0.8
-        }
-      },
-      hazardAreas: {
-        fill: { color: colors.poi.transport, minZoom: 11, opacity: 0.1 },
-        outline: {
-          color: colors.poi.transport,
-          dash: [1, 1],
-          minZoom: 11,
-          opacity: 0.72,
-          width: 0.8
-        }
-      },
-      wreckAreas: {
-        fill: { color: colors.hydro.label, minZoom: 11, opacity: 0.08 },
-        outline: {
-          color: colors.hydro.label,
-          dash: [2, 1],
-          minZoom: 11,
-          opacity: 0.62,
-          width: 0.75
-        }
-      },
-      navigationAreas: {
-        fill: { color: colors.poi.transport, minZoom: 8, opacity: 0.06 },
-        outline: {
-          color: colors.poi.transport,
-          dash: [4, 2],
-          minZoom: 8,
-          opacity: 0.62,
-          width: 0.8
-        }
+        minZoom: 11,
+        placement: "point",
+        text: { ...chartText, field: expression(["get", fields.name]), size: 9 }
       },
-      coverage: {
-        outline: {
-          color: colors.poi.transport,
-          dash: [2, 3],
-          maxZoom: 9,
-          minZoom: 4,
-          opacity: 0.34,
-          width: 0.6
-        }
-      },
-      labels: {
-        coverage: {
-          maxZoom: 9,
-          minZoom: 4,
-          placement: "point",
-          priority: 70,
-          text: {
-            ...chartText,
-            color: colors.poi.transport,
-            field: expression(["coalesce", ["get", fields.name], ["get", fields.provider]]),
-            optional: true,
-            padding: 12,
-            size: 8
-          }
-        },
-        hazards: {
-          minZoom: 11,
-          placement: "point",
-          priority: 93,
-          text: {
-            ...chartText,
-            color: colors.poi.transport,
-            field: nameAndDepthWithPrefix(fields.name, fields.depth, "X"),
-            optional: true,
-            padding: 6,
-            size: 9
-          }
-        },
-        navigationAreas: {
-          minZoom: 10,
-          placement: "point",
-          priority: 78,
-          text: {
-            ...chartText,
-            color: colors.poi.transport,
-            field: expression(["coalesce", ["get", fields.name], ["get", fields.class]]),
-            optional: true,
-            padding: 8,
-            size: 9
-          }
-        },
-        reefs: {
-          minZoom: 12,
-          placement: "point",
-          priority: 89,
-          text: {
-            ...chartText,
-            field: nameAndDepthWithPrefix(fields.name, fields.depth, "Reef"),
-            optional: true,
-            padding: 7,
-            size: 9
-          }
-        },
-        wrecks: {
-          minZoom: 11,
-          placement: "point",
-          priority: 92,
-          text: {
-            ...chartText,
-            field: nameAndDepthWithPrefix(fields.name, fields.depth, "Wrk"),
-            optional: true,
-            padding: 6,
-            size: 9
-          }
-        }
+      wrecks: {
+        minZoom: 12,
+        placement: "point",
+        text: { ...markText, field: expression(["get", fields.name]), size: 9 }
       }
-    },
+    }
+  };
+  const config = mergeTileflowDesign(
+    defaults4,
     request
   );
   const source = nauticalSource.sourceId;
   const contributions = [];
-  appendAreaFeature(contributions, {
+  const add2 = (options) => appendNauticalLayer(contributions, { ...options, source });
+  add2({
+    // Only coverage that speaks for every family; lists of lights alone would double the tint.
+    filter: ["all", polygons, ["in", layers.aids, ["coalesce", ["get", fields.families], ""]]],
     id: "tileflow-nautical-coverage",
     localOrder: 380,
-    source,
     sourceLayer: layers.coverage,
     style: config.coverage,
     target: "nautical.coverage"
   });
-  appendAreaFeature(contributions, {
+  add2({
+    filter: polygons,
     id: "tileflow-nautical-navigation-areas",
     localOrder: 390,
-    source,
     sourceLayer: layers.navigationAreas,
     style: config.navigationAreas,
     target: "nautical.navigationAreas"
   });
-  appendAreaFeature(contributions, {
+  add2({
+    filter: polygons,
     id: "tileflow-nautical-reefs",
     localOrder: 400,
-    source,
     sourceLayer: layers.reefs,
     style: config.reefs,
     target: "nautical.reefs"
   });
-  appendAreaFeature(contributions, {
+  add2({
+    filter: linesOf(cableClasses),
+    id: "tileflow-nautical-cables",
+    line: true,
+    localOrder: 404,
+    sourceLayer: layers.navigationAreas,
+    style: config.cables,
+    target: "nautical.cables"
+  });
+  add2({
+    filter: linesOf(routeClasses),
+    id: "tileflow-nautical-routes",
+    line: true,
+    localOrder: 406,
+    sourceLayer: layers.navigationAreas,
+    style: config.routes,
+    target: "nautical.routes"
+  });
+  add2({
+    filter: polygons,
     id: "tileflow-nautical-hazard-areas",
     localOrder: 410,
-    source,
+    outlineFilter: ["match", ["geometry-type"], ["LineString", "Polygon"], true, false],
     sourceLayer: layers.hazards,
     style: config.hazardAreas,
     target: "nautical.hazardAreas"
   });
-  appendAreaFeature(contributions, {
+  add2({
+    filter: polygons,
     id: "tileflow-nautical-wreck-areas",
     localOrder: 420,
-    source,
     sourceLayer: layers.wrecks,
     style: config.wreckAreas,
     target: "nautical.wreckAreas"
   });
-  appendPolygonLabel(contributions, {
-    featureFilter: ["any", ["has", fields.name], ["has", fields.provider]],
-    id: "tileflow-nautical-coverage-labels",
-    localOrder: 1060,
-    source,
-    sourceLayer: layers.coverage,
-    style: config.labels?.coverage,
-    target: "nautical.labels.coverage"
-  });
-  appendPolygonLabel(contributions, {
-    featureFilter: ["any", ["has", fields.name], ["has", fields.class]],
-    id: "tileflow-nautical-navigation-area-labels",
-    localOrder: 1070,
-    source,
-    sourceLayer: layers.navigationAreas,
-    style: config.labels?.navigationAreas,
-    target: "nautical.labels.navigationAreas"
-  });
-  appendPolygonLabel(contributions, {
-    id: "tileflow-nautical-reef-labels",
-    localOrder: 1080,
-    source,
-    sourceLayer: layers.reefs,
-    style: config.labels?.reefs,
-    target: "nautical.labels.reefs"
+  for (const [key, id2, sourceLayer, localOrder] of [
+    ["coverage", "tileflow-nautical-coverage-labels", layers.coverage, 560],
+    ["navigationAreas", "tileflow-nautical-navigation-area-labels", layers.navigationAreas, 562],
+    ["reefs", "tileflow-nautical-reef-labels", layers.reefs, 564],
+    ["hazards", "tileflow-nautical-hazard-area-labels", layers.hazards, 566],
+    ["wrecks", "tileflow-nautical-wreck-area-labels", layers.wrecks, 568]
+  ]) {
+    add2({
+      filter: ["all", polygons, ["has", key === "coverage" ? fields.provider : fields.name]],
+      id: id2,
+      localOrder,
+      sourceLayer,
+      style: config.labels?.[key],
+      target: `nautical.labels.${key}`
+    });
+  }
+  add2({
+    filter: ["all", points, ["has", fields.depth]],
+    id: "tileflow-nautical-soundings",
+    localOrder: 570,
+    sourceLayer: layers.soundings,
+    style: config.soundings,
+    target: "nautical.soundings"
   });
-  appendPolygonLabel(contributions, {
-    id: "tileflow-nautical-hazard-area-labels",
-    localOrder: 1090,
-    source,
+  add2({
+    filter: points,
+    id: "tileflow-nautical-hazards",
+    localOrder: 574,
+    markerFilter: ["!=", ["get", fields.class], "rock"],
     sourceLayer: layers.hazards,
-    style: config.labels?.hazards,
-    target: "nautical.labels.hazards"
+    style: config.hazards,
+    symbolFilter: ["==", ["get", fields.class], "rock"],
+    target: "nautical.hazards"
   });
-  appendPolygonLabel(contributions, {
-    id: "tileflow-nautical-wreck-area-labels",
-    localOrder: 1095,
-    source,
+  add2({
+    filter: points,
+    id: "tileflow-nautical-wrecks",
+    localOrder: 578,
     sourceLayer: layers.wrecks,
-    style: config.labels?.wrecks,
-    target: "nautical.labels.wrecks"
+    style: config.wrecks,
+    target: "nautical.wrecks"
   });
-  appendPointFeature(contributions, {
-    id: "tileflow-nautical-soundings",
-    localOrder: 1100,
-    source,
-    sourceLayer: layers.soundings,
-    style: config.soundings,
-    target: "nautical.soundings",
-    filter: ["all", ["==", ["geometry-type"], "Point"], ["has", fields.depth]]
+  add2({
+    filter: ["all", points, ["==", ["get", fields.class], "harbour"]],
+    id: "tileflow-nautical-harbours",
+    localOrder: 582,
+    sourceLayer: layers.navigationAreas,
+    style: config.harbours,
+    target: "nautical.harbours"
   });
-  appendPointFeature(contributions, {
+  add2({
+    filter: [
+      "all",
+      points,
+      [
+        "match",
+        ["get", fields.class],
+        [...floatingAidClasses, ...fixedAidClasses, "lighthouse"],
+        false,
+        true
+      ]
+    ],
     id: "tileflow-nautical-aids",
-    localOrder: 1110,
-    source,
+    localOrder: 586,
     sourceLayer: layers.aids,
     style: config.aids,
-    target: "nautical.aids",
-    filter: [
-      "all",
-      ["==", ["geometry-type"], "Point"],
-      ["!=", ["get", fields.class], "lighthouse"]
-    ]
+    target: "nautical.aids"
   });
-  appendPointFeature(contributions, {
-    id: "tileflow-nautical-lighthouses",
-    localOrder: 1115,
-    source,
+  add2({
+    filter: ["all", points, ["match", ["get", fields.class], [...fixedAidClasses], true, false]],
+    id: "tileflow-nautical-beacons",
+    localOrder: 590,
     sourceLayer: layers.aids,
-    style: config.lighthouses,
-    target: "nautical.lighthouses",
-    filter: [
-      "all",
-      ["==", ["geometry-type"], "Point"],
-      ["==", ["get", fields.class], "lighthouse"]
-    ]
+    style: config.beacons,
+    target: "nautical.beacons"
   });
-  appendPointFeature(contributions, {
+  add2({
+    filter: points,
     id: "tileflow-nautical-lights",
-    localOrder: 1120,
-    source,
+    localOrder: 594,
     sourceLayer: layers.lights,
     style: config.lights,
-    target: "nautical.lights",
-    filter: ["==", ["geometry-type"], "Point"]
+    target: "nautical.lights"
   });
-  appendPointFeature(contributions, {
-    id: "tileflow-nautical-hazards",
-    localOrder: 1130,
-    source,
-    sourceLayer: layers.hazards,
-    style: config.hazards,
-    target: "nautical.hazards",
-    filter: ["==", ["geometry-type"], "Point"]
+  add2({
+    filter: ["all", points, ["match", ["get", fields.class], [...floatingAidClasses], true, false]],
+    id: "tileflow-nautical-buoys",
+    localOrder: 598,
+    sourceLayer: layers.aids,
+    style: config.buoys,
+    target: "nautical.buoys"
   });
-  appendPointFeature(contributions, {
-    id: "tileflow-nautical-wrecks",
-    localOrder: 1140,
-    source,
-    sourceLayer: layers.wrecks,
-    style: config.wrecks,
-    target: "nautical.wrecks",
-    filter: ["==", ["geometry-type"], "Point"]
+  add2({
+    filter: ["all", points, ["==", ["get", fields.class], "lighthouse"]],
+    id: "tileflow-nautical-lighthouses",
+    localOrder: 602,
+    sourceLayer: layers.aids,
+    style: config.lighthouses,
+    target: "nautical.lighthouses"
+  });
+  add2({
+    filter: ["all", points, ["==", ["get", fields.class], "port"]],
+    id: "tileflow-nautical-ports",
+    localOrder: 606,
+    sourceLayer: layers.navigationAreas,
+    style: config.ports,
+    target: "nautical.ports"
   });
   return contributions;
 }
-function appendPolygonLabel(contributions, options) {
-  const style = options.style;
-  if (!style || style.visible === false || (!style.text || style.text.visible === false) && (!style.icon || style.icon.visible === false)) {
-    return;
-  }
-  contributions.push(
-    nauticalContribution(
-      options.target,
-      options.localOrder,
-      applySymbolStyle(
-        {
-          id: options.id,
-          type: "symbol",
-          source: options.source,
-          "source-layer": options.sourceLayer,
-          filter: options.featureFilter ? ["all", ["==", ["geometry-type"], "Polygon"], options.featureFilter] : ["==", ["geometry-type"], "Polygon"]
-        },
-        style
-      ),
-      "symbols"
-    )
-  );
+var points = ["==", ["geometry-type"], "Point"];
+var polygons = ["==", ["geometry-type"], "Polygon"];
+function linesOf(classes) {
+  return [
+    "all",
+    ["==", ["geometry-type"], "LineString"],
+    ["match", ["get", fields.class], [...classes], true, false]
+  ];
 }
-function appendAreaFeature(contributions, options) {
-  if (!options.style) return;
-  for (const area of createAreaLayers(
-    {
-      id: options.id,
-      type: "fill",
-      source: options.source,
-      "source-layer": options.sourceLayer,
-      filter: ["==", ["geometry-type"], "Polygon"]
-    },
-    options.style
-  )) {
+var fromFeatureMinZoom = [">=", ["zoom"], ["to-number", ["get", fields.minZoom], 0]];
+function appendNauticalLayer(contributions, options) {
+  const style = options.style;
+  if (!style) return;
+  const base = (id2, type, filter) => ({
+    id: id2,
+    type,
+    source: options.source,
+    "source-layer": options.sourceLayer,
+    filter: ["all", filter, fromFeatureMinZoom]
+  });
+  if (options.line) {
+    const line = style;
+    if (line.visible === false) return;
     contributions.push(
       nauticalContribution(
-        `${options.target}.${area.phase}`,
-        options.localOrder + (area.phase === "fill" ? 0 : 1),
-        area.layer,
+        options.target,
+        options.localOrder,
+        applyLineStyle(base(options.id, "line", options.filter), line),
         "hydro"
       )
     );
+    return;
   }
-}
-function appendPointFeature(contributions, options) {
-  const style = options.style;
-  if (!style || style.visible === false) return;
-  const symbolStyle2 = withoutMarker(style);
-  const base = {
-    id: options.id,
-    type: "symbol",
-    source: options.source,
-    "source-layer": options.sourceLayer,
-    filter: options.filter
-  };
-  if (style.marker && style.marker.visible !== false) {
+  if ("fill" in style || "outline" in style) {
+    const area = style;
+    if (area.fill && area.fill.visible !== false) {
+      contributions.push(
+        nauticalContribution(
+          `${options.target}.fill`,
+          options.localOrder,
+          applyFillStyle(base(options.id, "fill", options.filter), area.fill),
+          "hydro"
+        )
+      );
+    }
+    if (area.outline && area.outline.visible !== false) {
+      contributions.push(
+        nauticalContribution(
+          `${options.target}.outline`,
+          options.localOrder + 1,
+          applyLineStyle(
+            base(`${options.id}-outline`, "line", options.outlineFilter ?? options.filter),
+            area.outline
+          ),
+          "hydro"
+        )
+      );
+    }
+    return;
+  }
+  const point = style;
+  if (point.visible === false) return;
+  const isLabel = options.target.startsWith("nautical.labels.");
+  if (!isLabel && point.marker && point.marker.visible !== false) {
     contributions.push(
       nauticalContribution(
         `${options.target}.marker`,
         options.localOrder,
         applyCircleStyle(
-          { ...base, id: `${options.id}-marker`, type: "circle" },
+          base(
+            `${options.id}-marker`,
+            "circle",
+            options.markerFilter ? ["all", options.filter, options.markerFilter] : options.filter
+          ),
           mergeTileflowDesign(
             {
-              ...style.maxZoom === void 0 ? {} : { maxZoom: style.maxZoom },
-              ...style.minZoom === void 0 ? {} : { minZoom: style.minZoom }
+              ...point.maxZoom === void 0 ? {} : { maxZoom: point.maxZoom },
+              ...point.minZoom === void 0 ? {} : { minZoom: point.minZoom }
             },
-            style.marker
+            point.marker
           )
         ),
         "symbols"
       )
     );
   }
-  const hasText = Boolean(style.text && style.text.visible !== false);
-  const hasIcon = Boolean(style.icon && style.icon.visible !== false);
+  const hasText = Boolean(point.text && point.text.visible !== false);
+  const hasIcon = Boolean(point.icon && point.icon.visible !== false);
   if (!hasText && !hasIcon) return;
   contributions.push(
     nauticalContribution(
-      `${options.target}.symbol`,
-      options.localOrder + 1,
-      applySymbolStyle(base, symbolStyle2),
+      isLabel ? options.target : `${options.target}.symbol`,
+      options.localOrder + (isLabel ? 0 : 1),
+      applySymbolStyle(
+        base(
+          options.id,
+          "symbol",
+          options.symbolFilter ? ["all", options.filter, options.symbolFilter] : options.filter
+        ),
+        withoutMarker(point)
+      ),
       "symbols"
     )
   );
@@ -4022,31 +4537,107 @@ function withoutMarker(style) {
 function nauticalContribution(target, localOrder, layer, slot) {
   return { kind: "layer", layer, localOrder, owner: "nautical", slot, target };
 }
-function nameAndDepthWithPrefix(nameField, depthField, prefix) {
+function themedImages(context) {
+  const roles = tileflowNauticalImageRoles;
+  const images = {};
+  for (const group of Object.keys(roles)) {
+    const image = context.images[roles[group].default];
+    if (image) images[group] = image;
+  }
+  const buoy = images.buoys;
+  if (typeof buoy === "string") {
+    const port = context.images[roles.buoys.port] ?? buoy;
+    const starboard = context.images[roles.buoys.starboard] ?? buoy;
+    const cardinal = context.images[roles.buoys.cardinal] ?? buoy;
+    images.buoys = expression([
+      "case",
+      ["==", ["get", fields.subclass], "cardinal"],
+      cardinal,
+      [
+        "match",
+        ["get", fields.category],
+        [...portLateralCategories],
+        port,
+        [...starboardLateralCategories],
+        starboard,
+        buoy
+      ]
+    ]);
+  }
+  return images;
+}
+function firstColour(field2) {
+  return [
+    "let",
+    "nauticalColours",
+    ["to-string", ["coalesce", ["get", field2], ""]],
+    leadingName(["var", "nauticalColours"])
+  ];
+}
+function secondColour(field2) {
+  return [
+    "let",
+    "nauticalColours",
+    ["to-string", ["coalesce", ["get", field2], ""]],
+    [
+      "let",
+      "nauticalComma",
+      ["index-of", ",", ["var", "nauticalColours"]],
+      [
+        "case",
+        ["<", ["var", "nauticalComma"], 0],
+        "",
+        [
+          "let",
+          "nauticalRest",
+          ["slice", ["var", "nauticalColours"], ["+", ["var", "nauticalComma"], 1]],
+          leadingName(["var", "nauticalRest"])
+        ]
+      ]
+    ]
+  ];
+}
+function leadingName(list) {
+  return [
+    "let",
+    "nauticalEnd",
+    ["index-of", ",", list],
+    ["case", ["<", ["var", "nauticalEnd"], 0], list, ["slice", list, 0, ["var", "nauticalEnd"]]]
+  ];
+}
+function colourMatch(name, palette, fallback) {
+  return [
+    "match",
+    name,
+    ...Object.entries(palette).flatMap(([colourName, value]) => [colourName, value]),
+    fallback
+  ];
+}
+function byClassAndZoom(stops) {
   return expression([
-    "concat",
-    prefix,
-    ["case", ["has", nameField], ["concat", " ", ["to-string", ["get", nameField]]], ""],
-    ["case", ["has", depthField], ["concat", " ", ["to-string", ["get", depthField]], "m"], ""]
+    "interpolate",
+    ["linear"],
+    ["zoom"],
+    ...stops.flatMap(([stop, major, minor]) => [
+      stop,
+      ["match", ["get", fields.class], "major", major, minor]
+    ])
   ]);
 }
-function lightLabel(fields) {
+function byPortSizeAndZoom(stops) {
   return expression([
-    "concat",
-    ["case", ["has", fields.character], ["to-string", ["get", fields.character]], "Lt"],
-    [
-      "case",
-      ["has", fields.rangeNm],
-      ["concat", " ", ["to-string", ["get", fields.rangeNm]], "M"],
-      ""
-    ],
-    [
-      "case",
-      ["has", fields.direction],
-      ["concat", " ", ["to-string", ["get", fields.direction]], "\xB0"],
-      ""
-    ],
-    ["case", ["has", fields.name], ["concat", " ", ["to-string", ["get", fields.name]]], ""]
+    "interpolate",
+    ["linear"],
+    ["zoom"],
+    ...stops.flatMap(([stop, values]) => [
+      stop,
+      [
+        "match",
+        ["get", fields.size],
+        ...portSizes.flatMap((size, index) => [size, values[index]]),
+        values[3]
+      ]
+    ])
   ]);
 }
 
@@ -4211,12 +4802,12 @@ function mergePoiCategoryLayers(entries, options) {
   };
   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 properties2 = [...new Set(records.flatMap((record4) => Object.keys(record4)))].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
+        (record4) => Object.hasOwn(record4, property) ? record4[property] : fallback
       );
       if (values.every((value) => sameJson(value, values[0]))) {
         if (values[0] !== void 0) merged[property] = values[0];
@@ -4575,11 +5166,11 @@ function compileCategory(category, request, semantics, context, language, select
   return parts;
 }
 function createPoiSelection(semantics, context, language) {
-  const { fields } = context.data.schema;
+  const { fields: fields2 } = 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 iconOnly = () => iconOnlyTypes.length ? ["match", ["get", fields2.poiType], iconOnlyTypes, true, false] : ["literal", false];
+  const inCategories = (categories) => categories.length === 1 ? ["==", ["get", fields2.poiCategory], categories[0]] : ["match", ["get", fields2.poiCategory], [...categories], true, false];
   const named = () => [
     "any",
     ...labelNameFields(language, context).map((field2) => ["has", field2])
@@ -4592,22 +5183,22 @@ function createPoiSelection(semantics, context, language) {
       if (!iconOnlyTypes.length || field2 === void 0) return field2;
       return expression([
         "match",
-        ["get", fields.poiType],
+        ["get", fields2.poiType],
         iconOnlyTypes,
         "",
         fieldValue(field2)
       ]);
     },
     filter(categories, representation) {
-      const filterRank = numericPoiField(fields.poiFilterRank, 6);
-      const sizeRank = numericPoiField(fields.poiSizeRank, 17);
+      const filterRank = numericPoiField(fields2.poiFilterRank, 6);
+      const sizeRank = numericPoiField(fields2.poiSizeRank, 17);
       const result = [
         "all",
         inCategories(categories),
-        ["has", fields.poiFilterRank],
+        ["has", fields2.poiFilterRank],
         [">=", filterRank, 0],
         ["<=", filterRank, poiRankThreshold(semantics.density)],
-        ["has", fields.poiSizeRank],
+        ["has", fields2.poiSizeRank],
         [">=", sizeRank, 0],
         ["<=", sizeRank, 16]
       ];
@@ -4830,9 +5421,19 @@ var visualNumberProperties = /* @__PURE__ */ new Set([
   "angle",
   "base",
   "blur",
+  "brightnessScale",
   "crownScale",
   "dash",
   "exaggeration",
+  "emissiveStrength",
+  "emissiveVariation",
+  "emissiveHeight",
+  "colorMix",
+  "metallic",
+  "roughness",
+  "hue",
+  "saturation",
+  "lightness",
   "fadeDuration",
   "gapWidth",
   "haloBlur",
@@ -4846,6 +5447,7 @@ var visualNumberProperties = /* @__PURE__ */ new Set([
   "maxAngle",
   "maxWidth",
   "miterLimit",
+  "modelOcclusion",
   "offset",
   "opacity",
   "padding",
@@ -4941,8 +5543,11 @@ var visualNumberProperties = /* @__PURE__ */ new Set([
   "text-translate",
   "symbol-spacing"
 ]);
+function isTileflowVisualColorCollection(property) {
+  return property === "colors" || property.endsWith("Colors") || property.endsWith("-colors");
+}
 function classifyTileflowVisualProperty(property, _value) {
-  if (property === "color" || property === "colors" || property.endsWith("Color") || property.endsWith("Colors") || property.endsWith("-color") || property.endsWith("-colors")) {
+  if (property === "color" || property.endsWith("Color") || property.endsWith("-color") || isTileflowVisualColorCollection(property)) {
     return "color";
   }
   if (property === "font" || property === "fallbacks" || property.endsWith("-font")) return "font";
@@ -5046,7 +5651,7 @@ function auditTileflowThemeValues(value, path = "value", context = inferAuditCon
   return diagnostics.sort(compareAuditDiagnostics);
 }
 function auditTileflowMapThemeValues(map) {
-  const modules = isRecord3(map.modules) ? map.modules : void 0;
+  const modules = isRecord4(map.modules) ? map.modules : void 0;
   const moduleDiagnostics = modules ? Object.keys(modules).sort(compareCodeUnits2).flatMap(
     (owner) => auditTileflowThemeValues(modules[owner], `modules.${owner}`, {
       owner,
@@ -5149,7 +5754,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 isRecord3(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
+  return isRecord4(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;
@@ -5165,7 +5770,7 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     visitAuditableArray(value, path, category, state, false, intentRequired);
     return;
   }
-  if (!isRecord3(value)) return;
+  if (!isRecord4(value)) return;
   if (value.kind === "expression" && Array.isArray(value.value)) {
     visitAuditableArray(value.value, `${path}.value`, category, state, true, intentRequired);
     return;
@@ -5185,15 +5790,19 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     }
     return;
   }
+  const collectionCategory = isTileflowVisualColorCollection(lastPathKey(path)) ? category : void 0;
   for (const key of Object.keys(value).sort(compareCodeUnits2)) {
     visitAuditableValue(
       value[key],
       `${path}.${key}`,
-      classifyTileflowVisualProperty(key, value[key]),
+      classifyTileflowVisualProperty(key, value[key]) ?? collectionCategory,
       state
     );
   }
 }
+function lastPathKey(path) {
+  return path.endsWith("]") ? "" : path.slice(path.lastIndexOf(".") + 1);
+}
 function visitAuditableArray(value, path, category, state, forceExpression = false, intentRequired = false) {
   const operator = typeof value[0] === "string" ? value[0] : void 0;
   const isExpression2 = forceExpression || isMapLibreExpressionOperator(operator);
@@ -5480,7 +6089,7 @@ var ThemeValueResolver = class {
     if (Array.isArray(value)) {
       return value.map((entry, index) => this.resolveTree(entry, `${path}[${index}]`, category));
     }
-    if (!isRecord3(value)) return value;
+    if (!isRecord4(value)) return value;
     if (value.kind === "expression" && Array.isArray(value.value)) {
       return {
         ...value,
@@ -5694,13 +6303,13 @@ function assertThemeIdentity(theme) {
   }
 }
 function assertThemeDocument(theme) {
-  const record3 = assertPlainThemeRecord(theme, "theme");
-  assertExactThemeKeys(record3, "theme", themeDocumentKeys);
-  assertRequiredThemeKeys(record3, "theme", themeDocumentKeys);
+  const record4 = assertPlainThemeRecord(theme, "theme");
+  assertExactThemeKeys(record4, "theme", themeDocumentKeys);
+  assertRequiredThemeKeys(record4, "theme", themeDocumentKeys);
   assertThemeIdentity(theme);
-  assertThemeTokens(record3.tokens, "theme.tokens", true);
-  assertThemeTypography(record3.typography, "theme.typography");
-  assertThemeLighting(record3.lighting, "theme.lighting");
+  assertThemeTokens(record4.tokens, "theme.tokens", true);
+  assertThemeTypography(record4.typography, "theme.typography");
+  assertThemeLighting(record4.lighting, "theme.lighting");
   cloneJson14(theme);
 }
 function assertThemeTokens(value, path, complete) {
@@ -5794,7 +6403,7 @@ function assertThemeLighting(value, path, allowReset = false) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -6146,11 +6755,11 @@ function cloneJson14(value) {
   if (serialized === void 0) throw new Error("Tileflow themes must be JSON-serializable.");
   return JSON.parse(serialized);
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord2(value) {
-  if (!isRecord3(value)) return false;
+  if (!isRecord4(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -6656,12 +7265,12 @@ function rgbToHex(r, g, b) {
 
 // src/modules/roads/roundabouts.ts
 function compileRoundabouts(request, surfaces, context, contributions) {
-  const { fields, layers } = context.data.schema;
-  if (!layers.circularFeature) return;
+  const { fields: fields2, layers: layers2 } = context.data.schema;
+  if (!layers2.circularFeature) return;
   const drawn = surfaces.filter(({ fill }) => fill && fill.visible !== false);
   if (!drawn.length) return;
   const values = (resolve) => drawn.map((surface) => ({
-    condition: tileflowRoadClassFilter(fields, surface.roadClass),
+    condition: tileflowRoadClassFilter(fields2, surface.roadClass),
     value: toMapLibreStyleValue(resolve(surface))
   }));
   const widths = values(({ fill }) => fill?.width ?? 1);
@@ -6669,10 +7278,10 @@ function compileRoundabouts(request, surfaces, context, contributions) {
   const gaps = values(({ casing }) => casing?.gapWidth ?? 0);
   const fallbackWidth = request?.fallbackWidth === void 0 ? void 0 : toMapLibreStyleValue(request.fallbackWidth);
   const borderWidth = request?.borderWidth === void 0 ? void 0 : toMapLibreStyleValue(request.borderWidth);
-  const radiusAt15 = ["to-number", ["get", fields.circularRadiusAtZoom15], 0];
-  const radiusMeters = ["to-number", ["get", fields.circularRadiusMeters], 0];
-  const innerMeters = ["to-number", ["get", fields.circularInnerRadiusMeters], 0];
-  const outerMeters = ["to-number", ["get", fields.circularOuterRadiusMeters], 0];
+  const radiusAt15 = ["to-number", ["get", fields2.circularRadiusAtZoom15], 0];
+  const radiusMeters = ["to-number", ["get", fields2.circularRadiusMeters], 0];
+  const innerMeters = ["to-number", ["get", fields2.circularInnerRadiusMeters], 0];
+  const outerMeters = ["to-number", ["get", fields2.circularOuterRadiusMeters], 0];
   const physical = [
     "all",
     [">", radiusMeters, 0],
@@ -6702,35 +7311,37 @@ function compileRoundabouts(request, surfaces, context, contributions) {
     }),
     0
   ) : atZoom(borderWidth, level);
-  const geometry = (casing, width) => expression([
-    "interpolate",
-    ["exponential", 2],
-    ["zoom"],
-    ...geometryLevels.flatMap((level) => {
-      const centerline = ["*", radiusAt15, 2 ** (level - 15)];
-      const fallback = fallbackWidth === void 0 ? select(
-        widths.map(({ condition, value }) => ({ condition, value: atZoom(value, level) })),
-        0
-      ) : atZoom(fallbackWidth, level);
-      const inner = [
-        "case",
-        physical,
-        ["*", centerline, ["/", innerMeters, radiusMeters]],
-        ["-", centerline, ["/", fallback, 2]]
-      ];
-      const fillWidth = [
-        "case",
-        physical,
-        ["*", centerline, ["/", ["-", outerMeters, innerMeters], radiusMeters]],
-        fallback
-      ];
-      const border = casing ? borderAt(level) : 0;
-      return [
-        level,
-        width ? ["max", 0, ["+", fillWidth, border]] : ["max", 0, ["-", inner, ["/", border, 2]]]
-      ];
-    })
-  ]);
+  const geometry = (casing, width) => expression(
+    bindRepeated([
+      "interpolate",
+      ["exponential", 2],
+      ["zoom"],
+      ...geometryLevels.flatMap((level) => {
+        const centerline = ["*", radiusAt15, 2 ** (level - 15)];
+        const fallback = fallbackWidth === void 0 ? select(
+          widths.map(({ condition, value }) => ({ condition, value: atZoom(value, level) })),
+          0
+        ) : atZoom(fallbackWidth, level);
+        const inner = [
+          "case",
+          physical,
+          ["*", centerline, ["/", innerMeters, radiusMeters]],
+          ["-", centerline, ["/", fallback, 2]]
+        ];
+        const fillWidth = [
+          "case",
+          physical,
+          ["*", centerline, ["/", ["-", outerMeters, innerMeters], radiusMeters]],
+          fallback
+        ];
+        const border = casing ? borderAt(level) : 0;
+        return [
+          level,
+          width ? ["max", 0, ["+", fillWidth, border]] : ["max", 0, ["-", inner, ["/", border, 2]]]
+        ];
+      })
+    ])
+  );
   const phaseStyle = (phase) => ({
     color: "rgba(0, 0, 0, 0)",
     minZoom: 15,
@@ -6740,7 +7351,7 @@ function compileRoundabouts(request, surfaces, context, contributions) {
     strokeWidth: geometry(phase === "casing", true),
     strokeColor: phase === "casing" ? context.colors.roads.casing : expression([
       "match",
-      ["coalesce", ["get", fields.class], "minor"],
+      ["coalesce", ["get", fields2.class], "minor"],
       "motorway",
       context.colors.roads.motorway,
       "trunk",
@@ -6751,7 +7362,7 @@ function compileRoundabouts(request, surfaces, context, contributions) {
       context.colors.roads.secondary,
       context.colors.roads.minor
     ]),
-    strokeOpacity: phaseVisibility(drawn, phase, fields)
+    strokeOpacity: phaseVisibility(drawn, phase, fields2)
   });
   for (const phase of ["casing", "fill"]) {
     const style = mergeTileflowDesign(phaseStyle(phase), request?.[phase]);
@@ -6767,13 +7378,13 @@ function compileRoundabouts(request, surfaces, context, contributions) {
           id: `tileflow-road-circular-${phase}`,
           type: "circle",
           source: context.data.sourceId,
-          "source-layer": layers.circularFeature,
+          "source-layer": layers2.circularFeature,
           filter: [
             "all",
-            ["==", ["get", fields.circularKind], "road_ring"],
+            ["==", ["get", fields2.circularKind], "road_ring"],
             [
               "any",
-              ...eligible.map((surface) => tileflowRoadClassFilter(fields, surface.roadClass))
+              ...eligible.map((surface) => tileflowRoadClassFilter(fields2, surface.roadClass))
             ]
           ]
         },
@@ -6787,13 +7398,70 @@ function compileRoundabouts(request, surfaces, context, contributions) {
     });
   }
 }
+var bindable = /* @__PURE__ */ new Set([
+  "case",
+  "match",
+  "all",
+  "any",
+  "!",
+  "==",
+  "!=",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "has",
+  "get",
+  "to-number",
+  "coalesce",
+  "+",
+  "-",
+  "*",
+  "/",
+  "max",
+  "min"
+]);
+function bindRepeated(curve) {
+  let tree = curve;
+  for (let index = 0; index < 2; index += 1) {
+    const json = /* @__PURE__ */ new Map();
+    const found = /* @__PURE__ */ new Map();
+    const visit = (value) => {
+      if (!Array.isArray(value) || value[0] === "literal")
+        return { text: JSON.stringify(value), free: true };
+      const parts = value.map(visit);
+      const text = `[${parts.map((part) => part.text).join(",")}]`;
+      json.set(value, text);
+      const free = value[0] !== "zoom" && value[0] !== "var" && parts.every((part) => part.free);
+      if (free && typeof value[0] === "string" && bindable.has(value[0]))
+        found.set(text, (found.get(text) ?? 0) + 1);
+      return { text, free };
+    };
+    visit(tree);
+    let best;
+    let saving = 256;
+    for (const [text, count] of found) {
+      const saved = (count - 1) * text.length;
+      if (count > 1 && saved > saving) [best, saving] = [text, saved];
+    }
+    if (best === void 0) break;
+    const name = `tileflow_${index}`;
+    const replace = (value) => {
+      if (!Array.isArray(value) || value[0] === "literal") return value;
+      if (json.get(value) === best) return ["var", name];
+      return value.map(replace);
+    };
+    tree = ["let", name, JSON.parse(best), replace(tree)];
+  }
+  return tree;
+}
 function select(values, fallback) {
   if (!values.length) return fallback;
   const serialized = JSON.stringify(values[0].value);
   if (values.every(({ value }) => JSON.stringify(value) === serialized)) return values[0].value;
   return ["case", ...values.flatMap(({ condition, value }) => [condition, value]), fallback];
 }
-function phaseVisibility(surfaces, phase, fields) {
+function phaseVisibility(surfaces, phase, fields2) {
   const levels = [
     ...new Set(
       surfaces.flatMap((surface) => {
@@ -6809,7 +7477,7 @@ function phaseVisibility(surfaces, phase, fields) {
     surfaces.map((surface) => {
       const style = surface[phase];
       return {
-        condition: tileflowRoadClassFilter(fields, surface.roadClass),
+        condition: tileflowRoadClassFilter(fields2, surface.roadClass),
         value: (style?.minZoom === void 0 || level >= style.minZoom) && (style?.maxZoom === void 0 || level < style.maxZoom) ? 1 : 0
       };
     }),
@@ -6898,13 +7566,49 @@ function atZoom(value, level) {
     stops.push({ level: value[index], value: value[index + 1] });
   }
   const exact = stops.find((stop) => stop.level === level);
-  if (exact) return exact.value;
+  if (exact) return foldConstants(exact.value);
   const lower = [...stops].reverse().find((stop) => stop.level < level);
   const upper = stops.find((stop) => stop.level > level);
-  if (value[0] === "step") return lower?.value ?? value[2];
-  if (!lower) return upper?.value ?? 0;
-  if (!upper) return lower.value;
-  return ["interpolate", value[1], level, lower.level, lower.value, upper.level, upper.value];
+  if (value[0] === "step") return foldConstants(lower?.value ?? value[2]);
+  if (!lower) return foldConstants(upper?.value ?? 0);
+  if (!upper) return foldConstants(lower.value);
+  const at = interpolationFactor2(
+    value[1],
+    level - lower.level,
+    upper.level - lower.level
+  );
+  const folded = Number.isFinite(at) ? interpolated(foldConstants(lower.value), foldConstants(upper.value), at) : void 0;
+  return folded ?? ["interpolate", value[1], level, lower.level, lower.value, upper.level, upper.value];
+}
+function foldConstants(value) {
+  if (!Array.isArray(value) || value[0] === "literal") return value;
+  const folded = value.map(foldConstants);
+  const [operator, ...operands] = folded;
+  if (!operands.length || !operands.every((operand) => typeof operand === "number")) return folded;
+  const numbers = operands;
+  const result = operator === "*" ? numbers.reduce((product, number) => product * number, 1) : operator === "+" ? numbers.reduce((sum, number) => sum + number, 0) : operator === "-" ? numbers.length === 1 ? -numbers[0] : numbers[0] - numbers[1] : operator === "/" && numbers.length === 2 ? numbers[0] / numbers[1] : operator === "max" ? Math.max(...numbers) : operator === "min" ? Math.min(...numbers) : void 0;
+  return result !== void 0 && Number.isFinite(result) ? result : folded;
+}
+function interpolated(lower, upper, at) {
+  if (typeof lower === "number" && typeof upper === "number") return lower + (upper - lower) * at;
+  if (JSON.stringify(lower) === JSON.stringify(upper)) return lower;
+  if (!Array.isArray(lower) || !Array.isArray(upper) || lower.length !== upper.length || lower[0] !== "case" && lower[0] !== "match" || lower[0] !== upper[0])
+    return void 0;
+  const first = lower[0] === "case" ? 1 : 2;
+  const result = lower.slice(0, first);
+  if (JSON.stringify(result) !== JSON.stringify(upper.slice(0, first))) return void 0;
+  for (let index = first; index < lower.length; index += 1) {
+    const output = (index - first) % 2 === 1 || index === lower.length - 1;
+    if (!output) {
+      if (JSON.stringify(lower[index]) !== JSON.stringify(upper[index])) return void 0;
+      result.push(lower[index]);
+      continue;
+    }
+    const value = interpolated(lower[index], upper[index], at);
+    if (value === void 0) return void 0;
+    result.push(value);
+  }
+  return result;
 }
 
 // src/modules/roads/compiler.ts
@@ -6975,6 +7679,10 @@ function compileRoads(request, context) {
       request?.classes?.[roadClass]
     );
     const treatments = resolveRoadTreatments(request, schema.fields, roadClass);
+    const drawn = {
+      field: schema.fields.class,
+      classes: new Set(tileflowRoadClassValues(roadClass))
+    };
     const roundaboutSurface = { roadClass };
     roundaboutSurfaces.push(roundaboutSurface);
     for (const structure of ["tunnel", "surface", "bridge"]) {
@@ -6997,7 +7705,8 @@ function compileRoads(request, context) {
           treatments,
           structure,
           phase,
-          phaseDefaults.color
+          phaseDefaults.color,
+          drawn
         );
         const contribution = {
           family: roadLinePhysicalFamily(roadClass, structure, phase),
@@ -7060,7 +7769,8 @@ function compileRoads(request, context) {
           treatments,
           structure,
           "fill",
-          roadColor(context, roadClass)
+          roadColor(context, roadClass),
+          drawn
         );
         const size = hatch.size === void 0 ? scaleStyleValue(treatedFill.width ?? 1, 0.68) : toMapLibreStyleValue(hatch.size);
         const minZoom = hatch.minZoom ?? treatedFill.minZoom;
@@ -7181,31 +7891,24 @@ function compileRoads(request, context) {
   const areaTargets = [
     {
       id: "tileflow-road-area",
-      filter: ["==", ["geometry-type"], "Polygon"],
+      kind: void 0,
       name: "road",
       style: areaStyles.road
     },
     {
       id: "tileflow-road-pedestrian-area",
-      filter: [
-        "all",
-        ["==", ["geometry-type"], "Polygon"],
-        tileflowRoadClassFilter(schema.fields, "pedestrian")
-      ],
+      kind: tileflowRoadClassFilter(schema.fields, "pedestrian"),
       name: "pedestrian",
       style: areaStyles.pedestrian
     },
     {
       id: "tileflow-road-pier-area",
-      filter: [
-        "all",
-        ["==", ["geometry-type"], "Polygon"],
-        ["==", ["get", schema.fields.class], "pier"]
-      ],
+      kind: ["==", ["get", schema.fields.class], "pier"],
       name: "pier",
       style: areaStyles.pier
     }
   ];
+  const polygons2 = ["==", ["geometry-type"], "Polygon"];
   let areaOrder = 900;
   for (const target of areaTargets) {
     if (!target.style) continue;
@@ -7215,13 +7918,19 @@ function compileRoads(request, context) {
         type: "fill",
         source,
         "source-layer": schema.layers.road,
-        filter: target.filter
+        filter: target.kind ? ["all", polygons2, target.kind] : polygons2
       },
       target.style
     )) {
+      const { filter: _polygonFilter, ...unfiltered } = area.layer;
+      const outline = area.phase === "outline" && schema.layers.transportationOutline ? {
+        ...unfiltered,
+        "source-layer": schema.layers.transportationOutline,
+        ...target.kind ? { filter: target.kind } : {}
+      } : area.layer;
       contributions.push({
         kind: "layer",
-        layer: area.layer,
+        layer: outline,
         localOrder: areaOrder++,
         owner: "roads",
         slot: "transport-areas",
@@ -7299,8 +8008,8 @@ function roadPhysicalCohort(roadClass) {
   return "path";
 }
 function compileSidewalks(request, pedestrianAreaColor, context, contributions) {
-  const { fields, layers } = context.data.schema;
-  if (!layers.sidewalk) return;
+  const { fields: fields2, layers: layers2 } = context.data.schema;
+  if (!layers2.sidewalk) return;
   const config = mergeTileflowDesign(
     {
       surface: {
@@ -7314,11 +8023,11 @@ function compileSidewalks(request, pedestrianAreaColor, context, contributions)
   const base = {
     type: "fill",
     source: context.data.sourceId,
-    "source-layer": layers.sidewalk,
+    "source-layer": layers2.sidewalk,
     filter: [
       "all",
       ["==", ["geometry-type"], "Polygon"],
-      ["match", ["get", fields.class], ["sidewalk", "pedestrian"], true, false]
+      ["match", ["get", fields2.class], ["sidewalk", "pedestrian"], true, false]
     ]
   };
   if (config.surface?.visible !== false) {
@@ -7356,8 +8065,8 @@ function compileSidewalks(request, pedestrianAreaColor, context, contributions)
   }
 }
 function compileCrossings(request, context, contributions) {
-  const { fields, layers } = context.data.schema;
-  if (!request || !layers.streetFurniture) return;
+  const { fields: fields2, layers: layers2 } = context.data.schema;
+  if (!request || !layers2.streetFurniture) return;
   const config = mergeTileflowDesign(
     {
       allowOverlap: true,
@@ -7370,7 +8079,7 @@ function compileCrossings(request, context, contributions) {
       ]),
       padding: 0,
       pitchAlignment: "map",
-      rotate: expression(["+", ["to-number", ["get", fields.direction], 0], 90]),
+      rotate: expression(["+", ["to-number", ["get", fields2.direction], 0], 90]),
       rotationAlignment: "map",
       size: zoom.linear([
         [15, 0.22],
@@ -7393,14 +8102,14 @@ function compileCrossings(request, context, contributions) {
         id: "tileflow-road-crossing",
         type: "symbol",
         source: context.data.sourceId,
-        "source-layer": layers.streetFurniture,
+        "source-layer": layers2.streetFurniture,
         filter: [
           "all",
           ["==", ["geometry-type"], "Point"],
-          ["==", ["get", fields.subclass], "crossing"],
-          ["!=", ["get", fields.crossing], "no"],
-          ["has", fields.markings],
-          ["match", ["get", fields.markings], ["no", "none", "unmarked"], false, true]
+          ["==", ["get", fields2.subclass], "crossing"],
+          ["!=", ["get", fields2.crossing], "no"],
+          ["has", fields2.markings],
+          ["match", ["get", fields2.markings], ["no", "none", "unmarked"], false, true]
         ]
       },
       config
@@ -7476,43 +8185,44 @@ function substituteZoom(value, level) {
   if (value.length === 1 && value[0] === "zoom") return level;
   return value.map((entry) => substituteZoom(entry, level));
 }
-function resolveRoadTreatments(request, fields, roadClass) {
+function resolveRoadTreatments(request, fields2, roadClass) {
   const entries = [];
   const add2 = (style, condition) => {
     if (style && style.enabled !== false) entries.push({ condition, style });
   };
   add2(request?.modifiers?.construction, [
     "match",
-    ["get", fields.class],
+    ["get", fields2.class],
     tileflowRoadConstructionClasses,
     true,
     false
   ]);
-  add2(request?.restrictions?.bicycle, restrictedAccessFilter(fields.bicycle));
-  add2(request?.restrictions?.foot, restrictedAccessFilter(fields.foot));
-  add2(request?.restrictions?.horse, restrictedAccessFilter(fields.horse));
-  add2(request?.restrictions?.access, restrictedAccessFilter(fields.access));
-  add2(request?.restrictions?.toll, flagFilter(fields.toll));
-  add2(request?.modifiers?.expressway, flagFilter(fields.expressway));
-  add2(request?.modifiers?.ramp, flagFilter(fields.ramp));
-  add2(request?.modifiers?.unpaved, ["==", ["get", fields.surface], "unpaved"]);
-  add2(request?.modifiers?.indoor, flagFilter(fields.indoor));
-  add2(request?.modifiers?.official, flagFilter(fields.official));
-  for (const [scale, style] of Object.entries(request?.mountainBike ?? {})) {
-    add2(style, ["==", ["to-string", ["get", fields.mtbScale]], scale]);
-  }
+  add2(request?.restrictions?.bicycle, restrictedAccessFilter(fields2.bicycle));
+  add2(request?.restrictions?.foot, restrictedAccessFilter(fields2.foot));
+  add2(request?.restrictions?.horse, restrictedAccessFilter(fields2.horse));
+  add2(request?.restrictions?.access, restrictedAccessFilter(fields2.access));
+  add2(request?.restrictions?.toll, flagFilter(fields2.toll));
+  add2(request?.modifiers?.expressway, flagFilter(fields2.expressway));
+  add2(request?.modifiers?.ramp, flagFilter(fields2.ramp));
+  add2(request?.modifiers?.unpaved, ["==", ["get", fields2.surface], "unpaved"]);
+  add2(request?.modifiers?.indoor, flagFilter(fields2.indoor));
+  add2(request?.modifiers?.official, flagFilter(fields2.official));
+  if (isTileflowPathRoadClass(roadClass) || roadClass === "track")
+    for (const [scale, style] of Object.entries(request?.mountainBike ?? {})) {
+      add2(style, ["==", ["to-string", ["get", fields2.mtbScale]], scale]);
+    }
   if (roadClass === "service") {
     for (const [serviceType, value] of Object.entries(serviceTypeValues)) {
       add2(request?.serviceTypes?.[serviceType], [
         "==",
-        ["get", fields.service],
+        ["get", fields2.service],
         value
       ]);
     }
   }
   return entries;
 }
-function applyRoadTreatments(base, treatments, structure, phase, fallbackColor) {
+function applyRoadTreatments(base, treatments, structure, phase, fallbackColor, drawn) {
   const result = { ...base };
   const paintProperties = [
     "blur",
@@ -7529,12 +8239,12 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
       return value === void 0 ? [] : [
         {
           condition,
-          resolve: () => expressionOutput(toMapLibreStyleValue(value))
+          resolve: () => expressionOutput(withinClasses(toMapLibreStyleValue(value), drawn))
         }
       ];
     });
     if (branches.length > 0) {
-      if (property === "dash" && isSolidRoadDash(result[property] ?? treatmentPaintDefaults.dash) && branches.every(({ resolve }) => isSolidRoadDash(resolve()))) {
+      if (property === "dash" && isSolidRoadDash(withinClasses(result[property] ?? treatmentPaintDefaults.dash, drawn)) && branches.every(({ resolve }) => isSolidRoadDash(resolve()))) {
         delete result[property];
         continue;
       }
@@ -7564,6 +8274,49 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
   }
   return result;
 }
+function withinClasses(value, drawn) {
+  const decided = (condition) => {
+    if (!Array.isArray(condition)) return typeof condition === "boolean" ? condition : void 0;
+    const [operator, ...operands] = condition;
+    const isClass = (operand) => Array.isArray(operand) && operand.length === 2 && operand[0] === "get" && (operand[1] === drawn.field || typeof operand[1] === "object" && operand[1] !== null && operand[1].kind === "tileflow-data-field" && operand[1].name === "class");
+    const among = (labels2) => {
+      const hits = [...drawn.classes].filter((value2) => labels2.includes(value2)).length;
+      return hits === 0 ? false : hits === drawn.classes.size ? true : void 0;
+    };
+    if ((operator === "==" || operator === "!=") && operands.length === 2) {
+      const label = isClass(operands[0]) ? operands[1] : isClass(operands[1]) ? operands[0] : null;
+      if (typeof label !== "string") return void 0;
+      const equal2 = among([label]);
+      return equal2 === void 0 ? void 0 : operator === "==" ? equal2 : !equal2;
+    }
+    if (operator === "match" && operands.length === 4 && isClass(operands[0]) && typeof operands[2] === "boolean" && typeof operands[3] === "boolean") {
+      const labels2 = Array.isArray(operands[1]) ? operands[1] : [operands[1]];
+      const matched = among(labels2);
+      return matched === void 0 ? void 0 : matched ? operands[2] : operands[3];
+    }
+    if (operator === "!" && operands.length === 1) {
+      const inner = decided(operands[0]);
+      return inner === void 0 ? void 0 : !inner;
+    }
+    if (operator === "all" || operator === "any") {
+      const results = operands.map(decided);
+      if (results.includes(operator === "all" ? false : true)) return operator !== "all";
+      return results.every((result) => result !== void 0) ? operator === "all" : void 0;
+    }
+    return void 0;
+  };
+  if (!Array.isArray(value) || value[0] !== "case") return value;
+  const branches = [];
+  for (let index = 1; index < value.length - 1; index += 2) {
+    const holds = decided(value[index]);
+    if (holds === false) continue;
+    const output = withinClasses(value[index + 1], drawn);
+    if (holds === true) return branches.length ? ["case", ...branches, output] : output;
+    branches.push(value[index], output);
+  }
+  const fallback = withinClasses(value.at(-1), drawn);
+  return branches.length ? ["case", ...branches, fallback] : fallback;
+}
 function isSolidRoadDash(value) {
   const output = expressionOutput(value);
   const dash = Array.isArray(output) && output[0] === "literal" ? output[1] : output;
@@ -8308,7 +9061,7 @@ function compileWater(request, context, language = "auto") {
   );
   if (config.enabled === false) return [];
   const source = context.data.sourceId;
-  const { fields, layers } = context.data.schema;
+  const { fields: fields2, layers: layers2 } = context.data.schema;
   const contributions = [];
   if (config.bodies) {
     for (const area of createAreaLayers(
@@ -8316,8 +9069,8 @@ function compileWater(request, context, language = "auto") {
         id: "tileflow-water",
         type: "fill",
         source,
-        "source-layer": layers.water,
-        filter: ["!=", ["get", fields.intermittent], 1]
+        "source-layer": layers2.water,
+        filter: ["!=", ["get", fields2.intermittent], 1]
       },
       config.bodies
     )) {
@@ -8337,8 +9090,8 @@ function compileWater(request, context, language = "auto") {
         id: "tileflow-water-intermittent",
         type: "fill",
         source,
-        "source-layer": layers.water,
-        filter: ["==", ["get", fields.intermittent], 1]
+        "source-layer": layers2.water,
+        filter: ["==", ["get", fields2.intermittent], 1]
       },
       config.intermittent.bodies
     )) {
@@ -8356,9 +9109,9 @@ function compileWater(request, context, language = "auto") {
   const sidecarBathymetry = bathymetryProduct?.vector;
   const usePrimaryBathymetryFallback = context.marine === void 0;
   const bathymetrySource = sidecarBathymetry?.sourceId ?? source;
-  const bathymetryLayer = sidecarBathymetry ? "bathymetry" : usePrimaryBathymetryFallback ? layers.bathymetry : void 0;
-  const bathymetryDepthField = sidecarBathymetry ? "min_depth" : usePrimaryBathymetryFallback ? fields.bathymetryMinDepth : void 0;
-  const bathymetrySortField = sidecarBathymetry ? "sort_key" : usePrimaryBathymetryFallback ? fields.bathymetrySortKey : void 0;
+  const bathymetryLayer = sidecarBathymetry ? "bathymetry" : usePrimaryBathymetryFallback ? layers2.bathymetry : void 0;
+  const bathymetryDepthField = sidecarBathymetry ? "min_depth" : usePrimaryBathymetryFallback ? fields2.bathymetryMinDepth : void 0;
+  const bathymetrySortField = sidecarBathymetry ? "sort_key" : usePrimaryBathymetryFallback ? fields2.bathymetrySortKey : void 0;
   if (bathymetryLayer && bathymetryDepthField && bathymetrySortField) {
     const depth = context.colors.hydro.depth;
     const depthStops = bathymetryDepthStops(depth);
@@ -8558,11 +9311,11 @@ function compileWater(request, context, language = "auto") {
           id: `tileflow-waterway-${name}`,
           type: "line",
           source,
-          "source-layer": layers.waterway,
+          "source-layer": layers2.waterway,
           filter: [
             "all",
-            classFilter3(fields.class, classes),
-            ["!=", ["get", fields.intermittent], 1]
+            classFilter3(fields2.class, classes),
+            ["!=", ["get", fields2.intermittent], 1]
           ]
         },
         style
@@ -8587,11 +9340,11 @@ function compileWater(request, context, language = "auto") {
           id: `tileflow-waterway-${name}-intermittent`,
           type: "line",
           source,
-          "source-layer": layers.waterway,
+          "source-layer": layers2.waterway,
           filter: [
             "all",
-            classFilter3(fields.class, classes),
-            ["==", ["get", fields.intermittent], 1]
+            classFilter3(fields2.class, classes),
+            ["==", ["get", fields2.intermittent], 1]
           ]
         },
         mergeTileflowDesign(style, intermittent)
@@ -8606,8 +9359,8 @@ function compileWater(request, context, language = "auto") {
 }
 function appendBathymetryNames(contributions, options) {
   const { context, language } = options;
-  const { fields } = tileflowBathymetryV1Schema;
-  const localName = ["to-string", ["coalesce", ["get", fields.name], ""]];
+  const { fields: fields2 } = tileflowBathymetryV1Schema;
+  const localName = ["to-string", ["coalesce", ["get", fields2.name], ""]];
   const name = language === "auto" || language === "local" ? localName : [
     "case",
     ["!=", ["to-string", ["coalesce", ["get", `name:${language}`], ""]], ""],
@@ -8618,7 +9371,7 @@ function appendBathymetryNames(contributions, options) {
     {
       minZoom: 0,
       placement: "point",
-      priority: expression(["to-number", ["get", fields.sortKey], 0]),
+      priority: expression(["to-number", ["get", fields2.sortKey], 0]),
       priorityOrder: "lower-first",
       text: {
         ...typographyTextStyle(context.typography.water),
@@ -8636,8 +9389,8 @@ function appendBathymetryNames(contributions, options) {
     options.style
   );
   if (style.visible === false || style.text?.visible === false) return;
-  const sourceMinimum = ["to-number", ["coalesce", ["get", fields.minZoom], 0], 0];
-  const sourceMaximum = ["to-number", ["coalesce", ["get", fields.maxZoom], 24], 24];
+  const sourceMinimum = ["to-number", ["coalesce", ["get", fields2.minZoom], 0], 0];
+  const sourceMaximum = ["to-number", ["coalesce", ["get", fields2.maxZoom], 24], 24];
   const ranges = options.availability === true ? void 0 : [...options.availability.zoomRanges].sort(
     (left, right) => left.minZoom - right.minZoom || left.maxZoom - right.maxZoom
   );
@@ -9078,8 +9831,8 @@ function assertProvidedServices(domain, services) {
   }
 }
 function checkedModuleRecord(entries) {
-  const record3 = Object.fromEntries(entries);
-  const actual = Object.keys(record3).sort(compareCodeUnits3);
+  const record4 = Object.fromEntries(entries);
+  const actual = Object.keys(record4).sort(compareCodeUnits3);
   if (actual.length !== tileflowSemanticDomainRegistry.length || actual.some(
     (name, index) => name !== [...tileflowSemanticDomainRegistry.map(({ name: name2 }) => name2)].sort(compareCodeUnits3)[index]
   )) {
@@ -9087,7 +9840,7 @@ function checkedModuleRecord(entries) {
       "Tileflow semantic domain registry did not produce one value for every module."
     );
   }
-  return record3;
+  return record4;
 }
 function assertRegistryIsValid() {
   const names = /* @__PURE__ */ new Set();
@@ -9146,12 +9899,12 @@ function readTileflowCompilerProvenance(layer) {
   const target = metadata[tileflowCompilerMetadataKeys.target];
   return owner && slot && typeof target === "string" && tileflowSemanticTargetPattern.test(target) ? [{ operations: [], owner, slot, target }] : [];
 }
-function createTileflowStyleInspection(map, theme, layers) {
+function createTileflowStyleInspection(map, theme, layers2) {
   return {
     schemaVersion: tileflowStyleInspectionSchemaVersion,
     map,
     theme,
-    layers: layers.map((layer, index) => ({
+    layers: layers2.map((layer, index) => ({
       id: typeof layer.id === "string" ? layer.id : "",
       index,
       type: typeof layer.type === "string" ? layer.type : "",
@@ -9251,12 +10004,12 @@ var classicManifestSchemaOperations = {
 
 // src/portable-identity-schema.ts
 function createPortableIdentitySchemas(operations) {
-  const bounded = operations.maxLength(
+  const bounded2 = operations.maxLength(
     operations.minLength(operations.string(), 1),
     tileflowPortableIdMaximumLength
   );
   const pattern = operations.regex(
-    bounded,
+    bounded2,
     tileflowPortableIdPattern,
     "Expected lowercase kebab-case beginning with a letter"
   );
@@ -9370,7 +10123,7 @@ function insertTileflowOverlays(input) {
         available.length > 0 ? `Use one of: ${available.join(", ")}.` : "Declare the source first."
       );
     }
-    const layers2 = overlay.layers.map((layer, index) => {
+    const layers3 = overlay.layers.map((layer, index) => {
       if (layerIds.has(layer.id)) {
         throw new TileflowOverlayCompilationError(
           "TF_OVERLAY_LAYER_ID_DUPLICATE",
@@ -9388,21 +10141,21 @@ function insertTileflowOverlays(input) {
         }
       };
     });
-    groups.set(overlay.placement, [...groups.get(overlay.placement) ?? [], ...layers2]);
+    groups.set(overlay.placement, [...groups.get(overlay.placement) ?? [], ...layers3]);
     identities[overlayId] = Object.freeze({
       layers: Object.freeze(overlay.layers.map(({ id: id2 }) => id2)),
       placement: overlay.placement,
       source: overlay.source
     });
   }
-  let layers = input.basemapLayers.map(cloneJson18);
+  let layers2 = input.basemapLayers.map(cloneJson18);
   for (const placement of tileflowOverlayPlacements) {
     const overlayLayers = groups.get(placement);
     if (!overlayLayers?.length) continue;
-    const index = tileflowOverlayInsertionIndex(layers, placement);
-    layers = [...layers.slice(0, index), ...overlayLayers, ...layers.slice(index)];
+    const index = tileflowOverlayInsertionIndex(layers2, placement);
+    layers2 = [...layers2.slice(0, index), ...overlayLayers, ...layers2.slice(index)];
   }
-  return { identities, layers };
+  return { identities, layers: layers2 };
 }
 function isSafeLocalPmtilesPath(value) {
   if (typeof value !== "string" || value.length > 512 || !value.endsWith(".pmtiles") || value.includes("\\") || /[\p{Cc}?#]/u.test(value)) {
@@ -9426,8 +10179,8 @@ function cloneJson18(value) {
     Object.entries(value).map(([key, child]) => [key, cloneJson18(child)])
   );
 }
-function tileflowOverlayInsertionIndex(layers, placement) {
-  const ranks = layers.map((layer) => {
+function tileflowOverlayInsertionIndex(layers2, placement) {
+  const ranks = layers2.map((layer) => {
     const slots = readTileflowCompilerProvenance(layer).map(
       ({ slot }) => tileflowLayerSlots.indexOf(slot)
     );
@@ -9634,6 +10387,14 @@ function validateBoundaryChoroplethOverlays(mapId, overlays, boundaryAreas) {
   return overlays;
 }
 
+// src/notices.ts
+var tileflowNoticesMetadataKey = "tileflow:notices";
+var tileflowNoticeLimits = Object.freeze({
+  maxNotices: 8,
+  maxSources: 16,
+  maxTextLength: 120
+});
+
 // src/resolved-map-schema.ts
 import { Color as Color3 } from "@maplibre/maplibre-gl-style-spec";
 import { z as z5 } from "zod";
@@ -10271,12 +11032,12 @@ function dataSource() {
   return Object.freeze({ kind: "tileflow-data-source", name: "primary" });
 }
 function createSemanticDataView(data) {
-  const fields = Object.fromEntries(
+  const fields2 = Object.fromEntries(
     Object.entries(data.schema.fields).flatMap(
       ([name, value]) => value === void 0 ? [] : [[name, field(name)]]
     )
   );
-  const layers = Object.fromEntries(
+  const layers2 = Object.fromEntries(
     Object.entries(data.schema.layers).flatMap(
       ([name, value]) => value === void 0 ? [] : [[name, dataLayer(name)]]
     )
@@ -10284,7 +11045,7 @@ function createSemanticDataView(data) {
   return {
     ...data,
     sourceId: dataSource(),
-    schema: { ...data.schema, fields, layers }
+    schema: { ...data.schema, fields: fields2, layers: layers2 }
   };
 }
 function bindSemanticReferences(value, data) {
@@ -10306,21 +11067,21 @@ function bindSemanticValue(value, schema, sourceId) {
   }
   if (isDataSourceReference(value)) return sourceId;
   if (Array.isArray(value)) return value.map((item) => bindSemanticValue(item, schema, sourceId));
-  if (!isRecord4(value)) return value;
+  if (!isRecord5(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([key, item]) => [key, bindSemanticValue(item, schema, sourceId)])
   );
 }
 function isDataFieldReference2(value) {
-  return isRecord4(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
+  return isRecord5(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
 }
 function isDataLayerReference(value) {
-  return isRecord4(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
+  return isRecord5(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
 }
 function isDataSourceReference(value) {
-  return isRecord4(value) && value.kind === "tileflow-data-source" && value.name === "primary";
+  return isRecord5(value) && value.kind === "tileflow-data-source" && value.name === "primary";
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compareCodeUnits5(left, right) {
@@ -10424,8 +11185,8 @@ function createTileflowLayerTemplateIR(layer, semanticKey) {
     renderer: type,
     ...filter === void 0 ? {} : { selector: cloneJson20(filter) },
     style: Object.freeze({
-      ...isRecord5(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
-      ...isRecord5(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
+      ...isRecord6(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
+      ...isRecord6(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
     })
   });
 }
@@ -10448,12 +11209,12 @@ function materializeTileflowLayerFamilyIR(template, semantics) {
   });
 }
 function lowerTileflowDomainIR(families, data, resolvePhysicalId = physicalLayerIdForSemanticKey) {
-  const layers = families.map(
+  const layers2 = families.map(
     (family) => bindSemanticReferences(emitLayer(family, resolvePhysicalId), data)
   );
-  assertNoSemanticReferences(layers);
+  assertNoSemanticReferences(layers2);
   const ids = /* @__PURE__ */ new Set();
-  for (const layer of layers) {
+  for (const layer of layers2) {
     if (ids.has(layer.id)) {
       throw new TileflowDomainIRError(
         "TILEFLOW_DOMAIN_IR_DUPLICATE_PHYSICAL_ID",
@@ -10462,7 +11223,7 @@ function lowerTileflowDomainIR(families, data, resolvePhysicalId = physicalLayer
     }
     ids.add(layer.id);
   }
-  return Object.freeze({ layers: Object.freeze(layers) });
+  return Object.freeze({ layers: Object.freeze(layers2) });
 }
 var TileflowDomainIRError = class extends Error {
   code;
@@ -10616,7 +11377,11 @@ var exactPhysicalLayerIds = Object.freeze({
 });
 var nauticalPhysicalBases = Object.freeze({
   "nautical.aids": "tileflow-nautical-aids",
+  "nautical.beacons": "tileflow-nautical-beacons",
+  "nautical.buoys": "tileflow-nautical-buoys",
+  "nautical.cables": "tileflow-nautical-cables",
   "nautical.coverage": "tileflow-nautical-coverage",
+  "nautical.harbours": "tileflow-nautical-harbours",
   "nautical.hazardAreas": "tileflow-nautical-hazard-areas",
   "nautical.hazards": "tileflow-nautical-hazards",
   "nautical.labels.coverage": "tileflow-nautical-coverage-labels",
@@ -10627,7 +11392,9 @@ var nauticalPhysicalBases = Object.freeze({
   "nautical.lighthouses": "tileflow-nautical-lighthouses",
   "nautical.lights": "tileflow-nautical-lights",
   "nautical.navigationAreas": "tileflow-nautical-navigation-areas",
+  "nautical.ports": "tileflow-nautical-ports",
   "nautical.reefs": "tileflow-nautical-reefs",
+  "nautical.routes": "tileflow-nautical-routes",
   "nautical.soundings": "tileflow-nautical-soundings",
   "nautical.wreckAreas": "tileflow-nautical-wreck-areas",
   "nautical.wrecks": "tileflow-nautical-wrecks"
@@ -10679,21 +11446,21 @@ function visitReferences(value, counts, visited = /* @__PURE__ */ new WeakSet())
   }
 }
 function isSemanticFieldReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-field";
+  return isRecord6(value) && value.kind === "tileflow-data-field";
 }
 function isSemanticLayerReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-layer";
+  return isRecord6(value) && value.kind === "tileflow-data-layer";
 }
 function isSemanticSourceReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-source";
+  return isRecord6(value) && value.kind === "tileflow-data-source";
 }
 function cloneJson20(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord4(value) {
-  return isRecord5(value) ? value : {};
+  return isRecord6(value) ? value : {};
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -10745,7 +11512,7 @@ function validateTileflowRenderSelectorConstraints(input) {
   };
   while (pending.length > 0) {
     const current = pending.pop();
-    if (!isRecord6(current.selector) || typeof current.selector.kind !== "string") {
+    if (!isRecord7(current.selector) || typeof current.selector.kind !== "string") {
       addIssue(
         "invalid-selector",
         "a render selector must be a semantic selector node",
@@ -10806,7 +11573,7 @@ function validateTileflowRenderSelectorConstraints(input) {
         }
         for (const [index, branch] of current.selector.branches.entries()) {
           const branchPath = [...branchesPath, index];
-          if (!isRecord6(branch)) {
+          if (!isRecord7(branch)) {
             addIssue("invalid-selector", "match selector branch must be an object", branchPath);
             continue;
           }
@@ -10837,14 +11604,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 (!isRecord6(stop)) {
+          if (!isRecord7(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 (!isRecord6(stop)) continue;
+          if (!isRecord7(stop)) continue;
           const zoom3 = stop.zoom;
           const zoomPath = [...stopsPath, index, "zoom"];
           if (typeof zoom3 !== "number" || !Number.isFinite(zoom3) || zoom3 < 0 || zoom3 > 24) {
@@ -10908,18 +11675,18 @@ function compileRenderSelector(selector, data) {
   assertRenderSelectorConstraints(selector);
   return lowerSelector(selector, data);
 }
-function applyCompiledRenderStacks(input, operations) {
-  let layers = input.map(cloneJson21);
+function applyCompiledRenderStacks(input, operations, targetsOfOtherModes = /* @__PURE__ */ new Map()) {
+  let layers2 = input.map(cloneJson21);
   const passes = operations.filter(
     (operation) => operation.kind === "layer"
   );
   const refinements = operations.filter(
     (operation) => operation.kind === "refinement"
   );
-  requireUniqueCompiledLayers(layers, passes);
+  requireUniqueCompiledLayers(layers2, passes);
   const passTargets = new Set(passes.map(({ target }) => target));
-  const knownTargets = /* @__PURE__ */ new Set([...layers.map(({ target }) => target), ...passTargets]);
-  const activeOwners = new Set(layers.map(({ owner }) => owner));
+  const knownTargets = /* @__PURE__ */ new Set([...layers2.map(({ target }) => target), ...passTargets]);
+  const activeOwners = new Set(layers2.map(({ owner }) => owner));
   const drawn = /* @__PURE__ */ new Set();
   for (let changed = true; changed; ) {
     changed = false;
@@ -10937,11 +11704,12 @@ function applyCompiledRenderStacks(input, operations) {
     (refinement) => refinement.requirements.every((requirement) => activeOwners.has(requirement))
   ).sort(compareCompiledOperations);
   for (const refinement of activeRefinements) {
-    const index = findTargetIndex(layers, refinement.target);
+    const index = findTargetIndex(layers2, refinement.target);
     if (index < 0 && !passTargets.has(refinement.target)) {
+      const other = targetsOfOtherModes.get(refinement.target);
       throw renderStackError(
         "unknown-refinement-target",
-        `Render refinement targets unknown semantic contribution: ${refinement.target}.`
+        other === void 0 ? `Render refinement targets unknown semantic contribution: ${refinement.target}.` : `Render refinement targets ${refinement.target}, ${describeOtherMode(other)}`
       );
     }
     if (refinement.placement !== void 0 && placementAnchor(refinement.placement) === refinement.target) {
@@ -10963,20 +11731,21 @@ function applyCompiledRenderStacks(input, operations) {
   for (const operation of pending) {
     const anchor = placementAnchor(operation.placement);
     if (anchor !== void 0 && !knownTargets.has(anchor)) {
+      const other = targetsOfOtherModes.get(anchor);
       throw renderStackError(
         "unknown-or-circular-anchor",
-        `${operation.target} is placed beside unknown semantic target ${anchor}.`
+        other === void 0 ? `${operation.target} is placed beside unknown semantic target ${anchor}.` : `${operation.target} is placed beside ${anchor}, ${describeOtherMode(other)}`
       );
     }
   }
   const lastPlaced = /* @__PURE__ */ new Map();
   const isMovePending = (target) => pending.some((operation) => operation.kind === "refinement" && operation.target === target);
   const isReady = (operation) => {
-    if (operation.kind === "refinement" && findTargetIndex(layers, operation.target) < 0) {
+    if (operation.kind === "refinement" && findTargetIndex(layers2, operation.target) < 0) {
       return false;
     }
     const anchor = placementAnchor(operation.placement);
-    return anchor === void 0 || findTargetIndex(layers, anchor) >= 0 && !isMovePending(anchor);
+    return anchor === void 0 || findTargetIndex(layers2, anchor) >= 0 && !isMovePending(anchor);
   };
   while (pending.length > 0) {
     const first = pending.find(isReady);
@@ -10994,34 +11763,34 @@ function applyCompiledRenderStacks(input, operations) {
     const moved = /* @__PURE__ */ new Map();
     for (const operation of group) {
       if (operation.kind !== "refinement") continue;
-      const index2 = findTargetIndex(layers, operation.target);
-      moved.set(operation.target, requireRefinementOwner(layers[index2], operation));
-      layers = [...layers.slice(0, index2), ...layers.slice(index2 + 1)];
+      const index2 = findTargetIndex(layers2, operation.target);
+      moved.set(operation.target, requireRefinementOwner(layers2[index2], operation));
+      layers2 = [...layers2.slice(0, index2), ...layers2.slice(index2 + 1)];
       for (const [placed, target] of lastPlaced) {
         if (target === operation.target) lastPlaced.delete(placed);
       }
     }
     const placement = first.placement;
     const anchor = placementAnchor(placement);
-    const anchorLayer = anchor === void 0 ? void 0 : layers[findTargetIndex(layers, anchor)];
+    const anchorLayer = anchor === void 0 ? void 0 : layers2[findTargetIndex(layers2, anchor)];
     const slot = anchorLayer === void 0 ? tileflowBandPlacementSlot(placement) : requireSemanticSlot(anchorLayer, anchor);
     const block = group.map(
       (operation) => operation.kind === "layer" ? materializeRenderLayer(operation, anchorLayer, slot) : moveLayer(moved.get(operation.target), operation, slot, anchorLayer)
     );
     const previous = lastPlaced.get(key);
-    const previousIndex = previous === void 0 ? -1 : findTargetIndex(layers, previous);
-    const index = anchorLayer !== void 0 ? findTargetIndex(layers, anchor) + (key.startsWith("above:") ? 1 : 0) : previousIndex >= 0 ? previousIndex + 1 : tileflowBandPlacementIndex(
-      layers.map((candidate) => tileflowLayerSlots.indexOf(candidate.slot)),
+    const previousIndex = previous === void 0 ? -1 : findTargetIndex(layers2, previous);
+    const index = anchorLayer !== void 0 ? findTargetIndex(layers2, anchor) + (key.startsWith("above:") ? 1 : 0) : previousIndex >= 0 ? previousIndex + 1 : tileflowBandPlacementIndex(
+      layers2.map((candidate) => tileflowLayerSlots.indexOf(candidate.slot)),
       placement
     );
-    layers = [...layers.slice(0, index), ...block, ...layers.slice(index)];
+    layers2 = [...layers2.slice(0, index), ...block, ...layers2.slice(index)];
     lastPlaced.set(key, block.at(-1).target);
   }
   for (const refinement of activeRefinements) {
     if (refinement.patch === void 0) continue;
-    const index = findTargetIndex(layers, refinement.target);
+    const index = findTargetIndex(layers2, refinement.target);
     if (index < 0) continue;
-    const previous = requireRefinementOwner(layers[index], refinement);
+    const previous = requireRefinementOwner(layers2[index], refinement);
     const expectedType = rendererLayerType(refinement.renderer);
     if (previous.renderer !== expectedType) {
       throw renderStackError(
@@ -11029,9 +11798,9 @@ function applyCompiledRenderStacks(input, operations) {
         `Render refinement ${refinement.target} expects ${expectedType}, found ${String(previous.renderer)}.`
       );
     }
-    layers[index] = applyRefinement(previous, { ...refinement, patch: refinement.patch });
+    layers2[index] = applyRefinement(previous, { ...refinement, patch: refinement.patch });
   }
-  return layers;
+  return layers2;
 }
 function requireRefinementOwner(layer, refinement) {
   if (layer.owner !== refinement.owner) {
@@ -11169,7 +11938,7 @@ function applyRendererStyle(layer, renderer, style) {
   };
 }
 function lowerSelector(selector, data) {
-  if (!isRecord6(selector) || typeof selector.kind !== "string") {
+  if (!isRecord7(selector) || typeof selector.kind !== "string") {
     throw renderStackError(
       "invalid-selector",
       "A render selector must be a semantic selector node."
@@ -11372,7 +12141,7 @@ function requireRenderer(value) {
 function requirePlacement(value) {
   if (typeof value === "string") {
     if (tileflowBandPlacements.includes(value)) return;
-  } else if (isRecord6(value)) {
+  } else if (isRecord7(value)) {
     const keys = Object.keys(value);
     if (keys.length === 1 && (keys[0] === "above" || keys[0] === "below")) {
       requirePortableTarget(value[keys[0]], "render placement target");
@@ -11399,7 +12168,7 @@ function validateRefinementShape(operation) {
   validateStyle(operation.renderer, operation.style);
 }
 function validateStyle(renderer, style) {
-  if (!isRecord6(style)) {
+  if (!isRecord7(style)) {
     throw renderStackError(
       "invalid-style",
       `A ${renderer} render operation requires a style object.`
@@ -11501,7 +12270,7 @@ function normalizeRequirements(requirements) {
   return [...requirements];
 }
 function requireRenderStackEntries(stack) {
-  if (!isRecord6(stack)) {
+  if (!isRecord7(stack)) {
     throw renderStackError("invalid-stack", "A render stack must be a named operation record.");
   }
   const entries = Object.entries(stack);
@@ -11550,9 +12319,9 @@ function requireOperationName(name) {
     );
   }
 }
-function requireUniqueCompiledLayers(layers, operations) {
-  const keys = new Set(layers.map(({ key }) => key));
-  const targets = new Set(layers.map(({ target }) => target));
+function requireUniqueCompiledLayers(layers2, operations) {
+  const keys = new Set(layers2.map(({ key }) => key));
+  const targets = new Set(layers2.map(({ target }) => target));
   for (const operation of operations) {
     if (keys.has(operation.template.key)) {
       throw renderStackError(
@@ -11612,8 +12381,8 @@ function requireSemanticSlot(layer, target) {
   }
   return layer.slot;
 }
-function findTargetIndex(layers, target) {
-  return layers.findIndex((layer) => layer.target === target);
+function findTargetIndex(layers2, target) {
+  return layers2.findIndex((layer) => layer.target === target);
 }
 function requireScalar(value, description) {
   if (typeof value !== "boolean" && typeof value !== "number" && typeof value !== "string" || typeof value === "number" && !Number.isFinite(value)) {
@@ -11638,6 +12407,9 @@ function assertOnlyKeys(input, allowed, description) {
     );
   }
 }
+function describeOtherMode({ activeMode, mode, owner }) {
+  return `which ${owner} draws only in mode '${mode}'; this map draws ${owner} in mode '${activeMode}'. Place the operation beside a target drawn in mode '${activeMode}' or at a band edge, or remove it; refine({mode: '${activeMode}', renderStack: reset()}) removes an inherited ${owner} render stack.`;
+}
 function renderStackError(code, message) {
   return Object.assign(new Error(message), { code, name: "TileflowRenderStackError" });
 }
@@ -11648,9 +12420,9 @@ function cloneJson21(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord5(value) {
-  return isRecord6(value) ? value : {};
+  return isRecord7(value) ? value : {};
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -12721,6 +13493,29 @@ function boundedThemeNumberSchema(min, max) {
     }).strict()
   ]);
 }
+var entranceBandSchema = z5.tuple([z5.number().finite().min(0).max(24), z5.number().finite().min(0).max(24)]).refine(([from, to]) => from < to, "A band starts at a lower zoom than it ends.");
+var modelRoleLightingSchema = z5.object({
+  emissiveStrength: boundedThemeNumberSchema(0, 5).optional(),
+  emissiveVariation: boundedThemeNumberSchema(0, 1).optional(),
+  emissiveColor: themeColorValueSchema.optional(),
+  color: themeColorValueSchema.optional(),
+  colorMix: boundedThemeNumberSchema(0, 1).optional(),
+  metallic: boundedThemeNumberSchema(0, 1).optional(),
+  roughness: boundedThemeNumberSchema(0, 1).optional(),
+  colorVariation: z5.object({
+    hue: z5.tuple([boundedThemeNumberSchema(0, 360), boundedThemeNumberSchema(0, 360)]),
+    saturation: z5.tuple([boundedThemeNumberSchema(0, 100), boundedThemeNumberSchema(0, 100)]),
+    lightness: z5.tuple([boundedThemeNumberSchema(0, 100), boundedThemeNumberSchema(0, 100)]),
+    space: z5.enum(["srgb", "linear"]).optional()
+  }).strict().optional(),
+  emissiveHeight: z5.tuple([
+    boundedThemeNumberSchema(0, 1),
+    boundedThemeNumberSchema(0, 1),
+    boundedThemeNumberSchema(0, 1),
+    boundedThemeNumberSchema(0, 1),
+    boundedThemeNumberSchema(-1, 1)
+  ]).optional()
+}).strict();
 var buildingsModuleSchema = z5.object({
   type: z5.literal("buildings"),
   businessCorridor: areaStyleSchema.optional(),
@@ -12736,7 +13531,27 @@ var buildingsModuleSchema = z5.object({
     edgeRadius: z5.number().min(0).max(1).optional(),
     edgeColor: themeColorValueSchema.optional(),
     nightLight: boundedThemeNumberSchema(0, 2).optional(),
+    floodLight: z5.object({
+      intensity: boundedThemeNumberSchema(0, 1).optional(),
+      brightnessScale: boundedThemeNumberSchema(0, 16).optional(),
+      color: themeColorValueSchema.optional(),
+      groundRadius: z5.tuple([z5.number().finite().min(0).max(2048), z5.number().finite().min(0).max(2048)]).refine(([min, max]) => min <= max, "The minimum radius must not exceed the maximum.").optional(),
+      minGroundHeight: z5.number().finite().min(0).max(6e3).optional(),
+      minWallHeight: z5.number().finite().min(0).max(6e3).optional(),
+      wallHeightRatio: z5.number().finite().min(0).max(1).optional()
+    }).strict().optional(),
+    modelLighting: z5.object({
+      unclassified: modelRoleLightingSchema.optional(),
+      wall: modelRoleLightingSchema.optional(),
+      door: modelRoleLightingSchema.optional(),
+      roof: modelRoleLightingSchema.optional(),
+      window: modelRoleLightingSchema.optional(),
+      lamp: modelRoleLightingSchema.optional(),
+      logo: modelRoleLightingSchema.optional()
+    }).strict().optional(),
+    entrance: z5.object({ buildings: entranceBandSchema.optional(), models: entranceBandSchema.optional() }).strict().optional(),
     occlusion: z5.boolean().optional(),
+    modelOcclusion: boundedThemeNumberSchema(0, 1).optional(),
     shadows: z5.boolean().optional(),
     windows: z5.boolean().optional(),
     models: z5.array(
@@ -12973,8 +13788,12 @@ var poiModuleSchema = z5.object({
 var nauticalModuleSchema = z5.object({
   type: z5.literal("nautical"),
   aids: markerSymbolStyleSchema.optional(),
+  beacons: markerSymbolStyleSchema.optional(),
+  buoys: markerSymbolStyleSchema.optional(),
+  cables: lineStyleSchema.optional(),
   coverage: areaStyleSchema.optional(),
   enabled: z5.boolean().optional(),
+  harbours: markerSymbolStyleSchema.optional(),
   hazardAreas: areaStyleSchema.optional(),
   hazards: markerSymbolStyleSchema.optional(),
   labels: z5.object({
@@ -12987,8 +13806,10 @@ var nauticalModuleSchema = z5.object({
   lighthouses: markerSymbolStyleSchema.optional(),
   lights: markerSymbolStyleSchema.optional(),
   navigationAreas: areaStyleSchema.optional(),
+  ports: markerSymbolStyleSchema.optional(),
   reefs: areaStyleSchema.optional(),
   renderStack: renderStackSchema.optional(),
+  routes: lineStyleSchema.optional(),
   soundings: markerSymbolStyleSchema.optional(),
   wreckAreas: areaStyleSchema.optional(),
   wrecks: markerSymbolStyleSchema.optional()
@@ -13108,6 +13929,7 @@ var layerBindingsSchema = z5.object({
   streetFurniture: z5.string().trim().min(1).optional(),
   trafficControl: z5.string().trim().min(1).optional(),
   tree: z5.string().trim().min(1).optional(),
+  transportationOutline: z5.string().trim().min(1).optional(),
   water: z5.string().trim().min(1),
   waterName: z5.string().trim().min(1),
   waterway: z5.string().trim().min(1)
@@ -13847,8 +14669,8 @@ function isSafeGlyphUrl(value) {
 function validateZoomRanges(value, context, path = []) {
   if (!value || typeof value !== "object") return;
   if (!Array.isArray(value)) {
-    const record3 = value;
-    if (typeof record3.minZoom === "number" && typeof record3.maxZoom === "number" && record3.minZoom > record3.maxZoom) {
+    const record4 = value;
+    if (typeof record4.minZoom === "number" && typeof record4.maxZoom === "number" && record4.minZoom > record4.maxZoom) {
       context.addIssue({
         code: "custom",
         path: [...path, "maxZoom"],
@@ -14470,7 +15292,7 @@ function applyTileflowIconCapabilities(style, icons) {
       "line-pattern",
       "background-pattern"
     ]) {
-      const pattern = record(layer.paint)[property];
+      const pattern = record2(layer.paint)[property];
       if (pattern !== void 0 && [...outputs(pattern, ids)].some((id2) => appearances[id2]?.representation === "sdf")) {
         throw Object.assign(new Error(`Layer "${layer.id}" cannot use an SDF icon as a pattern.`), {
           code: "TF_ICON_PATTERN_SDF",
@@ -14479,7 +15301,7 @@ function applyTileflowIconCapabilities(style, icons) {
         });
       }
     }
-    const image = record(layer.layout)["icon-image"];
+    const image = record2(layer.layout)["icon-image"];
     if (image === void 0) continue;
     if (typeof image === "string" && /\{[^{}]+\}/u.test(image) || typeof image !== "string" && !Array.isArray(image)) {
       throw Object.assign(new Error(`Layer "${layer.id}" has an unproven legacy icon selection.`), {
@@ -14501,7 +15323,7 @@ function applyTileflowIconCapabilities(style, icons) {
         }
       );
     }
-    const paint = { ...record(layer.paint) };
+    const paint = { ...record2(layer.paint) };
     for (const [property, limit] of [
       ["icon-halo-width", 2],
       ["icon-halo-blur", 1]
@@ -14531,7 +15353,7 @@ function applyTileflowIconCapabilities(style, icons) {
     layer.paint = paint;
   }
 }
-function record(value) {
+function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function outputs(value, ids) {
@@ -14620,8 +15442,8 @@ function defaultPaint(image, key, names, appearances, ids) {
 // src/cartography/interaction-manifest.ts
 var tileflowInteractionManifestMetadataKey = "tileflow:interaction-manifest";
 var tileflowInteractionManifestVersion = 3;
-function createTileflowInteractionManifest(layers, fields) {
-  const poiLayers = layers.flatMap((layer, priority) => {
+function createTileflowInteractionManifest(layers2, fields2) {
+  const poiLayers = layers2.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;
@@ -14650,7 +15472,7 @@ function createTileflowInteractionManifest(layers, fields) {
           identity: ["source", "source-layer", "feature-id"],
           representationPriority: ["marker", "icon", "combined", "label"]
         },
-        fields: { ...fields },
+        fields: { ...fields2 },
         hitTesting: { frequency: "animation-frame", order: "rendered-topmost" },
         identity: "maplibre-feature-id-if-present",
         layers: poiLayers
@@ -14659,13 +15481,13 @@ function createTileflowInteractionManifest(layers, fields) {
     version: tileflowInteractionManifestVersion
   };
 }
-function assertTileflowInteractionManifestLayers(manifest, layers) {
+function assertTileflowInteractionManifestLayers(manifest, layers2) {
   const poiLayers = manifest?.domains.poi?.layers ?? [];
   if (poiLayers.length > 256) {
     throw new Error("Tileflow interaction manifest exceeds the 256-layer POI lookup limit.");
   }
   const layersById = new Map(
-    layers.flatMap((layer) => typeof layer.id === "string" ? [[layer.id, layer]] : [])
+    layers2.flatMap((layer) => typeof layer.id === "string" ? [[layer.id, layer]] : [])
   );
   const poiNamespaces = new Set(
     poiLayers.map((layer) => `${layer.source}\0${layer.sourceLayer}`)
@@ -14714,11 +15536,11 @@ function isTileflowPoiCategory(value) {
   return typeof value === "string" && tileflowPoiCategories.includes(value);
 }
 function semanticTarget(layer) {
-  if (!isRecord7(layer.metadata)) return void 0;
+  if (!isRecord8(layer.metadata)) return void 0;
   const value = layer.metadata[tileflowCompilerMetadataKeys.target];
   return typeof value === "string" ? value : void 0;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSafeArtifactName(value) {
@@ -14729,9 +15551,9 @@ function isSafeArtifactName(value) {
 }
 
 // src/cartography/layout-zoom-diagnostics.ts
-function diagnoseFractionalLayoutZoomSteps(layers) {
+function diagnoseFractionalLayoutZoomSteps(layers2) {
   const diagnostics = [];
-  for (const layer of layers) {
+  for (const layer of layers2) {
     const layout = layer.layout;
     if (layout === null || typeof layout !== "object") continue;
     for (const [property, value] of Object.entries(layout)) {
@@ -14772,11 +15594,11 @@ function isZoom2(value) {
 // src/cartography/overlay-placement-manifest.ts
 var tileflowOverlayPlacementManifestMetadataKey = "tileflow:overlay-placement-manifest";
 var tileflowOverlayPlacementManifestSchemaVersion = 1;
-function createTileflowOverlayPlacementManifest(layers) {
+function createTileflowOverlayPlacementManifest(layers2) {
   const anchors = Object.fromEntries(
     tileflowOverlayPlacements.map((placement) => {
-      const index = tileflowOverlayInsertionIndex(layers, placement);
-      const id2 = index < layers.length ? layers[index]?.id : void 0;
+      const index = tileflowOverlayInsertionIndex(layers2, placement);
+      const id2 = index < layers2.length ? layers2[index]?.id : void 0;
       if (id2 !== void 0 && typeof id2 !== "string") {
         throw new Error(`Tileflow overlay placement ${placement} resolved an invalid layer ID.`);
       }
@@ -14788,7 +15610,7 @@ function createTileflowOverlayPlacementManifest(layers) {
     schemaVersion: tileflowOverlayPlacementManifestSchemaVersion
   };
 }
-function assertTileflowOverlayPlacementManifestLayers(manifest, layers) {
+function assertTileflowOverlayPlacementManifestLayers(manifest, layers2) {
   if (manifest.schemaVersion !== tileflowOverlayPlacementManifestSchemaVersion) {
     throw new Error("Tileflow overlay placement manifest schema version is unsupported.");
   }
@@ -14797,14 +15619,14 @@ function assertTileflowOverlayPlacementManifestLayers(manifest, layers) {
     throw new Error("Tileflow overlay placement manifest keys are invalid.");
   }
   const layerIndexes = new Map(
-    layers.flatMap(
+    layers2.flatMap(
       (layer, index) => typeof layer.id === "string" ? [[layer.id, index]] : []
     )
   );
   let previous = -1;
   for (const placement of tileflowOverlayPlacements) {
     const anchor = manifest.anchors[placement];
-    const index = anchor === null ? layers.length : layerIndexes.get(anchor);
+    const index = anchor === null ? layers2.length : layerIndexes.get(anchor);
     if (index === void 0) {
       throw new Error(`Tileflow overlay placement manifest references missing layer: ${anchor}`);
     }
@@ -14836,18 +15658,18 @@ var lineLayoutDefaults = {
   "line-round-limit": 1.05
 };
 function planTileflowLayerFamilies(input) {
-  let layers = input.map(cloneJson23);
-  layers = consolidateRoadLines(layers);
-  layers = consolidateRoadHatches(layers);
-  layers = consolidateRoadLabels(layers);
-  layers = consolidateFillFamily(layers, "land.landcover", "land.cohorts.landcover");
-  layers = consolidateFillFamily(layers, "land.landuse", "land.cohorts.landuse");
-  layers = consolidateWaterways(layers);
-  return layers;
-}
-function consolidateRoadLines(layers) {
+  let layers2 = input.map(cloneJson23);
+  layers2 = consolidateRoadLines(layers2);
+  layers2 = consolidateRoadHatches(layers2);
+  layers2 = consolidateRoadLabels(layers2);
+  layers2 = consolidateFillFamily(layers2, "land.landcover", "land.cohorts.landcover");
+  layers2 = consolidateFillFamily(layers2, "land.landuse", "land.cohorts.landuse");
+  layers2 = consolidateWaterways(layers2);
+  return layers2;
+}
+function consolidateRoadLines(layers2) {
   const groups = /* @__PURE__ */ new Map();
-  for (const [index, layer] of layers.entries()) {
+  for (const [index, layer] of layers2.entries()) {
     if (layer.renderer !== "line" || layer.family?.kind !== "road-line") continue;
     const key = layer.family.group;
     const group = groups.get(key) ?? [];
@@ -14862,7 +15684,7 @@ function consolidateRoadLines(layers) {
       continue;
     }
     const mergedId = eligible[0].layer.family.outputKey;
-    if (hasGeneratedKeyCollision(layers, mergedId, eligible)) continue;
+    if (hasGeneratedKeyCollision(layers2, mergedId, eligible)) continue;
     const merged = mergeRoadLineGroup(
       mergedId,
       eligible.map(({ layer }) => layer)
@@ -14876,10 +15698,10 @@ function consolidateRoadLines(layers) {
     }
     replacements.set(insertAt, [...replacements.get(insertAt) ?? [], merged]);
   }
-  return applyReplacements(layers, replacements);
+  return applyReplacements(layers2, replacements);
 }
-function canMergeRoadLines(layers) {
-  const common = layers[0];
+function canMergeRoadLines(layers2) {
+  const common = layers2[0];
   if (!common) return false;
   const supportedPaint = /* @__PURE__ */ new Set([...Object.keys(linePaintDefaults), "line-pattern"]);
   const supportedLayout = /* @__PURE__ */ new Set([
@@ -14887,18 +15709,20 @@ function canMergeRoadLines(layers) {
     "line-sort-key",
     "visibility"
   ]);
-  return layers.every(
+  return layers2.every(
     (layer) => sameLayerSource(layer, common) && Object.keys(layer.style.appearance ?? {}).every((key) => supportedPaint.has(key)) && Object.keys(layer.style.placement ?? {}).every((key) => supportedLayout.has(key)) && layer.style.appearance?.["line-pattern"] === void 0 && layer.style.placement?.visibility !== "none" && !isOrderedRenderPass(layer) && sameTopLevelProperties(layer, common, ["minZoom"])
   );
 }
-function mergeRoadLineGroup(key, layers) {
-  const first = layers[0];
-  const conditions = layers.map((layer) => asFilter(layer.selector));
+function mergeRoadLineGroup(key, layers2) {
+  const first = layers2[0];
+  const conditions = layers2.map((layer) => asFilter(layer.selector));
   if (conditions.some(containsZoom)) return void 0;
   const paint = {};
-  const paintKeys = new Set(layers.flatMap((layer) => Object.keys(layer.style.appearance ?? {})));
+  const paintKeys = new Set(layers2.flatMap((layer) => Object.keys(layer.style.appearance ?? {})));
   for (const key2 of paintKeys) {
-    const values = layers.map((layer) => layer.style.appearance?.[key2]);
+    const values = layers2.map((layer) => layer.style.appearance?.[key2]);
+    if (key2 === "line-dasharray" && values.every((value) => isSolidDash(value ?? linePaintDefaults[key2])))
+      continue;
     const combined = combineConditionalValues(
       values.map((value, index) => ({
         condition: conditions[index],
@@ -14912,7 +15736,7 @@ function mergeRoadLineGroup(key, layers) {
   }
   const layout = {};
   for (const key2 of Object.keys(lineLayoutDefaults)) {
-    const values = layers.map((layer, index) => ({
+    const values = layers2.map((layer, index) => ({
       condition: conditions[index],
       value: layer.style.placement?.[key2] ?? lineLayoutDefaults[key2]
     }));
@@ -14925,7 +15749,7 @@ function mergeRoadLineGroup(key, layers) {
     }
   }
   const sortKey = combineConditionalValues(
-    layers.map((layer, index) => ({
+    layers2.map((layer, index) => ({
       condition: conditions[index],
       value: rankedSortKey(layer.style.placement?.["line-sort-key"] ?? 0, index)
     })),
@@ -14942,16 +15766,16 @@ function mergeRoadLineGroup(key, layers) {
       selector: unionFilters(conditions),
       range: {
         minZoom: roadHighZoom,
-        ...finiteMaximumZoom(layers) === void 0 ? {} : { maxZoom: finiteMaximumZoom(layers) }
+        ...finiteMaximumZoom(layers2) === void 0 ? {} : { maxZoom: finiteMaximumZoom(layers2) }
       },
       style: { appearance: paint, placement: layout }
     },
-    layers
+    layers2
   );
 }
-function consolidateRoadHatches(layers) {
+function consolidateRoadHatches(layers2) {
   const groups = /* @__PURE__ */ new Map();
-  for (const [index, layer] of layers.entries()) {
+  for (const [index, layer] of layers2.entries()) {
     if (layer.renderer !== "symbol" && layer.renderer !== "line" || layer.family?.kind !== "road-hatch") {
       continue;
     }
@@ -14971,7 +15795,7 @@ function consolidateRoadHatches(layers) {
       continue;
     }
     const mergedId = first.family.outputKey;
-    if (hasGeneratedKeyCollision(layers, mergedId, entries)) continue;
+    if (hasGeneratedKeyCollision(layers2, mergedId, entries)) continue;
     const conditions = entries.map(({ layer }) => asFilter(layer.selector));
     const sortKeyProperty = first.renderer === "line" ? "line-sort-key" : "symbol-sort-key";
     const layoutKeys = new Set(
@@ -15076,17 +15900,17 @@ function consolidateRoadHatches(layers) {
     for (const { index } of entries) replacements.set(index, []);
     replacements.set(entries.at(-1).index, [merged]);
   }
-  return applyReplacements(layers, replacements);
+  return applyReplacements(layers2, replacements);
 }
-function consolidateRoadLabels(layers) {
-  const candidates = layers.map((layer, index) => ({
+function consolidateRoadLabels(layers2) {
+  const candidates = layers2.map((layer, index) => ({
     index,
     layer,
     roadClass: layer.family?.kind === "road-label" ? layer.family.member : void 0
   })).filter(
     ({ layer, roadClass }) => layer.renderer === "symbol" && roadClass !== void 0 && layer.feature?.dataLayer !== void 0
   );
-  if (candidates.some(({ layer }) => isOrderedRenderPass(layer))) return layers;
+  if (candidates.some(({ layer }) => isOrderedRenderPass(layer))) return layers2;
   const groups = /* @__PURE__ */ new Map();
   for (const candidate of candidates) {
     const { layer } = candidate;
@@ -15108,7 +15932,7 @@ function consolidateRoadLabels(layers) {
     if (!group.every(({ layer }) => sameTopLevelProperties(layer, first))) continue;
     const conditions = group.map(({ layer }) => asFilter(layer.selector));
     const key = group.some(({ roadClass }) => roadClass === "motorway") ? "labels.cohorts.roads.major" : group.some(({ roadClass }) => roadClass === "service") ? "labels.cohorts.roads.local" : `labels.cohorts.roads.cohort${groupNumber++}`;
-    if (hasGeneratedKeyCollision(layers, key, group)) continue;
+    if (hasGeneratedKeyCollision(layers2, key, group)) continue;
     const layout = { ...first.style.placement ?? {} };
     const sortKeyValues = group.map(({ layer }, index) => {
       const original = layer.style.placement?.["symbol-sort-key"] ?? 0;
@@ -15133,13 +15957,13 @@ function consolidateRoadLabels(layers) {
     for (const { index } of group) replacements.set(index, []);
     replacements.set(group.at(-1).index, [merged]);
   }
-  return applyReplacements(layers, replacements);
+  return applyReplacements(layers2, replacements);
 }
-function consolidateFillFamily(layers, group, mergedId) {
-  const candidates = layers.map((layer, index) => ({ index, layer })).filter(
+function consolidateFillFamily(layers2, group, mergedId) {
+  const candidates = layers2.map((layer, index) => ({ index, layer })).filter(
     ({ layer }) => layer.renderer === "fill" && layer.family?.kind === "fill" && layer.family.group === group
   );
-  if (candidates.some(({ layer }) => isOrderedRenderPass(layer))) return layers;
+  if (candidates.some(({ layer }) => isOrderedRenderPass(layer))) return layers2;
   const groups = /* @__PURE__ */ new Map();
   for (const candidate of candidates) {
     const { layer } = candidate;
@@ -15211,7 +16035,7 @@ function consolidateFillFamily(layers, group, mergedId) {
       if (!sortKey.ok) continue;
       layout["fill-sort-key"] = sortKey.value;
       const key = suffix === 0 ? mergedId : `${mergedId}.cohort${suffix}`;
-      if (hasGeneratedKeyCollision(layers, key, group2)) continue;
+      if (hasGeneratedKeyCollision(layers2, key, group2)) continue;
       const merged = withMergedOrigins(
         {
           ...first,
@@ -15226,20 +16050,20 @@ function consolidateFillFamily(layers, group, mergedId) {
       replacements.set(group2.at(-1).index, [merged]);
     }
   }
-  return applyReplacements(layers, replacements);
+  return applyReplacements(layers2, replacements);
 }
-function consolidateWaterways(layers) {
+function consolidateWaterways(layers2) {
   const replacements = /* @__PURE__ */ new Map();
   for (const name of ["river", "canal", "stream", "other"]) {
-    const regularIndex = layers.findIndex(
+    const regularIndex = layers2.findIndex(
       (layer) => layer.family?.kind === "waterway" && layer.family.group === name && layer.family.variant === "regular"
     );
-    const intermittentIndex = layers.findIndex(
+    const intermittentIndex = layers2.findIndex(
       (layer) => layer.family?.kind === "waterway" && layer.family.group === name && layer.family.variant === "intermittent"
     );
     if (regularIndex < 0 || intermittentIndex < 0) continue;
-    const regular = layers[regularIndex];
-    const intermittent = layers[intermittentIndex];
+    const regular = layers2[regularIndex];
+    const intermittent = layers2[intermittentIndex];
     if (!sameLayerSource(regular, intermittent) || isOrderedRenderPass(regular) || isOrderedRenderPass(intermittent) || intermittentIndex !== regularIndex + 1 || minimumZoom(regular) !== minimumZoom(intermittent) || maximumZoom(regular) !== maximumZoom(intermittent) || !allEqual([regular.style.placement ?? {}, intermittent.style.placement ?? {}]) || !sameTopLevelProperties(regular, intermittent)) {
       continue;
     }
@@ -15298,7 +16122,7 @@ function consolidateWaterways(layers) {
     replacements.set(regularIndex, []);
     replacements.set(intermittentIndex, [merged]);
   }
-  return applyReplacements(layers, replacements);
+  return applyReplacements(layers2, replacements);
 }
 function combineConditionalValues(entries, fallback, minimumRelevantZoom) {
   if (entries.length === 0) return { ok: true, value: fallback };
@@ -15533,8 +16357,8 @@ function unionFilters(filters) {
 function asFilter(value) {
   return Array.isArray(value) ? value : ["literal", true];
 }
-function applyReplacements(layers, replacements) {
-  return layers.flatMap((layer, index) => replacements.get(index) ?? [layer]);
+function applyReplacements(layers2, replacements) {
+  return layers2.flatMap((layer, index) => replacements.get(index) ?? [layer]);
 }
 function sameLayerSource(left, right) {
   return allEqual([left.feature, right.feature]);
@@ -15572,9 +16396,9 @@ function contiguousRuns(entries) {
   }
   return runs;
 }
-function hasGeneratedKeyCollision(layers, key, entries) {
+function hasGeneratedKeyCollision(layers2, key, entries) {
   const members = new Set(entries.map(({ layer }) => layer));
-  return layers.some((layer) => layer.key === key && !members.has(layer));
+  return layers2.some((layer) => layer.key === key && !members.has(layer));
 }
 function withMaximumZoom(layer, maxzoom) {
   return {
@@ -15588,8 +16412,8 @@ function minimumZoom(layer) {
 function maximumZoom(layer) {
   return typeof layer.range?.maxZoom === "number" ? layer.range.maxZoom : Infinity;
 }
-function finiteMaximumZoom(layers) {
-  const maximum2 = Math.max(...layers.map(maximumZoom));
+function finiteMaximumZoom(layers2) {
+  const maximum2 = Math.max(...layers2.map(maximumZoom));
   return Number.isFinite(maximum2) ? maximum2 : void 0;
 }
 function cloneJson23(value) {
@@ -15613,18 +16437,18 @@ var colourSources = [
   ["tileflow-buildings-3d", "fill-extrusion-color"],
   ["tileflow-buildings-fill", "fill-color"]
 ];
-function tileflowBuildings3DDesignOf(module, context, layers, buildingModels, tileflowLandmarks) {
-  const config = isRecord8(module) ? module : {};
+function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, tileflowLandmarks) {
+  const config = isRecord9(module) ? module : {};
   if (config.enabled === false) return void 0;
   const style = config.threeDimensional ?? {};
   const defaults4 = tileflowDefaultBuildings3DDesign;
   let color2;
   let verticalGradient = true;
   for (const [id2, property] of colourSources) {
-    const value = layers.find((layer) => layer.id === id2)?.paint?.[property];
+    const value = layers2.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;
+      verticalGradient = layers2.find((layer) => layer.id === id2)?.paint?.["fill-extrusion-vertical-gradient"] !== false;
       break;
     }
   }
@@ -15647,9 +16471,54 @@ function tileflowBuildings3DDesignOf(module, context, layers, buildingModels, ti
     edgeRadius: number(style.edgeRadius, defaults4.edgeRadius),
     ...typeof edgeColor === "string" ? { edgeColor } : {},
     nightLight: number(style.nightLight, 0),
+    ...isRecord9(style.floodLight) ? {
+      floodLight: readBuildingFloodLight({
+        ...style.floodLight,
+        intensity: number(style.floodLight.intensity, 0),
+        brightnessScale: number(style.floodLight.brightnessScale, 1),
+        color: style.floodLight.color === void 0 ? void 0 : toMapLibreStyleValue(style.floodLight.color)
+      })
+    } : {},
+    ...isRecord9(style.modelLighting) ? {
+      modelLighting: readModelRoleLighting(
+        Object.fromEntries(
+          Object.entries(style.modelLighting).filter(([, entry]) => isRecord9(entry)).map(([role, entry]) => {
+            const own = entry;
+            return [
+              role,
+              {
+                ...own,
+                emissiveStrength: number(own.emissiveStrength, 0),
+                ...Object.fromEntries(
+                  ["emissiveVariation", "colorMix", "metallic", "roughness"].filter((key) => own[key] !== void 0).map((key) => [key, number(own[key], 0)])
+                ),
+                ...Array.isArray(own.emissiveHeight) ? { emissiveHeight: own.emissiveHeight.map((v) => number(v, 0)) } : {},
+                ...isRecord9(own.colorVariation) ? {
+                  colorVariation: {
+                    ...own.colorVariation,
+                    ...Object.fromEntries(
+                      ["hue", "saturation", "lightness"].map((key) => [
+                        key,
+                        Array.isArray(
+                          own.colorVariation[key]
+                        ) ? own.colorVariation[key].map((v) => number(v, 0)) : []
+                      ])
+                    )
+                  }
+                } : {},
+                color: own.color === void 0 ? void 0 : toMapLibreStyleValue(own.color),
+                emissiveColor: own.emissiveColor === void 0 ? void 0 : toMapLibreStyleValue(own.emissiveColor)
+              }
+            ];
+          })
+        )
+      )
+    } : {},
     windows: style.windows === true,
+    ...readTileflowBuildingsEntrance(style.entrance),
     shadows: typeof style.shadows === "boolean" ? style.shadows : defaults4.shadows,
     occlusion: typeof style.occlusion === "boolean" ? style.occlusion : defaults4.occlusion,
+    modelOcclusion: number(style.modelOcclusion, defaults4.modelOcclusion),
     ...placedModels(style.models, buildingModels),
     ...modelColours(style.modelColors),
     ...landmarksOf(style.landmarks, tileflowLandmarks)
@@ -15657,7 +16526,7 @@ function tileflowBuildings3DDesignOf(module, context, layers, buildingModels, ti
 }
 function landmarksOf(value, tileflowLandmarks) {
   if (value === false) return {};
-  if (isRecord8(value) && typeof value.url === "string") return { landmarks: { url: value.url } };
+  if (isRecord9(value) && typeof value.url === "string") return { landmarks: { url: value.url } };
   return tileflowLandmarks ? { landmarks: { url: tileflowLandmarks } } : {};
 }
 function placedModels(value, served) {
@@ -15684,7 +16553,7 @@ function placedModels(value, served) {
   };
 }
 function modelColours(value) {
-  if (!isRecord8(value)) return {};
+  if (!isRecord9(value)) return {};
   const colours = {};
   for (const [part, colour] of Object.entries(value)) {
     const resolved = colour === void 0 ? void 0 : toMapLibreStyleValue(colour);
@@ -15693,10 +16562,10 @@ function modelColours(value) {
   return Object.keys(colours).length > 0 ? { modelColors: colours } : {};
 }
 function tileflowStreetLightsDesignOf(module, context) {
-  const config = isRecord8(module) ? module : {};
-  const layers = context.data.schema.layers;
+  const config = isRecord9(module) ? module : {};
+  const layers2 = context.data.schema.layers;
   const style = config.streetLights ?? {};
-  if (config.enabled === false || style.enabled !== true || !layers.streetFurniture)
+  if (config.enabled === false || style.enabled !== true || !layers2.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);
@@ -15704,16 +16573,16 @@ function tileflowStreetLightsDesignOf(module, context) {
   return {
     source: context.data.sourceId,
     layers: {
-      streetFurniture: layers.streetFurniture,
-      transportation: layers.road,
-      ...layers.sidewalk ? { sidewalk: layers.sidewalk } : {}
+      streetFurniture: layers2.streetFurniture,
+      transportation: layers2.road,
+      ...layers2.sidewalk ? { sidewalk: layers2.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) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -15885,7 +16754,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     )
   );
   const renderStackModules = Object.values(modules).filter(
-    (module) => isRecord9(module) && module.enabled !== false && "renderStack" in module && isRecord9(module.renderStack)
+    (module) => isRecord10(module) && module.enabled !== false && "renderStack" in module && isRecord10(module.renderStack)
   );
   const renderOperations = runCompilationPhase(
     "render-stack",
@@ -15911,7 +16780,11 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   const requestedRenderOperations = domainIR.renderOperations;
   const stackedFamilies = runCompilationPhase(
     "render-stack",
-    () => applyCompiledRenderStacks(assembledFamilies, requestedRenderOperations)
+    () => applyCompiledRenderStacks(
+      assembledFamilies,
+      requestedRenderOperations,
+      buildingTargetsOfOtherModes(modules.buildings)
+    )
   );
   const plannedFamilies = runCompilationPhase(
     "physical-planner",
@@ -16047,11 +16920,11 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     "finalization",
     () => createTileflowOverlayPlacementManifest(plannedLayers)
   );
-  const layers = runCompilationPhase("finalization", () => finalizeTileflowLayers(plannedLayers));
+  const layers2 = runCompilationPhase("finalization", () => finalizeTileflowLayers(plannedLayers));
   const buildings3D = tileflowBuildings3DDesignOf(
     modules.buildings,
     context,
-    layers,
+    layers2,
     options.preparedAssets?.buildingModels,
     data.kind === "tileflow-world" ? `${apiBaseUrl}/landmarks/tiles.json` : void 0
   );
@@ -16061,11 +16934,11 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   );
   runCompilationPhase(
     "finalization",
-    () => assertTileflowInteractionManifestLayers(interactionManifest, layers)
+    () => assertTileflowInteractionManifestLayers(interactionManifest, layers2)
   );
   runCompilationPhase(
     "finalization",
-    () => assertTileflowOverlayPlacementManifestLayers(overlayPlacementManifest, layers)
+    () => assertTileflowOverlayPlacementManifestLayers(overlayPlacementManifest, layers2)
   );
   const glyphs = runCompilationPhase("assets", () => resolveGlyphs(config));
   const sprite = options.preparedAssets?.icons?.sprite;
@@ -16105,10 +16978,10 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       version: 8,
       name: config.name ?? "Streets",
       sources,
-      layers
+      layers: layers2
     })
   );
-  const flatVegetationLayers = layers.filter((layer) => {
+  const flatVegetationLayers = layers2.filter((layer) => {
     const metadata = layer.metadata;
     return metadata?.["tileflow:vegetation-mode"] !== void 0 || metadata?.["tileflow:domain"] === "vegetation";
   });
@@ -16127,6 +17000,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       layer.layout = { ...layer.layout, visibility: "none" };
   }
   const atmosphere = resolveTileflowAtmosphere(config.atmosphere);
+  const notices = compiledNotices(layers2, marine);
   const style = {
     ...atmosphere ? { sky: compileTileflowSky(atmosphere) } : {},
     version: 8,
@@ -16136,7 +17010,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     ...config.projection ? { projection: { type: config.projection } } : {},
     ...sprite ? { sprite } : {},
     sources,
-    layers,
+    layers: layers2,
     ...terrain?.mode === "3d" && terrain.raster ? { terrain: { exaggeration: terrain.exaggeration, source: terrain.raster.sourceId } } : {},
     metadata: {
       ...mapMetadata ? {
@@ -16175,8 +17049,9 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       "tileflow:sourceRequirements": sourceRequirements,
       ...interactionManifest ? { [tileflowInteractionManifestMetadataKey]: interactionManifest } : {},
       [tileflowOverlayPlacementManifestMetadataKey]: overlayPlacementManifest,
-      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord9(module) || module.enabled !== false).map(([name]) => name).sort(),
-      ...config.view ? { "tileflow:view": config.view } : {}
+      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord10(module) || module.enabled !== false).map(([name]) => name).sort(),
+      ...config.view ? { "tileflow:view": config.view } : {},
+      ...notices.length > 0 ? { [tileflowNoticesMetadataKey]: notices } : {}
     }
   };
   const report = {
@@ -16236,7 +17111,7 @@ function finalizeTileflowLayers(input) {
     if (typeof minimum2 === "number" && typeof maximum2 === "number" && minimum2 > maximum2) {
       throw new Error(`Compiled Tileflow layer ${id2} requires minzoom <= maxzoom.`);
     }
-    const metadata = isRecord9(layer.metadata) ? { ...layer.metadata } : void 0;
+    const metadata = isRecord10(layer.metadata) ? { ...layer.metadata } : void 0;
     if (metadata) {
       const owner = metadata[tileflowCompilerMetadataKeys.owner];
       delete metadata[tileflowCompilerProvenanceMetadataKey];
@@ -16270,9 +17145,14 @@ function assertMapLibreStyle(style, mapId) {
     }
   );
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function compiledNotices(layers2, marine) {
+  const nautical2 = marine?.nautical?.sourceId;
+  if (!nautical2 || !layers2.some((layer) => layer.source === nautical2)) return [];
+  return [{ ...tileflowNauticalNotice, sources: [nautical2] }];
+}
 function resolveGlyphs(config) {
   if (config.fonts !== void 0) return void 0;
   return config.glyphs?.url;
@@ -16310,8 +17190,8 @@ function assertPreparedIconReferences(style, config, prepared) {
 function collectStyleImageReferences(style) {
   const result = /* @__PURE__ */ new Set();
   for (const layer of style.layers) {
-    const layout = isRecord9(layer.layout) ? layer.layout : {};
-    const paint = isRecord9(layer.paint) ? layer.paint : {};
+    const layout = isRecord10(layer.layout) ? layer.layout : {};
+    const paint = isRecord10(layer.paint) ? layer.paint : {};
     const layerId = typeof layer.id === "string" ? layer.id : "<unknown>";
     for (const [property, value] of [
       ["icon-image", layout["icon-image"]],
@@ -16400,7 +17280,7 @@ function assertGlyphFontStacks(style, config) {
   const declared = new Set(config.glyphs.fontStacks);
   const missing = /* @__PURE__ */ new Set();
   for (const layer of style.layers) {
-    const layout = isRecord9(layer.layout) ? layer.layout : void 0;
+    const layout = isRecord10(layer.layout) ? layer.layout : void 0;
     const font = layout?.["text-font"];
     if (!Array.isArray(font) || !font.every((entry) => typeof entry === "string")) continue;
     const stack = font.join(",");
@@ -16416,7 +17296,7 @@ function assertGlyphFontStacks(style, config) {
 function assertTextAssets(style, config) {
   const textLayers = [];
   for (const layer of style.layers) {
-    const layout = isRecord9(layer.layout) ? layer.layout : void 0;
+    const layout = isRecord10(layer.layout) ? layer.layout : void 0;
     if (layout?.["text-field"] === void 0) continue;
     textLayers.push(typeof layer.id === "string" ? layer.id : "<unknown>");
     const font = layout["text-font"];
@@ -16429,7 +17309,7 @@ function assertTextAssets(style, config) {
   if (textLayers.length === 0) return;
   if (config.fonts !== void 0) {
     const backed = style.layers.find((layer) => {
-      const font = isRecord9(layer.layout) ? layer.layout["text-font"] : void 0;
+      const font = isRecord10(layer.layout) ? layer.layout["text-font"] : void 0;
       return Array.isArray(font) && font.length === 1 && typeof font[0] === "string" && parseTileflowLineBackgroundFontStack(font[0]) !== void 0;
     });
     if (backed) {
@@ -16455,8 +17335,8 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record3 = isRecord9(error) ? error : {};
-  if (typeof record3.phase === "string") return error;
+  const record4 = isRecord10(error) ? error : {};
+  if (typeof record4.phase === "string") return error;
   if (error instanceof Error && Object.isExtensible(error)) {
     Object.defineProperty(error, "phase", { configurable: true, enumerable: true, value: phase });
     return error;
@@ -16472,7 +17352,7 @@ function withCompilationPhase(error, phase) {
     "severity",
     "target"
   ]) {
-    if (record3[key] !== void 0) Object.assign(wrapped, { [key]: record3[key] });
+    if (record4[key] !== void 0) Object.assign(wrapped, { [key]: record4[key] });
   }
   Object.assign(wrapped, { phase });
   return wrapped;
@@ -17206,6 +18086,9 @@ function applyModuleOperation(resolved, moduleName, operation, mapId, path) {
         assertNoReset(patch, mapId, `${path}/patches/${index}`, true);
         next = applyModulePatch(next, patch, mapId, `${path}/patches/${index}`);
       }
+      if (isPlainRecord4(next.renderStack) && Object.keys(next.renderStack).length === 0) {
+        delete next.renderStack;
+      }
       assertModuleOwner(next, moduleName, mapId, path);
       resolved[moduleName] = next;
       return;
@@ -17368,11 +18251,11 @@ function cloneDesign(value) {
 function describeMap(value) {
   return typeof value.id === "string" && value.id ? value.id : "<anonymous>";
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord4(value) {
-  if (!isRecord10(value)) return false;
+  if (!isRecord11(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -18251,9 +19134,9 @@ var tileflowNativeBuildRecordSchema = strictNativeObject({
   engines: strictNativeObject({ android: z13.literal("13.2.0"), ios: z13.literal("6.26.0") }),
   buildManifestSha256: hashSchema,
   transformations: z13.array(tileflowNativeStyleTransformationSchema).max(4096)
-}).superRefine((record3, context) => {
+}).superRefine((record4, context) => {
   let previous = "";
-  for (const [index, item] of record3.transformations.entries()) {
+  for (const [index, item] of record4.transformations.entries()) {
     const name = `${item.map}/${item.theme}`;
     if (name <= previous)
       context.addIssue({
@@ -26956,13 +27839,13 @@ function validateNativeStyle(input, options, stage) {
       issues.push(createTileflowNativeDiagnostic(code, path));
     }
   };
-  if (!record2(options) || !plainOptions(options)) {
+  if (!record3(options) || !plainOptions(options)) {
     return [createTileflowNativeDiagnostic("NATIVE_RENDERER_UNSUPPORTED", "/profile")];
   }
   if (options.profile !== void 0 && options.profile !== "native-v1" || !expressionDefinitions) {
     return [createTileflowNativeDiagnostic("NATIVE_RENDERER_UNSUPPORTED", "/profile")];
   }
-  if (!isBoundedNativeJson(input, stage) || !record2(input)) {
+  if (!isBoundedNativeJson(input, stage) || !record3(input)) {
     return [createTileflowNativeDiagnostic("NATIVE_UNSUPPORTED_STYLE")];
   }
   const style = input;
@@ -26976,11 +27859,11 @@ function validateNativeStyle(input, options, stage) {
   }
   if (style.projection !== void 0) {
     const projection = style.projection;
-    if (!record2(projection) || projection.type !== "mercator" || Object.keys(projection).length !== 1) {
+    if (!record3(projection) || projection.type !== "mercator" || Object.keys(projection).length !== 1) {
       add2("NATIVE_UNSUPPORTED_STYLE", "/projection");
     }
   }
-  if (record2(style.metadata)) {
+  if (record3(style.metadata)) {
     for (const key of Object.keys(style.metadata).sort()) {
       if (/^tileflow:(?:contour|pmtiles)/iu.test(key)) {
         add2("NATIVE_UNSUPPORTED_SOURCE", nativePointer("/metadata", key));
@@ -27023,14 +27906,14 @@ function validateNativeStyle(input, options, stage) {
       add2("NATIVE_FONT_UNAVAILABLE", "/glyphs");
     } else checkUrl(style.glyphs, "/glyphs", "glyphs");
   }
-  const sources = record2(style.sources) ? style.sources : {};
+  const sources = record3(style.sources) ? style.sources : {};
   if (Object.keys(sources).length > tileflowNativeProfileLimits.maximumSources) {
     add2("NATIVE_UNSUPPORTED_SOURCE", "/sources");
   }
   for (const id2 of Object.keys(sources).sort().slice(0, tileflowNativeProfileLimits.maximumSources)) {
     const source = sources[id2];
     const path = nativePointer("/sources", id2);
-    if (!record2(source) || typeof source.type !== "string" || !sourceKinds.has(source.type)) {
+    if (!record3(source) || typeof source.type !== "string" || !sourceKinds.has(source.type)) {
       add2("NATIVE_UNSUPPORTED_SOURCE", path);
       continue;
     }
@@ -27042,7 +27925,7 @@ function validateNativeStyle(input, options, stage) {
       "NATIVE_UNSUPPORTED_SOURCE"
     );
     if (source.clusterProperties !== void 0) {
-      if (record2(source.clusterProperties)) {
+      if (record3(source.clusterProperties)) {
         for (const key of Object.keys(source.clusterProperties).sort()) {
           const values = source.clusterProperties[key];
           if (Array.isArray(values))
@@ -27068,7 +27951,7 @@ function validateNativeStyle(input, options, stage) {
   if (faces !== void 0) {
     const support = spec.$root?.["font-faces"]?.["sdk-support"]?.["basic functionality"];
     if (!support || !supportsBoth(support)) add2("NATIVE_FONT_UNAVAILABLE", "/font-faces");
-    if (!record2(faces) || Object.keys(faces).length > tileflowNativeProfileLimits.maximumFontFaces) {
+    if (!record3(faces) || Object.keys(faces).length > tileflowNativeProfileLimits.maximumFontFaces) {
       add2("NATIVE_FONT_UNAVAILABLE", "/font-faces");
     } else {
       for (const name of Object.keys(faces).sort()) {
@@ -27080,19 +27963,19 @@ function validateNativeStyle(input, options, stage) {
       }
     }
   }
-  const layers = Array.isArray(style.layers) ? style.layers : [];
-  if (layers.length > tileflowNativeProfileLimits.maximumLayers)
+  const layers2 = Array.isArray(style.layers) ? style.layers : [];
+  if (layers2.length > tileflowNativeProfileLimits.maximumLayers)
     add2("NATIVE_UNSUPPORTED_STYLE", "/layers");
-  layers.slice(0, tileflowNativeProfileLimits.maximumLayers).forEach((layer, i) => {
+  layers2.slice(0, tileflowNativeProfileLimits.maximumLayers).forEach((layer, i) => {
     const path = `/layers/${i}`;
-    if (!record2(layer) || typeof layer.type !== "string" || !layerKinds.has(layer.type) || layer.ref !== void 0) {
+    if (!record3(layer) || typeof layer.type !== "string" || !layerKinds.has(layer.type) || layer.ref !== void 0) {
       add2("NATIVE_UNSUPPORTED_STYLE", path);
       return;
     }
     properties(layer, spec.layer, path, add2);
     for (const group of ["layout", "paint"]) {
       const values = layer[group];
-      if (!record2(values)) continue;
+      if (!record3(values)) continue;
       properties(
         values,
         spec[`${group}_${layer.type}`],
@@ -27106,7 +27989,7 @@ function validateNativeStyle(input, options, stage) {
       }
     }
     expressions(layer.filter, `${path}/filter`, add2);
-    if (!options.deferFontClosure && record2(layer.layout) && layer.layout["text-field"] !== void 0) {
+    if (!options.deferFontClosure && record3(layer.layout) && layer.layout["text-field"] !== void 0) {
       const fonts = layer.layout["text-font"];
       if (style.glyphs === void 0) {
         if (!fontStackAvailable(fonts, faces))
@@ -27116,7 +27999,7 @@ function validateNativeStyle(input, options, stage) {
     }
   });
   for (const key of ["light", "transition"]) {
-    if (record2(style[key])) {
+    if (record3(style[key])) {
       properties(style[key], spec[key], `/${key}`, add2);
       for (const [property, value] of Object.entries(style[key]))
         expressions(value, nativePointer(`/${key}`, property), add2);
@@ -27149,7 +28032,7 @@ function properties(values, definitions, path, add2, code = "NATIVE_UNSUPPORTED_
     const basic = definition["sdk-support"]?.["basic functionality"];
     if (basic && !supportsBoth(basic)) add2(code, nativePointer(path, key));
     const value = values[key];
-    if (checkFeatureSupport && record2(value) && Object.hasOwn(value, "stops"))
+    if (checkFeatureSupport && record3(value) && Object.hasOwn(value, "stops"))
       add2(code, nativePointer(path, key));
     if (typeof value === "string") {
       const enumSupport = definition.values?.[value]?.["sdk-support"]?.["basic functionality"];
@@ -27175,7 +28058,7 @@ function expressions(value, path, add2) {
     if (index === 0) return;
     if (operator === "match" && index >= 2 && index < value.length - 1 && index % 2 === 0) return;
     if (operator.startsWith("interpolate") && index === 1) return;
-    if (record2(child)) {
+    if (record3(child)) {
       for (const key of Object.keys(child).sort())
         expressions(child[key], nativePointer(`${path}/${index}`, key), add2);
     } else expressions(child, `${path}/${index}`, add2);
@@ -27183,14 +28066,14 @@ function expressions(value, path, add2) {
 }
 function fontStackAvailable(value, faces) {
   const stack = Array.isArray(value) && value.length === 2 && value[0] === "literal" ? value[1] : value;
-  return Array.isArray(stack) && stack.length > 0 && record2(faces) && stack.every((name) => typeof name === "string" && Object.hasOwn(faces, name));
+  return Array.isArray(stack) && stack.length > 0 && record3(faces) && stack.every((name) => typeof name === "string" && Object.hasOwn(faces, name));
 }
 function inlineFontStacks(value, path, faces, add2) {
   if (!Array.isArray(value) || !isExpression(value) || value[0] === "literal") return;
   value.forEach((child, index) => {
     if (index === 0 || value[0] === "match" && index >= 2 && index < value.length - 1 && index % 2 === 0)
       return;
-    if (value[0] === "format" && record2(child) && child["text-font"] !== void 0 && !fontStackAvailable(child["text-font"], faces)) {
+    if (value[0] === "format" && record3(child) && child["text-font"] !== void 0 && !fontStackAvailable(child["text-font"], faces)) {
       add2("NATIVE_FONT_UNAVAILABLE", `${path}/${index}/text-font`);
     }
     inlineFontStacks(child, `${path}/${index}`, faces, add2);
@@ -27207,7 +28090,7 @@ function parserIssuePointer(key, style) {
       path = nativePointer(path, match3[1]);
       value = value[Number(match3[1])];
       rest = rest.slice(match3[0].length).replace(/^\./u, "");
-    } else if (record2(value)) {
+    } else if (record3(value)) {
       const matches = Object.keys(value).filter(
         (name2) => rest === name2 || rest.startsWith(`${name2}.`) || rest.startsWith(`${name2}[`)
       );
@@ -27238,7 +28121,7 @@ function plainOptions(value) {
     return false;
   }
 }
-function record2(value) {
+function record3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function normalizeNativeDiagnostics(input) {
@@ -27528,15 +28411,15 @@ function semanticIdentity(style) {
   const candidate = object(style.metadata)?.["tileflow:interaction-manifest"];
   if (candidate === void 0) return void 0;
   const manifest = semanticSchema.parse(candidate);
-  const layers = style.layers.map((value) => {
+  const layers2 = style.layers.map((value) => {
     const layer = object(value);
     if (!layer) throw new Error();
     return layer;
   });
-  assertTileflowInteractionManifestLayers(manifest, layers);
+  assertTileflowInteractionManifestLayers(manifest, layers2);
   const seen = /* @__PURE__ */ new Set();
   for (const layer of manifest.domains.poi?.layers ?? []) {
-    if (seen.has(layer.layerId) || layers[layer.priority]?.id !== layer.layerId) throw new Error();
+    if (seen.has(layer.layerId) || layers2[layer.priority]?.id !== layer.layerId) throw new Error();
     seen.add(layer.layerId);
   }
   const poi2 = manifest.domains.poi;