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

package/dist/build.js

@@ -850,98 +850,6 @@ function cloneJson(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
-// src/cartography/contributions.ts
-var tileflowLayerSlots = [
-  "background",
-  "land",
-  "terrain",
-  "hydro",
-  "building-areas",
-  "transport-areas",
-  "transport-tunnel-shadow",
-  "transport-tunnel-casing",
-  "transport-tunnel-fill",
-  "transport-pedestrian-areas",
-  "aeroways",
-  "transport-surface-shadow",
-  "transport-surface-casing",
-  "transport-surface-fill",
-  "transport-bridge-shadow",
-  "transport-bridge-casing",
-  "transport-bridge-fill",
-  "transport-symbols",
-  "boundaries",
-  "buildings",
-  "vegetation",
-  "symbols"
-];
-var tileflowLayerBands = [
-  "land",
-  "relief",
-  "water",
-  "roads",
-  "boundaries",
-  "buildings",
-  "vegetation",
-  "labels"
-];
-var bandSlots = {
-  land: ["background", "land"],
-  relief: ["terrain", "terrain"],
-  water: ["hydro", "hydro"],
-  roads: ["transport-areas", "transport-symbols"],
-  boundaries: ["boundaries", "boundaries"],
-  buildings: ["buildings", "buildings"],
-  vegetation: ["vegetation", "vegetation"],
-  labels: ["symbols", "symbols"]
-};
-var tileflowBandPlacements = tileflowLayerBands.flatMap(
-  (band) => [`below-${band}`, `above-${band}`]
-);
-function tileflowBandPlacementSlot(placement) {
-  const [side, band] = splitBandPlacement(placement);
-  return bandSlots[band][side === "below" ? 0 : 1];
-}
-function tileflowBandPlacementIndex(slotRanks, placement) {
-  const [side, band] = splitBandPlacement(placement);
-  const [first, last] = bandSlots[band];
-  const threshold = side === "below" ? tileflowLayerSlots.indexOf(first) : tileflowLayerSlots.indexOf(last) + 1;
-  const index = slotRanks.findIndex((rank) => rank !== void 0 && rank >= threshold);
-  return index < 0 ? slotRanks.length : index;
-}
-function splitBandPlacement(placement) {
-  const separator = placement.indexOf("-");
-  return [
-    placement.slice(0, separator),
-    placement.slice(separator + 1)
-  ];
-}
-var tileflowSemanticTargetPattern = /^[a-z][a-z0-9-]*(?:\.[A-Za-z0-9_-]+)*$/u;
-var tileflowRenderStackOperationNamePattern = /^[a-z][A-Za-z0-9_-]*$/u;
-var tileflowCompilerMetadataKeys = Object.freeze({
-  owner: "tileflow:compiler-owner",
-  slot: "tileflow:compiler-slot",
-  target: "tileflow:compiler-target"
-});
-
-// src/modules/addresses/index.ts
-function addresses(options = {}) {
-  return { type: "addresses", ...cloneJson2(options) };
-}
-function cloneJson2(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
-// src/cartography/context.ts
-function typographyTextStyle(typography) {
-  return {
-    font: typography.font,
-    ...typography.fallbacks ? { fallbacks: typography.fallbacks } : {},
-    ...typography.letterSpacing === void 0 ? {} : { letterSpacing: typography.letterSpacing },
-    ...typography.transform === void 0 ? {} : { transform: typography.transform }
-  };
-}
-
 // src/cartography/layer-style.ts
 import { Color as Color2 } from "@maplibre/maplibre-gl-style-spec";
 
@@ -1169,11 +1077,11 @@ var zoom = {
 };
 function expression(value) {
   validateExpressionArray(value, "expression");
-  return { kind: "expression", value: cloneJson3(value) };
+  return { kind: "expression", value: cloneJson2(value) };
 }
 function toMapLibreStyleValue(value) {
   if (isTileflowExpression(value)) {
-    return cloneJson3(value.value);
+    return cloneJson2(value.value);
   }
   if (isTileflowZoomValue(value)) {
     if (value.interpolation === "step") {
@@ -1181,8 +1089,8 @@ function toMapLibreStyleValue(value) {
       return [
         "step",
         ["zoom"],
-        cloneJson3(firstValue),
-        ...rest.flatMap(([stop, stopValue]) => [stop, cloneJson3(stopValue)])
+        cloneJson2(firstValue),
+        ...rest.flatMap(([stop, stopValue]) => [stop, cloneJson2(stopValue)])
       ];
     }
     const interpolation = value.interpolation === "exponential" ? ["exponential", value.base] : [value.interpolation];
@@ -1190,13 +1098,13 @@ function toMapLibreStyleValue(value) {
       "interpolate",
       interpolation,
       ["zoom"],
-      ...value.stops.flatMap(([stop, stopValue]) => [stop, cloneJson3(stopValue)])
+      ...value.stops.flatMap(([stop, stopValue]) => [stop, cloneJson2(stopValue)])
     ];
   }
   if (isTileflowThemeValueNode(value)) {
     throw new Error("Tileflow theme values must be resolved before MapLibre style compilation.");
   }
-  return cloneJson3(value);
+  return cloneJson2(value);
 }
 function isTileflowExpression(value) {
   return isRecord(value) && value.kind === "expression" && Array.isArray(value.value);
@@ -1233,7 +1141,7 @@ function createZoomValue(interpolation, stops, base) {
       throw new Error("Tileflow zoom stops must be strictly increasing.");
     }
     previous = stop;
-    return [stop, cloneJson3(value)];
+    return [stop, cloneJson2(value)];
   });
   return {
     kind: "zoom",
@@ -1249,9 +1157,9 @@ function validateExpressionArray(value, name) {
   if (!isMapLibreExpressionOperator(value[0])) {
     throw new Error(`Unknown MapLibre expression operator: ${value[0]}`);
   }
-  cloneJson3(value);
+  cloneJson2(value);
 }
-function cloneJson3(value) {
+function cloneJson2(value) {
   const serialized = JSON.stringify(value);
   if (serialized === void 0) {
     throw new Error("Tileflow style values must be JSON-serializable.");
@@ -1571,30 +1479,30 @@ function asRecord(value) {
 
 // src/cartography/merge.ts
 function mergeTileflowDesign(base, ...overlays) {
-  let resolved = cloneJson4(base);
+  let resolved = cloneJson3(base);
   for (const overlay of overlays) {
     resolved = mergeValue(resolved, overlay);
   }
   return resolved;
 }
 function mergeValue(base, overlay) {
-  if (overlay === void 0) return cloneJson4(base);
+  if (overlay === void 0) return cloneJson3(base);
   if (Array.isArray(overlay) || isTileflowExpression(overlay) || isTileflowThemeValueNode(overlay) || isTileflowZoomValue(overlay) || !isRecord2(overlay)) {
-    return cloneJson4(overlay);
+    return cloneJson3(overlay);
   }
   const baseRecord = isRecord2(base) ? base : {};
   const result = {};
   for (const key of /* @__PURE__ */ new Set([...Object.keys(baseRecord), ...Object.keys(overlay)])) {
     const overlayValue = overlay[key];
     if (overlayValue === void 0) {
-      if (key in baseRecord) result[key] = cloneJson4(baseRecord[key]);
+      if (key in baseRecord) result[key] = cloneJson3(baseRecord[key]);
       continue;
     }
     result[key] = mergeValue(baseRecord[key], overlayValue);
   }
   return result;
 }
-function cloneJson4(value) {
+function cloneJson3(value) {
   if (value === void 0) return value;
   return JSON.parse(JSON.stringify(value));
 }
@@ -1602,6 +1510,402 @@ function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
+// src/trees-3d.ts
+var tileflowWorldTreeFields = Object.freeze({
+  height: "height",
+  diameterCrown: "diameter_crown",
+  circumference: "circumference",
+  genus: "genus",
+  species: "species",
+  leafType: "leaf_type",
+  taxon: "taxon",
+  canopyRank: "rank",
+  canopyClearance: "clearance_px_z15",
+  canopyCover: "cover_pct",
+  canopyHeight: "height_m"
+});
+var tileflowDefaultUnknownTreeForms = Object.freeze({
+  round: 1,
+  open: 1,
+  tall: 1
+});
+var broadleaves = Object.freeze({
+  ...Object.fromEntries(
+    [
+      "acacia",
+      "albizia",
+      "arbutus",
+      "bursera",
+      "ceratonia",
+      "delonix",
+      "ficus",
+      "gleditsia",
+      "jacaranda",
+      "olea",
+      "quercus",
+      "robinia",
+      "schinus",
+      "sophora",
+      "styphnolobium",
+      "tamarix"
+    ].map((genus) => [genus, "open"])
+  ),
+  ...Object.fromEntries(
+    [
+      "betula",
+      "celtis",
+      "fraxinus",
+      "ginkgo",
+      "liquidambar",
+      "liriodendron",
+      "magnolia",
+      "platanus",
+      "populus",
+      "pyrus",
+      "ulmus",
+      "zelkova"
+    ].map((genus) => [genus, "tall"])
+  ),
+  ...Object.fromEntries(
+    [
+      "acer",
+      "aesculus",
+      "carpinus",
+      "castanea",
+      "catalpa",
+      "cercis",
+      "citrus",
+      "fagus",
+      "lagerstroemia",
+      "malus",
+      "melia",
+      "morus",
+      "prunus",
+      "sorbus",
+      "tilia"
+    ].map((genus) => [genus, "round"])
+  )
+});
+var tileflowTreeModelIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var tileflowVegetationMetadataKey = "tileflow:vegetation";
+function tileflowVegetationMetadata(vegetation2) {
+  return { version: 1, ...vegetation2 };
+}
+
+// src/modules/vegetation/compiler.ts
+function compileVegetation(request, context) {
+  const minZoom = request?.flat?.minZoom ?? 16;
+  const mode = request?.mode ?? "3d";
+  const config = mergeTileflowDesign(
+    {
+      type: "vegetation",
+      enabled: true,
+      flat: {
+        color: context.colors.landcover.wood,
+        minZoom,
+        opacity: mode === "3d" ? 0.82 : 0.9,
+        pitchAlignment: "map",
+        pitchScale: "map",
+        radius: minZoom < 24 ? zoom.linear([
+          [minZoom, 2.2],
+          [minZoom < 20 ? 20 : 24, 8]
+        ]) : 2.2,
+        strokeColor: context.colors.park,
+        strokeOpacity: 0.55,
+        strokeWidth: 0.8
+      },
+      mode,
+      threeDimensional: {
+        barkColor: context.colors.vegetation.tree.bark,
+        broadleafColors: context.colors.vegetation.tree.broadleaf,
+        coniferColors: context.colors.vegetation.tree.conifer,
+        palmColors: context.colors.vegetation.tree.palm,
+        crownScale: 1,
+        heightScale: 1
+      }
+    },
+    request
+  );
+  if (config.enabled === false || !context.data.schema.layers.tree) return [];
+  const resolvedMode = config.mode ?? "3d";
+  return [
+    {
+      kind: "layer",
+      layer: applyCircleStyle(
+        {
+          id: "tileflow-vegetation-trees",
+          type: "circle",
+          source: context.data.sourceId,
+          "source-layer": context.data.schema.layers.tree,
+          // The layer also holds rows of trees as lines; a circle on each vertex would misdraw them.
+          filter: ["==", ["geometry-type"], "Point"],
+          metadata: {
+            "tileflow:vegetation-mode": resolvedMode,
+            ...resolvedMode === "3d" ? { "tileflow:vegetation-fallback": "flat-circle" } : {}
+          }
+        },
+        config.flat ?? {}
+      ),
+      localOrder: 1,
+      owner: "vegetation",
+      slot: "vegetation",
+      target: "vegetation.trees"
+    }
+  ];
+}
+function tileflowVegetationDescription(request, context) {
+  const { schema } = context.data;
+  if (request?.enabled === false || (request?.mode ?? "3d") !== "3d" || !schema.layers.tree)
+    return void 0;
+  const tree = context.colors.vegetation.tree;
+  const style = request?.threeDimensional ?? {};
+  const colours = (value, fallback) => Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string") ? value : [...fallback];
+  const number = (value) => {
+    const resolved = value === void 0 ? void 0 : toMapLibreStyleValue(value);
+    return typeof resolved === "number" && resolved > 0 ? resolved : 1;
+  };
+  const field2 = (name, fallback) => schema.fields[name] ?? fallback;
+  return {
+    source: context.data.sourceId,
+    layers: {
+      tree: schema.layers.tree,
+      ...schema.layers.canopy ? { canopy: schema.layers.canopy } : {}
+    },
+    fields: {
+      ...tileflowWorldTreeFields,
+      height: field2("height", tileflowWorldTreeFields.height),
+      diameterCrown: field2("diameterCrown", tileflowWorldTreeFields.diameterCrown),
+      genus: field2("genus", tileflowWorldTreeFields.genus),
+      species: field2("species", tileflowWorldTreeFields.species),
+      leafType: field2("leafType", tileflowWorldTreeFields.leafType),
+      canopyRank: field2("canopyRank", tileflowWorldTreeFields.canopyRank),
+      canopyClearance: field2("canopyClearanceAtZoom15", tileflowWorldTreeFields.canopyClearance),
+      canopyCover: field2("canopyCoverPercent", tileflowWorldTreeFields.canopyCover)
+    },
+    colors: {
+      bark: typeof style.barkColor === "string" ? style.barkColor : tree.bark,
+      broadleaf: colours(style.broadleafColors, tree.broadleaf),
+      conifer: colours(style.coniferColors, tree.conifer),
+      palm: colours(style.palmColors, tree.palm)
+    },
+    heightScale: number(style.heightScale),
+    crownScale: number(style.crownScale),
+    forms: Object.fromEntries(
+      Object.entries(style.forms ?? {}).map(([form, own]) => [
+        form,
+        {
+          heightScale: number(own?.heightScale),
+          crownScale: number(own?.crownScale),
+          ...own?.models?.length ? { models: [...own.models] } : {}
+        }
+      ])
+    ),
+    // Filled by the compiler from the map's prepared models.
+    models: {},
+    finish: style.finish ?? "faceted",
+    edges: (() => {
+      const edges = toMapLibreStyleValue(style.edges ?? 0);
+      return typeof edges === "number" ? edges : 0;
+    })(),
+    ...(() => {
+      const edgeColor = style.edgeColor === void 0 ? void 0 : toMapLibreStyleValue(style.edgeColor);
+      return typeof edgeColor === "string" ? { edgeColor } : {};
+    })(),
+    unknownForms: style.unknownForms ?? tileflowDefaultUnknownTreeForms,
+    regions: style.regions ?? [],
+    // Filled by the compiler once the style's layers are final.
+    flatLayers: []
+  };
+}
+
+// src/buildings-3d-design.ts
+var tileflowBuildingsMetadataKey = "tileflow:buildings";
+var tileflowDefaultBuildings3DDesign = Object.freeze({
+  source: "tileflow",
+  layers: Object.freeze({ building: "building", places: "poi" }),
+  color: "#d8d0c0",
+  edges: 1,
+  nightLight: 1,
+  windows: false,
+  shadows: true,
+  occlusion: true
+});
+function tileflowBuildingsMetadata(design) {
+  return { version: 1, ...design };
+}
+
+// src/street-lights.ts
+var tileflowStreetLightsMetadataKey = "tileflow:street-lights";
+var tileflowDefaultStreetLightsDesign = Object.freeze({
+  source: "tileflow",
+  layers: Object.freeze({
+    streetFurniture: "street_furniture",
+    transportation: "transportation",
+    sidewalk: "sidewalk"
+  }),
+  estimate: "lit",
+  color: "#ffcf8f",
+  intensity: 1
+});
+function tileflowStreetLightsMetadata(design) {
+  return { version: 1, ...design };
+}
+
+// src/cartography/scene-3d-metadata.ts
+var colourSources = [
+  ["tileflow-buildings-render-extrusion", "fill-extrusion-color"],
+  ["tileflow-buildings-3d", "fill-extrusion-color"],
+  ["tileflow-buildings-fill", "fill-color"]
+];
+function tileflowBuildings3DDesignOf(module, context, layers) {
+  const config = isRecord3(module) ? module : {};
+  if (config.enabled === false) return void 0;
+  const style = config.threeDimensional ?? {};
+  let color2;
+  for (const [id2, property] of colourSources) {
+    const value = layers.find((layer) => layer.id === id2)?.paint?.[property];
+    if (typeof value === "string" || Array.isArray(value)) {
+      color2 = value;
+      break;
+    }
+  }
+  const number = (value, fallback) => {
+    const resolved = value === void 0 ? void 0 : toMapLibreStyleValue(value);
+    return typeof resolved === "number" ? resolved : fallback;
+  };
+  const edgeColor = style.edgeColor === void 0 ? void 0 : toMapLibreStyleValue(style.edgeColor);
+  return {
+    source: context.data.sourceId,
+    layers: {
+      building: context.data.schema.layers.building,
+      ...context.data.schema.layers.poi ? { places: context.data.schema.layers.poi } : {}
+    },
+    color: color2 ?? context.colors.buildings.generic,
+    edges: number(style.edges, 1),
+    ...typeof edgeColor === "string" ? { edgeColor } : {},
+    nightLight: number(style.nightLight, 1),
+    windows: style.windows === true,
+    shadows: style.shadows !== false,
+    occlusion: style.occlusion !== false
+  };
+}
+function tileflowStreetLightsDesignOf(module, context) {
+  const config = isRecord3(module) ? module : {};
+  const layers = context.data.schema.layers;
+  const style = config.streetLights ?? {};
+  if (config.enabled === false || style.enabled === false || !layers.streetFurniture)
+    return void 0;
+  const color2 = style.color === void 0 ? void 0 : toMapLibreStyleValue(style.color);
+  const intensity = style.intensity === void 0 ? void 0 : toMapLibreStyleValue(style.intensity);
+  const estimate = style.estimate;
+  return {
+    source: context.data.sourceId,
+    layers: {
+      streetFurniture: layers.streetFurniture,
+      transportation: layers.road,
+      ...layers.sidewalk ? { sidewalk: layers.sidewalk } : {}
+    },
+    estimate: estimate === "streets" || estimate === "none" || estimate === "lit" ? estimate : "lit",
+    color: typeof color2 === "string" ? color2 : tileflowDefaultStreetLightsDesign.color,
+    intensity: typeof intensity === "number" ? intensity : 1
+  };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/cartography/contributions.ts
+var tileflowLayerSlots = [
+  "background",
+  "land",
+  "terrain",
+  "hydro",
+  "building-areas",
+  "transport-areas",
+  "transport-tunnel-shadow",
+  "transport-tunnel-casing",
+  "transport-tunnel-fill",
+  "transport-pedestrian-areas",
+  "aeroways",
+  "transport-surface-shadow",
+  "transport-surface-casing",
+  "transport-surface-fill",
+  "transport-bridge-shadow",
+  "transport-bridge-casing",
+  "transport-bridge-fill",
+  "transport-symbols",
+  "boundaries",
+  "buildings",
+  "vegetation",
+  "symbols"
+];
+var tileflowLayerBands = [
+  "land",
+  "relief",
+  "water",
+  "roads",
+  "boundaries",
+  "buildings",
+  "vegetation",
+  "labels"
+];
+var bandSlots = {
+  land: ["background", "land"],
+  relief: ["terrain", "terrain"],
+  water: ["hydro", "hydro"],
+  roads: ["transport-areas", "transport-symbols"],
+  boundaries: ["boundaries", "boundaries"],
+  buildings: ["buildings", "buildings"],
+  vegetation: ["vegetation", "vegetation"],
+  labels: ["symbols", "symbols"]
+};
+var tileflowBandPlacements = tileflowLayerBands.flatMap(
+  (band) => [`below-${band}`, `above-${band}`]
+);
+function tileflowBandPlacementSlot(placement) {
+  const [side, band] = splitBandPlacement(placement);
+  return bandSlots[band][side === "below" ? 0 : 1];
+}
+function tileflowBandPlacementIndex(slotRanks, placement) {
+  const [side, band] = splitBandPlacement(placement);
+  const [first, last] = bandSlots[band];
+  const threshold = side === "below" ? tileflowLayerSlots.indexOf(first) : tileflowLayerSlots.indexOf(last) + 1;
+  const index = slotRanks.findIndex((rank) => rank !== void 0 && rank >= threshold);
+  return index < 0 ? slotRanks.length : index;
+}
+function splitBandPlacement(placement) {
+  const separator = placement.indexOf("-");
+  return [
+    placement.slice(0, separator),
+    placement.slice(separator + 1)
+  ];
+}
+var tileflowSemanticTargetPattern = /^[a-z][a-z0-9-]*(?:\.[A-Za-z0-9_-]+)*$/u;
+var tileflowRenderStackOperationNamePattern = /^[a-z][A-Za-z0-9_-]*$/u;
+var tileflowCompilerMetadataKeys = Object.freeze({
+  owner: "tileflow:compiler-owner",
+  slot: "tileflow:compiler-slot",
+  target: "tileflow:compiler-target"
+});
+
+// src/modules/addresses/index.ts
+function addresses(options = {}) {
+  return { type: "addresses", ...cloneJson4(options) };
+}
+function cloneJson4(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/cartography/context.ts
+function typographyTextStyle(typography) {
+  return {
+    font: typography.font,
+    ...typography.fallbacks ? { fallbacks: typography.fallbacks } : {},
+    ...typography.letterSpacing === void 0 ? {} : { letterSpacing: typography.letterSpacing },
+    ...typography.transform === void 0 ? {} : { transform: typography.transform }
+  };
+}
+
 // src/modules/addresses/compiler.ts
 function compileAddresses(request, context) {
   if (request?.enabled === false) return [];
@@ -4211,6 +4515,38 @@ function isTileflowThemeName(value) {
   return isTileflowPortableId(value) && value !== "system";
 }
 
+// src/sun.ts
+var tileflowSunMetadataKey = "tileflow:sun";
+var tileflowDefaultSunPreset = Object.freeze({
+  azimuth: 210,
+  altitude: 60,
+  color: "#ffffff",
+  intensity: 0.5,
+  shadowIntensity: 1,
+  ambient: Object.freeze({ color: "#ffffff", intensity: 0.5 })
+});
+var degrees = Math.PI / 180;
+function normalizeTileflowAzimuth(azimuth) {
+  const turned = azimuth % 360;
+  return turned < 0 ? turned + 360 : turned === 0 ? 0 : turned;
+}
+function tileflowSunMetadata(preset) {
+  return Object.freeze({ version: 1, ...preset });
+}
+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))
+    ]
+  };
+}
+
 // src/themes/visual-semantics.ts
 var visualNumberProperties = /* @__PURE__ */ new Set([
   "angle",
@@ -4369,7 +4705,9 @@ var themeTypographyKeys = [
   "water"
 ];
 var themeTypographyDomains = ["places", "poi", "roads", "water"];
-var themeLightingKeys = ["anchor", "color", "intensity", "position"];
+var themeLightingKeys = ["ambient", "anchor", "color", "intensity", "position", "sun"];
+var themeSunKeys = ["altitude", "azimuth", "color", "intensity", "shadowIntensity"];
+var themeAmbientKeys = ["color", "intensity"];
 function resolveTileflowTheme(theme) {
   assertThemeDocument(theme);
   const resolver = new ThemeValueResolver(theme);
@@ -4380,11 +4718,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
@@ -4428,7 +4767,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,
@@ -4531,7 +4870,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;
@@ -4547,7 +4886,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;
@@ -4862,7 +5201,7 @@ var ThemeValueResolver = class {
     if (Array.isArray(value)) {
       return value.map((entry, index) => this.resolveTree(entry, `${path}[${index}]`, category));
     }
-    if (!isRecord3(value)) return value;
+    if (!isRecord4(value)) return value;
     if (value.kind === "expression" && Array.isArray(value.value)) {
       return {
         ...value,
@@ -4902,6 +5241,65 @@ var ThemeValueResolver = class {
     };
   }
   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);
@@ -5078,6 +5476,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);
   }
@@ -5097,7 +5513,7 @@ function assertThemeLighting(value, path) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -5244,6 +5660,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);
 }
@@ -5448,11 +5865,11 @@ function cloneJson14(value) {
   if (serialized === void 0) throw new Error("Tileflow themes must be JSON-serializable.");
   return JSON.parse(serialized);
 }
-function isRecord3(value) {
+function 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;
 }
@@ -5644,7 +6061,8 @@ function resolveColors(overrides = {}, defaults4 = defaultColors, moduleOverride
           resolved.landcover.grass,
           resolved.landcover.meadow
         ],
-        conifer: [resolved.landcover.protected, resolved.landcover.scrub, resolved.landcover.wood]
+        conifer: [resolved.landcover.protected, resolved.landcover.scrub, resolved.landcover.wood],
+        palm: [resolved.landcover.urbanPark, resolved.landcover.grass, resolved.landcover.meadow]
       }
     }
   };
@@ -5811,6 +6229,11 @@ function resolveThemeColors(theme) {
           optionalColor("vegetation.tree.conifer.a", colors.vegetation.tree.conifer[0]),
           optionalColor("vegetation.tree.conifer.b", colors.vegetation.tree.conifer[1]),
           optionalColor("vegetation.tree.conifer.c", colors.vegetation.tree.conifer[2])
+        ],
+        palm: [
+          optionalColor("vegetation.tree.palm.a", colors.vegetation.tree.palm[0]),
+          optionalColor("vegetation.tree.palm.b", colors.vegetation.tree.palm[1]),
+          optionalColor("vegetation.tree.palm.c", colors.vegetation.tree.palm[2])
         ]
       }
     }
@@ -6217,7 +6640,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) {
@@ -6286,15 +6709,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
@@ -6946,10 +7369,10 @@ function roadWidth(roadClass, scale) {
       [16, 3.4]
     ]
   };
