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

package/dist/build.js

@@ -45,6 +45,112 @@ function compileTileflowSky(options) {
   };
 }
 
+// src/models-3d-model.ts
+var tileflowModelParts = Object.freeze({
+  surface: 0,
+  secondary: 1,
+  glass: 2,
+  accent: 3,
+  roof: 4
+});
+var tileflowModelLightingRoles = Object.freeze({
+  unclassified: 0,
+  wall: 1,
+  door: 2,
+  roof: 3,
+  window: 4,
+  lamp: 5,
+  logo: 6
+});
+var tileflowModelDefaultLightingRoles = Object.freeze([1, 1, 4, 1, 3]);
+var tileflowModelLimits = Object.freeze({
+  /** Levels of detail, nearest first. */
+  levels: 3,
+  /** Vertices of one level. */
+  vertices: 2e5,
+  /** Triangles of one level. */
+  triangles: 2e5,
+  /** Points of the footprint's rings, together. */
+  footprintPoints: 4096,
+  /** Half the model's widest extent, in metres. */
+  radius: 2e3,
+  /** The model's height, in metres. */
+  height: 1e3,
+  /** Models in one prepared file, as a landmark tile holds them. */
+  models: 512,
+  /** Bytes of one prepared file. */
+  bytes: 16 * 1024 * 1024
+});
+
+// src/building-illumination.ts
+var defaultBuildingFloodLight = Object.freeze({
+  intensity: 0,
+  brightnessScale: 1,
+  color: "#f5cfa8",
+  groundRadius: [30, 100],
+  minGroundHeight: 30,
+  minWallHeight: 200,
+  wallHeightRatio: 1 / 3
+});
+var defaultModelEmissionGradient = [0, 1, 1, 1, 0];
+function readBuildingFloodLight(value) {
+  if (!record(value)) return void 0;
+  const defaults4 = defaultBuildingFloodLight;
+  const radius = value.groundRadius;
+  return {
+    intensity: bounded(value.intensity, 0, 1, 0),
+    brightnessScale: bounded(value.brightnessScale, 0, 16, 1),
+    color: typeof value.color === "string" ? value.color : defaults4.color,
+    groundRadius: Array.isArray(radius) && radius.length === 2 && radius.every((v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 2048) && radius[0] <= radius[1] ? [radius[0], radius[1]] : defaults4.groundRadius,
+    minGroundHeight: bounded(value.minGroundHeight, 0, 6e3, defaults4.minGroundHeight),
+    minWallHeight: bounded(value.minWallHeight, 0, 6e3, defaults4.minWallHeight),
+    wallHeightRatio: bounded(value.wallHeightRatio, 0, 1, defaults4.wallHeightRatio)
+  };
+}
+function readModelRoleLighting(value) {
+  if (!record(value)) return void 0;
+  const result = {};
+  for (const role of Object.keys(tileflowModelLightingRoles)) {
+    const entry = value[role];
+    if (!record(entry)) continue;
+    const gradient = entry.emissiveHeight;
+    result[role] = {
+      emissiveStrength: bounded(entry.emissiveStrength, 0, 5, 0),
+      ...entry.emissiveVariation === void 0 ? {} : { emissiveVariation: bounded(entry.emissiveVariation, 0, 1, 0) },
+      ...typeof entry.emissiveColor === "string" ? { emissiveColor: entry.emissiveColor } : {},
+      ...typeof entry.color === "string" ? { color: entry.color } : {},
+      ...entry.colorMix === void 0 ? {} : { colorMix: bounded(entry.colorMix, 0, 1, 1) },
+      ...entry.metallic === void 0 ? {} : { metallic: bounded(entry.metallic, 0, 1, 0) },
+      ...entry.roughness === void 0 ? {} : { roughness: bounded(entry.roughness, 0, 1, 1) },
+      ...readRoleColorVariation(entry.colorVariation),
+      emissiveHeight: Array.isArray(gradient) && gradient.length === 5 && gradient.every(
+        (v, i) => typeof v === "number" && Number.isFinite(v) && v <= 1 && v >= (i === 4 ? -1 : 0)
+      ) ? gradient : defaultModelEmissionGradient
+    };
+  }
+  return Object.keys(result).length ? result : void 0;
+}
+function readRoleColorVariation(value) {
+  if (!record(value)) return {};
+  for (const [key, max] of [
+    ["hue", 360],
+    ["saturation", 100],
+    ["lightness", 100]
+  ]) {
+    const range2 = value[key];
+    if (!Array.isArray(range2) || range2.length !== 2 || range2[0] > range2[1] || !range2.every((v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= max))
+      return {};
+  }
+  if (value.space !== void 0 && value.space !== "srgb" && value.space !== "linear") return {};
+  return { colorVariation: value };
+}
+function bounded(value, min, max, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= min && value <= max ? value : fallback;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/buildings-3d-design.ts
 var tileflowBuildingsMetadataKey = "tileflow:buildings";
 var tileflowDefaultBuildings3DDesign = Object.freeze({
@@ -59,7 +165,8 @@ var tileflowDefaultBuildings3DDesign = Object.freeze({
   nightLight: 0,
   windows: false,
   shadows: true,
-  occlusion: true
+  occlusion: true,
+  modelOcclusion: 0.75
 });
 function tileflowBuildingsMetadata(design) {
   return { version: 1, ...design };
@@ -183,26 +290,26 @@ var canonicalFields = {
 };
 var worldAttribution = '<a href="https://tileflow.dev/copyright">\xA9 Tileflow</a> <a href="https://www.openmaptiles.org/">\xA9 OpenMapTiles</a> <a href="https://www.openstreetmap.org/copyright">\xA9 OpenStreetMap</a>';
 function openMapTiles(options = {}) {
-  const layers = { ...canonicalLayers, ...options.layers };
-  const fields = { ...canonicalFields, ...options.fields };
-  if (options.capabilities?.businessCorridor === false) delete layers.businessCorridor;
+  const layers2 = { ...canonicalLayers, ...options.layers };
+  const fields2 = { ...canonicalFields, ...options.fields };
+  if (options.capabilities?.businessCorridor === false) delete layers2.businessCorridor;
   if (options.capabilities?.bathymetry === true) {
-    layers.bathymetry ??= "bathymetry";
-    fields.bathymetryMinDepth ??= "min_depth";
-    fields.bathymetrySortKey ??= "sort_key";
+    layers2.bathymetry ??= "bathymetry";
+    fields2.bathymetryMinDepth ??= "min_depth";
+    fields2.bathymetrySortKey ??= "sort_key";
   } else {
-    delete layers.bathymetry;
-    delete fields.bathymetryMinDepth;
-    delete fields.bathymetrySortKey;
+    delete layers2.bathymetry;
+    delete fields2.bathymetryMinDepth;
+    delete fields2.bathymetrySortKey;
   }
-  if (options.capabilities?.canopy === false) delete layers.canopy;
-  if (options.capabilities?.globalLandcover === false) delete layers.globalLandcover;
-  if (options.capabilities?.tree === false) delete layers.tree;
+  if (options.capabilities?.canopy === false) delete layers2.canopy;
+  if (options.capabilities?.globalLandcover === false) delete layers2.globalLandcover;
+  if (options.capabilities?.tree === false) delete layers2.tree;
   return {
     type: "openmaptiles",
     contractVersion: openMapTilesContractVersion,
-    fields,
-    layers,
+    fields: fields2,
+    layers: layers2,
     semantics: {
       parkLayer: options.semantics?.parkLayer ?? "mixed"
     }
@@ -496,25 +603,25 @@ function inferTileflowDataRequirements(style, options = {}) {
   for (const [index, layer] of (style.layers ?? []).entries()) {
     if (layer.source !== sourceId || typeof layer["source-layer"] !== "string") continue;
     const sourceLayer = layer["source-layer"];
-    const fields = getOrCreate(fieldsByLayer, sourceLayer);
+    const fields2 = getOrCreate(fieldsByLayer, sourceLayer);
     const filter = layer.filter === void 0 ? void 0 : convertFilter(layer.filter);
-    collectFieldAccesses(filter, fields, dynamicAccesses, `layers[${index}].filter`);
+    collectFieldAccesses(filter, fields2, dynamicAccesses, `layers[${index}].filter`);
     for (const key of ["layout", "paint"]) {
-      collectFieldAccesses(layer[key], fields, dynamicAccesses, `layers[${index}].${key}`);
+      collectFieldAccesses(layer[key], fields2, dynamicAccesses, `layers[${index}].${key}`);
     }
   }
   for (const requirement of options.additional ?? []) {
     requirePortableName(requirement.id, "additional source layer");
-    const fields = getOrCreate(fieldsByLayer, requirement.id);
+    const fields2 = getOrCreate(fieldsByLayer, requirement.id);
     for (const field2 of requirement.fields) {
       requirePortableName(field2.name, `additional field on ${requirement.id}`);
-      const existing = fields.get(field2.name);
+      const existing = fields2.get(field2.name);
       if (existing !== void 0 && field2.type !== void 0 && existing !== field2.type) {
         throw new TypeError(
           `Conflicting manual data types for ${requirement.id}.${field2.name}: ${existing} and ${field2.type}.`
         );
       }
-      fields.set(field2.name, field2.type ?? existing);
+      fields2.set(field2.name, field2.type ?? existing);
     }
   }
   return {
@@ -522,8 +629,8 @@ function inferTileflowDataRequirements(style, options = {}) {
     dynamicAccesses: [...dynamicAccesses].sort(compareCodeUnits),
     schemaVersion: 1,
     sourceId,
-    sourceLayers: [...fieldsByLayer].sort(([left], [right]) => compareCodeUnits(left, right)).map(([id2, fields]) => ({
-      fields: [...fields].sort(([left], [right]) => compareCodeUnits(left, right)).map(([name, type]) => ({ name, ...type === void 0 ? {} : { type } })),
+    sourceLayers: [...fieldsByLayer].sort(([left], [right]) => compareCodeUnits(left, right)).map(([id2, fields2]) => ({
+      fields: [...fields2].sort(([left], [right]) => compareCodeUnits(left, right)).map(([name, type]) => ({ name, ...type === void 0 ? {} : { type } })),
       id: id2
     }))
   };
@@ -598,40 +705,40 @@ function validateTileflowDataCompatibility(requirements, contract) {
   }
   return issues;
 }
-function collectFieldAccesses(value, fields, dynamicAccesses, path) {
+function collectFieldAccesses(value, fields2, dynamicAccesses, path) {
   if (Array.isArray(value)) {
     const operator = value[0];
     if (operator === "literal") return;
     if (operator === "get" || operator === "has") {
       const featureProperties = value.length === 2 || isPropertiesExpression(value[2]);
       if (featureProperties) {
-        if (typeof value[1] === "string") fields.set(value[1], fields.get(value[1]));
+        if (typeof value[1] === "string") fields2.set(value[1], fields2.get(value[1]));
         else dynamicAccesses.add(`${path}[1]`);
       }
       if (typeof value[1] !== "string") {
-        collectFieldAccesses(value[1], fields, dynamicAccesses, `${path}[1]`);
+        collectFieldAccesses(value[1], fields2, dynamicAccesses, `${path}[1]`);
       }
       if (!featureProperties) {
-        collectFieldAccesses(value[2], fields, dynamicAccesses, `${path}[2]`);
+        collectFieldAccesses(value[2], fields2, dynamicAccesses, `${path}[2]`);
       }
       for (let index = 3; index < value.length; index += 1) {
-        collectFieldAccesses(value[index], fields, dynamicAccesses, `${path}[${index}]`);
+        collectFieldAccesses(value[index], fields2, dynamicAccesses, `${path}[${index}]`);
       }
       return;
     }
     if (operator === "properties") dynamicAccesses.add(path);
     for (let index = 1; index < value.length; index += 1) {
-      collectFieldAccesses(value[index], fields, dynamicAccesses, `${path}[${index}]`);
+      collectFieldAccesses(value[index], fields2, dynamicAccesses, `${path}[${index}]`);
     }
     return;
   }
   if (!value || typeof value !== "object") return;
-  const record3 = value;
-  if (typeof record3.property === "string" && Array.isArray(record3.stops)) {
-    fields.set(record3.property, fields.get(record3.property));
+  const record4 = value;
+  if (typeof record4.property === "string" && Array.isArray(record4.stops)) {
+    fields2.set(record4.property, fields2.get(record4.property));
   }
-  for (const [key, child] of Object.entries(record3)) {
-    collectFieldAccesses(child, fields, dynamicAccesses, `${path}.${key}`);
+  for (const [key, child] of Object.entries(record4)) {
+    collectFieldAccesses(child, fields2, dynamicAccesses, `${path}.${key}`);
   }
 }
 function isPropertiesExpression(value) {
@@ -1237,20 +1344,20 @@ function applySymbolStyle(layer, style) {
   return applyLayerRange(result, range2);
 }
 function createAreaLayers(base, style) {
-  const layers = [];
+  const layers2 = [];
   if (style.fill && style.fill.visible !== false) {
-    layers.push({
+    layers2.push({
       layer: applyFillStyle({ ...base, type: "fill" }, style.fill),
       phase: "fill"
     });
   }
   if (style.outline && style.outline.visible !== false) {
-    layers.push({
+    layers2.push({
       layer: applyLineStyle({ ...base, id: `${base.id}-outline`, type: "line" }, style.outline),
       phase: "outline"
     });
   }
-  return layers;
+  return layers2;
 }
 function applyCircleStyle(layer, style) {
   const paint = { ...asRecord(layer.paint) };
@@ -1861,21 +1968,21 @@ function compileBuildings(request, context) {
   return contributions;
 }
 function buildingColorExpression(context) {
-  const fields = context.data.schema.fields;
+  const fields2 = context.data.schema.fields;
   const colors = context.colors.buildings;
   return [
     "case",
-    ["==", ["coalesce", ["get", fields.buildingTone], ""], "active"],
+    ["==", ["coalesce", ["get", fields2.buildingTone], ""], "active"],
     colors.active,
-    ["==", ["coalesce", ["get", fields.buildingTone], ""], "destination"],
+    ["==", ["coalesce", ["get", fields2.buildingTone], ""], "destination"],
     colors.destination,
-    ["==", ["coalesce", ["get", fields.buildingTone], ""], "commercial"],
+    ["==", ["coalesce", ["get", fields2.buildingTone], ""], "commercial"],
     colors.commercial,
     // Without a tone, World's use class: housing, shops and offices, public buildings and works
     // each take their theme colour; a shed, a garage or an unknown use the generic one.
     [
       "match",
-      ["coalesce", ["get", fields.class], ""],
+      ["coalesce", ["get", fields2.class], ""],
       "residential",
       colors.residential,
       "commercial",
@@ -1899,7 +2006,7 @@ function businessCorridorVisibilityFilter(context) {
   ];
 }
 function buildingHeightExpression(context) {
-  const fields = context.data.schema.fields;
+  const fields2 = context.data.schema.fields;
   return [
     "max",
     0,
@@ -1907,7 +2014,7 @@ function buildingHeightExpression(context) {
       "to-number",
       [
         "coalesce",
-        ["get", fields.renderHeight],
+        ["get", fields2.renderHeight],
         // V8.14 materializes this fallback in the tile. Keep the defensive
         // value only for malformed or legacy third-party sources.
         5
@@ -1917,11 +2024,11 @@ function buildingHeightExpression(context) {
   ];
 }
 function buildingBaseExpression(context, height) {
-  const fields = context.data.schema.fields;
+  const fields2 = context.data.schema.fields;
   return [
     "max",
     0,
-    ["min", ["to-number", ["coalesce", ["get", fields.renderMinHeight], 0], 0], height]
+    ["min", ["to-number", ["coalesce", ["get", fields2.renderMinHeight], 0], 0], height]
   ];
 }
 
@@ -1976,12 +2083,12 @@ var tileflowRoadConstructionClasses = [
 function isTileflowPathRoadClass(roadClass) {
   return tileflowPathRoadClasses.includes(roadClass);
 }
-function tileflowRoadClassFilter(fields, roadClass) {
+function tileflowRoadClassFilter(fields2, roadClass) {
   if (isTileflowPathRoadClass(roadClass)) {
     return [
       "all",
-      ["match", ["get", fields.class], ["path", ...constructionClasses[roadClass]], true, false],
-      ["match", ["get", fields.subclass], pathSubclasses[roadClass], true, false]
+      ["match", ["get", fields2.class], ["path", ...constructionClasses[roadClass]], true, false],
+      ["match", ["get", fields2.subclass], pathSubclasses[roadClass], true, false]
     ];
   }
   const classes = roadClass === "minor" ? [
@@ -1999,7 +2106,7 @@ function tileflowRoadClassFilter(fields, roadClass) {
     ...compatibleRoadClasses[roadClass] ?? [],
     ...constructionClasses[roadClass]
   ];
-  return ["match", ["get", fields.class], classes, true, false];
+  return ["match", ["get", fields2.class], classes, true, false];
 }
 
 // src/modules/roads/index.ts
@@ -2157,25 +2264,25 @@ function labelNameFields(language, context) {
   return labelFieldExpression(language, context).slice(1).map((entry) => entry[1]);
 }
 function labelFieldExpression(language, context) {
-  const fields = context.data.schema.fields;
+  const fields2 = context.data.schema.fields;
   if (language === "local") {
     return [
       "coalesce",
-      ["get", fields.name],
-      ["get", fields.nameLatin],
-      ["get", fields.nameEnglish]
+      ["get", fields2.name],
+      ["get", fields2.nameLatin],
+      ["get", fields2.nameEnglish]
     ];
   }
   if (language === "auto") {
     return [
       "coalesce",
-      ["get", fields.nameLatin],
-      ["get", fields.name],
-      ["get", fields.nameEnglish]
+      ["get", fields2.nameLatin],
+      ["get", fields2.name],
+      ["get", fields2.nameEnglish]
     ];
   }
-  const requestedField = language === "en" ? fields.nameEnglish : `name:${language}`;
-  return ["coalesce", ["get", requestedField], ["get", fields.nameLatin], ["get", fields.name]];
+  const requestedField = language === "en" ? fields2.nameEnglish : `name:${language}`;
+  return ["coalesce", ["get", requestedField], ["get", fields2.nameLatin], ["get", fields2.name]];
 }
 
 // src/modules/labels/compiler.ts
@@ -2712,8 +2819,8 @@ function classFilter(field2, classes) {
 function aerodromeLabelExpression(detail, language, context) {
   const name = labelFieldExpression(language, context);
   if (detail === "none") return name;
-  const fields = context.data.schema.fields;
-  const code = detail === "all" ? ["coalesce", ["get", fields.iata], ["get", fields.icao], ""] : ["coalesce", ["get", fields.iata], ""];
+  const fields2 = context.data.schema.fields;
+  const code = detail === "all" ? ["coalesce", ["get", fields2.iata], ["get", fields2.icao], ""] : ["coalesce", ["get", fields2.iata], ""];
   return [
     "case",
     ["!=", ["to-string", code], ""],
@@ -2801,8 +2908,8 @@ function placePriority(rankField, base, capitals = false, capitalField = "capita
 function capitalFilter(capitalField) {
   return [">", ["to-number", ["get", capitalField], 0], 0];
 }
-function roadClassesFilter(fields, roadClasses) {
-  return roadClasses.length === 1 ? tileflowRoadClassFilter(fields, roadClasses[0]) : ["any", ...roadClasses.map((roadClass) => tileflowRoadClassFilter(fields, roadClass))];
+function roadClassesFilter(fields2, roadClasses) {
+  return roadClasses.length === 1 ? tileflowRoadClassFilter(fields2, roadClasses[0]) : ["any", ...roadClasses.map((roadClass) => tileflowRoadClassFilter(fields2, roadClass))];
 }
 function symbolContribution(target, localOrder, layer, slot = "symbols", family) {
   return {
@@ -3251,11 +3358,11 @@ function compileLandforms(request, language, context) {
     ];
   });
 }
-function landformFilter(fields, classes) {
-  const classFilter4 = classes.length === 1 ? ["==", ["get", fields.class], classes[0]] : ["match", ["get", fields.class], classes, true, false];
+function landformFilter(fields2, classes) {
+  const classFilter4 = classes.length === 1 ? ["==", ["get", fields2.class], classes[0]] : ["match", ["get", fields2.class], classes, true, false];
   const classZoom = [
     "match",
-    ["get", fields.class],
+    ["get", fields2.class],
     "volcano",
     [">=", ["zoom"], 9],
     "peak",
@@ -3269,10 +3376,10 @@ function landformFilter(fields, classes) {
   return [
     "all",
     ["==", ["geometry-type"], "Point"],
-    ["has", fields.name],
+    ["has", fields2.name],
     classFilter4,
     classZoom,
-    ["<=", ["to-number", ["get", fields.rank], 99], ["step", ["zoom"], 3, 12, 10, 14, 99]]
+    ["<=", ["to-number", ["get", fields2.rank], 99], ["step", ["zoom"], 3, 12, 10, 14, 99]]
   ];
 }
 function landformContribution(target, localOrder, layer) {
@@ -3287,6 +3394,25 @@ function landformContribution(target, localOrder, layer) {
 }
 
 // src/modules/nautical/index.ts
+var tileflowNauticalImageRoles = Object.freeze({
+  aids: Object.freeze({ default: "nautical.aid" }),
+  beacons: Object.freeze({ default: "nautical.beacon" }),
+  buoys: Object.freeze({
+    cardinal: "nautical.buoy.cardinal",
+    default: "nautical.buoy",
+    port: "nautical.buoy.port",
+    starboard: "nautical.buoy.starboard"
+  }),
+  harbours: Object.freeze({ default: "nautical.harbour" }),
+  lighthouses: Object.freeze({ default: "nautical.lighthouse" }),
+  lights: Object.freeze({ default: "nautical.light" }),
+  ports: Object.freeze({ default: "nautical.port" }),
+  wrecks: Object.freeze({ default: "nautical.wreck" })
+});
+var tileflowNauticalNotice = Object.freeze({
+  id: "nautical-not-for-navigation",
+  text: "Not for navigation"
+});
 function nautical(options = {}) {
   return { type: "nautical", ...cloneJson11(options) };
 }
@@ -3332,30 +3458,51 @@ var tileflowBathymetryV1Schema = Object.freeze({
 });
 var tileflowNauticalV1Schema = Object.freeze({
   fields: Object.freeze({
+    category: "category",
     cell: "cell",
     character: "character",
     class: "class",
     color: "color",
+    colorPattern: "color_pattern",
+    country: "country",
     coverage: "coverage",
     depth: "depth",
-    direction: "direction",
     edition: "edition",
+    families: "families",
+    group: "group",
+    heightM: "height_m",
+    label: "label",
     licence: "licence",
+    lit: "lit",
+    minZoom: "min_zoom",
     name: "name",
-    provider: "provider",
+    orientation: "orientation",
+    periodS: "period_s",
+    position: "position",
     provenance: "provenance",
-    quality: "quality",
+    provider: "provider",
     rangeNm: "range_nm",
+    rank: "rank",
+    reference: "reference",
+    restriction: "restriction",
     scale: "scale",
+    sectorEnd: "sector_end",
+    sectorStart: "sector_start",
+    shape: "shape",
+    size: "size",
     subclass: "subclass",
-    update: "update"
+    system: "system",
+    topmark: "topmark",
+    unlocode: "unlocode",
+    update: "update",
+    waterLevel: "water_level"
   }),
   geometryTypes: Object.freeze({
     aids: Object.freeze(["Point"]),
     coverage: Object.freeze(["Polygon"]),
-    hazards: Object.freeze(["Point", "Polygon"]),
+    hazards: Object.freeze(["Point", "LineString", "Polygon"]),
     lights: Object.freeze(["Point"]),
-    navigationAreas: Object.freeze(["Polygon"]),
+    navigationAreas: Object.freeze(["Point", "LineString", "Polygon"]),
     reefs: Object.freeze(["Polygon"]),
     soundings: Object.freeze(["Point"]),
     wrecks: Object.freeze(["Point", "Polygon"])
@@ -3526,490 +3673,832 @@ function cloneJson12(value) {
 }
 
 // src/modules/nautical/compiler.ts
+var { fields, layers } = tileflowNauticalV1Schema;
+var markColours = Object.freeze({
+  amber: "#F2A10A",
+  black: "#1F2328",
+  blue: "#2D6CDF",
+  brown: "#8A5A2E",
+  green: "#1E9E57",
+  grey: "#8C939A",
+  magenta: "#C2398F",
+  orange: "#EF7D1A",
+  pink: "#EE8AB8",
+  red: "#D3313A",
+  violet: "#8456C9",
+  white: "#FFFFFF",
+  yellow: "#F5C518"
+});
+var lightColours = Object.freeze({
+  ...markColours,
+  white: "#F7D046"
+});
+var floatingAidClasses = ["buoy", "light-float", "light-vessel"];
+var fixedAidClasses = ["beacon", "daymark"];
+var portLateralCategories = ["port", "preferred-channel-port", "waterway-left"];
+var starboardLateralCategories = [
+  "preferred-channel-starboard",
+  "starboard",
+  "waterway-right"
+];
+var exposedWaterLevels = ["above-mean-water", "awash", "covers", "dry"];
+var dangerousWreckClasses = ["dangerous", "hull-showing", "mast-showing"];
+var operationalAreaClasses = [
+  "anchor-berth",
+  "anchorage",
+  "dumping-ground",
+  "military",
+  "restricted",
+  "traffic-separation"
+];
+var routeClasses = ["route", "traffic-separation"];
+var cableClasses = ["cable", "cable-area", "pipeline", "pipeline-area"];
+var portSizes = ["large", "medium", "small", "very-small"];
 function compileNautical(request, context) {
   const nauticalSource = context.marine?.nautical;
   if (!nauticalSource || request?.enabled === false) return [];
   const colors = context.colors;
-  const { fields, layers } = tileflowNauticalV1Schema;
+  const ink = colors.hydro.label;
+  const halo = colors.hydro.water;
+  const accent = colors.poi.transport;
   const chartText = {
     ...typographyTextStyle(context.typography.water),
-    color: colors.hydro.label,
-    haloColor: colors.hydro.water,
+    color: ink,
+    haloColor: halo,
     haloWidth: 1.2
   };
-  const config = mergeTileflowDesign(
-    {
-      type: "nautical",
-      enabled: true,
-      soundings: {
-        minZoom: 12,
-        placement: "point",
-        priority: 92,
+  const markText = {
+    ...typographyTextStyle(context.typography.poi),
+    color: ink,
+    haloColor: halo,
+    haloWidth: 1.2,
+    transform: "none"
+  };
+  const images = themedImages(context);
+  const rankPriority = {
+    priority: expression(["coalesce", ["get", fields.rank], 9]),
+    priorityOrder: "lower-first"
+  };
+  const nameFrom = (minZoom) => expression(["step", ["zoom"], "", minZoom, ["coalesce", ["get", fields.name], ""]]);
+  const sideLabel = { anchor: "left", offset: [0.85, 0], optional: true };
+  const belowLabel = { anchor: "top", offset: [0, 0.75], optional: true };
+  const markColour = expression(colourMatch(firstColour(fields.color), markColours, ink));
+  const markStroke = expression(colourMatch(secondColour(fields.color), markColours, ink));
+  const flareColour = expression(
+    colourMatch(firstColour(fields.color), lightColours, lightColours.white)
+  );
+  const iconPaint = { color: markColour, haloColor: ink, haloWidth: 1 };
+  const defaults4 = {
+    type: "nautical",
+    enabled: true,
+    // Coverage cells are square tiles; a faint seamless tint before marks appear avoids a grid.
+    coverage: {
+      fill: {
+        antialias: false,
+        color: ink,
+        maxZoom: 8,
+        opacity: zoom.linear([
+          [0, 0.06],
+          [5, 0.045],
+          [8, 0]
+        ])
+      }
+    },
+    navigationAreas: {
+      fill: {
+        color: accent,
+        minZoom: 7,
+        opacity: expression([
+          "match",
+          ["get", fields.class],
+          "traffic-separation",
+          0.08,
+          ["military", "restricted", "dumping-ground"],
+          0.05,
+          0
+        ])
+      },
+      outline: {
+        color: expression([
+          "match",
+          ["get", fields.class],
+          [...operationalAreaClasses],
+          accent,
+          ink
+        ]),
+        dash: [4, 2],
+        minZoom: 7,
+        opacity: expression([
+          "interpolate",
+          ["linear"],
+          ["zoom"],
+          7,
+          ["match", ["get", fields.class], [...operationalAreaClasses], 0.55, 0],
+          10,
+          ["match", ["get", fields.class], [...operationalAreaClasses], 0.75, 0],
+          12,
+          ["match", ["get", fields.class], [...operationalAreaClasses], 0.85, 0.4]
+        ]),
+        width: zoom.linear([
+          [7, 0.6],
+          [14, 1.2]
+        ])
+      }
+    },
+    reefs: {
+      fill: { color: colors.landcover.sand, minZoom: 6, opacity: 0.32 },
+      outline: { color: ink, dash: [1.5, 1.5], minZoom: 6, opacity: 0.6, width: 0.8 }
+    },
+    cables: {
+      color: accent,
+      dash: [2, 2],
+      minZoom: 8,
+      opacity: zoom.linear([
+        [8, 0.3],
+        [12, 0.6]
+      ]),
+      width: zoom.linear([
+        [8, 0.6],
+        [14, 1]
+      ])
+    },
+    routes: {
+      color: expression([
+        "match",
+        ["get", fields.class],
+        "traffic-separation",
+        accent,
+        ink
+      ]),
+      dash: [5, 3],
+      minZoom: 8,
+      opacity: 0.72,
+      width: zoom.linear([
+        [8, 0.6],
+        [14, 1.3]
+      ])
+    },
+    hazardAreas: {
+      fill: { color: accent, minZoom: 10, opacity: 0.08 },
+      outline: { color: accent, dash: [1, 1], minZoom: 10, opacity: 0.7, width: 0.8 }
+    },
+    wreckAreas: {
+      fill: { color: ink, minZoom: 11, opacity: 0.08 },
+      outline: { color: ink, dash: [2, 1], minZoom: 11, opacity: 0.6, width: 0.75 }
+    },
+    soundings: {
+      minZoom: 12,
+      placement: "point",
+      text: {
+        ...chartText,
+        allowOverlap: false,
+        field: expression(["to-string", ["get", fields.depth]]),
+        optional: false,
+        padding: 5,
+        size: zoom.linear([
+          [12, 9],
+          [16, 11]
+        ]),
+        transform: "none"
+      }
+    },
+    hazards: {
+      minZoom: 8,
+      placement: "point",
+      marker: {
+        color: expression([
+          "match",
+          ["get", fields.class],
+          "offshore-platform",
+          ink,
+          "rgba(0, 0, 0, 0)"
+        ]),
+        radius: zoom.linear([
+          [8, 2.2],
+          [16, 3.6]
+        ]),
+        strokeColor: ink,
+        strokeWidth: 1.1
+      },
+      text: {
+        ...markText,
+        field: expression([
+          "match",
+          ["get", fields.waterLevel],
+          [...exposedWaterLevels],
+          "*",
+          "+"
+        ]),
+        haloWidth: 1,
+        offset: expression([
+          "match",
+          ["get", fields.waterLevel],
+          [...exposedWaterLevels],
+          ["literal", [0, 0.25]],
+          ["literal", [0, 0]]
+        ]),
+        optional: false,
+        padding: 1,
+        size: zoom.linear([
+          [12, 11],
+          [16, 14]
+        ])
+      }
+    },
+    wrecks: {
+      minZoom: 11,
+      placement: "point",
+      ...images.wrecks ? {
+        icon: {
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.wrecks,
+          opacity: expression([
+            "match",
+            ["get", fields.class],
+            [...dangerousWreckClasses],
+            1,
+            0.65
+          ]),
+          size: zoom.linear([
+            [11, 1],
+            [16, 1.4]
+          ])
+        },
+        text: { ...markText, ...sideLabel, field: nameFrom(14), padding: 4, size: 9 }
+      } : {
         text: {
-          ...chartText,
-          allowOverlap: false,
-          field: expression(["to-string", ["get", fields.depth]]),
+          ...markText,
+          color: expression([
+            "match",
+            ["get", fields.class],
+            [...dangerousWreckClasses],
+            accent,
+            ink
+          ]),
+          field: "Wk",
           optional: false,
-          padding: 5,
+          padding: 3,
+          size: 10
+        }
+      }
+    },
+    harbours: {
+      minZoom: 11,
+      placement: "point",
+      ...images.harbours ? {
+        icon: {
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.harbours,
           size: zoom.linear([
-            [12, 9],
-            [16, 11]
+            [11, 0.9],
+            [16, 1.3]
           ])
         }
+      } : {
+        marker: {
+          color: ink,
+          radius: zoom.linear([
+            [11, 2.2],
+            [16, 3.6]
+          ]),
+          strokeColor: halo,
+          strokeWidth: 1
+        }
       },
-      aids: {
-        minZoom: 10,
-        placement: "point",
-        priority: 98,
+      text: { ...markText, ...belowLabel, field: nameFrom(12), padding: 4, size: 10 }
+    },
+    aids: {
+      minZoom: 11,
+      placement: "point",
+      ...rankPriority,
+      ...images.aids ? {
+        icon: {
+          ...iconPaint,
+          image: images.aids,
+          size: zoom.linear([
+            [11, 0.8],
+            [16, 1.2]
+          ])
+        }
+      } : {
         marker: {
-          color: colors.hydro.water,
+          color: halo,
           radius: zoom.linear([
-            [10, 2.6],
-            [16, 4.2]
+            [11, 1.8],
+            [16, 3]
           ]),
-          strokeColor: colors.hydro.label,
-          strokeWidth: 1.2
-        },
-        text: {
-          ...chartText,
-          field: expression([
-            "coalesce",
-            ["get", fields.name],
-            ["get", fields.subclass],
-            ["get", fields.class]
+          strokeColor: ink,
+          strokeWidth: 1
+        }
+      },
+      text: { ...markText, ...sideLabel, field: nameFrom(15), padding: 3, size: 9 }
+    },
+    beacons: {
+      minZoom: 11,
+      placement: "point",
+      ...rankPriority,
+      ...images.beacons ? {
+        icon: {
+          ...iconPaint,
+          image: images.beacons,
+          size: zoom.linear([
+            [11, 0.8],
+            [16, 1.2]
+          ])
+        }
+      } : {
+        marker: {
+          color: markColour,
+          radius: zoom.linear([
+            [11, 1.8],
+            [16, 3.4]
           ]),
-          offset: [0, 1.1],
-          optional: true,
-          padding: 4,
-          size: 10
+          strokeColor: markStroke,
+          strokeWidth: 1
         }
       },
-      lighthouses: {
-        minZoom: 10,
-        placement: "point",
-        priority: 99,
+      text: { ...markText, ...sideLabel, field: nameFrom(14), padding: 3, size: 9 }
+    },
+    lights: {
+      minZoom: 6,
+      placement: "point",
+      ...rankPriority,
+      ...images.lights ? {
+        icon: {
+          allowOverlap: true,
+          color: flareColour,
+          haloColor: halo,
+          haloWidth: 0.5,
+          ignorePlacement: true,
+          image: images.lights,
+          opacity: 0.9,
+          size: byClassAndZoom([
+            [6, 0.9, 0.65],
+            [14, 1.6, 1.15]
+          ])
+        }
+      } : {
         marker: {
-          color: colors.hydro.water,
+          color: flareColour,
+          opacity: 0.55,
+          radius: byClassAndZoom([
+            [6, 3.2, 1.8],
+            [14, 7, 4.5]
+          ])
+        }
+      },
+      text: {
+        ...markText,
+        ...sideLabel,
+        field: expression([
+          "step",
+          ["zoom"],
+          "",
+          10,
+          [
+            "case",
+            ["==", ["get", fields.class], "major"],
+            ["coalesce", ["get", fields.label], ""],
+            ""
+          ],
+          13,
+          ["coalesce", ["get", fields.label], ""]
+        ]),
+        padding: 3,
+        size: zoom.linear([
+          [10, 9],
+          [16, 10.5]
+        ])
+      }
+    },
+    buoys: {
+      minZoom: 8,
+      placement: "point",
+      ...rankPriority,
+      ...images.buoys ? {
+        icon: {
+          ...iconPaint,
+          // Dense harbours thin out by rank at low zooms instead of piling up.
+          image: images.buoys,
+          padding: 1,
+          size: zoom.linear([
+            [11, 1],
+            [16, 1.5]
+          ])
+        }
+      } : {
+        marker: {
+          color: markColour,
           radius: zoom.linear([
-            [10, 3],
+            [8, 2.4],
             [16, 4.6]
           ]),
-          strokeColor: colors.hydro.label,
+          strokeColor: markStroke,
           strokeWidth: 1.4
-        },
-        text: {
-          ...chartText,
-          field: expression([
-            "case",
-            ["has", fields.name],
-            ["to-string", ["get", fields.name]],
-            "Lighthouse"
-          ]),
-          offset: [0, 1.2],
-          optional: true,
-          padding: 4,
-          size: 10
         }
       },
-      lights: {
-        minZoom: 11,
-        placement: "point",
-        priority: 96,
+      text: { ...markText, ...sideLabel, field: nameFrom(14), padding: 3, size: 9 }
+    },
+    lighthouses: {
+      minZoom: 8,
+      placement: "point",
+      ...rankPriority,
+      ...images.lighthouses ? {
+        icon: {
+          allowOverlap: true,
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.lighthouses,
+          size: zoom.linear([
+            [8, 1],
+            [16, 1.6]
+          ])
+        }
+      } : {
         marker: {
-          color: colors.poi.transport,
-          opacity: 0.24,
+          color: ink,
           radius: zoom.linear([
-            [11, 4],
-            [16, 7]
+            [8, 2.6],
+            [16, 4.8]
           ]),
-          strokeColor: colors.poi.transport,
-          strokeWidth: 1
-        },
-        text: {
-          ...chartText,
-          color: colors.poi.transport,
-          field: lightLabel(fields),
-          offset: [0, 1.25],
-          optional: true,
-          padding: 5,
-          size: 9
+          strokeColor: halo,
+          strokeWidth: 1.2
+        }
+      },
+      text: {
+        ...markText,
+        ...belowLabel,
+        field: nameFrom(10),
+        padding: 4,
+        size: zoom.linear([
+          [10, 9.5],
+          [16, 11.5]
+        ])
+      }
+    },
+    ports: {
+      minZoom: 3,
+      placement: "point",
+      ...rankPriority,
+      ...images.ports ? {
+        icon: {
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.ports,
+          size: byPortSizeAndZoom([
+            [3, [1.05, 0.95, 0.85, 0.75]],
+            [12, [1.45, 1.35, 1.25, 1.15]]
+          ])
+        }
+      } : {
+        marker: {
+          color: ink,
+          radius: byPortSizeAndZoom([
+            [3, [3.2, 2.8, 2.4, 2]],
+            [12, [5, 4.5, 4, 3.5]]
+          ]),
+          strokeColor: halo,
+          strokeWidth: 1.2
         }
       },
+      text: {
+        ...markText,
+        ...belowLabel,
+        field: expression(["coalesce", ["get", fields.name], ""]),
+        padding: 6,
+        size: byPortSizeAndZoom([
+          [3, [11, 10, 9.5, 9]],
+          [12, [12.5, 11.5, 11, 10.5]]
+        ])
+      }
+    },
+    labels: {
+      coverage: {
+        maxZoom: 9,
+        minZoom: 4,
+        placement: "point",
+        visible: false,
+        text: { ...chartText, field: expression(["get", fields.provider]), size: 8 }
+      },
       hazards: {
         minZoom: 11,
         placement: "point",
-        priority: 95,
-        text: {
-          ...chartText,
-          color: colors.poi.transport,
-          field: nameAndDepthWithPrefix(fields.name, fields.depth, "X"),
-          optional: false,
-          padding: 5,
-          size: 12
-        }
+        text: { ...markText, color: accent, field: expression(["get", fields.name]) }
       },
-      wrecks: {
+      navigationAreas: {
         minZoom: 11,
         placement: "point",
-        priority: 94,
         text: {
-          ...chartText,
-          field: nameAndDepthWithPrefix(fields.name, fields.depth, "Wrk"),
-          optional: false,
-          padding: 5,
-          size: 9
+          ...markText,
+          color: expression([
+            "match",
+            ["get", fields.class],
+            [...operationalAreaClasses],
+            accent,
+            ink
+          ]),
+          field: expression(["get", fields.name]),
+          optional: true,
+          padding: 8,
+          size: 9.5
         }
       },
       reefs: {
-        fill: { color: colors.landcover.sand, minZoom: 7, opacity: 0.34 },
-        outline: {
-          color: colors.hydro.label,
-          dash: [1.5, 1.5],
-          minZoom: 7,
-          opacity: 0.62,
-          width: 0.8
-        }
-      },
-      hazardAreas: {
-        fill: { color: colors.poi.transport, minZoom: 11, opacity: 0.1 },
-        outline: {
-          color: colors.poi.transport,
-          dash: [1, 1],
-          minZoom: 11,
-          opacity: 0.72,
-          width: 0.8
-        }
-      },
-      wreckAreas: {
-        fill: { color: colors.hydro.label, minZoom: 11, opacity: 0.08 },
-        outline: {
-          color: colors.hydro.label,
-          dash: [2, 1],
-          minZoom: 11,
-          opacity: 0.62,
-          width: 0.75
-        }
-      },
-      navigationAreas: {
-        fill: { color: colors.poi.transport, minZoom: 8, opacity: 0.06 },
-        outline: {
-          color: colors.poi.transport,
-          dash: [4, 2],
-          minZoom: 8,
-          opacity: 0.62,
-          width: 0.8
-        }
+        minZoom: 11,
+        placement: "point",
+        text: { ...chartText, field: expression(["get", fields.name]), size: 9 }
       },
-      coverage: {
-        outline: {
-          color: colors.poi.transport,
-          dash: [2, 3],
-          maxZoom: 9,
-          minZoom: 4,
-          opacity: 0.34,
-          width: 0.6
-        }
-      },
-      labels: {
-        coverage: {
-          maxZoom: 9,
-          minZoom: 4,
-          placement: "point",
-          priority: 70,
-          text: {
-            ...chartText,
-            color: colors.poi.transport,
-            field: expression(["coalesce", ["get", fields.name], ["get", fields.provider]]),
-            optional: true,
-            padding: 12,
-            size: 8
-          }
-        },
-        hazards: {
-          minZoom: 11,
-          placement: "point",
-          priority: 93,
-          text: {
-            ...chartText,
-            color: colors.poi.transport,
-            field: nameAndDepthWithPrefix(fields.name, fields.depth, "X"),
-            optional: true,
-            padding: 6,
-            size: 9
-          }
-        },
-        navigationAreas: {
-          minZoom: 10,
-          placement: "point",
-          priority: 78,
-          text: {
-            ...chartText,
-            color: colors.poi.transport,
-            field: expression(["coalesce", ["get", fields.name], ["get", fields.class]]),
-            optional: true,
-            padding: 8,
-            size: 9
-          }
-        },
-        reefs: {
-          minZoom: 12,
-          placement: "point",
-          priority: 89,
-          text: {
-            ...chartText,
-            field: nameAndDepthWithPrefix(fields.name, fields.depth, "Reef"),
-            optional: true,
-            padding: 7,
-            size: 9
-          }
-        },
-        wrecks: {
-          minZoom: 11,
-          placement: "point",
-          priority: 92,
-          text: {
-            ...chartText,
-            field: nameAndDepthWithPrefix(fields.name, fields.depth, "Wrk"),
-            optional: true,
-            padding: 6,
-            size: 9
-          }
-        }
+      wrecks: {
+        minZoom: 12,
+        placement: "point",
+        text: { ...markText, field: expression(["get", fields.name]), size: 9 }
       }
-    },
+    }
+  };
+  const config = mergeTileflowDesign(
+    defaults4,
     request
   );
   const source = nauticalSource.sourceId;
   const contributions = [];
-  appendAreaFeature(contributions, {
+  const add2 = (options) => appendNauticalLayer(contributions, { ...options, source });
+  add2({
+    // Only coverage that speaks for every family; lists of lights alone would double the tint.
+    filter: ["all", polygons, ["in", layers.aids, ["coalesce", ["get", fields.families], ""]]],
     id: "tileflow-nautical-coverage",
     localOrder: 380,
-    source,
     sourceLayer: layers.coverage,
     style: config.coverage,
     target: "nautical.coverage"
   });
-  appendAreaFeature(contributions, {
+  add2({
+    filter: polygons,
     id: "tileflow-nautical-navigation-areas",
     localOrder: 390,
-    source,
     sourceLayer: layers.navigationAreas,
     style: config.navigationAreas,
     target: "nautical.navigationAreas"
   });
-  appendAreaFeature(contributions, {
+  add2({
+    filter: polygons,
     id: "tileflow-nautical-reefs",
     localOrder: 400,
-    source,
     sourceLayer: layers.reefs,
     style: config.reefs,
     target: "nautical.reefs"
   });
-  appendAreaFeature(contributions, {
+  add2({
+    filter: linesOf(cableClasses),
+    id: "tileflow-nautical-cables",
+    line: true,
+    localOrder: 404,
+    sourceLayer: layers.navigationAreas,
+    style: config.cables,
+    target: "nautical.cables"
+  });
+  add2({
+    filter: linesOf(routeClasses),
+    id: "tileflow-nautical-routes",
+    line: true,
+    localOrder: 406,
+    sourceLayer: layers.navigationAreas,
+    style: config.routes,
+    target: "nautical.routes"
+  });
+  add2({
+    filter: polygons,
     id: "tileflow-nautical-hazard-areas",
     localOrder: 410,
-    source,
+    outlineFilter: ["match", ["geometry-type"], ["LineString", "Polygon"], true, false],
     sourceLayer: layers.hazards,
     style: config.hazardAreas,
     target: "nautical.hazardAreas"
   });
-  appendAreaFeature(contributions, {
+  add2({
+    filter: polygons,
     id: "tileflow-nautical-wreck-areas",
     localOrder: 420,
-    source,
     sourceLayer: layers.wrecks,
     style: config.wreckAreas,
     target: "nautical.wreckAreas"
   });
-  appendPolygonLabel(contributions, {
-    featureFilter: ["any", ["has", fields.name], ["has", fields.provider]],
-    id: "tileflow-nautical-coverage-labels",
-    localOrder: 1060,
-    source,
-    sourceLayer: layers.coverage,
-    style: config.labels?.coverage,
-    target: "nautical.labels.coverage"
-  });
-  appendPolygonLabel(contributions, {
-    featureFilter: ["any", ["has", fields.name], ["has", fields.class]],
-    id: "tileflow-nautical-navigation-area-labels",
-    localOrder: 1070,
-    source,
-    sourceLayer: layers.navigationAreas,
-    style: config.labels?.navigationAreas,
-    target: "nautical.labels.navigationAreas"
-  });
-  appendPolygonLabel(contributions, {
-    id: "tileflow-nautical-reef-labels",
-    localOrder: 1080,
-    source,
-    sourceLayer: layers.reefs,
-    style: config.labels?.reefs,
-    target: "nautical.labels.reefs"
+  for (const [key, id2, sourceLayer, localOrder] of [
+    ["coverage", "tileflow-nautical-coverage-labels", layers.coverage, 560],
+    ["navigationAreas", "tileflow-nautical-navigation-area-labels", layers.navigationAreas, 562],
+    ["reefs", "tileflow-nautical-reef-labels", layers.reefs, 564],
+    ["hazards", "tileflow-nautical-hazard-area-labels", layers.hazards, 566],
+    ["wrecks", "tileflow-nautical-wreck-area-labels", layers.wrecks, 568]
+  ]) {
+    add2({
+      filter: ["all", polygons, ["has", key === "coverage" ? fields.provider : fields.name]],
+      id: id2,
+      localOrder,
+      sourceLayer,
+      style: config.labels?.[key],
+      target: `nautical.labels.${key}`
+    });
+  }
+  add2({
+    filter: ["all", points, ["has", fields.depth]],
+    id: "tileflow-nautical-soundings",
+    localOrder: 570,
+    sourceLayer: layers.soundings,
+    style: config.soundings,
+    target: "nautical.soundings"
   });
-  appendPolygonLabel(contributions, {
-    id: "tileflow-nautical-hazard-area-labels",
-    localOrder: 1090,
-    source,
+  add2({
+    filter: points,
+    id: "tileflow-nautical-hazards",
+    localOrder: 574,
+    markerFilter: ["!=", ["get", fields.class], "rock"],
     sourceLayer: layers.hazards,
-    style: config.labels?.hazards,
-    target: "nautical.labels.hazards"
+    style: config.hazards,
+    symbolFilter: ["==", ["get", fields.class], "rock"],
+    target: "nautical.hazards"
   });
-  appendPolygonLabel(contributions, {
-    id: "tileflow-nautical-wreck-area-labels",
-    localOrder: 1095,
-    source,
+  add2({
+    filter: points,
+    id: "tileflow-nautical-wrecks",
+    localOrder: 578,
     sourceLayer: layers.wrecks,
-    style: config.labels?.wrecks,
-    target: "nautical.labels.wrecks"
+    style: config.wrecks,
+    target: "nautical.wrecks"
   });
-  appendPointFeature(contributions, {
-    id: "tileflow-nautical-soundings",
-    localOrder: 1100,
-    source,
-    sourceLayer: layers.soundings,
-    style: config.soundings,
-    target: "nautical.soundings",
-    filter: ["all", ["==", ["geometry-type"], "Point"], ["has", fields.depth]]
+  add2({
+    filter: ["all", points, ["==", ["get", fields.class], "harbour"]],
+    id: "tileflow-nautical-harbours",
+    localOrder: 582,
+    sourceLayer: layers.navigationAreas,
+    style: config.harbours,
+    target: "nautical.harbours"
   });
-  appendPointFeature(contributions, {
+  add2({
+    filter: [
+      "all",
+      points,
+      [
+        "match",
+        ["get", fields.class],
+        [...floatingAidClasses, ...fixedAidClasses, "lighthouse"],
+        false,
+        true
+      ]
+    ],
     id: "tileflow-nautical-aids",
-    localOrder: 1110,
-    source,
+    localOrder: 586,
     sourceLayer: layers.aids,
     style: config.aids,
-    target: "nautical.aids",
-    filter: [
-      "all",
-      ["==", ["geometry-type"], "Point"],
-      ["!=", ["get", fields.class], "lighthouse"]
-    ]
+    target: "nautical.aids"
   });
-  appendPointFeature(contributions, {
-    id: "tileflow-nautical-lighthouses",
-    localOrder: 1115,
-    source,
+  add2({
+    filter: ["all", points, ["match", ["get", fields.class], [...fixedAidClasses], true, false]],
+    id: "tileflow-nautical-beacons",
+    localOrder: 590,
     sourceLayer: layers.aids,
-    style: config.lighthouses,
-    target: "nautical.lighthouses",
-    filter: [
-      "all",
-      ["==", ["geometry-type"], "Point"],
-      ["==", ["get", fields.class], "lighthouse"]
-    ]
+    style: config.beacons,
+    target: "nautical.beacons"
   });
-  appendPointFeature(contributions, {
+  add2({
+    filter: points,
     id: "tileflow-nautical-lights",
-    localOrder: 1120,
-    source,
+    localOrder: 594,
     sourceLayer: layers.lights,
     style: config.lights,
-    target: "nautical.lights",
-    filter: ["==", ["geometry-type"], "Point"]
+    target: "nautical.lights"
   });
-  appendPointFeature(contributions, {
-    id: "tileflow-nautical-hazards",
-    localOrder: 1130,
-    source,
-    sourceLayer: layers.hazards,
-    style: config.hazards,
-    target: "nautical.hazards",
-    filter: ["==", ["geometry-type"], "Point"]
+  add2({
+    filter: ["all", points, ["match", ["get", fields.class], [...floatingAidClasses], true, false]],
+    id: "tileflow-nautical-buoys",
+    localOrder: 598,
+    sourceLayer: layers.aids,
+    style: config.buoys,
+    target: "nautical.buoys"
   });
-  appendPointFeature(contributions, {
-    id: "tileflow-nautical-wrecks",
-    localOrder: 1140,
-    source,
-    sourceLayer: layers.wrecks,
-    style: config.wrecks,
-    target: "nautical.wrecks",
-    filter: ["==", ["geometry-type"], "Point"]
+  add2({
+    filter: ["all", points, ["==", ["get", fields.class], "lighthouse"]],
+    id: "tileflow-nautical-lighthouses",
+    localOrder: 602,
+    sourceLayer: layers.aids,
+    style: config.lighthouses,
+    target: "nautical.lighthouses"
+  });
+  add2({
+    filter: ["all", points, ["==", ["get", fields.class], "port"]],
+    id: "tileflow-nautical-ports",
+    localOrder: 606,
+    sourceLayer: layers.navigationAreas,
+    style: config.ports,
+    target: "nautical.ports"
   });
   return contributions;
 }
-function appendPolygonLabel(contributions, options) {
-  const style = options.style;
-  if (!style || style.visible === false || (!style.text || style.text.visible === false) && (!style.icon || style.icon.visible === false)) {
-    return;
-  }
-  contributions.push(
-    nauticalContribution(
-      options.target,
-      options.localOrder,
-      applySymbolStyle(
-        {
-          id: options.id,
-          type: "symbol",
-          source: options.source,
-          "source-layer": options.sourceLayer,
-          filter: options.featureFilter ? ["all", ["==", ["geometry-type"], "Polygon"], options.featureFilter] : ["==", ["geometry-type"], "Polygon"]
-        },
-        style
-      ),
-      "symbols"
-    )
-  );
+var points = ["==", ["geometry-type"], "Point"];
+var polygons = ["==", ["geometry-type"], "Polygon"];
+function linesOf(classes) {
+  return [
+    "all",
+    ["==", ["geometry-type"], "LineString"],
+    ["match", ["get", fields.class], [...classes], true, false]
+  ];
 }
-function appendAreaFeature(contributions, options) {
-  if (!options.style) return;
-  for (const area of createAreaLayers(
-    {
-      id: options.id,
-      type: "fill",
-      source: options.source,
-      "source-layer": options.sourceLayer,
-      filter: ["==", ["geometry-type"], "Polygon"]
-    },
-    options.style
-  )) {
+var fromFeatureMinZoom = [">=", ["zoom"], ["to-number", ["get", fields.minZoom], 0]];
+function appendNauticalLayer(contributions, options) {
+  const style = options.style;
+  if (!style) return;
+  const base = (id2, type, filter) => ({
+    id: id2,
+    type,
+    source: options.source,
+    "source-layer": options.sourceLayer,
+    filter: ["all", filter, fromFeatureMinZoom]
+  });
+  if (options.line) {
+    const line = style;
+    if (line.visible === false) return;
     contributions.push(
       nauticalContribution(
-        `${options.target}.${area.phase}`,
-        options.localOrder + (area.phase === "fill" ? 0 : 1),
-        area.layer,
+        options.target,
+        options.localOrder,
+        applyLineStyle(base(options.id, "line", options.filter), line),
         "hydro"
       )
     );
+    return;
   }
-}
-function appendPointFeature(contributions, options) {
-  const style = options.style;
-  if (!style || style.visible === false) return;
-  const symbolStyle2 = withoutMarker(style);
-  const base = {
-    id: options.id,
-    type: "symbol",
-    source: options.source,
-    "source-layer": options.sourceLayer,
-    filter: options.filter
-  };
-  if (style.marker && style.marker.visible !== false) {
+  if ("fill" in style || "outline" in style) {
+    const area = style;
+    if (area.fill && area.fill.visible !== false) {
+      contributions.push(
+        nauticalContribution(
+          `${options.target}.fill`,
+          options.localOrder,
+          applyFillStyle(base(options.id, "fill", options.filter), area.fill),
+          "hydro"
+        )
+      );
+    }
+    if (area.outline && area.outline.visible !== false) {
+      contributions.push(
+        nauticalContribution(
+          `${options.target}.outline`,
+          options.localOrder + 1,
+          applyLineStyle(
+            base(`${options.id}-outline`, "line", options.outlineFilter ?? options.filter),
+            area.outline
+          ),
+          "hydro"
+        )
+      );
+    }
+    return;
+  }
+  const point = style;
+  if (point.visible === false) return;
+  const isLabel = options.target.startsWith("nautical.labels.");
+  if (!isLabel && point.marker && point.marker.visible !== false) {
     contributions.push(
       nauticalContribution(
         `${options.target}.marker`,
         options.localOrder,
         applyCircleStyle(
-          { ...base, id: `${options.id}-marker`, type: "circle" },
+          base(
+            `${options.id}-marker`,
+            "circle",
+            options.markerFilter ? ["all", options.filter, options.markerFilter] : options.filter
+          ),
           mergeTileflowDesign(
             {
-              ...style.maxZoom === void 0 ? {} : { maxZoom: style.maxZoom },
-              ...style.minZoom === void 0 ? {} : { minZoom: style.minZoom }
+              ...point.maxZoom === void 0 ? {} : { maxZoom: point.maxZoom },
+              ...point.minZoom === void 0 ? {} : { minZoom: point.minZoom }
             },
-            style.marker
+            point.marker
           )
         ),
         "symbols"
       )
     );
   }
-  const hasText = Boolean(style.text && style.text.visible !== false);
-  const hasIcon = Boolean(style.icon && style.icon.visible !== false);
+  const hasText = Boolean(point.text && point.text.visible !== false);
+  const hasIcon = Boolean(point.icon && point.icon.visible !== false);
   if (!hasText && !hasIcon) return;
   contributions.push(
     nauticalContribution(
-      `${options.target}.symbol`,
-      options.localOrder + 1,
-      applySymbolStyle(base, symbolStyle2),
+      isLabel ? options.target : `${options.target}.symbol`,
+      options.localOrder + (isLabel ? 0 : 1),
+      applySymbolStyle(
+        base(
+          options.id,
+          "symbol",
+          options.symbolFilter ? ["all", options.filter, options.symbolFilter] : options.filter
+        ),
+        withoutMarker(point)
+      ),
       "symbols"
     )
   );
@@ -4022,31 +4511,107 @@ function withoutMarker(style) {
 function nauticalContribution(target, localOrder, layer, slot) {
   return { kind: "layer", layer, localOrder, owner: "nautical", slot, target };
 }
-function nameAndDepthWithPrefix(nameField, depthField, prefix) {
+function themedImages(context) {
+  const roles = tileflowNauticalImageRoles;
+  const images = {};
+  for (const group of Object.keys(roles)) {
+    const image = context.images[roles[group].default];
+    if (image) images[group] = image;
+  }
+  const buoy = images.buoys;
+  if (typeof buoy === "string") {
+    const port = context.images[roles.buoys.port] ?? buoy;
+    const starboard = context.images[roles.buoys.starboard] ?? buoy;
+    const cardinal = context.images[roles.buoys.cardinal] ?? buoy;
+    images.buoys = expression([
+      "case",
+      ["==", ["get", fields.subclass], "cardinal"],
+      cardinal,
+      [
+        "match",
+        ["get", fields.category],
+        [...portLateralCategories],
+        port,
+        [...starboardLateralCategories],
+        starboard,
+        buoy
+      ]
+    ]);
+  }
+  return images;
+}
+function firstColour(field2) {
+  return [
+    "let",
+    "nauticalColours",
+    ["to-string", ["coalesce", ["get", field2], ""]],
+    leadingName(["var", "nauticalColours"])
+  ];
+}
+function secondColour(field2) {
+  return [
+    "let",
+    "nauticalColours",
+    ["to-string", ["coalesce", ["get", field2], ""]],
+    [
+      "let",
+      "nauticalComma",
+      ["index-of", ",", ["var", "nauticalColours"]],
+      [
+        "case",
+        ["<", ["var", "nauticalComma"], 0],
+        "",
+        [
+          "let",
+          "nauticalRest",
+          ["slice", ["var", "nauticalColours"], ["+", ["var", "nauticalComma"], 1]],
+          leadingName(["var", "nauticalRest"])
+        ]
+      ]
+    ]
+  ];
+}
+function leadingName(list) {
+  return [
+    "let",
+    "nauticalEnd",
+    ["index-of", ",", list],
+    ["case", ["<", ["var", "nauticalEnd"], 0], list, ["slice", list, 0, ["var", "nauticalEnd"]]]
+  ];
+}
+function colourMatch(name, palette, fallback) {
+  return [
+    "match",
+    name,
+    ...Object.entries(palette).flatMap(([colourName, value]) => [colourName, value]),
+    fallback
+  ];
+}
+function byClassAndZoom(stops) {
   return expression([
-    "concat",
-    prefix,
-    ["case", ["has", nameField], ["concat", " ", ["to-string", ["get", nameField]]], ""],
-    ["case", ["has", depthField], ["concat", " ", ["to-string", ["get", depthField]], "m"], ""]
+    "interpolate",
+    ["linear"],
+    ["zoom"],
+    ...stops.flatMap(([stop, major, minor]) => [
+      stop,
+      ["match", ["get", fields.class], "major", major, minor]
+    ])
   ]);
 }
-function lightLabel(fields) {
+function byPortSizeAndZoom(stops) {
   return expression([
-    "concat",
-    ["case", ["has", fields.character], ["to-string", ["get", fields.character]], "Lt"],
-    [
-      "case",
-      ["has", fields.rangeNm],
-      ["concat", " ", ["to-string", ["get", fields.rangeNm]], "M"],
-      ""
-    ],
-    [
-      "case",
-      ["has", fields.direction],
-      ["concat", " ", ["to-string", ["get", fields.direction]], "\xB0"],
-      ""
-    ],
-    ["case", ["has", fields.name], ["concat", " ", ["to-string", ["get", fields.name]]], ""]
+    "interpolate",
+    ["linear"],
+    ["zoom"],
+    ...stops.flatMap(([stop, values]) => [
+      stop,
+      [
+        "match",
+        ["get", fields.size],
+        ...portSizes.flatMap((size, index) => [size, values[index]]),
+        values[3]
+      ]
+    ])
   ]);
 }
 
@@ -4211,12 +4776,12 @@ function mergePoiCategoryLayers(entries, options) {
   };
   for (const part of ["layout", "paint"]) {
     const records = entries.map(({ layer }) => asRecord2(layer[part]));
-    const properties2 = [...new Set(records.flatMap((record3) => Object.keys(record3)))].sort();
+    const properties2 = [...new Set(records.flatMap((record4) => Object.keys(record4)))].sort();
     const merged = {};
     for (const property of properties2) {
       const fallback = Object.hasOwn(varying, property) ? varying[property] : tileflowPoiLayerPropertyDefaults[property];
       const values = records.map(
-        (record3) => Object.hasOwn(record3, property) ? record3[property] : fallback
+        (record4) => Object.hasOwn(record4, property) ? record4[property] : fallback
       );
       if (values.every((value) => sameJson(value, values[0]))) {
         if (values[0] !== void 0) merged[property] = values[0];
@@ -4575,11 +5140,11 @@ function compileCategory(category, request, semantics, context, language, select
   return parts;
 }
 function createPoiSelection(semantics, context, language) {
-  const { fields } = context.data.schema;
+  const { fields: fields2 } = context.data.schema;
   const shown = /* @__PURE__ */ new Map();
   const iconOnlyTypes = [...new Set(semantics.placement.iconOnlyTypes)];
-  const iconOnly = () => iconOnlyTypes.length ? ["match", ["get", fields.poiType], iconOnlyTypes, true, false] : ["literal", false];
-  const inCategories = (categories) => categories.length === 1 ? ["==", ["get", fields.poiCategory], categories[0]] : ["match", ["get", fields.poiCategory], [...categories], true, false];
+  const iconOnly = () => iconOnlyTypes.length ? ["match", ["get", fields2.poiType], iconOnlyTypes, true, false] : ["literal", false];
+  const inCategories = (categories) => categories.length === 1 ? ["==", ["get", fields2.poiCategory], categories[0]] : ["match", ["get", fields2.poiCategory], [...categories], true, false];
   const named = () => [
     "any",
     ...labelNameFields(language, context).map((field2) => ["has", field2])
@@ -4592,22 +5157,22 @@ function createPoiSelection(semantics, context, language) {
       if (!iconOnlyTypes.length || field2 === void 0) return field2;
       return expression([
         "match",
-        ["get", fields.poiType],
+        ["get", fields2.poiType],
         iconOnlyTypes,
         "",
         fieldValue(field2)
       ]);
     },
     filter(categories, representation) {
-      const filterRank = numericPoiField(fields.poiFilterRank, 6);
-      const sizeRank = numericPoiField(fields.poiSizeRank, 17);
+      const filterRank = numericPoiField(fields2.poiFilterRank, 6);
+      const sizeRank = numericPoiField(fields2.poiSizeRank, 17);
       const result = [
         "all",
         inCategories(categories),
-        ["has", fields.poiFilterRank],
+        ["has", fields2.poiFilterRank],
         [">=", filterRank, 0],
         ["<=", filterRank, poiRankThreshold(semantics.density)],
-        ["has", fields.poiSizeRank],
+        ["has", fields2.poiSizeRank],
         [">=", sizeRank, 0],
         ["<=", sizeRank, 16]
       ];
@@ -4830,9 +5395,19 @@ var visualNumberProperties = /* @__PURE__ */ new Set([
   "angle",
   "base",
   "blur",
+  "brightnessScale",
   "crownScale",
   "dash",
   "exaggeration",
+  "emissiveStrength",
+  "emissiveVariation",
+  "emissiveHeight",
+  "colorMix",
+  "metallic",
+  "roughness",
+  "hue",
+  "saturation",
+  "lightness",
   "fadeDuration",
   "gapWidth",
   "haloBlur",
@@ -4846,6 +5421,7 @@ var visualNumberProperties = /* @__PURE__ */ new Set([
   "maxAngle",
   "maxWidth",
   "miterLimit",
+  "modelOcclusion",
   "offset",
   "opacity",
   "padding",
@@ -5694,13 +6270,13 @@ function assertThemeIdentity(theme) {
   }
 }
 function assertThemeDocument(theme) {
-  const record3 = assertPlainThemeRecord(theme, "theme");
-  assertExactThemeKeys(record3, "theme", themeDocumentKeys);
-  assertRequiredThemeKeys(record3, "theme", themeDocumentKeys);
+  const record4 = assertPlainThemeRecord(theme, "theme");
+  assertExactThemeKeys(record4, "theme", themeDocumentKeys);
+  assertRequiredThemeKeys(record4, "theme", themeDocumentKeys);
   assertThemeIdentity(theme);
-  assertThemeTokens(record3.tokens, "theme.tokens", true);
-  assertThemeTypography(record3.typography, "theme.typography");
-  assertThemeLighting(record3.lighting, "theme.lighting");
+  assertThemeTokens(record4.tokens, "theme.tokens", true);
+  assertThemeTypography(record4.typography, "theme.typography");
+  assertThemeLighting(record4.lighting, "theme.lighting");
   cloneJson14(theme);
 }
 function assertThemeTokens(value, path, complete) {
@@ -6656,12 +7232,12 @@ function rgbToHex(r, g, b) {
 
 // src/modules/roads/roundabouts.ts
 function compileRoundabouts(request, surfaces, context, contributions) {
-  const { fields, layers } = context.data.schema;
-  if (!layers.circularFeature) return;
+  const { fields: fields2, layers: layers2 } = context.data.schema;
+  if (!layers2.circularFeature) return;
   const drawn = surfaces.filter(({ fill }) => fill && fill.visible !== false);
   if (!drawn.length) return;
   const values = (resolve) => drawn.map((surface) => ({
-    condition: tileflowRoadClassFilter(fields, surface.roadClass),
+    condition: tileflowRoadClassFilter(fields2, surface.roadClass),
     value: toMapLibreStyleValue(resolve(surface))
   }));
   const widths = values(({ fill }) => fill?.width ?? 1);
@@ -6669,10 +7245,10 @@ function compileRoundabouts(request, surfaces, context, contributions) {
   const gaps = values(({ casing }) => casing?.gapWidth ?? 0);
   const fallbackWidth = request?.fallbackWidth === void 0 ? void 0 : toMapLibreStyleValue(request.fallbackWidth);
   const borderWidth = request?.borderWidth === void 0 ? void 0 : toMapLibreStyleValue(request.borderWidth);
-  const radiusAt15 = ["to-number", ["get", fields.circularRadiusAtZoom15], 0];
-  const radiusMeters = ["to-number", ["get", fields.circularRadiusMeters], 0];
-  const innerMeters = ["to-number", ["get", fields.circularInnerRadiusMeters], 0];
-  const outerMeters = ["to-number", ["get", fields.circularOuterRadiusMeters], 0];
+  const radiusAt15 = ["to-number", ["get", fields2.circularRadiusAtZoom15], 0];
+  const radiusMeters = ["to-number", ["get", fields2.circularRadiusMeters], 0];
+  const innerMeters = ["to-number", ["get", fields2.circularInnerRadiusMeters], 0];
+  const outerMeters = ["to-number", ["get", fields2.circularOuterRadiusMeters], 0];
   const physical = [
     "all",
     [">", radiusMeters, 0],
@@ -6740,7 +7316,7 @@ function compileRoundabouts(request, surfaces, context, contributions) {
     strokeWidth: geometry(phase === "casing", true),
     strokeColor: phase === "casing" ? context.colors.roads.casing : expression([
       "match",
-      ["coalesce", ["get", fields.class], "minor"],
+      ["coalesce", ["get", fields2.class], "minor"],
       "motorway",
       context.colors.roads.motorway,
       "trunk",
@@ -6751,7 +7327,7 @@ function compileRoundabouts(request, surfaces, context, contributions) {
       context.colors.roads.secondary,
       context.colors.roads.minor
     ]),
-    strokeOpacity: phaseVisibility(drawn, phase, fields)
+    strokeOpacity: phaseVisibility(drawn, phase, fields2)
   });
   for (const phase of ["casing", "fill"]) {
     const style = mergeTileflowDesign(phaseStyle(phase), request?.[phase]);
@@ -6767,13 +7343,13 @@ function compileRoundabouts(request, surfaces, context, contributions) {
           id: `tileflow-road-circular-${phase}`,
           type: "circle",
           source: context.data.sourceId,
-          "source-layer": layers.circularFeature,
+          "source-layer": layers2.circularFeature,
           filter: [
             "all",
-            ["==", ["get", fields.circularKind], "road_ring"],
+            ["==", ["get", fields2.circularKind], "road_ring"],
             [
               "any",
-              ...eligible.map((surface) => tileflowRoadClassFilter(fields, surface.roadClass))
+              ...eligible.map((surface) => tileflowRoadClassFilter(fields2, surface.roadClass))
             ]
           ]
         },
@@ -6793,7 +7369,7 @@ function select(values, fallback) {
   if (values.every(({ value }) => JSON.stringify(value) === serialized)) return values[0].value;
   return ["case", ...values.flatMap(({ condition, value }) => [condition, value]), fallback];
 }
-function phaseVisibility(surfaces, phase, fields) {
+function phaseVisibility(surfaces, phase, fields2) {
   const levels = [
     ...new Set(
       surfaces.flatMap((surface) => {
@@ -6809,7 +7385,7 @@ function phaseVisibility(surfaces, phase, fields) {
     surfaces.map((surface) => {
       const style = surface[phase];
       return {
-        condition: tileflowRoadClassFilter(fields, surface.roadClass),
+        condition: tileflowRoadClassFilter(fields2, surface.roadClass),
         value: (style?.minZoom === void 0 || level >= style.minZoom) && (style?.maxZoom === void 0 || level < style.maxZoom) ? 1 : 0
       };
     }),
@@ -7299,8 +7875,8 @@ function roadPhysicalCohort(roadClass) {
   return "path";
 }
 function compileSidewalks(request, pedestrianAreaColor, context, contributions) {
-  const { fields, layers } = context.data.schema;
-  if (!layers.sidewalk) return;
+  const { fields: fields2, layers: layers2 } = context.data.schema;
+  if (!layers2.sidewalk) return;
   const config = mergeTileflowDesign(
     {
       surface: {
@@ -7314,11 +7890,11 @@ function compileSidewalks(request, pedestrianAreaColor, context, contributions)
   const base = {
     type: "fill",
     source: context.data.sourceId,
-    "source-layer": layers.sidewalk,
+    "source-layer": layers2.sidewalk,
     filter: [
       "all",
       ["==", ["geometry-type"], "Polygon"],
-      ["match", ["get", fields.class], ["sidewalk", "pedestrian"], true, false]
+      ["match", ["get", fields2.class], ["sidewalk", "pedestrian"], true, false]
     ]
   };
   if (config.surface?.visible !== false) {
@@ -7356,8 +7932,8 @@ function compileSidewalks(request, pedestrianAreaColor, context, contributions)
   }
 }
 function compileCrossings(request, context, contributions) {
-  const { fields, layers } = context.data.schema;
-  if (!request || !layers.streetFurniture) return;
+  const { fields: fields2, layers: layers2 } = context.data.schema;
+  if (!request || !layers2.streetFurniture) return;
   const config = mergeTileflowDesign(
     {
       allowOverlap: true,
@@ -7370,7 +7946,7 @@ function compileCrossings(request, context, contributions) {
       ]),
       padding: 0,
       pitchAlignment: "map",
-      rotate: expression(["+", ["to-number", ["get", fields.direction], 0], 90]),
+      rotate: expression(["+", ["to-number", ["get", fields2.direction], 0], 90]),
       rotationAlignment: "map",
       size: zoom.linear([
         [15, 0.22],
@@ -7393,14 +7969,14 @@ function compileCrossings(request, context, contributions) {
         id: "tileflow-road-crossing",
         type: "symbol",
         source: context.data.sourceId,
-        "source-layer": layers.streetFurniture,
+        "source-layer": layers2.streetFurniture,
         filter: [
           "all",
           ["==", ["geometry-type"], "Point"],
-          ["==", ["get", fields.subclass], "crossing"],
-          ["!=", ["get", fields.crossing], "no"],
-          ["has", fields.markings],
-          ["match", ["get", fields.markings], ["no", "none", "unmarked"], false, true]
+          ["==", ["get", fields2.subclass], "crossing"],
+          ["!=", ["get", fields2.crossing], "no"],
+          ["has", fields2.markings],
+          ["match", ["get", fields2.markings], ["no", "none", "unmarked"], false, true]
         ]
       },
       config
@@ -7476,36 +8052,36 @@ function substituteZoom(value, level) {
   if (value.length === 1 && value[0] === "zoom") return level;
   return value.map((entry) => substituteZoom(entry, level));
 }
-function resolveRoadTreatments(request, fields, roadClass) {
+function resolveRoadTreatments(request, fields2, roadClass) {
   const entries = [];
   const add2 = (style, condition) => {
     if (style && style.enabled !== false) entries.push({ condition, style });
   };
   add2(request?.modifiers?.construction, [
     "match",
-    ["get", fields.class],
+    ["get", fields2.class],
     tileflowRoadConstructionClasses,
     true,
     false
   ]);
-  add2(request?.restrictions?.bicycle, restrictedAccessFilter(fields.bicycle));
-  add2(request?.restrictions?.foot, restrictedAccessFilter(fields.foot));
-  add2(request?.restrictions?.horse, restrictedAccessFilter(fields.horse));
-  add2(request?.restrictions?.access, restrictedAccessFilter(fields.access));
-  add2(request?.restrictions?.toll, flagFilter(fields.toll));
-  add2(request?.modifiers?.expressway, flagFilter(fields.expressway));
-  add2(request?.modifiers?.ramp, flagFilter(fields.ramp));
-  add2(request?.modifiers?.unpaved, ["==", ["get", fields.surface], "unpaved"]);
-  add2(request?.modifiers?.indoor, flagFilter(fields.indoor));
-  add2(request?.modifiers?.official, flagFilter(fields.official));
+  add2(request?.restrictions?.bicycle, restrictedAccessFilter(fields2.bicycle));
+  add2(request?.restrictions?.foot, restrictedAccessFilter(fields2.foot));
+  add2(request?.restrictions?.horse, restrictedAccessFilter(fields2.horse));
+  add2(request?.restrictions?.access, restrictedAccessFilter(fields2.access));
+  add2(request?.restrictions?.toll, flagFilter(fields2.toll));
+  add2(request?.modifiers?.expressway, flagFilter(fields2.expressway));
+  add2(request?.modifiers?.ramp, flagFilter(fields2.ramp));
+  add2(request?.modifiers?.unpaved, ["==", ["get", fields2.surface], "unpaved"]);
+  add2(request?.modifiers?.indoor, flagFilter(fields2.indoor));
+  add2(request?.modifiers?.official, flagFilter(fields2.official));
   for (const [scale, style] of Object.entries(request?.mountainBike ?? {})) {
-    add2(style, ["==", ["to-string", ["get", fields.mtbScale]], scale]);
+    add2(style, ["==", ["to-string", ["get", fields2.mtbScale]], scale]);
   }
   if (roadClass === "service") {
     for (const [serviceType, value] of Object.entries(serviceTypeValues)) {
       add2(request?.serviceTypes?.[serviceType], [
         "==",
-        ["get", fields.service],
+        ["get", fields2.service],
         value
       ]);
     }
@@ -8308,7 +8884,7 @@ function compileWater(request, context, language = "auto") {
   );
   if (config.enabled === false) return [];
   const source = context.data.sourceId;
-  const { fields, layers } = context.data.schema;
+  const { fields: fields2, layers: layers2 } = context.data.schema;
   const contributions = [];
   if (config.bodies) {
     for (const area of createAreaLayers(
@@ -8316,8 +8892,8 @@ function compileWater(request, context, language = "auto") {
         id: "tileflow-water",
         type: "fill",
         source,
-        "source-layer": layers.water,
-        filter: ["!=", ["get", fields.intermittent], 1]
+        "source-layer": layers2.water,
+        filter: ["!=", ["get", fields2.intermittent], 1]
       },
       config.bodies
     )) {
@@ -8337,8 +8913,8 @@ function compileWater(request, context, language = "auto") {
         id: "tileflow-water-intermittent",
         type: "fill",
         source,
-        "source-layer": layers.water,
-        filter: ["==", ["get", fields.intermittent], 1]
+        "source-layer": layers2.water,
+        filter: ["==", ["get", fields2.intermittent], 1]
       },
       config.intermittent.bodies
     )) {
@@ -8356,9 +8932,9 @@ function compileWater(request, context, language = "auto") {
   const sidecarBathymetry = bathymetryProduct?.vector;
   const usePrimaryBathymetryFallback = context.marine === void 0;
   const bathymetrySource = sidecarBathymetry?.sourceId ?? source;
-  const bathymetryLayer = sidecarBathymetry ? "bathymetry" : usePrimaryBathymetryFallback ? layers.bathymetry : void 0;
-  const bathymetryDepthField = sidecarBathymetry ? "min_depth" : usePrimaryBathymetryFallback ? fields.bathymetryMinDepth : void 0;
-  const bathymetrySortField = sidecarBathymetry ? "sort_key" : usePrimaryBathymetryFallback ? fields.bathymetrySortKey : void 0;
+  const bathymetryLayer = sidecarBathymetry ? "bathymetry" : usePrimaryBathymetryFallback ? layers2.bathymetry : void 0;
+  const bathymetryDepthField = sidecarBathymetry ? "min_depth" : usePrimaryBathymetryFallback ? fields2.bathymetryMinDepth : void 0;
+  const bathymetrySortField = sidecarBathymetry ? "sort_key" : usePrimaryBathymetryFallback ? fields2.bathymetrySortKey : void 0;
   if (bathymetryLayer && bathymetryDepthField && bathymetrySortField) {
     const depth = context.colors.hydro.depth;
     const depthStops = bathymetryDepthStops(depth);
@@ -8558,11 +9134,11 @@ function compileWater(request, context, language = "auto") {
           id: `tileflow-waterway-${name}`,
           type: "line",
           source,
-          "source-layer": layers.waterway,
+          "source-layer": layers2.waterway,
           filter: [
             "all",
-            classFilter3(fields.class, classes),
-            ["!=", ["get", fields.intermittent], 1]
+            classFilter3(fields2.class, classes),
+            ["!=", ["get", fields2.intermittent], 1]
           ]
         },
         style
@@ -8587,11 +9163,11 @@ function compileWater(request, context, language = "auto") {
           id: `tileflow-waterway-${name}-intermittent`,
           type: "line",
           source,
-          "source-layer": layers.waterway,
+          "source-layer": layers2.waterway,
           filter: [
             "all",
-            classFilter3(fields.class, classes),
-            ["==", ["get", fields.intermittent], 1]
+            classFilter3(fields2.class, classes),
+            ["==", ["get", fields2.intermittent], 1]
           ]
         },
         mergeTileflowDesign(style, intermittent)
@@ -8606,8 +9182,8 @@ function compileWater(request, context, language = "auto") {
 }
 function appendBathymetryNames(contributions, options) {
   const { context, language } = options;
-  const { fields } = tileflowBathymetryV1Schema;
-  const localName = ["to-string", ["coalesce", ["get", fields.name], ""]];
+  const { fields: fields2 } = tileflowBathymetryV1Schema;
+  const localName = ["to-string", ["coalesce", ["get", fields2.name], ""]];
   const name = language === "auto" || language === "local" ? localName : [
     "case",
     ["!=", ["to-string", ["coalesce", ["get", `name:${language}`], ""]], ""],
@@ -8618,7 +9194,7 @@ function appendBathymetryNames(contributions, options) {
     {
       minZoom: 0,
       placement: "point",
-      priority: expression(["to-number", ["get", fields.sortKey], 0]),
+      priority: expression(["to-number", ["get", fields2.sortKey], 0]),
       priorityOrder: "lower-first",
       text: {
         ...typographyTextStyle(context.typography.water),
@@ -8636,8 +9212,8 @@ function appendBathymetryNames(contributions, options) {
     options.style
   );
   if (style.visible === false || style.text?.visible === false) return;
-  const sourceMinimum = ["to-number", ["coalesce", ["get", fields.minZoom], 0], 0];
-  const sourceMaximum = ["to-number", ["coalesce", ["get", fields.maxZoom], 24], 24];
+  const sourceMinimum = ["to-number", ["coalesce", ["get", fields2.minZoom], 0], 0];
+  const sourceMaximum = ["to-number", ["coalesce", ["get", fields2.maxZoom], 24], 24];
   const ranges = options.availability === true ? void 0 : [...options.availability.zoomRanges].sort(
     (left, right) => left.minZoom - right.minZoom || left.maxZoom - right.maxZoom
   );
@@ -9078,8 +9654,8 @@ function assertProvidedServices(domain, services) {
   }
 }
 function checkedModuleRecord(entries) {
-  const record3 = Object.fromEntries(entries);
-  const actual = Object.keys(record3).sort(compareCodeUnits3);
+  const record4 = Object.fromEntries(entries);
+  const actual = Object.keys(record4).sort(compareCodeUnits3);
   if (actual.length !== tileflowSemanticDomainRegistry.length || actual.some(
     (name, index) => name !== [...tileflowSemanticDomainRegistry.map(({ name: name2 }) => name2)].sort(compareCodeUnits3)[index]
   )) {
@@ -9087,7 +9663,7 @@ function checkedModuleRecord(entries) {
       "Tileflow semantic domain registry did not produce one value for every module."
     );
   }
-  return record3;
+  return record4;
 }
 function assertRegistryIsValid() {
   const names = /* @__PURE__ */ new Set();
@@ -9146,12 +9722,12 @@ function readTileflowCompilerProvenance(layer) {
   const target = metadata[tileflowCompilerMetadataKeys.target];
   return owner && slot && typeof target === "string" && tileflowSemanticTargetPattern.test(target) ? [{ operations: [], owner, slot, target }] : [];
 }
-function createTileflowStyleInspection(map, theme, layers) {
+function createTileflowStyleInspection(map, theme, layers2) {
   return {
     schemaVersion: tileflowStyleInspectionSchemaVersion,
     map,
     theme,
-    layers: layers.map((layer, index) => ({
+    layers: layers2.map((layer, index) => ({
       id: typeof layer.id === "string" ? layer.id : "",
       index,
       type: typeof layer.type === "string" ? layer.type : "",
@@ -9251,12 +9827,12 @@ var classicManifestSchemaOperations = {
 
 // src/portable-identity-schema.ts
 function createPortableIdentitySchemas(operations) {
-  const bounded = operations.maxLength(
+  const bounded2 = operations.maxLength(
     operations.minLength(operations.string(), 1),
     tileflowPortableIdMaximumLength
   );
   const pattern = operations.regex(
-    bounded,
+    bounded2,
     tileflowPortableIdPattern,
     "Expected lowercase kebab-case beginning with a letter"
   );
@@ -9370,7 +9946,7 @@ function insertTileflowOverlays(input) {
         available.length > 0 ? `Use one of: ${available.join(", ")}.` : "Declare the source first."
       );
     }
-    const layers2 = overlay.layers.map((layer, index) => {
+    const layers3 = overlay.layers.map((layer, index) => {
       if (layerIds.has(layer.id)) {
         throw new TileflowOverlayCompilationError(
           "TF_OVERLAY_LAYER_ID_DUPLICATE",
@@ -9388,21 +9964,21 @@ function insertTileflowOverlays(input) {
         }
       };
     });
-    groups.set(overlay.placement, [...groups.get(overlay.placement) ?? [], ...layers2]);
+    groups.set(overlay.placement, [...groups.get(overlay.placement) ?? [], ...layers3]);
     identities[overlayId] = Object.freeze({
       layers: Object.freeze(overlay.layers.map(({ id: id2 }) => id2)),
       placement: overlay.placement,
       source: overlay.source
     });
   }
-  let layers = input.basemapLayers.map(cloneJson18);
+  let layers2 = input.basemapLayers.map(cloneJson18);
   for (const placement of tileflowOverlayPlacements) {
     const overlayLayers = groups.get(placement);
     if (!overlayLayers?.length) continue;
-    const index = tileflowOverlayInsertionIndex(layers, placement);
-    layers = [...layers.slice(0, index), ...overlayLayers, ...layers.slice(index)];
+    const index = tileflowOverlayInsertionIndex(layers2, placement);
+    layers2 = [...layers2.slice(0, index), ...overlayLayers, ...layers2.slice(index)];
   }
-  return { identities, layers };
+  return { identities, layers: layers2 };
 }
 function isSafeLocalPmtilesPath(value) {
   if (typeof value !== "string" || value.length > 512 || !value.endsWith(".pmtiles") || value.includes("\\") || /[\p{Cc}?#]/u.test(value)) {
@@ -9426,8 +10002,8 @@ function cloneJson18(value) {
     Object.entries(value).map(([key, child]) => [key, cloneJson18(child)])
   );
 }
-function tileflowOverlayInsertionIndex(layers, placement) {
-  const ranks = layers.map((layer) => {
+function tileflowOverlayInsertionIndex(layers2, placement) {
+  const ranks = layers2.map((layer) => {
     const slots = readTileflowCompilerProvenance(layer).map(
       ({ slot }) => tileflowLayerSlots.indexOf(slot)
     );
@@ -9634,6 +10210,14 @@ function validateBoundaryChoroplethOverlays(mapId, overlays, boundaryAreas) {
   return overlays;
 }
 
+// src/notices.ts
+var tileflowNoticesMetadataKey = "tileflow:notices";
+var tileflowNoticeLimits = Object.freeze({
+  maxNotices: 8,
+  maxSources: 16,
+  maxTextLength: 120
+});
+
 // src/resolved-map-schema.ts
 import { Color as Color3 } from "@maplibre/maplibre-gl-style-spec";
 import { z as z5 } from "zod";
@@ -10271,12 +10855,12 @@ function dataSource() {
   return Object.freeze({ kind: "tileflow-data-source", name: "primary" });
 }
 function createSemanticDataView(data) {
-  const fields = Object.fromEntries(
+  const fields2 = Object.fromEntries(
     Object.entries(data.schema.fields).flatMap(
       ([name, value]) => value === void 0 ? [] : [[name, field(name)]]
     )
   );
-  const layers = Object.fromEntries(
+  const layers2 = Object.fromEntries(
     Object.entries(data.schema.layers).flatMap(
       ([name, value]) => value === void 0 ? [] : [[name, dataLayer(name)]]
     )
@@ -10284,7 +10868,7 @@ function createSemanticDataView(data) {
   return {
     ...data,
     sourceId: dataSource(),
-    schema: { ...data.schema, fields, layers }
+    schema: { ...data.schema, fields: fields2, layers: layers2 }
   };
 }
 function bindSemanticReferences(value, data) {
@@ -10448,12 +11032,12 @@ function materializeTileflowLayerFamilyIR(template, semantics) {
   });
 }
 function lowerTileflowDomainIR(families, data, resolvePhysicalId = physicalLayerIdForSemanticKey) {
-  const layers = families.map(
+  const layers2 = families.map(
     (family) => bindSemanticReferences(emitLayer(family, resolvePhysicalId), data)
   );
-  assertNoSemanticReferences(layers);
+  assertNoSemanticReferences(layers2);
   const ids = /* @__PURE__ */ new Set();
-  for (const layer of layers) {
+  for (const layer of layers2) {
     if (ids.has(layer.id)) {
       throw new TileflowDomainIRError(
         "TILEFLOW_DOMAIN_IR_DUPLICATE_PHYSICAL_ID",
@@ -10462,7 +11046,7 @@ function lowerTileflowDomainIR(families, data, resolvePhysicalId = physicalLayer
     }
     ids.add(layer.id);
   }
-  return Object.freeze({ layers: Object.freeze(layers) });
+  return Object.freeze({ layers: Object.freeze(layers2) });
 }
 var TileflowDomainIRError = class extends Error {
   code;
@@ -10616,7 +11200,11 @@ var exactPhysicalLayerIds = Object.freeze({
 });
 var nauticalPhysicalBases = Object.freeze({
   "nautical.aids": "tileflow-nautical-aids",
+  "nautical.beacons": "tileflow-nautical-beacons",
+  "nautical.buoys": "tileflow-nautical-buoys",
+  "nautical.cables": "tileflow-nautical-cables",
   "nautical.coverage": "tileflow-nautical-coverage",
+  "nautical.harbours": "tileflow-nautical-harbours",
   "nautical.hazardAreas": "tileflow-nautical-hazard-areas",
   "nautical.hazards": "tileflow-nautical-hazards",
   "nautical.labels.coverage": "tileflow-nautical-coverage-labels",
@@ -10627,7 +11215,9 @@ var nauticalPhysicalBases = Object.freeze({
   "nautical.lighthouses": "tileflow-nautical-lighthouses",
   "nautical.lights": "tileflow-nautical-lights",
   "nautical.navigationAreas": "tileflow-nautical-navigation-areas",
+  "nautical.ports": "tileflow-nautical-ports",
   "nautical.reefs": "tileflow-nautical-reefs",
+  "nautical.routes": "tileflow-nautical-routes",
   "nautical.soundings": "tileflow-nautical-soundings",
   "nautical.wreckAreas": "tileflow-nautical-wreck-areas",
   "nautical.wrecks": "tileflow-nautical-wrecks"
@@ -10909,17 +11499,17 @@ function compileRenderSelector(selector, data) {
   return lowerSelector(selector, data);
 }
 function applyCompiledRenderStacks(input, operations) {
-  let layers = input.map(cloneJson21);
+  let layers2 = input.map(cloneJson21);
   const passes = operations.filter(
     (operation) => operation.kind === "layer"
   );
   const refinements = operations.filter(
     (operation) => operation.kind === "refinement"
   );
-  requireUniqueCompiledLayers(layers, passes);
+  requireUniqueCompiledLayers(layers2, passes);
   const passTargets = new Set(passes.map(({ target }) => target));
-  const knownTargets = /* @__PURE__ */ new Set([...layers.map(({ target }) => target), ...passTargets]);
-  const activeOwners = new Set(layers.map(({ owner }) => owner));
+  const knownTargets = /* @__PURE__ */ new Set([...layers2.map(({ target }) => target), ...passTargets]);
+  const activeOwners = new Set(layers2.map(({ owner }) => owner));
   const drawn = /* @__PURE__ */ new Set();
   for (let changed = true; changed; ) {
     changed = false;
@@ -10937,7 +11527,7 @@ function applyCompiledRenderStacks(input, operations) {
     (refinement) => refinement.requirements.every((requirement) => activeOwners.has(requirement))
   ).sort(compareCompiledOperations);
   for (const refinement of activeRefinements) {
-    const index = findTargetIndex(layers, refinement.target);
+    const index = findTargetIndex(layers2, refinement.target);
     if (index < 0 && !passTargets.has(refinement.target)) {
       throw renderStackError(
         "unknown-refinement-target",
@@ -10972,11 +11562,11 @@ function applyCompiledRenderStacks(input, operations) {
   const lastPlaced = /* @__PURE__ */ new Map();
   const isMovePending = (target) => pending.some((operation) => operation.kind === "refinement" && operation.target === target);
   const isReady = (operation) => {
-    if (operation.kind === "refinement" && findTargetIndex(layers, operation.target) < 0) {
+    if (operation.kind === "refinement" && findTargetIndex(layers2, operation.target) < 0) {
       return false;
     }
     const anchor = placementAnchor(operation.placement);
-    return anchor === void 0 || findTargetIndex(layers, anchor) >= 0 && !isMovePending(anchor);
+    return anchor === void 0 || findTargetIndex(layers2, anchor) >= 0 && !isMovePending(anchor);
   };
   while (pending.length > 0) {
     const first = pending.find(isReady);
@@ -10994,34 +11584,34 @@ function applyCompiledRenderStacks(input, operations) {
     const moved = /* @__PURE__ */ new Map();
     for (const operation of group) {
       if (operation.kind !== "refinement") continue;
-      const index2 = findTargetIndex(layers, operation.target);
-      moved.set(operation.target, requireRefinementOwner(layers[index2], operation));
-      layers = [...layers.slice(0, index2), ...layers.slice(index2 + 1)];
+      const index2 = findTargetIndex(layers2, operation.target);
+      moved.set(operation.target, requireRefinementOwner(layers2[index2], operation));
+      layers2 = [...layers2.slice(0, index2), ...layers2.slice(index2 + 1)];
       for (const [placed, target] of lastPlaced) {
         if (target === operation.target) lastPlaced.delete(placed);
       }
     }
     const placement = first.placement;
     const anchor = placementAnchor(placement);
-    const anchorLayer = anchor === void 0 ? void 0 : layers[findTargetIndex(layers, anchor)];
+    const anchorLayer = anchor === void 0 ? void 0 : layers2[findTargetIndex(layers2, anchor)];
     const slot = anchorLayer === void 0 ? tileflowBandPlacementSlot(placement) : requireSemanticSlot(anchorLayer, anchor);
     const block = group.map(
       (operation) => operation.kind === "layer" ? materializeRenderLayer(operation, anchorLayer, slot) : moveLayer(moved.get(operation.target), operation, slot, anchorLayer)
     );
     const previous = lastPlaced.get(key);
-    const previousIndex = previous === void 0 ? -1 : findTargetIndex(layers, previous);
-    const index = anchorLayer !== void 0 ? findTargetIndex(layers, anchor) + (key.startsWith("above:") ? 1 : 0) : previousIndex >= 0 ? previousIndex + 1 : tileflowBandPlacementIndex(
-      layers.map((candidate) => tileflowLayerSlots.indexOf(candidate.slot)),
+    const previousIndex = previous === void 0 ? -1 : findTargetIndex(layers2, previous);
+    const index = anchorLayer !== void 0 ? findTargetIndex(layers2, anchor) + (key.startsWith("above:") ? 1 : 0) : previousIndex >= 0 ? previousIndex + 1 : tileflowBandPlacementIndex(
+      layers2.map((candidate) => tileflowLayerSlots.indexOf(candidate.slot)),
       placement
     );
-    layers = [...layers.slice(0, index), ...block, ...layers.slice(index)];
+    layers2 = [...layers2.slice(0, index), ...block, ...layers2.slice(index)];
     lastPlaced.set(key, block.at(-1).target);
   }
   for (const refinement of activeRefinements) {
     if (refinement.patch === void 0) continue;
-    const index = findTargetIndex(layers, refinement.target);
+    const index = findTargetIndex(layers2, refinement.target);
     if (index < 0) continue;
-    const previous = requireRefinementOwner(layers[index], refinement);
+    const previous = requireRefinementOwner(layers2[index], refinement);
     const expectedType = rendererLayerType(refinement.renderer);
     if (previous.renderer !== expectedType) {
       throw renderStackError(
@@ -11029,9 +11619,9 @@ function applyCompiledRenderStacks(input, operations) {
         `Render refinement ${refinement.target} expects ${expectedType}, found ${String(previous.renderer)}.`
       );
     }
-    layers[index] = applyRefinement(previous, { ...refinement, patch: refinement.patch });
+    layers2[index] = applyRefinement(previous, { ...refinement, patch: refinement.patch });
   }
-  return layers;
+  return layers2;
 }
 function requireRefinementOwner(layer, refinement) {
   if (layer.owner !== refinement.owner) {
@@ -11550,9 +12140,9 @@ function requireOperationName(name) {
     );
   }
 }
-function requireUniqueCompiledLayers(layers, operations) {
-  const keys = new Set(layers.map(({ key }) => key));
-  const targets = new Set(layers.map(({ target }) => target));
+function requireUniqueCompiledLayers(layers2, operations) {
+  const keys = new Set(layers2.map(({ key }) => key));
+  const targets = new Set(layers2.map(({ target }) => target));
   for (const operation of operations) {
     if (keys.has(operation.template.key)) {
       throw renderStackError(
@@ -11612,8 +12202,8 @@ function requireSemanticSlot(layer, target) {
   }
   return layer.slot;
 }
-function findTargetIndex(layers, target) {
-  return layers.findIndex((layer) => layer.target === target);
+function findTargetIndex(layers2, target) {
+  return layers2.findIndex((layer) => layer.target === target);
 }
 function requireScalar(value, description) {
   if (typeof value !== "boolean" && typeof value !== "number" && typeof value !== "string" || typeof value === "number" && !Number.isFinite(value)) {
@@ -12721,6 +13311,28 @@ function boundedThemeNumberSchema(min, max) {
     }).strict()
   ]);
 }
+var modelRoleLightingSchema = z5.object({
+  emissiveStrength: boundedThemeNumberSchema(0, 5).optional(),
+  emissiveVariation: boundedThemeNumberSchema(0, 1).optional(),
+  emissiveColor: themeColorValueSchema.optional(),
+  color: themeColorValueSchema.optional(),
+  colorMix: boundedThemeNumberSchema(0, 1).optional(),
+  metallic: boundedThemeNumberSchema(0, 1).optional(),
+  roughness: boundedThemeNumberSchema(0, 1).optional(),
+  colorVariation: z5.object({
+    hue: z5.tuple([boundedThemeNumberSchema(0, 360), boundedThemeNumberSchema(0, 360)]),
+    saturation: z5.tuple([boundedThemeNumberSchema(0, 100), boundedThemeNumberSchema(0, 100)]),
+    lightness: z5.tuple([boundedThemeNumberSchema(0, 100), boundedThemeNumberSchema(0, 100)]),
+    space: z5.enum(["srgb", "linear"]).optional()
+  }).strict().optional(),
+  emissiveHeight: z5.tuple([
+    boundedThemeNumberSchema(0, 1),
+    boundedThemeNumberSchema(0, 1),
+    boundedThemeNumberSchema(0, 1),
+    boundedThemeNumberSchema(0, 1),
+    boundedThemeNumberSchema(-1, 1)
+  ]).optional()
+}).strict();
 var buildingsModuleSchema = z5.object({
   type: z5.literal("buildings"),
   businessCorridor: areaStyleSchema.optional(),
@@ -12736,7 +13348,26 @@ var buildingsModuleSchema = z5.object({
     edgeRadius: z5.number().min(0).max(1).optional(),
     edgeColor: themeColorValueSchema.optional(),
     nightLight: boundedThemeNumberSchema(0, 2).optional(),
+    floodLight: z5.object({
+      intensity: boundedThemeNumberSchema(0, 1).optional(),
+      brightnessScale: boundedThemeNumberSchema(0, 16).optional(),
+      color: themeColorValueSchema.optional(),
+      groundRadius: z5.tuple([z5.number().finite().min(0).max(2048), z5.number().finite().min(0).max(2048)]).refine(([min, max]) => min <= max, "The minimum radius must not exceed the maximum.").optional(),
+      minGroundHeight: z5.number().finite().min(0).max(6e3).optional(),
+      minWallHeight: z5.number().finite().min(0).max(6e3).optional(),
+      wallHeightRatio: z5.number().finite().min(0).max(1).optional()
+    }).strict().optional(),
+    modelLighting: z5.object({
+      unclassified: modelRoleLightingSchema.optional(),
+      wall: modelRoleLightingSchema.optional(),
+      door: modelRoleLightingSchema.optional(),
+      roof: modelRoleLightingSchema.optional(),
+      window: modelRoleLightingSchema.optional(),
+      lamp: modelRoleLightingSchema.optional(),
+      logo: modelRoleLightingSchema.optional()
+    }).strict().optional(),
     occlusion: z5.boolean().optional(),
+    modelOcclusion: boundedThemeNumberSchema(0, 1).optional(),
     shadows: z5.boolean().optional(),
     windows: z5.boolean().optional(),
     models: z5.array(
@@ -12973,8 +13604,12 @@ var poiModuleSchema = z5.object({
 var nauticalModuleSchema = z5.object({
   type: z5.literal("nautical"),
   aids: markerSymbolStyleSchema.optional(),
+  beacons: markerSymbolStyleSchema.optional(),
+  buoys: markerSymbolStyleSchema.optional(),
+  cables: lineStyleSchema.optional(),
   coverage: areaStyleSchema.optional(),
   enabled: z5.boolean().optional(),
+  harbours: markerSymbolStyleSchema.optional(),
   hazardAreas: areaStyleSchema.optional(),
   hazards: markerSymbolStyleSchema.optional(),
   labels: z5.object({
@@ -12987,8 +13622,10 @@ var nauticalModuleSchema = z5.object({
   lighthouses: markerSymbolStyleSchema.optional(),
   lights: markerSymbolStyleSchema.optional(),
   navigationAreas: areaStyleSchema.optional(),
+  ports: markerSymbolStyleSchema.optional(),
   reefs: areaStyleSchema.optional(),
   renderStack: renderStackSchema.optional(),
+  routes: lineStyleSchema.optional(),
   soundings: markerSymbolStyleSchema.optional(),
   wreckAreas: areaStyleSchema.optional(),
   wrecks: markerSymbolStyleSchema.optional()
@@ -13847,8 +14484,8 @@ function isSafeGlyphUrl(value) {
 function validateZoomRanges(value, context, path = []) {
   if (!value || typeof value !== "object") return;
   if (!Array.isArray(value)) {
-    const record3 = value;
-    if (typeof record3.minZoom === "number" && typeof record3.maxZoom === "number" && record3.minZoom > record3.maxZoom) {
+    const record4 = value;
+    if (typeof record4.minZoom === "number" && typeof record4.maxZoom === "number" && record4.minZoom > record4.maxZoom) {
       context.addIssue({
         code: "custom",
         path: [...path, "maxZoom"],
@@ -14470,7 +15107,7 @@ function applyTileflowIconCapabilities(style, icons) {
       "line-pattern",
       "background-pattern"
     ]) {
-      const pattern = record(layer.paint)[property];
+      const pattern = record2(layer.paint)[property];
       if (pattern !== void 0 && [...outputs(pattern, ids)].some((id2) => appearances[id2]?.representation === "sdf")) {
         throw Object.assign(new Error(`Layer "${layer.id}" cannot use an SDF icon as a pattern.`), {
           code: "TF_ICON_PATTERN_SDF",
@@ -14479,7 +15116,7 @@ function applyTileflowIconCapabilities(style, icons) {
         });
       }
     }
-    const image = record(layer.layout)["icon-image"];
+    const image = record2(layer.layout)["icon-image"];
     if (image === void 0) continue;
     if (typeof image === "string" && /\{[^{}]+\}/u.test(image) || typeof image !== "string" && !Array.isArray(image)) {
       throw Object.assign(new Error(`Layer "${layer.id}" has an unproven legacy icon selection.`), {
@@ -14501,7 +15138,7 @@ function applyTileflowIconCapabilities(style, icons) {
         }
       );
     }
-    const paint = { ...record(layer.paint) };
+    const paint = { ...record2(layer.paint) };
     for (const [property, limit] of [
       ["icon-halo-width", 2],
       ["icon-halo-blur", 1]
@@ -14531,7 +15168,7 @@ function applyTileflowIconCapabilities(style, icons) {
     layer.paint = paint;
   }
 }
-function record(value) {
+function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function outputs(value, ids) {
@@ -14620,8 +15257,8 @@ function defaultPaint(image, key, names, appearances, ids) {
 // src/cartography/interaction-manifest.ts
 var tileflowInteractionManifestMetadataKey = "tileflow:interaction-manifest";
 var tileflowInteractionManifestVersion = 3;
-function createTileflowInteractionManifest(layers, fields) {
-  const poiLayers = layers.flatMap((layer, priority) => {
+function createTileflowInteractionManifest(layers2, fields2) {
+  const poiLayers = layers2.flatMap((layer, priority) => {
     const id2 = typeof layer.id === "string" ? layer.id : void 0;
     const source = typeof layer.source === "string" ? layer.source : void 0;
     const sourceLayer = typeof layer["source-layer"] === "string" ? layer["source-layer"] : void 0;
@@ -14650,7 +15287,7 @@ function createTileflowInteractionManifest(layers, fields) {
           identity: ["source", "source-layer", "feature-id"],
           representationPriority: ["marker", "icon", "combined", "label"]
         },
-        fields: { ...fields },
+        fields: { ...fields2 },
         hitTesting: { frequency: "animation-frame", order: "rendered-topmost" },
         identity: "maplibre-feature-id-if-present",
         layers: poiLayers
@@ -14659,13 +15296,13 @@ function createTileflowInteractionManifest(layers, fields) {
     version: tileflowInteractionManifestVersion
   };
 }
-function assertTileflowInteractionManifestLayers(manifest, layers) {
+function assertTileflowInteractionManifestLayers(manifest, layers2) {
   const poiLayers = manifest?.domains.poi?.layers ?? [];
   if (poiLayers.length > 256) {
     throw new Error("Tileflow interaction manifest exceeds the 256-layer POI lookup limit.");
   }
   const layersById = new Map(
-    layers.flatMap((layer) => typeof layer.id === "string" ? [[layer.id, layer]] : [])
+    layers2.flatMap((layer) => typeof layer.id === "string" ? [[layer.id, layer]] : [])
   );
   const poiNamespaces = new Set(
     poiLayers.map((layer) => `${layer.source}\0${layer.sourceLayer}`)
@@ -14729,9 +15366,9 @@ function isSafeArtifactName(value) {
 }
 
 // src/cartography/layout-zoom-diagnostics.ts
-function diagnoseFractionalLayoutZoomSteps(layers) {
+function diagnoseFractionalLayoutZoomSteps(layers2) {
   const diagnostics = [];
-  for (const layer of layers) {
+  for (const layer of layers2) {
     const layout = layer.layout;
     if (layout === null || typeof layout !== "object") continue;
     for (const [property, value] of Object.entries(layout)) {
@@ -14772,11 +15409,11 @@ function isZoom2(value) {
 // src/cartography/overlay-placement-manifest.ts
 var tileflowOverlayPlacementManifestMetadataKey = "tileflow:overlay-placement-manifest";
 var tileflowOverlayPlacementManifestSchemaVersion = 1;
-function createTileflowOverlayPlacementManifest(layers) {
+function createTileflowOverlayPlacementManifest(layers2) {
   const anchors = Object.fromEntries(
     tileflowOverlayPlacements.map((placement) => {
-      const index = tileflowOverlayInsertionIndex(layers, placement);
-      const id2 = index < layers.length ? layers[index]?.id : void 0;
+      const index = tileflowOverlayInsertionIndex(layers2, placement);
+      const id2 = index < layers2.length ? layers2[index]?.id : void 0;
       if (id2 !== void 0 && typeof id2 !== "string") {
         throw new Error(`Tileflow overlay placement ${placement} resolved an invalid layer ID.`);
       }
@@ -14788,7 +15425,7 @@ function createTileflowOverlayPlacementManifest(layers) {
     schemaVersion: tileflowOverlayPlacementManifestSchemaVersion
   };
 }
-function assertTileflowOverlayPlacementManifestLayers(manifest, layers) {
+function assertTileflowOverlayPlacementManifestLayers(manifest, layers2) {
   if (manifest.schemaVersion !== tileflowOverlayPlacementManifestSchemaVersion) {
     throw new Error("Tileflow overlay placement manifest schema version is unsupported.");
   }
@@ -14797,14 +15434,14 @@ function assertTileflowOverlayPlacementManifestLayers(manifest, layers) {
     throw new Error("Tileflow overlay placement manifest keys are invalid.");
   }
   const layerIndexes = new Map(
-    layers.flatMap(
+    layers2.flatMap(
       (layer, index) => typeof layer.id === "string" ? [[layer.id, index]] : []
     )
   );
   let previous = -1;
   for (const placement of tileflowOverlayPlacements) {
     const anchor = manifest.anchors[placement];
-    const index = anchor === null ? layers.length : layerIndexes.get(anchor);
+    const index = anchor === null ? layers2.length : layerIndexes.get(anchor);
     if (index === void 0) {
       throw new Error(`Tileflow overlay placement manifest references missing layer: ${anchor}`);
     }
@@ -14836,18 +15473,18 @@ var lineLayoutDefaults = {
   "line-round-limit": 1.05
 };
 function planTileflowLayerFamilies(input) {
-  let layers = input.map(cloneJson23);
-  layers = consolidateRoadLines(layers);
-  layers = consolidateRoadHatches(layers);
-  layers = consolidateRoadLabels(layers);
-  layers = consolidateFillFamily(layers, "land.landcover", "land.cohorts.landcover");
-  layers = consolidateFillFamily(layers, "land.landuse", "land.cohorts.landuse");
-  layers = consolidateWaterways(layers);
-  return layers;
-}
-function consolidateRoadLines(layers) {
+  let layers2 = input.map(cloneJson23);
+  layers2 = consolidateRoadLines(layers2);
+  layers2 = consolidateRoadHatches(layers2);
+  layers2 = consolidateRoadLabels(layers2);
+  layers2 = consolidateFillFamily(layers2, "land.landcover", "land.cohorts.landcover");
+  layers2 = consolidateFillFamily(layers2, "land.landuse", "land.cohorts.landuse");
+  layers2 = consolidateWaterways(layers2);
+  return layers2;
+}
+function consolidateRoadLines(layers2) {
   const groups = /* @__PURE__ */ new Map();
-  for (const [index, layer] of layers.entries()) {
+  for (const [index, layer] of layers2.entries()) {
     if (layer.renderer !== "line" || layer.family?.kind !== "road-line") continue;
     const key = layer.family.group;
     const group = groups.get(key) ?? [];
@@ -14862,7 +15499,7 @@ function consolidateRoadLines(layers) {
       continue;
     }
     const mergedId = eligible[0].layer.family.outputKey;
-    if (hasGeneratedKeyCollision(layers, mergedId, eligible)) continue;
+    if (hasGeneratedKeyCollision(layers2, mergedId, eligible)) continue;
     const merged = mergeRoadLineGroup(
       mergedId,
       eligible.map(({ layer }) => layer)
@@ -14876,10 +15513,10 @@ function consolidateRoadLines(layers) {
     }
     replacements.set(insertAt, [...replacements.get(insertAt) ?? [], merged]);
   }
-  return applyReplacements(layers, replacements);
+  return applyReplacements(layers2, replacements);
 }
-function canMergeRoadLines(layers) {
-  const common = layers[0];
+function canMergeRoadLines(layers2) {
+  const common = layers2[0];
   if (!common) return false;
   const supportedPaint = /* @__PURE__ */ new Set([...Object.keys(linePaintDefaults), "line-pattern"]);
   const supportedLayout = /* @__PURE__ */ new Set([
@@ -14887,18 +15524,18 @@ function canMergeRoadLines(layers) {
     "line-sort-key",
     "visibility"
   ]);
-  return layers.every(
+  return layers2.every(
     (layer) => sameLayerSource(layer, common) && Object.keys(layer.style.appearance ?? {}).every((key) => supportedPaint.has(key)) && Object.keys(layer.style.placement ?? {}).every((key) => supportedLayout.has(key)) && layer.style.appearance?.["line-pattern"] === void 0 && layer.style.placement?.visibility !== "none" && !isOrderedRenderPass(layer) && sameTopLevelProperties(layer, common, ["minZoom"])
   );
 }
-function mergeRoadLineGroup(key, layers) {
-  const first = layers[0];
-  const conditions = layers.map((layer) => asFilter(layer.selector));
+function mergeRoadLineGroup(key, layers2) {
+  const first = layers2[0];
+  const conditions = layers2.map((layer) => asFilter(layer.selector));
   if (conditions.some(containsZoom)) return void 0;
   const paint = {};
-  const paintKeys = new Set(layers.flatMap((layer) => Object.keys(layer.style.appearance ?? {})));
+  const paintKeys = new Set(layers2.flatMap((layer) => Object.keys(layer.style.appearance ?? {})));
   for (const key2 of paintKeys) {
-    const values = layers.map((layer) => layer.style.appearance?.[key2]);
+    const values = layers2.map((layer) => layer.style.appearance?.[key2]);
     const combined = combineConditionalValues(
       values.map((value, index) => ({
         condition: conditions[index],
@@ -14912,7 +15549,7 @@ function mergeRoadLineGroup(key, layers) {
   }
   const layout = {};
   for (const key2 of Object.keys(lineLayoutDefaults)) {
-    const values = layers.map((layer, index) => ({
+    const values = layers2.map((layer, index) => ({
       condition: conditions[index],
       value: layer.style.placement?.[key2] ?? lineLayoutDefaults[key2]
     }));
@@ -14925,7 +15562,7 @@ function mergeRoadLineGroup(key, layers) {
     }
   }
   const sortKey = combineConditionalValues(
-    layers.map((layer, index) => ({
+    layers2.map((layer, index) => ({
       condition: conditions[index],
       value: rankedSortKey(layer.style.placement?.["line-sort-key"] ?? 0, index)
     })),
@@ -14942,16 +15579,16 @@ function mergeRoadLineGroup(key, layers) {
       selector: unionFilters(conditions),
       range: {
         minZoom: roadHighZoom,
-        ...finiteMaximumZoom(layers) === void 0 ? {} : { maxZoom: finiteMaximumZoom(layers) }
+        ...finiteMaximumZoom(layers2) === void 0 ? {} : { maxZoom: finiteMaximumZoom(layers2) }
       },
       style: { appearance: paint, placement: layout }
     },
-    layers
+    layers2
   );
 }
-function consolidateRoadHatches(layers) {
+function consolidateRoadHatches(layers2) {
   const groups = /* @__PURE__ */ new Map();
-  for (const [index, layer] of layers.entries()) {
+  for (const [index, layer] of layers2.entries()) {
     if (layer.renderer !== "symbol" && layer.renderer !== "line" || layer.family?.kind !== "road-hatch") {
       continue;
     }
@@ -14971,7 +15608,7 @@ function consolidateRoadHatches(layers) {
       continue;
     }
     const mergedId = first.family.outputKey;
-    if (hasGeneratedKeyCollision(layers, mergedId, entries)) continue;
+    if (hasGeneratedKeyCollision(layers2, mergedId, entries)) continue;
     const conditions = entries.map(({ layer }) => asFilter(layer.selector));
     const sortKeyProperty = first.renderer === "line" ? "line-sort-key" : "symbol-sort-key";
     const layoutKeys = new Set(
@@ -15076,17 +15713,17 @@ function consolidateRoadHatches(layers) {
     for (const { index } of entries) replacements.set(index, []);
     replacements.set(entries.at(-1).index, [merged]);
   }
-  return applyReplacements(layers, replacements);
+  return applyReplacements(layers2, replacements);
 }
-function consolidateRoadLabels(layers) {
-  const candidates = layers.map((layer, index) => ({
+function consolidateRoadLabels(layers2) {
+  const candidates = layers2.map((layer, index) => ({
     index,
     layer,
     roadClass: layer.family?.kind === "road-label" ? layer.family.member : void 0
   })).filter(
     ({ layer, roadClass }) => layer.renderer === "symbol" && roadClass !== void 0 && layer.feature?.dataLayer !== void 0
   );
-  if (candidates.some(({ layer }) => isOrderedRenderPass(layer))) return layers;
+  if (candidates.some(({ layer }) => isOrderedRenderPass(layer))) return layers2;
   const groups = /* @__PURE__ */ new Map();
   for (const candidate of candidates) {
     const { layer } = candidate;
@@ -15108,7 +15745,7 @@ function consolidateRoadLabels(layers) {
     if (!group.every(({ layer }) => sameTopLevelProperties(layer, first))) continue;
     const conditions = group.map(({ layer }) => asFilter(layer.selector));
     const key = group.some(({ roadClass }) => roadClass === "motorway") ? "labels.cohorts.roads.major" : group.some(({ roadClass }) => roadClass === "service") ? "labels.cohorts.roads.local" : `labels.cohorts.roads.cohort${groupNumber++}`;
-    if (hasGeneratedKeyCollision(layers, key, group)) continue;
+    if (hasGeneratedKeyCollision(layers2, key, group)) continue;
     const layout = { ...first.style.placement ?? {} };
     const sortKeyValues = group.map(({ layer }, index) => {
       const original = layer.style.placement?.["symbol-sort-key"] ?? 0;
@@ -15133,13 +15770,13 @@ function consolidateRoadLabels(layers) {
     for (const { index } of group) replacements.set(index, []);
     replacements.set(group.at(-1).index, [merged]);
   }
-  return applyReplacements(layers, replacements);
+  return applyReplacements(layers2, replacements);
 }
-function consolidateFillFamily(layers, group, mergedId) {
-  const candidates = layers.map((layer, index) => ({ index, layer })).filter(
+function consolidateFillFamily(layers2, group, mergedId) {
+  const candidates = layers2.map((layer, index) => ({ index, layer })).filter(
     ({ layer }) => layer.renderer === "fill" && layer.family?.kind === "fill" && layer.family.group === group
   );
-  if (candidates.some(({ layer }) => isOrderedRenderPass(layer))) return layers;
+  if (candidates.some(({ layer }) => isOrderedRenderPass(layer))) return layers2;
   const groups = /* @__PURE__ */ new Map();
   for (const candidate of candidates) {
     const { layer } = candidate;
@@ -15211,7 +15848,7 @@ function consolidateFillFamily(layers, group, mergedId) {
       if (!sortKey.ok) continue;
       layout["fill-sort-key"] = sortKey.value;
       const key = suffix === 0 ? mergedId : `${mergedId}.cohort${suffix}`;
-      if (hasGeneratedKeyCollision(layers, key, group2)) continue;
+      if (hasGeneratedKeyCollision(layers2, key, group2)) continue;
       const merged = withMergedOrigins(
         {
           ...first,
@@ -15226,20 +15863,20 @@ function consolidateFillFamily(layers, group, mergedId) {
       replacements.set(group2.at(-1).index, [merged]);
     }
   }
-  return applyReplacements(layers, replacements);
+  return applyReplacements(layers2, replacements);
 }
-function consolidateWaterways(layers) {
+function consolidateWaterways(layers2) {
   const replacements = /* @__PURE__ */ new Map();
   for (const name of ["river", "canal", "stream", "other"]) {
-    const regularIndex = layers.findIndex(
+    const regularIndex = layers2.findIndex(
       (layer) => layer.family?.kind === "waterway" && layer.family.group === name && layer.family.variant === "regular"
     );
-    const intermittentIndex = layers.findIndex(
+    const intermittentIndex = layers2.findIndex(
       (layer) => layer.family?.kind === "waterway" && layer.family.group === name && layer.family.variant === "intermittent"
     );
     if (regularIndex < 0 || intermittentIndex < 0) continue;
-    const regular = layers[regularIndex];
-    const intermittent = layers[intermittentIndex];
+    const regular = layers2[regularIndex];
+    const intermittent = layers2[intermittentIndex];
     if (!sameLayerSource(regular, intermittent) || isOrderedRenderPass(regular) || isOrderedRenderPass(intermittent) || intermittentIndex !== regularIndex + 1 || minimumZoom(regular) !== minimumZoom(intermittent) || maximumZoom(regular) !== maximumZoom(intermittent) || !allEqual([regular.style.placement ?? {}, intermittent.style.placement ?? {}]) || !sameTopLevelProperties(regular, intermittent)) {
       continue;
     }
@@ -15298,7 +15935,7 @@ function consolidateWaterways(layers) {
     replacements.set(regularIndex, []);
     replacements.set(intermittentIndex, [merged]);
   }
-  return applyReplacements(layers, replacements);
+  return applyReplacements(layers2, replacements);
 }
 function combineConditionalValues(entries, fallback, minimumRelevantZoom) {
   if (entries.length === 0) return { ok: true, value: fallback };
@@ -15533,8 +16170,8 @@ function unionFilters(filters) {
 function asFilter(value) {
   return Array.isArray(value) ? value : ["literal", true];
 }
-function applyReplacements(layers, replacements) {
-  return layers.flatMap((layer, index) => replacements.get(index) ?? [layer]);
+function applyReplacements(layers2, replacements) {
+  return layers2.flatMap((layer, index) => replacements.get(index) ?? [layer]);
 }
 function sameLayerSource(left, right) {
   return allEqual([left.feature, right.feature]);
@@ -15572,9 +16209,9 @@ function contiguousRuns(entries) {
   }
   return runs;
 }
-function hasGeneratedKeyCollision(layers, key, entries) {
+function hasGeneratedKeyCollision(layers2, key, entries) {
   const members = new Set(entries.map(({ layer }) => layer));
-  return layers.some((layer) => layer.key === key && !members.has(layer));
+  return layers2.some((layer) => layer.key === key && !members.has(layer));
 }
 function withMaximumZoom(layer, maxzoom) {
   return {
@@ -15588,8 +16225,8 @@ function minimumZoom(layer) {
 function maximumZoom(layer) {
   return typeof layer.range?.maxZoom === "number" ? layer.range.maxZoom : Infinity;
 }
-function finiteMaximumZoom(layers) {
-  const maximum2 = Math.max(...layers.map(maximumZoom));
+function finiteMaximumZoom(layers2) {
+  const maximum2 = Math.max(...layers2.map(maximumZoom));
   return Number.isFinite(maximum2) ? maximum2 : void 0;
 }
 function cloneJson23(value) {
@@ -15613,7 +16250,7 @@ var colourSources = [
   ["tileflow-buildings-3d", "fill-extrusion-color"],
   ["tileflow-buildings-fill", "fill-color"]
 ];
-function tileflowBuildings3DDesignOf(module, context, layers, buildingModels, tileflowLandmarks) {
+function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, tileflowLandmarks) {
   const config = isRecord8(module) ? module : {};
   if (config.enabled === false) return void 0;
   const style = config.threeDimensional ?? {};
@@ -15621,10 +16258,10 @@ function tileflowBuildings3DDesignOf(module, context, layers, buildingModels, ti
   let color2;
   let verticalGradient = true;
   for (const [id2, property] of colourSources) {
-    const value = layers.find((layer) => layer.id === id2)?.paint?.[property];
+    const value = layers2.find((layer) => layer.id === id2)?.paint?.[property];
     if (typeof value === "string" || Array.isArray(value)) {
       color2 = value;
-      verticalGradient = layers.find((layer) => layer.id === id2)?.paint?.["fill-extrusion-vertical-gradient"] !== false;
+      verticalGradient = layers2.find((layer) => layer.id === id2)?.paint?.["fill-extrusion-vertical-gradient"] !== false;
       break;
     }
   }
@@ -15647,9 +16284,53 @@ function tileflowBuildings3DDesignOf(module, context, layers, buildingModels, ti
     edgeRadius: number(style.edgeRadius, defaults4.edgeRadius),
     ...typeof edgeColor === "string" ? { edgeColor } : {},
     nightLight: number(style.nightLight, 0),
+    ...isRecord8(style.floodLight) ? {
+      floodLight: readBuildingFloodLight({
+        ...style.floodLight,
+        intensity: number(style.floodLight.intensity, 0),
+        brightnessScale: number(style.floodLight.brightnessScale, 1),
+        color: style.floodLight.color === void 0 ? void 0 : toMapLibreStyleValue(style.floodLight.color)
+      })
+    } : {},
+    ...isRecord8(style.modelLighting) ? {
+      modelLighting: readModelRoleLighting(
+        Object.fromEntries(
+          Object.entries(style.modelLighting).filter(([, entry]) => isRecord8(entry)).map(([role, entry]) => {
+            const own = entry;
+            return [
+              role,
+              {
+                ...own,
+                emissiveStrength: number(own.emissiveStrength, 0),
+                ...Object.fromEntries(
+                  ["emissiveVariation", "colorMix", "metallic", "roughness"].filter((key) => own[key] !== void 0).map((key) => [key, number(own[key], 0)])
+                ),
+                ...Array.isArray(own.emissiveHeight) ? { emissiveHeight: own.emissiveHeight.map((v) => number(v, 0)) } : {},
+                ...isRecord8(own.colorVariation) ? {
+                  colorVariation: {
+                    ...own.colorVariation,
+                    ...Object.fromEntries(
+                      ["hue", "saturation", "lightness"].map((key) => [
+                        key,
+                        Array.isArray(
+                          own.colorVariation[key]
+                        ) ? own.colorVariation[key].map((v) => number(v, 0)) : []
+                      ])
+                    )
+                  }
+                } : {},
+                color: own.color === void 0 ? void 0 : toMapLibreStyleValue(own.color),
+                emissiveColor: own.emissiveColor === void 0 ? void 0 : toMapLibreStyleValue(own.emissiveColor)
+              }
+            ];
+          })
+        )
+      )
+    } : {},
     windows: style.windows === true,
     shadows: typeof style.shadows === "boolean" ? style.shadows : defaults4.shadows,
     occlusion: typeof style.occlusion === "boolean" ? style.occlusion : defaults4.occlusion,
+    modelOcclusion: number(style.modelOcclusion, defaults4.modelOcclusion),
     ...placedModels(style.models, buildingModels),
     ...modelColours(style.modelColors),
     ...landmarksOf(style.landmarks, tileflowLandmarks)
@@ -15694,9 +16375,9 @@ function modelColours(value) {
 }
 function tileflowStreetLightsDesignOf(module, context) {
   const config = isRecord8(module) ? module : {};
-  const layers = context.data.schema.layers;
+  const layers2 = context.data.schema.layers;
   const style = config.streetLights ?? {};
-  if (config.enabled === false || style.enabled !== true || !layers.streetFurniture)
+  if (config.enabled === false || style.enabled !== true || !layers2.streetFurniture)
     return void 0;
   const color2 = style.color === void 0 ? void 0 : toMapLibreStyleValue(style.color);
   const intensity = style.intensity === void 0 ? void 0 : toMapLibreStyleValue(style.intensity);
@@ -15704,9 +16385,9 @@ function tileflowStreetLightsDesignOf(module, context) {
   return {
     source: context.data.sourceId,
     layers: {
-      streetFurniture: layers.streetFurniture,
-      transportation: layers.road,
-      ...layers.sidewalk ? { sidewalk: layers.sidewalk } : {}
+      streetFurniture: layers2.streetFurniture,
+      transportation: layers2.road,
+      ...layers2.sidewalk ? { sidewalk: layers2.sidewalk } : {}
     },
     estimate: estimate === "streets" || estimate === "none" || estimate === "lit" ? estimate : "lit",
     color: typeof color2 === "string" ? color2 : tileflowDefaultStreetLightsDesign.color,
@@ -16047,11 +16728,11 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     "finalization",
     () => createTileflowOverlayPlacementManifest(plannedLayers)
   );
-  const layers = runCompilationPhase("finalization", () => finalizeTileflowLayers(plannedLayers));
+  const layers2 = runCompilationPhase("finalization", () => finalizeTileflowLayers(plannedLayers));
   const buildings3D = tileflowBuildings3DDesignOf(
     modules.buildings,
     context,
-    layers,
+    layers2,
     options.preparedAssets?.buildingModels,
     data.kind === "tileflow-world" ? `${apiBaseUrl}/landmarks/tiles.json` : void 0
   );
@@ -16061,11 +16742,11 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   );
   runCompilationPhase(
     "finalization",
-    () => assertTileflowInteractionManifestLayers(interactionManifest, layers)
+    () => assertTileflowInteractionManifestLayers(interactionManifest, layers2)
   );
   runCompilationPhase(
     "finalization",
-    () => assertTileflowOverlayPlacementManifestLayers(overlayPlacementManifest, layers)
+    () => assertTileflowOverlayPlacementManifestLayers(overlayPlacementManifest, layers2)
   );
   const glyphs = runCompilationPhase("assets", () => resolveGlyphs(config));
   const sprite = options.preparedAssets?.icons?.sprite;
@@ -16105,10 +16786,10 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       version: 8,
       name: config.name ?? "Streets",
       sources,
-      layers
+      layers: layers2
     })
   );
-  const flatVegetationLayers = layers.filter((layer) => {
+  const flatVegetationLayers = layers2.filter((layer) => {
     const metadata = layer.metadata;
     return metadata?.["tileflow:vegetation-mode"] !== void 0 || metadata?.["tileflow:domain"] === "vegetation";
   });
@@ -16127,6 +16808,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       layer.layout = { ...layer.layout, visibility: "none" };
   }
   const atmosphere = resolveTileflowAtmosphere(config.atmosphere);
+  const notices = compiledNotices(layers2, marine);
   const style = {
     ...atmosphere ? { sky: compileTileflowSky(atmosphere) } : {},
     version: 8,
@@ -16136,7 +16818,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     ...config.projection ? { projection: { type: config.projection } } : {},
     ...sprite ? { sprite } : {},
     sources,
-    layers,
+    layers: layers2,
     ...terrain?.mode === "3d" && terrain.raster ? { terrain: { exaggeration: terrain.exaggeration, source: terrain.raster.sourceId } } : {},
     metadata: {
       ...mapMetadata ? {
@@ -16176,7 +16858,8 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       ...interactionManifest ? { [tileflowInteractionManifestMetadataKey]: interactionManifest } : {},
       [tileflowOverlayPlacementManifestMetadataKey]: overlayPlacementManifest,
       "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord9(module) || module.enabled !== false).map(([name]) => name).sort(),
-      ...config.view ? { "tileflow:view": config.view } : {}
+      ...config.view ? { "tileflow:view": config.view } : {},
+      ...notices.length > 0 ? { [tileflowNoticesMetadataKey]: notices } : {}
     }
   };
   const report = {
@@ -16273,6 +16956,11 @@ function assertMapLibreStyle(style, mapId) {
 function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function compiledNotices(layers2, marine) {
+  const nautical2 = marine?.nautical?.sourceId;
+  if (!nautical2 || !layers2.some((layer) => layer.source === nautical2)) return [];
+  return [{ ...tileflowNauticalNotice, sources: [nautical2] }];
+}
 function resolveGlyphs(config) {
   if (config.fonts !== void 0) return void 0;
   return config.glyphs?.url;
@@ -16455,8 +17143,8 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record3 = isRecord9(error) ? error : {};
-  if (typeof record3.phase === "string") return error;
+  const record4 = isRecord9(error) ? error : {};
+  if (typeof record4.phase === "string") return error;
   if (error instanceof Error && Object.isExtensible(error)) {
     Object.defineProperty(error, "phase", { configurable: true, enumerable: true, value: phase });
     return error;
@@ -16472,7 +17160,7 @@ function withCompilationPhase(error, phase) {
     "severity",
     "target"
   ]) {
-    if (record3[key] !== void 0) Object.assign(wrapped, { [key]: record3[key] });
+    if (record4[key] !== void 0) Object.assign(wrapped, { [key]: record4[key] });
   }
   Object.assign(wrapped, { phase });
   return wrapped;
@@ -18251,9 +18939,9 @@ var tileflowNativeBuildRecordSchema = strictNativeObject({
   engines: strictNativeObject({ android: z13.literal("13.2.0"), ios: z13.literal("6.26.0") }),
   buildManifestSha256: hashSchema,
   transformations: z13.array(tileflowNativeStyleTransformationSchema).max(4096)
-}).superRefine((record3, context) => {
+}).superRefine((record4, context) => {
   let previous = "";
-  for (const [index, item] of record3.transformations.entries()) {
+  for (const [index, item] of record4.transformations.entries()) {
     const name = `${item.map}/${item.theme}`;
     if (name <= previous)
       context.addIssue({
@@ -26956,13 +27644,13 @@ function validateNativeStyle(input, options, stage) {
       issues.push(createTileflowNativeDiagnostic(code, path));
     }
   };
-  if (!record2(options) || !plainOptions(options)) {
+  if (!record3(options) || !plainOptions(options)) {
     return [createTileflowNativeDiagnostic("NATIVE_RENDERER_UNSUPPORTED", "/profile")];
   }
   if (options.profile !== void 0 && options.profile !== "native-v1" || !expressionDefinitions) {
     return [createTileflowNativeDiagnostic("NATIVE_RENDERER_UNSUPPORTED", "/profile")];
   }
-  if (!isBoundedNativeJson(input, stage) || !record2(input)) {
+  if (!isBoundedNativeJson(input, stage) || !record3(input)) {
     return [createTileflowNativeDiagnostic("NATIVE_UNSUPPORTED_STYLE")];
   }
   const style = input;
@@ -26976,11 +27664,11 @@ function validateNativeStyle(input, options, stage) {
   }
   if (style.projection !== void 0) {
     const projection = style.projection;
-    if (!record2(projection) || projection.type !== "mercator" || Object.keys(projection).length !== 1) {
+    if (!record3(projection) || projection.type !== "mercator" || Object.keys(projection).length !== 1) {
       add2("NATIVE_UNSUPPORTED_STYLE", "/projection");
     }
   }
-  if (record2(style.metadata)) {
+  if (record3(style.metadata)) {
     for (const key of Object.keys(style.metadata).sort()) {
       if (/^tileflow:(?:contour|pmtiles)/iu.test(key)) {
         add2("NATIVE_UNSUPPORTED_SOURCE", nativePointer("/metadata", key));
@@ -27023,14 +27711,14 @@ function validateNativeStyle(input, options, stage) {
       add2("NATIVE_FONT_UNAVAILABLE", "/glyphs");
     } else checkUrl(style.glyphs, "/glyphs", "glyphs");
   }
-  const sources = record2(style.sources) ? style.sources : {};
+  const sources = record3(style.sources) ? style.sources : {};
   if (Object.keys(sources).length > tileflowNativeProfileLimits.maximumSources) {
     add2("NATIVE_UNSUPPORTED_SOURCE", "/sources");
   }
   for (const id2 of Object.keys(sources).sort().slice(0, tileflowNativeProfileLimits.maximumSources)) {
     const source = sources[id2];
     const path = nativePointer("/sources", id2);
-    if (!record2(source) || typeof source.type !== "string" || !sourceKinds.has(source.type)) {
+    if (!record3(source) || typeof source.type !== "string" || !sourceKinds.has(source.type)) {
       add2("NATIVE_UNSUPPORTED_SOURCE", path);
       continue;
     }
@@ -27042,7 +27730,7 @@ function validateNativeStyle(input, options, stage) {
       "NATIVE_UNSUPPORTED_SOURCE"
     );
     if (source.clusterProperties !== void 0) {
-      if (record2(source.clusterProperties)) {
+      if (record3(source.clusterProperties)) {
         for (const key of Object.keys(source.clusterProperties).sort()) {
           const values = source.clusterProperties[key];
           if (Array.isArray(values))
@@ -27068,7 +27756,7 @@ function validateNativeStyle(input, options, stage) {
   if (faces !== void 0) {
     const support = spec.$root?.["font-faces"]?.["sdk-support"]?.["basic functionality"];
     if (!support || !supportsBoth(support)) add2("NATIVE_FONT_UNAVAILABLE", "/font-faces");
-    if (!record2(faces) || Object.keys(faces).length > tileflowNativeProfileLimits.maximumFontFaces) {
+    if (!record3(faces) || Object.keys(faces).length > tileflowNativeProfileLimits.maximumFontFaces) {
       add2("NATIVE_FONT_UNAVAILABLE", "/font-faces");
     } else {
       for (const name of Object.keys(faces).sort()) {
@@ -27080,19 +27768,19 @@ function validateNativeStyle(input, options, stage) {
       }
     }
   }
-  const layers = Array.isArray(style.layers) ? style.layers : [];
-  if (layers.length > tileflowNativeProfileLimits.maximumLayers)
+  const layers2 = Array.isArray(style.layers) ? style.layers : [];
+  if (layers2.length > tileflowNativeProfileLimits.maximumLayers)
     add2("NATIVE_UNSUPPORTED_STYLE", "/layers");
-  layers.slice(0, tileflowNativeProfileLimits.maximumLayers).forEach((layer, i) => {
+  layers2.slice(0, tileflowNativeProfileLimits.maximumLayers).forEach((layer, i) => {
     const path = `/layers/${i}`;
-    if (!record2(layer) || typeof layer.type !== "string" || !layerKinds.has(layer.type) || layer.ref !== void 0) {
+    if (!record3(layer) || typeof layer.type !== "string" || !layerKinds.has(layer.type) || layer.ref !== void 0) {
       add2("NATIVE_UNSUPPORTED_STYLE", path);
       return;
     }
     properties(layer, spec.layer, path, add2);
     for (const group of ["layout", "paint"]) {
       const values = layer[group];
-      if (!record2(values)) continue;
+      if (!record3(values)) continue;
       properties(
         values,
         spec[`${group}_${layer.type}`],
@@ -27106,7 +27794,7 @@ function validateNativeStyle(input, options, stage) {
       }
     }
     expressions(layer.filter, `${path}/filter`, add2);
-    if (!options.deferFontClosure && record2(layer.layout) && layer.layout["text-field"] !== void 0) {
+    if (!options.deferFontClosure && record3(layer.layout) && layer.layout["text-field"] !== void 0) {
       const fonts = layer.layout["text-font"];
       if (style.glyphs === void 0) {
         if (!fontStackAvailable(fonts, faces))
@@ -27116,7 +27804,7 @@ function validateNativeStyle(input, options, stage) {
     }
   });
   for (const key of ["light", "transition"]) {
-    if (record2(style[key])) {
+    if (record3(style[key])) {
       properties(style[key], spec[key], `/${key}`, add2);
       for (const [property, value] of Object.entries(style[key]))
         expressions(value, nativePointer(`/${key}`, property), add2);
@@ -27149,7 +27837,7 @@ function properties(values, definitions, path, add2, code = "NATIVE_UNSUPPORTED_
     const basic = definition["sdk-support"]?.["basic functionality"];
     if (basic && !supportsBoth(basic)) add2(code, nativePointer(path, key));
     const value = values[key];
-    if (checkFeatureSupport && record2(value) && Object.hasOwn(value, "stops"))
+    if (checkFeatureSupport && record3(value) && Object.hasOwn(value, "stops"))
       add2(code, nativePointer(path, key));
     if (typeof value === "string") {
       const enumSupport = definition.values?.[value]?.["sdk-support"]?.["basic functionality"];
@@ -27175,7 +27863,7 @@ function expressions(value, path, add2) {
     if (index === 0) return;
     if (operator === "match" && index >= 2 && index < value.length - 1 && index % 2 === 0) return;
     if (operator.startsWith("interpolate") && index === 1) return;
-    if (record2(child)) {
+    if (record3(child)) {
       for (const key of Object.keys(child).sort())
         expressions(child[key], nativePointer(`${path}/${index}`, key), add2);
     } else expressions(child, `${path}/${index}`, add2);
@@ -27183,14 +27871,14 @@ function expressions(value, path, add2) {
 }
 function fontStackAvailable(value, faces) {
   const stack = Array.isArray(value) && value.length === 2 && value[0] === "literal" ? value[1] : value;
-  return Array.isArray(stack) && stack.length > 0 && record2(faces) && stack.every((name) => typeof name === "string" && Object.hasOwn(faces, name));
+  return Array.isArray(stack) && stack.length > 0 && record3(faces) && stack.every((name) => typeof name === "string" && Object.hasOwn(faces, name));
 }
 function inlineFontStacks(value, path, faces, add2) {
   if (!Array.isArray(value) || !isExpression(value) || value[0] === "literal") return;
   value.forEach((child, index) => {
     if (index === 0 || value[0] === "match" && index >= 2 && index < value.length - 1 && index % 2 === 0)
       return;
-    if (value[0] === "format" && record2(child) && child["text-font"] !== void 0 && !fontStackAvailable(child["text-font"], faces)) {
+    if (value[0] === "format" && record3(child) && child["text-font"] !== void 0 && !fontStackAvailable(child["text-font"], faces)) {
       add2("NATIVE_FONT_UNAVAILABLE", `${path}/${index}/text-font`);
     }
     inlineFontStacks(child, `${path}/${index}`, faces, add2);
@@ -27207,7 +27895,7 @@ function parserIssuePointer(key, style) {
       path = nativePointer(path, match3[1]);
       value = value[Number(match3[1])];
       rest = rest.slice(match3[0].length).replace(/^\./u, "");
-    } else if (record2(value)) {
+    } else if (record3(value)) {
       const matches = Object.keys(value).filter(
         (name2) => rest === name2 || rest.startsWith(`${name2}.`) || rest.startsWith(`${name2}[`)
       );
@@ -27238,7 +27926,7 @@ function plainOptions(value) {
     return false;
   }
 }
-function record2(value) {
+function record3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function normalizeNativeDiagnostics(input) {
@@ -27528,15 +28216,15 @@ function semanticIdentity(style) {
   const candidate = object(style.metadata)?.["tileflow:interaction-manifest"];
   if (candidate === void 0) return void 0;
   const manifest = semanticSchema.parse(candidate);
-  const layers = style.layers.map((value) => {
+  const layers2 = style.layers.map((value) => {
     const layer = object(value);
     if (!layer) throw new Error();
     return layer;
   });
-  assertTileflowInteractionManifestLayers(manifest, layers);
+  assertTileflowInteractionManifestLayers(manifest, layers2);
   const seen = /* @__PURE__ */ new Set();
   for (const layer of manifest.domains.poi?.layers ?? []) {
-    if (seen.has(layer.layerId) || layers[layer.priority]?.id !== layer.layerId) throw new Error();
+    if (seen.has(layer.layerId) || layers2[layer.priority]?.id !== layer.layerId) throw new Error();
     seen.add(layer.layerId);
   }
   const poi2 = manifest.domains.poi;