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

package/dist/index.js

@@ -261,16 +261,16 @@ var init_expression_operators = __esm({
 function fixed(value, options) {
   const reason = options.reason.trim();
   if (!reason) throw new Error("Tileflow fixed values require a non-empty reason.");
-  cloneJson3(value);
+  cloneJson2(value);
   return { kind: "theme-fixed", reason, value };
 }
 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") {
@@ -278,8 +278,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];
@@ -287,13 +287,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);
@@ -330,7 +330,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",
@@ -359,9 +359,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.");
@@ -403,9 +403,9 @@ var init_values = __esm({
     color = {
       alpha(value, opacity) {
         return {
-          color: cloneJson3(value),
+          color: cloneJson2(value),
           kind: "theme-color",
-          opacity: cloneJson3(opacity),
+          opacity: cloneJson2(opacity),
           operation: "alpha"
         };
       },
@@ -414,12 +414,12 @@ var init_values = __esm({
           throw new Error("Tileflow color mixing supports only the deterministic OKLCH color space.");
         }
         return {
-          amount: cloneJson3(options.amount),
-          from: cloneJson3(from),
+          amount: cloneJson2(options.amount),
+          from: cloneJson2(from),
           kind: "theme-color",
           operation: "mix",
           space: "oklch",
-          to: cloneJson3(to)
+          to: cloneJson2(to)
         };
       }
     };
@@ -662,9 +662,9 @@ function tileflowSunMetadata(preset) {
   return Object.freeze({ version: 1, ...preset });
 }
 function readTileflowSunPreset(metadata) {
-  if (!isRecord3(metadata)) return void 0;
+  if (!isRecord6(metadata)) return void 0;
   const value = metadata[tileflowSunMetadataKey];
-  if (!isRecord3(value) || value.version !== 1 || !isRecord3(value.ambient)) return void 0;
+  if (!isRecord6(value) || value.version !== 1 || !isRecord6(value.ambient)) return void 0;
   const { azimuth, altitude, color: color3, intensity, shadowIntensity } = value;
   const ambient = value.ambient;
   if (!isFiniteNumber(azimuth) || !isFiniteNumber(altitude) || !isUnit(intensity) || !isUnit(shadowIntensity) || !isUnit(ambient.intensity) || !isColour(color3) || !isColour(ambient.color))
@@ -681,7 +681,7 @@ function readTileflowSunPreset(metadata) {
 function tileflowStyleSunPreset(style) {
   const published = readTileflowSunPreset(style?.metadata);
   if (published) return published;
-  const light = isRecord3(style?.light) ? style.light : void 0;
+  const light = isRecord6(style?.light) ? style.light : void 0;
   const position = light?.position;
   if (!position) return tileflowDefaultSunPreset;
   return Object.freeze({
@@ -719,7 +719,7 @@ function smoothstep2(from, to, value) {
 function clamp01(value) {
   return Math.min(1, Math.max(0, Number.isFinite(value) ? value : 0));
 }
-function isRecord3(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isFiniteNumber(value) {
@@ -963,7 +963,7 @@ function auditTileflowThemeValues(value, path = "value", context = inferAuditCon
   return diagnostics.sort(compareAuditDiagnostics);
 }
 function auditTileflowMapThemeValues(map) {
-  const modules = isRecord4(map.modules) ? map.modules : void 0;
+  const modules = isRecord7(map.modules) ? map.modules : void 0;
   const moduleDiagnostics = modules ? Object.keys(modules).sort(compareCodeUnits2).flatMap(
     (owner) => auditTileflowThemeValues(modules[owner], `modules.${owner}`, {
       owner,
@@ -1070,7 +1070,7 @@ function isThemePrimitiveForCategory(value, category) {
   return category === "number" ? typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every((entry) => typeof entry === "number" && Number.isFinite(entry)) : typeof value === "string" && value.length > 0;
 }
 function isThemeValueCandidate(value) {
-  return isRecord4(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
+  return isRecord7(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;
@@ -1086,7 +1086,7 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     visitAuditableArray(value, path, category, state, false, intentRequired);
     return;
   }
-  if (!isRecord4(value)) return;
+  if (!isRecord7(value)) return;
   if (value.kind === "expression" && Array.isArray(value.value)) {
     visitAuditableArray(value.value, `${path}.value`, category, state, true, intentRequired);
     return;
@@ -1469,7 +1469,7 @@ function assertThemeLighting(value, path) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord4(value)) {
+  if (!isRecord7(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -1830,11 +1830,11 @@ function cloneJson14(value) {
   if (serialized === void 0) throw new Error("Tileflow themes must be JSON-serializable.");
   return JSON.parse(serialized);
 }
-function isRecord4(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord(value) {
-  if (!isRecord4(value)) return false;
+  if (!isRecord7(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -1947,7 +1947,7 @@ var init_model = __esm({
         if (Array.isArray(value)) {
           return value.map((entry, index) => this.resolveTree(entry, `${path}[${index}]`, category));
         }
-        if (!isRecord4(value)) return value;
+        if (!isRecord7(value)) return value;
         if (value.kind === "expression" && Array.isArray(value.value)) {
           return {
             ...value,
@@ -2956,7 +2956,7 @@ var defaults = {
 function resolveTileflowAtmosphere(value) {
   if (!value) return void 0;
   const options = { ...defaults, ...value === true ? {} : value };
-  const normalize = (input) => {
+  const normalize2 = (input) => {
     const color3 = typeof input === "string" ? Color.parse(input) : void 0;
     if (!color3 || color3.a !== 1)
       throw new Error("Atmosphere colors must resolve to opaque colors.");
@@ -2966,10 +2966,10 @@ function resolveTileflowAtmosphere(value) {
   };
   return {
     ...options,
-    skyColor: normalize(options.skyColor),
-    horizonColor: normalize(options.horizonColor),
-    fogColor: normalize(options.fogColor),
-    spaceColor: normalize(options.spaceColor)
+    skyColor: normalize2(options.skyColor),
+    horizonColor: normalize2(options.horizonColor),
+    fogColor: normalize2(options.fogColor),
+    spaceColor: normalize2(options.spaceColor)
   };
 }
 function compileTileflowSky(options) {
@@ -3480,10 +3480,10 @@ function isCanonicalOpenMapTilesSchema(schema) {
     ([key, value]) => schema.fields[key] === value
   );
 }
-function dataIdentity(kind, schema, version, url) {
+function dataIdentity(kind, schema, version2, url) {
   return {
-    ...version.generation ? { generation: version.generation } : {},
-    ..."worldSelection" in version && version.worldSelection ? { worldSelection: version.worldSelection } : {},
+    ...version2.generation ? { generation: version2.generation } : {},
+    ..."worldSelection" in version2 && version2.worldSelection ? { worldSelection: version2.worldSelection } : {},
     ...kind === "vector-tiles" ? {
       bindings: {
         fields: { ...schema.fields },
@@ -3498,7 +3498,7 @@ function dataIdentity(kind, schema, version, url) {
       }
     } : {},
     kind,
-    ...version.revision ? { revision: version.revision } : {},
+    ...version2.revision ? { revision: version2.revision } : {},
     schema: schema.type,
     schemaVersion: schema.contractVersion,
     semantics: { ...schema.semantics },
@@ -4090,98 +4090,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";
 
@@ -4815,30 +4723,30 @@ function asRecord2(value) {
 // src/cartography/merge.ts
 init_values();
 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));
 }
@@ -4846,6 +4754,558 @@ function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
+// src/modules/vegetation/compiler.ts
+init_values();
+
+// src/trees-3d.ts
+var tileflowTreeForms = ["round", "open", "tall", "conifer", "columnar", "palm"];
+var tileflowTreeFinishes = ["faceted", "smooth", "toon"];
+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"])
+  )
+});
+function tileflowTreeFormMixProblem(mix2) {
+  if (typeof mix2 !== "object" || mix2 === null || Array.isArray(mix2))
+    return "a mix of forms is an object of weights, such as {round: 1, palm: 2}";
+  let total = 0;
+  for (const [form, weight] of Object.entries(mix2)) {
+    if (!tileflowTreeForms.includes(form))
+      return `"${form}" is not a tree form; forms are ${tileflowTreeForms.join(", ")}`;
+    if (typeof weight !== "number" || !Number.isFinite(weight) || weight < 0)
+      return `the weight of "${form}" must be a number of 0 or more`;
+    total += weight;
+  }
+  return total > 0 ? void 0 : "a mix of forms needs at least one weight above 0";
+}
+var tileflowTreeModelIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var tileflowVegetationMetadataKey = "tileflow:vegetation";
+function tileflowVegetationMetadata(vegetation2) {
+  return { version: 1, ...vegetation2 };
+}
+function readTileflowVegetation3D(metadata) {
+  if (!isRecord3(metadata)) return void 0;
+  const value = metadata[tileflowVegetationMetadataKey];
+  if (!isRecord3(value) || value.version !== 1) return void 0;
+  const { source, layers, fields, colors, heightScale, crownScale, unknownForms, regions: regions2 } = value;
+  if (typeof source !== "string" || !isRecord3(layers) || typeof layers.tree !== "string")
+    return void 0;
+  if (!isRecord3(fields) || !isRecord3(colors) || typeof colors.bark !== "string") return void 0;
+  const palette = (list) => Array.isArray(list) && list.length > 0 && list.every((entry) => typeof entry === "string") ? list : void 0;
+  const broadleaf = palette(colors.broadleaf);
+  const conifer = palette(colors.conifer);
+  const palm = palette(colors.palm) ?? broadleaf;
+  if (!broadleaf || !conifer || !palm) return void 0;
+  const scale = (number) => typeof number === "number" && number > 0 && number <= 10 ? number : 1;
+  const mix2 = tileflowTreeFormMixProblem(unknownForms) === void 0 ? unknownForms : void 0;
+  const models = Object.fromEntries(
+    Object.entries(isRecord3(value.models) ? value.models : {}).filter(
+      ([id2, model]) => tileflowTreeModelIdPattern.test(id2) && isRecord3(model) && typeof model.near === "string" && (model.far === void 0 || typeof model.far === "string")
+    ).slice(0, 16).map(([id2, model]) => {
+      const { near, far } = model;
+      return [id2, far === void 0 ? { near } : { near, far }];
+    })
+  );
+  const ownScales = isRecord3(value.forms) ? value.forms : {};
+  const forms = Object.fromEntries(
+    tileflowTreeForms.flatMap((form) => {
+      const own = ownScales[form];
+      if (!isRecord3(own)) return [];
+      const drawn = Array.isArray(own.models) ? [...new Set(own.models)].filter((id2) => typeof id2 === "string" && id2 in models).slice(0, 4) : [];
+      return [
+        [
+          form,
+          {
+            heightScale: scale(own.heightScale),
+            crownScale: scale(own.crownScale),
+            ...drawn.length > 0 ? { models: drawn } : {}
+          }
+        ]
+      ];
+    })
+  );
+  const finish = tileflowTreeFinishes.find((name) => name === value.finish) ?? "faceted";
+  const edges = typeof value.edges === "number" && value.edges >= 0 && value.edges <= 1 ? value.edges : 0;
+  const zones = Array.isArray(regions2) ? regions2.filter(
+    (region) => isRecord3(region) && tileflowTreeRegionProblem(region) === void 0
+  ) : [];
+  const named = Object.fromEntries(
+    Object.entries(tileflowWorldTreeFields).map(([key, fallback]) => [
+      key,
+      typeof fields[key] === "string" ? fields[key] : fallback
+    ])
+  );
+  return {
+    source,
+    layers: {
+      tree: layers.tree,
+      ...typeof layers.canopy === "string" ? { canopy: layers.canopy } : {}
+    },
+    fields: named,
+    colors: { bark: colors.bark, broadleaf, conifer, palm },
+    heightScale: scale(heightScale),
+    crownScale: scale(crownScale),
+    forms,
+    models,
+    finish,
+    edges,
+    ...typeof value.edgeColor === "string" ? { edgeColor: value.edgeColor } : {},
+    unknownForms: mix2 ?? tileflowDefaultUnknownTreeForms,
+    regions: zones,
+    flatLayers: Array.isArray(value.flatLayers) ? value.flatLayers.filter((id2) => typeof id2 === "string") : []
+  };
+}
+function tileflowTreeRegionProblem(region) {
+  if (!isRecord3(region)) return "a region is an object with bounds and unknownForms";
+  const bounds = region.bounds;
+  if (!Array.isArray(bounds) || bounds.length !== 4 || !bounds.every((value) => typeof value === "number" && Number.isFinite(value)))
+    return "bounds are [west, south, east, north] in degrees";
+  const [west, south, east, north] = bounds;
+  if (Math.abs(west) > 180 || Math.abs(east) > 180 || Math.abs(south) > 90 || Math.abs(north) > 90)
+    return "bounds are [west, south, east, north] in degrees, longitudes within \xB1180 and latitudes within \xB190";
+  if (south > north) return "a region\u2019s south lies below its north";
+  const mix2 = tileflowTreeFormMixProblem(region.unknownForms);
+  return mix2 ? `unknownForms: ${mix2}` : void 0;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(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,
+        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 };
+}
+function readTileflowBuildings3D(metadata) {
+  if (!isRecord4(metadata)) return void 0;
+  const value = metadata[tileflowBuildingsMetadataKey];
+  if (!isRecord4(value) || value.version !== 1) return void 0;
+  const { source, layers, color: color3 } = value;
+  if (typeof source !== "string" || !isRecord4(layers) || typeof layers.building !== "string")
+    return void 0;
+  if (typeof color3 !== "string" && !Array.isArray(color3)) return void 0;
+  const within = (number, high, fallback) => typeof number === "number" && number >= 0 && number <= high ? number : fallback;
+  return {
+    source,
+    layers: {
+      building: layers.building,
+      ...typeof layers.places === "string" ? { places: layers.places } : {}
+    },
+    color: color3,
+    edges: within(value.edges, 1, 1),
+    ...typeof value.edgeColor === "string" ? { edgeColor: value.edgeColor } : {},
+    nightLight: within(value.nightLight, 2, 1),
+    windows: value.windows === true,
+    shadows: value.shadows !== false,
+    occlusion: value.occlusion !== false
+  };
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/street-lights.ts
+init_theme_blend();
+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 };
+}
+function readTileflowStreetLights(metadata) {
+  if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata))
+    return void 0;
+  const value = metadata[tileflowStreetLightsMetadataKey];
+  if (typeof value !== "object" || value === null || value.version !== 1) return void 0;
+  const layers = value.layers;
+  if (typeof value.source !== "string" || typeof layers?.streetFurniture !== "string" || typeof layers.transportation !== "string")
+    return void 0;
+  const estimate = ["lit", "streets", "none"].find((name) => name === value.estimate);
+  const intensity = typeof value.intensity === "number" && value.intensity >= 0 && value.intensity <= 2 ? value.intensity : 1;
+  return {
+    source: value.source,
+    layers: {
+      streetFurniture: layers.streetFurniture,
+      transportation: layers.transportation,
+      ...typeof layers.sidewalk === "string" ? { sidewalk: layers.sidewalk } : {}
+    },
+    estimate: estimate ?? "lit",
+    color: typeof value.color === "string" && tileflowColourChannels(value.color) ? value.color : tileflowDefaultStreetLightsDesign.color,
+    intensity
+  };
+}
+
+// src/cartography/scene-3d-metadata.ts
+init_values();
+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 = isRecord5(module) ? module : {};
+  if (config.enabled === false) return void 0;
+  const style = config.threeDimensional ?? {};
+  let color3;
+  for (const [id2, property] of colourSources) {
+    const value = layers.find((layer) => layer.id === id2)?.paint?.[property];
+    if (typeof value === "string" || Array.isArray(value)) {
+      color3 = 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: color3 ?? 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 = isRecord5(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 color3 = 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 color3 === "string" ? color3 : tileflowDefaultStreetLightsDesign.color,
+    intensity: typeof intensity === "number" ? intensity : 1
+  };
+}
+function isRecord5(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
 init_values();
 function compileAddresses(request, context) {
@@ -7645,7 +8105,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]
       }
     }
   };
@@ -7812,6 +8273,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])
         ]
       }
     }
@@ -9161,77 +9627,6 @@ function cloneJson16(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
-// src/modules/vegetation/compiler.ts
-init_values();
-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) };
@@ -10933,21 +11328,21 @@ function bindSemanticValue(value, schema, sourceId) {
   }
   if (isDataSourceReference(value)) return sourceId;
   if (Array.isArray(value)) return value.map((item) => bindSemanticValue(item, schema, sourceId));
-  if (!isRecord5(value)) return value;
+  if (!isRecord8(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([key, item]) => [key, bindSemanticValue(item, schema, sourceId)])
   );
 }
 function isDataFieldReference2(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
+  return isRecord8(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
 }
 function isDataLayerReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
+  return isRecord8(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
 }
 function isDataSourceReference(value) {
-  return isRecord5(value) && value.kind === "tileflow-data-source" && value.name === "primary";
+  return isRecord8(value) && value.kind === "tileflow-data-source" && value.name === "primary";
 }
-function isRecord5(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compareCodeUnits5(left, right) {
@@ -11051,8 +11446,8 @@ function createTileflowLayerTemplateIR(layer, semanticKey) {
     renderer: type,
     ...filter === void 0 ? {} : { selector: cloneJson20(filter) },
     style: Object.freeze({
-      ...isRecord6(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
-      ...isRecord6(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
+      ...isRecord9(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
+      ...isRecord9(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
     })
   });
 }
@@ -11292,21 +11687,21 @@ function visitReferences(value, counts, visited = /* @__PURE__ */ new WeakSet())
   }
 }
 function isSemanticFieldReference(value) {
-  return isRecord6(value) && value.kind === "tileflow-data-field";
+  return isRecord9(value) && value.kind === "tileflow-data-field";
 }
 function isSemanticLayerReference(value) {
-  return isRecord6(value) && value.kind === "tileflow-data-layer";
+  return isRecord9(value) && value.kind === "tileflow-data-layer";
 }
 function isSemanticSourceReference(value) {
-  return isRecord6(value) && value.kind === "tileflow-data-source";
+  return isRecord9(value) && value.kind === "tileflow-data-source";
 }
 function cloneJson20(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord4(value) {
-  return isRecord6(value) ? value : {};
+  return isRecord9(value) ? value : {};
 }
-function isRecord6(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -11370,7 +11765,7 @@ function validateTileflowRenderSelectorConstraints(input) {
   };
   while (pending.length > 0) {
     const current = pending.pop();
-    if (!isRecord7(current.selector) || typeof current.selector.kind !== "string") {
+    if (!isRecord10(current.selector) || typeof current.selector.kind !== "string") {
       addIssue(
         "invalid-selector",
         "a render selector must be a semantic selector node",
@@ -11431,7 +11826,7 @@ function validateTileflowRenderSelectorConstraints(input) {
         }
         for (const [index, branch] of current.selector.branches.entries()) {
           const branchPath = [...branchesPath, index];
-          if (!isRecord7(branch)) {
+          if (!isRecord10(branch)) {
             addIssue("invalid-selector", "match selector branch must be an object", branchPath);
             continue;
           }
@@ -11462,14 +11857,14 @@ function validateTileflowRenderSelectorConstraints(input) {
         for (let index = current.selector.stops.length - 1; index >= 0; index -= 1) {
           const stop = current.selector.stops[index];
           const stopPath = [...stopsPath, index];
-          if (!isRecord7(stop)) {
+          if (!isRecord10(stop)) {
             addIssue("invalid-selector", "step selector stop must be an object", stopPath);
             continue;
           }
           pushChild(stop.selector, current.depth + 1, [...stopPath, "selector"]);
         }
         for (const [index, stop] of current.selector.stops.entries()) {
-          if (!isRecord7(stop)) continue;
+          if (!isRecord10(stop)) continue;
           const zoom3 = stop.zoom;
           const zoomPath = [...stopsPath, index, "zoom"];
           if (typeof zoom3 !== "number" || !Number.isFinite(zoom3) || zoom3 < 0 || zoom3 > 24) {
@@ -11852,7 +12247,7 @@ function applyRendererStyle(layer, renderer, style) {
   };
 }
 function lowerSelector(selector, data) {
-  if (!isRecord7(selector) || typeof selector.kind !== "string") {
+  if (!isRecord10(selector) || typeof selector.kind !== "string") {
     throw renderStackError(
       "invalid-selector",
       "A render selector must be a semantic selector node."
@@ -12055,7 +12450,7 @@ function requireRenderer(value) {
 function requirePlacement(value) {
   if (typeof value === "string") {
     if (tileflowBandPlacements.includes(value)) return;
-  } else if (isRecord7(value)) {
+  } else if (isRecord10(value)) {
     const keys = Object.keys(value);
     if (keys.length === 1 && (keys[0] === "above" || keys[0] === "below")) {
       requirePortableTarget(value[keys[0]], "render placement target");
@@ -12082,7 +12477,7 @@ function validateRefinementShape(operation) {
   validateStyle(operation.renderer, operation.style);
 }
 function validateStyle(renderer, style) {
-  if (!isRecord7(style)) {
+  if (!isRecord10(style)) {
     throw renderStackError(
       "invalid-style",
       `A ${renderer} render operation requires a style object.`
@@ -12184,7 +12579,7 @@ function normalizeRequirements(requirements) {
   return [...requirements];
 }
 function requireRenderStackEntries(stack) {
-  if (!isRecord7(stack)) {
+  if (!isRecord10(stack)) {
     throw renderStackError("invalid-stack", "A render stack must be a named operation record.");
   }
   const entries = Object.entries(stack);
@@ -12331,9 +12726,9 @@ function cloneJson21(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function asRecord5(value) {
-  return isRecord7(value) ? value : {};
+  return isRecord10(value) ? value : {};
 }
-function isRecord7(value) {
+function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -13372,6 +13767,17 @@ var waterModuleSchema = z7.object({
     stream: lineStyleSchema.optional()
   }).strict().optional()
 }).strict();
+function boundedThemeNumberSchema(min, max) {
+  return z7.union([
+    z7.number().finite().min(min).max(max),
+    themeNumberReferenceSchema,
+    z7.object({
+      kind: z7.literal("theme-fixed"),
+      reason: z7.string().trim().min(1),
+      value: z7.number().finite().min(min).max(max)
+    }).strict()
+  ]);
+}
 var buildingsModuleSchema = z7.object({
   type: z7.literal("buildings"),
   businessCorridor: areaStyleSchema.optional(),
@@ -13379,7 +13785,15 @@ var buildingsModuleSchema = z7.object({
   extrusion: extrusionStyleSchema.optional(),
   flat: areaStyleSchema.optional(),
   mode: z7.enum(["3d", "flat"]).optional(),
-  renderStack: renderStackSchema.optional()
+  renderStack: renderStackSchema.optional(),
+  threeDimensional: z7.object({
+    edges: boundedThemeNumberSchema(0, 1).optional(),
+    edgeColor: themeColorValueSchema.optional(),
+    nightLight: boundedThemeNumberSchema(0, 2).optional(),
+    occlusion: z7.boolean().optional(),
+    shadows: z7.boolean().optional(),
+    windows: z7.boolean().optional()
+  }).strict().optional()
 }).strict();
 var addressesModuleSchema = z7.object({
   type: z7.literal("addresses"),
@@ -13492,6 +13906,12 @@ var roadsModuleSchema = z7.object({
     pattern: fillStyleSchema.optional(),
     surface: fillStyleSchema.optional()
   }).strict().optional(),
+  streetLights: z7.object({
+    color: themeColorValueSchema.optional(),
+    enabled: z7.boolean().optional(),
+    estimate: z7.enum(["lit", "streets", "none"]).optional(),
+    intensity: boundedThemeNumberSchema(0, 2).optional()
+  }).strict().optional(),
   structures: roadStructureMapSchema.optional(),
   weight: z7.enum(["thin", "regular", "bold"]).optional(),
   widthScale: z7.partialRecord(roadClassSchema, themeNumberValueSchema).optional()
@@ -13580,6 +14000,16 @@ var nauticalModuleSchema = z7.object({
   wreckAreas: areaStyleSchema.optional(),
   wrecks: markerSymbolStyleSchema.optional()
 }).strict();
+var treeFormMixSchema = z7.object({
+  round: z7.number().finite().min(0).optional(),
+  open: z7.number().finite().min(0).optional(),
+  tall: z7.number().finite().min(0).optional(),
+  conifer: z7.number().finite().min(0).optional(),
+  columnar: z7.number().finite().min(0).optional(),
+  palm: z7.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 = z7.object({
   addresses: addressesModuleSchema.optional(),
   aeroways: aerowaysModuleSchema.optional(),
@@ -13602,6 +14032,39 @@ var modulesSchema = z7.object({
       barkColor: themeColorValueSchema.optional(),
       broadleafColors: z7.array(themeColorValueSchema).min(1).max(8).optional(),
       coniferColors: z7.array(themeColorValueSchema).min(1).max(8).optional(),
+      palmColors: z7.array(themeColorValueSchema).min(1).max(8).optional(),
+      finish: z7.enum(["faceted", "smooth", "toon"]).optional(),
+      edges: boundedThemeNumberSchema(0, 1).optional(),
+      edgeColor: themeColorValueSchema.optional(),
+      forms: z7.partialRecord(
+        z7.enum(["round", "open", "tall", "conifer", "columnar", "palm"]),
+        z7.object({
+          crownScale: boundedThemeNumberSchema(0.1, 10).optional(),
+          heightScale: boundedThemeNumberSchema(0.1, 10).optional(),
+          models: z7.array(
+            z7.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: z7.array(
+        z7.object({
+          bounds: z7.tuple([
+            z7.number().finite().min(-180).max(180),
+            z7.number().finite().min(-90).max(90),
+            z7.number().finite().min(-180).max(180),
+            z7.number().finite().min(-90).max(90)
+          ]).refine(([, south, , north]) => south <= north, {
+            message: "Expected bounds as [west, south, east, north] with south below north"
+          }),
+          unknownForms: treeFormMixSchema
+        }).strict()
+      ).max(16).optional(),
       crownScale: z7.union([
         z7.number().finite().positive().max(10),
         themeNumberReferenceSchema,
@@ -13934,6 +14397,7 @@ var iconDirectoriesSchema = z7.array(
   }
 });
 var fontDirectoriesSchema = z7.array(assetDirectorySchema).max(16);
+var modelDirectoriesSchema = z7.array(assetDirectorySchema).max(16);
 var fontStacksSchema = z7.array(
   z7.string().min(1).max(200).refine(
     (value) => value === value.trim() && value === value.normalize("NFC") && !/[\p{Cc}\\/]/u.test(value),
@@ -14155,6 +14619,7 @@ var resolvedTileflowMapSchema = z7.object({
   icons: iconDirectoriesSchema.optional(),
   id: tileflowMapIdSchema,
   marine: marineSchema.optional(),
+  models: modelDirectoriesSchema.optional(),
   modules: modulesSchema.optional(),
   name: z7.string().trim().min(1),
   overlays: overlaysSchema.optional(),
@@ -15097,11 +15562,11 @@ function isTileflowPoiCategory(value) {
   return typeof value === "string" && tileflowPoiCategories.includes(value);
 }
 function semanticTarget(layer) {
-  if (!isRecord8(layer.metadata)) return void 0;
+  if (!isRecord11(layer.metadata)) return void 0;
   const value = layer.metadata[tileflowCompilerMetadataKeys.target];
   return typeof value === "string" ? value : void 0;
 }
-function isRecord8(value) {
+function isRecord11(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSafeArtifactName(value) {
@@ -16145,8 +16610,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) => isRecord9(module) && module.enabled !== false && "renderStack" in module && isRecord9(module.renderStack)
+    (module) => isRecord12(module) && module.enabled !== false && "renderStack" in module && isRecord12(module.renderStack)
   );
   const renderOperations = runCompilationPhase(
     "render-stack",
@@ -16306,6 +16782,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)
@@ -16378,13 +16863,33 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       "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]) => !isRecord9(module) || module.enabled !== false).map(([name]) => name).sort(),
+      "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord12(module) || module.enabled !== false).map(([name]) => name).sort(),
       ...config.view ? { "tileflow:view": config.view } : {}
     }
   };
@@ -16436,7 +16941,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 = isRecord9(layer.metadata) ? { ...layer.metadata } : void 0;
+    const metadata = isRecord12(layer.metadata) ? { ...layer.metadata } : void 0;
     if (metadata) {
       const owner = metadata[tileflowCompilerMetadataKeys.owner];
       delete metadata[tileflowCompilerProvenanceMetadataKey];
@@ -16470,13 +16975,32 @@ function assertMapLibreStyle(style, mapId) {
     }
   );
 }
-function isRecord9(value) {
+function isRecord12(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;
@@ -16491,8 +17015,8 @@ function assertPreparedIconReferences(style, config, prepared) {
 function collectStyleImageReferences(style) {
   const result = /* @__PURE__ */ new Set();
   for (const layer of style.layers) {
-    const layout = isRecord9(layer.layout) ? layer.layout : {};
-    const paint = isRecord9(layer.paint) ? layer.paint : {};
+    const layout = isRecord12(layer.layout) ? layer.layout : {};
+    const paint = isRecord12(layer.paint) ? layer.paint : {};
     const layerId = typeof layer.id === "string" ? layer.id : "<unknown>";
     for (const [property, value] of [
       ["icon-image", layout["icon-image"]],
@@ -16581,7 +17105,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 = isRecord9(layer.layout) ? layer.layout : void 0;
+    const layout = isRecord12(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(",");
@@ -16597,7 +17121,7 @@ function assertGlyphFontStacks(style, config) {
 function assertTextAssets(style, config) {
   const textLayers = [];
   for (const layer of style.layers) {
-    const layout = isRecord9(layer.layout) ? layer.layout : void 0;
+    const layout = isRecord12(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"];
@@ -16610,7 +17134,7 @@ function assertTextAssets(style, config) {
   if (textLayers.length === 0) return;
   if (config.fonts !== void 0) {
     const backed = style.layers.find((layer) => {
-      const font = isRecord9(layer.layout) ? layer.layout["text-font"] : void 0;
+      const font = isRecord12(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) {
@@ -16636,7 +17160,7 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record2 = isRecord9(error) ? error : {};
+  const record2 = isRecord12(error) ? error : {};
   if (typeof record2.phase === "string") return error;
   if (error instanceof Error && Object.isExtensible(error)) {
     Object.defineProperty(error, "phase", { configurable: true, enumerable: true, value: phase });
@@ -16733,6 +17257,7 @@ var tileflowMapMergeStrategies = {
   icons: "icons",
   id: "identity",
   marine: "atomic",
+  models: "atomic",
   modules: "modules",
   name: "identity",
   overlays: "keyed-resources",
@@ -17078,11 +17603,11 @@ function cloneDesign(value) {
 function describeMap(value) {
   return typeof value.id === "string" && value.id ? value.id : "<anonymous>";
 }
-function isRecord10(value) {
+function isRecord13(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord4(value) {
-  if (!isRecord10(value)) return false;
+  if (!isRecord13(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -17840,7 +18365,7 @@ function semanticDesign(map) {
 }
 function compareValues(before, after, path, output) {
   if (Object.is(before, after)) return;
-  if (isRecord11(before) && isRecord11(after)) {
+  if (isRecord14(before) && isRecord14(after)) {
     const keys = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort(
       compareCodeUnits9
     );
@@ -17882,7 +18407,7 @@ function toSemanticValue(value, path) {
   }
   throw new TypeError(`Tileflow semantic value at ${path || "/"} is not JSON-serializable.`);
 }
-function isRecord11(value) {
+function isRecord14(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function isUnknownRecord(value) {
@@ -17895,7 +18420,7 @@ function deepEqual(left, right) {
   if (Array.isArray(left) || Array.isArray(right)) {
     return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => deepEqual(value, right[index]));
   }
-  if (!isRecord11(left) || !isRecord11(right)) return false;
+  if (!isRecord14(left) || !isRecord14(right)) return false;
   const leftKeys = Object.keys(left).sort(compareCodeUnits9);
   const rightKeys = Object.keys(right).sort(compareCodeUnits9);
   return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => key === rightKeys[index] && deepEqual(left[key], right[key]));
@@ -18696,7 +19221,7 @@ async function requestSessionGrant(input) {
       else throw error;
     }
     throwIfSessionGrantAborted(signal);
-    if (response.status === 409 && isRecord12(body) && body.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && body.ok === false && body.retryWithNewSession === true && body.sessionId === input.sessionId) {
+    if (response.status === 409 && isRecord15(body) && body.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && body.ok === false && body.retryWithNewSession === true && body.sessionId === input.sessionId) {
       throw new TileflowSessionRestartError();
     }
     if (!response.ok) {
@@ -18769,7 +19294,7 @@ function sessionGrantAbortReason(signal) {
   return error;
 }
 function parseSessionGrantResponse(value, expectedSessionId) {
-  if (!isRecord12(value) || value.ok !== true || value.sessionId !== expectedSessionId) return null;
+  if (!isRecord15(value) || value.ok !== true || value.sessionId !== expectedSessionId) return null;
   if (value.usageMode !== void 0 && value.usageMode !== "session") return null;
   if (value.billingEnabled !== void 0 && value.billingEnabled !== false) return null;
   if (value.disposition !== void 0 && value.disposition !== "ordinary" && value.disposition !== "unbilled_fail_open") {
@@ -18788,11 +19313,11 @@ function parseSessionGrantResponse(value, expectedSessionId) {
   }
   return value;
 }
-function isRecord12(value) {
+function isRecord15(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRuntimeRecord(value) {
-  if (!isRecord12(value)) return false;
+  if (!isRecord15(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -19465,10 +19990,10 @@ var tileflowIconCompositionSchema = z13.object({
     })
   ).min(1).max(tileflowIconPackageLimits.maxIconCount)
 }).strict().superRefine((receipt, context) => {
-  const version = receipt.winners.some(
+  const version2 = receipt.winners.some(
     (winner) => winner.appearance !== void 0 || winner.layout !== void 0
   ) ? 2 : 1;
-  if (receipt.compositionVersion !== version || receipt.format !== `tileflow-icon-composition-v${version}`)
+  if (receipt.compositionVersion !== version2 || receipt.format !== `tileflow-icon-composition-v${version2}`)
     context.addIssue({
       code: "custom",
       path: ["compositionVersion"],
@@ -19574,6 +20099,164 @@ var tileflowIconSpriteIndexSchema = z14.record(tileflowIconIdSchema, tileflowIco
   (index) => Object.keys(index).length > 0 && Object.keys(index).length <= tileflowIconPackageLimits.maxIconCount,
   `A generated sprite index must contain 1 through ${tileflowIconPackageLimits.maxIconCount} icons`
 );
+
+// src/trees-3d-mesh.ts
+var tileflowTreeParts = { bark: 0, leaves: 1, fronds: 2, stem: 3 };
+var golden = (1 + Math.sqrt(5)) / 2;
+var icosahedron = {
+  corners: [
+    [-1, golden, 0],
+    [1, golden, 0],
+    [-1, -golden, 0],
+    [1, -golden, 0],
+    [0, -1, golden],
+    [0, 1, golden],
+    [0, -1, -golden],
+    [0, 1, -golden],
+    [golden, 0, -1],
+    [golden, 0, 1],
+    [-golden, 0, -1],
+    [-golden, 0, 1]
+  ].map((corner) => normalize(corner)),
+  faces: [
+    [0, 11, 5],
+    [0, 5, 1],
+    [0, 1, 7],
+    [0, 7, 10],
+    [0, 10, 11],
+    [1, 5, 9],
+    [5, 11, 4],
+    [11, 10, 2],
+    [10, 7, 6],
+    [7, 1, 8],
+    [3, 9, 4],
+    [3, 4, 2],
+    [3, 2, 6],
+    [3, 6, 8],
+    [3, 8, 9],
+    [4, 9, 5],
+    [2, 4, 11],
+    [6, 2, 10],
+    [8, 6, 7],
+    [9, 8, 1]
+  ]
+};
+function normalize(v) {
+  const size = Math.hypot(v[0], v[1], v[2]) || 1;
+  return [v[0] / size, v[1] / size, v[2] / size];
+}
+
+// src/trees-3d-model.ts
+var tileflowTreeModelLimits = Object.freeze({
+  /** Triangles of a near model, the one drawn close to the camera. */
+  nearTriangles: 1e3,
+  /** Triangles of a far model, drawn beyond the nearest tiles. */
+  farTriangles: 120,
+  /** Vertices of one model. */
+  vertices: 4096,
+  /** Models one map carries. */
+  models: 16,
+  /** Models one form draws from. */
+  perForm: 4
+});
+var magic = [84, 70, 84, 77];
+var version = 1;
+var headerBytes = 16;
+var vertexBytes = 12;
+var positionRange = 2;
+var partCount = Object.keys(tileflowTreeParts).length;
+function encodeTileflowTreeModel(mesh, level) {
+  const count = mesh.positions.length / 3;
+  const triangles = mesh.indices.length / 3;
+  const limit = level === "near" ? tileflowTreeModelLimits.nearTriangles : tileflowTreeModelLimits.farTriangles;
+  if (!Number.isInteger(count) || count < 3 || count > tileflowTreeModelLimits.vertices)
+    throw new RangeError(`A tree model has 3 to ${tileflowTreeModelLimits.vertices} vertices.`);
+  if (!Number.isInteger(triangles) || triangles < 1 || triangles > limit)
+    throw new RangeError(`A ${level} tree model has 1 to ${limit} triangles.`);
+  for (const list of [mesh.normals, mesh.positions])
+    if (list.length !== count * 3)
+      throw new RangeError("Every vertex needs a position and normal.");
+  for (const list of [mesh.parts, mesh.shades, mesh.occlusion])
+    if (list.length !== count) throw new RangeError("Every vertex needs a part, shade and light.");
+  const bytes = new Uint8Array(headerBytes + count * vertexBytes + mesh.indices.length * 2);
+  const view = new DataView(bytes.buffer);
+  bytes.set(magic, 0);
+  view.setUint16(4, version, true);
+  view.setUint16(6, count, true);
+  view.setUint32(8, mesh.indices.length, true);
+  view.setUint16(12, Math.round(clamp(mesh.proportion, 0.1, 3) * 1e3), true);
+  for (let index = 0; index < count; index += 1) {
+    const at = headerBytes + index * vertexBytes;
+    for (let axis = 0; axis < 3; axis += 1) {
+      const value = clamp(mesh.positions[index * 3 + axis] / positionRange, -1, 1);
+      view.setInt16(at + axis * 2, Math.round(value * 32767), true);
+      view.setInt8(at + 6 + axis, Math.round(clamp(mesh.normals[index * 3 + axis], -1, 1) * 127));
+    }
+    const part = mesh.parts[index];
+    if (!Number.isInteger(part) || part < 0 || part >= partCount)
+      throw new RangeError(`Vertex ${index} has no tree part.`);
+    bytes[at + 9] = part;
+    bytes[at + 10] = Math.round((clamp(mesh.shades[index], -1, 1) + 1) / 2 * 255);
+    bytes[at + 11] = Math.round(clamp(mesh.occlusion[index], 0, 1) * 255);
+  }
+  const indexAt = headerBytes + count * vertexBytes;
+  mesh.indices.forEach((vertex, index) => {
+    if (!Number.isInteger(vertex) || vertex < 0 || vertex >= count)
+      throw new RangeError(`Index ${index} names no vertex.`);
+    view.setUint16(indexAt + index * 2, vertex, true);
+  });
+  let text = "";
+  for (let at = 0; at < bytes.length; at += 32768)
+    text += String.fromCharCode(...bytes.subarray(at, at + 32768));
+  return btoa(text);
+}
+function decodeTileflowTreeModel(text, level) {
+  if (typeof text !== "string" || text.length > 2e5) return void 0;
+  let bytes;
+  try {
+    const binary = atob(text);
+    bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  } catch {
+    return void 0;
+  }
+  if (bytes.length < headerBytes || magic.some((byte, index) => bytes[index] !== byte))
+    return void 0;
+  const view = new DataView(bytes.buffer);
+  const count = view.getUint16(6, true);
+  const indexCount = view.getUint32(8, true);
+  const proportion = view.getUint16(12, true) / 1e3;
+  const limit = level === "near" ? tileflowTreeModelLimits.nearTriangles : tileflowTreeModelLimits.farTriangles;
+  if (view.getUint16(4, true) !== version || count < 3 || count > tileflowTreeModelLimits.vertices || indexCount < 3 || indexCount % 3 !== 0 || indexCount / 3 > limit || !(proportion >= 0.1 && proportion <= 3) || bytes.length !== headerBytes + count * vertexBytes + indexCount * 2)
+    return void 0;
+  const positions = [];
+  const normals = [];
+  const parts = [];
+  const shades = [];
+  const occlusion = [];
+  for (let index = 0; index < count; index += 1) {
+    const at = headerBytes + index * vertexBytes;
+    for (let axis = 0; axis < 3; axis += 1) {
+      positions.push(view.getInt16(at + axis * 2, true) / 32767 * positionRange);
+      normals.push(view.getInt8(at + 6 + axis) / 127);
+    }
+    if (bytes[at + 9] >= partCount) return void 0;
+    parts.push(bytes[at + 9]);
+    shades.push(bytes[at + 10] / 255 * 2 - 1);
+    occlusion.push(bytes[at + 11] / 255);
+  }
+  const indices = [];
+  const indexAt = headerBytes + count * vertexBytes;
+  for (let index = 0; index < indexCount; index += 1) {
+    const vertex = view.getUint16(indexAt + index * 2, true);
+    if (vertex >= count) return void 0;
+    indices.push(vertex);
+  }
+  return { proportion, positions, normals, parts, shades, occlusion, indices };
+}
+function clamp(value, low, high) {
+  return Number.isFinite(value) ? Math.min(high, Math.max(low, value)) : 0;
+}
 export {
   TileflowIconSetError,
   TileflowMapResolutionError,
@@ -19602,6 +20285,7 @@ export {
   createTileflowLineBackgroundFontStack,
   createTileflowSessionController,
   createTileflowSessionId,
+  decodeTileflowTreeModel,
   defaultTileflowManifestUrl,
   defaultTileflowRuntimeView,
   defineMap,
@@ -19610,6 +20294,7 @@ export {
   diffTileflowIconPackageManifests,
   diffTileflowMaps,
   disable,
+  encodeTileflowTreeModel,
   expr,
   field,
   fixed,
@@ -19658,8 +20343,11 @@ export {
   parseTileflowMap,
   parseTileflowRuntimeManifest,
   poi,
+  readTileflowBuildings3D,
   readTileflowIconLayout,
+  readTileflowStreetLights,
   readTileflowSunPreset,
+  readTileflowVegetation3D,
   refine,
   refineRenderTarget,
   remove,
@@ -19700,6 +20388,7 @@ export {
   tileflowBathymetryDemSourceId,
   tileflowBathymetrySourceId,
   tileflowBathymetryV1Schema,
+  tileflowBuildingsMetadataKey,
   tileflowCaptureApplicationTargetSchema,
   tileflowCaptureBoundsCameraSchema,
   tileflowCaptureCameraSchema,
@@ -19788,6 +20477,7 @@ export {
   tileflowRuntimeManifestSchema,
   tileflowRuntimeManifestVersion,
   tileflowSemanticDiffSchemaVersion,
+  tileflowStreetLightsMetadataKey,
   tileflowStyleFontFaceLimits,
   tileflowStyleFontFacesMetadataKey,
   tileflowStyleSunPreset,
@@ -19798,6 +20488,11 @@ export {
   tileflowThemeLimits,
   tileflowThemeNameSchema,
   tileflowThemeTokenCategories,
+  tileflowTreeForms,
+  tileflowTreeModelIdPattern,
+  tileflowTreeModelLimits,
+  tileflowTreeParts,
+  tileflowVegetationMetadataKey,
   tileflowWorld,
   tileflowWorldGeneration,
   tileflowWorldReleaseIdMaximumLength,