-  return zoom.linear(stops[roadClass].map(([z15, value]) => [z15, value * scale]));
+  return zoom.linear(stops[roadClass].map(([z16, value]) => [z16, value * scale]));
 }
 function widen(value, addition) {
-  return zoom.linear(value.stops.map(([z15, width]) => [z15, width + addition]));
+  return zoom.linear(value.stops.map(([z16, width]) => [z16, width + addition]));
 }
 function structureFilter(field2, structure) {
   if (structure === "surface") {
@@ -7159,76 +7582,6 @@ function cloneJson16(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
-// src/modules/vegetation/compiler.ts
-function compileVegetation(request, context) {
-  const minZoom = request?.flat?.minZoom ?? 16;
-  const mode = request?.mode ?? "3d";
-  const config = mergeTileflowDesign(
-    {
-      type: "vegetation",
-      enabled: true,
-      flat: {
-        color: context.colors.landcover.wood,
-        minZoom,
-        opacity: mode === "3d" ? 0.82 : 0.9,
-        pitchAlignment: "map",
-        pitchScale: "map",
-        radius: minZoom < 24 ? zoom.linear([
-          [minZoom, 2.2],
-          [minZoom < 20 ? 20 : 24, 8]
-        ]) : 2.2,
-        strokeColor: context.colors.park,
-        strokeOpacity: 0.55,
-        strokeWidth: 0.8
-      },
-      mode,
-      threeDimensional: {
-        barkColor: context.colors.vegetation.tree.bark,
-        broadleafColors: context.colors.vegetation.tree.broadleaf,
-        coniferColors: context.colors.vegetation.tree.conifer,
-        crownScale: 1,
-        heightScale: 1
-      }
-    },
-    request
-  );
-  if (config.enabled === false || !context.data.schema.layers.tree) return [];
-  const resolvedMode = config.mode ?? "3d";
-  const threeDimensional = config.threeDimensional;
-  return [
-    {
-      kind: "layer",
-      layer: applyCircleStyle(
-        {
-          id: "tileflow-vegetation-trees",
-          type: "circle",
-          source: context.data.sourceId,
-          "source-layer": context.data.schema.layers.tree,
-          metadata: {
-            "tileflow:vegetation-mode": resolvedMode,
-            ...resolvedMode === "3d" ? { "tileflow:vegetation-fallback": "flat-circle" } : {},
-            "tileflow:tree-bark-color": threeDimensional.barkColor,
-            "tileflow:tree-broadleaf-colors": threeDimensional.broadleafColors,
-            "tileflow:tree-conifer-colors": threeDimensional.coniferColors,
-            "tileflow:tree-crown-field": context.data.schema.fields.diameterCrown,
-            "tileflow:tree-crown-scale": threeDimensional.crownScale,
-            "tileflow:tree-genus-field": context.data.schema.fields.genus,
-            "tileflow:tree-height-field": context.data.schema.fields.height,
-            "tileflow:tree-height-scale": threeDimensional.heightScale,
-            "tileflow:tree-leaf-type-field": context.data.schema.fields.leafType,
-            "tileflow:tree-species-field": context.data.schema.fields.species
-          }
-        },
-        config.flat ?? {}
-      ),
-      localOrder: 1,
-      owner: "vegetation",
-      slot: "vegetation",
-      target: "vegetation.trees"
-    }
-  ];
-}
-
 // src/modules/water/index.ts
 function water(options = {}) {
   return { type: "water", ...cloneJson17(options) };
@@ -8462,24 +8815,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)];
@@ -8673,7 +9041,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);
@@ -8689,7 +9061,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);
@@ -8918,21 +9294,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) {
@@ -9036,8 +9412,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)) } : {}
     })
   });
 }
