@tileflow/core 0.1.0-alpha.33 → 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 [];
@@ -4463,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,
@@ -4566,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;
@@ -4582,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;
@@ -4897,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,
@@ -5209,7 +5513,7 @@ function assertThemeLighting(value, path) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -5561,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;
 }
@@ -5757,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]
       }
     }
   };
@@ -5924,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])
         ]
       }
     }
@@ -7272,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) };
@@ -9054,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) {
@@ -9172,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)) } : {}
     })
   });
 }
@@ -9413,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));
 }
 
@@ -9479,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",
@@ -9540,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;
           }
@@ -9571,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) {
@@ -9903,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."
@@ -10106,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");
@@ -10133,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.`
@@ -10235,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);
@@ -10382,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));
 }
 
@@ -11408,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(),
@@ -11415,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"),
@@ -11528,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()
@@ -11616,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(),
@@ -11638,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,
@@ -11970,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),
@@ -12191,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(),
@@ -13099,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) {
@@ -14127,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",
@@ -14288,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)
@@ -14360,13 +14690,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]) => !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 } : {}
     }
   };
@@ -14418,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];
@@ -14452,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;
@@ -14473,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"]],
@@ -14563,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(",");
@@ -14579,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"];
@@ -14592,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) {
@@ -14618,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 });
@@ -15178,6 +15547,7 @@ var tileflowMapMergeStrategies = {
   icons: "icons",
   id: "identity",
   marine: "atomic",
+  models: "atomic",
   modules: "modules",
   name: "identity",
   overlays: "keyed-resources",
@@ -15523,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;
 }
@@ -16045,6 +16415,7 @@ async function hashTileflowMapRevision(input, sourceAssets) {
   const {
     fonts: _fonts,
     icons: _icons,
+    models: _models,
     id: _id,
     name: _name,
     version: _version,
@@ -16140,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}`;