@tileflow/core 0.1.0-alpha.32 → 0.1.0-alpha.33

package/dist/index.js

@@ -440,6 +440,315 @@ var init_values = __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;
+  return turned < 0 ? turned + 360 : turned === 0 ? 0 : turned;
+}
+function tileflowSunPosition(date, location) {
+  const time = typeof date === "number" ? date : date.getTime();
+  const [longitude, latitude] = location;
+  if (!Number.isFinite(time)) throw new TypeError("The sun position needs a valid date.");
+  if (!Number.isFinite(longitude) || !Number.isFinite(latitude) || Math.abs(latitude) > 90) {
+    throw new TypeError(
+      "The sun position needs a [longitude, latitude] location in degrees, latitude from -90 to 90."
+    );
+  }
+  const t = (time / 864e5 + 24405875e-1 - 2451545) / 36525;
+  const meanLongitude = normalizeTileflowAzimuth(280.46646 + t * (36000.76983 + t * 3032e-7));
+  const meanAnomaly = 357.52911 + t * (35999.05029 - 1537e-7 * t);
+  const eccentricity = 0.016708634 - t * (42037e-9 + 1267e-10 * t);
+  const m = meanAnomaly * degrees;
+  const centre = Math.sin(m) * (1.914602 - t * (4817e-6 + 14e-6 * t)) + Math.sin(2 * m) * (0.019993 - 101e-6 * t) + Math.sin(3 * m) * 289e-6;
+  const omega = (125.04 - 1934.136 * t) * degrees;
+  const apparentLongitude = (meanLongitude + centre - 569e-5 - 478e-5 * Math.sin(omega)) * degrees;
+  const meanObliquity = 23 + (26 + (21.448 - t * (46.815 + t * (59e-5 - t * 1813e-6))) / 60) / 60;
+  const obliquity = (meanObliquity + 256e-5 * Math.cos(omega)) * degrees;
+  const declination = Math.asin(Math.sin(obliquity) * Math.sin(apparentLongitude));
+  const y = Math.tan(obliquity / 2) ** 2;
+  const l0 = meanLongitude * degrees;
+  const equation = 4 / degrees * (y * Math.sin(2 * l0) - 2 * eccentricity * Math.sin(m) + 4 * eccentricity * y * Math.sin(m) * Math.cos(2 * l0) - 0.5 * y * y * Math.sin(4 * l0) - 1.25 * eccentricity * eccentricity * Math.sin(2 * m));
+  const minutes = (time % 864e5 + 864e5) % 864e5 / 6e4;
+  const solarMinutes = ((minutes + equation + 4 * longitude) % 1440 + 1440) % 1440;
+  const hourAngle = (solarMinutes / 4 - 180) * degrees;
+  const phi = latitude * degrees;
+  const cosZenith = Math.min(
+    1,
+    Math.max(
+      -1,
+      Math.sin(phi) * Math.sin(declination) + Math.cos(phi) * Math.cos(declination) * Math.cos(hourAngle)
+    )
+  );
+  const elevation = 90 - Math.acos(cosZenith) / degrees;
+  const azimuth = normalizeTileflowAzimuth(
+    Math.atan2(
+      Math.sin(hourAngle),
+      Math.cos(hourAngle) * Math.sin(phi) - Math.tan(declination) * Math.cos(phi)
+    ) / degrees + 180
+  );
+  return Object.freeze({ azimuth, altitude: Math.min(90, elevation + refraction(elevation)) });
+}
+function refraction(elevation) {
+  if (elevation > 85) return 0;
+  const tangent = Math.tan(elevation * degrees);
+  let seconds;
+  if (elevation > 5) seconds = 58.1 / tangent - 0.07 / tangent ** 3 + 86e-6 / tangent ** 5;
+  else if (elevation > -0.575)
+    seconds = 1735 + elevation * (-518.2 + elevation * (103.4 + elevation * (-12.79 + elevation * 0.711)));
+  else seconds = -20.772 / tangent;
+  return seconds / 3600;
+}
+function tileflowSunDirection(azimuth, altitude) {
+  const a = azimuth * degrees;
+  const h = altitude * degrees;
+  return Object.freeze([
+    Math.sin(a) * Math.cos(h),
+    Math.cos(a) * Math.cos(h),
+    Math.sin(h)
+  ]);
+}
+function resolveTileflowSun(preset, direction = preset, source = "theme") {
+  const azimuth = normalizeTileflowAzimuth(direction.azimuth);
+  const altitude = Math.min(90, Math.max(-90, direction.altitude));
+  const horizon = smoothstep2(-0.5, 3, altitude);
+  const intensity = clamp01(preset.intensity) * horizon;
+  const rgb = rgbOf(preset.color);
+  const ambientRgb = rgbOf(preset.ambient.color);
+  const ambientIntensity = clamp01(preset.ambient.intensity);
+  const brightness = clamp01(
+    (luminance(ambientRgb) * ambientIntensity + luminance(rgb) * intensity * Math.max(0, Math.sin(altitude * degrees))) / 2
+  );
+  return Object.freeze({
+    azimuth,
+    altitude,
+    direction: tileflowSunDirection(azimuth, altitude),
+    color: preset.color,
+    rgb,
+    intensity,
+    shadowIntensity: clamp01(preset.shadowIntensity),
+    ambient: Object.freeze({
+      color: preset.ambient.color,
+      rgb: ambientRgb,
+      intensity: ambientIntensity
+    }),
+    brightness: Number(brightness.toFixed(6)),
+    source
+  });
+}
+function mixTileflowSunPresets(from, to, t) {
+  const at = clamp01(Number.isFinite(t) ? t : 0);
+  if (at === 0) return from;
+  if (at === 1) return to;
+  const colour = (a, b) => mixTileflowColours(a, b, at) ?? (at < 0.5 ? a : b);
+  const number = (a, b) => a + (b - a) * at;
+  return Object.freeze({
+    azimuth: mixTileflowAzimuths(from.azimuth, to.azimuth, at),
+    altitude: number(from.altitude, to.altitude),
+    color: colour(from.color, to.color),
+    intensity: number(from.intensity, to.intensity),
+    shadowIntensity: number(from.shadowIntensity, to.shadowIntensity),
+    ambient: Object.freeze({
+      color: colour(from.ambient.color, to.ambient.color),
+      intensity: number(from.ambient.intensity, to.ambient.intensity)
+    })
+  });
+}
+function mixTileflowAzimuths(from, to, t) {
+  let delta = normalizeTileflowAzimuth(to) - normalizeTileflowAzimuth(from);
+  if (delta > 180) delta -= 360;
+  if (delta < -180) delta += 360;
+  return normalizeTileflowAzimuth(from + delta * t);
+}
+function tileflowSunMetadata(preset) {
+  return Object.freeze({ version: 1, ...preset });
+}
+function readTileflowSunPreset(metadata) {
+  if (!isRecord3(metadata)) return void 0;
+  const value = metadata[tileflowSunMetadataKey];
+  if (!isRecord3(value) || value.version !== 1 || !isRecord3(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))
+    return void 0;
+  return Object.freeze({
+    azimuth: normalizeTileflowAzimuth(azimuth),
+    altitude: Math.min(90, Math.max(-90, altitude)),
+    color: color3,
+    intensity,
+    shadowIntensity,
+    ambient: Object.freeze({ color: ambient.color, intensity: ambient.intensity })
+  });
+}
+function tileflowStyleSunPreset(style) {
+  const published = readTileflowSunPreset(style?.metadata);
+  if (published) return published;
+  const light = isRecord3(style?.light) ? style.light : void 0;
+  const position = light?.position;
+  if (!position) return tileflowDefaultSunPreset;
+  return Object.freeze({
+    ...tileflowDefaultSunPreset,
+    azimuth: normalizeTileflowAzimuth(position[1]),
+    altitude: Math.min(90, Math.max(-90, 90 - position[2])),
+    ...typeof light.color === "string" && isColour(light.color) ? { color: light.color } : {}
+  });
+}
+function tileflowSunLight(direction, base) {
+  const radial = base?.position?.[0] ?? 1.15;
+  return {
+    ...base ?? {},
+    anchor: "map",
+    position: [
+      radial,
+      Number(normalizeTileflowAzimuth(direction.azimuth).toFixed(3)),
+      // MapLibre lights the extrusions from above the horizon only.
+      Number(Math.min(90, Math.max(0, 90 - direction.altitude)).toFixed(3))
+    ]
+  };
+}
+function rgbOf(colour) {
+  const channels = tileflowColourChannels(colour) ?? [1, 1, 1, 1];
+  return Object.freeze([channels[0], channels[1], channels[2]]);
+}
+function luminance([r, g, b]) {
+  const linear = (value) => value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
+}
+function smoothstep2(from, to, value) {
+  const t = clamp01((value - from) / (to - from));
+  return t * t * (3 - 2 * t);
+}
+function clamp01(value) {
+  return Math.min(1, Math.max(0, Number.isFinite(value) ? value : 0));
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isUnit(value) {
+  return isFiniteNumber(value) && value >= 0 && value <= 1;
+}
+function isColour(value) {
+  return typeof value === "string" && tileflowColourChannels(value) !== null;
+}
+var tileflowSunMetadataKey, tileflowDefaultSunPreset, degrees;
+var init_sun = __esm({
+  "src/sun.ts"() {
+    "use strict";
+    init_theme_blend();
+    tileflowSunMetadataKey = "tileflow:sun";
+    tileflowDefaultSunPreset = Object.freeze({
+      azimuth: 210,
+      altitude: 60,
+      color: "#ffffff",
+      intensity: 0.5,
+      shadowIntensity: 1,
+      ambient: Object.freeze({ color: "#ffffff", intensity: 0.5 })
+    });
+    degrees = Math.PI / 180;
+  }
+});
+
 // src/themes/visual-semantics.ts
 function classifyTileflowVisualProperty(property, _value) {
   if (property === "color" || property === "colors" || property.endsWith("Color") || property.endsWith("Colors") || property.endsWith("-color") || property.endsWith("-colors")) {
@@ -582,7 +891,7 @@ function defineTheme(baseOrDefinition, maybeDefinition) {
   const theme = {
     colorScheme: definition.colorScheme,
     id: definition.id,
-    lighting: mergeRecord(base?.lighting ?? {}, definition.lighting ?? {}),
+    lighting: mergeLighting(base?.lighting ?? {}, definition.lighting ?? {}),
     tokens: {
       color: mergeRecord(base?.tokens.color ?? {}, definition.tokens?.color ?? {}),
       font: mergeRecord(base?.tokens.font ?? {}, definition.tokens?.font ?? {}),
@@ -605,11 +914,12 @@ function resolveTileflowTheme(theme) {
     number: resolver.resolveCategory("number")
   };
   const typography = resolver.resolveTypography(theme.typography);
-  const lighting = resolver.resolveLighting(theme.lighting);
+  const { light: lighting, sun } = resolver.resolveLighting(theme.lighting);
   return {
     colorScheme: theme.colorScheme,
     id: theme.id,
     lighting,
+    ...sun ? { sun } : {},
     tokens,
     typography,
     version: theme.version
@@ -653,7 +963,7 @@ function auditTileflowThemeValues(value, path = "value", context = inferAuditCon
   return diagnostics.sort(compareAuditDiagnostics);
 }
 function auditTileflowMapThemeValues(map) {
-  const modules = isRecord3(map.modules) ? map.modules : void 0;
+  const modules = isRecord4(map.modules) ? map.modules : void 0;
   const moduleDiagnostics = modules ? Object.keys(modules).sort(compareCodeUnits2).flatMap(
     (owner) => auditTileflowThemeValues(modules[owner], `modules.${owner}`, {
       owner,
@@ -760,7 +1070,7 @@ function isThemePrimitiveForCategory(value, category) {
   return category === "number" ? typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every((entry) => typeof entry === "number" && Number.isFinite(entry)) : typeof value === "string" && value.length > 0;
 }
 function isThemeValueCandidate(value) {
-  return isRecord3(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
+  return isRecord4(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
 }
 function visitAuditableValue(value, path, category, state, intentRequired = false) {
   if (isThemeStructuralPath(path)) category = void 0;
@@ -776,7 +1086,7 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     visitAuditableArray(value, path, category, state, false, intentRequired);
     return;
   }
-  if (!isRecord3(value)) return;
+  if (!isRecord4(value)) return;
   if (value.kind === "expression" && Array.isArray(value.value)) {
     visitAuditableArray(value.value, `${path}.value`, category, state, true, intentRequired);
     return;
@@ -1122,6 +1432,24 @@ function assertThemeTypographyStyleFields(style, path) {
 function assertThemeLighting(value, path) {
   const lighting = assertPlainThemeRecord(value, path);
   assertExactThemeKeys(lighting, path, themeLightingKeys);
+  if (Object.hasOwn(lighting, "sun")) {
+    const sun = assertPlainThemeRecord(lighting.sun, `${path}.sun`);
+    assertExactThemeKeys(sun, `${path}.sun`, themeSunKeys);
+    for (const key of ["altitude", "azimuth", "intensity", "shadowIntensity"]) {
+      if (Object.hasOwn(sun, key))
+        assertThemeCategoryValue(sun[key], "number", `${path}.sun.${key}`);
+    }
+    if (Object.hasOwn(sun, "color"))
+      assertThemeCategoryValue(sun.color, "color", `${path}.sun.color`);
+  }
+  if (Object.hasOwn(lighting, "ambient")) {
+    const ambient = assertPlainThemeRecord(lighting.ambient, `${path}.ambient`);
+    assertExactThemeKeys(ambient, `${path}.ambient`, themeAmbientKeys);
+    if (Object.hasOwn(ambient, "intensity"))
+      assertThemeCategoryValue(ambient.intensity, "number", `${path}.ambient.intensity`);
+    if (Object.hasOwn(ambient, "color"))
+      assertThemeCategoryValue(ambient.color, "color", `${path}.ambient.color`);
+  }
   if (Object.hasOwn(lighting, "anchor") && lighting.anchor !== "map" && lighting.anchor !== "viewport") {
     throw themeTypeError(`${path}.anchor`, "map or viewport", lighting.anchor);
   }
@@ -1141,7 +1469,7 @@ function assertThemeLighting(value, path) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -1288,6 +1616,7 @@ function inferThemeCategoryFromPath(path) {
   const tokenCategory = path.match(/^theme\.tokens\.(color|font|image|number)(?:\.|$)/u)?.[1];
   if (isThemeTokenCategory(tokenCategory)) return tokenCategory;
   if (/^theme\.lighting\.position(?:\[\d+\])?$/u.test(path)) return "number";
+  if (/^theme\.lighting\.sun\.(?:altitude|azimuth|shadowIntensity)$/u.test(path)) return "number";
   const segments = path.replace(/\[\d+\]/g, "").split(".");
   return [...segments].reverse().map((segment) => classifyTileflowVisualProperty(segment)).find((category) => category !== void 0);
 }
@@ -1329,6 +1658,15 @@ function mergeOptionalStyle(key, base, overlay) {
   const value = mergeRecord(base[key] ?? {}, overlay?.[key] ?? {});
   return Object.keys(value).length ? { [key]: value } : {};
 }
+function mergeLighting(base, overlay) {
+  const merged = mergeRecord(base, overlay);
+  for (const key of ["sun", "ambient"]) {
+    if (base[key] !== void 0 && overlay[key] !== void 0) {
+      merged[key] = mergeRecord(base[key], overlay[key]);
+    }
+  }
+  return merged;
+}
 function mergeRecord(base, overlay) {
   if (!isPlainRecord(base) || !isPlainRecord(overlay)) {
     throw new Error("Tileflow theme composition accepts only plain JSON objects.");
@@ -1410,9 +1748,9 @@ function oklchToRgba({ c, h, l }) {
   const sLinear = sRoot ** 3;
   return {
     a: 1,
-    b: clamp01(-0.0041960863 * lLinear - 0.7034186147 * mLinear + 1.707614701 * sLinear),
-    g: clamp01(-1.2684380046 * lLinear + 2.6097574011 * mLinear - 0.3413193965 * sLinear),
-    r: clamp01(4.0767416621 * lLinear - 3.3077115913 * mLinear + 0.2309699292 * sLinear)
+    b: clamp012(-0.0041960863 * lLinear - 0.7034186147 * mLinear + 1.707614701 * sLinear),
+    g: clamp012(-1.2684380046 * lLinear + 2.6097574011 * mLinear - 0.3413193965 * sLinear),
+    r: clamp012(4.0767416621 * lLinear - 3.3077115913 * mLinear + 0.2309699292 * sLinear)
   };
 }
 function formatColor({ a, b, g, r }) {
@@ -1423,7 +1761,7 @@ function formatColor({ a, b, g, r }) {
   return `rgba(${channels[0]}, ${channels[1]}, ${channels[2]}, ${round(a, 4)})`;
 }
 function formatSrgbColor({ a, b, g, r }) {
-  const channels = [r, g, b].map((entry) => Math.round(clamp01(entry) * 255));
+  const channels = [r, g, b].map((entry) => Math.round(clamp012(entry) * 255));
   if (a >= 0.9995) {
     return `#${channels.map((entry) => entry.toString(16).padStart(2, "0")).join("")}`;
   }
@@ -1433,7 +1771,7 @@ function srgbToLinear(value) {
   return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
 }
 function linearToSrgb(value) {
-  const clamped = clamp01(value);
+  const clamped = clamp012(value);
   return clamped <= 31308e-7 ? clamped * 12.92 : 1.055 * clamped ** (1 / 2.4) - 0.055;
 }
 function assertColor(value, path) {
@@ -1480,7 +1818,7 @@ function describe(value) {
 function interpolate(from, to, amount) {
   return from + (to - from) * amount;
 }
-function clamp01(value) {
+function clamp012(value) {
   return Math.max(0, Math.min(1, value));
 }
 function round(value, digits) {
@@ -1492,24 +1830,25 @@ function cloneJson14(value) {
   if (serialized === void 0) throw new Error("Tileflow themes must be JSON-serializable.");
   return JSON.parse(serialized);
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord(value) {
-  if (!isRecord3(value)) return false;
+  if (!isRecord4(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
 function compareCodeUnits2(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
-var tileflowThemeLimits, TileflowThemeAuditError, defaultTypography, themeDocumentKeys, themeDefinitionRequiredKeys, themeTypographyStyleKeys, themeTypographyKeys, themeTypographyDomains, themeLightingKeys, expressionDataOperators, ThemeValueResolver, themeStructuralPathSegments;
+var tileflowThemeLimits, TileflowThemeAuditError, defaultTypography, themeDocumentKeys, themeDefinitionRequiredKeys, themeTypographyStyleKeys, themeTypographyKeys, themeTypographyDomains, themeLightingKeys, themeSunKeys, themeAmbientKeys, expressionDataOperators, ThemeValueResolver, themeStructuralPathSegments;
 var init_model = __esm({
   "src/themes/model.ts"() {
     "use strict";
     init_expression_operators();
     init_values();
     init_portable_identity_rules();
+    init_sun();
     init_visual_semantics();
     tileflowThemeLimits = Object.freeze({ maxThemes: 64 });
     TileflowThemeAuditError = class extends Error {
@@ -1545,7 +1884,9 @@ var init_model = __esm({
       "water"
     ];
     themeTypographyDomains = ["places", "poi", "roads", "water"];
-    themeLightingKeys = ["anchor", "color", "intensity", "position"];
+    themeLightingKeys = ["ambient", "anchor", "color", "intensity", "position", "sun"];
+    themeSunKeys = ["altitude", "azimuth", "color", "intensity", "shadowIntensity"];
+    themeAmbientKeys = ["color", "intensity"];
     expressionDataOperators = /* @__PURE__ */ new Set([
       "accumulated",
       "collator",
@@ -1606,7 +1947,7 @@ var init_model = __esm({
         if (Array.isArray(value)) {
           return value.map((entry, index) => this.resolveTree(entry, `${path}[${index}]`, category));
         }
-        if (!isRecord3(value)) return value;
+        if (!isRecord4(value)) return value;
         if (value.kind === "expression" && Array.isArray(value.value)) {
           return {
             ...value,
@@ -1646,6 +1987,65 @@ var init_model = __esm({
         };
       }
       resolveLighting(lighting) {
+        const { ambient, sun, ...flat } = lighting;
+        const light = this.#resolveFlatLight(flat);
+        if (sun === void 0 && ambient === void 0) return { light };
+        const resolvedSun = this.resolveTree(sun ?? {}, "theme.lighting.sun");
+        const resolvedAmbient = this.resolveTree(ambient ?? {}, "theme.lighting.ambient");
+        const defaults4 = tileflowDefaultSunPreset;
+        const number = (value, path, fallback, range2) => {
+          if (value === void 0) return fallback;
+          assertFiniteNumber(value, path);
+          if (range2 && (value < range2[0] || value > range2[1])) {
+            throw new Error(`Tileflow ${path} must be between ${range2[0]} and ${range2[1]}.`);
+          }
+          return value;
+        };
+        const colour = (value, path, fallback) => {
+          if (value === void 0) return fallback;
+          assertColor(value, path);
+          return value;
+        };
+        const preset = {
+          azimuth: normalizeTileflowAzimuth(
+            number(resolvedSun.azimuth, "theme.lighting.sun.azimuth", defaults4.azimuth)
+          ),
+          altitude: number(
+            resolvedSun.altitude,
+            "theme.lighting.sun.altitude",
+            defaults4.altitude,
+            [-90, 90]
+          ),
+          color: colour(resolvedSun.color, "theme.lighting.sun.color", defaults4.color),
+          intensity: number(
+            resolvedSun.intensity,
+            "theme.lighting.sun.intensity",
+            defaults4.intensity,
+            [0, 1]
+          ),
+          shadowIntensity: number(
+            resolvedSun.shadowIntensity,
+            "theme.lighting.sun.shadowIntensity",
+            defaults4.shadowIntensity,
+            [0, 1]
+          ),
+          ambient: {
+            color: colour(
+              resolvedAmbient.color,
+              "theme.lighting.ambient.color",
+              defaults4.ambient.color
+            ),
+            intensity: number(
+              resolvedAmbient.intensity,
+              "theme.lighting.ambient.intensity",
+              defaults4.ambient.intensity,
+              [0, 1]
+            )
+          }
+        };
+        return { light: sun === void 0 ? light : tileflowSunLight(preset, light), sun: preset };
+      }
+      #resolveFlatLight(lighting) {
         const result = this.resolveTree(lighting, "theme.lighting");
         if (result.anchor !== void 0 && result.anchor !== "map" && result.anchor !== "viewport") {
           throw themeTypeError("theme.lighting.anchor", "map or viewport", result.anchor);
@@ -2238,6 +2638,216 @@ function hasControlCharacter(value) {
   return false;
 }
 
+// src/capture-shot.ts
+import { z as z4 } from "zod";
+
+// src/capture-shot-motion.ts
+function tileflowShotStateAt(shot, at) {
+  const { keyframes } = shot;
+  const first = keyframes[0];
+  const last = keyframes.at(-1);
+  if (!first || !last || keyframes.length < 2)
+    throw new TypeError("A shot needs at least two keyframes.");
+  const time = Math.min(last.at, Math.max(first.at, Number.isFinite(at) ? at : first.at));
+  let segment = 0;
+  while (segment < keyframes.length - 2 && time > keyframes[segment + 1].at) segment += 1;
+  const from = keyframes[segment];
+  const to = keyframes[segment + 1];
+  const linear = Math.min(1, Math.max(0, (time - from.at) / (to.at - from.at)));
+  const t = shot.easing === "linear" ? linear : smoothstep(linear);
+  return {
+    at: time,
+    camera: interpolateCamera(cameraOf(from), cameraOf(to), t),
+    ...from.blend && to.blend ? { blendPosition: interpolateNumber(from.blend.position, to.blend.position, t) } : {}
+  };
+}
+function cameraOf({ camera }) {
+  return {
+    type: "center",
+    center: [camera.center[0], camera.center[1]],
+    zoom: camera.zoom,
+    bearing: camera.bearing ?? 0,
+    pitch: camera.pitch ?? 0
+  };
+}
+var maximumMercatorLatitude = 85.051129;
+function interpolateCamera(from, to, t) {
+  return {
+    type: "center",
+    center: interpolateCenter(from.center, to.center, t),
+    zoom: interpolateNumber(from.zoom, to.zoom, t),
+    bearing: interpolateBearing(from.bearing, to.bearing, t),
+    pitch: interpolateNumber(from.pitch, to.pitch, t)
+  };
+}
+function interpolateNumber(from, to, t) {
+  if (t <= 0 || from === to) return from;
+  if (t >= 1) return to;
+  return from + (to - from) * t;
+}
+function interpolateCenter(from, to, t) {
+  if (t <= 0 || from[0] === to[0] && from[1] === to[1]) return [from[0], from[1]];
+  if (t >= 1) return [to[0], to[1]];
+  const start = mercatorFromLngLat(from);
+  const end = mercatorFromLngLat(to);
+  let dx = end[0] - start[0];
+  if (dx > 0.5) dx -= 1;
+  else if (dx < -0.5) dx += 1;
+  return lngLatFromMercator([start[0] + dx * t, start[1] + (end[1] - start[1]) * t]);
+}
+function interpolateBearing(from, to, t) {
+  if (t <= 0 || from === to) return from;
+  if (t >= 1) return to;
+  const delta = ((to - from) % 360 + 540) % 360 - 180;
+  return wrapDegrees(from + delta * t);
+}
+function mercatorFromLngLat([longitude, latitude]) {
+  const clamped = Math.max(-maximumMercatorLatitude, Math.min(maximumMercatorLatitude, latitude));
+  return [
+    (180 + longitude) / 360,
+    (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + clamped * Math.PI / 360))) / 360
+  ];
+}
+function lngLatFromMercator([x, y]) {
+  const latitude = 360 / Math.PI * Math.atan(Math.exp((180 - y * 360) * Math.PI / 180)) - 90;
+  return [wrapDegrees(x * 360 - 180), latitude];
+}
+function wrapDegrees(value) {
+  if (value >= -180 && value <= 180) return value;
+  return ((value + 180) % 360 + 360) % 360 - 180;
+}
+function smoothstep(t) {
+  return t * t * (3 - 2 * t);
+}
+
+// src/capture-shot.ts
+init_portable_identity();
+var tileflowCaptureShotSchemaVersion = 1;
+var tileflowCaptureShotLimits = Object.freeze({
+  blendThemes: Object.freeze({ maximum: 8, minimum: 2 }),
+  defaultFps: 30,
+  durationMs: Object.freeze({ maximum: 6e4 }),
+  fps: Object.freeze([24, 25, 30, 50, 60]),
+  keyframes: Object.freeze({ maximum: 64, minimum: 2 }),
+  maximumFrames: 3600
+});
+var tileflowCaptureShotNameSchema = tileflowCaptureSceneNameSchema;
+var tileflowCaptureShotBlendSchema = z4.object({
+  themes: z4.array(tileflowThemeNameSchema).min(tileflowCaptureShotLimits.blendThemes.minimum).max(tileflowCaptureShotLimits.blendThemes.maximum),
+  position: z4.number().finite().min(0)
+}).strict().superRefine((blend, context) => {
+  if (new Set(blend.themes).size !== blend.themes.length) {
+    context.addIssue({ code: "custom", message: "Expected distinct themes", path: ["themes"] });
+  }
+  if (blend.position > blend.themes.length - 1) {
+    context.addIssue({
+      code: "custom",
+      message: `Expected a position from 0 to ${blend.themes.length - 1}`,
+      path: ["position"]
+    });
+  }
+});
+var tileflowCaptureShotKeyframeSchema = z4.object({
+  at: z4.number().int().min(0).max(tileflowCaptureShotLimits.durationMs.maximum),
+  camera: tileflowCaptureCenterCameraSchema,
+  blend: tileflowCaptureShotBlendSchema.optional()
+}).strict();
+var tileflowCaptureShotFields = {
+  theme: tileflowThemeNameSchema,
+  viewport: tileflowCaptureViewportSchema,
+  fps: z4.literal(tileflowCaptureShotLimits.fps).optional(),
+  keyframes: z4.array(tileflowCaptureShotKeyframeSchema).min(tileflowCaptureShotLimits.keyframes.minimum).max(tileflowCaptureShotLimits.keyframes.maximum),
+  easing: z4.enum(["smooth", "linear"]).optional()
+};
+var tileflowCaptureShotSchema = z4.object({ map: tileflowPortableIdSchema, ...tileflowCaptureShotFields }).strict().superRefine(checkShotTiming);
+var tileflowMapShotSchema = z4.object(tileflowCaptureShotFields).strict().superRefine(checkShotTiming);
+function normalizeTileflowCaptureShot(input) {
+  const shot = tileflowCaptureShotSchema.parse(input);
+  return { map: shot.map, ...normalizeShotFields(shot) };
+}
+function tileflowCaptureShotFrameCount(shot) {
+  const fps = shot.fps ?? tileflowCaptureShotLimits.defaultFps;
+  const duration = shot.keyframes.at(-1)?.at ?? 0;
+  return Math.floor(duration * fps / 1e3 + 1e-9) + 1;
+}
+function tileflowCaptureShotFrames(shot) {
+  const { map: _map, ...fields } = shot;
+  const normalized = normalizeShotFields(tileflowMapShotSchema.parse(fields));
+  const count = tileflowCaptureShotFrameCount(normalized);
+  const duration = normalized.keyframes.at(-1).at;
+  const frames = [];
+  for (let index = 0; index < count; index += 1) {
+    const at = Math.min(duration, index * 1e3 / normalized.fps);
+    frames.push({ index, ...tileflowShotStateAt(normalized, at) });
+  }
+  return frames;
+}
+function normalizeShotFields(shot) {
+  return {
+    theme: shot.theme,
+    viewport: { ...shot.viewport, dpr: shot.viewport.dpr ?? 1 },
+    fps: shot.fps ?? tileflowCaptureShotLimits.defaultFps,
+    easing: shot.easing ?? "smooth",
+    keyframes: shot.keyframes.map((keyframe) => ({
+      at: keyframe.at,
+      camera: {
+        type: "center",
+        center: keyframe.camera.center,
+        zoom: keyframe.camera.zoom,
+        bearing: keyframe.camera.bearing ?? 0,
+        pitch: keyframe.camera.pitch ?? 0
+      },
+      ...keyframe.blend ? { blend: { themes: [...keyframe.blend.themes], position: keyframe.blend.position } } : {}
+    }))
+  };
+}
+function checkShotTiming(shot, context) {
+  const { keyframes } = shot;
+  if (keyframes[0] && keyframes[0].at !== 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Expected the first keyframe at 0 milliseconds",
+      path: ["keyframes", 0, "at"]
+    });
+  }
+  for (let index = 1; index < keyframes.length; index += 1) {
+    if (keyframes[index].at <= keyframes[index - 1].at) {
+      context.addIssue({
+        code: "custom",
+        message: "Expected a time after the previous keyframe",
+        path: ["keyframes", index, "at"]
+      });
+    }
+  }
+  const blended = keyframes.filter((keyframe) => keyframe.blend !== void 0);
+  if (blended.length > 0) {
+    const themes = JSON.stringify(blended[0].blend.themes);
+    keyframes.forEach((keyframe, index) => {
+      if (!keyframe.blend) {
+        context.addIssue({
+          code: "custom",
+          message: "Expected a blend on every keyframe when one keyframe blends themes",
+          path: ["keyframes", index, "blend"]
+        });
+      } else if (JSON.stringify(keyframe.blend.themes) !== themes) {
+        context.addIssue({
+          code: "custom",
+          message: "Expected the same themes, in the same order, on every keyframe",
+          path: ["keyframes", index, "blend", "themes"]
+        });
+      }
+    });
+  }
+  const frames = tileflowCaptureShotFrameCount(shot);
+  if (frames > tileflowCaptureShotLimits.maximumFrames) {
+    context.addIssue({
+      code: "custom",
+      message: `Expected at most ${tileflowCaptureShotLimits.maximumFrames} frames; this shot renders ${frames}`,
+      path: ["keyframes", keyframes.length - 1, "at"]
+    });
+  }
+}
+
 // src/cartography/compilation-report.ts
 var tileflowCompilationReportSchemaVersion = 1;
 var tileflowCompilationPhases = Object.freeze([
@@ -2379,7 +2989,7 @@ var tileflowWorldGeneration = "v1";
 var tileflowWorldTileJsonUrl = "https://api.tileflow.dev/tiles/world/tiles.json";
 
 // src/data/world-release-id.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/data/world-release-id-values.ts
 var tileflowWorldReleaseIdMinimumLength = 12;
@@ -2391,7 +3001,7 @@ function isTileflowWorldReleaseId(value) {
 }
 
 // src/data/world-release-id.ts
-var tileflowWorldReleaseIdSchema = z4.string().min(tileflowWorldReleaseIdMinimumLength).max(tileflowWorldReleaseIdMaximumLength).regex(tileflowWorldReleaseIdPattern);
+var tileflowWorldReleaseIdSchema = z5.string().min(tileflowWorldReleaseIdMinimumLength).max(tileflowWorldReleaseIdMaximumLength).regex(tileflowWorldReleaseIdPattern);
 
 // src/data/index.ts
 var tileflowPrimarySourceId = "tileflow";
@@ -7608,7 +8218,7 @@ function compileRoads(request, context) {
       });
     }
   }
-  compileSidewalks(request?.sidewalks, context, contributions);
+  compileSidewalks(request?.sidewalks, areaStyles.pedestrian?.fill?.color, context, contributions);
   compileRoundabouts(request?.roundabouts, context, contributions);
   compileCrossings(request?.crossings, context, contributions);
   if (semantics.oneWayMarkers && visible.size > 0) {
@@ -7677,15 +8287,15 @@ function roadPhysicalCohort(roadClass) {
   if (roadClass === "minor" || roadClass === "service" || roadClass === "track") return "local";
   return "path";
 }
-function compileSidewalks(request, context, contributions) {
+function compileSidewalks(request, pedestrianAreaColor, context, contributions) {
   const { fields, layers } = context.data.schema;
   if (!layers.sidewalk) return;
   const config = mergeTileflowDesign(
     {
       surface: {
-        color: context.colors.roads.casing,
+        color: pedestrianAreaColor ?? context.colors.road,
         minZoom: 17,
-        opacity: 0.96
+        opacity: 1
       }
     },
     request
@@ -8337,10 +8947,10 @@ function roadWidth(roadClass, scale) {
       [16, 3.4]
     ]
   };
-  return zoom.linear(stops[roadClass].map(([z14, value]) => [z14, value * scale]));
+  return zoom.linear(stops[roadClass].map(([z15, value]) => [z15, value * scale]));
 }
 function widen(value, addition) {
-  return zoom.linear(value.stops.map(([z14, width]) => [z14, width + addition]));
+  return zoom.linear(value.stops.map(([z15, width]) => [z15, width + addition]));
 }
 function structureFilter(field2, structure) {
   if (structure === "surface") {
@@ -9661,7 +10271,7 @@ function isPlainRecord2(value) {
 
 // src/resolved-map-schema.ts
 import { Color as Color3 } from "@maplibre/maplibre-gl-style-spec";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/cartography/data-expression.ts
 init_values();
@@ -9844,24 +10454,39 @@ function validateStops(stops, api) {
   }
 }
 function validateOperandCount(count, api) {
-  if (count > tileflowDataExpressionLimits.maxOperands) {
-    throw new Error(
-      `${api} supports at most ${tileflowDataExpressionLimits.maxOperands} operands.`
+  const limit = tileflowDataExpressionLimits.maxOperands;
+  if (count > limit) {
+    throw limitError(
+      `${api} received ${count} operands; it supports at most ${limit}. Nest ${api} calls of at most ${limit} operands each.`
     );
   }
 }
 function validateBranchCount(count, api) {
-  if (count > tileflowDataExpressionLimits.maxBranches) {
-    throw new Error(
-      `${api} supports at most ${tileflowDataExpressionLimits.maxBranches} branches.`
+  const limit = tileflowDataExpressionLimits.maxBranches;
+  if (count > limit) {
+    throw limitError(
+      `${api} received ${count} branches; it supports at most ${limit}. Split the lookup into nested ${api} groups of at most ${limit} branches, or reduce the mapping.`
     );
   }
 }
 function validateStopCount(count, api) {
-  if (count > tileflowDataExpressionLimits.maxStops) {
-    throw new Error(`${api} supports at most ${tileflowDataExpressionLimits.maxStops} stops.`);
+  const limit = tileflowDataExpressionLimits.maxStops;
+  if (count > limit) {
+    throw limitError(
+      `${api} received ${count} stops; it supports at most ${limit}. Remove stops the curve can interpolate.`
+    );
   }
 }
+function limitError(message) {
+  const site = authoringCallSite(new Error().stack);
+  return new Error(site ? `${message} Called at ${site}.` : message);
+}
+function authoringCallSite(stack) {
+  const locations = (stack ?? "").split("\n").slice(1).map((line) => /\(?([^()\s]+?):(\d+):(\d+)\)?$/.exec(line.trim())).filter((match2) => match2 !== null).map(([, file, line, column]) => ({ file: file.replace(/^file:\/\//, ""), line, column }));
+  const own = locations[0]?.file;
+  const site = locations.find(({ file }) => file !== own && !file.startsWith("node:"));
+  return site ? `${site.file}:${site.line}:${site.column}` : void 0;
+}
 function node(value) {
   if (isTileflowExpression(value)) return cloneJson19(value.value);
   if (isDataFieldReference(value)) return ["get", cloneJson19(value)];
@@ -10055,7 +10680,11 @@ function visitExpression(value, path, variables, issues) {
         return;
       }
       if ((value.length - 2) / 2 > branchLimit) {
-        addExpressionIssue(issues, path, `Expression case exceeds ${branchLimit} branches.`);
+        addExpressionIssue(
+          issues,
+          path,
+          `Expression case has ${(value.length - 2) / 2} branches and exceeds ${branchLimit}.`
+        );
         return;
       }
       for (let index = 1; index < value.length; index += 1) visit(value[index], index);
@@ -10071,7 +10700,11 @@ function visitExpression(value, path, variables, issues) {
         return;
       }
       if ((value.length - 3) / 2 > branchLimit) {
-        addExpressionIssue(issues, path, `Expression match exceeds ${branchLimit} branches.`);
+        addExpressionIssue(
+          issues,
+          path,
+          `Expression match has ${(value.length - 3) / 2} branches and exceeds ${branchLimit}.`
+        );
         return;
       }
       visit(value[1], 1);
@@ -10300,21 +10933,21 @@ function bindSemanticValue(value, schema, sourceId) {
   }
   if (isDataSourceReference(value)) return sourceId;
   if (Array.isArray(value)) return value.map((item) => bindSemanticValue(item, schema, sourceId));
-  if (!isRecord4(value)) return value;
+  if (!isRecord5(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([key, item]) => [key, bindSemanticValue(item, schema, sourceId)])
   );
 }
 function isDataFieldReference2(value) {
-  return isRecord4(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
+  return isRecord5(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
 }
 function isDataLayerReference(value) {
-  return isRecord4(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
+  return isRecord5(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
 }
 function isDataSourceReference(value) {
-  return isRecord4(value) && value.kind === "tileflow-data-source" && value.name === "primary";
+  return isRecord5(value) && value.kind === "tileflow-data-source" && value.name === "primary";
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compareCodeUnits5(left, right) {
@@ -10418,8 +11051,8 @@ function createTileflowLayerTemplateIR(layer, semanticKey) {
     renderer: type,
     ...filter === void 0 ? {} : { selector: cloneJson20(filter) },
     style: Object.freeze({
-      ...isRecord5(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
-      ...isRecord5(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
+      ...isRecord6(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
+      ...isRecord6(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
     })
   });
 }
@@ -10659,21 +11292,21 @@ function visitReferences(value, counts, visited = /* @__PURE__ */ new WeakSet())
   }
 }
 function isSemanticFieldReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-field";
+  return isRecord6(value) && value.kind === "tileflow-data-field";
 }
 function isSemanticLayerReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-layer";
+  return isRecord6(value) && value.kind === "tileflow-data-layer";
 }
 function isSemanticSourceReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-source";
+  return isRecord6(value) && value.kind === "tileflow-data-source";
 }
 function cloneJson20(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord4(value) {
-  return isRecord5(value) ? value : {};
+  return isRecord6(value) ? value : {};
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -10737,7 +11370,7 @@ function validateTileflowRenderSelectorConstraints(input) {
   };
   while (pending.length > 0) {
     const current = pending.pop();
-    if (!isRecord6(current.selector) || typeof current.selector.kind !== "string") {
+    if (!isRecord7(current.selector) || typeof current.selector.kind !== "string") {
       addIssue(
         "invalid-selector",
         "a render selector must be a semantic selector node",
@@ -10798,7 +11431,7 @@ function validateTileflowRenderSelectorConstraints(input) {
         }
         for (const [index, branch] of current.selector.branches.entries()) {
           const branchPath = [...branchesPath, index];
-          if (!isRecord6(branch)) {
+          if (!isRecord7(branch)) {
             addIssue("invalid-selector", "match selector branch must be an object", branchPath);
             continue;
           }
@@ -10829,14 +11462,14 @@ function validateTileflowRenderSelectorConstraints(input) {
         for (let index = current.selector.stops.length - 1; index >= 0; index -= 1) {
           const stop = current.selector.stops[index];
           const stopPath = [...stopsPath, index];
-          if (!isRecord6(stop)) {
+          if (!isRecord7(stop)) {
             addIssue("invalid-selector", "step selector stop must be an object", stopPath);
             continue;
           }
           pushChild(stop.selector, current.depth + 1, [...stopPath, "selector"]);
         }
         for (const [index, stop] of current.selector.stops.entries()) {
-          if (!isRecord6(stop)) continue;
+          if (!isRecord7(stop)) continue;
           const zoom3 = stop.zoom;
           const zoomPath = [...stopsPath, index, "zoom"];
           if (typeof zoom3 !== "number" || !Number.isFinite(zoom3) || zoom3 < 0 || zoom3 > 24) {
@@ -11219,7 +11852,7 @@ function applyRendererStyle(layer, renderer, style) {
   };
 }
 function lowerSelector(selector, data) {
-  if (!isRecord6(selector) || typeof selector.kind !== "string") {
+  if (!isRecord7(selector) || typeof selector.kind !== "string") {
     throw renderStackError(
       "invalid-selector",
       "A render selector must be a semantic selector node."
@@ -11422,7 +12055,7 @@ function requireRenderer(value) {
 function requirePlacement(value) {
   if (typeof value === "string") {
     if (tileflowBandPlacements.includes(value)) return;
-  } else if (isRecord6(value)) {
+  } else if (isRecord7(value)) {
     const keys = Object.keys(value);
     if (keys.length === 1 && (keys[0] === "above" || keys[0] === "below")) {
       requirePortableTarget(value[keys[0]], "render placement target");
@@ -11449,7 +12082,7 @@ function validateRefinementShape(operation) {
   validateStyle(operation.renderer, operation.style);
 }
 function validateStyle(renderer, style) {
-  if (!isRecord6(style)) {
+  if (!isRecord7(style)) {
     throw renderStackError(
       "invalid-style",
       `A ${renderer} render operation requires a style object.`
@@ -11551,7 +12184,7 @@ function normalizeRequirements(requirements) {
   return [...requirements];
 }
 function requireRenderStackEntries(stack) {
-  if (!isRecord6(stack)) {
+  if (!isRecord7(stack)) {
     throw renderStackError("invalid-stack", "A render stack must be a named operation record.");
   }
   const entries = Object.entries(stack);
@@ -11698,9 +12331,9 @@ function cloneJson21(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord5(value) {
-  return isRecord6(value) ? value : {};
+  return isRecord7(value) ? value : {};
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -11708,18 +12341,18 @@ function isRecord6(value) {
 init_values();
 
 // src/icon-set.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var tileflowIconSourceLimit = 32;
 var slug = "[a-z0-9]+(?:-[a-z0-9]+)*";
-var tileflowIconSetReferenceSchema = z5.string().max(130).regex(
+var tileflowIconSetReferenceSchema = z6.string().max(130).regex(
   new RegExp(`^@${slug}/${slug}$`, "u"),
   "Expected a canonical @team/set reference without a version suffix"
 ).refine(
   (value) => value.slice(1).split("/").every((part) => part.length <= 64),
   "Team and set slugs must contain at most 64 characters"
 );
-var tileflowIconSetSourceSchema = z5.object({
-  kind: z5.literal("icon-set"),
+var tileflowIconSetSourceSchema = z6.object({
+  kind: z6.literal("icon-set"),
   reference: tileflowIconSetReferenceSchema
 }).strict();
 function iconSet(reference) {
@@ -11730,10 +12363,10 @@ function iconSet(reference) {
 function isTileflowIconSetSource(value) {
   return tileflowIconSetSourceSchema.safeParse(value).success;
 }
-var tileflowIconSetIdSchema = z5.string().regex(/^ics_[A-Za-z0-9_-]{16}$/u);
-var tileflowIconSetVersionIdSchema = z5.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u);
-var tileflowIconSetPackageIdSchema = z5.string().regex(/^icp_[A-Za-z0-9_-]{16,64}$/u);
-var tileflowIconSetTeamIdSchema = z5.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var tileflowIconSetIdSchema = z6.string().regex(/^ics_[A-Za-z0-9_-]{16}$/u);
+var tileflowIconSetVersionIdSchema = z6.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u);
+var tileflowIconSetPackageIdSchema = z6.string().regex(/^icp_[A-Za-z0-9_-]{16,64}$/u);
+var tileflowIconSetTeamIdSchema = z6.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/u);
 var TileflowIconSetError = class extends Error {
   constructor(code, message, options) {
     super(message, options);
@@ -11923,11 +12556,11 @@ var TileflowResolvedMapValidationError = class extends Error {
     this.messages = messages;
   }
 };
-var identifierSchema = z6.string().trim().regex(/^[A-Za-z0-9_-]+$/, "Expected letters, numbers, underscores, or hyphens").refine((value) => value !== "__proto__", "Expected a safe identifier");
-var revisionSchema = z6.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Expected a portable data revision");
-var zoomNumberSchema = z6.number().finite().min(0).max(24);
+var identifierSchema = z7.string().trim().regex(/^[A-Za-z0-9_-]+$/, "Expected letters, numbers, underscores, or hyphens").refine((value) => value !== "__proto__", "Expected a safe identifier");
+var revisionSchema = z7.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Expected a portable data revision");
+var zoomNumberSchema = z7.number().finite().min(0).max(24);
 function zoomValueSchemaFor(valueSchema) {
-  const stops = z6.array(z6.tuple([zoomNumberSchema, valueSchema])).min(1).superRefine((entries, context) => {
+  const stops = z7.array(z7.tuple([zoomNumberSchema, valueSchema])).min(1).superRefine((entries, context) => {
     for (let index = 1; index < entries.length; index += 1) {
       if (entries[index][0] <= entries[index - 1][0]) {
         context.addIssue({
@@ -11938,105 +12571,105 @@ function zoomValueSchemaFor(valueSchema) {
       }
     }
   });
-  return z6.discriminatedUnion("interpolation", [
-    z6.object({
-      base: z6.number().finite().positive(),
-      interpolation: z6.literal("exponential"),
-      kind: z6.literal("zoom"),
+  return z7.discriminatedUnion("interpolation", [
+    z7.object({
+      base: z7.number().finite().positive(),
+      interpolation: z7.literal("exponential"),
+      kind: z7.literal("zoom"),
       stops
     }).strict(),
-    z6.object({
-      interpolation: z6.literal("linear"),
-      kind: z6.literal("zoom"),
+    z7.object({
+      interpolation: z7.literal("linear"),
+      kind: z7.literal("zoom"),
       stops
     }).strict(),
-    z6.object({
-      interpolation: z6.literal("step"),
-      kind: z6.literal("zoom"),
+    z7.object({
+      interpolation: z7.literal("step"),
+      kind: z7.literal("zoom"),
       stops
     }).strict()
   ]);
 }
-var themeTokenNameSchema = z6.string().regex(
+var themeTokenNameSchema = z7.string().regex(
   /^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)*$/,
   "Expected a portable dot-separated semantic token name"
 );
-var themeTokenReferenceSchema = z6.object({
-  category: z6.enum(tileflowThemeTokenCategories),
-  kind: z6.literal("theme-token"),
+var themeTokenReferenceSchema = z7.object({
+  category: z7.enum(tileflowThemeTokenCategories),
+  kind: z7.literal("theme-token"),
   token: themeTokenNameSchema
 }).strict();
 var themeNumberReferenceSchema = themeTokenReferenceSchema.extend({
-  category: z6.literal("number")
+  category: z7.literal("number")
 });
-var fixedNumberSchema = z6.object({
-  kind: z6.literal("theme-fixed"),
-  reason: z6.string().trim().min(1),
-  value: z6.number().finite()
+var fixedNumberSchema = z7.object({
+  kind: z7.literal("theme-fixed"),
+  reason: z7.string().trim().min(1),
+  value: z7.number().finite()
 }).strict();
-var fixedNumberArraySchema = z6.object({
-  kind: z6.literal("theme-fixed"),
-  reason: z6.string().trim().min(1),
-  value: z6.array(z6.number().finite())
+var fixedNumberArraySchema = z7.object({
+  kind: z7.literal("theme-fixed"),
+  reason: z7.string().trim().min(1),
+  value: z7.array(z7.number().finite())
 }).strict();
-var fixedNumberOffsetSchema = z6.object({
-  kind: z6.literal("theme-fixed"),
-  reason: z6.string().trim().min(1),
-  value: z6.tuple([z6.number().finite(), z6.number().finite()])
+var fixedNumberOffsetSchema = z7.object({
+  kind: z7.literal("theme-fixed"),
+  reason: z7.string().trim().min(1),
+  value: z7.tuple([z7.number().finite(), z7.number().finite()])
 }).strict();
-var fixedNumberInsetsSchema = z6.object({
-  kind: z6.literal("theme-fixed"),
-  reason: z6.string().trim().min(1),
-  value: z6.tuple([
-    z6.number().finite(),
-    z6.number().finite(),
-    z6.number().finite(),
-    z6.number().finite()
+var fixedNumberInsetsSchema = z7.object({
+  kind: z7.literal("theme-fixed"),
+  reason: z7.string().trim().min(1),
+  value: z7.tuple([
+    z7.number().finite(),
+    z7.number().finite(),
+    z7.number().finite(),
+    z7.number().finite()
   ])
 }).strict();
-var fixedStringSchema = z6.object({ kind: z6.literal("theme-fixed"), reason: z6.string().trim().min(1), value: z6.string() }).strict();
-var themeColorOperationSchema = z6.lazy(
-  () => z6.discriminatedUnion("operation", [
-    z6.object({
+var fixedStringSchema = z7.object({ kind: z7.literal("theme-fixed"), reason: z7.string().trim().min(1), value: z7.string() }).strict();
+var themeColorOperationSchema = z7.lazy(
+  () => z7.discriminatedUnion("operation", [
+    z7.object({
       color: themeColorValueSchema,
-      kind: z6.literal("theme-color"),
+      kind: z7.literal("theme-color"),
       opacity: themeNumberValueSchema,
-      operation: z6.literal("alpha")
+      operation: z7.literal("alpha")
     }).strict(),
-    z6.object({
+    z7.object({
       amount: themeNumberValueSchema,
       from: themeColorValueSchema,
-      kind: z6.literal("theme-color"),
-      operation: z6.literal("mix"),
-      space: z6.literal("oklch"),
+      kind: z7.literal("theme-color"),
+      operation: z7.literal("mix"),
+      space: z7.literal("oklch"),
       to: themeColorValueSchema
     }).strict()
   ])
 );
-var themeNumberValueSchema = z6.lazy(
-  () => z6.union([z6.number().finite(), fixedNumberSchema, themeNumberReferenceSchema])
+var themeNumberValueSchema = z7.lazy(
+  () => z7.union([z7.number().finite(), fixedNumberSchema, themeNumberReferenceSchema])
 );
-var themeColorValueSchema = z6.lazy(
-  () => z6.union([
-    z6.string().min(1),
+var themeColorValueSchema = z7.lazy(
+  () => z7.union([
+    z7.string().min(1),
     fixedStringSchema,
-    themeTokenReferenceSchema.extend({ category: z6.literal("color") }),
+    themeTokenReferenceSchema.extend({ category: z7.literal("color") }),
     themeColorOperationSchema
   ])
 );
-var themeFontValueSchema = z6.union([
-  z6.string().min(1),
+var themeFontValueSchema = z7.union([
+  z7.string().min(1),
   fixedStringSchema,
-  themeTokenReferenceSchema.extend({ category: z6.literal("font") })
+  themeTokenReferenceSchema.extend({ category: z7.literal("font") })
 ]);
-var themeImageValueSchema = z6.union([
-  z6.string().min(1),
+var themeImageValueSchema = z7.union([
+  z7.string().min(1),
   fixedStringSchema,
-  themeTokenReferenceSchema.extend({ category: z6.literal("image") })
+  themeTokenReferenceSchema.extend({ category: z7.literal("image") })
 ]);
 function expressionSchemaFor(expectedCategory) {
   const category = expectedCategory ?? "structural";
-  return z6.object({ kind: z6.literal("expression"), value: z6.array(z6.unknown()).min(1) }).strict().superRefine((expression2, context) => {
+  return z7.object({ kind: z7.literal("expression"), value: z7.array(z7.unknown()).min(1) }).strict().superRefine((expression2, context) => {
     for (const issue of validateTileflowDataExpression(expression2.value)) {
       context.addIssue({
         code: "custom",
@@ -12083,18 +12716,20 @@ function validateExpressionThemeValues(value, expectedCategory, context, path) {
     if (!parsed.success || parsed.data.category !== expectedCategory) {
       context.addIssue({
         code: "custom",
-        message: expectedCategory === void 0 ? "Structural expressions cannot contain theme-token references" : `Expected a ${expectedCategory} theme-token reference`,
+        message: expectedCategory === void 0 ? `Structural expressions cannot contain theme-token references. ${structuralThemeValueHint}` : parsed.success ? `Expected a ${expectedCategory} theme-token reference, received ${parsed.data.category} token "${parsed.data.token}". ${expressionOperandHint(expectedCategory)}` : `Expected a ${expectedCategory} theme-token reference`,
         path
       });
     }
     return;
   }
   if (candidate.kind === "theme-fixed") {
-    const parsed = expectedCategory === "number" ? z6.union([fixedNumberSchema, fixedNumberArraySchema]).safeParse(candidate) : expectedCategory === "color" || expectedCategory === "image" ? fixedStringSchema.safeParse(candidate) : void 0;
+    const parsed = expectedCategory === "number" ? z7.union([fixedNumberSchema, fixedNumberArraySchema]).safeParse(candidate) : expectedCategory === "color" || expectedCategory === "image" ? fixedStringSchema.safeParse(candidate) : void 0;
     if (!parsed?.success) {
+      const received = fixedValueKind(candidate.value);
+      const literal2 = JSON.stringify(candidate.value);
       context.addIssue({
         code: "custom",
-        message: expectedCategory === void 0 ? "Structural expressions cannot contain theme-fixed values" : `Expected a fixed ${expectedCategory} value`,
+        message: expectedCategory === void 0 ? `Structural expressions cannot contain theme-fixed values. ${structuralThemeValueHint}` : received !== void 0 && received !== expectedCategoryKind(expectedCategory) ? `Expected a fixed ${expectedCategory} value, received a fixed ${received}. ${expressionOperandHint(expectedCategory)} Write ${literal2} instead of fixed(${literal2}).` : `Expected a fixed ${expectedCategory} value`,
         path
       });
     }
@@ -12114,6 +12749,20 @@ function validateExpressionThemeValues(value, expectedCategory, context, path) {
     validateExpressionThemeValues(entry, expectedCategory, context, [...path, key]);
   }
 }
+var structuralThemeValueHint = "fixed() and theme tokens apply only to visual properties such as colours, sizes, and images; write structural values directly.";
+function expressionOperandHint(category) {
+  return `In ${category === "image" ? "an" : "a"} ${category} expression, fixed() and theme tokens belong in its ${category} results; conditions and other operands take plain values.`;
+}
+function fixedValueKind(value) {
+  if (typeof value === "number") return "number";
+  if (typeof value === "string") return "string";
+  if (typeof value === "boolean") return "boolean";
+  if (Array.isArray(value)) return "array";
+  return void 0;
+}
+function expectedCategoryKind(category) {
+  return category === "number" ? "number" : "string";
+}
 var numberExpressionSchema = expressionSchemaFor("number");
 var colorExpressionSchema = expressionSchemaFor("color");
 var imageExpressionSchema = expressionSchemaFor("image");
@@ -12121,80 +12770,80 @@ var structuralExpressionSchema = expressionSchemaFor(void 0);
 var numberZoomValueSchema = zoomValueSchemaFor(themeNumberValueSchema);
 var colorZoomValueSchema = zoomValueSchemaFor(themeColorValueSchema);
 var imageZoomValueSchema = zoomValueSchemaFor(themeImageValueSchema);
-var stringZoomValueSchema = zoomValueSchemaFor(z6.string());
-var numberValueSchema = z6.union([
+var stringZoomValueSchema = zoomValueSchemaFor(z7.string());
+var numberValueSchema = z7.union([
   themeNumberValueSchema,
   numberExpressionSchema,
   numberZoomValueSchema
 ]);
-var structuralNumberValueSchema = z6.union([
-  z6.number().finite(),
+var structuralNumberValueSchema = z7.union([
+  z7.number().finite(),
   structuralExpressionSchema,
-  zoomValueSchemaFor(z6.number().finite())
+  zoomValueSchemaFor(z7.number().finite())
 ]);
-var colorValueSchema = z6.union([
+var colorValueSchema = z7.union([
   themeColorValueSchema,
   colorExpressionSchema,
   colorZoomValueSchema
 ]);
-var imageValueSchema = z6.union([
+var imageValueSchema = z7.union([
   themeImageValueSchema,
   imageExpressionSchema,
   imageZoomValueSchema
 ]);
-var stringValueSchema = z6.union([z6.string(), structuralExpressionSchema, stringZoomValueSchema]);
-var themeNumberArraySchema = z6.array(themeNumberValueSchema);
-var themeNumberArrayValueSchema = z6.union([themeNumberArraySchema, fixedNumberArraySchema]);
-var numberArrayValueSchema = z6.union([
+var stringValueSchema = z7.union([z7.string(), structuralExpressionSchema, stringZoomValueSchema]);
+var themeNumberArraySchema = z7.array(themeNumberValueSchema);
+var themeNumberArrayValueSchema = z7.union([themeNumberArraySchema, fixedNumberArraySchema]);
+var numberArrayValueSchema = z7.union([
   themeNumberArrayValueSchema,
   numberExpressionSchema,
   zoomValueSchemaFor(themeNumberArrayValueSchema)
 ]);
-var themeNumberOffsetSchema = z6.tuple([themeNumberValueSchema, themeNumberValueSchema]);
-var themeNumberOffsetValueSchema = z6.union([themeNumberOffsetSchema, fixedNumberOffsetSchema]);
-var numberOffsetValueSchema = z6.union([
+var themeNumberOffsetSchema = z7.tuple([themeNumberValueSchema, themeNumberValueSchema]);
+var themeNumberOffsetValueSchema = z7.union([themeNumberOffsetSchema, fixedNumberOffsetSchema]);
+var numberOffsetValueSchema = z7.union([
   themeNumberOffsetValueSchema,
   numberExpressionSchema,
   zoomValueSchemaFor(themeNumberOffsetValueSchema)
 ]);
-var themeNumberInsetsSchema = z6.tuple([
+var themeNumberInsetsSchema = z7.tuple([
   themeNumberValueSchema,
   themeNumberValueSchema,
   themeNumberValueSchema,
   themeNumberValueSchema
 ]);
-var themeNumberInsetsValueSchema = z6.union([themeNumberInsetsSchema, fixedNumberInsetsSchema]);
-var numberInsetsValueSchema = z6.union([
+var themeNumberInsetsValueSchema = z7.union([themeNumberInsetsSchema, fixedNumberInsetsSchema]);
+var numberInsetsValueSchema = z7.union([
   themeNumberInsetsValueSchema,
   numberExpressionSchema,
   zoomValueSchemaFor(themeNumberInsetsValueSchema)
 ]);
-var lineCapSchema = z6.enum(["butt", "round", "square"]);
-var lineCapValueSchema = z6.union([
+var lineCapSchema = z7.enum(["butt", "round", "square"]);
+var lineCapValueSchema = z7.union([
   lineCapSchema,
   structuralExpressionSchema,
   zoomValueSchemaFor(lineCapSchema)
 ]);
-var lineJoinSchema = z6.enum(["bevel", "miter", "round"]);
-var lineJoinValueSchema = z6.union([
+var lineJoinSchema = z7.enum(["bevel", "miter", "round"]);
+var lineJoinValueSchema = z7.union([
   lineJoinSchema,
   structuralExpressionSchema,
   zoomValueSchemaFor(lineJoinSchema)
 ]);
-var exactFontFaceSchema = z6.string().min(1).max(100).refine(
+var exactFontFaceSchema = z7.string().min(1).max(100).refine(
   (value) => value === value.trim() && value === value.normalize("NFC") && !/[\p{Cc}\\]/u.test(value),
   "Expected an exact NFC font face name without surrounding whitespace, controls, or backslashes"
 );
-var moduleFontValueSchema = z6.union([
+var moduleFontValueSchema = z7.union([
   exactFontFaceSchema,
   fixedStringSchema,
-  themeTokenReferenceSchema.extend({ category: z6.literal("font") })
+  themeTokenReferenceSchema.extend({ category: z7.literal("font") })
 ]);
-var moduleFontFallbacksSchema = z6.array(moduleFontValueSchema).max(8);
-var hexColorSchema = z6.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
+var moduleFontFallbacksSchema = z7.array(moduleFontValueSchema).max(8);
+var hexColorSchema = z7.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
   message: "Expected a hex color like #F6F7F3 or #F6F7F3FF"
 });
-var rgbColorSchema = z6.string().refine((value) => {
+var rgbColorSchema = z7.string().refine((value) => {
   const match2 = value.match(
     /^rgba?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)(?:\s*,\s*(\d+(?:\.\d+)?))?\s*\)$/iu
   );
@@ -12203,21 +12852,21 @@ var rgbColorSchema = z6.string().refine((value) => {
   const alpha2 = Number(match2[4] ?? 1);
   return channels.every((channel) => channel >= 0 && channel <= 255) && alpha2 >= 0 && alpha2 <= 1;
 }, "Expected a Tileflow hex, rgb(), or rgba() color");
-var terrainColorLiteralSchema = z6.union([hexColorSchema, rgbColorSchema]);
-var terrainColorValueSchema = z6.union([
+var terrainColorLiteralSchema = z7.union([hexColorSchema, rgbColorSchema]);
+var terrainColorValueSchema = z7.union([
   terrainColorLiteralSchema,
   fixedStringSchema.extend({ value: terrainColorLiteralSchema }),
-  themeTokenReferenceSchema.extend({ category: z6.literal("color") }),
+  themeTokenReferenceSchema.extend({ category: z7.literal("color") }),
   themeColorOperationSchema
 ]);
 function terrainNumberValueSchema(schema) {
-  return z6.union([schema, fixedNumberSchema.extend({ value: schema }), themeNumberReferenceSchema]);
+  return z7.union([schema, fixedNumberSchema.extend({ value: schema }), themeNumberReferenceSchema]);
 }
-var themeTypographyStyleSchema = z6.object({
-  fallbacks: z6.array(themeFontValueSchema).max(8).optional(),
+var themeTypographyStyleSchema = z7.object({
+  fallbacks: z7.array(themeFontValueSchema).max(8).optional(),
   font: themeFontValueSchema.optional(),
   letterSpacing: themeNumberValueSchema.optional(),
-  transform: z6.enum(["lowercase", "none", "uppercase"]).optional()
+  transform: z7.enum(["lowercase", "none", "uppercase"]).optional()
 }).strict();
 var themeTypographySchema = themeTypographyStyleSchema.extend({
   places: themeTypographyStyleSchema.optional(),
@@ -12225,46 +12874,57 @@ var themeTypographySchema = themeTypographyStyleSchema.extend({
   roads: themeTypographyStyleSchema.optional(),
   water: themeTypographyStyleSchema.optional()
 });
-var themeLightingSchema = z6.object({
-  anchor: z6.enum(["map", "viewport"]).optional(),
+var themeLightingSchema = z7.object({
+  ambient: z7.object({
+    color: themeColorValueSchema.optional(),
+    intensity: themeNumberValueSchema.optional()
+  }).strict().optional(),
+  anchor: z7.enum(["map", "viewport"]).optional(),
   color: themeColorValueSchema.optional(),
   intensity: themeNumberValueSchema.optional(),
-  position: z6.tuple([themeNumberValueSchema, themeNumberValueSchema, themeNumberValueSchema]).optional()
+  position: z7.tuple([themeNumberValueSchema, themeNumberValueSchema, themeNumberValueSchema]).optional(),
+  sun: z7.object({
+    altitude: themeNumberValueSchema.optional(),
+    azimuth: themeNumberValueSchema.optional(),
+    color: themeColorValueSchema.optional(),
+    intensity: themeNumberValueSchema.optional(),
+    shadowIntensity: themeNumberValueSchema.optional()
+  }).strict().optional()
 }).strict();
-var tileflowThemeSchema = z6.object({
-  colorScheme: z6.enum(["light", "dark"]),
+var tileflowThemeSchema = z7.object({
+  colorScheme: z7.enum(["light", "dark"]),
   id: tileflowThemeNameSchema,
   lighting: themeLightingSchema,
-  tokens: z6.object({
-    color: z6.record(themeTokenNameSchema, themeColorValueSchema),
-    font: z6.record(themeTokenNameSchema, themeFontValueSchema),
-    image: z6.record(themeTokenNameSchema, themeImageValueSchema),
-    number: z6.record(themeTokenNameSchema, themeNumberValueSchema)
+  tokens: z7.object({
+    color: z7.record(themeTokenNameSchema, themeColorValueSchema),
+    font: z7.record(themeTokenNameSchema, themeFontValueSchema),
+    image: z7.record(themeTokenNameSchema, themeImageValueSchema),
+    number: z7.record(themeTokenNameSchema, themeNumberValueSchema)
   }).strict(),
   typography: themeTypographySchema,
-  version: z6.number().int().positive()
+  version: z7.number().int().positive()
 }).strict();
 var rangeShape = {
   maxZoom: zoomNumberSchema.optional(),
   minZoom: zoomNumberSchema.optional(),
-  visible: z6.boolean().optional()
+  visible: z7.boolean().optional()
 };
-var backgroundStyleSchema = z6.object({
+var backgroundStyleSchema = z7.object({
   ...rangeShape,
   color: colorValueSchema.optional(),
   opacity: numberValueSchema.optional(),
   pattern: imageValueSchema.optional()
 }).strict();
-var fillStyleSchema = z6.object({
+var fillStyleSchema = z7.object({
   ...rangeShape,
-  antialias: z6.boolean().optional(),
+  antialias: z7.boolean().optional(),
   color: colorValueSchema.optional(),
   opacity: numberValueSchema.optional(),
   pattern: imageValueSchema.optional(),
   translate: numberOffsetValueSchema.optional(),
-  translateAnchor: z6.enum(["map", "viewport"]).optional()
+  translateAnchor: z7.enum(["map", "viewport"]).optional()
 }).strict();
-var lineStyleSchema = z6.object({
+var lineStyleSchema = z7.object({
   ...rangeShape,
   blur: numberValueSchema.optional(),
   cap: lineCapValueSchema.optional(),
@@ -12278,13 +12938,13 @@ var lineStyleSchema = z6.object({
   pattern: imageValueSchema.optional(),
   roundLimit: numberValueSchema.optional(),
   translate: numberOffsetValueSchema.optional(),
-  translateAnchor: z6.enum(["map", "viewport"]).optional(),
+  translateAnchor: z7.enum(["map", "viewport"]).optional(),
   width: numberValueSchema.optional()
 }).strict();
-var textStyleSchema = z6.object({
+var textStyleSchema = z7.object({
   ...rangeShape,
-  allowOverlap: z6.boolean().optional(),
-  anchor: z6.enum([
+  allowOverlap: z7.boolean().optional(),
+  anchor: z7.enum([
     "bottom",
     "bottom-left",
     "bottom-right",
@@ -12295,9 +12955,9 @@ var textStyleSchema = z6.object({
     "top-left",
     "top-right"
   ]).optional(),
-  background: z6.object({
+  background: z7.object({
     color: colorValueSchema,
-    fit: z6.literal("lines"),
+    fit: z7.literal("lines"),
     padding: themeNumberValueSchema.optional()
   }).strict().optional(),
   color: colorValueSchema.optional(),
@@ -12307,26 +12967,26 @@ var textStyleSchema = z6.object({
   haloBlur: numberValueSchema.optional(),
   haloColor: colorValueSchema.optional(),
   haloWidth: numberValueSchema.optional(),
-  ignorePlacement: z6.boolean().optional(),
-  justify: z6.enum(["auto", "center", "left", "right"]).optional(),
-  keepUpright: z6.boolean().optional(),
+  ignorePlacement: z7.boolean().optional(),
+  justify: z7.enum(["auto", "center", "left", "right"]).optional(),
+  keepUpright: z7.boolean().optional(),
   letterSpacing: numberValueSchema.optional(),
   lineHeight: numberValueSchema.optional(),
   maxAngle: numberValueSchema.optional(),
   maxWidth: numberValueSchema.optional(),
   offset: numberOffsetValueSchema.optional(),
-  optional: z6.boolean().optional(),
+  optional: z7.boolean().optional(),
   opacity: numberValueSchema.optional(),
-  overlap: z6.enum(["always", "cooperative", "never"]).optional(),
+  overlap: z7.enum(["always", "cooperative", "never"]).optional(),
   padding: numberValueSchema.optional(),
-  pitchAlignment: z6.enum(["auto", "map", "viewport"]).optional(),
+  pitchAlignment: z7.enum(["auto", "map", "viewport"]).optional(),
   radialOffset: numberValueSchema.optional(),
   rotate: numberValueSchema.optional(),
-  rotationAlignment: z6.enum(["auto", "map", "viewport"]).optional(),
+  rotationAlignment: z7.enum(["auto", "map", "viewport"]).optional(),
   size: numberValueSchema.optional(),
-  transform: z6.enum(["lowercase", "none", "uppercase"]).optional(),
-  variableAnchors: z6.array(
-    z6.enum([
+  transform: z7.enum(["lowercase", "none", "uppercase"]).optional(),
+  variableAnchors: z7.array(
+    z7.enum([
       "bottom",
       "bottom-left",
       "bottom-right",
@@ -12339,10 +12999,10 @@ var textStyleSchema = z6.object({
     ])
   ).min(1).optional()
 }).strict();
-var iconStyleSchema = z6.object({
+var iconStyleSchema = z7.object({
   ...rangeShape,
-  allowOverlap: z6.boolean().optional(),
-  anchor: z6.enum([
+  allowOverlap: z7.boolean().optional(),
+  anchor: z7.enum([
     "bottom",
     "bottom-left",
     "bottom-right",
@@ -12357,61 +13017,61 @@ var iconStyleSchema = z6.object({
   haloBlur: numberValueSchema.optional(),
   haloColor: colorValueSchema.optional(),
   haloWidth: numberValueSchema.optional(),
-  ignorePlacement: z6.boolean().optional(),
+  ignorePlacement: z7.boolean().optional(),
   image: imageValueSchema.optional(),
   offset: numberOffsetValueSchema.optional(),
   opacity: numberValueSchema.optional(),
-  keepUpright: z6.boolean().optional(),
-  optional: z6.boolean().optional(),
-  overlap: z6.enum(["always", "cooperative", "never"]).optional(),
+  keepUpright: z7.boolean().optional(),
+  optional: z7.boolean().optional(),
+  overlap: z7.enum(["always", "cooperative", "never"]).optional(),
   padding: numberValueSchema.optional(),
-  pitchAlignment: z6.enum(["auto", "map", "viewport"]).optional(),
+  pitchAlignment: z7.enum(["auto", "map", "viewport"]).optional(),
   rotate: numberValueSchema.optional(),
-  rotationAlignment: z6.enum(["auto", "map", "viewport"]).optional(),
+  rotationAlignment: z7.enum(["auto", "map", "viewport"]).optional(),
   size: numberValueSchema.optional(),
-  textFit: z6.enum(["both", "height", "none", "width"]).optional(),
+  textFit: z7.enum(["both", "height", "none", "width"]).optional(),
   textFitPadding: numberInsetsValueSchema.optional()
 }).strict();
 var symbolPlacementShape = {
   ...rangeShape,
-  placement: z6.enum(["line", "line-center", "point"]).optional(),
+  placement: z7.enum(["line", "line-center", "point"]).optional(),
   priority: structuralNumberValueSchema.optional(),
-  priorityOrder: z6.enum(["higher-first", "lower-first"]).optional(),
+  priorityOrder: z7.enum(["higher-first", "lower-first"]).optional(),
   spacing: numberValueSchema.optional(),
-  zOrder: z6.enum(["auto", "source", "viewport-y"]).optional()
+  zOrder: z7.enum(["auto", "source", "viewport-y"]).optional()
 };
-var circleStyleSchema = z6.object({
+var circleStyleSchema = z7.object({
   ...rangeShape,
   blur: numberValueSchema.optional(),
   color: colorValueSchema.optional(),
   opacity: numberValueSchema.optional(),
-  pitchAlignment: z6.enum(["map", "viewport"]).optional(),
-  pitchScale: z6.enum(["map", "viewport"]).optional(),
+  pitchAlignment: z7.enum(["map", "viewport"]).optional(),
+  pitchScale: z7.enum(["map", "viewport"]).optional(),
   priority: structuralNumberValueSchema.optional(),
-  priorityOrder: z6.enum(["higher-first", "lower-first"]).optional(),
+  priorityOrder: z7.enum(["higher-first", "lower-first"]).optional(),
   radius: numberValueSchema.optional(),
   strokeColor: colorValueSchema.optional(),
   strokeOpacity: numberValueSchema.optional(),
   strokeWidth: numberValueSchema.optional(),
   translate: numberOffsetValueSchema.optional(),
-  translateAnchor: z6.enum(["map", "viewport"]).optional()
+  translateAnchor: z7.enum(["map", "viewport"]).optional()
 }).strict();
-var extrusionStyleSchema = z6.object({
+var extrusionStyleSchema = z7.object({
   ...rangeShape,
   base: numberValueSchema.optional(),
   color: colorValueSchema.optional(),
   height: numberValueSchema.optional(),
   opacity: numberValueSchema.optional(),
   pattern: imageValueSchema.optional(),
-  verticalGradient: z6.boolean().optional()
+  verticalGradient: z7.boolean().optional()
 }).strict();
-var areaStyleSchema = z6.object({ fill: fillStyleSchema.optional(), outline: lineStyleSchema.optional() }).strict();
-var lineStackStyleSchema = z6.object({
+var areaStyleSchema = z7.object({ fill: fillStyleSchema.optional(), outline: lineStyleSchema.optional() }).strict();
+var lineStackStyleSchema = z7.object({
   casing: lineStyleSchema.optional(),
   fill: lineStyleSchema.optional(),
   shadow: lineStyleSchema.optional()
 }).strict();
-var lineHatchStyleSchema = z6.object({
+var lineHatchStyleSchema = z7.object({
   ...rangeShape,
   angle: numberValueSchema.optional(),
   color: colorValueSchema.optional(),
@@ -12460,62 +13120,62 @@ var lineHatchStyleSchema = z6.object({
   }
 });
 var roadLayerStyleSchema = lineStackStyleSchema.extend({ hatch: lineHatchStyleSchema.optional() }).strict();
-var symbolStyleSchema = z6.object({
+var symbolStyleSchema = z7.object({
   ...symbolPlacementShape,
   icon: iconStyleSchema.optional(),
   text: textStyleSchema.optional()
 }).strict();
 var markerSymbolStyleSchema = symbolStyleSchema.extend({ marker: circleStyleSchema.optional() }).strict();
 var poiCategoryStyleSchema = markerSymbolStyleSchema.omit({ priority: true, priorityOrder: true }).extend({
-  density: z6.union([z6.literal(1), z6.literal(2), z6.literal(3), z6.literal(4), z6.literal(5)]).optional()
+  density: z7.union([z7.literal(1), z7.literal(2), z7.literal(3), z7.literal(4), z7.literal(5)]).optional()
 }).strict();
-var renderScalarSchema = z6.union([z6.boolean(), z6.number().finite(), z6.string()]);
-var renderTargetSchema = z6.string().regex(tileflowSemanticTargetPattern, "Expected a semantic target");
-var renderStackOperationNameSchema = z6.string().regex(
+var renderScalarSchema = z7.union([z7.boolean(), z7.number().finite(), z7.string()]);
+var renderTargetSchema = z7.string().regex(tileflowSemanticTargetPattern, "Expected a semantic target");
+var renderStackOperationNameSchema = z7.string().regex(
   tileflowRenderStackOperationNamePattern,
   "Expected a lowercase-initial portable render-stack operation name without dots"
 );
 var renderFieldNormalizationShape = {
-  coerce: z6.literal("number").optional(),
+  coerce: z7.literal("number").optional(),
   fallback: renderScalarSchema.optional(),
-  field: z6.enum(tileflowSemanticFieldNames)
+  field: z7.enum(tileflowSemanticFieldNames)
 };
-var renderSelectorNodeSchema = z6.lazy(
-  () => z6.discriminatedUnion("kind", [
-    z6.object({ kind: z6.literal("literal"), value: z6.boolean() }).strict(),
-    z6.object({ kind: z6.literal("geometry"), geometry: z6.enum(tileflowRenderSelectorGeometries) }).strict(),
-    z6.object({ kind: z6.literal("has"), field: z6.enum(tileflowSemanticFieldNames) }).strict(),
-    z6.object({
+var renderSelectorNodeSchema = z7.lazy(
+  () => z7.discriminatedUnion("kind", [
+    z7.object({ kind: z7.literal("literal"), value: z7.boolean() }).strict(),
+    z7.object({ kind: z7.literal("geometry"), geometry: z7.enum(tileflowRenderSelectorGeometries) }).strict(),
+    z7.object({ kind: z7.literal("has"), field: z7.enum(tileflowSemanticFieldNames) }).strict(),
+    z7.object({
       ...renderFieldNormalizationShape,
-      kind: z6.literal("compare"),
-      operator: z6.enum(tileflowRenderSelectorComparisons),
+      kind: z7.literal("compare"),
+      operator: z7.enum(tileflowRenderSelectorComparisons),
       value: renderScalarSchema
     }).strict(),
-    z6.object({
+    z7.object({
       ...renderFieldNormalizationShape,
-      kind: z6.literal("in"),
-      values: z6.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
+      kind: z7.literal("in"),
+      values: z7.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
     }).strict(),
-    z6.object({
+    z7.object({
       ...renderFieldNormalizationShape,
-      branches: z6.array(
-        z6.object({
-          result: z6.boolean(),
-          values: z6.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
+      branches: z7.array(
+        z7.object({
+          result: z7.boolean(),
+          values: z7.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
         }).strict()
       ).min(1).max(tileflowRenderStackLimits.maxMatchBranches),
-      kind: z6.literal("match"),
-      otherwise: z6.boolean()
+      kind: z7.literal("match"),
+      otherwise: z7.boolean()
     }).strict(),
-    z6.object({ kind: z6.literal("not"), selector: renderSelectorNodeSchema }).strict(),
-    z6.object({
-      kind: z6.enum(["all", "any"]),
-      selectors: z6.array(renderSelectorNodeSchema).min(1).max(tileflowRenderStackLimits.maxSelectorChildren)
+    z7.object({ kind: z7.literal("not"), selector: renderSelectorNodeSchema }).strict(),
+    z7.object({
+      kind: z7.enum(["all", "any"]),
+      selectors: z7.array(renderSelectorNodeSchema).min(1).max(tileflowRenderStackLimits.maxSelectorChildren)
     }).strict(),
-    z6.object({
+    z7.object({
       fallback: renderSelectorNodeSchema,
-      kind: z6.literal("step"),
-      stops: z6.array(z6.object({ selector: renderSelectorNodeSchema, zoom: zoomNumberSchema }).strict()).min(1).max(tileflowRenderStackLimits.maxStepStops)
+      kind: z7.literal("step"),
+      stops: z7.array(z7.object({ selector: renderSelectorNodeSchema, zoom: zoomNumberSchema }).strict()).min(1).max(tileflowRenderStackLimits.maxStepStops)
     }).strict()
   ])
 );
@@ -12526,7 +13186,7 @@ var renderSelectorSchema = renderSelectorNodeSchema.superRefine(
     }
   }
 );
-var renderVisibilitySchema = z6.object({ visibilityGroup: z6.literal("building").optional() });
+var renderVisibilitySchema = z7.object({ visibilityGroup: z7.literal("building").optional() });
 var renderStyleSchemas = {
   background: backgroundStyleSchema.extend(renderVisibilitySchema.shape).strict(),
   circle: circleStyleSchema.extend(renderVisibilitySchema.shape).strict(),
@@ -12535,7 +13195,7 @@ var renderStyleSchemas = {
   line: lineStyleSchema.extend(renderVisibilitySchema.shape).strict(),
   symbol: symbolStyleSchema.extend(renderVisibilitySchema.shape).strict()
 };
-var renderRequirementsSchema = z6.array(z6.enum(tileflowLayerDomains)).min(1).max(tileflowRenderStackLimits.maxRequirements).superRefine((requirements, context) => {
+var renderRequirementsSchema = z7.array(z7.enum(tileflowLayerDomains)).min(1).max(tileflowRenderStackLimits.maxRequirements).superRefine((requirements, context) => {
   const seen = /* @__PURE__ */ new Set();
   for (const [index, requirement] of requirements.entries()) {
     if (seen.has(requirement)) {
@@ -12548,55 +13208,55 @@ var renderRequirementsSchema = z6.array(z6.enum(tileflowLayerDomains)).min(1).ma
     seen.add(requirement);
   }
 });
-var renderPlacementSchema = z6.union([
-  z6.enum(tileflowBandPlacements),
-  z6.object({ above: renderTargetSchema }).strict(),
-  z6.object({ below: renderTargetSchema }).strict()
+var renderPlacementSchema = z7.union([
+  z7.enum(tileflowBandPlacements),
+  z7.object({ above: renderTargetSchema }).strict(),
+  z7.object({ below: renderTargetSchema }).strict()
 ]);
 var vectorRenderPassSchemas = tileflowRenderStackRenderers.filter((renderer) => renderer !== "background").map(
-  (renderer) => z6.object({
-    feature: z6.enum(tileflowSemanticLayerNames).optional(),
-    kind: z6.literal("render-pass"),
+  (renderer) => z7.object({
+    feature: z7.enum(tileflowSemanticLayerNames).optional(),
+    kind: z7.literal("render-pass"),
     placement: renderPlacementSchema,
-    renderer: z6.literal(renderer),
+    renderer: z7.literal(renderer),
     requirements: renderRequirementsSchema.optional(),
     selector: renderSelectorSchema.optional(),
     style: renderStyleSchemas[renderer]
   }).strict()
 );
-var renderPassSchema = z6.discriminatedUnion("renderer", [
-  z6.object({
-    kind: z6.literal("render-pass"),
+var renderPassSchema = z7.discriminatedUnion("renderer", [
+  z7.object({
+    kind: z7.literal("render-pass"),
     placement: renderPlacementSchema,
-    renderer: z6.literal("background"),
+    renderer: z7.literal("background"),
     requirements: renderRequirementsSchema.optional(),
     style: renderStyleSchemas.background
   }).strict(),
   ...vectorRenderPassSchemas
 ]);
 var renderRefinementSchemas = tileflowRenderStackRenderers.map(
-  (renderer) => z6.object({
-    kind: z6.literal("refine-render-target"),
+  (renderer) => z7.object({
+    kind: z7.literal("refine-render-target"),
     placement: renderPlacementSchema.optional(),
     requirements: renderRequirementsSchema.optional(),
-    renderer: z6.literal(renderer),
+    renderer: z7.literal(renderer),
     ...renderer === "background" ? {} : { selector: renderSelectorSchema.optional() },
     style: renderStyleSchemas[renderer],
     target: renderTargetSchema
   }).strict()
 );
-var renderPlacementRefinementSchema = z6.object({
-  kind: z6.literal("refine-render-target"),
+var renderPlacementRefinementSchema = z7.object({
+  kind: z7.literal("refine-render-target"),
   placement: renderPlacementSchema,
   requirements: renderRequirementsSchema.optional(),
   target: renderTargetSchema
 }).strict();
-var renderStackOperationSchema = z6.union([
+var renderStackOperationSchema = z7.union([
   renderPassSchema,
   ...renderRefinementSchemas,
   renderPlacementRefinementSchema
 ]);
-var renderStackSchema = z6.record(renderStackOperationNameSchema, renderStackOperationSchema).superRefine((stack, context) => {
+var renderStackSchema = z7.record(renderStackOperationNameSchema, renderStackOperationSchema).superRefine((stack, context) => {
   const size = Object.keys(stack).length;
   if (size === 0) {
     context.addIssue({
@@ -12611,19 +13271,19 @@ var renderStackSchema = z6.record(renderStackOperationNameSchema, renderStackOpe
     });
   }
 }).describe("tileflow-render-stack");
-var roadClassSchema = z6.enum(tileflowRoadClasses);
-var roadClassStyleSchema = z6.object({
-  enabled: z6.boolean().optional(),
+var roadClassSchema = z7.enum(tileflowRoadClasses);
+var roadClassStyleSchema = z7.object({
+  enabled: z7.boolean().optional(),
   bridge: roadLayerStyleSchema.optional(),
   surface: roadLayerStyleSchema.optional(),
   tunnel: roadLayerStyleSchema.optional()
 }).strict();
-var roadStructureMapSchema = z6.object({
+var roadStructureMapSchema = z7.object({
   bridge: roadLayerStyleSchema.optional(),
   surface: roadLayerStyleSchema.optional(),
   tunnel: roadLayerStyleSchema.optional()
 }).strict();
-var roadTreatmentLayerStyleSchema = z6.object({
+var roadTreatmentLayerStyleSchema = z7.object({
   casing: lineStyleSchema.pick({
     blur: true,
     color: true,
@@ -12652,19 +13312,19 @@ var roadTreatmentLayerStyleSchema = z6.object({
     width: true
   }).optional()
 }).strict();
-var roadTreatmentStyleSchema = z6.object({
+var roadTreatmentStyleSchema = z7.object({
   bridge: roadTreatmentLayerStyleSchema.optional(),
-  enabled: z6.boolean().optional(),
+  enabled: z7.boolean().optional(),
   surface: roadTreatmentLayerStyleSchema.optional(),
   tunnel: roadTreatmentLayerStyleSchema.optional(),
   widthScale: themeNumberValueSchema.optional()
 }).strict();
-var landModuleSchema = z6.object({
-  type: z6.literal("land"),
+var landModuleSchema = z7.object({
+  type: z7.literal("land"),
   background: backgroundStyleSchema.optional(),
-  enabled: z6.boolean().optional(),
+  enabled: z7.boolean().optional(),
   globalLandcover: fillStyleSchema.optional(),
-  landcover: z6.object({
+  landcover: z7.object({
     farmland: areaStyleSchema.optional(),
     flowerbed: areaStyleSchema.optional(),
     grass: areaStyleSchema.optional(),
@@ -12680,7 +13340,7 @@ var landModuleSchema = z6.object({
     wetland: areaStyleSchema.optional(),
     wood: areaStyleSchema.optional()
   }).strict().optional(),
-  landuse: z6.object({
+  landuse: z7.object({
     cemetery: areaStyleSchema.optional(),
     civic: areaStyleSchema.optional(),
     commercial: areaStyleSchema.optional(),
@@ -12696,99 +13356,99 @@ var landModuleSchema = z6.object({
   }).strict().optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var waterModuleSchema = z6.object({
-  type: z6.literal("water"),
+var waterModuleSchema = z7.object({
+  type: z7.literal("water"),
   bathymetry: fillStyleSchema.optional(),
   bathymetryContours: lineStyleSchema.optional(),
   bathymetryLabels: symbolStyleSchema.optional(),
   bodies: areaStyleSchema.optional(),
-  enabled: z6.boolean().optional(),
-  intermittent: z6.object({ bodies: areaStyleSchema.optional(), waterways: lineStyleSchema.optional() }).strict().optional(),
+  enabled: z7.boolean().optional(),
+  intermittent: z7.object({ bodies: areaStyleSchema.optional(), waterways: lineStyleSchema.optional() }).strict().optional(),
   renderStack: renderStackSchema.optional(),
-  waterways: z6.object({
+  waterways: z7.object({
     canal: lineStyleSchema.optional(),
     other: lineStyleSchema.optional(),
     river: lineStyleSchema.optional(),
     stream: lineStyleSchema.optional()
   }).strict().optional()
 }).strict();
-var buildingsModuleSchema = z6.object({
-  type: z6.literal("buildings"),
+var buildingsModuleSchema = z7.object({
+  type: z7.literal("buildings"),
   businessCorridor: areaStyleSchema.optional(),
-  enabled: z6.boolean().optional(),
+  enabled: z7.boolean().optional(),
   extrusion: extrusionStyleSchema.optional(),
   flat: areaStyleSchema.optional(),
-  mode: z6.enum(["3d", "flat"]).optional(),
+  mode: z7.enum(["3d", "flat"]).optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var addressesModuleSchema = z6.object({
-  type: z6.literal("addresses"),
-  enabled: z6.boolean().optional(),
+var addressesModuleSchema = z7.object({
+  type: z7.literal("addresses"),
+  enabled: z7.boolean().optional(),
   labels: symbolStyleSchema.optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var landformClassSchema = z6.enum(tileflowLandformClasses);
-var landformsModuleSchema = z6.object({
-  type: z6.literal("landforms"),
-  classes: z6.partialRecord(landformClassSchema, symbolStyleSchema).optional(),
-  elevation: z6.boolean().optional(),
-  enabled: z6.boolean().optional(),
+var landformClassSchema = z7.enum(tileflowLandformClasses);
+var landformsModuleSchema = z7.object({
+  type: z7.literal("landforms"),
+  classes: z7.partialRecord(landformClassSchema, symbolStyleSchema).optional(),
+  elevation: z7.boolean().optional(),
+  enabled: z7.boolean().optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var boundariesModuleSchema = z6.object({
-  type: z6.literal("boundaries"),
+var boundariesModuleSchema = z7.object({
+  type: z7.literal("boundaries"),
   admin2: lineStyleSchema.optional(),
   admin4: lineStyleSchema.optional(),
   disputed: lineStyleSchema.optional(),
-  enabled: z6.boolean().optional(),
+  enabled: z7.boolean().optional(),
   maritime: lineStyleSchema.optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var aerowaysModuleSchema = z6.object({
-  type: z6.literal("aeroways"),
+var aerowaysModuleSchema = z7.object({
+  type: z7.literal("aeroways"),
   area: areaStyleSchema.optional(),
-  enabled: z6.boolean().optional(),
+  enabled: z7.boolean().optional(),
   runway: lineStackStyleSchema.optional(),
   runwayRef: symbolStyleSchema.optional(),
   renderStack: renderStackSchema.optional(),
   taxiway: lineStackStyleSchema.optional()
 }).strict();
-var transitModuleSchema = z6.object({
-  type: z6.literal("transit"),
+var transitModuleSchema = z7.object({
+  type: z7.literal("transit"),
   cableway: lineStyleSchema.optional(),
-  enabled: z6.boolean().optional(),
+  enabled: z7.boolean().optional(),
   ferry: lineStyleSchema.optional(),
-  rail: z6.object({
+  rail: z7.object({
     bridge: lineStyleSchema.optional(),
     surface: lineStyleSchema.optional(),
     tunnel: lineStyleSchema.optional()
   }).strict().optional(),
-  railHatching: z6.object({
+  railHatching: z7.object({
     bridge: lineStyleSchema.optional(),
     surface: lineStyleSchema.optional(),
     tunnel: lineStyleSchema.optional()
   }).strict().optional(),
-  serviceRail: z6.object({
+  serviceRail: z7.object({
     bridge: lineStyleSchema.optional(),
     surface: lineStyleSchema.optional(),
     tunnel: lineStyleSchema.optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var roadsModuleSchema = z6.object({
-  type: z6.literal("roads"),
-  areas: z6.object({
+var roadsModuleSchema = z7.object({
+  type: z7.literal("roads"),
+  areas: z7.object({
     pedestrian: areaStyleSchema.optional(),
     pier: areaStyleSchema.optional(),
     road: areaStyleSchema.optional()
   }).strict().optional(),
-  classes: z6.partialRecord(roadClassSchema, roadClassStyleSchema).optional(),
+  classes: z7.partialRecord(roadClassSchema, roadClassStyleSchema).optional(),
   crossings: iconStyleSchema.extend({ image: imageValueSchema }).strict().optional(),
-  detail: z6.enum(["none", "highways", "major", "streets", "all"]).optional(),
-  enabled: z6.boolean().optional(),
-  extras: z6.object({ paths: z6.boolean().optional() }).strict().optional(),
-  hierarchy: z6.enum(["subtle", "clear", "strong"]).optional(),
-  modifiers: z6.object({
+  detail: z7.enum(["none", "highways", "major", "streets", "all"]).optional(),
+  enabled: z7.boolean().optional(),
+  extras: z7.object({ paths: z7.boolean().optional() }).strict().optional(),
+  hierarchy: z7.enum(["subtle", "clear", "strong"]).optional(),
+  modifiers: z7.object({
     construction: roadTreatmentStyleSchema.optional(),
     expressway: roadTreatmentStyleSchema.optional(),
     indoor: roadTreatmentStyleSchema.optional(),
@@ -12796,7 +13456,7 @@ var roadsModuleSchema = z6.object({
     ramp: roadTreatmentStyleSchema.optional(),
     unpaved: roadTreatmentStyleSchema.optional()
   }).strict().optional(),
-  mountainBike: z6.object({
+  mountainBike: z7.object({
     "0": roadTreatmentStyleSchema.optional(),
     "0+": roadTreatmentStyleSchema.optional(),
     "1": roadTreatmentStyleSchema.optional(),
@@ -12809,9 +13469,9 @@ var roadsModuleSchema = z6.object({
     "5": roadTreatmentStyleSchema.optional(),
     "6": roadTreatmentStyleSchema.optional()
   }).strict().optional(),
-  oneWayMarkers: z6.boolean().optional(),
-  outline: z6.enum(["none", "subtle", "strong"]).optional(),
-  restrictions: z6.object({
+  oneWayMarkers: z7.boolean().optional(),
+  outline: z7.enum(["none", "subtle", "strong"]).optional(),
+  restrictions: z7.object({
     access: roadTreatmentStyleSchema.optional(),
     bicycle: roadTreatmentStyleSchema.optional(),
     foot: roadTreatmentStyleSchema.optional(),
@@ -12819,24 +13479,24 @@ var roadsModuleSchema = z6.object({
     toll: roadTreatmentStyleSchema.optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional(),
-  roundabouts: z6.object({ casing: circleStyleSchema.optional(), fill: circleStyleSchema.optional() }).strict().optional(),
-  serviceTypes: z6.object({
+  roundabouts: z7.object({ casing: circleStyleSchema.optional(), fill: circleStyleSchema.optional() }).strict().optional(),
+  serviceTypes: z7.object({
     alley: roadTreatmentStyleSchema.optional(),
     crossover: roadTreatmentStyleSchema.optional(),
     driveway: roadTreatmentStyleSchema.optional(),
     parkingAisle: roadTreatmentStyleSchema.optional(),
     yard: roadTreatmentStyleSchema.optional()
   }).strict().optional(),
-  sidewalks: z6.object({
+  sidewalks: z7.object({
     outline: lineStyleSchema.optional(),
     pattern: fillStyleSchema.optional(),
     surface: fillStyleSchema.optional()
   }).strict().optional(),
   structures: roadStructureMapSchema.optional(),
-  weight: z6.enum(["thin", "regular", "bold"]).optional(),
-  widthScale: z6.partialRecord(roadClassSchema, themeNumberValueSchema).optional()
+  weight: z7.enum(["thin", "regular", "bold"]).optional(),
+  widthScale: z7.partialRecord(roadClassSchema, themeNumberValueSchema).optional()
 }).strict();
-var placeLabelStylesSchema = z6.object({
+var placeLabelStylesSchema = z7.object({
   city: symbolStyleSchema.optional(),
   continent: symbolStyleSchema.optional(),
   country: symbolStyleSchema.optional(),
@@ -12846,65 +13506,65 @@ var placeLabelStylesSchema = z6.object({
   town: symbolStyleSchema.optional(),
   village: symbolStyleSchema.optional()
 }).strict();
-var waterLabelStylesSchema = z6.object({
+var waterLabelStylesSchema = z7.object({
   line: symbolStyleSchema.optional(),
   ocean: symbolStyleSchema.optional(),
   other: symbolStyleSchema.optional(),
   waterway: symbolStyleSchema.optional()
 }).strict();
-var labelsModuleSchema = z6.object({
-  type: z6.literal("labels"),
-  aerodromeCodes: z6.enum(["none", "iata", "all"]).optional(),
-  collisionPriority: z6.enum(["balanced", "navigation"]).optional(),
-  enabled: z6.boolean().optional(),
-  junctions: z6.boolean().optional(),
-  language: z6.string().trim().min(1).optional(),
-  places: z6.enum(["none", "major", "all"]).optional(),
-  roadClasses: z6.array(roadClassSchema).min(1).optional(),
+var labelsModuleSchema = z7.object({
+  type: z7.literal("labels"),
+  aerodromeCodes: z7.enum(["none", "iata", "all"]).optional(),
+  collisionPriority: z7.enum(["balanced", "navigation"]).optional(),
+  enabled: z7.boolean().optional(),
+  junctions: z7.boolean().optional(),
+  language: z7.string().trim().min(1).optional(),
+  places: z7.enum(["none", "major", "all"]).optional(),
+  roadClasses: z7.array(roadClassSchema).min(1).optional(),
   renderStack: renderStackSchema.optional(),
-  roads: z6.enum(["none", "highways", "major", "streets", "all"]).optional(),
-  styles: z6.object({
+  roads: z7.enum(["none", "highways", "major", "streets", "all"]).optional(),
+  styles: z7.object({
     aerodrome: symbolStyleSchema.optional(),
     junctions: symbolStyleSchema.optional(),
     places: placeLabelStylesSchema.optional(),
-    roads: z6.partialRecord(roadClassSchema, symbolStyleSchema).optional(),
-    shields: z6.object({
+    roads: z7.partialRecord(roadClassSchema, symbolStyleSchema).optional(),
+    shields: z7.object({
       default: symbolStyleSchema.optional(),
       detail: symbolStyleSchema.optional(),
-      kinds: z6.record(identifierSchema, z6.object({ image: themeImageValueSchema }).strict()).optional(),
+      kinds: z7.record(identifierSchema, z7.object({ image: themeImageValueSchema }).strict()).optional(),
       overview: symbolStyleSchema.optional(),
-      textColors: z6.record(identifierSchema, z6.object({ color: themeColorValueSchema }).strict()).optional()
+      textColors: z7.record(identifierSchema, z7.object({ color: themeColorValueSchema }).strict()).optional()
     }).strict().optional(),
     water: waterLabelStylesSchema.optional()
   }).strict().optional(),
-  shields: z6.enum(["none", "major", "all"]).optional(),
-  water: z6.enum(["none", "major", "all"]).optional()
+  shields: z7.enum(["none", "major", "all"]).optional(),
+  water: z7.enum(["none", "major", "all"]).optional()
 }).strict();
-var poiModuleSchema = z6.object({
-  type: z6.literal("poi"),
-  categories: z6.array(z6.enum(tileflowPoiCategories)).optional(),
-  color: z6.enum(["uniform", "category"]).optional(),
-  density: z6.union([z6.literal(1), z6.literal(2), z6.literal(3), z6.literal(4), z6.literal(5)]).optional(),
-  enabled: z6.boolean().optional(),
-  icons: z6.boolean().optional(),
-  labels: z6.boolean().optional(),
+var poiModuleSchema = z7.object({
+  type: z7.literal("poi"),
+  categories: z7.array(z7.enum(tileflowPoiCategories)).optional(),
+  color: z7.enum(["uniform", "category"]).optional(),
+  density: z7.union([z7.literal(1), z7.literal(2), z7.literal(3), z7.literal(4), z7.literal(5)]).optional(),
+  enabled: z7.boolean().optional(),
+  icons: z7.boolean().optional(),
+  labels: z7.boolean().optional(),
   minZoom: zoomNumberSchema.optional(),
-  placement: z6.object({
-    coupleIconAndLabel: z6.boolean().optional(),
-    iconPadding: z6.number().finite().min(0).optional(),
-    textPadding: z6.number().finite().min(0).optional()
+  placement: z7.object({
+    coupleIconAndLabel: z7.boolean().optional(),
+    iconPadding: z7.number().finite().min(0).optional(),
+    textPadding: z7.number().finite().min(0).optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional(),
-  styles: z6.partialRecord(z6.enum(tileflowPoiCategories), poiCategoryStyleSchema).optional()
+  styles: z7.partialRecord(z7.enum(tileflowPoiCategories), poiCategoryStyleSchema).optional()
 }).strict();
-var nauticalModuleSchema = z6.object({
-  type: z6.literal("nautical"),
+var nauticalModuleSchema = z7.object({
+  type: z7.literal("nautical"),
   aids: markerSymbolStyleSchema.optional(),
   coverage: areaStyleSchema.optional(),
-  enabled: z6.boolean().optional(),
+  enabled: z7.boolean().optional(),
   hazardAreas: areaStyleSchema.optional(),
   hazards: markerSymbolStyleSchema.optional(),
-  labels: z6.object({
+  labels: z7.object({
     coverage: symbolStyleSchema.optional(),
     hazards: symbolStyleSchema.optional(),
     navigationAreas: symbolStyleSchema.optional(),
@@ -12920,7 +13580,7 @@ var nauticalModuleSchema = z6.object({
   wreckAreas: areaStyleSchema.optional(),
   wrecks: markerSymbolStyleSchema.optional()
 }).strict();
-var modulesSchema = z6.object({
+var modulesSchema = z7.object({
   addresses: addressesModuleSchema.optional(),
   aeroways: aerowaysModuleSchema.optional(),
   boundaries: boundariesModuleSchema.optional(),
@@ -12932,151 +13592,151 @@ var modulesSchema = z6.object({
   poi: poiModuleSchema.optional(),
   roads: roadsModuleSchema.optional(),
   transit: transitModuleSchema.optional(),
-  vegetation: z6.object({
-    type: z6.literal("vegetation"),
-    enabled: z6.boolean().optional(),
+  vegetation: z7.object({
+    type: z7.literal("vegetation"),
+    enabled: z7.boolean().optional(),
     flat: circleStyleSchema.optional(),
-    mode: z6.enum(["3d", "flat"]).optional(),
+    mode: z7.enum(["3d", "flat"]).optional(),
     renderStack: renderStackSchema.optional(),
-    threeDimensional: z6.object({
+    threeDimensional: z7.object({
       barkColor: themeColorValueSchema.optional(),
-      broadleafColors: z6.array(themeColorValueSchema).min(1).max(8).optional(),
-      coniferColors: z6.array(themeColorValueSchema).min(1).max(8).optional(),
-      crownScale: z6.union([
-        z6.number().finite().positive().max(10),
+      broadleafColors: z7.array(themeColorValueSchema).min(1).max(8).optional(),
+      coniferColors: z7.array(themeColorValueSchema).min(1).max(8).optional(),
+      crownScale: z7.union([
+        z7.number().finite().positive().max(10),
         themeNumberReferenceSchema,
-        z6.object({
-          kind: z6.literal("theme-fixed"),
-          reason: z6.string().trim().min(1),
-          value: z6.number().finite().positive().max(10)
+        z7.object({
+          kind: z7.literal("theme-fixed"),
+          reason: z7.string().trim().min(1),
+          value: z7.number().finite().positive().max(10)
         }).strict()
       ]).optional(),
-      heightScale: z6.union([
-        z6.number().finite().positive().max(10),
+      heightScale: z7.union([
+        z7.number().finite().positive().max(10),
         themeNumberReferenceSchema,
-        z6.object({
-          kind: z6.literal("theme-fixed"),
-          reason: z6.string().trim().min(1),
-          value: z6.number().finite().positive().max(10)
+        z7.object({
+          kind: z7.literal("theme-fixed"),
+          reason: z7.string().trim().min(1),
+          value: z7.number().finite().positive().max(10)
         }).strict()
       ]).optional()
     }).strict().optional()
   }).strict().optional(),
   water: waterModuleSchema.optional()
 }).strict();
-var layerBindingsSchema = z6.object({
-  aerodromeLabel: z6.string().trim().min(1),
-  aeroway: z6.string().trim().min(1),
-  boundary: z6.string().trim().min(1),
-  building: z6.string().trim().min(1),
-  bathymetry: z6.string().trim().min(1).optional(),
-  businessCorridor: z6.string().trim().min(1).optional(),
-  canopy: z6.string().trim().min(1).optional(),
-  circularFeature: z6.string().trim().min(1).optional(),
-  globalLandcover: z6.string().trim().min(1).optional(),
-  houseNumber: z6.string().trim().min(1),
-  landcover: z6.string().trim().min(1),
-  landuse: z6.string().trim().min(1),
-  mountainPeak: z6.string().trim().min(1),
-  park: z6.string().trim().min(1),
-  place: z6.string().trim().min(1),
-  poi: z6.string().trim().min(1),
-  road: z6.string().trim().min(1),
-  roadName: z6.string().trim().min(1),
-  roadShield: z6.string().trim().min(1).optional(),
-  sidewalk: z6.string().trim().min(1).optional(),
-  streetFurniture: z6.string().trim().min(1).optional(),
-  tree: z6.string().trim().min(1).optional(),
-  water: z6.string().trim().min(1),
-  waterName: z6.string().trim().min(1),
-  waterway: z6.string().trim().min(1)
+var layerBindingsSchema = z7.object({
+  aerodromeLabel: z7.string().trim().min(1),
+  aeroway: z7.string().trim().min(1),
+  boundary: z7.string().trim().min(1),
+  building: z7.string().trim().min(1),
+  bathymetry: z7.string().trim().min(1).optional(),
+  businessCorridor: z7.string().trim().min(1).optional(),
+  canopy: z7.string().trim().min(1).optional(),
+  circularFeature: z7.string().trim().min(1).optional(),
+  globalLandcover: z7.string().trim().min(1).optional(),
+  houseNumber: z7.string().trim().min(1),
+  landcover: z7.string().trim().min(1),
+  landuse: z7.string().trim().min(1),
+  mountainPeak: z7.string().trim().min(1),
+  park: z7.string().trim().min(1),
+  place: z7.string().trim().min(1),
+  poi: z7.string().trim().min(1),
+  road: z7.string().trim().min(1),
+  roadName: z7.string().trim().min(1),
+  roadShield: z7.string().trim().min(1).optional(),
+  sidewalk: z7.string().trim().min(1).optional(),
+  streetFurniture: z7.string().trim().min(1).optional(),
+  tree: z7.string().trim().min(1).optional(),
+  water: z7.string().trim().min(1),
+  waterName: z7.string().trim().min(1),
+  waterway: z7.string().trim().min(1)
 }).strict();
-var fieldBindingsSchema = z6.object({
-  access: z6.string().trim().min(1),
-  activityScore: z6.string().trim().min(1),
-  adminLevel: z6.string().trim().min(1),
-  bicycle: z6.string().trim().min(1),
-  bathymetryMinDepth: z6.string().trim().min(1).optional(),
-  bathymetrySortKey: z6.string().trim().min(1).optional(),
-  brunnel: z6.string().trim().min(1),
-  buildingTone: z6.string().trim().min(1),
-  canopyClearanceAtZoom15: z6.string().trim().min(1),
-  canopyCoverPercent: z6.string().trim().min(1),
-  canopyRank: z6.string().trim().min(1),
-  capital: z6.string().trim().min(1),
-  circularClearanceExtraAtZoom15: z6.string().trim().min(1),
-  circularKind: z6.string().trim().min(1),
-  circularRadiusAtZoom15: z6.string().trim().min(1),
-  circularRadiusMeters: z6.string().trim().min(1),
-  circularInnerRadiusMeters: z6.string().trim().min(1),
-  circularOuterRadiusMeters: z6.string().trim().min(1),
-  class: z6.string().trim().min(1),
-  crossing: z6.string().trim().min(1),
-  confidence: z6.string().trim().min(1),
-  circumference: z6.string().trim().min(1),
-  diameterCrown: z6.string().trim().min(1),
-  disputed: z6.string().trim().min(1),
-  direction: z6.string().trim().min(1),
-  elevation: z6.string().trim().min(1),
-  elevationFeet: z6.string().trim().min(1),
-  expressway: z6.string().trim().min(1),
-  foot: z6.string().trim().min(1),
-  height: z6.string().trim().min(1),
-  hasParts: z6.string().trim().min(1),
-  hide3d: z6.string().trim().min(1),
-  horse: z6.string().trim().min(1),
-  houseNumber: z6.string().trim().min(1),
-  importanceTier: z6.string().trim().min(1),
-  iata: z6.string().trim().min(1),
-  icao: z6.string().trim().min(1),
-  indoor: z6.string().trim().min(1),
-  intermittent: z6.string().trim().min(1),
-  genus: z6.string().trim().min(1),
-  layer: z6.string().trim().min(1),
-  leafCycle: z6.string().trim().min(1),
-  leafType: z6.string().trim().min(1),
-  level: z6.string().trim().min(1),
-  maritime: z6.string().trim().min(1),
-  markings: z6.string().trim().min(1),
-  minHeight: z6.string().trim().min(1),
-  minZoom: z6.string().trim().min(1),
-  mtbScale: z6.string().trim().min(1),
-  name: z6.string().trim().min(1),
-  nameEnglish: z6.string().trim().min(1),
-  nameLatin: z6.string().trim().min(1),
-  network: z6.string().trim().min(1),
-  official: z6.string().trim().min(1),
-  oneway: z6.string().trim().min(1),
-  poiCategory: z6.string().trim().min(1),
-  poiFilterRank: z6.string().trim().min(1),
-  poiIcon: z6.string().trim().min(1),
-  poiSizeRank: z6.string().trim().min(1),
-  poiType: z6.string().trim().min(1),
-  ramp: z6.string().trim().min(1),
-  rank: z6.string().trim().min(1),
-  ref: z6.string().trim().min(1),
-  refLength: z6.string().trim().min(1),
-  renderHeight: z6.string().trim().min(1),
-  renderMinHeight: z6.string().trim().min(1),
-  shieldKind: z6.string().trim().min(1).optional(),
-  shieldLineLengthMeters: z6.string().trim().min(1).optional(),
-  shieldNetwork: z6.string().trim().min(1).optional(),
-  shieldRank: z6.string().trim().min(1).optional(),
-  shieldText: z6.string().trim().min(1).optional(),
-  shieldTextColor: z6.string().trim().min(1).optional(),
-  service: z6.string().trim().min(1),
-  species: z6.string().trim().min(1),
-  speciesWikidata: z6.string().trim().min(1),
-  subclass: z6.string().trim().min(1),
-  surface: z6.string().trim().min(1),
-  toll: z6.string().trim().min(1)
+var fieldBindingsSchema = z7.object({
+  access: z7.string().trim().min(1),
+  activityScore: z7.string().trim().min(1),
+  adminLevel: z7.string().trim().min(1),
+  bicycle: z7.string().trim().min(1),
+  bathymetryMinDepth: z7.string().trim().min(1).optional(),
+  bathymetrySortKey: z7.string().trim().min(1).optional(),
+  brunnel: z7.string().trim().min(1),
+  buildingTone: z7.string().trim().min(1),
+  canopyClearanceAtZoom15: z7.string().trim().min(1),
+  canopyCoverPercent: z7.string().trim().min(1),
+  canopyRank: z7.string().trim().min(1),
+  capital: z7.string().trim().min(1),
+  circularClearanceExtraAtZoom15: z7.string().trim().min(1),
+  circularKind: z7.string().trim().min(1),
+  circularRadiusAtZoom15: z7.string().trim().min(1),
+  circularRadiusMeters: z7.string().trim().min(1),
+  circularInnerRadiusMeters: z7.string().trim().min(1),
+  circularOuterRadiusMeters: z7.string().trim().min(1),
+  class: z7.string().trim().min(1),
+  crossing: z7.string().trim().min(1),
+  confidence: z7.string().trim().min(1),
+  circumference: z7.string().trim().min(1),
+  diameterCrown: z7.string().trim().min(1),
+  disputed: z7.string().trim().min(1),
+  direction: z7.string().trim().min(1),
+  elevation: z7.string().trim().min(1),
+  elevationFeet: z7.string().trim().min(1),
+  expressway: z7.string().trim().min(1),
+  foot: z7.string().trim().min(1),
+  height: z7.string().trim().min(1),
+  hasParts: z7.string().trim().min(1),
+  hide3d: z7.string().trim().min(1),
+  horse: z7.string().trim().min(1),
+  houseNumber: z7.string().trim().min(1),
+  importanceTier: z7.string().trim().min(1),
+  iata: z7.string().trim().min(1),
+  icao: z7.string().trim().min(1),
+  indoor: z7.string().trim().min(1),
+  intermittent: z7.string().trim().min(1),
+  genus: z7.string().trim().min(1),
+  layer: z7.string().trim().min(1),
+  leafCycle: z7.string().trim().min(1),
+  leafType: z7.string().trim().min(1),
+  level: z7.string().trim().min(1),
+  maritime: z7.string().trim().min(1),
+  markings: z7.string().trim().min(1),
+  minHeight: z7.string().trim().min(1),
+  minZoom: z7.string().trim().min(1),
+  mtbScale: z7.string().trim().min(1),
+  name: z7.string().trim().min(1),
+  nameEnglish: z7.string().trim().min(1),
+  nameLatin: z7.string().trim().min(1),
+  network: z7.string().trim().min(1),
+  official: z7.string().trim().min(1),
+  oneway: z7.string().trim().min(1),
+  poiCategory: z7.string().trim().min(1),
+  poiFilterRank: z7.string().trim().min(1),
+  poiIcon: z7.string().trim().min(1),
+  poiSizeRank: z7.string().trim().min(1),
+  poiType: z7.string().trim().min(1),
+  ramp: z7.string().trim().min(1),
+  rank: z7.string().trim().min(1),
+  ref: z7.string().trim().min(1),
+  refLength: z7.string().trim().min(1),
+  renderHeight: z7.string().trim().min(1),
+  renderMinHeight: z7.string().trim().min(1),
+  shieldKind: z7.string().trim().min(1).optional(),
+  shieldLineLengthMeters: z7.string().trim().min(1).optional(),
+  shieldNetwork: z7.string().trim().min(1).optional(),
+  shieldRank: z7.string().trim().min(1).optional(),
+  shieldText: z7.string().trim().min(1).optional(),
+  shieldTextColor: z7.string().trim().min(1).optional(),
+  service: z7.string().trim().min(1),
+  species: z7.string().trim().min(1),
+  speciesWikidata: z7.string().trim().min(1),
+  subclass: z7.string().trim().min(1),
+  surface: z7.string().trim().min(1),
+  toll: z7.string().trim().min(1)
 }).strict();
-var openMapTilesSchema = z6.object({
-  type: z6.literal("openmaptiles"),
-  contractVersion: z6.literal(openMapTilesContractVersion),
+var openMapTilesSchema = z7.object({
+  type: z7.literal("openmaptiles"),
+  contractVersion: z7.literal(openMapTilesContractVersion),
   fields: fieldBindingsSchema.partial().optional(),
   layers: layerBindingsSchema.partial().optional(),
-  semantics: z6.object({ parkLayer: z6.enum(["mixed", "protected-only"]).optional() }).strict().optional()
+  semantics: z7.object({ parkLayer: z7.enum(["mixed", "protected-only"]).optional() }).strict().optional()
 }).strict().transform(
   (schema) => openMapTiles({
     capabilities: schema.layers === void 0 ? void 0 : {
@@ -13092,12 +13752,12 @@ var openMapTilesSchema = z6.object({
   })
 );
 var vectorDataShape = {
-  type: z6.literal("vector-tiles"),
-  attribution: z6.string().trim().min(1),
+  type: z7.literal("vector-tiles"),
+  attribution: z7.string().trim().min(1),
   revision: revisionSchema.optional(),
   schema: openMapTilesSchema
 };
-var publicVectorUrlSchema = z6.string().min(1).max(4096).superRefine((value, context) => {
+var publicVectorUrlSchema = z7.string().min(1).max(4096).superRefine((value, context) => {
   try {
     validatePublicVectorUrl(value);
   } catch (error) {
@@ -13107,8 +13767,8 @@ var publicVectorUrlSchema = z6.string().min(1).max(4096).superRefine((value, con
     });
   }
 }).describe("tileflow-public-vector-url");
-var marineSourceSchema = z6.object({
-  attribution: z6.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
+var marineSourceSchema = z7.object({
+  attribution: z7.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
   sourceId: identifierSchema.optional(),
   url: publicVectorUrlSchema.optional()
 }).strict();
@@ -13116,24 +13776,24 @@ var bathymetryDemUrlSchema = publicVectorUrlSchema.refine(
   (value) => !value.startsWith("pmtiles://"),
   "Expected an HTTPS, loopback HTTP, or root-relative DEM TileJSON URL"
 ).describe("tileflow-public-dem-url");
-var bathymetryReliefSchema = z6.object({
+var bathymetryReliefSchema = z7.object({
   accentColor: terrainColorValueSchema.optional(),
-  attribution: z6.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
-  encoding: z6.enum(["mapbox", "terrarium"]).optional(),
-  exaggeration: terrainNumberValueSchema(z6.number().finite().min(0).max(1)).optional(),
+  attribution: z7.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
+  encoding: z7.enum(["mapbox", "terrarium"]).optional(),
+  exaggeration: terrainNumberValueSchema(z7.number().finite().min(0).max(1)).optional(),
   highlightColor: terrainColorValueSchema.optional(),
-  illuminationAltitude: terrainNumberValueSchema(z6.number().finite().min(0).max(90)).optional(),
-  illuminationAnchor: z6.enum(["map", "viewport"]).optional(),
-  illuminationDirection: terrainNumberValueSchema(z6.number().finite().min(0).max(359)).optional(),
+  illuminationAltitude: terrainNumberValueSchema(z7.number().finite().min(0).max(90)).optional(),
+  illuminationAnchor: z7.enum(["map", "viewport"]).optional(),
+  illuminationDirection: terrainNumberValueSchema(z7.number().finite().min(0).max(359)).optional(),
   maxZoom: zoomNumberSchema.optional(),
   minZoom: zoomNumberSchema.optional(),
-  multidirectional: z6.boolean().optional(),
-  opacity: terrainNumberValueSchema(z6.number().finite().min(0).max(1)).optional(),
+  multidirectional: z7.boolean().optional(),
+  opacity: terrainNumberValueSchema(z7.number().finite().min(0).max(1)).optional(),
   shadowColor: terrainColorValueSchema.optional(),
   sourceId: identifierSchema.optional(),
-  tileSize: z6.union([z6.literal(256), z6.literal(512)]).optional(),
+  tileSize: z7.union([z7.literal(256), z7.literal(512)]).optional(),
   url: bathymetryDemUrlSchema.optional(),
-  visible: z6.boolean().optional()
+  visible: z7.boolean().optional()
 }).strict().superRefine((relief, context) => {
   if (relief.minZoom !== void 0 && relief.maxZoom !== void 0 && relief.minZoom > relief.maxZoom) {
     context.addIssue({
@@ -13143,33 +13803,33 @@ var bathymetryReliefSchema = z6.object({
     });
   }
 });
-var bathymetryConfigSchema = z6.object({
+var bathymetryConfigSchema = z7.object({
   ...marineSourceSchema.shape,
-  bands: z6.union([z6.literal(false), fillStyleSchema]).optional(),
-  contours: z6.union([z6.literal(false), lineStyleSchema]).optional(),
-  display: z6.enum(["bands", "relief", "hybrid"]).optional(),
-  labels: z6.union([z6.literal(false), symbolStyleSchema]).optional(),
-  relief: z6.union([z6.literal(false), bathymetryReliefSchema]).optional(),
-  type: z6.literal("bathymetry")
+  bands: z7.union([z7.literal(false), fillStyleSchema]).optional(),
+  contours: z7.union([z7.literal(false), lineStyleSchema]).optional(),
+  display: z7.enum(["bands", "relief", "hybrid"]).optional(),
+  labels: z7.union([z7.literal(false), symbolStyleSchema]).optional(),
+  relief: z7.union([z7.literal(false), bathymetryReliefSchema]).optional(),
+  type: z7.literal("bathymetry")
 }).strict();
-var marineSchema = z6.union([
-  z6.enum(["none", "bathymetry", "nautical", "chart"]),
-  z6.object({
-    bathymetry: z6.union([z6.literal(false), marineSourceSchema, bathymetryConfigSchema]).optional(),
-    nautical: z6.union([z6.literal(false), marineSourceSchema]).optional()
+var marineSchema = z7.union([
+  z7.enum(["none", "bathymetry", "nautical", "chart"]),
+  z7.object({
+    bathymetry: z7.union([z7.literal(false), marineSourceSchema, bathymetryConfigSchema]).optional(),
+    nautical: z7.union([z7.literal(false), marineSourceSchema]).optional()
   }).strict()
 ]);
-var directVectorDataSchema = z6.object({
+var directVectorDataSchema = z7.object({
   ...vectorDataShape,
-  bounds: z6.tuple([
-    z6.number().finite().min(-180).max(180),
-    z6.number().finite().min(-90).max(90),
-    z6.number().finite().min(-180).max(180),
-    z6.number().finite().min(-90).max(90)
+  bounds: z7.tuple([
+    z7.number().finite().min(-180).max(180),
+    z7.number().finite().min(-90).max(90),
+    z7.number().finite().min(-180).max(180),
+    z7.number().finite().min(-90).max(90)
   ]).optional(),
-  maxzoom: z6.number().int().min(0).max(30).optional(),
-  minzoom: z6.number().int().min(0).max(30).optional(),
-  tiles: z6.array(publicVectorUrlSchema).min(1).max(8)
+  maxzoom: z7.number().int().min(0).max(30).optional(),
+  minzoom: z7.number().int().min(0).max(30).optional(),
+  tiles: z7.array(publicVectorUrlSchema).min(1).max(8)
 }).strict().refine(
   (value) => value.minzoom === void 0 || value.maxzoom === void 0 || value.minzoom <= value.maxzoom,
   { message: "minzoom must not exceed maxzoom", path: ["minzoom"] }
@@ -13177,34 +13837,34 @@ var directVectorDataSchema = z6.object({
   (value) => value.bounds === void 0 || value.bounds[0] < value.bounds[2] && value.bounds[1] < value.bounds[3],
   { message: "bounds must have increasing axes", path: ["bounds"] }
 );
-var dataSchema = z6.union([
-  z6.object({
-    type: z6.literal("tileflow-world"),
-    generation: z6.literal(tileflowWorldGeneration),
-    selection: z6.discriminatedUnion("kind", [
-      z6.object({ kind: z6.literal("current"), product: z6.literal("world-v1") }).strict(),
-      z6.object({
-        kind: z6.literal("release"),
-        product: z6.literal("world-v1"),
-        release: z6.object({
-          descriptorSha256: z6.string().regex(/^[0-9a-f]{64}$/u),
+var dataSchema = z7.union([
+  z7.object({
+    type: z7.literal("tileflow-world"),
+    generation: z7.literal(tileflowWorldGeneration),
+    selection: z7.discriminatedUnion("kind", [
+      z7.object({ kind: z7.literal("current"), product: z7.literal("world-v1") }).strict(),
+      z7.object({
+        kind: z7.literal("release"),
+        product: z7.literal("world-v1"),
+        release: z7.object({
+          descriptorSha256: z7.string().regex(/^[0-9a-f]{64}$/u),
           releaseId: tileflowWorldReleaseIdSchema
         }).strict()
       }).strict()
     ])
   }).strict(),
-  z6.object({ ...vectorDataShape, url: publicVectorUrlSchema }).strict(),
+  z7.object({ ...vectorDataShape, url: publicVectorUrlSchema }).strict(),
   directVectorDataSchema
 ]);
-var hostedTilesetSourceSchema = z6.object({
-  attribution: z6.string().trim().min(1).max(4096),
-  kind: z6.literal("hosted-tileset"),
-  local: z6.string().refine(isSafeLocalPmtilesPath, {
+var hostedTilesetSourceSchema = z7.object({
+  attribution: z7.string().trim().min(1).max(4096),
+  kind: z7.literal("hosted-tileset"),
+  local: z7.string().refine(isSafeLocalPmtilesPath, {
     message: "Expected a safe relative .pmtiles path beginning with ./ or ../"
   }),
-  tileset: z6.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u).refine((value) => value !== "terrain" && value !== "world", "Expected a Team tileset ID"),
-  tileSize: z6.union([z6.literal(256), z6.literal(512)]).optional(),
-  type: z6.enum(["raster", "vector"])
+  tileset: z7.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u).refine((value) => value !== "terrain" && value !== "world", "Expected a Team tileset ID"),
+  tileSize: z7.union([z7.literal(256), z7.literal(512)]).optional(),
+  type: z7.enum(["raster", "vector"])
 }).strict().superRefine((source, context) => {
   if (source.type === "vector" && source.tileSize !== void 0) {
     context.addIssue({
@@ -13214,7 +13874,7 @@ var hostedTilesetSourceSchema = z6.object({
     });
   }
 });
-var hostedSourcesSchema = z6.record(tileflowMapIdSchema, hostedTilesetSourceSchema).superRefine((sources, context) => {
+var hostedSourcesSchema = z7.record(tileflowMapIdSchema, hostedTilesetSourceSchema).superRefine((sources, context) => {
   if (Object.keys(sources).length > tileflowHostedSourceLimit) {
     context.addIssue({
       code: "too_big",
@@ -13223,7 +13883,7 @@ var hostedSourcesSchema = z6.record(tileflowMapIdSchema, hostedTilesetSourceSche
     });
   }
 });
-var maplibreOverlayLayerSchema = z6.record(z6.string(), z6.unknown()).superRefine((layer, context) => {
+var maplibreOverlayLayerSchema = z7.record(z7.string(), z7.unknown()).superRefine((layer, context) => {
   if (!tileflowMapIdSchema.safeParse(layer.id).success) {
     context.addIssue({ code: "custom", message: "Expected a portable layer ID", path: ["id"] });
   }
@@ -13241,28 +13901,28 @@ var maplibreOverlayLayerSchema = z6.record(z6.string(), z6.unknown()).superRefin
     });
   }
 });
-var maplibreOverlaySchema = z6.object({
-  kind: z6.literal("maplibre-overlay"),
-  layers: z6.array(maplibreOverlayLayerSchema).min(1),
-  placement: z6.enum(tileflowOverlayPlacements),
+var maplibreOverlaySchema = z7.object({
+  kind: z7.literal("maplibre-overlay"),
+  layers: z7.array(maplibreOverlayLayerSchema).min(1),
+  placement: z7.enum(tileflowOverlayPlacements),
   source: tileflowMapIdSchema
 }).strict();
-var overlaysSchema = z6.record(tileflowMapIdSchema, maplibreOverlaySchema);
-var localAssetDirectorySchema = z6.string().min(3).max(tileflowLocalDirectoryMaximumLength).refine(isTileflowLocalDirectory, { message: tileflowLocalDirectoryMessage });
-var packageAssetDirectorySchema = z6.object({
-  kind: z6.literal("package-directory"),
-  package: z6.string().regex(
+var overlaysSchema = z7.record(tileflowMapIdSchema, maplibreOverlaySchema);
+var localAssetDirectorySchema = z7.string().min(3).max(tileflowLocalDirectoryMaximumLength).refine(isTileflowLocalDirectory, { message: tileflowLocalDirectoryMessage });
+var packageAssetDirectorySchema = z7.object({
+  kind: z7.literal("package-directory"),
+  package: z7.string().regex(
     /^(?:@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*|[a-z0-9][a-z0-9._-]*)$/u,
     "Expected a lowercase npm package name"
   ),
-  path: z6.string().min(1).max(512).refine(
+  path: z7.string().min(1).max(512).refine(
     (value) => !value.startsWith("/") && !value.includes("\\") && value.split("/").every((segment) => Boolean(segment) && segment !== "." && segment !== ".."),
     "Expected a portable package-relative directory"
   )
 }).strict();
-var assetDirectorySchema = z6.union([localAssetDirectorySchema, packageAssetDirectorySchema]);
-var iconDirectoriesSchema = z6.array(
-  z6.union([localAssetDirectorySchema, packageAssetDirectorySchema, tileflowIconSetSourceSchema])
+var assetDirectorySchema = z7.union([localAssetDirectorySchema, packageAssetDirectorySchema]);
+var iconDirectoriesSchema = z7.array(
+  z7.union([localAssetDirectorySchema, packageAssetDirectorySchema, tileflowIconSetSourceSchema])
 ).max(tileflowIconSourceLimit).superRefine((sources, context) => {
   try {
     collectTileflowIconSetReferences(sources);
@@ -13273,9 +13933,9 @@ var iconDirectoriesSchema = z6.array(
     });
   }
 });
-var fontDirectoriesSchema = z6.array(assetDirectorySchema).max(16);
-var fontStacksSchema = z6.array(
-  z6.string().min(1).max(200).refine(
+var fontDirectoriesSchema = z7.array(assetDirectorySchema).max(16);
+var fontStacksSchema = z7.array(
+  z7.string().min(1).max(200).refine(
     (value) => value === value.trim() && value === value.normalize("NFC") && !/[\p{Cc}\\/]/u.test(value),
     "Expected an exact NFC MapLibre font-stack key without whitespace padding, controls, slashes, or backslashes"
   )
@@ -13292,10 +13952,10 @@ var fontStacksSchema = z6.array(
     seen.add(fontStack);
   }
 });
-var glyphsSchema = z6.object({
+var glyphsSchema = z7.object({
   fontStacks: fontStacksSchema,
-  kind: z6.literal("url"),
-  url: z6.string().min(1).refine(
+  kind: z7.literal("url"),
+  url: z7.string().min(1).refine(
     (value) => value.includes("{fontstack}") && value.includes("{range}"),
     "Expected {fontstack} and {range} placeholders"
   ).refine(isSafeGlyphUrl, "Expected an HTTP(S), root-relative, or path-relative glyph URL")
@@ -13303,34 +13963,34 @@ var glyphsSchema = z6.object({
 var terrainLayerRangeShape = {
   maxZoom: zoomNumberSchema.optional(),
   minZoom: zoomNumberSchema.optional(),
-  visible: z6.boolean().optional()
+  visible: z7.boolean().optional()
 };
-var terrainHillshadeSchema = z6.object({
+var terrainHillshadeSchema = z7.object({
   ...terrainLayerRangeShape,
   accentColor: terrainColorValueSchema.optional(),
-  exaggeration: terrainNumberValueSchema(z6.number().finite().min(0).max(1)).optional(),
+  exaggeration: terrainNumberValueSchema(z7.number().finite().min(0).max(1)).optional(),
   highlightColor: terrainColorValueSchema.optional(),
-  illuminationAnchor: z6.enum(["map", "viewport"]).optional(),
-  illuminationDirection: terrainNumberValueSchema(z6.number().finite().min(0).max(359)).optional(),
+  illuminationAnchor: z7.enum(["map", "viewport"]).optional(),
+  illuminationDirection: terrainNumberValueSchema(z7.number().finite().min(0).max(359)).optional(),
   shadowColor: terrainColorValueSchema.optional()
 }).strict();
-var terrainContourLineSchema = z6.object({
+var terrainContourLineSchema = z7.object({
   ...terrainLayerRangeShape,
   color: terrainColorValueSchema.optional(),
-  opacity: terrainNumberValueSchema(z6.number().finite().min(0).max(1)).optional(),
-  width: terrainNumberValueSchema(z6.number().finite().min(0).max(32)).optional()
+  opacity: terrainNumberValueSchema(z7.number().finite().min(0).max(1)).optional(),
+  width: terrainNumberValueSchema(z7.number().finite().min(0).max(32)).optional()
 }).strict();
-var terrainContourLabelSchema = z6.object({
+var terrainContourLabelSchema = z7.object({
   ...terrainLayerRangeShape,
   color: terrainColorValueSchema.optional(),
   font: moduleFontValueSchema.optional(),
   haloColor: terrainColorValueSchema.optional(),
-  haloWidth: terrainNumberValueSchema(z6.number().finite().min(0).max(16)).optional(),
-  opacity: terrainNumberValueSchema(z6.number().finite().min(0).max(1)).optional(),
-  size: terrainNumberValueSchema(z6.number().finite().min(1).max(64)).optional(),
-  spacing: terrainNumberValueSchema(z6.number().finite().min(1).max(1e3)).optional()
+  haloWidth: terrainNumberValueSchema(z7.number().finite().min(0).max(16)).optional(),
+  opacity: terrainNumberValueSchema(z7.number().finite().min(0).max(1)).optional(),
+  size: terrainNumberValueSchema(z7.number().finite().min(1).max(64)).optional(),
+  spacing: terrainNumberValueSchema(z7.number().finite().min(1).max(1e3)).optional()
 }).strict();
-var terrainContourThresholdPairSchema = z6.tuple([z6.number().finite().min(1e-3).max(1e5), z6.number().finite().min(1e-3).max(1e5)]).refine(([minor, index]) => minor <= index, {
+var terrainContourThresholdPairSchema = z7.tuple([z7.number().finite().min(1e-3).max(1e5), z7.number().finite().min(1e-3).max(1e5)]).refine(([minor, index]) => minor <= index, {
   message: "Expected the index contour interval to be greater than or equal to the minor interval"
 }).refine(([minor, index]) => isWholeContourMultiple2(index, minor), {
   message: "Expected the index contour interval to be a whole multiple of the minor interval"
@@ -13339,7 +13999,7 @@ function isWholeContourMultiple2(value, interval) {
   const ratio = value / interval;
   return Math.abs(ratio - Math.round(ratio)) <= Number.EPSILON * Math.max(1, ratio) * 8;
 }
-var terrainContourThresholdsSchema = z6.record(z6.string().regex(/^(?:0|[1-9]|1\d|2[0-4])$/u), terrainContourThresholdPairSchema).superRefine((thresholds, context) => {
+var terrainContourThresholdsSchema = z7.record(z7.string().regex(/^(?:0|[1-9]|1\d|2[0-4])$/u), terrainContourThresholdPairSchema).superRefine((thresholds, context) => {
   const count = Object.keys(thresholds).length;
   if (count === 0 || count > 25) {
     context.addIssue({
@@ -13348,19 +14008,19 @@ var terrainContourThresholdsSchema = z6.record(z6.string().regex(/^(?:0|[1-9]|1\
     });
   }
 });
-var terrainContoursSchema = z6.object({
-  demMaxZoom: z6.number().int().min(0).max(24),
-  demUrl: z6.string().min(1).max(2048).refine(
+var terrainContoursSchema = z7.object({
+  demMaxZoom: z7.number().int().min(0).max(24),
+  demUrl: z7.string().min(1).max(2048).refine(
     isSafeTileflowDemUrlTemplate,
     "Expected a safe HTTP(S) DEM URL template containing {z}, {x}, and {y}"
   ),
   index: terrainContourLineSchema.optional(),
   labels: terrainContourLabelSchema.optional(),
-  maxZoom: z6.number().int().min(0).max(24).optional(),
+  maxZoom: z7.number().int().min(0).max(24).optional(),
   minZoom: zoomNumberSchema.optional(),
   minor: terrainContourLineSchema.optional(),
-  multiplier: z6.number().finite().min(1e-3).max(100).optional(),
-  overzoom: z6.number().int().min(0).max(8).optional(),
+  multiplier: z7.number().finite().min(1e-3).max(100).optional(),
+  overzoom: z7.number().int().min(0).max(8).optional(),
   sourceId: identifierSchema.optional(),
   thresholds: terrainContourThresholdsSchema
 }).strict().superRefine((contours, context) => {
@@ -13424,44 +14084,44 @@ var terrainContoursSchema = z6.object({
     }
   }
 });
-var terrainSchema = z6.union([
-  z6.enum(["none", "hillshade", "3d"]),
-  z6.object({
-    attribution: z6.string().optional(),
+var terrainSchema = z7.union([
+  z7.enum(["none", "hillshade", "3d"]),
+  z7.object({
+    attribution: z7.string().optional(),
     contours: terrainContoursSchema.optional(),
-    encoding: z6.enum(["mapbox", "terrarium"]).optional(),
-    exaggeration: z6.number().finite().min(0).max(10).optional(),
+    encoding: z7.enum(["mapbox", "terrarium"]).optional(),
+    exaggeration: z7.number().finite().min(0).max(10).optional(),
     hillshade: terrainHillshadeSchema.optional(),
-    mode: z6.enum(["none", "hillshade", "3d"]).optional(),
-    sourceId: z6.string().trim().min(1).optional(),
-    url: z6.string().trim().min(1).optional()
+    mode: z7.enum(["none", "hillshade", "3d"]).optional(),
+    sourceId: z7.string().trim().min(1).optional(),
+    url: z7.string().trim().min(1).optional()
   }).strict()
 ]);
-var atmosphereColorLiteralSchema = z6.string().refine((value) => Color3.parse(value)?.a === 1, "Expected an opaque color");
-var atmosphereColorSchema = z6.union([
+var atmosphereColorLiteralSchema = z7.string().refine((value) => Color3.parse(value)?.a === 1, "Expected an opaque color");
+var atmosphereColorSchema = z7.union([
   atmosphereColorLiteralSchema,
   fixedStringSchema.extend({ value: atmosphereColorLiteralSchema }),
-  themeTokenReferenceSchema.extend({ category: z6.literal("color") }),
+  themeTokenReferenceSchema.extend({ category: z7.literal("color") }),
   themeColorOperationSchema
 ]);
-var atmosphereSchema = z6.union([
-  z6.boolean(),
-  z6.object({
+var atmosphereSchema = z7.union([
+  z7.boolean(),
+  z7.object({
     skyColor: atmosphereColorSchema.optional(),
     horizonColor: atmosphereColorSchema.optional(),
     fogColor: atmosphereColorSchema.optional(),
     spaceColor: atmosphereColorSchema.optional(),
-    starIntensity: z6.number().finite().min(0).max(1).optional(),
-    starParallax: z6.number().finite().min(0).max(1).optional()
+    starIntensity: z7.number().finite().min(0).max(1).optional(),
+    starParallax: z7.number().finite().min(0).max(1).optional()
   }).strict()
 ]);
-var viewSchema = z6.object({
-  bearing: z6.number().finite().min(-180).max(180).optional(),
-  center: z6.tuple([z6.number().finite().min(-180).max(180), z6.number().finite().min(-90).max(90)]).optional(),
-  pitch: z6.number().finite().min(0).max(85).optional(),
+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(),
   zoom: zoomNumberSchema.optional()
 }).strict();
-var themesSchema = z6.record(tileflowThemeNameSchema, tileflowThemeSchema).superRefine((themes, context) => {
+var themesSchema = z7.record(tileflowThemeNameSchema, tileflowThemeSchema).superRefine((themes, context) => {
   const names = Object.keys(themes);
   if (names.length === 0) {
     context.addIssue({ code: "custom", message: "Expected at least one named theme" });
@@ -13485,8 +14145,8 @@ var themesSchema = z6.record(tileflowThemeNameSchema, tileflowThemeSchema).super
     }
   }
 }).describe("tileflow-themes");
-var systemThemesSchema = z6.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict();
-var resolvedTileflowMapSchema = z6.object({
+var systemThemesSchema = z7.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict();
+var resolvedTileflowMapSchema = z7.object({
   atmosphere: atmosphereSchema.optional(),
   data: dataSchema.optional(),
   defaultTheme: tileflowThemeNameSchema,
@@ -13496,14 +14156,14 @@ var resolvedTileflowMapSchema = z6.object({
   id: tileflowMapIdSchema,
   marine: marineSchema.optional(),
   modules: modulesSchema.optional(),
-  name: z6.string().trim().min(1),
+  name: z7.string().trim().min(1),
   overlays: overlaysSchema.optional(),
-  projection: z6.enum(["globe", "mercator"]).optional(),
+  projection: z7.enum(["globe", "mercator"]).optional(),
   sources: hostedSourcesSchema.optional(),
   systemThemes: systemThemesSchema.optional(),
   terrain: terrainSchema.optional(),
   themes: themesSchema,
-  version: z6.number().int().positive(),
+  version: z7.number().int().positive(),
   view: viewSchema.optional()
 }).strict().superRefine((map, context) => {
   if (map.fonts !== void 0 && map.glyphs !== void 0) {
@@ -13584,9 +14244,43 @@ function parseOrThrow(schema, input, name) {
   if (result.success) return result.data;
   throw new TileflowResolvedMapValidationError(
     name,
-    validationMessagesFromIssues(result.error.issues)
+    validationMessagesFromIssues(expandUnionIssues(result.error.issues, [], input))
   );
 }
+function expandUnionIssues(issues, base, input) {
+  return issues.flatMap((issue) => {
+    const path = [...base, ...issue.path];
+    if (issue.code !== "invalid_union" || issue.errors.length === 0) return [{ ...issue, path }];
+    const candidates = issue.errors.filter((branch) => !branch.some(isUnionBranchMismatch));
+    if (candidates.length === 0) {
+      return [{ ...issue, path, message: unmatchedUnionMessage(valueAtPath(input, path)) }];
+    }
+    const fewest = Math.min(...candidates.map((branch) => branch.length));
+    const best = candidates.filter((branch) => branch.length === fewest);
+    return best.length === 1 ? expandUnionIssues(best[0], path, input) : [{ ...issue, path }];
+  });
+}
+function isUnionBranchMismatch(issue) {
+  if (issue.path.length === 0)
+    return issue.code === "invalid_type" || issue.code === "invalid_value";
+  return issue.path.length === 1 && (issue.code === "invalid_value" || issue.code === "invalid_union" && issue.errors.length === 0);
+}
+function unmatchedUnionMessage(value) {
+  const kind = value !== null && typeof value === "object" ? value.kind : void 0;
+  if (kind === "theme-fixed" || kind === "theme-token") {
+    return `This property is structural. ${structuralThemeValueHint}`;
+  }
+  const received = value === null ? "null" : Array.isArray(value) ? "an array" : typeof value;
+  return `Invalid input: no accepted form takes ${received === "object" ? "this object" : received}`;
+}
+function valueAtPath(input, path) {
+  let value = input;
+  for (const key of path) {
+    if (value === null || typeof value !== "object" || !Object.hasOwn(value, key)) return void 0;
+    value = value[key];
+  }
+  return value;
+}
 function validationMessagesFromIssues(issues) {
   return issues.flatMap((issue) => {
     const basePath = issue.path.join(".");
@@ -13650,6 +14344,74 @@ function findUnsafeObjectStructure(input) {
   return void 0;
 }
 
+// src/route-inks.ts
+var tileflowRouteMetadataKey = "tileflow:route";
+var tileflowRouteTokens = Object.freeze({
+  color: Object.freeze({
+    line: "route.line",
+    casing: "route.casing",
+    core: "route.core",
+    glow: "route.glow",
+    alternative: "route.alternative"
+  }),
+  number: Object.freeze({
+    glowOpacity: "route.glow.opacity",
+    coreOpacity: "route.core.opacity"
+  })
+});
+var tileflowDefaultRouteInks = Object.freeze({
+  light: Object.freeze({
+    line: "#2563eb",
+    casing: "#1e3a8a",
+    core: "#dbeafe",
+    glow: "#2563eb",
+    alternative: "#94a3b8",
+    glowOpacity: 0.16,
+    coreOpacity: 0
+  }),
+  dark: Object.freeze({
+    line: "#60a5fa",
+    casing: "#0b1220",
+    core: "#eff6ff",
+    glow: "#60a5fa",
+    alternative: "#64748b",
+    glowOpacity: 0.4,
+    coreOpacity: 0.7
+  })
+});
+var colourKeys = Object.keys(
+  tileflowRouteTokens.color
+);
+var numberKeys = Object.keys(
+  tileflowRouteTokens.number
+);
+function resolveTileflowRouteInks(theme) {
+  const defaults4 = tileflowDefaultRouteInks[theme.colorScheme];
+  const inks = { ...defaults4 };
+  for (const key of colourKeys) {
+    const value = theme.tokens.color[tileflowRouteTokens.color[key]];
+    if (value !== void 0) inks[key] = value;
+  }
+  for (const key of numberKeys) {
+    const token2 = tileflowRouteTokens.number[key];
+    const value = theme.tokens.number[token2];
+    if (value === void 0) continue;
+    if (!(value >= 0 && value <= 1)) {
+      throw new Error(
+        `Tileflow theme "${theme.id}" sets number token "${token2}" to ${value}; route opacities run from 0 to 1.`
+      );
+    }
+    inks[key] = value;
+  }
+  return Object.freeze(inks);
+}
+function tileflowRouteMetadata(inks) {
+  return Object.freeze({ version: 1, ...inks });
+}
+
+// src/cartography/streets.ts
+init_sun();
+
 // src/terrain/index.ts
 function resolveTerrain(terrain, apiBaseUrl) {
   if (!terrain || terrain === "none") return void 0;
@@ -13935,18 +14697,18 @@ function cloneJson22(value) {
 
 // src/icon-appearance.ts
 import { Color as Color4 } from "@maplibre/maplibre-gl-style-spec";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/icon-layout.ts
-import { z as z7 } from "zod";
-var coordinate = z7.number().int().nonnegative().max(2048);
-var regions = z7.array(z7.tuple([coordinate, coordinate])).min(1).max(2048);
+import { z as z8 } from "zod";
+var coordinate = z8.number().int().nonnegative().max(2048);
+var regions = z8.array(z8.tuple([coordinate, coordinate])).min(1).max(2048);
 var tileflowIconLayoutFields = {
   stretchX: regions.optional(),
   stretchY: regions.optional(),
-  content: z7.tuple([coordinate, coordinate, coordinate, coordinate]).optional()
+  content: z8.tuple([coordinate, coordinate, coordinate, coordinate]).optional()
 };
-var tileflowIconLayoutSchema = z7.object(tileflowIconLayoutFields).strict().superRefine((layout, context) => {
+var tileflowIconLayoutSchema = z8.object(tileflowIconLayoutFields).strict().superRefine((layout, context) => {
   if (!Object.values(layout).some((value) => value !== void 0))
     context.addIssue({
       code: "custom",
@@ -14008,14 +14770,14 @@ function scaleTileflowIconLayout(layout, scale) {
 }
 
 // src/icon-appearance.ts
-var color2 = z8.string().max(128).refine((value) => Color4.parse(value) !== void 0, "Expected a MapLibre color");
-var tileflowIconAppearanceSchema = z8.object({
-  representation: z8.literal("sdf"),
-  defaults: z8.object({
+var color2 = z9.string().max(128).refine((value) => Color4.parse(value) !== void 0, "Expected a MapLibre color");
+var tileflowIconAppearanceSchema = z9.object({
+  representation: z9.literal("sdf"),
+  defaults: z9.object({
     color: color2,
     haloColor: color2,
-    haloWidth: z8.number().finite().min(0).max(2),
-    haloBlur: z8.number().finite().min(0).max(1)
+    haloWidth: z9.number().finite().min(0).max(2),
+    haloBlur: z9.number().finite().min(0).max(1)
   }).strict()
 }).strict();
 function assertTileflowSdfPixels(input) {
@@ -14039,18 +14801,18 @@ function assertTileflowSdfPixels(input) {
     throw new Error("SDF pixels require an interior and a distance transition.");
 }
 var tileflowIconMetadataFileName = "tileflow.icons.json";
-var tileflowIconAuthorMetadataSchema = z8.object({
-  schemaVersion: z8.literal(1),
-  icons: z8.record(
-    z8.string().max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u),
-    z8.union([
-      z8.object({ representation: z8.literal("rgba"), layout: tileflowIconLayoutSchema.optional() }).strict(),
+var tileflowIconAuthorMetadataSchema = z9.object({
+  schemaVersion: z9.literal(1),
+  icons: z9.record(
+    z9.string().max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u),
+    z9.union([
+      z9.object({ representation: z9.literal("rgba"), layout: tileflowIconLayoutSchema.optional() }).strict(),
       tileflowIconAppearanceSchema.extend({
         layout: tileflowIconLayoutSchema.optional(),
         defaults: tileflowIconAppearanceSchema.shape.defaults.extend({
           haloColor: color2.default("transparent"),
-          haloWidth: z8.number().finite().min(0).max(2).default(0),
-          haloBlur: z8.number().finite().min(0).max(1).default(0)
+          haloWidth: z9.number().finite().min(0).max(2).default(0),
+          haloBlur: z9.number().finite().min(0).max(1).default(0)
         })
       })
     ])
@@ -14335,11 +15097,11 @@ function isTileflowPoiCategory(value) {
   return typeof value === "string" && tileflowPoiCategories.includes(value);
 }
 function semanticTarget(layer) {
-  if (!isRecord7(layer.metadata)) return void 0;
+  if (!isRecord8(layer.metadata)) return void 0;
   const value = layer.metadata[tileflowCompilerMetadataKeys.target];
   return typeof value === "string" ? value : void 0;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSafeArtifactName(value) {
@@ -14349,6 +15111,47 @@ function isSafeArtifactName(value) {
   });
 }
 
+// src/cartography/layout-zoom-diagnostics.ts
+function diagnoseFractionalLayoutZoomSteps(layers) {
+  const diagnostics = [];
+  for (const layer of layers) {
+    const layout = layer.layout;
+    if (layout === null || typeof layout !== "object") continue;
+    for (const [property, value] of Object.entries(layout)) {
+      const stops = fractionalZoomSteps(value);
+      if (stops.length === 0) continue;
+      const [origin] = readTileflowCompilerProvenance(layer);
+      const listed = stops.map((stop) => String(stop)).join(", ");
+      diagnostics.push({
+        code: "TF_LAYOUT_FRACTIONAL_ZOOM_STEP",
+        ...origin ? { domain: origin.owner } : {},
+        message: `${property} steps at zoom ${listed}; layout properties are evaluated at each tile's integer zoom, so the step takes effect at zoom ${stops.map(Math.ceil).join(", ")}.`,
+        path: `layers.${String(layer.id)}.layout.${property}`,
+        phase: "lowering",
+        severity: "warning",
+        suggestion: "Step at whole zooms, or move the change to a paint property or a zoom range.",
+        ...origin ? { target: origin.target } : {}
+      });
+    }
+  }
+  return diagnostics;
+}
+function fractionalZoomSteps(value) {
+  if (!Array.isArray(value)) return [];
+  const stops = [];
+  if (value[0] === "step" && isZoom(value[1])) {
+    for (let index = 3; index < value.length; index += 2) {
+      const stop = value[index];
+      if (typeof stop === "number" && !Number.isInteger(stop)) stops.push(stop);
+    }
+  }
+  for (const entry of value) stops.push(...fractionalZoomSteps(entry));
+  return stops;
+}
+function isZoom(value) {
+  return Array.isArray(value) && value.length === 1 && value[0] === "zoom";
+}
+
 // src/cartography/overlay-placement-manifest.ts
 var tileflowOverlayPlacementManifestMetadataKey = "tileflow:overlay-placement-manifest";
 var tileflowOverlayPlacementManifestSchemaVersion = 1;
@@ -15343,7 +16146,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     () => compileSemanticDomains(modules, context)
   );
   const renderStackModules = Object.values(modules).filter(
-    (module) => isRecord8(module) && module.enabled !== false && "renderStack" in module && isRecord8(module.renderStack)
+    (module) => isRecord9(module) && module.enabled !== false && "renderStack" in module && isRecord9(module.renderStack)
   );
   const renderOperations = runCompilationPhase(
     "render-stack",
@@ -15573,13 +16376,15 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       ...atmosphere ? { [tileflowAtmosphereMetadataKey]: { version: 1, ...atmosphere } } : {},
       "tileflow:theme": selected.name,
       "tileflow:colorScheme": resolvedTheme.colorScheme,
+      [tileflowRouteMetadataKey]: tileflowRouteMetadata(resolveTileflowRouteInks(resolvedTheme)),
+      ...resolvedTheme.sun ? { [tileflowSunMetadataKey]: tileflowSunMetadata(resolvedTheme.sun) } : {},
       "tileflow:data": data.identity,
       "tileflow:sources": sourceIdentities,
       ...Object.keys(loweredOverlays.identities).length > 0 ? { "tileflow:overlays": loweredOverlays.identities } : {},
       "tileflow:sourceRequirements": sourceRequirements,
       ...interactionManifest ? { [tileflowInteractionManifestMetadataKey]: interactionManifest } : {},
       [tileflowOverlayPlacementManifestMetadataKey]: overlayPlacementManifest,
-      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord8(module) || module.enabled !== false).map(([name]) => name).sort(),
+      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord9(module) || module.enabled !== false).map(([name]) => name).sort(),
       ...config.view ? { "tileflow:view": config.view } : {}
     }
   };
@@ -15599,7 +16404,16 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   runCompilationPhase("assets", () => assertTextAssets(style, config));
   runCompilationPhase("assets", () => assertGlyphFontStacks(style, config));
   runCompilationPhase("validation", () => assertMapLibreStyle(style, config.id));
-  return { diagnostics, report, style, ...inspection ? { inspection } : {} };
+  const layoutDiagnostics = runCompilationPhase(
+    "validation",
+    () => diagnoseFractionalLayoutZoomSteps(plannedLayers)
+  );
+  return {
+    diagnostics: [...diagnostics, ...layoutDiagnostics],
+    report,
+    style,
+    ...inspection ? { inspection } : {}
+  };
 }
 function finalizeTileflowLayers(input) {
   const ids = /* @__PURE__ */ new Set();
@@ -15622,7 +16436,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 = isRecord8(layer.metadata) ? { ...layer.metadata } : void 0;
+    const metadata = isRecord9(layer.metadata) ? { ...layer.metadata } : void 0;
     if (metadata) {
       const owner = metadata[tileflowCompilerMetadataKeys.owner];
       delete metadata[tileflowCompilerProvenanceMetadataKey];
@@ -15656,7 +16470,7 @@ function assertMapLibreStyle(style, mapId) {
     }
   );
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function resolveGlyphs(config) {
@@ -15677,8 +16491,8 @@ function assertPreparedIconReferences(style, config, prepared) {
 function collectStyleImageReferences(style) {
   const result = /* @__PURE__ */ new Set();
   for (const layer of style.layers) {
-    const layout = isRecord8(layer.layout) ? layer.layout : {};
-    const paint = isRecord8(layer.paint) ? layer.paint : {};
+    const layout = isRecord9(layer.layout) ? layer.layout : {};
+    const paint = isRecord9(layer.paint) ? layer.paint : {};
     const layerId = typeof layer.id === "string" ? layer.id : "<unknown>";
     for (const [property, value] of [
       ["icon-image", layout["icon-image"]],
@@ -15767,7 +16581,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 = isRecord8(layer.layout) ? layer.layout : void 0;
+    const layout = isRecord9(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(",");
@@ -15783,7 +16597,7 @@ function assertGlyphFontStacks(style, config) {
 function assertTextAssets(style, config) {
   const textLayers = [];
   for (const layer of style.layers) {
-    const layout = isRecord8(layer.layout) ? layer.layout : void 0;
+    const layout = isRecord9(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"];
@@ -15796,7 +16610,7 @@ function assertTextAssets(style, config) {
   if (textLayers.length === 0) return;
   if (config.fonts !== void 0) {
     const backed = style.layers.find((layer) => {
-      const font = isRecord8(layer.layout) ? layer.layout["text-font"] : void 0;
+      const font = isRecord9(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) {
@@ -15822,7 +16636,7 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record2 = isRecord8(error) ? error : {};
+  const record2 = isRecord9(error) ? error : {};
   if (typeof record2.phase === "string") return error;
   if (error instanceof Error && Object.isExtensible(error)) {
     Object.defineProperty(error, "phase", { configurable: true, enumerable: true, value: phase });
@@ -15924,6 +16738,7 @@ var tileflowMapMergeStrategies = {
   overlays: "keyed-resources",
   projection: "atomic",
   scenes: "leaf",
+  shots: "leaf",
   sources: "keyed-resources",
   systemThemes: "atomic",
   terrain: "atomic",
@@ -16263,11 +17078,11 @@ function cloneDesign(value) {
 function describeMap(value) {
   return typeof value.id === "string" && value.id ? value.id : "<anonymous>";
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord4(value) {
-  if (!isRecord9(value)) return false;
+  if (!isRecord10(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -16334,6 +17149,7 @@ function parseTileflowMap(map) {
   for (const node2 of lineage.reverse()) {
     const resolved = node2 === map ? resolvedLeaf : resolveMap(node2);
     validateMapScenes(node2, resolved.id);
+    validateMapShots(node2, resolved.id);
     const parsed = parseResolvedTileflowMap(resolved);
     if (node2 === map) parsedLeaf = parsed;
   }
@@ -16341,40 +17157,53 @@ function parseTileflowMap(map) {
   return parsedLeaf;
 }
 function validateMapScenes(map, mapId) {
-  if (map.scenes === void 0) return;
-  if (!isPlainRecord5(map.scenes)) {
-    throw new Error(`Invalid Tileflow map "${map.id}". scenes: Expected a plain object.`);
+  validateMapCaptureEntries(map, mapId, "scenes", (input) => {
+    const result = tileflowCaptureSceneSchema.safeParse(input);
+    return result.success ? tileflowCaptureSceneFitIssue(result.data) : result.error.issues[0];
+  });
+}
+function validateMapShots(map, mapId) {
+  validateMapCaptureEntries(map, mapId, "shots", (input) => {
+    const result = tileflowCaptureShotSchema.safeParse(input);
+    return result.success ? void 0 : result.error.issues[0];
+  });
+}
+function validateMapCaptureEntries(map, mapId, key, findIssue) {
+  const entries = map[key];
+  if (entries === void 0) return;
+  if (!isPlainRecord5(entries)) {
+    throw new Error(`Invalid Tileflow map "${map.id}". ${key}: Expected a plain object.`);
   }
+  const label = key === "scenes" ? "scene" : "shot";
   const namesByCaseFold = /* @__PURE__ */ new Map();
-  for (const [sceneName, input] of Object.entries(map.scenes)) {
-    const nameResult = tileflowCaptureSceneNameSchema.safeParse(sceneName);
+  for (const [name, input] of Object.entries(entries)) {
+    const nameResult = tileflowCaptureSceneNameSchema.safeParse(name);
     if (!nameResult.success) {
       throw new Error(
-        `Invalid Tileflow map "${map.id}". scenes.${sceneName}: ${nameResult.error.issues[0]?.message ?? "Invalid scene name"}`
+        `Invalid Tileflow map "${map.id}". ${key}.${name}: ${nameResult.error.issues[0]?.message ?? `Invalid ${label} name`}`
       );
     }
-    const normalizedSceneName = nameResult.data;
-    const folded = normalizedSceneName.toLowerCase();
+    const normalizedName = nameResult.data;
+    const folded = normalizedName.toLowerCase();
     const existing = namesByCaseFold.get(folded);
     if (existing) {
       throw new Error(
-        `Invalid Tileflow map "${map.id}". scenes.${sceneName}: Expected an id that does not normalize to "${existing}".`
+        `Invalid Tileflow map "${map.id}". ${key}.${name}: Expected an id that does not normalize to "${existing}".`
       );
     }
-    namesByCaseFold.set(folded, normalizedSceneName);
+    namesByCaseFold.set(folded, normalizedName);
     if (!isPlainRecord5(input)) {
-      throw new Error(`Invalid Tileflow map "${map.id}". scenes.${sceneName}: Expected an object.`);
+      throw new Error(`Invalid Tileflow map "${map.id}". ${key}.${name}: Expected an object.`);
     }
     if (Object.hasOwn(input, "map")) {
       throw new Error(
-        `Invalid Tileflow map "${map.id}". scenes.${sceneName}.map: Unrecognized key; a singular map scene inherits its map id.`
+        `Invalid Tileflow map "${map.id}". ${key}.${name}.map: Unrecognized key; a singular map ${label} inherits its map id.`
       );
     }
-    const result = tileflowCaptureSceneSchema.safeParse({ ...input, map: mapId });
-    const issue = result.success ? tileflowCaptureSceneFitIssue(result.data) : result.error.issues[0];
-    if (!result.success || issue) {
+    const issue = findIssue({ ...input, map: mapId });
+    if (issue) {
       throw new Error(
-        `Invalid Tileflow map "${map.id}". scenes.${sceneName}${issue?.path.length ? `.${issue.path.join(".")}` : ""}: ${issue?.message ?? "Invalid scene"}`
+        `Invalid Tileflow map "${map.id}". ${key}.${name}${issue.path.length ? `.${issue.path.join(".")}` : ""}: ${issue.message}`
       );
     }
   }
@@ -16997,7 +17826,7 @@ function resolveSemanticDiffInput(input) {
 }
 function isAuthoringOnlyMapShape(input) {
   if (!isUnknownRecord(input)) return true;
-  if (!Object.hasOwn(input, "name") || Object.hasOwn(input, "extends") || Object.hasOwn(input, "scenes")) {
+  if (!Object.hasOwn(input, "name") || Object.hasOwn(input, "extends") || Object.hasOwn(input, "scenes") || Object.hasOwn(input, "shots")) {
     return true;
   }
   if (!isUnknownRecord(input.modules)) return false;
@@ -17011,7 +17840,7 @@ function semanticDesign(map) {
 }
 function compareValues(before, after, path, output) {
   if (Object.is(before, after)) return;
-  if (isRecord10(before) && isRecord10(after)) {
+  if (isRecord11(before) && isRecord11(after)) {
     const keys = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort(
       compareCodeUnits9
     );
@@ -17053,7 +17882,7 @@ function toSemanticValue(value, path) {
   }
   throw new TypeError(`Tileflow semantic value at ${path || "/"} is not JSON-serializable.`);
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function isUnknownRecord(value) {
@@ -17066,7 +17895,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 (!isRecord10(left) || !isRecord10(right)) return false;
+  if (!isRecord11(left) || !isRecord11(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]));
@@ -17163,8 +17992,11 @@ function asRecord7(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
+// src/index.ts
+init_sun();
+
 // src/icon-package.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var tileflowIconPackageFileNames = [
   "sprite.json",
   "sprite.png",
@@ -17189,19 +18021,19 @@ var tileflowHostedAlphaCompatibility = {
   },
   maxMapsPerDeploy: 20
 };
-var sha256Schema = z9.string().regex(/^[a-f0-9]{64}$/);
+var sha256Schema = z10.string().regex(/^[a-f0-9]{64}$/);
 var tileflowIconPackageContentHashSchema = sha256Schema;
-var tileflowIconIdSchema = z9.string().max(64).regex(tileflowIconIdPattern);
-var tileflowRenderedIconManifestEntrySchema = z9.object({
+var tileflowIconIdSchema = z10.string().max(64).regex(tileflowIconIdPattern);
+var tileflowRenderedIconManifestEntrySchema = z10.object({
   name: tileflowIconIdSchema,
   appearance: tileflowIconAppearanceSchema.optional(),
   layout: tileflowIconLayoutSchema.optional(),
-  pixelSha256: z9.object({
+  pixelSha256: z10.object({
     oneX: sha256Schema,
     twoX: sha256Schema
   }).strict()
 }).strict();
-var tileflowIconPackageLabelSchema = z9.string().superRefine((value, context) => {
+var tileflowIconPackageLabelSchema = z10.string().superRefine((value, context) => {
   if (value !== value.trim() || value.length === 0) {
     context.addIssue({
       code: "custom",
@@ -17221,32 +18053,32 @@ var tileflowIconPackageLabelSchema = z9.string().superRefine((value, context) =>
     });
   }
 });
-var spriteDimensionsSchema = z9.object({
-  height: z9.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
-  pixelRatio: z9.union([z9.literal(1), z9.literal(2)]),
-  width: z9.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension)
+var spriteDimensionsSchema = z10.object({
+  height: z10.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
+  pixelRatio: z10.union([z10.literal(1), z10.literal(2)]),
+  width: z10.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension)
 }).strict();
 function iconPackageFileSchema(name, contentType) {
-  return z9.object({
-    byteLength: z9.number().int().nonnegative().max(tileflowIconPackageLimits.maxGeneratedFileBytes),
-    contentType: z9.literal(contentType),
-    name: z9.literal(name),
+  return z10.object({
+    byteLength: z10.number().int().nonnegative().max(tileflowIconPackageLimits.maxGeneratedFileBytes),
+    contentType: z10.literal(contentType),
+    name: z10.literal(name),
     sha256: sha256Schema
   }).strict();
 }
-var tileflowIconPackageManifestSchema = z9.object({
-  files: z9.tuple([
+var tileflowIconPackageManifestSchema = z10.object({
+  files: z10.tuple([
     iconPackageFileSchema("sprite.json", "application/json"),
     iconPackageFileSchema("sprite.png", "image/png"),
     iconPackageFileSchema("sprite@2x.json", "application/json"),
     iconPackageFileSchema("sprite@2x.png", "image/png")
   ]),
-  format: z9.enum(["tileflow-icon-package-v1", "tileflow-icon-package-v2"]),
-  iconNames: z9.array(tileflowIconIdSchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
-  renderedIcons: z9.array(tileflowRenderedIconManifestEntrySchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
-  sprites: z9.object({
-    oneX: spriteDimensionsSchema.extend({ pixelRatio: z9.literal(1) }),
-    twoX: spriteDimensionsSchema.extend({ pixelRatio: z9.literal(2) })
+  format: z10.enum(["tileflow-icon-package-v1", "tileflow-icon-package-v2"]),
+  iconNames: z10.array(tileflowIconIdSchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
+  renderedIcons: z10.array(tileflowRenderedIconManifestEntrySchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
+  sprites: z10.object({
+    oneX: spriteDimensionsSchema.extend({ pixelRatio: z10.literal(1) }),
+    twoX: spriteDimensionsSchema.extend({ pixelRatio: z10.literal(2) })
   }).strict()
 }).strict().superRefine((manifest, context) => {
   if (manifest.renderedIcons.some(
@@ -17381,7 +18213,7 @@ function containsControlCharacter(value) {
 }
 
 // src/font-bundle.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var tileflowFontBundleLimits = {
   maxFaceCount: 16,
   maxFileCount: 32,
@@ -17390,39 +18222,39 @@ var tileflowFontBundleLimits = {
   maxManifestBytes: 64 * 1024,
   maxPackageBytes: 20 * 1024 * 1024
 };
-var sha256Schema2 = z10.string().regex(/^[a-f0-9]{64}$/u);
-var fontFileNameSchema = z10.string().max(512).regex(/^fonts\/[a-z0-9]+(?:-[a-z0-9]+)*-[a-f0-9]{64}\.(?:otf|ttf|woff2)$/u);
-var licenseFileNameSchema = z10.string().max(512).regex(/^fonts\/licenses\/license-[a-f0-9]{64}\.txt$/u);
-var fontFamilySchema = z10.string().min(1).max(100).refine(
+var sha256Schema2 = z11.string().regex(/^[a-f0-9]{64}$/u);
+var fontFileNameSchema = z11.string().max(512).regex(/^fonts\/[a-z0-9]+(?:-[a-z0-9]+)*-[a-f0-9]{64}\.(?:otf|ttf|woff2)$/u);
+var licenseFileNameSchema = z11.string().max(512).regex(/^fonts\/licenses\/license-[a-f0-9]{64}\.txt$/u);
+var fontFamilySchema = z11.string().min(1).max(100).refine(
   (value) => value === value.trim() && !/[\p{Cc}\\]/u.test(value),
   "Font family must be printable, trimmed text"
 );
 var tileflowFontBundleContentHashSchema = sha256Schema2;
-var fontFileSchema = z10.object({
-  byteLength: z10.number().int().positive().max(tileflowFontBundleLimits.maxFontFileBytes),
-  contentType: z10.enum(["font/otf", "font/ttf", "font/woff2"]),
-  kind: z10.literal("font"),
+var fontFileSchema = z11.object({
+  byteLength: z11.number().int().positive().max(tileflowFontBundleLimits.maxFontFileBytes),
+  contentType: z11.enum(["font/otf", "font/ttf", "font/woff2"]),
+  kind: z11.literal("font"),
   name: fontFileNameSchema,
   sha256: sha256Schema2
 }).strict();
-var licenseFileSchema = z10.object({
-  byteLength: z10.number().int().positive().max(tileflowFontBundleLimits.maxLicenseFileBytes),
-  contentType: z10.literal("text/plain; charset=utf-8"),
-  kind: z10.literal("license"),
+var licenseFileSchema = z11.object({
+  byteLength: z11.number().int().positive().max(tileflowFontBundleLimits.maxLicenseFileBytes),
+  contentType: z11.literal("text/plain; charset=utf-8"),
+  kind: z11.literal("license"),
   name: licenseFileNameSchema,
   sha256: sha256Schema2
 }).strict();
-var fontFaceSchema = z10.object({
+var fontFaceSchema = z11.object({
   family: fontFamilySchema,
   file: fontFileNameSchema,
   licenseFile: licenseFileNameSchema,
-  style: z10.enum(["italic", "normal", "oblique"]),
-  weight: z10.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
+  style: z11.enum(["italic", "normal", "oblique"]),
+  weight: z11.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
 }).strict();
-var tileflowFontBundleManifestSchema = z10.object({
-  files: z10.array(z10.discriminatedUnion("kind", [fontFileSchema, licenseFileSchema])).min(2).max(tileflowFontBundleLimits.maxFileCount),
-  fontFaces: z10.array(fontFaceSchema).min(1).max(tileflowFontBundleLimits.maxFaceCount),
-  format: z10.literal("tileflow-font-bundle-v1")
+var tileflowFontBundleManifestSchema = z11.object({
+  files: z11.array(z11.discriminatedUnion("kind", [fontFileSchema, licenseFileSchema])).min(2).max(tileflowFontBundleLimits.maxFileCount),
+  fontFaces: z11.array(fontFaceSchema).min(1).max(tileflowFontBundleLimits.maxFaceCount),
+  format: z11.literal("tileflow-font-bundle-v1")
 }).strict().superRefine((manifest, context) => {
   const sortedFiles = [...manifest.files].sort(
     (left, right) => compareCodeUnits11(left.name, right.name)
@@ -17864,7 +18696,7 @@ async function requestSessionGrant(input) {
       else throw error;
     }
     throwIfSessionGrantAborted(signal);
-    if (response.status === 409 && isRecord11(body) && body.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && body.ok === false && body.retryWithNewSession === true && body.sessionId === input.sessionId) {
+    if (response.status === 409 && isRecord12(body) && body.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && body.ok === false && body.retryWithNewSession === true && body.sessionId === input.sessionId) {
       throw new TileflowSessionRestartError();
     }
     if (!response.ok) {
@@ -17937,7 +18769,7 @@ function sessionGrantAbortReason(signal) {
   return error;
 }
 function parseSessionGrantResponse(value, expectedSessionId) {
-  if (!isRecord11(value) || value.ok !== true || value.sessionId !== expectedSessionId) return null;
+  if (!isRecord12(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") {
@@ -17956,11 +18788,11 @@ function parseSessionGrantResponse(value, expectedSessionId) {
   }
   return value;
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRuntimeRecord(value) {
-  if (!isRecord11(value)) return false;
+  if (!isRecord12(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -18391,7 +19223,7 @@ function getTileflowLocationBaseUrl() {
 }
 
 // src/icon-lock.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/icon-json.ts
 function parseTileflowIconJson(text, maximumBytes) {
@@ -18498,15 +19330,15 @@ function parseTileflowIconJson(text, maximumBytes) {
 // src/icon-lock.ts
 var tileflowIconsLockfileName = "tileflow.icons.lock.json";
 var tileflowIconsLockfileMaximumBytes = 4 * 1024 * 1024;
-var tileflowIconSetPinSchema = z11.object({
+var tileflowIconSetPinSchema = z12.object({
   teamId: tileflowIconSetTeamIdSchema,
   setId: tileflowIconSetIdSchema,
   versionId: tileflowIconSetVersionIdSchema,
-  version: z11.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  version: z12.number().int().positive().max(Number.MAX_SAFE_INTEGER),
   packageId: tileflowIconSetPackageIdSchema,
   contentHash: tileflowIconPackageContentHashSchema,
   manifest: tileflowIconPackageManifestSchema,
-  spriteUrl: z11.string().max(2048)
+  spriteUrl: z12.string().max(2048)
 }).strict().superRefine((pin, context) => {
   try {
     const url = new URL(pin.spriteUrl);
@@ -18521,9 +19353,9 @@ var tileflowIconSetPinSchema = z11.object({
     });
   }
 });
-var tileflowIconsLockfileSchema = z11.object({
-  lockfileVersion: z11.literal(1),
-  sets: z11.record(tileflowIconSetReferenceSchema, tileflowIconSetPinSchema)
+var tileflowIconsLockfileSchema = z12.object({
+  lockfileVersion: z12.literal(1),
+  sets: z12.record(tileflowIconSetReferenceSchema, tileflowIconSetPinSchema)
 }).strict().superRefine((lock, context) => {
   const entries = Object.entries(lock.sets);
   if (entries.length > tileflowIconSourceLimit) {
@@ -18577,59 +19409,59 @@ async function serializeTileflowIconsLockfile(input) {
 }
 
 // src/icon-composition.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var tileflowIconCompositionMaximumBytes = 1024 * 1024;
-var idsSchema = z12.array(tileflowIconIdSchema).max(tileflowIconPackageLimits.maxIconCount).refine(
+var idsSchema = z13.array(tileflowIconIdSchema).max(tileflowIconPackageLimits.maxIconCount).refine(
   (ids) => new Set(ids).size === ids.length && ids.every((id2, index) => index === 0 || compareCodeUnits11(ids[index - 1], id2) < 0),
   "Icon exports must be unique and sorted by code unit"
 );
-var localContributorSchema = z12.object({ kind: z12.literal("local"), iconIds: idsSchema }).strict();
-var packageContributorSchema = z12.object({
-  kind: z12.literal("package"),
-  package: z12.string().max(214).regex(/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u),
+var localContributorSchema = z13.object({ kind: z13.literal("local"), iconIds: idsSchema }).strict();
+var packageContributorSchema = z13.object({
+  kind: z13.literal("package"),
+  package: z13.string().max(214).regex(/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u),
   iconIds: idsSchema
 }).strict();
-var setContributorSchema = z12.object({
-  kind: z12.literal("icon-set"),
+var setContributorSchema = z13.object({
+  kind: z13.literal("icon-set"),
   reference: tileflowIconSetReferenceSchema,
   teamId: tileflowIconSetTeamIdSchema,
   setId: tileflowIconSetIdSchema,
   versionId: tileflowIconSetVersionIdSchema,
-  version: z12.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  version: z13.number().int().positive().max(Number.MAX_SAFE_INTEGER),
   packageId: tileflowIconSetPackageIdSchema,
   contentHash: tileflowIconPackageContentHashSchema,
   iconIds: idsSchema.min(1)
 }).strict();
-var tileflowRenderedIconIdentitySchema = z12.object({
-  kind: z12.literal("rendered-icon"),
+var tileflowRenderedIconIdentitySchema = z13.object({
+  kind: z13.literal("rendered-icon"),
   id: tileflowIconIdSchema,
   appearance: tileflowIconAppearanceSchema.optional(),
   layout: tileflowIconLayoutSchema.optional(),
-  width: z12.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
-  height: z12.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
-  pixelSha256: z12.object({
+  width: z13.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
+  height: z13.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
+  pixelSha256: z13.object({
     oneX: tileflowIconPackageContentHashSchema,
     twoX: tileflowIconPackageContentHashSchema
   }).strict()
 }).strict();
-var tileflowIconCompositionSchema = z12.object({
+var tileflowIconCompositionSchema = z13.object({
   // An explicit map keeps declaration order independent of TypeScript's literal cache.
-  format: z12.enum({
+  format: z13.enum({
     "tileflow-icon-composition-v1": "tileflow-icon-composition-v1",
     "tileflow-icon-composition-v2": "tileflow-icon-composition-v2"
   }),
-  compositionVersion: z12.union([z12.literal(1), z12.literal(2)]),
+  compositionVersion: z13.union([z13.literal(1), z13.literal(2)]),
   packageHash: tileflowIconPackageContentHashSchema,
-  contributors: z12.array(
-    z12.discriminatedUnion("kind", [
+  contributors: z13.array(
+    z13.discriminatedUnion("kind", [
       localContributorSchema,
       packageContributorSchema,
       setContributorSchema
     ])
   ).min(1).max(tileflowIconSourceLimit),
-  winners: z12.array(
+  winners: z13.array(
     tileflowRenderedIconIdentitySchema.omit({ kind: true }).extend({
-      contributor: z12.number().int().min(0).max(tileflowIconSourceLimit - 1)
+      contributor: z13.number().int().min(0).max(tileflowIconSourceLimit - 1)
     })
   ).min(1).max(tileflowIconPackageLimits.maxIconCount)
 }).strict().superRefine((receipt, context) => {
@@ -18714,15 +19546,15 @@ async function hashTileflowIconComposition(input) {
 }
 
 // src/icon-sprite-index.ts
-import { z as z13 } from "zod";
-var tileflowIconSpriteIndexEntrySchema = z13.object({
+import { z as z14 } from "zod";
+var tileflowIconSpriteIndexEntrySchema = z14.object({
   ...tileflowIconLayoutFields,
-  height: z13.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
-  width: z13.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
-  pixelRatio: z13.union([z13.literal(1), z13.literal(2)]),
-  x: z13.number().int().nonnegative().max(tileflowIconPackageLimits.maxAtlasDimension),
-  y: z13.number().int().nonnegative().max(tileflowIconPackageLimits.maxAtlasDimension),
-  sdf: z13.literal(true).optional(),
+  height: z14.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
+  width: z14.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
+  pixelRatio: z14.union([z14.literal(1), z14.literal(2)]),
+  x: z14.number().int().nonnegative().max(tileflowIconPackageLimits.maxAtlasDimension),
+  y: z14.number().int().nonnegative().max(tileflowIconPackageLimits.maxAtlasDimension),
+  sdf: z14.literal(true).optional(),
   tileflow: tileflowIconAppearanceSchema.optional()
 }).strict().refine(
   (entry) => entry.sdf === true === (entry.tileflow !== void 0),
@@ -18738,7 +19570,7 @@ var tileflowIconSpriteIndexEntrySchema = z13.object({
     });
   }
 });
-var tileflowIconSpriteIndexSchema = z13.record(tileflowIconIdSchema, tileflowIconSpriteIndexEntrySchema).refine(
+var tileflowIconSpriteIndexSchema = z14.record(tileflowIconIdSchema, tileflowIconSpriteIndexEntrySchema).refine(
   (index) => Object.keys(index).length > 0 && Object.keys(index).length <= tileflowIconPackageLimits.maxIconCount,
   `A generated sprite index must contain 1 through ${tileflowIconPackageLimits.maxIconCount} icons`
 );
@@ -18806,10 +19638,12 @@ export {
   loadTileflowManifest,
   maplibreOverlay,
   mergeTileflowAnalytics,
+  mixTileflowSunPresets,
   nautical,
   nearestTileflowBlendTheme,
   normalizeTileflowCaptureId,
   normalizeTileflowCaptureScene,
+  normalizeTileflowCaptureShot,
   normalizeTileflowLineBackgroundMetrics,
   normalizeTileflowRuntimeCenter,
   normalizeTileflowStaticImageSize,
@@ -18825,6 +19659,7 @@ export {
   parseTileflowRuntimeManifest,
   poi,
   readTileflowIconLayout,
+  readTileflowSunPreset,
   refine,
   refineRenderTarget,
   remove,
@@ -18840,11 +19675,13 @@ export {
   resolveTileflowIconPreviewPaint,
   resolveTileflowManifestMap,
   resolveTileflowMapMode,
+  resolveTileflowRouteInks,
   resolveTileflowRuntimeStyle,
   resolveTileflowRuntimeTheme,
   resolveTileflowRuntimeThemeBlend,
   resolveTileflowRuntimeView,
   resolveTileflowStaticImageUrl,
+  resolveTileflowSun,
   resolveTileflowTheme,
   roads,
   safeParseTileflowRuntimeManifest,
@@ -18873,11 +19710,21 @@ export {
   tileflowCaptureSceneNameSchema,
   tileflowCaptureSceneSchema,
   tileflowCaptureSceneSchemaVersion,
+  tileflowCaptureShotBlendSchema,
+  tileflowCaptureShotFrameCount,
+  tileflowCaptureShotFrames,
+  tileflowCaptureShotKeyframeSchema,
+  tileflowCaptureShotLimits,
+  tileflowCaptureShotNameSchema,
+  tileflowCaptureShotSchema,
+  tileflowCaptureShotSchemaVersion,
   tileflowCaptureTargetSchema,
   tileflowCaptureViewportSchema,
   tileflowCompilationPhases,
   tileflowCompilationPlannerStages,
   tileflowCompilationReportSchemaVersion,
+  tileflowDefaultRouteInks,
+  tileflowDefaultSunPreset,
   tileflowFontBundleContentHashSchema,
   tileflowFontBundleLimits,
   tileflowFontBundleManifestSchema,
@@ -18935,12 +19782,18 @@ export {
   tileflowRenderedIconIdentitySchema,
   tileflowRenderedIconManifestEntrySchema,
   tileflowRoadClasses,
+  tileflowRouteMetadataKey,
+  tileflowRouteTokens,
   tileflowRuntimeManifestLimits,
   tileflowRuntimeManifestSchema,
   tileflowRuntimeManifestVersion,
   tileflowSemanticDiffSchemaVersion,
   tileflowStyleFontFaceLimits,
   tileflowStyleFontFacesMetadataKey,
+  tileflowStyleSunPreset,
+  tileflowSunDirection,
+  tileflowSunMetadataKey,
+  tileflowSunPosition,
   tileflowThemeBlendLimits,
   tileflowThemeLimits,
   tileflowThemeNameSchema,