@@ -9277,21 +9653,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 asRecord3(value) {
-  return isRecord5(value) ? value : {};
+  return isRecord6(value) ? value : {};
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -9343,7 +9719,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",
@@ -9404,7 +9780,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;
           }
@@ -9435,14 +9811,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) {
@@ -9767,7 +10143,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."
@@ -9970,7 +10346,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");
@@ -9997,7 +10373,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.`
@@ -10099,7 +10475,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);
@@ -10246,9 +10622,9 @@ function cloneJson21(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord4(value) {
-  return isRecord6(value) ? value : {};
+  return isRecord7(value) ? value : {};
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -10616,7 +10992,7 @@ 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
       });
     }
@@ -10625,9 +11001,11 @@ function validateExpressionThemeValues(value, expectedCategory, context, path) {
   if (candidate.kind === "theme-fixed") {
     const parsed = expectedCategory === "number" ? z5.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
       });
     }
@@ -10647,6 +11025,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");
@@ -10759,10 +11151,21 @@ var themeTypographySchema = themeTypographyStyleSchema.extend({
   water: themeTypographyStyleSchema.optional()
 });
 var themeLightingSchema = z5.object({
+  ambient: z5.object({
+    color: themeColorValueSchema.optional(),
+    intensity: themeNumberValueSchema.optional()
+  }).strict().optional(),
   anchor: z5.enum(["map", "viewport"]).optional(),
   color: themeColorValueSchema.optional(),
   intensity: themeNumberValueSchema.optional(),
-  position: z5.tuple([themeNumberValueSchema, themeNumberValueSchema, themeNumberValueSchema]).optional()
+  position: z5.tuple([themeNumberValueSchema, themeNumberValueSchema, themeNumberValueSchema]).optional(),
+  sun: z5.object({
+    altitude: themeNumberValueSchema.optional(),
+    azimuth: themeNumberValueSchema.optional(),
+    color: themeColorValueSchema.optional(),
+    intensity: themeNumberValueSchema.optional(),
+    shadowIntensity: themeNumberValueSchema.optional()
+  }).strict().optional()
 }).strict();
 var tileflowThemeSchema = z5.object({
   colorScheme: z5.enum(["light", "dark"]),
@@ -11245,6 +11648,17 @@ var waterModuleSchema = z5.object({
     stream: lineStyleSchema.optional()
   }).strict().optional()
 }).strict();
+function boundedThemeNumberSchema(min, max) {
+  return z5.union([
+    z5.number().finite().min(min).max(max),
+    themeNumberReferenceSchema,
+    z5.object({
+      kind: z5.literal("theme-fixed"),
+      reason: z5.string().trim().min(1),
+      value: z5.number().finite().min(min).max(max)
+    }).strict()
+  ]);
+}
 var buildingsModuleSchema = z5.object({
   type: z5.literal("buildings"),
   businessCorridor: areaStyleSchema.optional(),
@@ -11252,7 +11666,15 @@ var buildingsModuleSchema = z5.object({
   extrusion: extrusionStyleSchema.optional(),
   flat: areaStyleSchema.optional(),
   mode: z5.enum(["3d", "flat"]).optional(),
-  renderStack: renderStackSchema.optional()
+  renderStack: renderStackSchema.optional(),
+  threeDimensional: z5.object({
+    edges: boundedThemeNumberSchema(0, 1).optional(),
+    edgeColor: themeColorValueSchema.optional(),
+    nightLight: boundedThemeNumberSchema(0, 2).optional(),
+    occlusion: z5.boolean().optional(),
+    shadows: z5.boolean().optional(),
+    windows: z5.boolean().optional()
+  }).strict().optional()
 }).strict();
 var addressesModuleSchema = z5.object({
   type: z5.literal("addresses"),
@@ -11365,6 +11787,12 @@ var roadsModuleSchema = z5.object({
     pattern: fillStyleSchema.optional(),
     surface: fillStyleSchema.optional()
   }).strict().optional(),
+  streetLights: z5.object({
+    color: themeColorValueSchema.optional(),
+    enabled: z5.boolean().optional(),
+    estimate: z5.enum(["lit", "streets", "none"]).optional(),
+    intensity: boundedThemeNumberSchema(0, 2).optional()
+  }).strict().optional(),
   structures: roadStructureMapSchema.optional(),
   weight: z5.enum(["thin", "regular", "bold"]).optional(),
   widthScale: z5.partialRecord(roadClassSchema, themeNumberValueSchema).optional()
@@ -11453,6 +11881,16 @@ var nauticalModuleSchema = z5.object({
   wreckAreas: areaStyleSchema.optional(),
   wrecks: markerSymbolStyleSchema.optional()
 }).strict();
+var treeFormMixSchema = z5.object({
+  round: z5.number().finite().min(0).optional(),
+  open: z5.number().finite().min(0).optional(),
+  tall: z5.number().finite().min(0).optional(),
+  conifer: z5.number().finite().min(0).optional(),
+  columnar: z5.number().finite().min(0).optional(),
+  palm: z5.number().finite().min(0).optional()
+}).strict().refine((mix2) => Object.values(mix2).some((weight) => (weight ?? 0) > 0), {
+  message: "Expected at least one tree form with a weight above 0"
+});
 var modulesSchema = z5.object({
   addresses: addressesModuleSchema.optional(),
   aeroways: aerowaysModuleSchema.optional(),
@@ -11475,6 +11913,39 @@ var modulesSchema = z5.object({
       barkColor: themeColorValueSchema.optional(),
       broadleafColors: z5.array(themeColorValueSchema).min(1).max(8).optional(),
       coniferColors: z5.array(themeColorValueSchema).min(1).max(8).optional(),
+      palmColors: z5.array(themeColorValueSchema).min(1).max(8).optional(),
+      finish: z5.enum(["faceted", "smooth", "toon"]).optional(),
+      edges: boundedThemeNumberSchema(0, 1).optional(),
+      edgeColor: themeColorValueSchema.optional(),
+      forms: z5.partialRecord(
+        z5.enum(["round", "open", "tall", "conifer", "columnar", "palm"]),
+        z5.object({
+          crownScale: boundedThemeNumberSchema(0.1, 10).optional(),
+          heightScale: boundedThemeNumberSchema(0.1, 10).optional(),
+          models: z5.array(
+            z5.string().max(64).regex(
+              tileflowTreeModelIdPattern,
+              "Expected a model id: its .glb file name in lowercase letters, digits and hyphens"
+            )
+          ).min(1).max(4).refine((ids) => new Set(ids).size === ids.length, {
+            message: "Expected each model once"
+          }).optional()
+        }).strict()
+      ).optional(),
+      unknownForms: treeFormMixSchema.optional(),
+      regions: z5.array(
+        z5.object({
+          bounds: z5.tuple([
+            z5.number().finite().min(-180).max(180),
+            z5.number().finite().min(-90).max(90),
+            z5.number().finite().min(-180).max(180),
+            z5.number().finite().min(-90).max(90)
+          ]).refine(([, south, , north]) => south <= north, {
+            message: "Expected bounds as [west, south, east, north] with south below north"
+          }),
+          unknownForms: treeFormMixSchema
+        }).strict()
+      ).max(16).optional(),
       crownScale: z5.union([
         z5.number().finite().positive().max(10),
         themeNumberReferenceSchema,
@@ -11807,6 +12278,7 @@ var iconDirectoriesSchema = z5.array(
   }
 });
 var fontDirectoriesSchema = z5.array(assetDirectorySchema).max(16);
+var modelDirectoriesSchema = z5.array(assetDirectorySchema).max(16);
 var fontStacksSchema = z5.array(
   z5.string().min(1).max(200).refine(
     (value) => value === value.trim() && value === value.normalize("NFC") && !/[\p{Cc}\\/]/u.test(value),
@@ -12028,6 +12500,7 @@ var resolvedTileflowMapSchema = z5.object({
   icons: iconDirectoriesSchema.optional(),
   id: tileflowMapIdSchema,
   marine: marineSchema.optional(),
+  models: modelDirectoriesSchema.optional(),
   modules: modulesSchema.optional(),
   name: z5.string().trim().min(1),
   overlays: overlaysSchema.optional(),
@@ -12117,9 +12590,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(".");
@@ -12183,6 +12690,71 @@ 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 token = tileflowRouteTokens.number[key];
+    const value = theme.tokens.number[token];
+    if (value === void 0) continue;
+    if (!(value >= 0 && value <= 1)) {
+      throw new Error(
+        `Tileflow theme "${theme.id}" sets number token "${token}" 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/terrain/index.ts
 function resolveTerrain(terrain, apiBaseUrl) {
   if (!terrain || terrain === "none") return void 0;
@@ -12837,11 +13409,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) {
@@ -12851,6 +13423,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;
@@ -13824,8 +14437,19 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     "domains",
     () => compileSemanticDomains(modules, context)
   );
+  const vegetation3D = runCompilationPhase(
+    "domains",
+    () => withPreparedTreeModels(
+      tileflowVegetationDescription(
+        modules.vegetation,
+        context
+      ),
+      config,
+      options.preparedAssets
+    )
+  );
   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",
@@ -13985,6 +14609,15 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     () => createTileflowOverlayPlacementManifest(plannedLayers)
   );
   const layers = runCompilationPhase("finalization", () => finalizeTileflowLayers(plannedLayers));
