@tileflow/core 0.1.0-alpha.38 → 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({
@@ -3429,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"
@@ -3493,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",
@@ -3514,6 +3591,7 @@ var tileflowNauticalV1Schema = Object.freeze({
     scale: "scale",
     sectorEnd: "sector_end",
     sectorStart: "sector_start",
+    sequence: "sequence",
     shape: "shape",
     size: "size",
     subclass: "subclass",
@@ -3521,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({
@@ -3544,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 });
@@ -3628,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,
@@ -3637,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);
@@ -3698,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({
@@ -3740,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 [];
@@ -3770,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,
@@ -3864,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 }
@@ -3973,6 +4197,7 @@ function compileNautical(request, context) {
     harbours: {
       minZoom: 11,
       placement: "point",
+      ...rankPriority,
       ...images.harbours ? {
         icon: {
           color: ink,
@@ -4023,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",
@@ -4205,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,
@@ -4254,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], ""]]],
@@ -4264,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",
@@ -4297,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"
@@ -4314,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,
@@ -4330,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",
@@ -4348,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",
@@ -4357,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",
@@ -4371,7 +4868,7 @@ function compileNautical(request, context) {
       [
         "match",
         ["get", fields.class],
-        [...floatingAidClasses, ...fixedAidClasses, "lighthouse"],
+        [...floatingAidClasses, ...fixedAidClasses, ...ownAidClasses, "lighthouse"],
         false,
         true
       ]
@@ -4382,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",
@@ -4392,6 +4897,7 @@ function compileNautical(request, context) {
   });
   add2({
     filter: points,
+    flash: animateLights,
     id: "tileflow-nautical-lights",
     localOrder: 594,
     sourceLayer: layers.lights,
@@ -4407,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,
@@ -4415,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,
@@ -4426,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) {
@@ -4488,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"
       )
     );
@@ -4513,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 };
@@ -4564,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",
@@ -5431,6 +6086,7 @@ var visualNumberProperties = /* @__PURE__ */ new Set([
   "colorMix",
   "metallic",
   "roughness",
+  "horizonBlend",
   "hue",
   "saturation",
   "lightness",
@@ -5458,6 +6114,7 @@ var visualNumberProperties = /* @__PURE__ */ new Set([
   "roundLimit",
   "size",
   "spacing",
+  "starIntensity",
   "strokeOpacity",
   "strokeWidth",
   "textFitPadding",
@@ -5651,7 +6308,7 @@ function auditTileflowThemeValues(value, path = "value", context = inferAuditCon
   return diagnostics.sort(compareAuditDiagnostics);
 }
 function auditTileflowMapThemeValues(map) {
-  const modules = isRecord4(map.modules) ? map.modules : void 0;
+  const modules = isRecord5(map.modules) ? map.modules : void 0;
   const moduleDiagnostics = modules ? Object.keys(modules).sort(compareCodeUnits2).flatMap(
     (owner) => auditTileflowThemeValues(modules[owner], `modules.${owner}`, {
       owner,
@@ -5754,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 isRecord4(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;
@@ -5770,7 +6427,7 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     visitAuditableArray(value, path, category, state, false, intentRequired);
     return;
   }
-  if (!isRecord4(value)) return;
+  if (!isRecord5(value)) return;
   if (value.kind === "expression" && Array.isArray(value.value)) {
     visitAuditableArray(value.value, `${path}.value`, category, state, true, intentRequired);
     return;
@@ -6089,7 +6746,7 @@ var ThemeValueResolver = class {
     if (Array.isArray(value)) {
       return value.map((entry, index) => this.resolveTree(entry, `${path}[${index}]`, category));
     }
-    if (!isRecord4(value)) return value;
+    if (!isRecord5(value)) return value;
     if (value.kind === "expression" && Array.isArray(value.value)) {
       return {
         ...value,
@@ -6403,7 +7060,7 @@ function assertThemeLighting(value, path, allowReset = false) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -6755,11 +7412,11 @@ function cloneJson14(value) {
   if (serialized === void 0) throw new Error("Tileflow themes must be JSON-serializable.");
   return JSON.parse(serialized);
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord2(value) {
-  if (!isRecord4(value)) return false;
+  if (!isRecord5(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -7493,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;
@@ -7551,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) {
@@ -7560,7 +8217,7 @@ 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] });
@@ -11067,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 (!isRecord5(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 isRecord5(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 isRecord5(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 isRecord5(value) && value.kind === "tileflow-data-source" && value.name === "primary";
+  return isRecord6(value) && value.kind === "tileflow-data-source" && value.name === "primary";
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compareCodeUnits5(left, right) {
@@ -11185,8 +11842,8 @@ function createTileflowLayerTemplateIR(layer, semanticKey) {
     renderer: type,
     ...filter === void 0 ? {} : { selector: cloneJson20(filter) },
     style: Object.freeze({
-      ...isRecord6(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
-      ...isRecord6(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
+      ...isRecord7(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
+      ...isRecord7(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
     })
   });
 }
@@ -11378,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",
@@ -11402,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;
@@ -11446,21 +12114,21 @@ function visitReferences(value, counts, visited = /* @__PURE__ */ new WeakSet())
   }
 }
 function isSemanticFieldReference(value) {
-  return isRecord6(value) && value.kind === "tileflow-data-field";
+  return isRecord7(value) && value.kind === "tileflow-data-field";
 }
 function isSemanticLayerReference(value) {
-  return isRecord6(value) && value.kind === "tileflow-data-layer";
+  return isRecord7(value) && value.kind === "tileflow-data-layer";
 }
 function isSemanticSourceReference(value) {
-  return isRecord6(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 isRecord6(value) ? value : {};
+  return isRecord7(value) ? value : {};
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -11512,7 +12180,7 @@ function validateTileflowRenderSelectorConstraints(input) {
   };
   while (pending.length > 0) {
     const current = pending.pop();
-    if (!isRecord7(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",
@@ -11573,7 +12241,7 @@ function validateTileflowRenderSelectorConstraints(input) {
         }
         for (const [index, branch] of current.selector.branches.entries()) {
           const branchPath = [...branchesPath, index];
-          if (!isRecord7(branch)) {
+          if (!isRecord8(branch)) {
             addIssue("invalid-selector", "match selector branch must be an object", branchPath);
             continue;
           }
@@ -11604,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 (!isRecord7(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 (!isRecord7(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) {
@@ -11938,7 +12606,7 @@ function applyRendererStyle(layer, renderer, style) {
   };
 }
 function lowerSelector(selector, data) {
-  if (!isRecord7(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."
@@ -12141,7 +12809,7 @@ function requireRenderer(value) {
 function requirePlacement(value) {
   if (typeof value === "string") {
     if (tileflowBandPlacements.includes(value)) return;
-  } else if (isRecord7(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");
@@ -12168,7 +12836,7 @@ function validateRefinementShape(operation) {
   validateStyle(operation.renderer, operation.style);
 }
 function validateStyle(renderer, style) {
-  if (!isRecord7(style)) {
+  if (!isRecord8(style)) {
     throw renderStackError(
       "invalid-style",
       `A ${renderer} render operation requires a style object.`
@@ -12270,7 +12938,7 @@ function normalizeRequirements(requirements) {
   return [...requirements];
 }
 function requireRenderStackEntries(stack) {
-  if (!isRecord7(stack)) {
+  if (!isRecord8(stack)) {
     throw renderStackError("invalid-stack", "A render stack must be a named operation record.");
   }
   const entries = Object.entries(stack);
@@ -12420,9 +13088,9 @@ function cloneJson21(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord5(value) {
-  return isRecord7(value) ? value : {};
+  return isRecord8(value) ? value : {};
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -12630,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";
@@ -13788,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(),
@@ -14338,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(),
@@ -14462,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) => {
@@ -14508,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(),
@@ -14795,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 } : {},
@@ -14927,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);
@@ -14935,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,
@@ -15536,11 +16233,11 @@ function isTileflowPoiCategory(value) {
   return typeof value === "string" && tileflowPoiCategories.includes(value);
 }
 function semanticTarget(layer) {
-  if (!isRecord8(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 isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSafeArtifactName(value) {
@@ -16438,7 +17135,7 @@ var colourSources = [
   ["tileflow-buildings-fill", "fill-color"]
 ];
 function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, tileflowLandmarks) {
-  const config = isRecord9(module) ? module : {};
+  const config = isRecord10(module) ? module : {};
   if (config.enabled === false) return void 0;
   const style = config.threeDimensional ?? {};
   const defaults4 = tileflowDefaultBuildings3DDesign;
@@ -16471,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),
-    ...isRecord9(style.floodLight) ? {
+    ...isRecord10(style.floodLight) ? {
       floodLight: readBuildingFloodLight({
         ...style.floodLight,
         intensity: number(style.floodLight.intensity, 0),
@@ -16479,10 +17176,10 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
         color: style.floodLight.color === void 0 ? void 0 : toMapLibreStyleValue(style.floodLight.color)
       })
     } : {},
-    ...isRecord9(style.modelLighting) ? {
+    ...isRecord10(style.modelLighting) ? {
       modelLighting: readModelRoleLighting(
         Object.fromEntries(
-          Object.entries(style.modelLighting).filter(([, entry]) => isRecord9(entry)).map(([role, entry]) => {
+          Object.entries(style.modelLighting).filter(([, entry]) => isRecord10(entry)).map(([role, entry]) => {
             const own = entry;
             return [
               role,
@@ -16493,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)) } : {},
-                ...isRecord9(own.colorVariation) ? {
+                ...isRecord10(own.colorVariation) ? {
                   colorVariation: {
                     ...own.colorVariation,
                     ...Object.fromEntries(
@@ -16526,7 +17223,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
 }
 function landmarksOf(value, tileflowLandmarks) {
   if (value === false) return {};
-  if (isRecord9(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) {
@@ -16553,7 +17250,7 @@ function placedModels(value, served) {
   };
 }
 function modelColours(value) {
-  if (!isRecord9(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);
@@ -16562,7 +17259,7 @@ function modelColours(value) {
   return Object.keys(colours).length > 0 ? { modelColors: colours } : {};
 }
 function tileflowStreetLightsDesignOf(module, context) {
-  const config = isRecord9(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)
@@ -16582,7 +17279,7 @@ function tileflowStreetLightsDesignOf(module, context) {
     intensity: typeof intensity === "number" ? intensity : 1
   };
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -16754,7 +17451,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     )
   );
   const renderStackModules = Object.values(modules).filter(
-    (module) => isRecord10(module) && module.enabled !== false && "renderStack" in module && isRecord10(module.renderStack)
+    (module) => isRecord11(module) && module.enabled !== false && "renderStack" in module && isRecord11(module.renderStack)
   );
   const renderOperations = runCompilationPhase(
     "render-stack",
@@ -17000,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 } : {},
@@ -17021,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)),
@@ -17049,9 +17753,10 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       "tileflow:sourceRequirements": sourceRequirements,
       ...interactionManifest ? { [tileflowInteractionManifestMetadataKey]: interactionManifest } : {},
       [tileflowOverlayPlacementManifestMetadataKey]: overlayPlacementManifest,
-      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord10(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 = {
@@ -17111,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 = isRecord10(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];
@@ -17145,7 +17850,7 @@ function assertMapLibreStyle(style, mapId) {
     }
   );
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compiledNotices(layers2, marine) {
@@ -17190,8 +17895,8 @@ function assertPreparedIconReferences(style, config, prepared) {
 function collectStyleImageReferences(style) {
   const result = /* @__PURE__ */ new Set();
   for (const layer of style.layers) {
-    const layout = isRecord10(layer.layout) ? layer.layout : {};
-    const paint = isRecord10(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"]],
@@ -17280,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 = isRecord10(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(",");
@@ -17296,7 +18001,7 @@ function assertGlyphFontStacks(style, config) {
 function assertTextAssets(style, config) {
   const textLayers = [];
   for (const layer of style.layers) {
-    const layout = isRecord10(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"];
@@ -17309,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 = isRecord10(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) {
@@ -17335,7 +18040,7 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record4 = isRecord10(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 });
@@ -17366,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;
@@ -17378,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))
   });
 }
@@ -17652,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 }
@@ -17905,6 +18639,7 @@ var tileflowMapMergeStrategies = {
   projection: "atomic",
   scenes: "leaf",
   shots: "leaf",
+  sky: "atomic",
   sources: "keyed-resources",
   systemThemes: "atomic",
   terrain: "atomic",
@@ -18251,11 +18986,11 @@ function cloneDesign(value) {
 function describeMap(value) {
   return typeof value.id === "string" && value.id ? value.id : "<anonymous>";
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord4(value) {
-  if (!isRecord11(value)) return false;
+  if (!isRecord12(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -19089,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) => {
@@ -28221,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"),