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

package/dist/index.js

@@ -13,6 +13,114 @@ var __export = (target, all2) => {
     __defProp(target, name, { get: all2[name], enumerable: true });
 };
 
+// src/theme-blend.ts
+function mixTileflowColours(from, to, t) {
+  const a = oklab(from);
+  const b = oklab(to);
+  if (!a || !b) return void 0;
+  return colourFromOklab(a.map((value, channel) => value + (b[channel] - value) * t));
+}
+function oklab(colour) {
+  const cached = oklabCache.get(colour);
+  if (cached !== void 0) return cached;
+  const rgba = parseColour(colour);
+  let result = null;
+  if (rgba) {
+    const [r, g, b] = rgba.slice(0, 3).map((channel) => {
+      const value = channel / 255;
+      return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+    });
+    const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+    const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+    const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+    result = [
+      0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+      1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+      0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+      rgba[3]
+    ];
+  }
+  if (oklabCache.size > 4096) oklabCache.clear();
+  oklabCache.set(colour, result);
+  return result;
+}
+function colourFromOklab([lightness, a, b, alpha2]) {
+  const l = (lightness + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (lightness - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (lightness - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  const [red, green, blue] = [
+    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  ].map((value) => {
+    const clamped = Math.min(1, Math.max(0, value));
+    const encoded = clamped <= 31308e-7 ? clamped * 12.92 : 1.055 * clamped ** (1 / 2.4) - 0.055;
+    return Math.round(encoded * 255);
+  });
+  return `rgba(${red}, ${green}, ${blue}, ${Number(alpha2.toFixed(3))})`;
+}
+function tileflowColourChannels(colour) {
+  const rgba = parseColour(colour);
+  if (!rgba) return null;
+  return [
+    Math.min(1, Math.max(0, rgba[0] / 255)),
+    Math.min(1, Math.max(0, rgba[1] / 255)),
+    Math.min(1, Math.max(0, rgba[2] / 255)),
+    Math.min(1, Math.max(0, rgba[3]))
+  ];
+}
+function parseColour(colour) {
+  const text = colour.trim().toLowerCase();
+  const hex = /^#([\da-f]{3,8})$/u.exec(text)?.[1];
+  if (hex && [3, 4, 6, 8].includes(hex.length)) {
+    const full = hex.length <= 4 ? [...hex].map((digit) => digit + digit).join("") : hex;
+    const channels = full.match(/../gu).map((pair) => Number.parseInt(pair, 16));
+    return [channels[0], channels[1], channels[2], channels.length > 3 ? channels[3] / 255 : 1];
+  }
+  const functional = /^(rgba?|hsla?)\(([^)]+)\)$/u.exec(text);
+  if (!functional) return null;
+  const parts = functional[2].split(/[\s,/]+/u).filter(Boolean);
+  if (parts.length < 3 || parts.length > 4) return null;
+  const alpha2 = parts[3] === void 0 ? 1 : parseUnit(parts[3], 1);
+  if (functional[1].startsWith("rgb")) {
+    const [r, g, b] = parts.slice(0, 3).map((part) => parseUnit(part, 255));
+    if ([r, g, b, alpha2].some((value) => value === null)) return null;
+    return [r, g, b, alpha2];
+  }
+  const hue = Number.parseFloat(parts[0]);
+  const saturation = parseUnit(parts[1], 1);
+  const light = parseUnit(parts[2], 1);
+  if (!Number.isFinite(hue) || saturation === null || light === null || alpha2 === null) return null;
+  const chroma = (1 - Math.abs(2 * light - 1)) * saturation;
+  const sector = (hue % 360 + 360) % 360 / 60;
+  const x = chroma * (1 - Math.abs(sector % 2 - 1));
+  const [r1, g1, b1] = sector < 1 ? [chroma, x, 0] : sector < 2 ? [x, chroma, 0] : sector < 3 ? [0, chroma, x] : sector < 4 ? [0, x, chroma] : sector < 5 ? [x, 0, chroma] : [chroma, 0, x];
+  const offset = light - chroma / 2;
+  return [(r1 + offset) * 255, (g1 + offset) * 255, (b1 + offset) * 255, alpha2];
+}
+function parseUnit(part, scale) {
+  const percentage = part.endsWith("%");
+  const value = Number.parseFloat(part);
+  if (!Number.isFinite(value)) return null;
+  return percentage ? value / 100 * scale : value;
+}
+var oklabCache;
+var init_theme_blend = __esm({
+  "src/theme-blend.ts"() {
+    "use strict";
+    oklabCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/camera-limits.ts
+var tileflowMaxPitch;
+var init_camera_limits = __esm({
+  "src/camera-limits.ts"() {
+    "use strict";
+    tileflowMaxPitch = 85;
+  }
+});
+
 // src/native-zod-object.ts
 import { z } from "zod";
 function strictNativeObject(shape) {
@@ -483,105 +591,6 @@ var init_operations = __esm({
   }
 });
 
-// src/theme-blend.ts
-function mixTileflowColours(from, to, t) {
-  const a = oklab(from);
-  const b = oklab(to);
-  if (!a || !b) return void 0;
-  return colourFromOklab(a.map((value, channel) => value + (b[channel] - value) * t));
-}
-function oklab(colour) {
-  const cached = oklabCache.get(colour);
-  if (cached !== void 0) return cached;
-  const rgba = parseColour(colour);
-  let result = null;
-  if (rgba) {
-    const [r, g, b] = rgba.slice(0, 3).map((channel) => {
-      const value = channel / 255;
-      return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
-    });
-    const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
-    const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
-    const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
-    result = [
-      0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
-      1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
-      0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
-      rgba[3]
-    ];
-  }
-  if (oklabCache.size > 4096) oklabCache.clear();
-  oklabCache.set(colour, result);
-  return result;
-}
-function colourFromOklab([lightness, a, b, alpha2]) {
-  const l = (lightness + 0.3963377774 * a + 0.2158037573 * b) ** 3;
-  const m = (lightness - 0.1055613458 * a - 0.0638541728 * b) ** 3;
-  const s = (lightness - 0.0894841775 * a - 1.291485548 * b) ** 3;
-  const [red, green, blue] = [
-    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
-    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
-    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
-  ].map((value) => {
-    const clamped = Math.min(1, Math.max(0, value));
-    const encoded = clamped <= 31308e-7 ? clamped * 12.92 : 1.055 * clamped ** (1 / 2.4) - 0.055;
-    return Math.round(encoded * 255);
-  });
-  return `rgba(${red}, ${green}, ${blue}, ${Number(alpha2.toFixed(3))})`;
-}
-function tileflowColourChannels(colour) {
-  const rgba = parseColour(colour);
-  if (!rgba) return null;
-  return [
-    Math.min(1, Math.max(0, rgba[0] / 255)),
-    Math.min(1, Math.max(0, rgba[1] / 255)),
-    Math.min(1, Math.max(0, rgba[2] / 255)),
-    Math.min(1, Math.max(0, rgba[3]))
-  ];
-}
-function parseColour(colour) {
-  const text = colour.trim().toLowerCase();
-  const hex = /^#([\da-f]{3,8})$/u.exec(text)?.[1];
-  if (hex && [3, 4, 6, 8].includes(hex.length)) {
-    const full = hex.length <= 4 ? [...hex].map((digit) => digit + digit).join("") : hex;
-    const channels = full.match(/../gu).map((pair) => Number.parseInt(pair, 16));
-    return [channels[0], channels[1], channels[2], channels.length > 3 ? channels[3] / 255 : 1];
-  }
-  const functional = /^(rgba?|hsla?)\(([^)]+)\)$/u.exec(text);
-  if (!functional) return null;
-  const parts = functional[2].split(/[\s,/]+/u).filter(Boolean);
-  if (parts.length < 3 || parts.length > 4) return null;
-  const alpha2 = parts[3] === void 0 ? 1 : parseUnit(parts[3], 1);
-  if (functional[1].startsWith("rgb")) {
-    const [r, g, b] = parts.slice(0, 3).map((part) => parseUnit(part, 255));
-    if ([r, g, b, alpha2].some((value) => value === null)) return null;
-    return [r, g, b, alpha2];
-  }
-  const hue = Number.parseFloat(parts[0]);
-  const saturation = parseUnit(parts[1], 1);
-  const light = parseUnit(parts[2], 1);
-  if (!Number.isFinite(hue) || saturation === null || light === null || alpha2 === null) return null;
-  const chroma = (1 - Math.abs(2 * light - 1)) * saturation;
-  const sector = (hue % 360 + 360) % 360 / 60;
-  const x = chroma * (1 - Math.abs(sector % 2 - 1));
-  const [r1, g1, b1] = sector < 1 ? [chroma, x, 0] : sector < 2 ? [x, chroma, 0] : sector < 3 ? [0, chroma, x] : sector < 4 ? [0, x, chroma] : sector < 5 ? [x, 0, chroma] : [chroma, 0, x];
-  const offset = light - chroma / 2;
-  return [(r1 + offset) * 255, (g1 + offset) * 255, (b1 + offset) * 255, alpha2];
-}
-function parseUnit(part, scale) {
-  const percentage = part.endsWith("%");
-  const value = Number.parseFloat(part);
-  if (!Number.isFinite(value)) return null;
-  return percentage ? value / 100 * scale : value;
-}
-var oklabCache;
-var init_theme_blend = __esm({
-  "src/theme-blend.ts"() {
-    "use strict";
-    oklabCache = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/sun.ts
 function normalizeTileflowAzimuth(azimuth) {
   const turned = azimuth % 360;
@@ -705,9 +714,9 @@ function tileflowSunMetadata(preset) {
   return Object.freeze({ version: 1, ...preset });
 }
 function readTileflowSunPreset(metadata) {
-  if (!isRecord4(metadata)) return void 0;
+  if (!isRecord5(metadata)) return void 0;
   const value = metadata[tileflowSunMetadataKey];
-  if (!isRecord4(value) || value.version !== 1 || !isRecord4(value.ambient)) return void 0;
+  if (!isRecord5(value) || value.version !== 1 || !isRecord5(value.ambient)) return void 0;
   const { azimuth, altitude, color: color3, intensity, shadowIntensity } = value;
   const ambient = value.ambient;
   if (!isFiniteNumber(azimuth) || !isFiniteNumber(altitude) || !isUnit(intensity) || !isUnit(shadowIntensity) || !isUnit(ambient.intensity) || !isColour(color3) || !isColour(ambient.color))
@@ -724,7 +733,7 @@ function readTileflowSunPreset(metadata) {
 function tileflowStyleSunPreset(style) {
   const published = readTileflowSunPreset(style?.metadata);
   if (published) return published;
-  const light = isRecord4(style?.light) ? style.light : void 0;
+  const light = isRecord5(style?.light) ? style.light : void 0;
   const position = light?.position;
   if (!position) return tileflowDefaultSunPreset;
   return Object.freeze({
@@ -762,7 +771,7 @@ function smoothstep2(from, to, value) {
 function clamp01(value) {
   return Math.min(1, Math.max(0, Number.isFinite(value) ? value : 0));
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isFiniteNumber(value) {
@@ -850,8 +859,11 @@ var init_time_of_day = __esm({
 });
 
 // src/themes/visual-semantics.ts
+function isTileflowVisualColorCollection(property) {
+  return property === "colors" || property.endsWith("Colors") || property.endsWith("-colors");
+}
 function classifyTileflowVisualProperty(property, _value) {
-  if (property === "color" || property === "colors" || property.endsWith("Color") || property.endsWith("Colors") || property.endsWith("-color") || property.endsWith("-colors")) {
+  if (property === "color" || property.endsWith("Color") || property.endsWith("-color") || isTileflowVisualColorCollection(property)) {
     return "color";
   }
   if (property === "font" || property === "fallbacks" || property.endsWith("-font")) return "font";
@@ -878,6 +890,7 @@ var init_visual_semantics = __esm({
       "colorMix",
       "metallic",
       "roughness",
+      "horizonBlend",
       "hue",
       "saturation",
       "lightness",
@@ -905,6 +918,7 @@ var init_visual_semantics = __esm({
       "roundLimit",
       "size",
       "spacing",
+      "starIntensity",
       "strokeOpacity",
       "strokeWidth",
       "textFitPadding",
@@ -1075,7 +1089,7 @@ function auditTileflowThemeValues(value, path = "value", context = inferAuditCon
   return diagnostics.sort(compareAuditDiagnostics);
 }
 function auditTileflowMapThemeValues(map) {
-  const modules = isRecord5(map.modules) ? map.modules : void 0;
+  const modules = isRecord6(map.modules) ? map.modules : void 0;
   const moduleDiagnostics = modules ? Object.keys(modules).sort(compareCodeUnits2).flatMap(
     (owner) => auditTileflowThemeValues(modules[owner], `modules.${owner}`, {
       owner,
@@ -1182,7 +1196,7 @@ function isThemePrimitiveForCategory(value, category) {
   return category === "number" ? typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every((entry) => typeof entry === "number" && Number.isFinite(entry)) : typeof value === "string" && value.length > 0;
 }
 function isThemeValueCandidate(value) {
-  return isRecord5(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
+  return isRecord6(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
 }
 function visitAuditableValue(value, path, category, state, intentRequired = false) {
   if (isThemeStructuralPath(path)) category = void 0;
@@ -1198,7 +1212,7 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     visitAuditableArray(value, path, category, state, false, intentRequired);
     return;
   }
-  if (!isRecord5(value)) return;
+  if (!isRecord6(value)) return;
   if (value.kind === "expression" && Array.isArray(value.value)) {
     visitAuditableArray(value.value, `${path}.value`, category, state, true, intentRequired);
     return;
@@ -1218,15 +1232,19 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     }
     return;
   }
+  const collectionCategory = isTileflowVisualColorCollection(lastPathKey(path)) ? category : void 0;
   for (const key of Object.keys(value).sort(compareCodeUnits2)) {
     visitAuditableValue(
       value[key],
       `${path}.${key}`,
-      classifyTileflowVisualProperty(key, value[key]),
+      classifyTileflowVisualProperty(key, value[key]) ?? collectionCategory,
       state
     );
   }
 }
+function lastPathKey(path) {
+  return path.endsWith("]") ? "" : path.slice(path.lastIndexOf(".") + 1);
+}
 function visitAuditableArray(value, path, category, state, forceExpression = false, intentRequired = false) {
   const operator = typeof value[0] === "string" ? value[0] : void 0;
   const isExpression = forceExpression || isMapLibreExpressionOperator(operator);
@@ -1583,7 +1601,7 @@ function assertThemeLighting(value, path, allowReset = false) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord5(value)) {
+  if (!isRecord6(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -1948,11 +1966,11 @@ function cloneJson14(value) {
   if (serialized === void 0) throw new Error("Tileflow themes must be JSON-serializable.");
   return JSON.parse(serialized);
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord2(value) {
-  if (!isRecord5(value)) return false;
+  if (!isRecord6(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -2067,7 +2085,7 @@ var init_model = __esm({
         if (Array.isArray(value)) {
           return value.map((entry, index) => this.resolveTree(entry, `${path}[${index}]`, category));
         }
-        if (!isRecord5(value)) return value;
+        if (!isRecord6(value)) return value;
         if (value.kind === "expression" && Array.isArray(value.value)) {
           return {
             ...value,
@@ -2326,13 +2344,14 @@ function createTileflowRuntimeViewSchema(operations2) {
     center: operations2.optional(
       operations2.tuplePair(operations2.number(-180, 180), operations2.number(-90, 90))
     ),
-    pitch: operations2.optional(operations2.number(0, 85)),
+    pitch: operations2.optional(operations2.number(0, tileflowMaxPitch)),
     zoom: operations2.optional(operations2.number(0, 24))
   });
 }
 var init_runtime_view_schema = __esm({
   "src/runtime-view-schema.ts"() {
     "use strict";
+    init_camera_limits();
   }
 });
 
@@ -2902,8 +2921,68 @@ var init_meshopt_decoder = __esm({
   }
 });
 
+// src/sky.ts
+init_theme_blend();
+var tileflowSkyMetadataKey = "tileflow:sky";
+var hexColour = /^#[0-9a-f]{6}$/iu;
+var unit = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+function readColours(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record3 = value;
+  if (Object.keys(record3).length !== 4) return void 0;
+  const { color: color3, horizonColor, horizonBlend, glowColor } = record3;
+  if (typeof color3 !== "string" || !hexColour.test(color3) || typeof horizonColor !== "string" || !hexColour.test(horizonColor) || typeof glowColor !== "string" || !hexColour.test(glowColor) || !unit(horizonBlend))
+    return void 0;
+  return { color: color3, horizonColor, horizonBlend, glowColor };
+}
+function readTileflowSky(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record3 = value;
+  const keys = Object.keys(record3);
+  if (record3.version !== 1 || keys.length !== (record3.timesOfDay === void 0 ? 3 : 4))
+    return void 0;
+  const { starIntensity, glowColor, timesOfDay } = record3;
+  if (!unit(starIntensity) || typeof glowColor !== "string" || !hexColour.test(glowColor))
+    return void 0;
+  if (timesOfDay === void 0) return { version: 1, starIntensity, glowColor };
+  if (!timesOfDay || typeof timesOfDay !== "object" || Array.isArray(timesOfDay)) return void 0;
+  const times = timesOfDay;
+  if (Object.keys(times).length !== 4) return void 0;
+  const day = readColours(times.day);
+  const dawn = readColours(times.dawn);
+  const dusk = readColours(times.dusk);
+  const night = readColours(times.night);
+  if (!day || !dawn || !dusk || !night) return void 0;
+  return { version: 1, starIntensity, glowColor, timesOfDay: { day, dawn, dusk, night } };
+}
+var smooth = (from, to, value) => {
+  const t = Math.min(1, Math.max(0, (value - from) / (to - from)));
+  return t * t * (3 - 2 * t);
+};
+function mixColours(from, to, t) {
+  if (t <= 0) return from;
+  if (t >= 1) return to;
+  return {
+    color: mixTileflowColours(from.color, to.color, t) ?? to.color,
+    horizonColor: mixTileflowColours(from.horizonColor, to.horizonColor, t) ?? to.horizonColor,
+    horizonBlend: from.horizonBlend + (to.horizonBlend - from.horizonBlend) * t,
+    glowColor: mixTileflowColours(from.glowColor, to.glowColor, t) ?? to.glowColor
+  };
+}
+function tileflowSkyAtSun(times, sun) {
+  const azimuth = (sun.azimuth % 360 + 360) % 360;
+  const twilight = azimuth < 180 ? times.dawn : times.dusk;
+  if (sun.altitude >= 2) return mixColours(twilight, times.day, smooth(2, 14, sun.altitude));
+  if (sun.altitude >= -2) return twilight;
+  return mixColours(times.night, twilight, smooth(-10, -2, sun.altitude));
+}
+
+// src/index.ts
+init_camera_limits();
+
 // src/capture-scene.ts
 init_portable_identity();
+init_camera_limits();
 import { z as z3 } from "zod";
 var tileflowCaptureSceneSchemaVersion = 1;
 var tileflowCaptureSceneLimits = Object.freeze({
@@ -2911,7 +2990,7 @@ var tileflowCaptureSceneLimits = Object.freeze({
   boundsPadding: { maximum: 1024, minimum: 0 },
   captureIdLength: tileflowPortableIdMaximumLength,
   maximumPhysicalPixels: 16777216,
-  pitch: { maximum: 85, minimum: 0 },
+  pitch: { maximum: tileflowMaxPitch, minimum: 0 },
   selectorLength: 256,
   viewport: { maximum: 4096, minimum: 64 },
   zoom: { maximum: 24, minimum: 0 }
@@ -3395,14 +3474,7 @@ var defaults = {
 function resolveTileflowAtmosphere(value) {
   if (!value) return void 0;
   const options = { ...defaults, ...value === true ? {} : value };
-  const normalize2 = (input) => {
-    const color3 = typeof input === "string" ? Color.parse(input) : void 0;
-    if (!color3 || color3.a !== 1)
-      throw new Error("Atmosphere colors must resolve to opaque colors.");
-    return `#${[color3.r, color3.g, color3.b].map(
-      (channel) => Math.round(channel * 255).toString(16).padStart(2, "0")
-    ).join("")}`;
-  };
+  const normalize2 = (input) => opaqueHex(input, "Atmosphere colors");
   return {
     ...options,
     skyColor: normalize2(options.skyColor),
@@ -3411,6 +3483,13 @@ function resolveTileflowAtmosphere(value) {
     spaceColor: normalize2(options.spaceColor)
   };
 }
+function opaqueHex(input, subject) {
+  const color3 = typeof input === "string" ? Color.parse(input) : void 0;
+  if (!color3 || color3.a !== 1) throw new Error(`${subject} must resolve to opaque colors.`);
+  return `#${[color3.r, color3.g, color3.b].map(
+    (channel) => Math.round(channel * 255).toString(16).padStart(2, "0")
+  ).join("")}`;
+}
 function compileTileflowSky(options) {
   return {
     "sky-color": options.skyColor,
@@ -3422,6 +3501,41 @@ function compileTileflowSky(options) {
     "atmosphere-blend": ["interpolate", ["linear"], ["zoom"], 0, 0.55, 3, 0.45, 5, 0.2, 7, 0]
   };
 }
+var skyDefaults = {
+  color: "#5c9ce6",
+  horizonColor: "#dcebf7",
+  horizonBlend: 0.6,
+  glowColor: "#ffc68a",
+  starIntensity: 0.6
+};
+function resolveTileflowSky(value) {
+  if (!value) return void 0;
+  const options = { ...skyDefaults, ...value === true ? {} : value };
+  const unit2 = (input, name) => {
+    if (typeof input !== "number" || !Number.isFinite(input) || input < 0 || input > 1)
+      throw new Error(`Sky ${name} must resolve to a number from 0 to 1.`);
+    return input;
+  };
+  return {
+    color: opaqueHex(options.color, "Sky colors"),
+    horizonColor: opaqueHex(options.horizonColor, "Sky colors"),
+    horizonBlend: unit2(options.horizonBlend, "horizonBlend"),
+    glowColor: opaqueHex(options.glowColor, "Sky colors"),
+    starIntensity: unit2(options.starIntensity, "starIntensity")
+  };
+}
+function compileTileflowStreetSky(options) {
+  return {
+    "sky-color": options.color,
+    "horizon-color": options.horizonColor,
+    // MapLibre fogs only 3D terrain; the haze matches the horizon so terrain meets the sky.
+    "fog-color": options.horizonColor,
+    "sky-horizon-blend": options.horizonBlend,
+    "horizon-fog-blend": 0.6,
+    "fog-ground-blend": 0.75,
+    "atmosphere-blend": ["interpolate", ["linear"], ["zoom"], 0, 0.55, 3, 0.45, 5, 0.2, 7, 0]
+  };
+}
 
 // src/models-3d-model.ts
 var tileflowModelParts = Object.freeze({
@@ -3655,6 +3769,7 @@ function readTileflowBuildings3D(metadata) {
     ...floodLight ? { floodLight } : {},
     ...modelLighting ? { modelLighting } : {},
     windows: value.windows === true,
+    ...readTileflowBuildingsEntrance(value.entrance),
     shadows: typeof value.shadows === "boolean" ? value.shadows : defaults4.shadows,
     occlusion: typeof value.occlusion === "boolean" ? value.occlusion : defaults4.occlusion,
     modelOcclusion: within(value.modelOcclusion, 1, defaults4.modelOcclusion),
@@ -3663,6 +3778,13 @@ function readTileflowBuildings3D(metadata) {
     ...landmarksOf(value.landmarks)
   };
 }
+function readTileflowBuildingsEntrance(value) {
+  if (!isRecord(value)) return {};
+  const band = (entry) => Array.isArray(entry) && entry.length === 2 && entry.every((zoom3) => typeof zoom3 === "number" && zoom3 >= 0 && zoom3 <= 24) && entry[0] < entry[1] ? [entry[0], entry[1]] : void 0;
+  const buildings2 = band(value.buildings);
+  const models = band(value.models);
+  return buildings2 || models ? { entrance: { ...buildings2 ? { buildings: buildings2 } : {}, ...models ? { models } : {} } } : {};
+}
 var modelId = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 var tileflowBuildingModelPlacementLimit = 256;
 var teamModelPrefix = "tileflow://team-models/";
@@ -3872,6 +3994,7 @@ function tileflowWorldV1Schema(options = {}) {
       sidewalk: "sidewalk",
       streetFurniture: "street_furniture",
       trafficControl: "traffic_control",
+      transportationOutline: "transportation_outline",
       ...options.layers
     },
     semantics: { ...options.semantics, parkLayer: "protected-only" }
@@ -3891,6 +4014,11 @@ function validateTileflowWorldV1Tilejson(tilejson, schema = tileflowWorldV1Schem
   const roadShield = requireTilejsonLayer(layers2, schema.layers.roadShield, issues);
   const canopy = optionalTilejsonLayer(layers2, schema.layers.canopy, issues);
   const trafficControl = optionalTilejsonLayer(layers2, schema.layers.trafficControl, issues);
+  const transportationOutline = requireTilejsonLayer(
+    layers2,
+    schema.layers.transportationOutline,
+    issues
+  );
   if (bathymetry2) {
     if (bathymetry2.minzoom !== 0 || bathymetry2.maxzoom !== 9) {
       issues.push(`Tileflow World V1 ${schema.layers.bathymetry} must declare z0-z9.`);
@@ -4081,6 +4209,27 @@ function validateTileflowWorldV1Tilejson(tilejson, schema = tileflowWorldV1Schem
       requireTilejsonField(canopy, schema.layers.canopy, field2, ["Number"], issues);
     }
   }
+  if (transportationOutline) {
+    if (transportationOutline.minzoom !== 13 || transportationOutline.maxzoom !== 15) {
+      issues.push(
+        `Tileflow World V1 ${schema.layers.transportationOutline} must declare native z13-z15.`
+      );
+    }
+    requireTilejsonField(
+      transportationOutline,
+      schema.layers.transportationOutline,
+      schema.fields.class,
+      ["String"],
+      issues
+    );
+    requireTilejsonField(
+      transportationOutline,
+      schema.layers.transportationOutline,
+      schema.fields.subclass,
+      ["String"],
+      issues
+    );
+  }
   return issues;
 }
 function requireTilejsonLayer(layers2, id2, issues) {
@@ -5045,7 +5194,7 @@ function applyLineStyle(layer, style) {
   const layout = { ...asRecord2(layer.layout) };
   setPaint(paint, "line-blur", style.blur);
   setPaint(paint, "line-color", style.color);
-  setPaint(paint, "line-dasharray", style.dash);
+  if (!isSolidDash(style.dash)) setPaint(paint, "line-dasharray", style.dash);
   setPaint(paint, "line-gap-width", style.gapWidth);
   setPaint(paint, "line-offset", style.offset);
   setPaint(paint, "line-opacity", style.opacity);
@@ -5289,6 +5438,12 @@ function withoutGovernedAllowOverlap(layout) {
   }
   return result;
 }
+function isSolidDash(value) {
+  if (value === void 0) return false;
+  const dash = toMapLibreStyleValue(value);
+  const array = Array.isArray(dash) && dash[0] === "literal" ? dash[1] : dash;
+  return Array.isArray(array) && array.length === 2 && array[0] === 1 && array[1] === 0;
+}
 function setPaint(paint, property, value) {
   if (value !== void 0) paint[property] = toMapLibreStyleValue(value);
 }
@@ -5816,6 +5971,21 @@ function compileBuildings(request, context) {
   }
   return contributions;
 }
+var buildingTargetsByMode = {
+  flat: ["buildings.flat.fill", "buildings.flat.outline"],
+  "3d": ["buildings.extrusion"]
+};
+function buildingTargetsOfOtherModes(request) {
+  const activeMode = request?.mode ?? "flat";
+  const targets = /* @__PURE__ */ new Map();
+  for (const [mode, modeTargets] of Object.entries(buildingTargetsByMode)) {
+    if (mode === activeMode) continue;
+    for (const target of modeTargets) {
+      targets.set(target, { activeMode, mode, owner: "buildings" });
+    }
+  }
+  return targets;
+}
 function buildingColorExpression(context) {
   const fields2 = context.data.schema.fields;
   const colors = context.colors.buildings;
@@ -5933,29 +6103,23 @@ function isTileflowPathRoadClass(roadClass) {
   return tileflowPathRoadClasses.includes(roadClass);
 }
 function tileflowRoadClassFilter(fields2, roadClass) {
+  const classes = tileflowRoadClassValues(roadClass);
   if (isTileflowPathRoadClass(roadClass)) {
     return [
       "all",
-      ["match", ["get", fields2.class], ["path", ...constructionClasses[roadClass]], true, false],
+      ["match", ["get", fields2.class], classes, true, false],
       ["match", ["get", fields2.subclass], pathSubclasses[roadClass], true, false]
     ];
   }
-  const classes = roadClass === "minor" ? [
-    "minor",
-    "residential",
-    "unclassified",
-    ...compatibleRoadClasses[roadClass] ?? [],
-    ...constructionClasses[roadClass]
-  ] : roadClass === "service" ? [
-    "service",
-    ...compatibleRoadClasses[roadClass] ?? [],
-    ...constructionClasses[roadClass]
-  ] : [
-    roadClass,
+  return ["match", ["get", fields2.class], classes, true, false];
+}
+function tileflowRoadClassValues(roadClass) {
+  if (isTileflowPathRoadClass(roadClass)) return ["path", ...constructionClasses[roadClass]];
+  return [
+    ...roadClass === "minor" ? ["minor", "residential", "unclassified"] : [roadClass],
     ...compatibleRoadClasses[roadClass] ?? [],
     ...constructionClasses[roadClass]
   ];
-  return ["match", ["get", fields2.class], classes, true, false];
 }
 
 // src/modules/roads/index.ts
@@ -7256,12 +7420,46 @@ var tileflowNauticalImageRoles = Object.freeze({
     port: "nautical.buoy.port",
     starboard: "nautical.buoy.starboard"
   }),
-  harbours: Object.freeze({ default: "nautical.harbour" }),
+  distanceMarks: Object.freeze({ default: "nautical.distance-mark" }),
+  /**
+   * A facility that lists several categories shows the first of `tileflowNauticalFacilityIcons`
+   * it lists; facilities without a variant token fall back to `nautical.facility`.
+   */
+  facilities: Object.freeze({
+    "boat-hoist": "nautical.facility.boat-hoist",
+    boatyard: "nautical.facility.boatyard",
+    default: "nautical.facility",
+    "fuel-station": "nautical.facility.fuel-station",
+    "pump-out": "nautical.facility.pump-out",
+    slipway: "nautical.facility.slipway",
+    "visitor-berth": "nautical.facility.visitor-berth",
+    "water-tap": "nautical.facility.water-tap"
+  }),
+  /** Harbours whose `subclass` lists a marina use `nautical.marina` when the theme declares it. */
+  harbours: Object.freeze({ default: "nautical.harbour", marina: "nautical.marina" }),
   lighthouses: Object.freeze({ default: "nautical.lighthouse" }),
   lights: Object.freeze({ default: "nautical.light" }),
+  /** Notice boards by function; a board without a variant token uses `nautical.notice`. */
+  notices: Object.freeze({
+    default: "nautical.notice",
+    information: "nautical.notice.information",
+    prohibition: "nautical.notice.prohibition",
+    recommendation: "nautical.notice.recommendation",
+    regulation: "nautical.notice.regulation",
+    restriction: "nautical.notice.restriction"
+  }),
   ports: Object.freeze({ default: "nautical.port" }),
   wrecks: Object.freeze({ default: "nautical.wreck" })
 });
+var tileflowNauticalFacilityIcons = Object.freeze([
+  "fuel-station",
+  "slipway",
+  "boat-hoist",
+  "pump-out",
+  "water-tap",
+  "visitor-berth",
+  "boatyard"
+]);
 var tileflowNauticalNotice = Object.freeze({
   id: "nautical-not-for-navigation",
   text: "Not for navigation"
@@ -7323,10 +7521,15 @@ var tileflowNauticalV1Schema = Object.freeze({
     country: "country",
     coverage: "coverage",
     depth: "depth",
+    distance: "distance",
+    distanceUnit: "distance_unit",
     edition: "edition",
     families: "families",
     group: "group",
     heightM: "height_m",
+    horizontalClearance: "horizontal_clearance",
+    impact: "impact",
+    information: "information",
     label: "label",
     licence: "licence",
     lit: "lit",
@@ -7344,6 +7547,7 @@ var tileflowNauticalV1Schema = Object.freeze({
     scale: "scale",
     sectorEnd: "sector_end",
     sectorStart: "sector_start",
+    sequence: "sequence",
     shape: "shape",
     size: "size",
     subclass: "subclass",
@@ -7351,6 +7555,10 @@ var tileflowNauticalV1Schema = Object.freeze({
     topmark: "topmark",
     unlocode: "unlocode",
     update: "update",
+    verticalClearance: "vertical_clearance",
+    verticalClearanceClosed: "vertical_clearance_closed",
+    verticalClearanceOpen: "vertical_clearance_open",
+    verticalClearanceSafe: "vertical_clearance_safe",
     waterLevel: "water_level"
   }),
   geometryTypes: Object.freeze({
@@ -7374,6 +7582,16 @@ var tileflowNauticalV1Schema = Object.freeze({
     wrecks: "wreck"
   }),
   product: "nautical-v1",
+  /**
+   * Known `provider` values and the `class` of their `coverage` cells. The source's TileJSON owns
+   * each provider's credit; the module never adds attribution.
+   */
+  providers: Object.freeze({
+    "nga-list-of-lights": "list",
+    "noaa-office-of-coast-survey": "chart",
+    openstreetmap: "community",
+    "usace-ienc": "chart"
+  }),
   schemaVersion: 1
 });
 var tileflowBathymetryNameLayerLimits = Object.freeze({ maxZoomRanges: 128 });
@@ -7461,8 +7679,11 @@ function resolveBathymetryRelief(style, apiBaseUrl) {
     style: cloneJson12(style)
   };
 }
+var tileflowNauticalPromoteId = Object.freeze({
+  [tileflowNauticalV1Schema.layers.lights]: tileflowNauticalV1Schema.fields.provenance
+});
 function resolveNauticalSource(config, apiBaseUrl) {
-  return resolveMarineSource({
+  const resolved = resolveMarineSource({
     config,
     defaultPath: "/tiles/nautical/tiles.json",
     defaultSourceId: tileflowNauticalSourceId,
@@ -7470,6 +7691,7 @@ function resolveNauticalSource(config, apiBaseUrl) {
     product: tileflowNauticalV1Schema.product,
     apiBaseUrl
   });
+  return { ...resolved, source: { ...resolved.source, promoteId: { ...tileflowNauticalPromoteId } } };
 }
 function resolveMarineSource(options) {
   const sourceId = validateSourceId(options.config.sourceId ?? options.defaultSourceId);
@@ -7531,6 +7753,85 @@ function cloneJson12(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
+// src/nautical-lights.ts
+var tileflowNauticalLightsMetadataKey = "tileflow:nautical-lights";
+var tileflowNauticalLightStates = Object.freeze({
+  /** Index of the colour shown, into the light's comma-separated `color` list. */
+  colour: "tileflowLightColour",
+  /** `1` while the light shines, `0` while it is eclipsed, in between for a fixed part. */
+  intensity: "tileflowLightIntensity"
+});
+var tileflowNauticalLightEclipseOpacity = 0.15;
+var tileflowNauticalLightsLimits = Object.freeze({ maxLayers: 16 });
+var identifierPattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u;
+var layerIdPattern = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/u;
+function readTileflowNauticalLights(metadata) {
+  if (!isRecord4(metadata)) return void 0;
+  const value = metadata[tileflowNauticalLightsMetadataKey];
+  if (!isRecord4(value) || value.version !== 1) return void 0;
+  const { layers: layers2, source, sourceLayer } = value;
+  if (typeof source !== "string" || !identifierPattern.test(source)) return void 0;
+  if (typeof sourceLayer !== "string" || !identifierPattern.test(sourceLayer)) return void 0;
+  if (!Array.isArray(layers2) || layers2.length === 0 || layers2.length > tileflowNauticalLightsLimits.maxLayers || !layers2.every((layer) => typeof layer === "string" && layerIdPattern.test(layer)) || new Set(layers2).size !== layers2.length) {
+    return void 0;
+  }
+  return Object.freeze({
+    layers: Object.freeze([...layers2]),
+    source,
+    sourceLayer,
+    version: 1
+  });
+}
+function declareTileflowNauticalLights(layers2, sourceId, sourceLayer) {
+  if (!sourceId) return void 0;
+  const ids = layers2.filter(
+    (layer) => layer.source === sourceId && layer["source-layer"] === sourceLayer && readsLightState(layer.paint)
+  ).map(({ id: id2 }) => id2).filter((id2) => typeof id2 === "string").slice(0, tileflowNauticalLightsLimits.maxLayers);
+  if (ids.length === 0) return void 0;
+  return { layers: ids, source: sourceId, sourceLayer, version: 1 };
+}
+function steadyTileflowNauticalLights(style) {
+  const declaration = isRecord4(style.metadata) ? readTileflowNauticalLights(style.metadata) : void 0;
+  const hasKey = isRecord4(style.metadata) && tileflowNauticalLightsMetadataKey in style.metadata;
+  if (!declaration && !hasKey) return style;
+  const metadata = { ...style.metadata };
+  delete metadata[tileflowNauticalLightsMetadataKey];
+  const layers2 = Array.isArray(style.layers) ? style.layers.map(
+    (layer) => isRecord4(layer) && isRecord4(layer.paint) && readsLightState(layer.paint) ? { ...layer, paint: steady(layer.paint) } : layer
+  ) : style.layers;
+  return { ...style, layers: layers2, metadata };
+}
+function tileflowNauticalLightStateRead(state, steadyValue) {
+  return ["number", ["feature-state", tileflowNauticalLightStates[state]], steadyValue];
+}
+var stateKeys = new Set(Object.values(tileflowNauticalLightStates));
+function readsLightState(value) {
+  if (!Array.isArray(value)) {
+    return isRecord4(value) ? Object.values(value).some(readsLightState) : false;
+  }
+  if (value[0] === "literal") return false;
+  if (value[0] === "feature-state" && typeof value[1] === "string" && stateKeys.has(value[1])) {
+    return true;
+  }
+  return value.some(readsLightState);
+}
+function steady(value) {
+  if (Array.isArray(value)) {
+    if (value[0] === "literal") return value;
+    if (value[0] === "number" && value.length === 3 && Array.isArray(value[1]) && value[1][0] === "feature-state" && typeof value[1][1] === "string" && stateKeys.has(value[1][1])) {
+      return value[2];
+    }
+    return value.map(steady);
+  }
+  if (isRecord4(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, steady(entry)]));
+  }
+  return value;
+}
+function isRecord4(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
 // src/modules/nautical/compiler.ts
 var { fields, layers } = tileflowNauticalV1Schema;
 var markColours = Object.freeze({
@@ -7573,6 +7874,24 @@ var operationalAreaClasses = [
 var routeClasses = ["route", "traffic-separation"];
 var cableClasses = ["cable", "cable-area", "pipeline", "pipeline-area"];
 var portSizes = ["large", "medium", "small", "very-small"];
+var ownAreaClasses = ["berth", "bridge", "facility", "harbour"];
+var ownAidClasses = ["distance-mark", "notice"];
+var marinaSubclasses = ["marina", "marina-no-facilities"];
+var noticeFunctionColours = Object.freeze({
+  information: markColours.blue,
+  prohibition: markColours.red,
+  recommendation: markColours.green,
+  regulation: markColours.red,
+  restriction: markColours.red
+});
+var distanceUnits = Object.freeze({
+  hectometres: "hm",
+  kilometres: "km",
+  metres: "m",
+  "nautical-miles": "NM",
+  "statute-miles": "mi"
+});
+var maxAlternatingColours = 3;
 function compileNautical(request, context) {
   const nauticalSource = context.marine?.nautical;
   if (!nauticalSource || request?.enabled === false) return [];
@@ -7603,10 +7922,30 @@ function compileNautical(request, context) {
   const belowLabel = { anchor: "top", offset: [0, 0.75], optional: true };
   const markColour = expression(colourMatch(firstColour(fields.color), markColours, ink));
   const markStroke = expression(colourMatch(secondColour(fields.color), markColours, ink));
+  const animateLights = request?.animateLights !== false;
   const flareColour = expression(
-    colourMatch(firstColour(fields.color), lightColours, lightColours.white)
+    colourMatch(
+      animateLights ? nthColour(fields.color, tileflowNauticalLightStateRead("colour", 0)) : firstColour(fields.color),
+      lightColours,
+      lightColours.white
+    )
   );
   const iconPaint = { color: markColour, haloColor: ink, haloWidth: 1 };
+  const noticeColours = [
+    "match",
+    ["get", fields.subclass],
+    ...Object.entries(noticeFunctionColours).flat(),
+    ink
+  ];
+  const noticeColour = expression(noticeColours);
+  const distanceOpacity = (installed, notInstalled) => expression([
+    "match",
+    ["get", fields.category],
+    "not-installed",
+    notInstalled,
+    installed
+  ]);
+  const isGuestBerth = listIncludes(fields.subclass, "guest");
   const defaults4 = {
     type: "nautical",
     enabled: true,
@@ -7697,6 +8036,60 @@ function compileNautical(request, context) {
         [14, 1.3]
       ])
     },
+    harbourAreas: {
+      fill: { color: ink, minZoom: 10, opacity: 0.05 },
+      outline: {
+        color: ink,
+        minZoom: 10,
+        opacity: zoom.linear([
+          [10, 0.35],
+          [14, 0.6]
+        ]),
+        width: zoom.linear([
+          [10, 0.5],
+          [16, 1]
+        ])
+      }
+    },
+    berths: {
+      fill: { color: ink, minZoom: 13, opacity: 0.06 },
+      outline: {
+        color: ink,
+        minZoom: 13,
+        opacity: expression(["case", isGuestBerth, 0.95, 0.5]),
+        width: expression([
+          "interpolate",
+          ["linear"],
+          ["zoom"],
+          13,
+          ["case", isGuestBerth, 1.2, 0.6],
+          16,
+          ["case", isGuestBerth, 2.4, 1.2]
+        ])
+      }
+    },
+    bridges: {
+      fill: { color: colors.land, minZoom: 12, opacity: 0.9 },
+      outline: {
+        color: ink,
+        minZoom: 12,
+        opacity: 0.85,
+        width: zoom.linear([
+          [12, 0.8],
+          [16, 1.8]
+        ])
+      }
+    },
+    overheadCables: {
+      color: accent,
+      dash: [6, 2, 1, 2],
+      minZoom: 10,
+      opacity: 0.75,
+      width: zoom.linear([
+        [10, 0.7],
+        [16, 1.3]
+      ])
+    },
     hazardAreas: {
       fill: { color: accent, minZoom: 10, opacity: 0.08 },
       outline: { color: accent, dash: [1, 1], minZoom: 10, opacity: 0.7, width: 0.8 }
@@ -7806,6 +8199,7 @@ function compileNautical(request, context) {
     harbours: {
       minZoom: 11,
       placement: "point",
+      ...rankPriority,
       ...images.harbours ? {
         icon: {
           color: ink,
@@ -7856,6 +8250,147 @@ function compileNautical(request, context) {
       },
       text: { ...markText, ...sideLabel, field: nameFrom(15), padding: 3, size: 9 }
     },
+    notices: {
+      minZoom: 12,
+      placement: "point",
+      ...rankPriority,
+      ...images.notices ? {
+        icon: {
+          color: noticeColour,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.notices,
+          padding: 1,
+          size: zoom.linear([
+            [12, 0.8],
+            [16, 1.2]
+          ])
+        }
+      } : {
+        marker: {
+          color: expression([
+            "match",
+            ["get", fields.subclass],
+            ["prohibition", "recommendation", "information"],
+            noticeColours,
+            halo
+          ]),
+          radius: zoom.linear([
+            [12, 1.8],
+            [16, 3.2]
+          ]),
+          strokeColor: expression([
+            "match",
+            ["get", fields.subclass],
+            ["prohibition", "recommendation", "information"],
+            halo,
+            noticeColours
+          ]),
+          strokeWidth: 1
+        }
+      },
+      text: {
+        ...markText,
+        ...sideLabel,
+        field: expression([
+          "step",
+          ["zoom"],
+          "",
+          14,
+          ["to-string", ["coalesce", ["get", fields.information], ""]]
+        ]),
+        padding: 2,
+        size: 9
+      }
+    },
+    distanceMarks: {
+      minZoom: 11,
+      placement: "point",
+      ...rankPriority,
+      ...images.distanceMarks ? {
+        icon: {
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.distanceMarks,
+          opacity: distanceOpacity(1, 0.6),
+          size: zoom.linear([
+            [11, 0.7],
+            [16, 1]
+          ])
+        }
+      } : {
+        marker: {
+          color: ink,
+          opacity: distanceOpacity(1, 0.6),
+          radius: zoom.linear([
+            [11, 1.2],
+            [16, 2.2]
+          ]),
+          strokeColor: halo,
+          strokeWidth: 0.8
+        }
+      },
+      text: {
+        ...markText,
+        ...sideLabel,
+        field: expression([
+          "step",
+          ["zoom"],
+          "",
+          13,
+          [
+            "case",
+            ["has", fields.distance],
+            [
+              "concat",
+              ["to-string", ["get", fields.distance]],
+              [
+                "match",
+                ["get", fields.distanceUnit],
+                ...Object.entries(distanceUnits).flatMap(([unit2, label]) => [unit2, ` ${label}`]),
+                ""
+              ]
+            ],
+            ""
+          ]
+        ]),
+        opacity: distanceOpacity(1, 0.75),
+        padding: 2,
+        size: zoom.linear([
+          [13, 8.5],
+          [16, 10]
+        ])
+      }
+    },
+    facilities: {
+      minZoom: 13,
+      placement: "point",
+      ...images.facilities ? {
+        icon: {
+          color: ink,
+          haloColor: halo,
+          haloWidth: 1,
+          image: images.facilities,
+          padding: 1,
+          size: zoom.linear([
+            [13, 0.8],
+            [16, 1.15]
+          ])
+        }
+      } : {
+        marker: {
+          color: halo,
+          radius: zoom.linear([
+            [13, 1.8],
+            [16, 3]
+          ]),
+          strokeColor: ink,
+          strokeWidth: 1
+        }
+      },
+      text: { ...markText, ...sideLabel, field: nameFrom(15), padding: 3, size: 9 }
+    },
     beacons: {
       minZoom: 11,
       placement: "point",
@@ -8038,6 +8573,32 @@ function compileNautical(request, context) {
       }
     },
     labels: {
+      bridges: {
+        minZoom: 13,
+        placement: "point",
+        text: {
+          ...markText,
+          field: expression(bridgeClearance()),
+          padding: 2,
+          size: zoom.linear([
+            [13, 8.5],
+            [16, 10]
+          ])
+        }
+      },
+      overheadCables: {
+        minZoom: 12,
+        placement: "point",
+        spacing: 360,
+        text: {
+          ...markText,
+          color: accent,
+          field: expression(cableClearance()),
+          maxAngle: 30,
+          padding: 2,
+          size: 8.5
+        }
+      },
       coverage: {
         maxZoom: 9,
         minZoom: 4,
@@ -8087,6 +8648,7 @@ function compileNautical(request, context) {
   const source = nauticalSource.sourceId;
   const contributions = [];
   const add2 = (options) => appendNauticalLayer(contributions, { ...options, source });
+  const ofClass = (value) => ["==", ["get", fields.class], value];
   add2({
     // Only coverage that speaks for every family; lists of lights alone would double the tint.
     filter: ["all", polygons, ["in", layers.aids, ["coalesce", ["get", fields.families], ""]]],
@@ -8097,13 +8659,30 @@ function compileNautical(request, context) {
     target: "nautical.coverage"
   });
   add2({
-    filter: polygons,
+    filter: ["all", polygons, ["match", ["get", fields.class], [...ownAreaClasses], false, true]],
     id: "tileflow-nautical-navigation-areas",
     localOrder: 390,
     sourceLayer: layers.navigationAreas,
     style: config.navigationAreas,
     target: "nautical.navigationAreas"
   });
+  add2({
+    filter: ["all", polygons, ofClass("harbour")],
+    id: "tileflow-nautical-harbour-areas",
+    localOrder: 392,
+    sourceLayer: layers.navigationAreas,
+    style: config.harbourAreas,
+    target: "nautical.harbourAreas"
+  });
+  add2({
+    filter: ["all", polygons, ofClass("berth")],
+    id: "tileflow-nautical-berths",
+    localOrder: 394,
+    outlineFilter: ["all", linesOrPolygons, ofClass("berth")],
+    sourceLayer: layers.navigationAreas,
+    style: config.berths,
+    target: "nautical.berths"
+  });
   add2({
     filter: polygons,
     id: "tileflow-nautical-reefs",
@@ -8130,11 +8709,20 @@ function compileNautical(request, context) {
     style: config.routes,
     target: "nautical.routes"
   });
+  add2({
+    filter: linesOf(["overhead-cable"]),
+    id: "tileflow-nautical-overhead-cables",
+    line: true,
+    localOrder: 408,
+    sourceLayer: layers.navigationAreas,
+    style: config.overheadCables,
+    target: "nautical.overheadCables"
+  });
   add2({
     filter: polygons,
     id: "tileflow-nautical-hazard-areas",
     localOrder: 410,
-    outlineFilter: ["match", ["geometry-type"], ["LineString", "Polygon"], true, false],
+    outlineFilter: linesOrPolygons,
     sourceLayer: layers.hazards,
     style: config.hazardAreas,
     target: "nautical.hazardAreas"
@@ -8147,15 +8735,42 @@ function compileNautical(request, context) {
     style: config.wreckAreas,
     target: "nautical.wreckAreas"
   });
-  for (const [key, id2, sourceLayer, localOrder] of [
-    ["coverage", "tileflow-nautical-coverage-labels", layers.coverage, 560],
-    ["navigationAreas", "tileflow-nautical-navigation-area-labels", layers.navigationAreas, 562],
-    ["reefs", "tileflow-nautical-reef-labels", layers.reefs, 564],
-    ["hazards", "tileflow-nautical-hazard-area-labels", layers.hazards, 566],
-    ["wrecks", "tileflow-nautical-wreck-area-labels", layers.wrecks, 568]
+  add2({
+    // Bridges draw over the water and the areas below them.
+    filter: ["all", polygons, ofClass("bridge")],
+    id: "tileflow-nautical-bridges",
+    localOrder: 424,
+    outlineFilter: ["all", linesOrPolygons, ofClass("bridge")],
+    sourceLayer: layers.navigationAreas,
+    style: config.bridges,
+    target: "nautical.bridges"
+  });
+  for (const [key, id2, sourceLayer, localOrder, filter] of [
+    [
+      "coverage",
+      "tileflow-nautical-coverage-labels",
+      layers.coverage,
+      560,
+      ["has", fields.provider]
+    ],
+    [
+      "navigationAreas",
+      "tileflow-nautical-navigation-area-labels",
+      layers.navigationAreas,
+      562,
+      // Harbours, facilities and bridges carry their own symbols and labels.
+      [
+        "all",
+        ["has", fields.name],
+        ["match", ["get", fields.class], ["bridge", "facility", "harbour"], false, true]
+      ]
+    ],
+    ["reefs", "tileflow-nautical-reef-labels", layers.reefs, 564, ["has", fields.name]],
+    ["hazards", "tileflow-nautical-hazard-area-labels", layers.hazards, 566, ["has", fields.name]],
+    ["wrecks", "tileflow-nautical-wreck-area-labels", layers.wrecks, 568, ["has", fields.name]]
   ]) {
     add2({
-      filter: ["all", polygons, ["has", key === "coverage" ? fields.provider : fields.name]],
+      filter: ["all", polygons, filter],
       id: id2,
       localOrder,
       sourceLayer,
@@ -8163,6 +8778,37 @@ function compileNautical(request, context) {
       target: `nautical.labels.${key}`
     });
   }
+  add2({
+    filter: [
+      "all",
+      ofClass("bridge"),
+      [
+        "any",
+        ["has", fields.verticalClearance],
+        ["has", fields.verticalClearanceClosed],
+        ["has", fields.verticalClearanceOpen]
+      ]
+    ],
+    id: "tileflow-nautical-bridge-labels",
+    lines: { localOrder: 557, placement: "line-center" },
+    localOrder: 556,
+    sourceLayer: layers.navigationAreas,
+    style: config.labels?.bridges,
+    target: "nautical.labels.bridges"
+  });
+  add2({
+    filter: [
+      "all",
+      ofClass("overhead-cable"),
+      ["any", ["has", fields.verticalClearanceSafe], ["has", fields.verticalClearance]]
+    ],
+    id: "tileflow-nautical-overhead-cable-labels",
+    lines: { localOrder: 559, placement: "line" },
+    localOrder: 558,
+    sourceLayer: layers.navigationAreas,
+    style: config.labels?.overheadCables,
+    target: "nautical.labels.overheadCables"
+  });
   add2({
     filter: ["all", points, ["has", fields.depth]],
     id: "tileflow-nautical-soundings",
@@ -8181,6 +8827,16 @@ function compileNautical(request, context) {
     symbolFilter: ["==", ["get", fields.class], "rock"],
     target: "nautical.hazards"
   });
+  add2({
+    filter: ofClass("facility"),
+    id: "tileflow-nautical-facilities",
+    lines: { localOrder: 580, placement: "line-center" },
+    localOrder: 576,
+    markerFilter: points,
+    sourceLayer: layers.navigationAreas,
+    style: config.facilities,
+    target: "nautical.facilities"
+  });
   add2({
     filter: points,
     id: "tileflow-nautical-wrecks",
@@ -8190,13 +8846,23 @@ function compileNautical(request, context) {
     target: "nautical.wrecks"
   });
   add2({
-    filter: ["all", points, ["==", ["get", fields.class], "harbour"]],
+    // Harbour polygons, such as marinas, carry their symbol and name at their centre.
+    filter: ["all", pointsOrPolygons, ofClass("harbour")],
     id: "tileflow-nautical-harbours",
     localOrder: 582,
+    markerFilter: points,
     sourceLayer: layers.navigationAreas,
     style: config.harbours,
     target: "nautical.harbours"
   });
+  add2({
+    filter: ["all", points, ofClass("distance-mark")],
+    id: "tileflow-nautical-distance-marks",
+    localOrder: 584,
+    sourceLayer: layers.aids,
+    style: config.distanceMarks,
+    target: "nautical.distanceMarks"
+  });
   add2({
     filter: [
       "all",
@@ -8204,7 +8870,7 @@ function compileNautical(request, context) {
       [
         "match",
         ["get", fields.class],
-        [...floatingAidClasses, ...fixedAidClasses, "lighthouse"],
+        [...floatingAidClasses, ...fixedAidClasses, ...ownAidClasses, "lighthouse"],
         false,
         true
       ]
@@ -8215,6 +8881,14 @@ function compileNautical(request, context) {
     style: config.aids,
     target: "nautical.aids"
   });
+  add2({
+    filter: ["all", points, ofClass("notice")],
+    id: "tileflow-nautical-notices",
+    localOrder: 588,
+    sourceLayer: layers.aids,
+    style: config.notices,
+    target: "nautical.notices"
+  });
   add2({
     filter: ["all", points, ["match", ["get", fields.class], [...fixedAidClasses], true, false]],
     id: "tileflow-nautical-beacons",
@@ -8225,6 +8899,7 @@ function compileNautical(request, context) {
   });
   add2({
     filter: points,
+    flash: animateLights,
     id: "tileflow-nautical-lights",
     localOrder: 594,
     sourceLayer: layers.lights,
@@ -8240,7 +8915,7 @@ function compileNautical(request, context) {
     target: "nautical.buoys"
   });
   add2({
-    filter: ["all", points, ["==", ["get", fields.class], "lighthouse"]],
+    filter: ["all", points, ofClass("lighthouse")],
     id: "tileflow-nautical-lighthouses",
     localOrder: 602,
     sourceLayer: layers.aids,
@@ -8248,7 +8923,7 @@ function compileNautical(request, context) {
     target: "nautical.lighthouses"
   });
   add2({
-    filter: ["all", points, ["==", ["get", fields.class], "port"]],
+    filter: ["all", points, ofClass("port")],
     id: "tileflow-nautical-ports",
     localOrder: 606,
     sourceLayer: layers.navigationAreas,
@@ -8259,12 +8934,14 @@ function compileNautical(request, context) {
 }
 var points = ["==", ["geometry-type"], "Point"];
 var polygons = ["==", ["geometry-type"], "Polygon"];
+var lines = ["==", ["geometry-type"], "LineString"];
+var pointsOrPolygons = ["match", ["geometry-type"], ["Point", "Polygon"], true, false];
+var linesOrPolygons = ["match", ["geometry-type"], ["LineString", "Polygon"], true, false];
 function linesOf(classes) {
-  return [
-    "all",
-    ["==", ["geometry-type"], "LineString"],
-    ["match", ["get", fields.class], [...classes], true, false]
-  ];
+  return ["all", lines, ["match", ["get", fields.class], [...classes], true, false]];
+}
+function listIncludes(field2, item) {
+  return ["in", `,${item},`, ["concat", ",", ["to-string", ["coalesce", ["get", field2], ""]], ","]];
 }
 var fromFeatureMinZoom = [">=", ["zoom"], ["to-number", ["get", fields.minZoom], 0]];
 function appendNauticalLayer(contributions, options) {
@@ -8321,24 +8998,25 @@ function appendNauticalLayer(contributions, options) {
   if (point.visible === false) return;
   const isLabel = options.target.startsWith("nautical.labels.");
   if (!isLabel && point.marker && point.marker.visible !== false) {
+    const marker = applyCircleStyle(
+      base(
+        `${options.id}-marker`,
+        "circle",
+        options.markerFilter ? ["all", options.filter, options.markerFilter] : options.filter
+      ),
+      mergeTileflowDesign(
+        {
+          ...point.maxZoom === void 0 ? {} : { maxZoom: point.maxZoom },
+          ...point.minZoom === void 0 ? {} : { minZoom: point.minZoom }
+        },
+        point.marker
+      )
+    );
     contributions.push(
       nauticalContribution(
         `${options.target}.marker`,
         options.localOrder,
-        applyCircleStyle(
-          base(
-            `${options.id}-marker`,
-            "circle",
-            options.markerFilter ? ["all", options.filter, options.markerFilter] : options.filter
-          ),
-          mergeTileflowDesign(
-            {
-              ...point.maxZoom === void 0 ? {} : { maxZoom: point.maxZoom },
-              ...point.minZoom === void 0 ? {} : { minZoom: point.minZoom }
-            },
-            point.marker
-          )
-        ),
+        options.flash ? flashing(marker, ["circle-opacity", "circle-stroke-opacity"]) : marker,
         "symbols"
       )
     );
@@ -8346,21 +9024,79 @@ function appendNauticalLayer(contributions, options) {
   const hasText = Boolean(point.text && point.text.visible !== false);
   const hasIcon = Boolean(point.icon && point.icon.visible !== false);
   if (!hasText && !hasIcon) return;
+  const symbolFilter = [
+    options.filter,
+    ...options.symbolFilter ? [options.symbolFilter] : [],
+    ...options.lines ? [["!=", ["geometry-type"], "LineString"]] : []
+  ];
+  const symbol = applySymbolStyle(
+    base(
+      options.id,
+      "symbol",
+      symbolFilter.length === 1 ? symbolFilter[0] : ["all", ...symbolFilter]
+    ),
+    withoutMarker(point)
+  );
   contributions.push(
     nauticalContribution(
       isLabel ? options.target : `${options.target}.symbol`,
       options.localOrder + (isLabel ? 0 : 1),
-      applySymbolStyle(
-        base(
-          options.id,
-          "symbol",
-          options.symbolFilter ? ["all", options.filter, options.symbolFilter] : options.filter
-        ),
-        withoutMarker(point)
-      ),
+      options.flash && hasIcon ? flashing(symbol, ["icon-opacity"]) : symbol,
       "symbols"
     )
   );
+  if (options.lines) {
+    contributions.push(
+      nauticalContribution(
+        `${options.target}.lines`,
+        options.lines.localOrder,
+        applySymbolStyle(
+          base(`${options.id}-lines`, "symbol", [
+            "all",
+            options.filter,
+            ...options.symbolFilter ? [options.symbolFilter] : [],
+            lines
+          ]),
+          { ...withoutMarker(point), placement: options.lines.placement }
+        ),
+        "symbols"
+      )
+    );
+  }
+}
+function flashing(layer, properties) {
+  const paint = { ...layer.paint ?? {} };
+  const factor = [
+    "interpolate",
+    ["linear"],
+    tileflowNauticalLightStateRead("intensity", 1),
+    0,
+    tileflowNauticalLightEclipseOpacity,
+    1,
+    1
+  ];
+  for (const property of properties) {
+    const value = paint[property];
+    if (property !== "circle-opacity" && property !== "icon-opacity" && value === void 0) {
+      continue;
+    }
+    paint[property] = scaleOutputs(value ?? 1, factor);
+  }
+  return { ...layer, paint };
+}
+function scaleOutputs(value, factor) {
+  if (Array.isArray(value) && isZoomCurve(value)) {
+    const firstOutput = value[0] === "step" ? 2 : 4;
+    return value.map(
+      (entry, index) => index >= firstOutput && (index - firstOutput) % 2 === 0 ? ["*", entry, factor] : entry
+    );
+  }
+  return ["*", value, factor];
+}
+function isZoomCurve(value) {
+  const isZoom3 = (input) => Array.isArray(input) && input[0] === "zoom";
+  if (value[0] === "step") return isZoom3(value[1]);
+  return (value[0] === "interpolate" || value[0] === "interpolate-hcl" || value[0] === "interpolate-lab") && isZoom3(value[2]);
 }
 function withoutMarker(style) {
   const result = { ...style };
@@ -8397,8 +9133,96 @@ function themedImages(context) {
       ]
     ]);
   }
+  const notice = images.notices;
+  if (typeof notice === "string") {
+    const variants = ["information", "prohibition", "recommendation", "regulation", "restriction"].flatMap((role) => [role, context.images[roles.notices[role]] ?? notice]);
+    images.notices = expression(["match", ["get", fields.subclass], ...variants, notice]);
+  }
+  const facility = images.facilities;
+  if (typeof facility === "string") {
+    const cases = tileflowNauticalFacilityIcons.flatMap((category) => {
+      const image = context.images[roles.facilities[category]];
+      if (!image || image === facility) return [];
+      const categories = category === "visitor-berth" ? ["visitor-berth", "visitors-mooring"] : [category];
+      return [["any", ...categories.map((name) => listIncludes(fields.subclass, name))], image];
+    });
+    if (cases.length > 0) images.facilities = expression(["case", ...cases, facility]);
+  }
+  const harbour = images.harbours;
+  const marina = context.images[roles.harbours.marina];
+  if (typeof harbour === "string" && marina && marina !== harbour) {
+    images.harbours = expression([
+      "case",
+      ["any", ...marinaSubclasses.map((name) => listIncludes(fields.subclass, name))],
+      marina,
+      harbour
+    ]);
+  }
   return images;
 }
+function bridgeClearance() {
+  const metres = (field2) => ["concat", ["to-string", ["get", field2]], " m"];
+  const closed = fields.verticalClearanceClosed;
+  const open = fields.verticalClearanceOpen;
+  return [
+    "case",
+    ["any", ["has", closed], ["has", open]],
+    [
+      "concat",
+      ["case", ["has", closed], ["concat", "closed ", metres(closed)], ""],
+      ["case", ["all", ["has", closed], ["has", open]], " \xB7 ", ""],
+      ["case", ["has", open], ["concat", "open ", metres(open)], ""]
+    ],
+    ["has", fields.verticalClearance],
+    ["concat", "clearance ", metres(fields.verticalClearance)],
+    ""
+  ];
+}
+function cableClearance() {
+  return [
+    "case",
+    ["has", fields.verticalClearanceSafe],
+    ["concat", "safe clearance ", ["to-string", ["get", fields.verticalClearanceSafe]], " m"],
+    ["has", fields.verticalClearance],
+    ["concat", "clearance ", ["to-string", ["get", fields.verticalClearance]], " m"],
+    ""
+  ];
+}
+function nthColour(field2, index) {
+  const list = ["var", "nauticalColours"];
+  const cases = [];
+  for (let position = 1; position < maxAlternatingColours; position += 1) {
+    cases.push(["==", ["var", "nauticalColourIndex"], position], nthName(list, position));
+  }
+  return [
+    "let",
+    "nauticalColours",
+    ["to-string", ["coalesce", ["get", field2], ""]],
+    "nauticalColourIndex",
+    index,
+    ["case", ...cases, leadingName(list)]
+  ];
+}
+function nthName(list, position) {
+  if (position === 0) return leadingName(list);
+  const rest = `nauticalRest${position}`;
+  return [
+    "let",
+    rest,
+    [
+      "let",
+      "nauticalComma",
+      ["index-of", ",", list],
+      [
+        "case",
+        ["<", ["var", "nauticalComma"], 0],
+        "",
+        ["slice", list, ["+", ["var", "nauticalComma"], 1]]
+      ]
+    ],
+    nthName(["var", rest], position - 1)
+  ];
+}
 function firstColour(field2) {
   return [
     "let",
@@ -9689,35 +10513,37 @@ function compileRoundabouts(request, surfaces, context, contributions) {
     }),
     0
   ) : atZoom(borderWidth, level);
-  const geometry = (casing, width) => expression([
-    "interpolate",
-    ["exponential", 2],
-    ["zoom"],
-    ...geometryLevels.flatMap((level) => {
-      const centerline = ["*", radiusAt15, 2 ** (level - 15)];
-      const fallback = fallbackWidth === void 0 ? select(
-        widths.map(({ condition, value }) => ({ condition, value: atZoom(value, level) })),
-        0
-      ) : atZoom(fallbackWidth, level);
-      const inner = [
-        "case",
-        physical,
-        ["*", centerline, ["/", innerMeters, radiusMeters]],
-        ["-", centerline, ["/", fallback, 2]]
-      ];
-      const fillWidth = [
-        "case",
-        physical,
-        ["*", centerline, ["/", ["-", outerMeters, innerMeters], radiusMeters]],
-        fallback
-      ];
-      const border = casing ? borderAt(level) : 0;
-      return [
-        level,
-        width ? ["max", 0, ["+", fillWidth, border]] : ["max", 0, ["-", inner, ["/", border, 2]]]
-      ];
-    })
-  ]);
+  const geometry = (casing, width) => expression(
+    bindRepeated([
+      "interpolate",
+      ["exponential", 2],
+      ["zoom"],
+      ...geometryLevels.flatMap((level) => {
+        const centerline = ["*", radiusAt15, 2 ** (level - 15)];
+        const fallback = fallbackWidth === void 0 ? select(
+          widths.map(({ condition, value }) => ({ condition, value: atZoom(value, level) })),
+          0
+        ) : atZoom(fallbackWidth, level);
+        const inner = [
+          "case",
+          physical,
+          ["*", centerline, ["/", innerMeters, radiusMeters]],
+          ["-", centerline, ["/", fallback, 2]]
+        ];
+        const fillWidth = [
+          "case",
+          physical,
+          ["*", centerline, ["/", ["-", outerMeters, innerMeters], radiusMeters]],
+          fallback
+        ];
+        const border = casing ? borderAt(level) : 0;
+        return [
+          level,
+          width ? ["max", 0, ["+", fillWidth, border]] : ["max", 0, ["-", inner, ["/", border, 2]]]
+        ];
+      })
+    ])
+  );
   const phaseStyle = (phase) => ({
     color: "rgba(0, 0, 0, 0)",
     minZoom: 15,
@@ -9774,6 +10600,63 @@ function compileRoundabouts(request, surfaces, context, contributions) {
     });
   }
 }
+var bindable = /* @__PURE__ */ new Set([
+  "case",
+  "match",
+  "all",
+  "any",
+  "!",
+  "==",
+  "!=",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "has",
+  "get",
+  "to-number",
+  "coalesce",
+  "+",
+  "-",
+  "*",
+  "/",
+  "max",
+  "min"
+]);
+function bindRepeated(curve) {
+  let tree = curve;
+  for (let index = 0; index < 2; index += 1) {
+    const json = /* @__PURE__ */ new Map();
+    const found = /* @__PURE__ */ new Map();
+    const visit = (value) => {
+      if (!Array.isArray(value) || value[0] === "literal")
+        return { text: JSON.stringify(value), free: true };
+      const parts = value.map(visit);
+      const text = `[${parts.map((part) => part.text).join(",")}]`;
+      json.set(value, text);
+      const free = value[0] !== "zoom" && value[0] !== "var" && parts.every((part) => part.free);
+      if (free && typeof value[0] === "string" && bindable.has(value[0]))
+        found.set(text, (found.get(text) ?? 0) + 1);
+      return { text, free };
+    };
+    visit(tree);
+    let best;
+    let saving = 256;
+    for (const [text, count] of found) {
+      const saved = (count - 1) * text.length;
+      if (count > 1 && saved > saving) [best, saving] = [text, saved];
+    }
+    if (best === void 0) break;
+    const name = `tileflow_${index}`;
+    const replace = (value) => {
+      if (!Array.isArray(value) || value[0] === "literal") return value;
+      if (json.get(value) === best) return ["var", name];
+      return value.map(replace);
+    };
+    tree = ["let", name, JSON.parse(best), replace(tree)];
+  }
+  return tree;
+}
 function select(values, fallback) {
   if (!values.length) return fallback;
   const serialized = JSON.stringify(values[0].value);
@@ -9812,7 +10695,7 @@ function phaseVisibility(surfaces, phase, fields2) {
 function zoomLevels(values) {
   const levels = new Set(Array.from({ length: 10 }, (_, index) => index + 15));
   for (const value of values) {
-    if (!isZoomCurve(value)) continue;
+    if (!isZoomCurve2(value)) continue;
     for (let index = 3; index < value.length - 1; index += 2) {
       const level = value[index];
       if (level < 15 || level > 24) continue;
@@ -9870,7 +10753,7 @@ function interpolationFactor2(interpolation, distance, span) {
   const logarithm = Math.log(interpolation[1]);
   return Math.expm1(logarithm * distance) / Math.expm1(logarithm * span);
 }
-function isZoomCurve(value) {
+function isZoomCurve2(value) {
   return Array.isArray(value) && (value[0] === "interpolate" && isZoom(value[2]) || value[0] === "step" && isZoom(value[1]));
 }
 function isZoom(value) {
@@ -9879,19 +10762,55 @@ function isZoom(value) {
 function atZoom(value, level) {
   if (!Array.isArray(value) || value[0] === "literal") return value;
   if (isZoom(value)) return level;
-  if (!isZoomCurve(value)) return value.map((entry) => atZoom(entry, level));
+  if (!isZoomCurve2(value)) return value.map((entry) => atZoom(entry, level));
   const stops = [];
   for (let index = 3; index < value.length - 1; index += 2) {
     stops.push({ level: value[index], value: value[index + 1] });
   }
   const exact = stops.find((stop) => stop.level === level);
-  if (exact) return exact.value;
+  if (exact) return foldConstants(exact.value);
   const lower = [...stops].reverse().find((stop) => stop.level < level);
   const upper = stops.find((stop) => stop.level > level);
-  if (value[0] === "step") return lower?.value ?? value[2];
-  if (!lower) return upper?.value ?? 0;
-  if (!upper) return lower.value;
-  return ["interpolate", value[1], level, lower.level, lower.value, upper.level, upper.value];
+  if (value[0] === "step") return foldConstants(lower?.value ?? value[2]);
+  if (!lower) return foldConstants(upper?.value ?? 0);
+  if (!upper) return foldConstants(lower.value);
+  const at = interpolationFactor2(
+    value[1],
+    level - lower.level,
+    upper.level - lower.level
+  );
+  const folded = Number.isFinite(at) ? interpolated(foldConstants(lower.value), foldConstants(upper.value), at) : void 0;
+  return folded ?? ["interpolate", value[1], level, lower.level, lower.value, upper.level, upper.value];
+}
+function foldConstants(value) {
+  if (!Array.isArray(value) || value[0] === "literal") return value;
+  const folded = value.map(foldConstants);
+  const [operator, ...operands] = folded;
+  if (!operands.length || !operands.every((operand) => typeof operand === "number")) return folded;
+  const numbers = operands;
+  const result = operator === "*" ? numbers.reduce((product, number) => product * number, 1) : operator === "+" ? numbers.reduce((sum2, number) => sum2 + number, 0) : operator === "-" ? numbers.length === 1 ? -numbers[0] : numbers[0] - numbers[1] : operator === "/" && numbers.length === 2 ? numbers[0] / numbers[1] : operator === "max" ? Math.max(...numbers) : operator === "min" ? Math.min(...numbers) : void 0;
+  return result !== void 0 && Number.isFinite(result) ? result : folded;
+}
+function interpolated(lower, upper, at) {
+  if (typeof lower === "number" && typeof upper === "number") return lower + (upper - lower) * at;
+  if (JSON.stringify(lower) === JSON.stringify(upper)) return lower;
+  if (!Array.isArray(lower) || !Array.isArray(upper) || lower.length !== upper.length || lower[0] !== "case" && lower[0] !== "match" || lower[0] !== upper[0])
+    return void 0;
+  const first = lower[0] === "case" ? 1 : 2;
+  const result = lower.slice(0, first);
+  if (JSON.stringify(result) !== JSON.stringify(upper.slice(0, first))) return void 0;
+  for (let index = first; index < lower.length; index += 1) {
+    const output = (index - first) % 2 === 1 || index === lower.length - 1;
+    if (!output) {
+      if (JSON.stringify(lower[index]) !== JSON.stringify(upper[index])) return void 0;
+      result.push(lower[index]);
+      continue;
+    }
+    const value = interpolated(lower[index], upper[index], at);
+    if (value === void 0) return void 0;
+    result.push(value);
+  }
+  return result;
 }
 
 // src/modules/roads/compiler.ts
@@ -9962,6 +10881,10 @@ function compileRoads(request, context) {
       request?.classes?.[roadClass]
     );
     const treatments = resolveRoadTreatments(request, schema.fields, roadClass);
+    const drawn = {
+      field: schema.fields.class,
+      classes: new Set(tileflowRoadClassValues(roadClass))
+    };
     const roundaboutSurface = { roadClass };
     roundaboutSurfaces.push(roundaboutSurface);
     for (const structure of ["tunnel", "surface", "bridge"]) {
@@ -9984,7 +10907,8 @@ function compileRoads(request, context) {
           treatments,
           structure,
           phase,
-          phaseDefaults.color
+          phaseDefaults.color,
+          drawn
         );
         const contribution = {
           family: roadLinePhysicalFamily(roadClass, structure, phase),
@@ -10047,7 +10971,8 @@ function compileRoads(request, context) {
           treatments,
           structure,
           "fill",
-          roadColor(context, roadClass)
+          roadColor(context, roadClass),
+          drawn
         );
         const size = hatch.size === void 0 ? scaleStyleValue(treatedFill.width ?? 1, 0.68) : toMapLibreStyleValue(hatch.size);
         const minZoom = hatch.minZoom ?? treatedFill.minZoom;
@@ -10168,31 +11093,24 @@ function compileRoads(request, context) {
   const areaTargets = [
     {
       id: "tileflow-road-area",
-      filter: ["==", ["geometry-type"], "Polygon"],
+      kind: void 0,
       name: "road",
       style: areaStyles.road
     },
     {
       id: "tileflow-road-pedestrian-area",
-      filter: [
-        "all",
-        ["==", ["geometry-type"], "Polygon"],
-        tileflowRoadClassFilter(schema.fields, "pedestrian")
-      ],
+      kind: tileflowRoadClassFilter(schema.fields, "pedestrian"),
       name: "pedestrian",
       style: areaStyles.pedestrian
     },
     {
       id: "tileflow-road-pier-area",
-      filter: [
-        "all",
-        ["==", ["geometry-type"], "Polygon"],
-        ["==", ["get", schema.fields.class], "pier"]
-      ],
+      kind: ["==", ["get", schema.fields.class], "pier"],
       name: "pier",
       style: areaStyles.pier
     }
   ];
+  const polygons2 = ["==", ["geometry-type"], "Polygon"];
   let areaOrder = 900;
   for (const target of areaTargets) {
     if (!target.style) continue;
@@ -10202,13 +11120,19 @@ function compileRoads(request, context) {
         type: "fill",
         source,
         "source-layer": schema.layers.road,
-        filter: target.filter
+        filter: target.kind ? ["all", polygons2, target.kind] : polygons2
       },
       target.style
     )) {
+      const { filter: _polygonFilter, ...unfiltered } = area.layer;
+      const outline = area.phase === "outline" && schema.layers.transportationOutline ? {
+        ...unfiltered,
+        "source-layer": schema.layers.transportationOutline,
+        ...target.kind ? { filter: target.kind } : {}
+      } : area.layer;
       contributions.push({
         kind: "layer",
-        layer: area.layer,
+        layer: outline,
         localOrder: areaOrder++,
         owner: "roads",
         slot: "transport-areas",
@@ -10485,9 +11409,10 @@ function resolveRoadTreatments(request, fields2, roadClass) {
   add2(request?.modifiers?.unpaved, ["==", ["get", fields2.surface], "unpaved"]);
   add2(request?.modifiers?.indoor, flagFilter(fields2.indoor));
   add2(request?.modifiers?.official, flagFilter(fields2.official));
-  for (const [scale, style] of Object.entries(request?.mountainBike ?? {})) {
-    add2(style, ["==", ["to-string", ["get", fields2.mtbScale]], scale]);
-  }
+  if (isTileflowPathRoadClass(roadClass) || roadClass === "track")
+    for (const [scale, style] of Object.entries(request?.mountainBike ?? {})) {
+      add2(style, ["==", ["to-string", ["get", fields2.mtbScale]], scale]);
+    }
   if (roadClass === "service") {
     for (const [serviceType, value] of Object.entries(serviceTypeValues)) {
       add2(request?.serviceTypes?.[serviceType], [
@@ -10499,7 +11424,7 @@ function resolveRoadTreatments(request, fields2, roadClass) {
   }
   return entries;
 }
-function applyRoadTreatments(base, treatments, structure, phase, fallbackColor) {
+function applyRoadTreatments(base, treatments, structure, phase, fallbackColor, drawn) {
   const result = { ...base };
   const paintProperties = [
     "blur",
@@ -10516,12 +11441,12 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
       return value === void 0 ? [] : [
         {
           condition,
-          resolve: () => expressionOutput(toMapLibreStyleValue(value))
+          resolve: () => expressionOutput(withinClasses(toMapLibreStyleValue(value), drawn))
         }
       ];
     });
     if (branches.length > 0) {
-      if (property === "dash" && isSolidRoadDash(result[property] ?? treatmentPaintDefaults.dash) && branches.every(({ resolve }) => isSolidRoadDash(resolve()))) {
+      if (property === "dash" && isSolidRoadDash(withinClasses(result[property] ?? treatmentPaintDefaults.dash, drawn)) && branches.every(({ resolve }) => isSolidRoadDash(resolve()))) {
         delete result[property];
         continue;
       }
@@ -10551,6 +11476,49 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
   }
   return result;
 }
+function withinClasses(value, drawn) {
+  const decided = (condition) => {
+    if (!Array.isArray(condition)) return typeof condition === "boolean" ? condition : void 0;
+    const [operator, ...operands] = condition;
+    const isClass = (operand) => Array.isArray(operand) && operand.length === 2 && operand[0] === "get" && (operand[1] === drawn.field || typeof operand[1] === "object" && operand[1] !== null && operand[1].kind === "tileflow-data-field" && operand[1].name === "class");
+    const among = (labels2) => {
+      const hits = [...drawn.classes].filter((value2) => labels2.includes(value2)).length;
+      return hits === 0 ? false : hits === drawn.classes.size ? true : void 0;
+    };
+    if ((operator === "==" || operator === "!=") && operands.length === 2) {
+      const label = isClass(operands[0]) ? operands[1] : isClass(operands[1]) ? operands[0] : null;
+      if (typeof label !== "string") return void 0;
+      const equal = among([label]);
+      return equal === void 0 ? void 0 : operator === "==" ? equal : !equal;
+    }
+    if (operator === "match" && operands.length === 4 && isClass(operands[0]) && typeof operands[2] === "boolean" && typeof operands[3] === "boolean") {
+      const labels2 = Array.isArray(operands[1]) ? operands[1] : [operands[1]];
+      const matched = among(labels2);
+      return matched === void 0 ? void 0 : matched ? operands[2] : operands[3];
+    }
+    if (operator === "!" && operands.length === 1) {
+      const inner = decided(operands[0]);
+      return inner === void 0 ? void 0 : !inner;
+    }
+    if (operator === "all" || operator === "any") {
+      const results = operands.map(decided);
+      if (results.includes(operator === "all" ? false : true)) return operator !== "all";
+      return results.every((result) => result !== void 0) ? operator === "all" : void 0;
+    }
+    return void 0;
+  };
+  if (!Array.isArray(value) || value[0] !== "case") return value;
+  const branches = [];
+  for (let index = 1; index < value.length - 1; index += 2) {
+    const holds = decided(value[index]);
+    if (holds === false) continue;
+    const output = withinClasses(value[index + 1], drawn);
+    if (holds === true) return branches.length ? ["case", ...branches, output] : output;
+    branches.push(value[index], output);
+  }
+  const fallback = withinClasses(value.at(-1), drawn);
+  return branches.length ? ["case", ...branches, fallback] : fallback;
+}
 function isSolidRoadDash(value) {
   const output = expressionOutput(value);
   const dash = Array.isArray(output) && output[0] === "literal" ? output[1] : output;
@@ -11120,13 +12088,13 @@ function tileflowVegetationMetadata(vegetation2) {
   return { version: 1, ...vegetation2 };
 }
 function readTileflowVegetation3D(metadata) {
-  if (!isRecord6(metadata)) return void 0;
+  if (!isRecord7(metadata)) return void 0;
   const value = metadata[tileflowVegetationMetadataKey];
-  if (!isRecord6(value) || value.version !== 1) return void 0;
+  if (!isRecord7(value) || value.version !== 1) return void 0;
   const { source, layers: layers2, fields: fields2, colors, heightScale, crownScale, unknownForms, regions: regions2 } = value;
-  if (typeof source !== "string" || !isRecord6(layers2) || typeof layers2.tree !== "string")
+  if (typeof source !== "string" || !isRecord7(layers2) || typeof layers2.tree !== "string")
     return void 0;
-  if (!isRecord6(fields2) || !isRecord6(colors) || typeof colors.bark !== "string") return void 0;
+  if (!isRecord7(fields2) || !isRecord7(colors) || typeof colors.bark !== "string") return void 0;
   const palette = (list) => Array.isArray(list) && list.length > 0 && list.every((entry) => typeof entry === "string") ? list : void 0;
   const broadleaf = palette(colors.broadleaf);
   const conifer = palette(colors.conifer);
@@ -11136,18 +12104,18 @@ function readTileflowVegetation3D(metadata) {
   const scale = (number) => typeof number === "number" && number > 0 && number <= 10 ? number : 1;
   const mix2 = tileflowTreeFormMixProblem(unknownForms) === void 0 ? unknownForms : void 0;
   const models = Object.fromEntries(
-    Object.entries(isRecord6(value.models) ? value.models : {}).filter(
-      ([id2, model]) => tileflowTreeModelIdPattern.test(id2) && isRecord6(model) && typeof model.near === "string" && (model.far === void 0 || typeof model.far === "string")
+    Object.entries(isRecord7(value.models) ? value.models : {}).filter(
+      ([id2, model]) => tileflowTreeModelIdPattern.test(id2) && isRecord7(model) && typeof model.near === "string" && (model.far === void 0 || typeof model.far === "string")
     ).slice(0, 16).map(([id2, model]) => {
       const { near, far } = model;
       return [id2, far === void 0 ? { near } : { near, far }];
     })
   );
-  const ownScales = isRecord6(value.forms) ? value.forms : {};
+  const ownScales = isRecord7(value.forms) ? value.forms : {};
   const forms = Object.fromEntries(
     tileflowTreeForms.flatMap((form) => {
       const own = ownScales[form];
-      if (!isRecord6(own)) return [];
+      if (!isRecord7(own)) return [];
       const drawn = Array.isArray(own.models) ? [...new Set(own.models)].filter((id2) => typeof id2 === "string" && id2 in models).slice(0, 4) : [];
       return [
         [
@@ -11161,10 +12129,10 @@ function readTileflowVegetation3D(metadata) {
       ];
     })
   );
-  const finish = tileflowTreeFinishes.find((name) => name === value.finish) ?? "faceted";
+  const finish2 = tileflowTreeFinishes.find((name) => name === value.finish) ?? "faceted";
   const edges = typeof value.edges === "number" && value.edges >= 0 && value.edges <= 1 ? value.edges : 0;
   const zones = Array.isArray(regions2) ? regions2.filter(
-    (region) => isRecord6(region) && tileflowTreeRegionProblem(region) === void 0
+    (region) => isRecord7(region) && tileflowTreeRegionProblem(region) === void 0
   ) : [];
   const named = Object.fromEntries(
     Object.entries(tileflowWorldTreeFields).map(([key, fallback]) => [
@@ -11185,7 +12153,7 @@ function readTileflowVegetation3D(metadata) {
     crownScale: scale(crownScale),
     forms,
     models,
-    finish,
+    finish: finish2,
     edges,
     ...typeof value.edgeColor === "string" ? { edgeColor: value.edgeColor } : {},
     unknownForms: mix2 ?? tileflowDefaultUnknownTreeForms,
@@ -11194,7 +12162,7 @@ function readTileflowVegetation3D(metadata) {
   };
 }
 function tileflowTreeRegionProblem(region) {
-  if (!isRecord6(region)) return "a region is an object with bounds and unknownForms";
+  if (!isRecord7(region)) return "a region is an object with bounds and unknownForms";
   const bounds = region.bounds;
   if (!Array.isArray(bounds) || bounds.length !== 4 || !bounds.every((value) => typeof value === "number" && Number.isFinite(value)))
     return "bounds are [west, south, east, north] in degrees";
@@ -11205,7 +12173,7 @@ function tileflowTreeRegionProblem(region) {
   const mix2 = tileflowTreeFormMixProblem(region.unknownForms);
   return mix2 ? `unknownForms: ${mix2}` : void 0;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -12904,9 +13872,9 @@ var tileflowNoticeLimits = Object.freeze({
   maxSources: 16,
   maxTextLength: 120
 });
-var identifierPattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u;
+var identifierPattern2 = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u;
 function readTileflowNotices(metadata) {
-  if (!isRecord7(metadata)) return [];
+  if (!isRecord8(metadata)) return [];
   const value = metadata[tileflowNoticesMetadataKey];
   if (!Array.isArray(value)) return [];
   const notices = [];
@@ -12920,18 +13888,18 @@ function readTileflowNotices(metadata) {
   return Object.freeze(notices);
 }
 function readNotice(value) {
-  if (!isRecord7(value)) return void 0;
+  if (!isRecord8(value)) return void 0;
   const { id: id2, sources, text } = value;
-  if (typeof id2 !== "string" || !identifierPattern.test(id2)) return void 0;
+  if (typeof id2 !== "string" || !identifierPattern2.test(id2)) return void 0;
   if (typeof text !== "string" || text.trim() !== text || !text || text.length > tileflowNoticeLimits.maxTextLength || /\p{Cc}/u.test(text)) {
     return void 0;
   }
-  if (!Array.isArray(sources) || sources.length > tileflowNoticeLimits.maxSources || !sources.every((source) => typeof source === "string" && identifierPattern.test(source))) {
+  if (!Array.isArray(sources) || sources.length > tileflowNoticeLimits.maxSources || !sources.every((source) => typeof source === "string" && identifierPattern2.test(source))) {
     return void 0;
   }
   return Object.freeze({ id: id2, sources: Object.freeze([...sources]), text });
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -13608,21 +14576,21 @@ function bindSemanticValue(value, schema, sourceId) {
   }
   if (isDataSourceReference(value)) return sourceId;
   if (Array.isArray(value)) return value.map((item) => bindSemanticValue(item, schema, sourceId));
-  if (!isRecord8(value)) return value;
+  if (!isRecord9(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([key, item]) => [key, bindSemanticValue(item, schema, sourceId)])
   );
 }
 function isDataFieldReference2(value) {
-  return isRecord8(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
+  return isRecord9(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
 }
 function isDataLayerReference(value) {
-  return isRecord8(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
+  return isRecord9(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
 }
 function isDataSourceReference(value) {
-  return isRecord8(value) && value.kind === "tileflow-data-source" && value.name === "primary";
+  return isRecord9(value) && value.kind === "tileflow-data-source" && value.name === "primary";
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compareCodeUnits5(left, right) {
@@ -13726,8 +14694,8 @@ function createTileflowLayerTemplateIR(layer, semanticKey) {
     renderer: type,
     ...filter === void 0 ? {} : { selector: cloneJson20(filter) },
     style: Object.freeze({
-      ...isRecord9(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
-      ...isRecord9(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
+      ...isRecord10(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
+      ...isRecord10(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
     })
   });
 }
@@ -13919,20 +14887,29 @@ var exactPhysicalLayerIds = Object.freeze({
 var nauticalPhysicalBases = Object.freeze({
   "nautical.aids": "tileflow-nautical-aids",
   "nautical.beacons": "tileflow-nautical-beacons",
+  "nautical.berths": "tileflow-nautical-berths",
+  "nautical.bridges": "tileflow-nautical-bridges",
   "nautical.buoys": "tileflow-nautical-buoys",
   "nautical.cables": "tileflow-nautical-cables",
   "nautical.coverage": "tileflow-nautical-coverage",
+  "nautical.distanceMarks": "tileflow-nautical-distance-marks",
+  "nautical.facilities": "tileflow-nautical-facilities",
+  "nautical.harbourAreas": "tileflow-nautical-harbour-areas",
   "nautical.harbours": "tileflow-nautical-harbours",
   "nautical.hazardAreas": "tileflow-nautical-hazard-areas",
   "nautical.hazards": "tileflow-nautical-hazards",
+  "nautical.labels.bridges": "tileflow-nautical-bridge-labels",
   "nautical.labels.coverage": "tileflow-nautical-coverage-labels",
   "nautical.labels.hazards": "tileflow-nautical-hazard-area-labels",
   "nautical.labels.navigationAreas": "tileflow-nautical-navigation-area-labels",
+  "nautical.labels.overheadCables": "tileflow-nautical-overhead-cable-labels",
   "nautical.labels.reefs": "tileflow-nautical-reef-labels",
   "nautical.labels.wrecks": "tileflow-nautical-wreck-area-labels",
   "nautical.lighthouses": "tileflow-nautical-lighthouses",
   "nautical.lights": "tileflow-nautical-lights",
   "nautical.navigationAreas": "tileflow-nautical-navigation-areas",
+  "nautical.notices": "tileflow-nautical-notices",
+  "nautical.overheadCables": "tileflow-nautical-overhead-cables",
   "nautical.ports": "tileflow-nautical-ports",
   "nautical.reefs": "tileflow-nautical-reefs",
   "nautical.routes": "tileflow-nautical-routes",
@@ -13943,7 +14920,9 @@ var nauticalPhysicalBases = Object.freeze({
 function nauticalPhysicalLayerId(semanticKey) {
   const direct = nauticalPhysicalBases[semanticKey];
   if (direct) return direct;
-  const match3 = /^(nautical\.[A-Za-z0-9_.-]+)\.(fill|outline|marker|symbol)$/u.exec(semanticKey);
+  const match3 = /^(nautical\.[A-Za-z0-9_.-]+)\.(fill|outline|marker|symbol|lines)$/u.exec(
+    semanticKey
+  );
   if (!match3) return void 0;
   const base = nauticalPhysicalBases[match3[1]];
   if (!base) return void 0;
@@ -13987,21 +14966,21 @@ function visitReferences(value, counts, visited = /* @__PURE__ */ new WeakSet())
   }
 }
 function isSemanticFieldReference(value) {
-  return isRecord9(value) && value.kind === "tileflow-data-field";
+  return isRecord10(value) && value.kind === "tileflow-data-field";
 }
 function isSemanticLayerReference(value) {
-  return isRecord9(value) && value.kind === "tileflow-data-layer";
+  return isRecord10(value) && value.kind === "tileflow-data-layer";
 }
 function isSemanticSourceReference(value) {
-  return isRecord9(value) && value.kind === "tileflow-data-source";
+  return isRecord10(value) && value.kind === "tileflow-data-source";
 }
 function cloneJson20(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord5(value) {
-  return isRecord9(value) ? value : {};
+  return isRecord10(value) ? value : {};
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -14065,7 +15044,7 @@ function validateTileflowRenderSelectorConstraints(input) {
   };
   while (pending.length > 0) {
     const current = pending.pop();
-    if (!isRecord10(current.selector) || typeof current.selector.kind !== "string") {
+    if (!isRecord11(current.selector) || typeof current.selector.kind !== "string") {
       addIssue(
         "invalid-selector",
         "a render selector must be a semantic selector node",
@@ -14126,7 +15105,7 @@ function validateTileflowRenderSelectorConstraints(input) {
         }
         for (const [index, branch] of current.selector.branches.entries()) {
           const branchPath = [...branchesPath, index];
-          if (!isRecord10(branch)) {
+          if (!isRecord11(branch)) {
             addIssue("invalid-selector", "match selector branch must be an object", branchPath);
             continue;
           }
@@ -14157,14 +15136,14 @@ function validateTileflowRenderSelectorConstraints(input) {
         for (let index = current.selector.stops.length - 1; index >= 0; index -= 1) {
           const stop = current.selector.stops[index];
           const stopPath = [...stopsPath, index];
-          if (!isRecord10(stop)) {
+          if (!isRecord11(stop)) {
             addIssue("invalid-selector", "step selector stop must be an object", stopPath);
             continue;
           }
           pushChild(stop.selector, current.depth + 1, [...stopPath, "selector"]);
         }
         for (const [index, stop] of current.selector.stops.entries()) {
-          if (!isRecord10(stop)) continue;
+          if (!isRecord11(stop)) continue;
           const zoom3 = stop.zoom;
           const zoomPath = [...stopsPath, index, "zoom"];
           if (typeof zoom3 !== "number" || !Number.isFinite(zoom3) || zoom3 < 0 || zoom3 > 24) {
@@ -14286,7 +15265,7 @@ function compileRenderSelector(selector, data) {
   assertRenderSelectorConstraints(selector);
   return lowerSelector(selector, data);
 }
-function applyCompiledRenderStacks(input, operations2) {
+function applyCompiledRenderStacks(input, operations2, targetsOfOtherModes = /* @__PURE__ */ new Map()) {
   let layers2 = input.map(cloneJson21);
   const passes = operations2.filter(
     (operation) => operation.kind === "layer"
@@ -14317,9 +15296,10 @@ function applyCompiledRenderStacks(input, operations2) {
   for (const refinement of activeRefinements) {
     const index = findTargetIndex(layers2, refinement.target);
     if (index < 0 && !passTargets.has(refinement.target)) {
+      const other = targetsOfOtherModes.get(refinement.target);
       throw renderStackError(
         "unknown-refinement-target",
-        `Render refinement targets unknown semantic contribution: ${refinement.target}.`
+        other === void 0 ? `Render refinement targets unknown semantic contribution: ${refinement.target}.` : `Render refinement targets ${refinement.target}, ${describeOtherMode(other)}`
       );
     }
     if (refinement.placement !== void 0 && placementAnchor(refinement.placement) === refinement.target) {
@@ -14341,9 +15321,10 @@ function applyCompiledRenderStacks(input, operations2) {
   for (const operation of pending) {
     const anchor = placementAnchor(operation.placement);
     if (anchor !== void 0 && !knownTargets.has(anchor)) {
+      const other = targetsOfOtherModes.get(anchor);
       throw renderStackError(
         "unknown-or-circular-anchor",
-        `${operation.target} is placed beside unknown semantic target ${anchor}.`
+        other === void 0 ? `${operation.target} is placed beside unknown semantic target ${anchor}.` : `${operation.target} is placed beside ${anchor}, ${describeOtherMode(other)}`
       );
     }
   }
@@ -14547,7 +15528,7 @@ function applyRendererStyle(layer, renderer, style) {
   };
 }
 function lowerSelector(selector, data) {
-  if (!isRecord10(selector) || typeof selector.kind !== "string") {
+  if (!isRecord11(selector) || typeof selector.kind !== "string") {
     throw renderStackError(
       "invalid-selector",
       "A render selector must be a semantic selector node."
@@ -14750,7 +15731,7 @@ function requireRenderer(value) {
 function requirePlacement(value) {
   if (typeof value === "string") {
     if (tileflowBandPlacements.includes(value)) return;
-  } else if (isRecord10(value)) {
+  } else if (isRecord11(value)) {
     const keys = Object.keys(value);
     if (keys.length === 1 && (keys[0] === "above" || keys[0] === "below")) {
       requirePortableTarget(value[keys[0]], "render placement target");
@@ -14777,7 +15758,7 @@ function validateRefinementShape(operation) {
   validateStyle(operation.renderer, operation.style);
 }
 function validateStyle(renderer, style) {
-  if (!isRecord10(style)) {
+  if (!isRecord11(style)) {
     throw renderStackError(
       "invalid-style",
       `A ${renderer} render operation requires a style object.`
@@ -14879,7 +15860,7 @@ function normalizeRequirements(requirements) {
   return [...requirements];
 }
 function requireRenderStackEntries(stack) {
-  if (!isRecord10(stack)) {
+  if (!isRecord11(stack)) {
     throw renderStackError("invalid-stack", "A render stack must be a named operation record.");
   }
   const entries = Object.entries(stack);
@@ -15016,6 +15997,9 @@ function assertOnlyKeys(input, allowed, description) {
     );
   }
 }
+function describeOtherMode({ activeMode, mode, owner }) {
+  return `which ${owner} draws only in mode '${mode}'; this map draws ${owner} in mode '${activeMode}'. Place the operation beside a target drawn in mode '${activeMode}' or at a band edge, or remove it; refine({mode: '${activeMode}', renderStack: reset()}) removes an inherited ${owner} render stack.`;
+}
 function renderStackError(code, message) {
   return Object.assign(new Error(message), { code, name: "TileflowRenderStackError" });
 }
@@ -15026,9 +16010,9 @@ function cloneJson21(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord6(value) {
-  return isRecord10(value) ? value : {};
+  return isRecord11(value) ? value : {};
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -15244,6 +16228,7 @@ function isLoopbackHostname(hostname) {
 // src/resolved-map-schema.ts
 init_time_of_day();
 init_time_of_day_schema();
+init_camera_limits();
 var TileflowResolvedMapValidationError = class extends Error {
   code = "CONFIG_INVALID";
   messages;
@@ -16106,6 +17091,7 @@ function boundedThemeNumberSchema(min, max) {
     }).strict()
   ]);
 }
+var entranceBandSchema = z7.tuple([z7.number().finite().min(0).max(24), z7.number().finite().min(0).max(24)]).refine(([from, to]) => from < to, "A band starts at a lower zoom than it ends.");
 var modelRoleLightingSchema = z7.object({
   emissiveStrength: boundedThemeNumberSchema(0, 5).optional(),
   emissiveVariation: boundedThemeNumberSchema(0, 1).optional(),
@@ -16161,6 +17147,7 @@ var buildingsModuleSchema = z7.object({
       lamp: modelRoleLightingSchema.optional(),
       logo: modelRoleLightingSchema.optional()
     }).strict().optional(),
+    entrance: z7.object({ buildings: entranceBandSchema.optional(), models: entranceBandSchema.optional() }).strict().optional(),
     occlusion: z7.boolean().optional(),
     modelOcclusion: boundedThemeNumberSchema(0, 1).optional(),
     shadows: z7.boolean().optional(),
@@ -16399,24 +17386,34 @@ var poiModuleSchema = z7.object({
 var nauticalModuleSchema = z7.object({
   type: z7.literal("nautical"),
   aids: markerSymbolStyleSchema.optional(),
+  animateLights: z7.boolean().optional(),
   beacons: markerSymbolStyleSchema.optional(),
+  berths: areaStyleSchema.optional(),
+  bridges: areaStyleSchema.optional(),
   buoys: markerSymbolStyleSchema.optional(),
   cables: lineStyleSchema.optional(),
   coverage: areaStyleSchema.optional(),
+  distanceMarks: markerSymbolStyleSchema.optional(),
   enabled: z7.boolean().optional(),
+  facilities: markerSymbolStyleSchema.optional(),
+  harbourAreas: areaStyleSchema.optional(),
   harbours: markerSymbolStyleSchema.optional(),
   hazardAreas: areaStyleSchema.optional(),
   hazards: markerSymbolStyleSchema.optional(),
   labels: z7.object({
+    bridges: symbolStyleSchema.optional(),
     coverage: symbolStyleSchema.optional(),
     hazards: symbolStyleSchema.optional(),
     navigationAreas: symbolStyleSchema.optional(),
+    overheadCables: symbolStyleSchema.optional(),
     reefs: symbolStyleSchema.optional(),
     wrecks: symbolStyleSchema.optional()
   }).strict().optional(),
   lighthouses: markerSymbolStyleSchema.optional(),
   lights: markerSymbolStyleSchema.optional(),
   navigationAreas: areaStyleSchema.optional(),
+  notices: markerSymbolStyleSchema.optional(),
+  overheadCables: lineStyleSchema.optional(),
   ports: markerSymbolStyleSchema.optional(),
   reefs: areaStyleSchema.optional(),
   renderStack: renderStackSchema.optional(),
@@ -16540,6 +17537,7 @@ var layerBindingsSchema = z7.object({
   streetFurniture: z7.string().trim().min(1).optional(),
   trafficControl: z7.string().trim().min(1).optional(),
   tree: z7.string().trim().min(1).optional(),
+  transportationOutline: z7.string().trim().min(1).optional(),
   water: z7.string().trim().min(1),
   waterName: z7.string().trim().min(1),
   waterway: z7.string().trim().min(1)
@@ -16948,7 +17946,7 @@ var terrainContoursSchema = z7.object({
   demUrl: z7.string().min(1).max(2048).refine(
     isSafeTileflowDemUrlTemplate,
     "Expected a safe HTTP(S) DEM URL template containing {z}, {x}, and {y}"
-  ),
+  ).optional(),
   index: terrainContourLineSchema.optional(),
   labels: terrainContourLabelSchema.optional(),
   maxZoom: z7.number().int().min(0).max(24).optional(),
@@ -17072,10 +18070,25 @@ var atmosphereSchema = z7.union([
     starParallax: z7.number().finite().min(0).max(1).optional()
   }).strict()
 ]);
+var skyNumberSchema = z7.union([
+  z7.number().finite().min(0).max(1),
+  fixedNumberSchema.extend({ value: z7.number().finite().min(0).max(1) }),
+  themeNumberReferenceSchema
+]);
+var skySchema = z7.union([
+  z7.boolean(),
+  z7.object({
+    color: atmosphereColorSchema.optional(),
+    horizonColor: atmosphereColorSchema.optional(),
+    horizonBlend: skyNumberSchema.optional(),
+    glowColor: atmosphereColorSchema.optional(),
+    starIntensity: skyNumberSchema.optional()
+  }).strict()
+]);
 var viewSchema = z7.object({
   bearing: z7.number().finite().min(-180).max(180).optional(),
   center: z7.tuple([z7.number().finite().min(-180).max(180), z7.number().finite().min(-90).max(90)]).optional(),
-  pitch: z7.number().finite().min(0).max(85).optional(),
+  pitch: z7.number().finite().min(0).max(tileflowMaxPitch).optional(),
   zoom: zoomNumberSchema.optional()
 }).strict();
 var themesSchema = z7.record(tileflowThemeNameSchema, tileflowThemeSchema).superRefine((themes, context) => {
@@ -17118,6 +18131,7 @@ var resolvedTileflowMapSchema = z7.object({
   name: z7.string().trim().min(1),
   overlays: overlaysSchema.optional(),
   projection: z7.enum(["globe", "mercator"]).optional(),
+  sky: skySchema.optional(),
   sources: hostedSourcesSchema.optional(),
   systemThemes: systemThemesSchema.optional(),
   terrain: terrainSchema.optional(),
@@ -17431,7 +18445,7 @@ function resolveTerrain(terrain, apiBaseUrl) {
   const mode = terrainConfig.mode ?? "hillshade";
   const encoding = terrainConfig.encoding ?? "terrarium";
   const raster = mode === "none" ? void 0 : resolveRaster(terrainConfig, apiBaseUrl, encoding);
-  const contours = terrainConfig.contours ? resolveContours(terrainConfig.contours, encoding, terrainConfig.attribution) : void 0;
+  const contours = terrainConfig.contours ? resolveContours(terrainConfig.contours, encoding, terrainConfig.attribution, apiBaseUrl) : void 0;
   if (!raster && !contours) return void 0;
   return {
     ...contours ? { contours } : {},
@@ -17563,7 +18577,7 @@ function resolveRaster(terrain, apiBaseUrl, encoding) {
     }
   };
 }
-function resolveContours(contours, encoding, attribution) {
+function resolveContours(contours, encoding, attribution, apiBaseUrl) {
   const thresholdZooms = Object.keys(contours.thresholds).map(Number);
   const minimumZoom2 = contours.minZoom ?? Math.min(...thresholdZooms);
   const maximumZoom2 = contours.maxZoom ?? Math.max(...thresholdZooms);
@@ -17571,7 +18585,7 @@ function resolveContours(contours, encoding, attribution) {
   const tiles = [
     createTileflowContourProtocolUrl({
       demMaxzoom: contours.demMaxZoom,
-      demUrl: contours.demUrl,
+      demUrl: contours.demUrl ?? `${apiBaseUrl}/tiles/terrain/{z}/{x}/{y}.webp`,
       encoding,
       maxzoom: maximumZoom2,
       multiplier: contours.multiplier ?? 1,
@@ -18229,11 +19243,11 @@ function isTileflowPoiCategory(value) {
   return typeof value === "string" && tileflowPoiCategories.includes(value);
 }
 function semanticTarget(layer) {
-  if (!isRecord11(layer.metadata)) return void 0;
+  if (!isRecord12(layer.metadata)) return void 0;
   const value = layer.metadata[tileflowCompilerMetadataKeys.target];
   return typeof value === "string" ? value : void 0;
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSafeArtifactName(value) {
@@ -18415,6 +19429,8 @@ function mergeRoadLineGroup(key, layers2) {
   const paintKeys = new Set(layers2.flatMap((layer) => Object.keys(layer.style.appearance ?? {})));
   for (const key2 of paintKeys) {
     const values = layers2.map((layer) => layer.style.appearance?.[key2]);
+    if (key2 === "line-dasharray" && values.every((value) => isSolidDash(value ?? linePaintDefaults[key2])))
+      continue;
     const combined = combineConditionalValues(
       values.map((value, index) => ({
         condition: conditions[index],
@@ -18675,8 +19691,8 @@ function consolidateFillFamily(layers2, group, mergedId) {
   }
   const replacements = /* @__PURE__ */ new Map();
   let suffix = 0;
-  for (const grouped of groups.values()) {
-    for (const group2 of contiguousRuns(grouped)) {
+  for (const grouped2 of groups.values()) {
+    for (const group2 of contiguousRuns(grouped2)) {
       if (group2.length < 2) continue;
       const first = group2[0].layer;
       if (!group2.every(({ layer }) => sameTopLevelProperties(layer, first))) continue;
@@ -19131,7 +20147,7 @@ var colourSources = [
   ["tileflow-buildings-fill", "fill-color"]
 ];
 function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, tileflowLandmarks) {
-  const config = isRecord12(module) ? module : {};
+  const config = isRecord13(module) ? module : {};
   if (config.enabled === false) return void 0;
   const style = config.threeDimensional ?? {};
   const defaults4 = tileflowDefaultBuildings3DDesign;
@@ -19164,7 +20180,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
     edgeRadius: number(style.edgeRadius, defaults4.edgeRadius),
     ...typeof edgeColor === "string" ? { edgeColor } : {},
     nightLight: number(style.nightLight, 0),
-    ...isRecord12(style.floodLight) ? {
+    ...isRecord13(style.floodLight) ? {
       floodLight: readBuildingFloodLight({
         ...style.floodLight,
         intensity: number(style.floodLight.intensity, 0),
@@ -19172,10 +20188,10 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
         color: style.floodLight.color === void 0 ? void 0 : toMapLibreStyleValue(style.floodLight.color)
       })
     } : {},
-    ...isRecord12(style.modelLighting) ? {
+    ...isRecord13(style.modelLighting) ? {
       modelLighting: readModelRoleLighting(
         Object.fromEntries(
-          Object.entries(style.modelLighting).filter(([, entry]) => isRecord12(entry)).map(([role, entry]) => {
+          Object.entries(style.modelLighting).filter(([, entry]) => isRecord13(entry)).map(([role, entry]) => {
             const own = entry;
             return [
               role,
@@ -19186,7 +20202,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
                   ["emissiveVariation", "colorMix", "metallic", "roughness"].filter((key) => own[key] !== void 0).map((key) => [key, number(own[key], 0)])
                 ),
                 ...Array.isArray(own.emissiveHeight) ? { emissiveHeight: own.emissiveHeight.map((v) => number(v, 0)) } : {},
-                ...isRecord12(own.colorVariation) ? {
+                ...isRecord13(own.colorVariation) ? {
                   colorVariation: {
                     ...own.colorVariation,
                     ...Object.fromEntries(
@@ -19208,6 +20224,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
       )
     } : {},
     windows: style.windows === true,
+    ...readTileflowBuildingsEntrance(style.entrance),
     shadows: typeof style.shadows === "boolean" ? style.shadows : defaults4.shadows,
     occlusion: typeof style.occlusion === "boolean" ? style.occlusion : defaults4.occlusion,
     modelOcclusion: number(style.modelOcclusion, defaults4.modelOcclusion),
@@ -19218,7 +20235,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
 }
 function landmarksOf2(value, tileflowLandmarks) {
   if (value === false) return {};
-  if (isRecord12(value) && typeof value.url === "string") return { landmarks: { url: value.url } };
+  if (isRecord13(value) && typeof value.url === "string") return { landmarks: { url: value.url } };
   return tileflowLandmarks ? { landmarks: { url: tileflowLandmarks } } : {};
 }
 function placedModels(value, served) {
@@ -19245,7 +20262,7 @@ function placedModels(value, served) {
   };
 }
 function modelColours(value) {
-  if (!isRecord12(value)) return {};
+  if (!isRecord13(value)) return {};
   const colours = {};
   for (const [part, colour] of Object.entries(value)) {
     const resolved = colour === void 0 ? void 0 : toMapLibreStyleValue(colour);
@@ -19254,7 +20271,7 @@ function modelColours(value) {
   return Object.keys(colours).length > 0 ? { modelColors: colours } : {};
 }
 function tileflowStreetLightsDesignOf(module, context) {
-  const config = isRecord12(module) ? module : {};
+  const config = isRecord13(module) ? module : {};
   const layers2 = context.data.schema.layers;
   const style = config.streetLights ?? {};
   if (config.enabled === false || style.enabled !== true || !layers2.streetFurniture)
@@ -19274,7 +20291,7 @@ function tileflowStreetLightsDesignOf(module, context) {
     intensity: typeof intensity === "number" ? intensity : 1
   };
 }
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -19465,7 +20482,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     )
   );
   const renderStackModules = Object.values(modules).filter(
-    (module) => isRecord13(module) && module.enabled !== false && "renderStack" in module && isRecord13(module.renderStack)
+    (module) => isRecord14(module) && module.enabled !== false && "renderStack" in module && isRecord14(module.renderStack)
   );
   const renderOperations = runCompilationPhase(
     "render-stack",
@@ -19491,7 +20508,11 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   const requestedRenderOperations = domainIR.renderOperations;
   const stackedFamilies = runCompilationPhase(
     "render-stack",
-    () => applyCompiledRenderStacks(assembledFamilies, requestedRenderOperations)
+    () => applyCompiledRenderStacks(
+      assembledFamilies,
+      requestedRenderOperations,
+      buildingTargetsOfOtherModes(modules.buildings)
+    )
   );
   const plannedFamilies = runCompilationPhase(
     "physical-planner",
@@ -19707,9 +20728,15 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       layer.layout = { ...layer.layout, visibility: "none" };
   }
   const atmosphere = resolveTileflowAtmosphere(config.atmosphere);
+  const sky = resolveTileflowSky(config.sky);
   const notices = compiledNotices(layers2, marine);
+  const nauticalLights = declareTileflowNauticalLights(
+    layers2,
+    marine?.nautical?.sourceId,
+    tileflowNauticalV1Schema.layers.lights
+  );
   const style = {
-    ...atmosphere ? { sky: compileTileflowSky(atmosphere) } : {},
+    ...sky ? { sky: compileTileflowStreetSky(sky) } : atmosphere ? { sky: compileTileflowSky(atmosphere) } : {},
     version: 8,
     name: config.name ?? "Streets",
     ...glyphs ? { glyphs } : {},
@@ -19728,6 +20755,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
         ...mapMetadata.lineage && mapMetadata.lineage.length > 1 ? { "tileflow:extends": mapMetadata.lineage.slice(1) } : {}
       } : {},
       ...atmosphere ? { [tileflowAtmosphereMetadataKey]: { version: 1, ...atmosphere } } : {},
+      ...sky ? { [tileflowSkyMetadataKey]: skyMetadata(input, selected.name, sky) } : {},
       "tileflow:theme": selected.name,
       "tileflow:colorScheme": resolvedTheme.colorScheme,
       [tileflowRouteMetadataKey]: tileflowRouteMetadata(resolveTileflowRouteInks(resolvedTheme)),
@@ -19756,9 +20784,10 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       "tileflow:sourceRequirements": sourceRequirements,
       ...interactionManifest ? { [tileflowInteractionManifestMetadataKey]: interactionManifest } : {},
       [tileflowOverlayPlacementManifestMetadataKey]: overlayPlacementManifest,
-      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord13(module) || module.enabled !== false).map(([name]) => name).sort(),
+      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord14(module) || module.enabled !== false).map(([name]) => name).sort(),
       ...config.view ? { "tileflow:view": config.view } : {},
-      ...notices.length > 0 ? { [tileflowNoticesMetadataKey]: notices } : {}
+      ...notices.length > 0 ? { [tileflowNoticesMetadataKey]: notices } : {},
+      ...nauticalLights ? { [tileflowNauticalLightsMetadataKey]: nauticalLights } : {}
     }
   };
   const report = {
@@ -19818,7 +20847,7 @@ function finalizeTileflowLayers(input) {
     if (typeof minimum2 === "number" && typeof maximum2 === "number" && minimum2 > maximum2) {
       throw new Error(`Compiled Tileflow layer ${id2} requires minzoom <= maxzoom.`);
     }
-    const metadata = isRecord13(layer.metadata) ? { ...layer.metadata } : void 0;
+    const metadata = isRecord14(layer.metadata) ? { ...layer.metadata } : void 0;
     if (metadata) {
       const owner = metadata[tileflowCompilerMetadataKeys.owner];
       delete metadata[tileflowCompilerProvenanceMetadataKey];
@@ -19852,7 +20881,7 @@ function assertMapLibreStyle(style, mapId) {
     }
   );
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compiledNotices(layers2, marine) {
@@ -19897,8 +20926,8 @@ function assertPreparedIconReferences(style, config, prepared) {
 function collectStyleImageReferences(style) {
   const result = /* @__PURE__ */ new Set();
   for (const layer of style.layers) {
-    const layout = isRecord13(layer.layout) ? layer.layout : {};
-    const paint = isRecord13(layer.paint) ? layer.paint : {};
+    const layout = isRecord14(layer.layout) ? layer.layout : {};
+    const paint = isRecord14(layer.paint) ? layer.paint : {};
     const layerId = typeof layer.id === "string" ? layer.id : "<unknown>";
     for (const [property, value] of [
       ["icon-image", layout["icon-image"]],
@@ -19987,7 +21016,7 @@ function assertGlyphFontStacks(style, config) {
   const declared = new Set(config.glyphs.fontStacks);
   const missing = /* @__PURE__ */ new Set();
   for (const layer of style.layers) {
-    const layout = isRecord13(layer.layout) ? layer.layout : void 0;
+    const layout = isRecord14(layer.layout) ? layer.layout : void 0;
     const font = layout?.["text-font"];
     if (!Array.isArray(font) || !font.every((entry) => typeof entry === "string")) continue;
     const stack = font.join(",");
@@ -20003,7 +21032,7 @@ function assertGlyphFontStacks(style, config) {
 function assertTextAssets(style, config) {
   const textLayers = [];
   for (const layer of style.layers) {
-    const layout = isRecord13(layer.layout) ? layer.layout : void 0;
+    const layout = isRecord14(layer.layout) ? layer.layout : void 0;
     if (layout?.["text-field"] === void 0) continue;
     textLayers.push(typeof layer.id === "string" ? layer.id : "<unknown>");
     const font = layout["text-font"];
@@ -20016,7 +21045,7 @@ function assertTextAssets(style, config) {
   if (textLayers.length === 0) return;
   if (config.fonts !== void 0) {
     const backed = style.layers.find((layer) => {
-      const font = isRecord13(layer.layout) ? layer.layout["text-font"] : void 0;
+      const font = isRecord14(layer.layout) ? layer.layout["text-font"] : void 0;
       return Array.isArray(font) && font.length === 1 && typeof font[0] === "string" && parseTileflowLineBackgroundFontStack(font[0]) !== void 0;
     });
     if (backed) {
@@ -20042,7 +21071,7 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record3 = isRecord13(error) ? error : {};
+  const record3 = isRecord14(error) ? error : {};
   if (typeof record3.phase === "string") return error;
   if (error instanceof Error && Object.isExtensible(error)) {
     Object.defineProperty(error, "phase", { configurable: true, enumerable: true, value: phase });
@@ -20073,6 +21102,35 @@ function compareCodeUnits7(left, right) {
 function semanticReportKey(...parts) {
   return parts.join("\0");
 }
+function skyMetadata(input, themeName, sky) {
+  const family = Object.values(input.timeOfDay ?? {}).find(
+    (moments) => Object.values(moments).includes(themeName)
+  );
+  const colours = (name) => {
+    const theme = name === void 0 ? void 0 : input.themes[name];
+    if (!theme) return void 0;
+    const resolved = resolveTileflowSky(
+      resolveThemeValues({ sky: input.sky }, theme, `map.${input.id}.themes.${name}`).sky
+    );
+    return resolved ? {
+      color: resolved.color,
+      horizonColor: resolved.horizonColor,
+      horizonBlend: resolved.horizonBlend,
+      glowColor: resolved.glowColor
+    } : void 0;
+  };
+  const day = colours(family?.day);
+  const night = colours(family?.night);
+  const dawn = colours(family?.dawn);
+  const dusk = colours(family?.dusk);
+  const timesOfDay = day && night && (dawn ?? dusk) ? { day, night, dawn: dawn ?? dusk, dusk: dusk ?? dawn } : void 0;
+  return {
+    version: 1,
+    starIntensity: sky.starIntensity,
+    glowColor: sky.glowColor,
+    ...timesOfDay ? { timesOfDay } : {}
+  };
+}
 
 // src/maps/define.ts
 function defineMap(map) {
@@ -20115,6 +21173,7 @@ var tileflowMapMergeStrategies = {
   projection: "atomic",
   scenes: "leaf",
   shots: "leaf",
+  sky: "atomic",
   sources: "keyed-resources",
   systemThemes: "atomic",
   terrain: "atomic",
@@ -20296,6 +21355,9 @@ function applyModuleOperation(resolved, moduleName, operation, mapId, path) {
         assertNoReset(patch, mapId, `${path}/patches/${index}`, true);
         next = applyModulePatch(next, patch, mapId, `${path}/patches/${index}`);
       }
+      if (isPlainRecord4(next.renderStack) && Object.keys(next.renderStack).length === 0) {
+        delete next.renderStack;
+      }
       assertModuleOwner(next, moduleName, mapId, path);
       resolved[moduleName] = next;
       return;
@@ -20458,11 +21520,11 @@ function cloneDesign(value) {
 function describeMap(value) {
   return typeof value.id === "string" && value.id ? value.id : "<anonymous>";
 }
-function isRecord14(value) {
+function isRecord15(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord4(value) {
-  if (!isRecord14(value)) return false;
+  if (!isRecord15(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -21232,7 +22294,7 @@ function semanticDesign(map) {
 }
 function compareValues(before, after, path, output) {
   if (Object.is(before, after)) return;
-  if (isRecord15(before) && isRecord15(after)) {
+  if (isRecord16(before) && isRecord16(after)) {
     const keys = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort(
       compareCodeUnits9
     );
@@ -21274,7 +22336,7 @@ function toSemanticValue(value, path) {
   }
   throw new TypeError(`Tileflow semantic value at ${path || "/"} is not JSON-serializable.`);
 }
-function isRecord15(value) {
+function isRecord16(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function isUnknownRecord(value) {
@@ -21287,7 +22349,7 @@ function deepEqual(left, right) {
   if (Array.isArray(left) || Array.isArray(right)) {
     return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => deepEqual(value, right[index]));
   }
-  if (!isRecord15(left) || !isRecord15(right)) return false;
+  if (!isRecord16(left) || !isRecord16(right)) return false;
   const leftKeys = Object.keys(left).sort(compareCodeUnits9);
   const rightKeys = Object.keys(right).sort(compareCodeUnits9);
   return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => key === rightKeys[index] && deepEqual(left[key], right[key]));
@@ -21594,6 +22656,394 @@ function isClassTier(value) {
   return tileflowBoundaryClassTiers.includes(value);
 }
 
+// src/nautical-light-rhythm.ts
+var tileflowLightRhythmConventions = Object.freeze({
+  cardinalPeriods: Object.freeze({
+    Q: Object.freeze({ 3: 10, 6: 15, 9: 15 }),
+    "Q+LFl": 15,
+    VQ: Object.freeze({ 3: 5, 6: 10, 9: 10 }),
+    "VQ+LFl": 10
+  }),
+  fixedIntensity: 0.5,
+  flash: 1,
+  flashShare: 0.3,
+  interruptedShare: 0.6,
+  longFlash: 2,
+  morseUnit: 0.5,
+  occultingShare: 0.25,
+  quickCycle: Object.freeze({ Q: 1, UQ: 0.25, VQ: 0.5 }),
+  quickDuty: 0.3
+});
+var tileflowLightRhythmLimits = Object.freeze({
+  maxPeriod: 600,
+  maxPhases: 256,
+  maxSequenceLength: 512,
+  minPhase: 0.05
+});
+var conventions = tileflowLightRhythmConventions;
+var limits = tileflowLightRhythmLimits;
+var lit = 1;
+var eclipsed = 0;
+var morse = Object.freeze({
+  A: ".-",
+  B: "-...",
+  C: "-.-.",
+  D: "-..",
+  E: ".",
+  F: "..-.",
+  G: "--.",
+  H: "....",
+  I: "..",
+  J: ".---",
+  K: "-.-",
+  L: ".-..",
+  M: "--",
+  N: "-.",
+  O: "---",
+  P: ".--.",
+  Q: "--.-",
+  R: ".-.",
+  S: "...",
+  T: "-",
+  U: "..-",
+  V: "...-",
+  W: ".--",
+  X: "-..-",
+  Y: "-.--",
+  Z: "--..",
+  0: "-----",
+  1: ".----",
+  2: "..---",
+  3: "...--",
+  4: "....-",
+  5: ".....",
+  6: "-....",
+  7: "--...",
+  8: "---..",
+  9: "----."
+});
+function tileflowLightRhythm(light) {
+  const character = typeof light.character === "string" ? light.character.trim() : "";
+  const alternating = /^Al(?:\.|$)/u.test(character);
+  const base = alternating ? character.slice(3) : character;
+  const fixedPart = base === "FFl" || base === "F+LFl";
+  const period = positiveNumber(light.period_s);
+  const colours = colourCount(light.color);
+  let phases = parseSequence(light.sequence, fixedPart);
+  if (!phases) {
+    phases = alternating && (base === "" || base === "F") ? alternatingFixed(colours, period) : derivePhases(base, groupText(light.group), period);
+  }
+  if (!phases) return void 0;
+  if (alternating && colours > 1) phases = alternateColours(phases, colours);
+  return finish(phases);
+}
+function tileflowLightStateAt(rhythm, seconds) {
+  const periodMs = Math.round(rhythm.period * 1e3);
+  const timeMs = Number.isFinite(seconds) ? Math.floor(seconds * 1e3) : 0;
+  const offset = (timeMs % periodMs + periodMs) % periodMs;
+  let end = 0;
+  for (const phase of rhythm.phases) {
+    end += Math.round(phase.duration * 1e3);
+    if (offset < end) {
+      return { colour: phase.colour, intensity: phase.intensity, remaining: (end - offset) / 1e3 };
+    }
+  }
+  const first = rhythm.phases[0];
+  return { colour: first.colour, intensity: first.intensity, remaining: first.duration };
+}
+function parseSequence(value, fixedPart) {
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  if (!text || text.length > limits.maxSequenceLength) return void 0;
+  const phases = [];
+  for (const token2 of text.split("+")) {
+    const match3 = /^\s*(\()?\s*(\d+(?:\.\d+)?|\.\d+)\s*(\))?\s*$/u.exec(token2);
+    if (!match3 || Boolean(match3[1]) !== Boolean(match3[3])) return void 0;
+    const duration = Number(match3[2]);
+    if (!(duration > 0)) return void 0;
+    const intensity = match3[1] ? fixedPart ? conventions.fixedIntensity : eclipsed : lit;
+    phases.push({ colour: 0, duration, intensity });
+  }
+  if (!phases.some(({ intensity }) => intensity === lit)) return void 0;
+  if (!phases.some(({ intensity }) => intensity !== lit)) return void 0;
+  return phases;
+}
+function derivePhases(character, group, period) {
+  switch (character) {
+    case "Fl":
+      return grouped(
+        groupCounts(group),
+        period,
+        flashOf(groupCounts(group), period),
+        lit,
+        eclipsed
+      );
+    case "LFl":
+      return grouped(
+        groupCounts(group),
+        period,
+        longFlashOf(groupCounts(group), period),
+        lit,
+        eclipsed
+      );
+    case "FFl":
+      return grouped(
+        groupCounts(group),
+        period,
+        flashOf(groupCounts(group), period),
+        lit,
+        conventions.fixedIntensity
+      );
+    case "F+LFl":
+      return grouped(
+        groupCounts(group),
+        period,
+        longFlashOf(groupCounts(group), period),
+        lit,
+        conventions.fixedIntensity
+      );
+    case "Oc":
+    case "Oc+Fl": {
+      const counts = groupCounts(group);
+      if (!counts || !period) return void 0;
+      const eclipse = conventions.occultingShare * period / sum(counts);
+      return grouped(counts, period, eclipse, eclipsed, lit);
+    }
+    case "Iso":
+      return period ? [
+        { colour: 0, duration: period / 2, intensity: lit },
+        { colour: 0, duration: period / 2, intensity: eclipsed }
+      ] : void 0;
+    case "Q":
+    case "VQ":
+    case "UQ":
+      return quick(character, group, period);
+    case "IQ":
+    case "IVQ":
+    case "IUQ":
+      return interruptedQuick(character.slice(1), period);
+    case "Mo":
+      return morseCode(group, period);
+    case "Q+LFl":
+    case "VQ+LFl":
+    case "UQ+LFl":
+    case "Fl+LFl":
+      return withLongFlash(character, group, period);
+    default:
+      return void 0;
+  }
+}
+function grouped(counts, period, pulse, pulseIntensity, gapIntensity) {
+  if (!counts || !period || !pulse || !(pulse >= limits.minPhase)) return void 0;
+  const pulses = sum(counts);
+  const groups = counts.length;
+  const free = period - pulses * pulse;
+  const units = pulses - groups + 2 * (groups - 1) + 3;
+  const gap = Math.min(2 * pulse, free / units);
+  if (!(gap >= limits.minPhase)) return void 0;
+  const phases = [];
+  counts.forEach((count, index) => {
+    for (let pulseIndex = 0; pulseIndex < count; pulseIndex += 1) {
+      phases.push({ colour: 0, duration: pulse, intensity: pulseIntensity });
+      if (pulseIndex < count - 1) {
+        phases.push({ colour: 0, duration: gap, intensity: gapIntensity });
+      }
+    }
+    if (index < groups - 1) phases.push({ colour: 0, duration: 2 * gap, intensity: gapIntensity });
+  });
+  const used = phases.reduce((total, phase) => total + phase.duration, 0);
+  phases.push({ colour: 0, duration: period - used, intensity: gapIntensity });
+  return phases;
+}
+function quick(character, group, period) {
+  const cycle = conventions.quickCycle[character];
+  const flash = cycle * conventions.quickDuty;
+  if (group === "") {
+    return [
+      { colour: 0, duration: flash, intensity: lit },
+      { colour: 0, duration: cycle - flash, intensity: eclipsed }
+    ];
+  }
+  const counts = groupCounts(group);
+  if (!counts) return void 0;
+  const count = sum(counts);
+  const cardinal = conventions.cardinalPeriods[character]?.[count];
+  const cyclePeriod = period ?? cardinal;
+  if (!cyclePeriod && count === 1) return quick(character, "", void 0);
+  if (!cyclePeriod || cyclePeriod < (count + 1) * cycle) return void 0;
+  return [
+    ...quickFlashes(count, cycle, flash),
+    { colour: 0, duration: cyclePeriod - count * cycle, intensity: eclipsed }
+  ];
+}
+function quickFlashes(count, cycle, flash) {
+  const phases = [];
+  for (let index = 0; index < count; index += 1) {
+    phases.push({ colour: 0, duration: flash, intensity: lit });
+    phases.push({ colour: 0, duration: cycle - flash, intensity: eclipsed });
+  }
+  return phases;
+}
+function interruptedQuick(character, period) {
+  const cycle = conventions.quickCycle[character];
+  if (!period) return void 0;
+  const count = Math.max(2, Math.floor(conventions.interruptedShare * period / cycle));
+  if (period < (count + 1) * cycle) return void 0;
+  return [
+    ...quickFlashes(count, cycle, cycle * conventions.quickDuty),
+    { colour: 0, duration: period - count * cycle, intensity: eclipsed }
+  ];
+}
+function withLongFlash(character, group, period) {
+  const first = character.slice(0, character.indexOf("+"));
+  const counts = groupCounts(group);
+  if (group !== "" && !counts) return void 0;
+  const count = counts ? sum(counts) : first === "Fl" ? 1 : 6;
+  const cyclePeriod = period ?? conventions.cardinalPeriods[character] ?? void 0;
+  if (typeof cyclePeriod !== "number") return void 0;
+  let phases;
+  if (first === "Fl") {
+    const flash = Math.min(conventions.flash, conventions.flashShare * cyclePeriod / (count + 2));
+    phases = [];
+    for (let index = 0; index < count; index += 1) {
+      phases.push({ colour: 0, duration: flash, intensity: lit });
+      phases.push({ colour: 0, duration: 2 * flash, intensity: eclipsed });
+    }
+  } else {
+    const cycle = conventions.quickCycle[first];
+    phases = quickFlashes(count, cycle, cycle * conventions.quickDuty);
+  }
+  phases.push({ colour: 0, duration: conventions.longFlash, intensity: lit });
+  const used = phases.reduce((total, phase) => total + phase.duration, 0);
+  const rest = cyclePeriod - used;
+  if (!(rest >= conventions.longFlash / 2)) return void 0;
+  phases.push({ colour: 0, duration: rest, intensity: eclipsed });
+  return phases;
+}
+function morseCode(group, period) {
+  const letters = [...group.toUpperCase().replaceAll(/\s+/gu, "")];
+  if (letters.length === 0 || letters.length > 4) return void 0;
+  const codes = letters.map((letter) => morse[letter]);
+  if (codes.some((code) => code === void 0)) return void 0;
+  const signalUnits = [];
+  codes.forEach((code, letterIndex) => {
+    [...code].forEach((signal, signalIndex) => {
+      if (signalIndex > 0) signalUnits.push({ units: 1, intensity: eclipsed });
+      signalUnits.push({ units: signal === "." ? 1 : 3, intensity: lit });
+    });
+    if (letterIndex < codes.length - 1) signalUnits.push({ units: 3, intensity: eclipsed });
+  });
+  const units = signalUnits.reduce((total, signal) => total + signal.units, 0);
+  const unit2 = period ? Math.min(conventions.morseUnit, period / (units + 3)) : conventions.morseUnit;
+  const cyclePeriod = period ?? (units + 7) * unit2;
+  if (!(unit2 >= limits.minPhase)) return void 0;
+  return [
+    ...signalUnits.map(({ units: count, intensity }) => ({
+      colour: 0,
+      duration: count * unit2,
+      intensity
+    })),
+    { colour: 0, duration: cyclePeriod - units * unit2, intensity: eclipsed }
+  ];
+}
+function alternatingFixed(colours, period) {
+  if (colours < 2 || !period) return void 0;
+  return Array.from({ length: colours }, (_, colour) => ({
+    colour,
+    duration: period / colours,
+    intensity: lit
+  }));
+}
+function alternateColours(phases, colours) {
+  const litPhases = phases.filter(({ intensity }) => intensity > eclipsed).length;
+  if (litPhases === 0) return [...phases];
+  const repeats = colours / gcd(litPhases, colours);
+  const result = [];
+  let next = 0;
+  for (let repeat = 0; repeat < repeats; repeat += 1) {
+    for (const phase of phases) {
+      if (phase.intensity > eclipsed) {
+        result.push({ ...phase, colour: next % colours });
+        next += 1;
+      } else {
+        result.push({ ...phase });
+      }
+    }
+  }
+  return result;
+}
+function finish(input) {
+  const phases = [];
+  for (const phase of input) {
+    const duration = Math.round(phase.duration * 1e3) / 1e3;
+    if (!Number.isFinite(duration) || duration < limits.minPhase) return void 0;
+    const previous = phases.at(-1);
+    if (previous && previous.intensity === phase.intensity && previous.colour === phase.colour) {
+      previous.duration = Math.round((previous.duration + duration) * 1e3) / 1e3;
+    } else {
+      phases.push({ colour: phase.colour, duration, intensity: phase.intensity });
+    }
+  }
+  if (phases.length > 1) {
+    const first = phases[0];
+    const last = phases.at(-1);
+    if (first.intensity === last.intensity && first.colour === last.colour) {
+      first.duration = Math.round((first.duration + last.duration) * 1e3) / 1e3;
+      phases.pop();
+    }
+  }
+  if (phases.length < 2 || phases.length > limits.maxPhases) return void 0;
+  const periodMs = phases.reduce((total, phase) => total + Math.round(phase.duration * 1e3), 0);
+  if (periodMs > limits.maxPeriod * 1e3) return void 0;
+  const frozen = Object.freeze(phases.map((phase) => Object.freeze({ ...phase })));
+  return Object.freeze({
+    key: frozen.map(
+      ({ colour, duration, intensity }) => `${Math.round(duration * 1e3)}:${intensity}:${colour}`
+    ).join(","),
+    period: periodMs / 1e3,
+    phases: frozen
+  });
+}
+function flashOf(counts, period) {
+  if (!counts || !period) return void 0;
+  return Math.min(conventions.flash, conventions.flashShare * period / sum(counts));
+}
+function longFlashOf(counts, period) {
+  if (!counts || !period) return void 0;
+  const pulses = sum(counts);
+  return period >= 2 * pulses * conventions.longFlash ? conventions.longFlash : conventions.flashShare * period / pulses;
+}
+function groupCounts(group) {
+  if (group === "") return [1];
+  const parts = group.split("+");
+  const counts = [];
+  for (const part of parts) {
+    if (!/^\s*\d{1,2}\s*$/u.test(part)) return void 0;
+    const count = Number(part);
+    if (count < 1) return void 0;
+    counts.push(count);
+  }
+  return sum(counts) <= 32 ? counts : void 0;
+}
+function groupText(value) {
+  if (typeof value === "number" && Number.isInteger(value)) return String(value);
+  return typeof value === "string" ? value.trim() : "";
+}
+function colourCount(value) {
+  if (typeof value !== "string") return 0;
+  return value.split(",").filter((name) => name.trim() !== "").length;
+}
+function positiveNumber(value) {
+  const number = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  return typeof number === "number" && Number.isFinite(number) && number > 0 ? number : void 0;
+}
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function gcd(a, b) {
+  return b === 0 ? a : gcd(b, a % b);
+}
+
 // src/icon-package.ts
 import { z as z10 } from "zod";
 var tileflowIconPackageFileNames = [
@@ -22299,7 +23749,7 @@ async function requestSessionGrant(input) {
       else throw error;
     }
     throwIfSessionGrantAborted(signal);
-    if (response.status === 409 && isRecord16(body) && body.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && body.ok === false && body.retryWithNewSession === true && body.sessionId === input.sessionId) {
+    if (response.status === 409 && isRecord17(body) && body.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && body.ok === false && body.retryWithNewSession === true && body.sessionId === input.sessionId) {
       throw new TileflowSessionRestartError();
     }
     if (!response.ok) {
@@ -22372,7 +23822,7 @@ function sessionGrantAbortReason(signal) {
   return error;
 }
 function parseSessionGrantResponse(value, expectedSessionId) {
-  if (!isRecord16(value) || value.ok !== true || value.sessionId !== expectedSessionId) return null;
+  if (!isRecord17(value) || value.ok !== true || value.sessionId !== expectedSessionId) return null;
   if (value.usageMode !== void 0 && value.usageMode !== "session") return null;
   if (value.billingEnabled !== void 0 && value.billingEnabled !== false) return null;
   if (value.disposition !== void 0 && value.disposition !== "ordinary" && value.disposition !== "unbilled_fail_open") {
@@ -22391,11 +23841,11 @@ function parseSessionGrantResponse(value, expectedSessionId) {
   }
   return value;
 }
-function isRecord16(value) {
+function isRecord17(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRuntimeRecord(value) {
-  if (!isRecord16(value)) return false;
+  if (!isRecord17(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -23860,7 +25310,7 @@ function readTileflowModelFileSummary(buffer) {
       height: round2(height, 100),
       footprint: {
         rings: footprint.length,
-        points: footprint.reduce((sum, ring) => sum + ring.length / 2, 0),
+        points: footprint.reduce((sum2, ring) => sum2 + ring.length / 2, 0),
         area: round2(Math.abs(area), 10)
       }
     };
@@ -24056,7 +25506,7 @@ function checkModel(model) {
     throw new RangeError("A footprint ring has at least three points.");
   if (footprint.some((ring) => ring.some((value) => !Number.isFinite(value))))
     throw new RangeError("A footprint point has no place.");
-  if (footprint.reduce((sum, ring) => sum + ring.length / 2, 0) > tileflowModelLimits.footprintPoints)
+  if (footprint.reduce((sum2, ring) => sum2 + ring.length / 2, 0) > tileflowModelLimits.footprintPoints)
     throw new RangeError(
       `A footprint has at most ${tileflowModelLimits.footprintPoints} points in all.`
     );
@@ -24322,7 +25772,7 @@ function validFootprint(footprint) {
   return points2 <= tileflowModelLimits.footprintPoints;
 }
 function readTileflowLandmarkRegion(json) {
-  if (!isRecord17(json)) return void 0;
+  if (!isRecord18(json)) return void 0;
   const named = json.format === "tileflow-landmark-region-v2";
   if (!named && json.format !== "tileflow-landmark-region-v1") return void 0;
   const region = json.region;
@@ -24353,7 +25803,7 @@ function readLandmarks(listed, tx, ty) {
   if (!Array.isArray(listed) || listed.length === 0) return void 0;
   const out = [];
   for (const landmark of listed) {
-    if (!isRecord17(landmark)) return void 0;
+    if (!isRecord18(landmark)) return void 0;
     const { id: id2, at, heading, footprint } = landmark;
     if (typeof id2 !== "string" || !landmarkId.test(id2)) return void 0;
     if (!Array.isArray(at) || at.length !== 2 || !at.every((value) => typeof value === "number"))
@@ -24377,10 +25827,10 @@ function readLandmarks(listed, tx, ty) {
   return out;
 }
 function readTileflowLandmarksTileJson(json, url) {
-  if (!isRecord17(json) || json.format !== "tileflow-landmarks-v2") return void 0;
+  if (!isRecord18(json) || json.format !== "tileflow-landmarks-v2") return void 0;
   const tile = Array.isArray(json.tiles) ? json.tiles[0] : void 0;
   const regions2 = json.regions;
-  if (typeof tile !== "string" || !tile.includes("{sha256}") || json.minzoom !== tileflowLandmarkTileZoom || json.maxzoom !== tileflowLandmarkTileZoom || !isRecord17(regions2) || regions2.zoom !== tileflowLandmarkRegionZoom || typeof regions2.url !== "string" || !regions2.url.includes("{x}") || !regions2.url.includes("{y}") || !Array.isArray(regions2.available))
+  if (typeof tile !== "string" || !tile.includes("{sha256}") || json.minzoom !== tileflowLandmarkTileZoom || json.maxzoom !== tileflowLandmarkTileZoom || !isRecord18(regions2) || regions2.zoom !== tileflowLandmarkRegionZoom || typeof regions2.url !== "string" || !regions2.url.includes("{x}") || !regions2.url.includes("{y}") || !Array.isArray(regions2.available))
     return void 0;
   const available = /* @__PURE__ */ new Set();
   for (const region of regions2.available) {
@@ -24398,7 +25848,7 @@ function readTileflowLandmarksTileJson(json, url) {
     regions: available
   };
 }
-function isRecord17(value) {
+function isRecord18(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -24437,6 +25887,7 @@ export {
   createTileflowLineBackgroundFontStack,
   createTileflowSessionController,
   createTileflowSessionId,
+  declareTileflowNauticalLights,
   decodeTileflowModels,
   decodeTileflowTreeModel,
   defaultTileflowManifestUrl,
@@ -24509,7 +25960,9 @@ export {
   readTileflowLandmarksTileJson,
   readTileflowModelFileIds,
   readTileflowModelFileSummary,
+  readTileflowNauticalLights,
   readTileflowNotices,
+  readTileflowSky,
   readTileflowStreetLights,
   readTileflowSunPreset,
   readTileflowTeamModelName,
@@ -24552,6 +26005,7 @@ export {
   sha256Hex,
   shouldLoadTileflowManifest,
   startTileflowSession,
+  steadyTileflowNauticalLights,
   tileflowAuthoringManifest,
   tileflowAuthoringManifestSchemaVersion,
   tileflowBandPlacements,
@@ -24630,6 +26084,10 @@ export {
   tileflowLandmarkTileOf,
   tileflowLandmarkTileZoom,
   tileflowLayerBands,
+  tileflowLightRhythm,
+  tileflowLightRhythmConventions,
+  tileflowLightRhythmLimits,
+  tileflowLightStateAt,
   tileflowLineBackgroundDefaults,
   tileflowLineBackgroundHaloRatio,
   tileflowLineBackgroundLimits,
@@ -24637,6 +26095,7 @@ export {
   tileflowLocalDirectoryMessage,
   tileflowMapDefaultMaxDepth,
   tileflowMapIdSchema,
+  tileflowMaxPitch,
   tileflowModelContentType,
   tileflowModelDefaultLightingRoles,
   tileflowModelFileName,
@@ -24647,8 +26106,14 @@ export {
   tileflowModelSurfaceLimits,
   tileflowModelTextureChannels,
   tileflowModelVertexBytes,
+  tileflowNauticalFacilityIcons,
   tileflowNauticalImageRoles,
+  tileflowNauticalLightEclipseOpacity,
+  tileflowNauticalLightStates,
+  tileflowNauticalLightsLimits,
+  tileflowNauticalLightsMetadataKey,
   tileflowNauticalNotice,
+  tileflowNauticalPromoteId,
   tileflowNauticalSourceId,
   tileflowNauticalV1Schema,
   tileflowNoticeLimits,
@@ -24676,6 +26141,8 @@ export {
   tileflowRuntimeManifestSchema,
   tileflowRuntimeManifestVersion,
   tileflowSemanticDiffSchemaVersion,
+  tileflowSkyAtSun,
+  tileflowSkyMetadataKey,
   tileflowStreetLightsMetadataKey,
   tileflowStyleFontFaceLimits,
   tileflowStyleFontFacesMetadataKey,