+  const buildings3D = tileflowBuildings3DDesignOf(
+    modules.buildings,
+    context,
+    layers
+  );
+  const streetLights = tileflowStreetLightsDesignOf(
+    modules.roads,
+    context
+  );
   runCompilationPhase(
     "finalization",
     () => assertTileflowInteractionManifestLayers(interactionManifest, layers)
@@ -14055,13 +14688,35 @@ 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) } : {},
+      ...buildings3D ? {
+        [tileflowBuildingsMetadataKey]: tileflowBuildingsMetadata(
+          bindSemanticReferences(buildings3D, semanticData)
+        )
+      } : {},
+      ...streetLights ? {
+        [tileflowStreetLightsMetadataKey]: tileflowStreetLightsMetadata(
+          bindSemanticReferences(streetLights, semanticData)
+        )
+      } : {},
+      ...vegetation3D ? {
+        [tileflowVegetationMetadataKey]: tileflowVegetationMetadata({
+          ...bindSemanticReferences(vegetation3D, semanticData),
+          // The layers that draw the trees flat: the module's own and its render passes.
+          flatLayers: layers.filter((layer) => {
+            const metadata = layer.metadata;
+            return metadata?.["tileflow:vegetation-mode"] !== void 0 || metadata?.["tileflow:domain"] === "vegetation";
+          }).map((layer) => String(layer.id))
+        })
+      } : {},
       "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 } : {}
     }
   };
