@tileflow/core 0.1.0-alpha.37 → 0.1.0-alpha.39

package/dist/build.js

@@ -4,6 +4,9 @@ import { validateStyleMin } from "@maplibre/maplibre-gl-style-spec";
 // src/atmosphere.ts
 var tileflowAtmosphereMetadataKey = "tileflow:atmosphere";
 
+// src/sky.ts
+var tileflowSkyMetadataKey = "tileflow:sky";
+
 // src/atmosphere-compile.ts
 import { Color } from "@maplibre/maplibre-gl-style-spec";
 var defaults = {
@@ -17,14 +20,7 @@ var defaults = {
 function resolveTileflowAtmosphere(value) {
   if (!value) return void 0;
   const options = { ...defaults, ...value === true ? {} : value };
-  const normalize = (input) => {
-    const color2 = typeof input === "string" ? Color.parse(input) : void 0;
-    if (!color2 || color2.a !== 1)
-      throw new Error("Atmosphere colors must resolve to opaque colors.");
-    return `#${[color2.r, color2.g, color2.b].map(
-      (channel) => Math.round(channel * 255).toString(16).padStart(2, "0")
-    ).join("")}`;
-  };
+  const normalize = (input) => opaqueHex(input, "Atmosphere colors");
   return {
     ...options,
     skyColor: normalize(options.skyColor),
@@ -33,6 +29,13 @@ function resolveTileflowAtmosphere(value) {
     spaceColor: normalize(options.spaceColor)
   };
 }
+function opaqueHex(input, subject) {
+  const color2 = typeof input === "string" ? Color.parse(input) : void 0;
+  if (!color2 || color2.a !== 1) throw new Error(`${subject} must resolve to opaque colors.`);
+  return `#${[color2.r, color2.g, color2.b].map(
+    (channel) => Math.round(channel * 255).toString(16).padStart(2, "0")
+  ).join("")}`;
+}
 function compileTileflowSky(options) {
   return {
     "sky-color": options.skyColor,
@@ -44,6 +47,41 @@ function compileTileflowSky(options) {
     "atmosphere-blend": ["interpolate", ["linear"], ["zoom"], 0, 0.55, 3, 0.45, 5, 0.2, 7, 0]
   };
 }
+var skyDefaults = {
+  color: "#5c9ce6",
+  horizonColor: "#dcebf7",
+  horizonBlend: 0.6,
+  glowColor: "#ffc68a",
+  starIntensity: 0.6
+};
+function resolveTileflowSky(value) {
+  if (!value) return void 0;
+  const options = { ...skyDefaults, ...value === true ? {} : value };
+  const unit = (input, name) => {
+    if (typeof input !== "number" || !Number.isFinite(input) || input < 0 || input > 1)
+      throw new Error(`Sky ${name} must resolve to a number from 0 to 1.`);
+    return input;
+  };
+  return {
+    color: opaqueHex(options.color, "Sky colors"),
+    horizonColor: opaqueHex(options.horizonColor, "Sky colors"),
+    horizonBlend: unit(options.horizonBlend, "horizonBlend"),
+    glowColor: opaqueHex(options.glowColor, "Sky colors"),
+    starIntensity: unit(options.starIntensity, "starIntensity")
+  };
+}
+function compileTileflowStreetSky(options) {
+  return {
+    "sky-color": options.color,
+    "horizon-color": options.horizonColor,
+    // MapLibre fogs only 3D terrain; the haze matches the horizon so terrain meets the sky.
+    "fog-color": options.horizonColor,
+    "sky-horizon-blend": options.horizonBlend,
+    "horizon-fog-blend": 0.6,
+    "fog-ground-blend": 0.75,
+    "atmosphere-blend": ["interpolate", ["linear"], ["zoom"], 0, 0.55, 3, 0.45, 5, 0.2, 7, 0]
+  };
+}
 
 // src/models-3d-model.ts
 var tileflowModelParts = Object.freeze({
@@ -171,6 +209,16 @@ var tileflowDefaultBuildings3DDesign = Object.freeze({
 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";
@@ -335,6 +383,7 @@ function tileflowWorldV1Schema(options = {}) {
       sidewalk: "sidewalk",
       streetFurniture: "street_furniture",
       trafficControl: "traffic_control",
+      transportationOutline: "transportation_outline",
       ...options.layers
     },
     semantics: { ...options.semantics, parkLayer: "protected-only" }
@@ -1109,26 +1158,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) {
@@ -1168,7 +1217,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) {
@@ -1201,7 +1250,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);
@@ -1445,6 +1494,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);
 }
@@ -1489,10 +1544,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];
@@ -1508,7 +1563,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));
 }
 
@@ -1967,6 +2022,21 @@ 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 fields2 = context.data.schema.fields;
   const colors = context.colors.buildings;
@@ -2084,29 +2154,23 @@ function isTileflowPathRoadClass(roadClass) {
   return tileflowPathRoadClasses.includes(roadClass);
 }
 function tileflowRoadClassFilter(fields2, roadClass) {
+  const classes = tileflowRoadClassValues(roadClass);
   if (isTileflowPathRoadClass(roadClass)) {
     return [
       "all",
-      ["match", ["get", fields2.class], ["path", ...constructionClasses[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", fields2.class], classes, true, false];
 }
 
 // src/modules/roads/index.ts
@@ -3403,12 +3467,46 @@ var tileflowNauticalImageRoles = Object.freeze({
     port: "nautical.buoy.port",
     starboard: "nautical.buoy.starboard"
   }),
-  harbours: Object.freeze({ default: "nautical.harbour" }),
+  distanceMarks: Object.freeze({ default: "nautical.distance-mark" }),
+  /**
+   * A facility that lists several categories shows the first of `tileflowNauticalFacilityIcons`
+   * it lists; facilities without a variant token fall back to `nautical.facility`.
+   */
+  facilities: Object.freeze({
+    "boat-hoist": "nautical.facility.boat-hoist",
+    boatyard: "nautical.facility.boatyard",
+    default: "nautical.facility",
+    "fuel-station": "nautical.facility.fuel-station",
+    "pump-out": "nautical.facility.pump-out",
+    slipway: "nautical.facility.slipway",
+    "visitor-berth": "nautical.facility.visitor-berth",
+    "water-tap": "nautical.facility.water-tap"
+  }),
+  /** Harbours whose `subclass` lists a marina use `nautical.marina` when the theme declares it. */
+  harbours: Object.freeze({ default: "nautical.harbour", marina: "nautical.marina" }),
   lighthouses: Object.freeze({ default: "nautical.lighthouse" }),
   lights: Object.freeze({ default: "nautical.light" }),
+  /** Notice boards by function; a board without a variant token uses `nautical.notice`. */
+  notices: Object.freeze({
+    default: "nautical.notice",
+    information: "nautical.notice.information",
+    prohibition: "nautical.notice.prohibition",
+    recommendation: "nautical.notice.recommendation",
+    regulation: "nautical.notice.regulation",
+    restriction: "nautical.notice.restriction"
+  }),
   ports: Object.freeze({ default: "nautical.port" }),
   wrecks: Object.freeze({ default: "nautical.wreck" })
 });
+var tileflowNauticalFacilityIcons = Object.freeze([
+  "fuel-station",
+  "slipway",
+  "boat-hoist",
+  "pump-out",
+  "water-tap",
+  "visitor-berth",
+  "boatyard"
+]);
 var tileflowNauticalNotice = Object.freeze({
   id: "nautical-not-for-navigation",
   text: "Not for navigation"
@@ -3467,10 +3565,15 @@ var tileflowNauticalV1Schema = Object.freeze({
     country: "country",
     coverage: "coverage",
     depth: "depth",
+    distance: "distance",
+    distanceUnit: "distance_unit",
     edition: "edition",
     families: "families",
     group: "group",
     heightM: "height_m",
+    horizontalClearance: "horizontal_clearance",
+    impact: "impact",
+    information: "information",
     label: "label",
     licence: "licence",
     lit: "lit",
@@ -3488,6 +3591,7 @@ var tileflowNauticalV1Schema = Object.freeze({
     scale: "scale",
     sectorEnd: "sector_end",
     sectorStart: "sector_start",
+    sequence: "sequence",
     shape: "shape",
     size: "size",
     subclass: "subclass",
@@ -3495,6 +3599,10 @@ var tileflowNauticalV1Schema = Object.freeze({
     topmark: "topmark",
     unlocode: "unlocode",
     update: "update",
+    verticalClearance: "vertical_clearance",
+    verticalClearanceClosed: "vertical_clearance_closed",
+    verticalClearanceOpen: "vertical_clearance_open",
+    verticalClearanceSafe: "vertical_clearance_safe",
     waterLevel: "water_level"
   }),
   geometryTypes: Object.freeze({
@@ -3518,6 +3626,16 @@ var tileflowNauticalV1Schema = Object.freeze({
     wrecks: "wreck"
   }),
   product: "nautical-v1",
+  /**
+   * Known `provider` values and the `class` of their `coverage` cells. The source's TileJSON owns
+   * each provider's credit; the module never adds attribution.
+   */
+  providers: Object.freeze({
+    "nga-list-of-lights": "list",
+    "noaa-office-of-coast-survey": "chart",
+    openstreetmap: "community",
+    "usace-ienc": "chart"
+  }),
   schemaVersion: 1
 });
 var tileflowBathymetryNameLayerLimits = Object.freeze({ maxZoomRanges: 128 });
@@ -3602,8 +3720,11 @@ function resolveBathymetryRelief(style, apiBaseUrl) {
     style: cloneJson12(style)
   };
 }
+var tileflowNauticalPromoteId = Object.freeze({
+  [tileflowNauticalV1Schema.layers.lights]: tileflowNauticalV1Schema.fields.provenance
+});
 function resolveNauticalSource(config, apiBaseUrl) {
-  return resolveMarineSource({
+  const resolved = resolveMarineSource({
     config,
     defaultPath: "/tiles/nautical/tiles.json",
     defaultSourceId: tileflowNauticalSourceId,
@@ -3611,6 +3732,7 @@ function resolveNauticalSource(config, apiBaseUrl) {
     product: tileflowNauticalV1Schema.product,
     apiBaseUrl
   });
+  return { ...resolved, source: { ...resolved.source, promoteId: { ...tileflowNauticalPromoteId } } };
 }
 function resolveMarineSource(options) {
   const sourceId = validateSourceId(options.config.sourceId ?? options.defaultSourceId);
@@ -3672,6 +3794,42 @@ function cloneJson12(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
+// src/nautical-lights.ts
+var tileflowNauticalLightsMetadataKey = "tileflow:nautical-lights";
+var tileflowNauticalLightStates = Object.freeze({
+  /** Index of the colour shown, into the light's comma-separated `color` list. */
+  colour: "tileflowLightColour",
+  /** `1` while the light shines, `0` while it is eclipsed, in between for a fixed part. */
+  intensity: "tileflowLightIntensity"
+});
+var tileflowNauticalLightEclipseOpacity = 0.15;
+var tileflowNauticalLightsLimits = Object.freeze({ maxLayers: 16 });
+function declareTileflowNauticalLights(layers2, sourceId, sourceLayer) {
+  if (!sourceId) return void 0;
+  const ids = layers2.filter(
+    (layer) => layer.source === sourceId && layer["source-layer"] === sourceLayer && readsLightState(layer.paint)
+  ).map(({ id: id2 }) => id2).filter((id2) => typeof id2 === "string").slice(0, tileflowNauticalLightsLimits.maxLayers);
+  if (ids.length === 0) return void 0;
+  return { layers: ids, source: sourceId, sourceLayer, version: 1 };
+}
+function tileflowNauticalLightStateRead(state, steadyValue) {
+  return ["number", ["feature-state", tileflowNauticalLightStates[state]], steadyValue];
+}
+var stateKeys = new Set(Object.values(tileflowNauticalLightStates));
+function readsLightState(value) {
+  if (!Array.isArray(value)) {
+    return isRecord4(value) ? Object.values(value).some(readsLightState) : false;
+  }
+  if (value[0] === "literal") return false;
+  if (value[0] === "feature-state" && typeof value[1] === "string" && stateKeys.has(value[1])) {
+    return true;
+  }
+  return value.some(readsLightState);
+}
+function isRecord4(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
 // src/modules/nautical/compiler.ts
 var { fields, layers } = tileflowNauticalV1Schema;
 var markColours = Object.freeze({
@@ -3714,6 +3872,24 @@ var operationalAreaClasses = [
 var routeClasses = ["route", "traffic-separation"];
 var cableClasses = ["cable", "cable-area", "pipeline", "pipeline-area"];
 var portSizes = ["large", "medium", "small", "very-small"];
+var ownAreaClasses = ["berth", "bridge", "facility", "harbour"];
+var ownAidClasses = ["distance-mark", "notice"];
+var marinaSubclasses = ["marina", "marina-no-facilities"];
+var noticeFunctionColours = Object.freeze({
+  information: markColours.blue,
+  prohibition: markColours.red,
+  recommendation: markColours.green,
+  regulation: markColours.red,
+  restriction: markColours.red
+});
+var distanceUnits = Object.freeze({
+  hectometres: "hm",
+  kilometres: "km",
+  metres: "m",
+  "nautical-miles": "NM",
+  "statute-miles": "mi"
+});
+var maxAlternatingColours = 3;
 function compileNautical(request, context) {
   const nauticalSource = context.marine?.nautical;
   if (!nauticalSource || request?.enabled === false) return [];
@@ -3744,10 +3920,30 @@ function compileNautical(request, context) {
   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 animateLights = request?.animateLights !== false;
   const flareColour = expression(
-    colourMatch(firstColour(fields.color), lightColours, lightColours.white)
+    colourMatch(
+      animateLights ? nthColour(fields.color, tileflowNauticalLightStateRead("colour", 0)) : firstColour(fields.color),
+      lightColours,
+      lightColours.white
+    )
   );
   const iconPaint = { color: markColour, haloColor: ink, haloWidth: 1 };
+  const noticeColours = [
+    "match",
+    ["get", fields.subclass],
+    ...Object.entries(noticeFunctionColours).flat(),
+    ink
+  ];
+  const noticeColour = expression(noticeColours);
+  const distanceOpacity = (installed, notInstalled) => expression([
+    "match",
+    ["get", fields.category],
+    "not-installed",
+    notInstalled,
+    installed
+  ]);
+  const isGuestBerth = listIncludes(fields.subclass, "guest");
   const defaults4 = {
     type: "nautical",
     enabled: true,
@@ -3838,6 +4034,60 @@ function compileNautical(request, context) {
         [14, 1.3]
       ])
     },
+    harbourAreas: {
+      fill: { color: ink, minZoom: 10, opacity: 0.05 },
+      outline: {
+        color: ink,
+        minZoom: 10,
+        opacity: zoom.linear([
+          [10, 0.35],
+          [14, 0.6]
+        ]),
+        width: zoom.linear([
+          [10, 0.5],
+          [16, 1]
+        ])
+      }
+    },
+    berths: {
+      fill: { color: ink, minZoom: 13, opacity: 0.06 },
+      outline: {
+        color: ink,
+        minZoom: 13,
+        opacity: expression(["case", isGuestBerth, 0.95, 0.5]),
+        width: expression([
+          "interpolate",
+          ["linear"],
+          ["zoom"],
+          13,
+          ["case", isGuestBerth, 1.2, 0.6],
+          16,
+          ["case", isGuestBerth, 2.4, 1.2]
+        ])
+      }
+    },
+    bridges: {
+      fill: { color: colors.land, minZoom: 12, opacity: 0.9 },
+      outline: {
+        color: ink,
+        minZoom: 12,
+        opacity: 0.85,
+        width: zoom.linear([
+          [12, 0.8],
+          [16, 1.8]
+        ])
+      }
+    },
+    overheadCables: {
+      color: accent,
+      dash: [6, 2, 1, 2],
+      minZoom: 10,
+      opacity: 0.75,
+      width: zoom.linear([
+        [10, 0.7],
+        [16, 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 }
@@ -3947,6 +4197,7 @@ function compileNautical(request, context) {
     harbours: {
       minZoom: 11,
       placement: "point",
+      ...rankPriority,
       ...images.harbours ? {
         icon: {
           color: ink,
@@ -3997,6 +4248,147 @@ function compileNautical(request, context) {
       },
       text: { ...markText, ...sideLabel, field: nameFrom(15), padding: 3, size: 9 }
     },
+    notices: {
+      minZoom: 12,
+      placement: "point",
+      ...rankPriority,
+      ...images.notices ? {
+        icon: {
+          color: noticeColour,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.notices,
+          padding: 1,
+          size: zoom.linear([
+            [12, 0.8],
+            [16, 1.2]
+          ])
+        }
+      } : {
+        marker: {
+          color: expression([
+            "match",
+            ["get", fields.subclass],
+            ["prohibition", "recommendation", "information"],
+            noticeColours,
+            halo
+          ]),
+          radius: zoom.linear([
+            [12, 1.8],
+            [16, 3.2]
+          ]),
+          strokeColor: expression([
+            "match",
+            ["get", fields.subclass],
+            ["prohibition", "recommendation", "information"],
+            halo,
+            noticeColours
+          ]),
+          strokeWidth: 1
+        }
+      },
+      text: {
+        ...markText,
+        ...sideLabel,
+        field: expression([
+          "step",
+          ["zoom"],
+          "",
+          14,
+          ["to-string", ["coalesce", ["get", fields.information], ""]]
+        ]),
+        padding: 2,
+        size: 9
+      }
+    },
+    distanceMarks: {
+      minZoom: 11,
+      placement: "point",
+      ...rankPriority,
+      ...images.distanceMarks ? {
+        icon: {
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.distanceMarks,
+          opacity: distanceOpacity(1, 0.6),
+          size: zoom.linear([
+            [11, 0.7],
+            [16, 1]
+          ])
+        }
+      } : {
+        marker: {
+          color: ink,
+          opacity: distanceOpacity(1, 0.6),
+          radius: zoom.linear([
+            [11, 1.2],
+            [16, 2.2]
+          ]),
+          strokeColor: halo,
+          strokeWidth: 0.8
+        }
+      },
+      text: {
+        ...markText,
+        ...sideLabel,
+        field: expression([
+          "step",
+          ["zoom"],
+          "",
+          13,
+          [
+            "case",
+            ["has", fields.distance],
+            [
+              "concat",
+              ["to-string", ["get", fields.distance]],
+              [
+                "match",
+                ["get", fields.distanceUnit],
+                ...Object.entries(distanceUnits).flatMap(([unit, label]) => [unit, ` ${label}`]),
+                ""
+              ]
+            ],
+            ""
+          ]
+        ]),
+        opacity: distanceOpacity(1, 0.75),
+        padding: 2,
+        size: zoom.linear([
+          [13, 8.5],
+          [16, 10]
+        ])
+      }
+    },
+    facilities: {
+      minZoom: 13,
+      placement: "point",
+      ...images.facilities ? {
+        icon: {
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.facilities,
+          padding: 1,
+          size: zoom.linear([
+            [13, 0.8],
+            [16, 1.15]
+          ])
+        }
+      } : {
+        marker: {
+          color: halo,
+          radius: zoom.linear([
+            [13, 1.8],
+            [16, 3]
+          ]),
+          strokeColor: ink,
+          strokeWidth: 1
+        }
+      },
+      text: { ...markText, ...sideLabel, field: nameFrom(15), padding: 3, size: 9 }
+    },
     beacons: {
       minZoom: 11,
       placement: "point",
@@ -4179,6 +4571,32 @@ function compileNautical(request, context) {
       }
     },
     labels: {
+      bridges: {
+        minZoom: 13,
+        placement: "point",
+        text: {
+          ...markText,
+          field: expression(bridgeClearance()),
+          padding: 2,
+          size: zoom.linear([
+            [13, 8.5],
+            [16, 10]
+          ])
+        }
+      },
+      overheadCables: {
+        minZoom: 12,
+        placement: "point",
+        spacing: 360,
+        text: {
+          ...markText,
+          color: accent,
+          field: expression(cableClearance()),
+          maxAngle: 30,
+          padding: 2,
+          size: 8.5
+        }
+      },
       coverage: {
         maxZoom: 9,
         minZoom: 4,
@@ -4228,6 +4646,7 @@ function compileNautical(request, context) {
   const source = nauticalSource.sourceId;
   const contributions = [];
   const add2 = (options) => appendNauticalLayer(contributions, { ...options, source });
+  const ofClass = (value) => ["==", ["get", fields.class], value];
   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], ""]]],
@@ -4238,13 +4657,30 @@ function compileNautical(request, context) {
     target: "nautical.coverage"
   });
   add2({
-    filter: polygons,
+    filter: ["all", polygons, ["match", ["get", fields.class], [...ownAreaClasses], false, true]],
     id: "tileflow-nautical-navigation-areas",
     localOrder: 390,
     sourceLayer: layers.navigationAreas,
     style: config.navigationAreas,
     target: "nautical.navigationAreas"
   });
+  add2({
+    filter: ["all", polygons, ofClass("harbour")],
+    id: "tileflow-nautical-harbour-areas",
+    localOrder: 392,
+    sourceLayer: layers.navigationAreas,
+    style: config.harbourAreas,
+    target: "nautical.harbourAreas"
+  });
+  add2({
+    filter: ["all", polygons, ofClass("berth")],
+    id: "tileflow-nautical-berths",
+    localOrder: 394,
+    outlineFilter: ["all", linesOrPolygons, ofClass("berth")],
+    sourceLayer: layers.navigationAreas,
+    style: config.berths,
+    target: "nautical.berths"
+  });
   add2({
     filter: polygons,
     id: "tileflow-nautical-reefs",
@@ -4271,11 +4707,20 @@ function compileNautical(request, context) {
     style: config.routes,
     target: "nautical.routes"
   });
+  add2({
+    filter: linesOf(["overhead-cable"]),
+    id: "tileflow-nautical-overhead-cables",
+    line: true,
+    localOrder: 408,
+    sourceLayer: layers.navigationAreas,
+    style: config.overheadCables,
+    target: "nautical.overheadCables"
+  });
   add2({
     filter: polygons,
     id: "tileflow-nautical-hazard-areas",
     localOrder: 410,
-    outlineFilter: ["match", ["geometry-type"], ["LineString", "Polygon"], true, false],
+    outlineFilter: linesOrPolygons,
     sourceLayer: layers.hazards,
     style: config.hazardAreas,
     target: "nautical.hazardAreas"
@@ -4288,15 +4733,42 @@ function compileNautical(request, context) {
     style: config.wreckAreas,
     target: "nautical.wreckAreas"
   });
-  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({
+    // Bridges draw over the water and the areas below them.
+    filter: ["all", polygons, ofClass("bridge")],
+    id: "tileflow-nautical-bridges",
+    localOrder: 424,
+    outlineFilter: ["all", linesOrPolygons, ofClass("bridge")],
+    sourceLayer: layers.navigationAreas,
+    style: config.bridges,
+    target: "nautical.bridges"
+  });
+  for (const [key, id2, sourceLayer, localOrder, filter] of [
+    [
+      "coverage",
+      "tileflow-nautical-coverage-labels",
+      layers.coverage,
+      560,
+      ["has", fields.provider]
+    ],
+    [
+      "navigationAreas",
+      "tileflow-nautical-navigation-area-labels",
+      layers.navigationAreas,
+      562,
+      // Harbours, facilities and bridges carry their own symbols and labels.
+      [
+        "all",
+        ["has", fields.name],
+        ["match", ["get", fields.class], ["bridge", "facility", "harbour"], false, true]
+      ]
+    ],
+    ["reefs", "tileflow-nautical-reef-labels", layers.reefs, 564, ["has", fields.name]],
+    ["hazards", "tileflow-nautical-hazard-area-labels", layers.hazards, 566, ["has", fields.name]],
+    ["wrecks", "tileflow-nautical-wreck-area-labels", layers.wrecks, 568, ["has", fields.name]]
   ]) {
     add2({
-      filter: ["all", polygons, ["has", key === "coverage" ? fields.provider : fields.name]],
+      filter: ["all", polygons, filter],
       id: id2,
       localOrder,
       sourceLayer,
@@ -4304,6 +4776,37 @@ function compileNautical(request, context) {
       target: `nautical.labels.${key}`
     });
   }
+  add2({
+    filter: [
+      "all",
+      ofClass("bridge"),
+      [
+        "any",
+        ["has", fields.verticalClearance],
+        ["has", fields.verticalClearanceClosed],
+        ["has", fields.verticalClearanceOpen]
+      ]
+    ],
+    id: "tileflow-nautical-bridge-labels",
+    lines: { localOrder: 557, placement: "line-center" },
+    localOrder: 556,
+    sourceLayer: layers.navigationAreas,
+    style: config.labels?.bridges,
+    target: "nautical.labels.bridges"
+  });
+  add2({
+    filter: [
+      "all",
+      ofClass("overhead-cable"),
+      ["any", ["has", fields.verticalClearanceSafe], ["has", fields.verticalClearance]]
+    ],
+    id: "tileflow-nautical-overhead-cable-labels",
+    lines: { localOrder: 559, placement: "line" },
+    localOrder: 558,
+    sourceLayer: layers.navigationAreas,
+    style: config.labels?.overheadCables,
+    target: "nautical.labels.overheadCables"
+  });
   add2({
     filter: ["all", points, ["has", fields.depth]],
     id: "tileflow-nautical-soundings",
@@ -4322,6 +4825,16 @@ function compileNautical(request, context) {
     symbolFilter: ["==", ["get", fields.class], "rock"],
     target: "nautical.hazards"
   });
+  add2({
+    filter: ofClass("facility"),
+    id: "tileflow-nautical-facilities",
+    lines: { localOrder: 580, placement: "line-center" },
+    localOrder: 576,
+    markerFilter: points,
+    sourceLayer: layers.navigationAreas,
+    style: config.facilities,
+    target: "nautical.facilities"
+  });
   add2({
     filter: points,
     id: "tileflow-nautical-wrecks",
@@ -4331,13 +4844,23 @@ function compileNautical(request, context) {
     target: "nautical.wrecks"
   });
   add2({
-    filter: ["all", points, ["==", ["get", fields.class], "harbour"]],
+    // Harbour polygons, such as marinas, carry their symbol and name at their centre.
+    filter: ["all", pointsOrPolygons, ofClass("harbour")],
     id: "tileflow-nautical-harbours",
     localOrder: 582,
+    markerFilter: points,
     sourceLayer: layers.navigationAreas,
     style: config.harbours,
     target: "nautical.harbours"
   });
+  add2({
+    filter: ["all", points, ofClass("distance-mark")],
+    id: "tileflow-nautical-distance-marks",
+    localOrder: 584,
+    sourceLayer: layers.aids,
+    style: config.distanceMarks,
+    target: "nautical.distanceMarks"
+  });
   add2({
     filter: [
       "all",
@@ -4345,7 +4868,7 @@ function compileNautical(request, context) {
       [
         "match",
         ["get", fields.class],
-        [...floatingAidClasses, ...fixedAidClasses, "lighthouse"],
+        [...floatingAidClasses, ...fixedAidClasses, ...ownAidClasses, "lighthouse"],
         false,
         true
       ]
@@ -4356,6 +4879,14 @@ function compileNautical(request, context) {
     style: config.aids,
     target: "nautical.aids"
   });
+  add2({
+    filter: ["all", points, ofClass("notice")],
+    id: "tileflow-nautical-notices",
+    localOrder: 588,
+    sourceLayer: layers.aids,
+    style: config.notices,
+    target: "nautical.notices"
+  });
   add2({
     filter: ["all", points, ["match", ["get", fields.class], [...fixedAidClasses], true, false]],
     id: "tileflow-nautical-beacons",
@@ -4366,6 +4897,7 @@ function compileNautical(request, context) {
   });
   add2({
     filter: points,
+    flash: animateLights,
     id: "tileflow-nautical-lights",
     localOrder: 594,
     sourceLayer: layers.lights,
@@ -4381,7 +4913,7 @@ function compileNautical(request, context) {
     target: "nautical.buoys"
   });
   add2({
-    filter: ["all", points, ["==", ["get", fields.class], "lighthouse"]],
+    filter: ["all", points, ofClass("lighthouse")],
     id: "tileflow-nautical-lighthouses",
     localOrder: 602,
     sourceLayer: layers.aids,
@@ -4389,7 +4921,7 @@ function compileNautical(request, context) {
     target: "nautical.lighthouses"
   });
   add2({
-    filter: ["all", points, ["==", ["get", fields.class], "port"]],
+    filter: ["all", points, ofClass("port")],
     id: "tileflow-nautical-ports",
     localOrder: 606,
     sourceLayer: layers.navigationAreas,
@@ -4400,12 +4932,14 @@ function compileNautical(request, context) {
 }
 var points = ["==", ["geometry-type"], "Point"];
 var polygons = ["==", ["geometry-type"], "Polygon"];
+var lines = ["==", ["geometry-type"], "LineString"];
+var pointsOrPolygons = ["match", ["geometry-type"], ["Point", "Polygon"], true, false];
+var linesOrPolygons = ["match", ["geometry-type"], ["LineString", "Polygon"], true, false];
 function linesOf(classes) {
-  return [
-    "all",
-    ["==", ["geometry-type"], "LineString"],
-    ["match", ["get", fields.class], [...classes], true, false]
-  ];
+  return ["all", lines, ["match", ["get", fields.class], [...classes], true, false]];
+}
+function listIncludes(field2, item) {
+  return ["in", `,${item},`, ["concat", ",", ["to-string", ["coalesce", ["get", field2], ""]], ","]];
 }
 var fromFeatureMinZoom = [">=", ["zoom"], ["to-number", ["get", fields.minZoom], 0]];
 function appendNauticalLayer(contributions, options) {
@@ -4462,24 +4996,25 @@ function appendNauticalLayer(contributions, options) {
   if (point.visible === false) return;
   const isLabel = options.target.startsWith("nautical.labels.");
   if (!isLabel && point.marker && point.marker.visible !== false) {
+    const marker = applyCircleStyle(
+      base(
+        `${options.id}-marker`,
+        "circle",
+        options.markerFilter ? ["all", options.filter, options.markerFilter] : options.filter
+      ),
+      mergeTileflowDesign(
+        {
+          ...point.maxZoom === void 0 ? {} : { maxZoom: point.maxZoom },
+          ...point.minZoom === void 0 ? {} : { minZoom: point.minZoom }
+        },
+        point.marker
+      )
+    );
     contributions.push(
       nauticalContribution(
         `${options.target}.marker`,
         options.localOrder,
-        applyCircleStyle(
-          base(
-            `${options.id}-marker`,
-            "circle",
-            options.markerFilter ? ["all", options.filter, options.markerFilter] : options.filter
-          ),
-          mergeTileflowDesign(
-            {
-              ...point.maxZoom === void 0 ? {} : { maxZoom: point.maxZoom },
-              ...point.minZoom === void 0 ? {} : { minZoom: point.minZoom }
-            },
-            point.marker
-          )
-        ),
+        options.flash ? flashing(marker, ["circle-opacity", "circle-stroke-opacity"]) : marker,
         "symbols"
       )
     );
@@ -4487,21 +5022,79 @@ function appendNauticalLayer(contributions, options) {
   const hasText = Boolean(point.text && point.text.visible !== false);
   const hasIcon = Boolean(point.icon && point.icon.visible !== false);
   if (!hasText && !hasIcon) return;
+  const symbolFilter = [
+    options.filter,
+    ...options.symbolFilter ? [options.symbolFilter] : [],
+    ...options.lines ? [["!=", ["geometry-type"], "LineString"]] : []
+  ];
+  const symbol = applySymbolStyle(
+    base(
+      options.id,
+      "symbol",
+      symbolFilter.length === 1 ? symbolFilter[0] : ["all", ...symbolFilter]
+    ),
+    withoutMarker(point)
+  );
   contributions.push(
     nauticalContribution(
       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)
-      ),
+      options.flash && hasIcon ? flashing(symbol, ["icon-opacity"]) : symbol,
       "symbols"
     )
   );
+  if (options.lines) {
+    contributions.push(
+      nauticalContribution(
+        `${options.target}.lines`,
+        options.lines.localOrder,
+        applySymbolStyle(
+          base(`${options.id}-lines`, "symbol", [
+            "all",
+            options.filter,
+            ...options.symbolFilter ? [options.symbolFilter] : [],
+            lines
+          ]),
+          { ...withoutMarker(point), placement: options.lines.placement }
+        ),
+        "symbols"
+      )
+    );
+  }
+}
+function flashing(layer, properties2) {
+  const paint = { ...layer.paint ?? {} };
+  const factor = [
+    "interpolate",
+    ["linear"],
+    tileflowNauticalLightStateRead("intensity", 1),
+    0,
+    tileflowNauticalLightEclipseOpacity,
+    1,
+    1
+  ];
+  for (const property of properties2) {
+    const value = paint[property];
+    if (property !== "circle-opacity" && property !== "icon-opacity" && value === void 0) {
+      continue;
+    }
+    paint[property] = scaleOutputs(value ?? 1, factor);
+  }
+  return { ...layer, paint };
+}
+function scaleOutputs(value, factor) {
+  if (Array.isArray(value) && isZoomCurve(value)) {
+    const firstOutput = value[0] === "step" ? 2 : 4;
+    return value.map(
+      (entry, index) => index >= firstOutput && (index - firstOutput) % 2 === 0 ? ["*", entry, factor] : entry
+    );
+  }
+  return ["*", value, factor];
+}
+function isZoomCurve(value) {
+  const isZoom3 = (input) => Array.isArray(input) && input[0] === "zoom";
+  if (value[0] === "step") return isZoom3(value[1]);
+  return (value[0] === "interpolate" || value[0] === "interpolate-hcl" || value[0] === "interpolate-lab") && isZoom3(value[2]);
 }
 function withoutMarker(style) {
   const result = { ...style };
@@ -4538,8 +5131,96 @@ function themedImages(context) {
       ]
     ]);
   }
+  const notice = images.notices;
+  if (typeof notice === "string") {
+    const variants = ["information", "prohibition", "recommendation", "regulation", "restriction"].flatMap((role) => [role, context.images[roles.notices[role]] ?? notice]);
+    images.notices = expression(["match", ["get", fields.subclass], ...variants, notice]);
+  }
+  const facility = images.facilities;
+  if (typeof facility === "string") {
+    const cases = tileflowNauticalFacilityIcons.flatMap((category) => {
+      const image = context.images[roles.facilities[category]];
+      if (!image || image === facility) return [];
+      const categories = category === "visitor-berth" ? ["visitor-berth", "visitors-mooring"] : [category];
+      return [["any", ...categories.map((name) => listIncludes(fields.subclass, name))], image];
+    });
+    if (cases.length > 0) images.facilities = expression(["case", ...cases, facility]);
+  }
+  const harbour = images.harbours;
+  const marina = context.images[roles.harbours.marina];
+  if (typeof harbour === "string" && marina && marina !== harbour) {
+    images.harbours = expression([
+      "case",
+      ["any", ...marinaSubclasses.map((name) => listIncludes(fields.subclass, name))],
+      marina,
+      harbour
+    ]);
+  }
   return images;
 }
+function bridgeClearance() {
+  const metres = (field2) => ["concat", ["to-string", ["get", field2]], " m"];
+  const closed = fields.verticalClearanceClosed;
+  const open = fields.verticalClearanceOpen;
+  return [
+    "case",
+    ["any", ["has", closed], ["has", open]],
+    [
+      "concat",
+      ["case", ["has", closed], ["concat", "closed ", metres(closed)], ""],
+      ["case", ["all", ["has", closed], ["has", open]], " \xB7 ", ""],
+      ["case", ["has", open], ["concat", "open ", metres(open)], ""]
+    ],
+    ["has", fields.verticalClearance],
+    ["concat", "clearance ", metres(fields.verticalClearance)],
+    ""
+  ];
+}
+function cableClearance() {
+  return [
+    "case",
+    ["has", fields.verticalClearanceSafe],
+    ["concat", "safe clearance ", ["to-string", ["get", fields.verticalClearanceSafe]], " m"],
+    ["has", fields.verticalClearance],
+    ["concat", "clearance ", ["to-string", ["get", fields.verticalClearance]], " m"],
+    ""
+  ];
+}
+function nthColour(field2, index) {
+  const list = ["var", "nauticalColours"];
+  const cases = [];
+  for (let position = 1; position < maxAlternatingColours; position += 1) {
+    cases.push(["==", ["var", "nauticalColourIndex"], position], nthName(list, position));
+  }
+  return [
+    "let",
+    "nauticalColours",
+    ["to-string", ["coalesce", ["get", field2], ""]],
+    "nauticalColourIndex",
+    index,
+    ["case", ...cases, leadingName(list)]
+  ];
+}
+function nthName(list, position) {
+  if (position === 0) return leadingName(list);
+  const rest = `nauticalRest${position}`;
+  return [
+    "let",
+    rest,
+    [
+      "let",
+      "nauticalComma",
+      ["index-of", ",", list],
+      [
+        "case",
+        ["<", ["var", "nauticalComma"], 0],
+        "",
+        ["slice", list, ["+", ["var", "nauticalComma"], 1]]
+      ]
+    ],
+    nthName(["var", rest], position - 1)
+  ];
+}
 function firstColour(field2) {
   return [
     "let",
@@ -5405,6 +6086,7 @@ var visualNumberProperties = /* @__PURE__ */ new Set([
   "colorMix",
   "metallic",
   "roughness",
+  "horizonBlend",
   "hue",
   "saturation",
   "lightness",
@@ -5432,6 +6114,7 @@ var visualNumberProperties = /* @__PURE__ */ new Set([
   "roundLimit",
   "size",
   "spacing",
+  "starIntensity",
   "strokeOpacity",
   "strokeWidth",
   "textFitPadding",
@@ -5517,8 +6200,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";
@@ -5622,7 +6308,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 = isRecord5(map.modules) ? map.modules : void 0;
   const moduleDiagnostics = modules ? Object.keys(modules).sort(compareCodeUnits2).flatMap(
     (owner) => auditTileflowThemeValues(modules[owner], `modules.${owner}`, {
       owner,
@@ -5725,7 +6411,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 isRecord5(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;
@@ -5741,7 +6427,7 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     visitAuditableArray(value, path, category, state, false, intentRequired);
     return;
   }
-  if (!isRecord3(value)) return;
+  if (!isRecord5(value)) return;
   if (value.kind === "expression" && Array.isArray(value.value)) {
     visitAuditableArray(value.value, `${path}.value`, category, state, true, intentRequired);
     return;
@@ -5761,15 +6447,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);
@@ -6056,7 +6746,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 (!isRecord5(value)) return value;
     if (value.kind === "expression" && Array.isArray(value.value)) {
       return {
         ...value,
@@ -6370,7 +7060,7 @@ function assertThemeLighting(value, path, allowReset = false) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord3(value)) {
+  if (!isRecord5(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -6722,11 +7412,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 isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord2(value) {
-  if (!isRecord3(value)) return false;
+  if (!isRecord5(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -7278,35 +7968,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,
@@ -7363,6 +8055,63 @@ 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);
@@ -7401,7 +8150,7 @@ function phaseVisibility(surfaces, phase, fields2) {
 function zoomLevels(values) {
   const levels = new Set(Array.from({ length: 10 }, (_, index) => index + 15));
   for (const value of values) {
-    if (!isZoomCurve(value)) continue;
+    if (!isZoomCurve2(value)) continue;
     for (let index = 3; index < value.length - 1; index += 2) {
       const level = value[index];
       if (level < 15 || level > 24) continue;
@@ -7459,7 +8208,7 @@ function interpolationFactor2(interpolation, distance, span) {
   const logarithm = Math.log(interpolation[1]);
   return Math.expm1(logarithm * distance) / Math.expm1(logarithm * span);
 }
-function isZoomCurve(value) {
+function isZoomCurve2(value) {
   return Array.isArray(value) && (value[0] === "interpolate" && isZoom(value[2]) || value[0] === "step" && isZoom(value[1]));
 }
 function isZoom(value) {
@@ -7468,19 +8217,55 @@ function isZoom(value) {
 function atZoom(value, level) {
   if (!Array.isArray(value) || value[0] === "literal") return value;
   if (isZoom(value)) return level;
-  if (!isZoomCurve(value)) return value.map((entry) => atZoom(entry, level));
+  if (!isZoomCurve2(value)) return value.map((entry) => atZoom(entry, level));
   const stops = [];
   for (let index = 3; index < value.length - 1; index += 2) {
     stops.push({ level: value[index], value: value[index + 1] });
   }
   const exact = stops.find((stop) => stop.level === level);
-  if (exact) return exact.value;
+  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
@@ -7551,6 +8336,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"]) {
@@ -7573,7 +8362,8 @@ function compileRoads(request, context) {
           treatments,
           structure,
           phase,
-          phaseDefaults.color
+          phaseDefaults.color,
+          drawn
         );
         const contribution = {
           family: roadLinePhysicalFamily(roadClass, structure, phase),
@@ -7636,7 +8426,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;
@@ -7757,31 +8548,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;
@@ -7791,13 +8575,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",
@@ -8074,9 +8864,10 @@ function resolveRoadTreatments(request, fields2, roadClass) {
   add2(request?.modifiers?.unpaved, ["==", ["get", fields2.surface], "unpaved"]);
   add2(request?.modifiers?.indoor, flagFilter(fields2.indoor));
   add2(request?.modifiers?.official, flagFilter(fields2.official));
-  for (const [scale, style] of Object.entries(request?.mountainBike ?? {})) {
-    add2(style, ["==", ["to-string", ["get", fields2.mtbScale]], scale]);
-  }
+  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], [
@@ -8088,7 +8879,7 @@ function resolveRoadTreatments(request, fields2, roadClass) {
   }
   return entries;
 }
-function applyRoadTreatments(base, treatments, structure, phase, fallbackColor) {
+function applyRoadTreatments(base, treatments, structure, phase, fallbackColor, drawn) {
   const result = { ...base };
   const paintProperties = [
     "blur",
@@ -8105,12 +8896,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;
       }
@@ -8140,6 +8931,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;
@@ -10890,21 +11724,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 (!isRecord6(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 isRecord6(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 isRecord6(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 isRecord6(value) && value.kind === "tileflow-data-source" && value.name === "primary";
 }
-function isRecord4(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compareCodeUnits5(left, right) {
@@ -11008,8 +11842,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)) } : {}
+      ...isRecord7(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
+      ...isRecord7(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
     })
   });
 }
@@ -11201,20 +12035,29 @@ var exactPhysicalLayerIds = Object.freeze({
 var nauticalPhysicalBases = Object.freeze({
   "nautical.aids": "tileflow-nautical-aids",
   "nautical.beacons": "tileflow-nautical-beacons",
+  "nautical.berths": "tileflow-nautical-berths",
+  "nautical.bridges": "tileflow-nautical-bridges",
   "nautical.buoys": "tileflow-nautical-buoys",
   "nautical.cables": "tileflow-nautical-cables",
   "nautical.coverage": "tileflow-nautical-coverage",
+  "nautical.distanceMarks": "tileflow-nautical-distance-marks",
+  "nautical.facilities": "tileflow-nautical-facilities",
+  "nautical.harbourAreas": "tileflow-nautical-harbour-areas",
   "nautical.harbours": "tileflow-nautical-harbours",
   "nautical.hazardAreas": "tileflow-nautical-hazard-areas",
   "nautical.hazards": "tileflow-nautical-hazards",
+  "nautical.labels.bridges": "tileflow-nautical-bridge-labels",
   "nautical.labels.coverage": "tileflow-nautical-coverage-labels",
   "nautical.labels.hazards": "tileflow-nautical-hazard-area-labels",
   "nautical.labels.navigationAreas": "tileflow-nautical-navigation-area-labels",
+  "nautical.labels.overheadCables": "tileflow-nautical-overhead-cable-labels",
   "nautical.labels.reefs": "tileflow-nautical-reef-labels",
   "nautical.labels.wrecks": "tileflow-nautical-wreck-area-labels",
   "nautical.lighthouses": "tileflow-nautical-lighthouses",
   "nautical.lights": "tileflow-nautical-lights",
   "nautical.navigationAreas": "tileflow-nautical-navigation-areas",
+  "nautical.notices": "tileflow-nautical-notices",
+  "nautical.overheadCables": "tileflow-nautical-overhead-cables",
   "nautical.ports": "tileflow-nautical-ports",
   "nautical.reefs": "tileflow-nautical-reefs",
   "nautical.routes": "tileflow-nautical-routes",
@@ -11225,7 +12068,9 @@ var nauticalPhysicalBases = Object.freeze({
 function nauticalPhysicalLayerId(semanticKey) {
   const direct = nauticalPhysicalBases[semanticKey];
   if (direct) return direct;
-  const match3 = /^(nautical\.[A-Za-z0-9_.-]+)\.(fill|outline|marker|symbol)$/u.exec(semanticKey);
+  const match3 = /^(nautical\.[A-Za-z0-9_.-]+)\.(fill|outline|marker|symbol|lines)$/u.exec(
+    semanticKey
+  );
   if (!match3) return void 0;
   const base = nauticalPhysicalBases[match3[1]];
   if (!base) return void 0;
@@ -11269,21 +12114,21 @@ function visitReferences(value, counts, visited = /* @__PURE__ */ new WeakSet())
   }
 }
 function isSemanticFieldReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-field";
+  return isRecord7(value) && value.kind === "tileflow-data-field";
 }
 function isSemanticLayerReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-layer";
+  return isRecord7(value) && value.kind === "tileflow-data-layer";
 }
 function isSemanticSourceReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-source";
+  return isRecord7(value) && value.kind === "tileflow-data-source";
 }
 function cloneJson20(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord4(value) {
-  return isRecord5(value) ? value : {};
+  return isRecord7(value) ? value : {};
 }
-function isRecord5(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -11335,7 +12180,7 @@ function validateTileflowRenderSelectorConstraints(input) {
   };
   while (pending.length > 0) {
     const current = pending.pop();
-    if (!isRecord6(current.selector) || typeof current.selector.kind !== "string") {
+    if (!isRecord8(current.selector) || typeof current.selector.kind !== "string") {
       addIssue(
         "invalid-selector",
         "a render selector must be a semantic selector node",
@@ -11396,7 +12241,7 @@ function validateTileflowRenderSelectorConstraints(input) {
         }
         for (const [index, branch] of current.selector.branches.entries()) {
           const branchPath = [...branchesPath, index];
-          if (!isRecord6(branch)) {
+          if (!isRecord8(branch)) {
             addIssue("invalid-selector", "match selector branch must be an object", branchPath);
             continue;
           }
@@ -11427,14 +12272,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 (!isRecord8(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 (!isRecord8(stop)) continue;
           const zoom3 = stop.zoom;
           const zoomPath = [...stopsPath, index, "zoom"];
           if (typeof zoom3 !== "number" || !Number.isFinite(zoom3) || zoom3 < 0 || zoom3 > 24) {
@@ -11498,7 +12343,7 @@ function compileRenderSelector(selector, data) {
   assertRenderSelectorConstraints(selector);
   return lowerSelector(selector, data);
 }
-function applyCompiledRenderStacks(input, operations) {
+function applyCompiledRenderStacks(input, operations, targetsOfOtherModes = /* @__PURE__ */ new Map()) {
   let layers2 = input.map(cloneJson21);
   const passes = operations.filter(
     (operation) => operation.kind === "layer"
@@ -11529,9 +12374,10 @@ function applyCompiledRenderStacks(input, operations) {
   for (const refinement of activeRefinements) {
     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) {
@@ -11553,9 +12399,10 @@ 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)}`
       );
     }
   }
@@ -11759,7 +12606,7 @@ function applyRendererStyle(layer, renderer, style) {
   };
 }
 function lowerSelector(selector, data) {
-  if (!isRecord6(selector) || typeof selector.kind !== "string") {
+  if (!isRecord8(selector) || typeof selector.kind !== "string") {
     throw renderStackError(
       "invalid-selector",
       "A render selector must be a semantic selector node."
@@ -11962,7 +12809,7 @@ function requireRenderer(value) {
 function requirePlacement(value) {
   if (typeof value === "string") {
     if (tileflowBandPlacements.includes(value)) return;
-  } else if (isRecord6(value)) {
+  } else if (isRecord8(value)) {
     const keys = Object.keys(value);
     if (keys.length === 1 && (keys[0] === "above" || keys[0] === "below")) {
       requirePortableTarget(value[keys[0]], "render placement target");
@@ -11989,7 +12836,7 @@ function validateRefinementShape(operation) {
   validateStyle(operation.renderer, operation.style);
 }
 function validateStyle(renderer, style) {
-  if (!isRecord6(style)) {
+  if (!isRecord8(style)) {
     throw renderStackError(
       "invalid-style",
       `A ${renderer} render operation requires a style object.`
@@ -12091,7 +12938,7 @@ function normalizeRequirements(requirements) {
   return [...requirements];
 }
 function requireRenderStackEntries(stack) {
-  if (!isRecord6(stack)) {
+  if (!isRecord8(stack)) {
     throw renderStackError("invalid-stack", "A render stack must be a named operation record.");
   }
   const entries = Object.entries(stack);
@@ -12228,6 +13075,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" });
 }
@@ -12238,9 +13088,9 @@ function cloneJson21(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord5(value) {
-  return isRecord6(value) ? value : {};
+  return isRecord8(value) ? value : {};
 }
-function isRecord6(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -12448,6 +13298,9 @@ function createTileflowTimeOfDaySchema(operations, themeName) {
   );
 }
 
+// src/camera-limits.ts
+var tileflowMaxPitch = 85;
+
 // src/resolved-map-schema.ts
 var TileflowResolvedMapValidationError = class extends Error {
   code = "CONFIG_INVALID";
@@ -13311,6 +14164,7 @@ 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(),
@@ -13366,6 +14220,7 @@ var buildingsModuleSchema = z5.object({
       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(),
@@ -13604,24 +14459,34 @@ var poiModuleSchema = z5.object({
 var nauticalModuleSchema = z5.object({
   type: z5.literal("nautical"),
   aids: markerSymbolStyleSchema.optional(),
+  animateLights: z5.boolean().optional(),
   beacons: markerSymbolStyleSchema.optional(),
+  berths: areaStyleSchema.optional(),
+  bridges: areaStyleSchema.optional(),
   buoys: markerSymbolStyleSchema.optional(),
   cables: lineStyleSchema.optional(),
   coverage: areaStyleSchema.optional(),
+  distanceMarks: markerSymbolStyleSchema.optional(),
   enabled: z5.boolean().optional(),
+  facilities: markerSymbolStyleSchema.optional(),
+  harbourAreas: areaStyleSchema.optional(),
   harbours: markerSymbolStyleSchema.optional(),
   hazardAreas: areaStyleSchema.optional(),
   hazards: markerSymbolStyleSchema.optional(),
   labels: z5.object({
+    bridges: symbolStyleSchema.optional(),
     coverage: symbolStyleSchema.optional(),
     hazards: symbolStyleSchema.optional(),
     navigationAreas: symbolStyleSchema.optional(),
+    overheadCables: symbolStyleSchema.optional(),
     reefs: symbolStyleSchema.optional(),
     wrecks: symbolStyleSchema.optional()
   }).strict().optional(),
   lighthouses: markerSymbolStyleSchema.optional(),
   lights: markerSymbolStyleSchema.optional(),
   navigationAreas: areaStyleSchema.optional(),
+  notices: markerSymbolStyleSchema.optional(),
+  overheadCables: lineStyleSchema.optional(),
   ports: markerSymbolStyleSchema.optional(),
   reefs: areaStyleSchema.optional(),
   renderStack: renderStackSchema.optional(),
@@ -13745,6 +14610,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)
@@ -14153,7 +15019,7 @@ var terrainContoursSchema = z5.object({
   demUrl: z5.string().min(1).max(2048).refine(
     isSafeTileflowDemUrlTemplate,
     "Expected a safe HTTP(S) DEM URL template containing {z}, {x}, and {y}"
-  ),
+  ).optional(),
   index: terrainContourLineSchema.optional(),
   labels: terrainContourLabelSchema.optional(),
   maxZoom: z5.number().int().min(0).max(24).optional(),
@@ -14277,10 +15143,25 @@ var atmosphereSchema = z5.union([
     starParallax: z5.number().finite().min(0).max(1).optional()
   }).strict()
 ]);
+var skyNumberSchema = z5.union([
+  z5.number().finite().min(0).max(1),
+  fixedNumberSchema.extend({ value: z5.number().finite().min(0).max(1) }),
+  themeNumberReferenceSchema
+]);
+var skySchema = z5.union([
+  z5.boolean(),
+  z5.object({
+    color: atmosphereColorSchema.optional(),
+    horizonColor: atmosphereColorSchema.optional(),
+    horizonBlend: skyNumberSchema.optional(),
+    glowColor: atmosphereColorSchema.optional(),
+    starIntensity: skyNumberSchema.optional()
+  }).strict()
+]);
 var viewSchema = z5.object({
   bearing: z5.number().finite().min(-180).max(180).optional(),
   center: z5.tuple([z5.number().finite().min(-180).max(180), z5.number().finite().min(-90).max(90)]).optional(),
-  pitch: z5.number().finite().min(0).max(85).optional(),
+  pitch: z5.number().finite().min(0).max(tileflowMaxPitch).optional(),
   zoom: zoomNumberSchema.optional()
 }).strict();
 var themesSchema = z5.record(tileflowThemeNameSchema, tileflowThemeSchema).superRefine((themes, context) => {
@@ -14323,6 +15204,7 @@ var resolvedTileflowMapSchema = z5.object({
   name: z5.string().trim().min(1),
   overlays: overlaysSchema.optional(),
   projection: z5.enum(["globe", "mercator"]).optional(),
+  sky: skySchema.optional(),
   sources: hostedSourcesSchema.optional(),
   systemThemes: systemThemesSchema.optional(),
   terrain: terrainSchema.optional(),
@@ -14610,7 +15492,7 @@ function resolveTerrain(terrain, apiBaseUrl) {
   const mode = terrainConfig.mode ?? "hillshade";
   const encoding = terrainConfig.encoding ?? "terrarium";
   const raster = mode === "none" ? void 0 : resolveRaster(terrainConfig, apiBaseUrl, encoding);
-  const contours = terrainConfig.contours ? resolveContours(terrainConfig.contours, encoding, terrainConfig.attribution) : void 0;
+  const contours = terrainConfig.contours ? resolveContours(terrainConfig.contours, encoding, terrainConfig.attribution, apiBaseUrl) : void 0;
   if (!raster && !contours) return void 0;
   return {
     ...contours ? { contours } : {},
@@ -14742,7 +15624,7 @@ function resolveRaster(terrain, apiBaseUrl, encoding) {
     }
   };
 }
-function resolveContours(contours, encoding, attribution) {
+function resolveContours(contours, encoding, attribution, apiBaseUrl) {
   const thresholdZooms = Object.keys(contours.thresholds).map(Number);
   const minimumZoom2 = contours.minZoom ?? Math.min(...thresholdZooms);
   const maximumZoom2 = contours.maxZoom ?? Math.max(...thresholdZooms);
@@ -14750,7 +15632,7 @@ function resolveContours(contours, encoding, attribution) {
   const tiles = [
     createTileflowContourProtocolUrl({
       demMaxzoom: contours.demMaxZoom,
-      demUrl: contours.demUrl,
+      demUrl: contours.demUrl ?? `${apiBaseUrl}/tiles/terrain/{z}/{x}/{y}.webp`,
       encoding,
       maxzoom: maximumZoom2,
       multiplier: contours.multiplier ?? 1,
@@ -15351,11 +16233,11 @@ function isTileflowPoiCategory(value) {
   return typeof value === "string" && tileflowPoiCategories.includes(value);
 }
 function semanticTarget(layer) {
-  if (!isRecord7(layer.metadata)) return void 0;
+  if (!isRecord9(layer.metadata)) return void 0;
   const value = layer.metadata[tileflowCompilerMetadataKeys.target];
   return typeof value === "string" ? value : void 0;
 }
-function isRecord7(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSafeArtifactName(value) {
@@ -15536,6 +16418,8 @@ function mergeRoadLineGroup(key, layers2) {
   const paintKeys = new Set(layers2.flatMap((layer) => Object.keys(layer.style.appearance ?? {})));
   for (const key2 of paintKeys) {
     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],
@@ -16251,7 +17135,7 @@ var colourSources = [
   ["tileflow-buildings-fill", "fill-color"]
 ];
 function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, tileflowLandmarks) {
-  const config = isRecord8(module) ? module : {};
+  const config = isRecord10(module) ? module : {};
   if (config.enabled === false) return void 0;
   const style = config.threeDimensional ?? {};
   const defaults4 = tileflowDefaultBuildings3DDesign;
@@ -16284,7 +17168,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
     edgeRadius: number(style.edgeRadius, defaults4.edgeRadius),
     ...typeof edgeColor === "string" ? { edgeColor } : {},
     nightLight: number(style.nightLight, 0),
-    ...isRecord8(style.floodLight) ? {
+    ...isRecord10(style.floodLight) ? {
       floodLight: readBuildingFloodLight({
         ...style.floodLight,
         intensity: number(style.floodLight.intensity, 0),
@@ -16292,10 +17176,10 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
         color: style.floodLight.color === void 0 ? void 0 : toMapLibreStyleValue(style.floodLight.color)
       })
     } : {},
-    ...isRecord8(style.modelLighting) ? {
+    ...isRecord10(style.modelLighting) ? {
       modelLighting: readModelRoleLighting(
         Object.fromEntries(
-          Object.entries(style.modelLighting).filter(([, entry]) => isRecord8(entry)).map(([role, entry]) => {
+          Object.entries(style.modelLighting).filter(([, entry]) => isRecord10(entry)).map(([role, entry]) => {
             const own = entry;
             return [
               role,
@@ -16306,7 +17190,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
                   ["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)) } : {},
-                ...isRecord8(own.colorVariation) ? {
+                ...isRecord10(own.colorVariation) ? {
                   colorVariation: {
                     ...own.colorVariation,
                     ...Object.fromEntries(
@@ -16328,6 +17212,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
       )
     } : {},
     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),
@@ -16338,7 +17223,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
 }
 function landmarksOf(value, tileflowLandmarks) {
   if (value === false) return {};
-  if (isRecord8(value) && typeof value.url === "string") return { landmarks: { url: value.url } };
+  if (isRecord10(value) && typeof value.url === "string") return { landmarks: { url: value.url } };
   return tileflowLandmarks ? { landmarks: { url: tileflowLandmarks } } : {};
 }
 function placedModels(value, served) {
@@ -16365,7 +17250,7 @@ function placedModels(value, served) {
   };
 }
 function modelColours(value) {
-  if (!isRecord8(value)) return {};
+  if (!isRecord10(value)) return {};
   const colours = {};
   for (const [part, colour] of Object.entries(value)) {
     const resolved = colour === void 0 ? void 0 : toMapLibreStyleValue(colour);
@@ -16374,7 +17259,7 @@ function modelColours(value) {
   return Object.keys(colours).length > 0 ? { modelColors: colours } : {};
 }
 function tileflowStreetLightsDesignOf(module, context) {
-  const config = isRecord8(module) ? module : {};
+  const config = isRecord10(module) ? module : {};
   const layers2 = context.data.schema.layers;
   const style = config.streetLights ?? {};
   if (config.enabled === false || style.enabled !== true || !layers2.streetFurniture)
@@ -16394,7 +17279,7 @@ function tileflowStreetLightsDesignOf(module, context) {
     intensity: typeof intensity === "number" ? intensity : 1
   };
 }
-function isRecord8(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -16566,7 +17451,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) => isRecord11(module) && module.enabled !== false && "renderStack" in module && isRecord11(module.renderStack)
   );
   const renderOperations = runCompilationPhase(
     "render-stack",
@@ -16592,7 +17477,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",
@@ -16808,9 +17697,15 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       layer.layout = { ...layer.layout, visibility: "none" };
   }
   const atmosphere = resolveTileflowAtmosphere(config.atmosphere);
+  const sky = resolveTileflowSky(config.sky);
   const notices = compiledNotices(layers2, marine);
+  const nauticalLights = declareTileflowNauticalLights(
+    layers2,
+    marine?.nautical?.sourceId,
+    tileflowNauticalV1Schema.layers.lights
+  );
   const style = {
-    ...atmosphere ? { sky: compileTileflowSky(atmosphere) } : {},
+    ...sky ? { sky: compileTileflowStreetSky(sky) } : atmosphere ? { sky: compileTileflowSky(atmosphere) } : {},
     version: 8,
     name: config.name ?? "Streets",
     ...glyphs ? { glyphs } : {},
@@ -16829,6 +17724,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
         ...mapMetadata.lineage && mapMetadata.lineage.length > 1 ? { "tileflow:extends": mapMetadata.lineage.slice(1) } : {}
       } : {},
       ...atmosphere ? { [tileflowAtmosphereMetadataKey]: { version: 1, ...atmosphere } } : {},
+      ...sky ? { [tileflowSkyMetadataKey]: skyMetadata(input, selected.name, sky) } : {},
       "tileflow:theme": selected.name,
       "tileflow:colorScheme": resolvedTheme.colorScheme,
       [tileflowRouteMetadataKey]: tileflowRouteMetadata(resolveTileflowRouteInks(resolvedTheme)),
@@ -16857,9 +17753,10 @@ 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(),
+      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord11(module) || module.enabled !== false).map(([name]) => name).sort(),
       ...config.view ? { "tileflow:view": config.view } : {},
-      ...notices.length > 0 ? { [tileflowNoticesMetadataKey]: notices } : {}
+      ...notices.length > 0 ? { [tileflowNoticesMetadataKey]: notices } : {},
+      ...nauticalLights ? { [tileflowNauticalLightsMetadataKey]: nauticalLights } : {}
     }
   };
   const report = {
@@ -16919,7 +17816,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 = isRecord11(layer.metadata) ? { ...layer.metadata } : void 0;
     if (metadata) {
       const owner = metadata[tileflowCompilerMetadataKeys.owner];
       delete metadata[tileflowCompilerProvenanceMetadataKey];
@@ -16953,7 +17850,7 @@ function assertMapLibreStyle(style, mapId) {
     }
   );
 }
-function isRecord9(value) {
+function isRecord11(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compiledNotices(layers2, marine) {
@@ -16998,8 +17895,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 = isRecord11(layer.layout) ? layer.layout : {};
+    const paint = isRecord11(layer.paint) ? layer.paint : {};
     const layerId = typeof layer.id === "string" ? layer.id : "<unknown>";
     for (const [property, value] of [
       ["icon-image", layout["icon-image"]],
@@ -17088,7 +17985,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 = isRecord11(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(",");
@@ -17104,7 +18001,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 = isRecord11(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"];
@@ -17117,7 +18014,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 = isRecord11(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) {
@@ -17143,7 +18040,7 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record4 = isRecord9(error) ? error : {};
+  const record4 = isRecord11(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 });
@@ -17174,6 +18071,35 @@ function compareCodeUnits7(left, right) {
 function semanticReportKey(...parts) {
   return parts.join("\0");
 }
+function skyMetadata(input, themeName, sky) {
+  const family = Object.values(input.timeOfDay ?? {}).find(
+    (moments) => Object.values(moments).includes(themeName)
+  );
+  const colours = (name) => {
+    const theme = name === void 0 ? void 0 : input.themes[name];
+    if (!theme) return void 0;
+    const resolved = resolveTileflowSky(
+      resolveThemeValues({ sky: input.sky }, theme, `map.${input.id}.themes.${name}`).sky
+    );
+    return resolved ? {
+      color: resolved.color,
+      horizonColor: resolved.horizonColor,
+      horizonBlend: resolved.horizonBlend,
+      glowColor: resolved.glowColor
+    } : void 0;
+  };
+  const day = colours(family?.day);
+  const night = colours(family?.night);
+  const dawn = colours(family?.dawn);
+  const dusk = colours(family?.dusk);
+  const timesOfDay = day && night && (dawn ?? dusk) ? { day, night, dawn: dawn ?? dusk, dusk: dusk ?? dawn } : void 0;
+  return {
+    version: 1,
+    starIntensity: sky.starIntensity,
+    glowColor: sky.glowColor,
+    ...timesOfDay ? { timesOfDay } : {}
+  };
+}
 
 // src/manifest-types.ts
 var tileflowRuntimeManifestVersion = 1;
@@ -17186,7 +18112,7 @@ function createTileflowRuntimeViewSchema(operations) {
     center: operations.optional(
       operations.tuplePair(operations.number(-180, 180), operations.number(-90, 90))
     ),
-    pitch: operations.optional(operations.number(0, 85)),
+    pitch: operations.optional(operations.number(0, tileflowMaxPitch)),
     zoom: operations.optional(operations.number(0, 24))
   });
 }
@@ -17460,7 +18386,7 @@ var tileflowCaptureSceneLimits = Object.freeze({
   boundsPadding: { maximum: 1024, minimum: 0 },
   captureIdLength: tileflowPortableIdMaximumLength,
   maximumPhysicalPixels: 16777216,
-  pitch: { maximum: 85, minimum: 0 },
+  pitch: { maximum: tileflowMaxPitch, minimum: 0 },
   selectorLength: 256,
   viewport: { maximum: 4096, minimum: 64 },
   zoom: { maximum: 24, minimum: 0 }
@@ -17713,6 +18639,7 @@ var tileflowMapMergeStrategies = {
   projection: "atomic",
   scenes: "leaf",
   shots: "leaf",
+  sky: "atomic",
   sources: "keyed-resources",
   systemThemes: "atomic",
   terrain: "atomic",
@@ -17894,6 +18821,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;
@@ -18056,11 +18986,11 @@ function cloneDesign(value) {
 function describeMap(value) {
   return typeof value.id === "string" && value.id ? value.id : "<anonymous>";
 }
-function isRecord10(value) {
+function isRecord12(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord4(value) {
-  if (!isRecord10(value)) return false;
+  if (!isRecord12(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -18894,6 +19824,8 @@ var tileflowNativeStyleTransformationSchema = strictNativeObject({
   inputLayers: layerCountSchema,
   outputLayers: layerCountSchema,
   projection: z13.enum(["none", "mercator-to-implicit", "globe-to-mercator"]),
+  /** Present when preparation removed a browser sky, which Native does not draw. */
+  sky: z13.literal("removed").optional(),
   layers: z13.array(layerTransformationSchema).max(tileflowNativeProfileLimits.maximumLayers),
   symbolOverlap: z13.array(symbolOverlapTransformationSchema).max(tileflowNativeProfileLimits.maximumLayers)
 }).superRefine((style, context) => {
@@ -28026,7 +28958,7 @@ var viewSchema2 = z15.object({
   center: z15.tuple([z15.number().min(-180).max(180), z15.number().min(-90).max(90)]).optional(),
   zoom: z15.number().min(0).max(24).optional(),
   bearing: z15.number().finite().optional(),
-  pitch: z15.number().min(0).max(85).optional()
+  pitch: z15.number().min(0).max(tileflowMaxPitch).optional()
 }).strict();
 var tileflowRendererDeploymentArtifactSchema = z15.object({
   kind: z15.literal("tileflow-map-deployment"),