@@ -14081,7 +14736,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();
@@ -14104,7 +14768,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];
@@ -14138,13 +14802,32 @@ function assertMapLibreStyle(style, mapId) {
     }
   );
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function resolveGlyphs(config) {
   if (config.fonts !== void 0) return void 0;
   return config.glyphs?.url;
 }
+function withPreparedTreeModels(vegetation2, config, prepared) {
+  if (!vegetation2) return void 0;
+  const referenced = [
+    ...new Set(Object.values(vegetation2.forms).flatMap((form) => form?.models ?? []))
+  ].sort();
+  if (referenced.length === 0) return vegetation2;
+  const available = prepared?.models ?? {};
+  const missing = referenced.filter((id2) => !Object.hasOwn(available, id2));
+  if (missing.length > 0) {
+    const authoring = config.models?.length ? `Add ${missing.map((id2) => `${id2}.glb`).join(", ")} to a map.models directory, or run the Node build so the directories are prepared.` : "Declare map.models with directories containing those .glb files.";
+    throw new Error(
+      `Tileflow map "${config.id}" draws missing 3D models: ${missing.join(", ")}. ${authoring}`
+    );
+  }
+  return {
+    ...vegetation2,
+    models: Object.fromEntries(referenced.map((id2) => [id2, available[id2]]))
+  };
+}
 function assertPreparedIconReferences(style, config, prepared) {
   const references = collectStyleImageReferences(style);
   if (references.size === 0) return;
@@ -14159,8 +14842,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"]],
@@ -14249,7 +14932,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(",");
@@ -14265,7 +14948,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"];
@@ -14278,7 +14961,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) {
@@ -14304,7 +14987,7 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record3 = isRecord8(error) ? error : {};
+  const record3 = isRecord9(error) ? error : {};
   if (typeof record3.phase === "string") return error;
   if (error instanceof Error && Object.isExtensible(error)) {
     Object.defineProperty(error, "phase", { configurable: true, enumerable: true, value: phase });
@@ -14726,6 +15409,97 @@ function hasControlCharacter(value) {
   return false;
 }
 
+// src/capture-shot.ts
+import { z as z9 } from "zod";
+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 tileflowCaptureShotBlendSchema = z9.object({
+  themes: z9.array(tileflowThemeNameSchema).min(tileflowCaptureShotLimits.blendThemes.minimum).max(tileflowCaptureShotLimits.blendThemes.maximum),
+  position: z9.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 = z9.object({
+  at: z9.number().int().min(0).max(tileflowCaptureShotLimits.durationMs.maximum),
+  camera: tileflowCaptureCenterCameraSchema,
+  blend: tileflowCaptureShotBlendSchema.optional()
+}).strict();
+var tileflowCaptureShotFields = {
+  theme: tileflowThemeNameSchema,
+  viewport: tileflowCaptureViewportSchema,
+  fps: z9.literal(tileflowCaptureShotLimits.fps).optional(),
+  keyframes: z9.array(tileflowCaptureShotKeyframeSchema).min(tileflowCaptureShotLimits.keyframes.minimum).max(tileflowCaptureShotLimits.keyframes.maximum),
+  easing: z9.enum(["smooth", "linear"]).optional()
+};
+var tileflowCaptureShotSchema = z9.object({ map: tileflowPortableIdSchema, ...tileflowCaptureShotFields }).strict().superRefine(checkShotTiming);
+var tileflowMapShotSchema = z9.object(tileflowCaptureShotFields).strict().superRefine(checkShotTiming);
+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 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/maps/operations.ts
 var resetValue = deepFreeze({ $tileflow: "reset" });
 var disableValue = deepFreeze({ op: "disable" });
@@ -14773,11 +15547,13 @@ var tileflowMapMergeStrategies = {
   icons: "icons",
   id: "identity",
   marine: "atomic",
+  models: "atomic",
   modules: "modules",
   name: "identity",
   overlays: "keyed-resources",
   projection: "atomic",
   scenes: "leaf",
+  shots: "leaf",
   sources: "keyed-resources",
   systemThemes: "atomic",
   terrain: "atomic",
@@ -15117,11 +15893,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;
 }
@@ -15154,6 +15930,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;
   }
@@ -15161,40 +15938,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}`
       );
     }
   }
@@ -15206,10 +15996,10 @@ function isPlainRecord5(value) {
 }
 
 // src/icon-composition.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/icon-package.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var tileflowIconIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 var tileflowIconPackageLimits = {
   decodeConcurrency: 4,
@@ -15228,19 +16018,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",
@@ -15260,32 +16050,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(
@@ -15384,57 +16174,57 @@ function containsControlCharacter(value) {
 
 // src/icon-composition.ts
 var tileflowIconCompositionMaximumBytes = 1024 * 1024;
-var idsSchema = z10.array(tileflowIconIdSchema).max(tileflowIconPackageLimits.maxIconCount).refine(
+var idsSchema = z11.array(tileflowIconIdSchema).max(tileflowIconPackageLimits.maxIconCount).refine(
   (ids) => new Set(ids).size === ids.length && ids.every((id2, index) => index === 0 || compareCodeUnits8(ids[index - 1], id2) < 0),
   "Icon exports must be unique and sorted by code unit"
 );
-var localContributorSchema = z10.object({ kind: z10.literal("local"), iconIds: idsSchema }).strict();
-var packageContributorSchema = z10.object({
-  kind: z10.literal("package"),
-  package: z10.string().max(214).regex(/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u),
+var localContributorSchema = z11.object({ kind: z11.literal("local"), iconIds: idsSchema }).strict();
+var packageContributorSchema = z11.object({
+  kind: z11.literal("package"),
+  package: z11.string().max(214).regex(/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u),
   iconIds: idsSchema
 }).strict();
-var setContributorSchema = z10.object({
-  kind: z10.literal("icon-set"),
+var setContributorSchema = z11.object({
+  kind: z11.literal("icon-set"),
   reference: tileflowIconSetReferenceSchema,
   teamId: tileflowIconSetTeamIdSchema,
   setId: tileflowIconSetIdSchema,
   versionId: tileflowIconSetVersionIdSchema,
-  version: z10.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  version: z11.number().int().positive().max(Number.MAX_SAFE_INTEGER),
   packageId: tileflowIconSetPackageIdSchema,
   contentHash: tileflowIconPackageContentHashSchema,
   iconIds: idsSchema.min(1)
 }).strict();
-var tileflowRenderedIconIdentitySchema = z10.object({
-  kind: z10.literal("rendered-icon"),
+var tileflowRenderedIconIdentitySchema = z11.object({
+  kind: z11.literal("rendered-icon"),
   id: tileflowIconIdSchema,
   appearance: tileflowIconAppearanceSchema.optional(),
   layout: tileflowIconLayoutSchema.optional(),
-  width: z10.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
-  height: z10.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
-  pixelSha256: z10.object({
+  width: z11.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
+  height: z11.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
+  pixelSha256: z11.object({
     oneX: tileflowIconPackageContentHashSchema,
     twoX: tileflowIconPackageContentHashSchema
   }).strict()
 }).strict();
-var tileflowIconCompositionSchema = z10.object({
+var tileflowIconCompositionSchema = z11.object({
   // An explicit map keeps declaration order independent of TypeScript's literal cache.
-  format: z10.enum({
+  format: z11.enum({
     "tileflow-icon-composition-v1": "tileflow-icon-composition-v1",
     "tileflow-icon-composition-v2": "tileflow-icon-composition-v2"
   }),
-  compositionVersion: z10.union([z10.literal(1), z10.literal(2)]),
+  compositionVersion: z11.union([z11.literal(1), z11.literal(2)]),
   packageHash: tileflowIconPackageContentHashSchema,
-  contributors: z10.array(
-    z10.discriminatedUnion("kind", [
+  contributors: z11.array(
+    z11.discriminatedUnion("kind", [
       localContributorSchema,
       packageContributorSchema,
       setContributorSchema
     ])
   ).min(1).max(tileflowIconSourceLimit),
-  winners: z10.array(
+  winners: z11.array(
     tileflowRenderedIconIdentitySchema.omit({ kind: true }).extend({
-      contributor: z10.number().int().min(0).max(tileflowIconSourceLimit - 1)
+      contributor: z11.number().int().min(0).max(tileflowIconSourceLimit - 1)
     })
   ).min(1).max(tileflowIconPackageLimits.maxIconCount)
 }).strict().superRefine((receipt, context) => {
@@ -15625,6 +16415,7 @@ async function hashTileflowMapRevision(input, sourceAssets) {
   const {
     fonts: _fonts,
     icons: _icons,
+    models: _models,
     id: _id,
     name: _name,
     version: _version,
@@ -15720,10 +16511,26 @@ function normalizeSourceAssets(input) {
   if (new Set(fonts.map(fontIdentity)).size !== fonts.length) {
     throw new Error("Effective Tileflow font source identities must have unique faces.");
   }
+  const models = [...input.models ?? []].map((model) => {
+    assertSha256(model.sha256, `model ${model.id}`);
+    if (model.level !== "near" && model.level !== "far")
+      throw new Error(`Tileflow model ${model.id} is near or far.`);
+    return { id: model.id, level: model.level, sha256: model.sha256 };
+  }).sort(
+    (left, right) => compareCodeUnits8(`${left.id}\0${left.level}`, `${right.id}\0${right.level}`)
+  );
+  if (new Set(models.map((model) => `${model.id}\0${model.level}`)).size !== models.length) {
+    throw new Error("Effective Tileflow model source identities must be unique.");
+  }
   const iconComposition = input.iconComposition === void 0 ? void 0 : parseTileflowIconComposition(input.iconComposition);
   if (icons.some((icon) => icon.kind === "rendered-icon") && !iconComposition)
     throw new Error("Rendered icon identities require an explicit composition receipt");
-  return { fonts, icons, ...iconComposition ? { iconComposition } : {} };
+  return {
+    fonts,
+    icons,
+    ...iconComposition ? { iconComposition } : {},
+    ...models.length > 0 ? { models } : {}
+  };
 }
 function fontIdentity(font) {
   return `${font.family}\0${font.style}\0${font.weight}`;
@@ -15786,23 +16593,23 @@ function compileTileflowMapWithInspection(config, options) {
 }
 
 // src/renderer-deployment.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/native-build-record.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/native-profile-definition.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var tileflowNativeProfileSchema = strictNativeObject({
-  id: z11.literal("native-v1"),
-  renderer: z11.literal("native"),
-  schemaVersion: z11.literal(1),
-  styleVersion: z11.literal(8),
-  validatorStyleSpec: z11.literal("24.8.5"),
-  reactNativeStyleSpec: z11.literal("26.2.1"),
-  maplibreReactNative: z11.literal("11.3.10"),
-  android: z11.literal("13.2.0"),
-  ios: z11.literal("6.26.0")
+  id: z12.literal("native-v1"),
+  renderer: z12.literal("native"),
+  schemaVersion: z12.literal(1),
+  styleVersion: z12.literal(8),
+  validatorStyleSpec: z12.literal("24.8.5"),
+  reactNativeStyleSpec: z12.literal("26.2.1"),
+  maplibreReactNative: z12.literal("11.3.10"),
+  android: z12.literal("13.2.0"),
+  ios: z12.literal("6.26.0")
 });
 var tileflowNativeProfile = Object.freeze({
   id: "native-v1",
@@ -15815,8 +16622,8 @@ var tileflowNativeProfile = Object.freeze({
   android: "13.2.0",
   ios: "6.26.0"
 });
-var tileflowNativeProfileIdSchema = z11.literal("native-v1");
-var tileflowRendererSchema = z11.enum(["web", "native"]);
+var tileflowNativeProfileIdSchema = z12.literal("native-v1");
+var tileflowRendererSchema = z12.enum(["web", "native"]);
 
 // src/native-profile-helpers.ts
 var tileflowNativeProfileLimits = Object.freeze({
@@ -15897,20 +16704,20 @@ function isBoundedNativeJson(input, stage = "input") {
 }
 
 // src/native-build-record.ts
-var hashSchema = z12.string().regex(/^[a-f0-9]{64}$/u);
-var layerCountSchema = z12.number().int().min(0).max(tileflowNativeProfileLimits.maximumLayers);
+var hashSchema = z13.string().regex(/^[a-f0-9]{64}$/u);
+var layerCountSchema = z13.number().int().min(0).max(tileflowNativeProfileLimits.maximumLayers);
 var layerTransformationSchema = strictNativeObject({
   inputLayer: layerCountSchema,
   outputStart: layerCountSchema,
-  outputCount: z12.number().int().min(1).max(32),
-  properties: z12.array(z12.enum(["line-cap", "line-dasharray"])).min(1).max(2).refine(
+  outputCount: z13.number().int().min(1).max(32),
+  properties: z13.array(z13.enum(["line-cap", "line-dasharray"])).min(1).max(2).refine(
     (properties2) => properties2.length === 1 || properties2[0] === "line-cap" && properties2[1] === "line-dasharray",
     "Expected unique, ordered properties"
   )
 });
 var symbolOverlapTransformationSchema = strictNativeObject({
   inputLayer: layerCountSchema,
-  properties: z12.array(z12.enum(["icon-overlap", "text-overlap"])).min(1).max(2).refine(
+  properties: z13.array(z13.enum(["icon-overlap", "text-overlap"])).min(1).max(2).refine(
     (properties2) => properties2.length === 1 || properties2[0] === "icon-overlap" && properties2[1] === "text-overlap",
     "Expected unique, ordered properties"
   )
@@ -15922,9 +16729,9 @@ var tileflowNativeStyleTransformationSchema = strictNativeObject({
   loweredStyleSha256: hashSchema,
   inputLayers: layerCountSchema,
   outputLayers: layerCountSchema,
-  projection: z12.enum(["none", "mercator-to-implicit", "globe-to-mercator"]),
-  layers: z12.array(layerTransformationSchema).max(tileflowNativeProfileLimits.maximumLayers),
-  symbolOverlap: z12.array(symbolOverlapTransformationSchema).max(tileflowNativeProfileLimits.maximumLayers)
+  projection: z13.enum(["none", "mercator-to-implicit", "globe-to-mercator"]),
+  layers: z13.array(layerTransformationSchema).max(tileflowNativeProfileLimits.maximumLayers),
+  symbolOverlap: z13.array(symbolOverlapTransformationSchema).max(tileflowNativeProfileLimits.maximumLayers)
 }).superRefine((style, context) => {
   let previous = -1;
   let added = 0;
@@ -15960,14 +16767,14 @@ var tileflowNativeStyleTransformationSchema = strictNativeObject({
   }
 });
 var tileflowNativeBuildRecordSchema = strictNativeObject({
-  schemaVersion: z12.literal(2),
-  renderer: z12.literal("native"),
-  profile: z12.literal("native-v1"),
-  validation: z12.literal("static-artifacts"),
-  preparationVersion: z12.literal("native-lowering-v1"),
-  engines: strictNativeObject({ android: z12.literal("13.2.0"), ios: z12.literal("6.26.0") }),
+  schemaVersion: z13.literal(2),
+  renderer: z13.literal("native"),
+  profile: z13.literal("native-v1"),
+  validation: z13.literal("static-artifacts"),
+  preparationVersion: z13.literal("native-lowering-v1"),
+  engines: strictNativeObject({ android: z13.literal("13.2.0"), ios: z13.literal("6.26.0") }),
   buildManifestSha256: hashSchema,
-  transformations: z12.array(tileflowNativeStyleTransformationSchema).max(4096)
+  transformations: z13.array(tileflowNativeStyleTransformationSchema).max(4096)
 }).superRefine((record3, context) => {
   let previous = "";
   for (const [index, item] of record3.transformations.entries()) {
@@ -24423,7 +25230,7 @@ var latest_default = {
 };
 
 // src/native-profile.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/native-url-policy.ts
 var tileflowNativeUrlLimits = Object.freeze({ maximumLength: 2048 });
@@ -24578,7 +25385,7 @@ var { resolveTileflowNativeResourceUrl } = createNativeUrlPolicy(
 );
 
 // src/native-profile.ts
-var tileflowNativeDiagnosticCodeSchema = z13.enum([
+var tileflowNativeDiagnosticCodeSchema = z14.enum([
   "NATIVE_UNSUPPORTED_STYLE",
   "NATIVE_UNSUPPORTED_SOURCE",
   "NATIVE_FONT_UNAVAILABLE",
@@ -24587,13 +25394,13 @@ var tileflowNativeDiagnosticCodeSchema = z13.enum([
 ]);
 var tileflowNativeDiagnosticSchema = strictNativeObject({
   code: tileflowNativeDiagnosticCodeSchema,
-  phase: z13.literal("native-compatibility"),
-  severity: z13.literal("error"),
-  path: z13.string().max(300).regex(/^(?:\/(?:[^~]|~[01])*)?$/u),
-  renderer: z13.literal("native"),
+  phase: z14.literal("native-compatibility"),
+  severity: z14.literal("error"),
+  path: z14.string().max(300).regex(/^(?:\/(?:[^~]|~[01])*)?$/u),
+  renderer: z14.literal("native"),
   profile: tileflowNativeProfileIdSchema,
-  message: z13.string().max(300),
-  suggestion: z13.string().max(300)
+  message: z14.string().max(300),
+  suggestion: z14.string().max(300)
 });
 var descriptions = {
   NATIVE_UNSUPPORTED_STYLE: [
@@ -24973,24 +25780,24 @@ var tileflowRendererDeploymentLimits = Object.freeze({
   maximumNativeFamilyBytes: tileflowNativeProfileLimits.maximumStyleBytes,
   maximumThemes: 64
 });
-var hashSchema2 = z14.string().regex(/^[a-f0-9]{64}$/u);
-var recordSchema = z14.record(z14.string().min(1).max(256), z14.unknown());
-var positive = z14.number().int().positive().max(Number.MAX_SAFE_INTEGER);
-var sourceAssetsSchema = z14.object({
-  fonts: z14.array(
-    z14.object({
-      family: z14.string().min(1).max(128),
+var hashSchema2 = z15.string().regex(/^[a-f0-9]{64}$/u);
+var recordSchema = z15.record(z15.string().min(1).max(256), z15.unknown());
+var positive = z15.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var sourceAssetsSchema = z15.object({
+  fonts: z15.array(
+    z15.object({
+      family: z15.string().min(1).max(128),
       sha256: hashSchema2,
-      style: z14.enum(["italic", "normal", "oblique"]),
-      weight: z14.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
+      style: z15.enum(["italic", "normal", "oblique"]),
+      weight: z15.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
     }).strict()
   ).max(64),
-  icons: z14.array(
-    z14.union([
-      z14.object({
-        format: z14.enum(["jpeg", "png", "svg", "webp"]),
+  icons: z15.array(
+    z15.union([
+      z15.object({
+        format: z15.enum(["jpeg", "png", "svg", "webp"]),
         id: tileflowPortableIdSchema,
-        kind: z14.enum(["icon", "pattern"]),
+        kind: z15.enum(["icon", "pattern"]),
         sha256: hashSchema2
       }).strict(),
       tileflowRenderedIconIdentitySchema
@@ -24998,44 +25805,44 @@ var sourceAssetsSchema = z14.object({
   ).max(512),
   iconComposition: tileflowIconCompositionSchema.optional()
 }).strict();
-var themeBuildSchema = z14.object({
-  colorScheme: z14.enum(["dark", "light"]),
+var themeBuildSchema = z15.object({
+  colorScheme: z15.enum(["dark", "light"]),
   dataRequirements: recordSchema,
   sourceRequirements: recordSchema,
   styleSha256: hashSchema2,
   themeId: tileflowPortableIdSchema,
   themeVersion: positive
 }).strict();
-var mapBuildSchema = z14.object({
+var mapBuildSchema = z15.object({
   assetSetSha256: hashSchema2,
   defaultTheme: tileflowThemeNameSchema,
-  lineage: z14.array(z14.object({ id: tileflowPortableIdSchema, mapVersion: positive }).strict()).min(1).max(64),
+  lineage: z15.array(z15.object({ id: tileflowPortableIdSchema, mapVersion: positive }).strict()).min(1).max(64),
   mapRevisionSha256: hashSchema2,
-  mapRevisionSchemaVersion: z14.literal(2).optional(),
+  mapRevisionSchemaVersion: z15.literal(2).optional(),
   mapVersion: positive,
-  semanticCompiler: z14.object({ name: z14.literal("tileflow-semantic"), version: z14.literal(1) }).strict(),
+  semanticCompiler: z15.object({ name: z15.literal("tileflow-semantic"), version: z15.literal(1) }).strict(),
   sourceAssets: sourceAssetsSchema,
-  systemThemes: z14.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
-  themes: z14.record(tileflowThemeNameSchema, themeBuildSchema)
+  systemThemes: z15.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
+  themes: z15.record(tileflowThemeNameSchema, themeBuildSchema)
 }).strict();
-var buildManifestSchema = z14.object({
-  schemaVersion: z14.literal(1),
-  maps: z14.record(tileflowPortableIdSchema, mapBuildSchema),
-  provenance: z14.object({
-    schemaVersion: z14.literal(1),
-    lockfile: z14.object({ format: z14.enum(["bun", "npm", "pnpm", "yarn"]), sha256: hashSchema2 }).strict().optional(),
-    packages: z14.record(z14.string().min(1).max(128), z14.string().min(1).max(128))
+var buildManifestSchema = z15.object({
+  schemaVersion: z15.literal(1),
+  maps: z15.record(tileflowPortableIdSchema, mapBuildSchema),
+  provenance: z15.object({
+    schemaVersion: z15.literal(1),
+    lockfile: z15.object({ format: z15.enum(["bun", "npm", "pnpm", "yarn"]), sha256: hashSchema2 }).strict().optional(),
+    packages: z15.record(z15.string().min(1).max(128), z15.string().min(1).max(128))
   }).strict().optional()
 }).strict();
 var familyShape = {
   buildManifest: buildManifestSchema,
-  styles: z14.record(tileflowThemeNameSchema, recordSchema)
+  styles: z15.record(tileflowThemeNameSchema, recordSchema)
 };
-var teamSourcesSchema = z14.record(
+var teamSourcesSchema = z15.record(
   tileflowPortableIdSchema,
-  z14.object({
-    tileset: z14.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
-    type: z14.enum(["raster", "vector"])
+  z15.object({
+    tileset: z15.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+    type: z15.enum(["raster", "vector"])
   }).strict()
 ).superRefine((sources, context) => {
   const entries = Object.entries(sources);
@@ -25047,21 +25854,21 @@ var teamSourcesSchema = z14.record(
     tilesets.add(value.tileset);
   }
 });
-var viewSchema2 = z14.object({
-  center: z14.tuple([z14.number().min(-180).max(180), z14.number().min(-90).max(90)]).optional(),
-  zoom: z14.number().min(0).max(24).optional(),
-  bearing: z14.number().finite().optional(),
-  pitch: z14.number().min(0).max(85).optional()
+var viewSchema2 = z15.object({
+  center: z15.tuple([z15.number().min(-180).max(180), z15.number().min(-90).max(90)]).optional(),
+  zoom: z15.number().min(0).max(24).optional(),
+  bearing: z15.number().finite().optional(),
+  pitch: z15.number().min(0).max(85).optional()
 }).strict();
-var tileflowRendererDeploymentArtifactSchema = z14.object({
-  kind: z14.literal("tileflow-map-deployment"),
-  schemaVersion: z14.literal(2),
+var tileflowRendererDeploymentArtifactSchema = z15.object({
+  kind: z15.literal("tileflow-map-deployment"),
+  schemaVersion: z15.literal(2),
   mapId: tileflowPortableIdSchema,
   teamSources: teamSourcesSchema,
   view: viewSchema2.optional(),
-  renderers: z14.object({
-    web: z14.object(familyShape).strict(),
-    native: z14.object({ ...familyShape, buildRecord: tileflowNativeBuildRecordSchema }).strict()
+  renderers: z15.object({
+    web: z15.object(familyShape).strict(),
+    native: z15.object({ ...familyShape, buildRecord: tileflowNativeBuildRecordSchema }).strict()
   }).strict()
 }).strict().superRefine((artifact, context) => {
   const fail = () => context.addIssue({
@@ -25186,30 +25993,30 @@ function object(value) {
 function equal(left, right) {
   return left === void 0 || right === void 0 ? left === right : serializeCanonicalJson(left) === serializeCanonicalJson(right);
 }
-var artifactName = z14.string().min(1).max(256).refine(
+var artifactName = z15.string().min(1).max(256).refine(
   (value) => [...value].every((char) => {
     const code = char.codePointAt(0);
     return code >= 32 && code !== 127;
   })
 );
-var semanticSchema = z14.object({
-  version: z14.literal(2),
-  domains: z14.object({
-    poi: z14.object({
-      deduplication: z14.object({
-        identity: z14.tuple([
-          z14.literal("source"),
-          z14.literal("source-layer"),
-          z14.literal("feature-id")
+var semanticSchema = z15.object({
+  version: z15.literal(2),
+  domains: z15.object({
+    poi: z15.object({
+      deduplication: z15.object({
+        identity: z15.tuple([
+          z15.literal("source"),
+          z15.literal("source-layer"),
+          z15.literal("feature-id")
         ]),
-        representationPriority: z14.tuple([
-          z14.literal("marker"),
-          z14.literal("icon"),
-          z14.literal("combined"),
-          z14.literal("label")
+        representationPriority: z15.tuple([
+          z15.literal("marker"),
+          z15.literal("icon"),
+          z15.literal("combined"),
+          z15.literal("label")
         ])
       }).strict(),
-      fields: z14.object({
+      fields: z15.object({
         category: artifactName,
         filterRank: artifactName,
         icon: artifactName,
@@ -25217,18 +26024,18 @@ var semanticSchema = z14.object({
         sizeRank: artifactName,
         type: artifactName
       }).strict(),
-      hitTesting: z14.object({
-        frequency: z14.literal("animation-frame"),
-        order: z14.literal("rendered-topmost")
+      hitTesting: z15.object({
+        frequency: z15.literal("animation-frame"),
+        order: z15.literal("rendered-topmost")
       }).strict(),
-      identity: z14.literal("maplibre-feature-id-if-present"),
-      layers: z14.array(
-        z14.object({
-          anchor: z14.literal("pointer-coordinate"),
-          category: z14.enum(tileflowPoiCategories),
+      identity: z15.literal("maplibre-feature-id-if-present"),
+      layers: z15.array(
+        z15.object({
+          anchor: z15.literal("pointer-coordinate"),
+          category: z15.enum(tileflowPoiCategories),
           layerId: artifactName,
-          priority: z14.number().int().min(0).max(4095),
-          representation: z14.enum(["combined", "icon", "label", "marker"]),
+          priority: z15.number().int().min(0).max(4095),
+          representation: z15.enum(["combined", "icon", "label", "marker"]),
           source: artifactName,
           sourceLayer: artifactName
         }).strict()
@@ -25254,8 +26061,8 @@ function semanticIdentity(style) {
   const poi2 = manifest.domains.poi;
   return poi2 ? { ...poi2, layers: poi2.layers.map(({ priority: _priority, ...identity }) => identity) } : manifest;
 }
-var mapIdSchema = z14.string().regex(/^map_[A-Za-z0-9_-]{16}$/u);
-var publicUrlSchema = z14.string().min(1).max(2048).refine((value) => {
+var mapIdSchema = z15.string().regex(/^map_[A-Za-z0-9_-]{16}$/u);
+var publicUrlSchema = z15.string().min(1).max(2048).refine((value) => {
   try {
     const url = new URL(value);
     return url.protocol === "https:" && !url.username && !url.password && !url.search && !url.hash && url.toString() === value && !/tf_(?:public|native|live)_/u.test(value);
@@ -25263,22 +26070,22 @@ var publicUrlSchema = z14.string().min(1).max(2048).refine((value) => {
     return false;
   }
 });
-var webResponseTheme = z14.object({ styleId: z14.string().min(1).max(128).optional(), styleUrl: publicUrlSchema }).strict();
-var nativeResponseTheme = z14.object({ styleUrl: publicUrlSchema, revision: hashSchema2 }).strict();
-var tileflowRendererDeploymentResponseSchema = z14.object({
-  kind: z14.literal("tileflow-map-deployment-result"),
-  schemaVersion: z14.literal(2),
-  changed: z14.boolean(),
+var webResponseTheme = z15.object({ styleId: z15.string().min(1).max(128).optional(), styleUrl: publicUrlSchema }).strict();
+var nativeResponseTheme = z15.object({ styleUrl: publicUrlSchema, revision: hashSchema2 }).strict();
+var tileflowRendererDeploymentResponseSchema = z15.object({
+  kind: z15.literal("tileflow-map-deployment-result"),
+  schemaVersion: z15.literal(2),
+  changed: z15.boolean(),
   mapId: mapIdSchema,
-  deploymentId: z14.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  deploymentId: z15.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/u),
   version: positive,
-  worldConversionId: z14.string().min(1).max(128).optional(),
-  renderers: z14.object({
-    web: z14.object({ themes: z14.record(tileflowThemeNameSchema, webResponseTheme) }).strict(),
-    native: z14.object({
-      profile: z14.literal("native-v1"),
+  worldConversionId: z15.string().min(1).max(128).optional(),
+  renderers: z15.object({
+    web: z15.object({ themes: z15.record(tileflowThemeNameSchema, webResponseTheme) }).strict(),
+    native: z15.object({
+      profile: z15.literal("native-v1"),
       manifestUrl: publicUrlSchema,
-      themes: z14.record(tileflowThemeNameSchema, nativeResponseTheme)
+      themes: z15.record(tileflowThemeNameSchema, nativeResponseTheme)
     }).strict()
   }).strict()
 }).strict().superRefine((value, context) => {