@tileflow/maps 0.1.0-alpha.16 → 0.1.0-alpha.18

package/dist/index.js

@@ -8208,21 +8208,21 @@ import {
   addresses as addresses4,
   boundaries as boundaries7,
   buildings as buildings6,
-  defineMap as defineMap7,
-  expr as expr12,
-  field as field11,
+  defineMap as defineMap8,
+  expr as expr14,
+  field as field14,
   fixed as fixed3,
   labels as labels7,
   land as land7,
   poi as poi4,
-  refineRenderTarget as refineRenderTarget5,
-  renderPass as renderPass10,
+  refineRenderTarget as refineRenderTarget6,
+  renderPass as renderPass13,
   roads as roads6,
-  token as token9,
+  token as token13,
   transit as transit7,
   water as water7,
-  withRenderStack as withRenderStack10,
-  zoom as zoom10
+  withRenderStack as withRenderStack11,
+  zoom as zoom13
 } from "@tileflow/core";
 
 // src/official/mapbox-rail.ts
@@ -8286,16 +8286,406 @@ function mapboxRailTransitStyle(color) {
   };
 }
 
+// src/official/streets-cartography.ts
+import {
+  defineMap as defineMap7,
+  expr as expr10,
+  field as field10,
+  refineRenderTarget as refineRenderTarget5,
+  renderPass as renderPass10,
+  resolveMap,
+  token as token7,
+  withRenderStack as withRenderStack8,
+  zoom as zoom11
+} from "@tileflow/core";
+
+// src/official/streets-ground-and-access.ts
+import { expr as expr9, field as field8, renderPass as renderPass8, token as token5, zoom as zoom9 } from "@tileflow/core";
+var streetsDayGroundColors = {
+  "surface.background": "#F5F0E5",
+  "surface.background.overview": "#F8F7F3",
+  "surface.land": "#F8F7F3",
+  "landcover.global.barren": "#F8F7F3",
+  "landcover.barren": "#F5F0E5",
+  "landcover.rock": "#EEE9DF",
+  "landcover.farmland": "#F0EDE2",
+  "landcover.orchard": "#DDEAD4",
+  "landcover.nursery": "#D6E8D2",
+  "landcover.global.crop": "#EFF1E6",
+  "landcover.global.urban": "#F5F3F3",
+  "landuse.residential": "#F5F3F3",
+  "landuse.civic": "#F5F3F3",
+  "landuse.education": "#EFEEEC",
+  "landuse.government": "#F5F3F3",
+  "landuse.military": "#F5F3F3",
+  "roads.accessOverview": "#D7D3CE"
+};
+var streetsAgriculturalColor = expr9.match(
+  expr9.get(field8("subclass")),
+  [
+    { labels: "orchard", value: token5.color("landcover.orchard") },
+    { labels: "plant_nursery", value: token5.color("landcover.nursery") }
+  ],
+  token5.color("landcover.farmland")
+);
+var streetsGroundBackground = zoom9.linear([
+  [10, token5.color("surface.background.overview")],
+  [13, token5.color("surface.background.transition")],
+  [14, token5.color("surface.background")]
+]);
+var streetsAccessOverview = renderPass8({
+  placement: { below: "roads.classes.minor.surface.fill" },
+  feature: "road",
+  renderer: "line",
+  selector: {
+    kind: "all",
+    selectors: [
+      { kind: "geometry", geometry: "line" },
+      { kind: "in", field: "class", values: ["track", "service"] },
+      { kind: "compare", field: "brunnel", operator: "ne", value: "tunnel" }
+    ]
+  },
+  style: {
+    minZoom: 12,
+    maxZoom: 15,
+    cap: "round",
+    join: "round",
+    color: zoom9.linear([
+      [14, token5.color("roads.accessOverview")],
+      [15, token5.color("roads.default")]
+    ]),
+    opacity: zoom9.linear([
+      [12, 0.35],
+      [13, 0.8],
+      [14, 1]
+    ]),
+    width: zoom9.linear([
+      [12, 0.35],
+      [13, 0.55],
+      [14, 0.85],
+      [15, 2.2857142857142856]
+    ])
+  }
+});
+
+// src/official/streets-network-overview.ts
+import { field as field9, renderPass as renderPass9, token as token6, zoom as zoom10 } from "@tileflow/core";
+var streetsNetworkDayColors = {
+  "roads.city.primary": "#B1C4CB",
+  "roads.city.secondary": "#C3CFD3",
+  "roads.city.tertiary": "#CCD6D9",
+  "roads.city.minor": "#D2DADC",
+  "roads.overview.major": "#8DB3C0",
+  "roads.overview.majorClose": "#85A9B5",
+  "roads.overview.casing": "#668D9A",
+  "roads.overview.casingClose": "#658B97"
+};
+function overviewWidth(width, local) {
+  if (!width || typeof width !== "object" || width.kind !== "expression") {
+    throw new Error("Expected an authored road-width expression");
+  }
+  const value = structuredClone(width.value);
+  if (value[0] !== "interpolate") throw new Error("Expected interpolated road widths");
+  for (let i = 3; i < value.length; i += 2) {
+    const factor = value[i] === 10 ? 1.12 : value[i] === 12 ? local ? 1.125 : 1.25 : value[i] === 14 ? 1.08 : 1;
+    if (factor !== 1) {
+      const authored = value[i + 1];
+      value[i + 1] = ["case", ["==", ["get", field9("ramp")], 1], authored, ["*", authored, factor]];
+    }
+  }
+  return { ...width, value };
+}
+function streetsOverviewRoads(roads7) {
+  if (!roads7) throw new Error("The Streets overview requires the roads module");
+  const renderStack = "renderStack" in roads7 ? roads7.renderStack : {};
+  const classes = { ...roads7.classes };
+  for (const name of ["motorway", "trunk"]) {
+    const road = classes[name];
+    const color = zoom10.linear([
+      [3, token6.color(`roads.${name}`)],
+      [6, token6.color("roads.overview.major")],
+      [12, token6.color("roads.overview.major")],
+      [14, token6.color("roads.overview.majorClose")],
+      [14.25, token6.color("roads.overview.majorClose")],
+      [15, token6.color(`roads.${name}`)]
+    ]);
+    classes[name] = {
+      ...road,
+      surface: { ...road.surface, fill: { ...road.surface.fill, color } },
+      bridge: {
+        ...road.bridge,
+        fill: { ...road.bridge.fill, color },
+        casing: {
+          ...road.bridge.casing,
+          color: zoom10.linear([
+            [12, token6.color("roads.overview.casing")],
+            [14, token6.color("roads.overview.casingClose")],
+            [14.25, token6.color("roads.overview.casingClose")],
+            [15, token6.color("roads.detail.casing")]
+          ])
+        }
+      }
+    };
+  }
+  for (const name of ["primary", "secondary", "tertiary", "minor"]) {
+    const road = classes[name];
+    const local = name === "minor";
+    classes[name] = { ...road };
+    for (const structure of ["surface", "bridge", "tunnel"]) {
+      const base = road[structure];
+      classes[name][structure] = {
+        ...base,
+        fill: {
+          ...base.fill,
+          width: overviewWidth(base.fill.width, local),
+          // The tile source first provides local geometry at z12. Make it readable
+          // on arrival, then converge to the detailed opacity by z13.
+          ...local ? {
+            opacity: zoom10.linear([
+              [12, structure === "tunnel" ? 0.55 : 0.8],
+              [13, structure === "tunnel" ? 0.8 : 1]
+            ])
+          } : {}
+        }
+      };
+    }
+  }
+  return {
+    ...roads7,
+    classes,
+    renderStack: {
+      ...renderStack,
+      overviewMajorCasing: renderPass9({
+        // Keep the casing below every road fill, including trunk and ramp fills.
+        // Drawing it above those fills exposes round segment caps as small rings.
+        placement: { below: "roads.classes.minor.surface.casing" },
+        feature: "road",
+        renderer: "line",
+        selector: {
+          kind: "all",
+          selectors: [
+            { kind: "geometry", geometry: "line" },
+            { kind: "in", field: "class", values: ["motorway", "trunk"] },
+            { kind: "compare", field: "brunnel", operator: "ne", value: "tunnel" }
+          ]
+        },
+        style: {
+          minZoom: 6,
+          maxZoom: 15,
+          cap: "round",
+          join: "round",
+          color: zoom10.linear([
+            [12, token6.color("roads.overview.casing")],
+            [14, token6.color("roads.overview.casingClose")],
+            [14.25, token6.color("roads.overview.casingClose")],
+            [15, token6.color("roads.detail.casing")]
+          ]),
+          gapWidth: roads7.classes.motorway.surface.fill.width,
+          width: zoom10.linear([
+            [6, 0.2],
+            [8, 0.4],
+            [10, 0.65],
+            [12, 0.8],
+            [14, 0.95],
+            [15, 1.0203013481363996]
+          ]),
+          opacity: zoom10.linear([
+            [6, 0.3],
+            [8, 0.8],
+            [10, 1]
+          ])
+        }
+      })
+    }
+  };
+}
+
+// src/official/streets-cartography.ts
+var visibleBuilding = {
+  kind: "all",
+  selectors: [
+    { field: "hide3d", kind: "compare", operator: "ne", value: true },
+    { field: "hide3d", kind: "compare", operator: "ne", value: 1 },
+    { field: "hide3d", kind: "compare", operator: "ne", value: "1" },
+    { field: "hide3d", kind: "compare", operator: "ne", value: "true" }
+  ]
+};
+function buildingColor2(outline = false, raised = false) {
+  return expr10.match(
+    expr10.get(field10("buildingTone")),
+    [
+      {
+        labels: ["commercial", "active"],
+        value: token7.color(`buildings.flat.${outline ? "activeOutline" : "active"}`)
+      }
+    ],
+    token7.color(
+      raised ? "buildings.raised.neutral" : `buildings.flat.${outline ? "neutralOutline" : "neutral"}`
+    )
+  );
+}
+function withStreetsCartography(base) {
+  const source = resolveMap(base);
+  const { land: land8, buildings: buildings7, poi: poi5, vegetation: vegetation6 } = source.modules ?? {};
+  if (!land8 || !buildings7 || !poi5 || !vegetation6)
+    throw new Error("Streets requires land, buildings, POI and vegetation");
+  const vegetationAppearance = {
+    ...vegetation6,
+    flat: { ...vegetation6.flat, strokeColor: token7.color("vegetation.tree.outline") }
+  };
+  const landStack = stackOf(land8);
+  const buildingStack = stackOf(buildings7);
+  const extrusion = buildingStack.extrusion;
+  if (extrusion?.kind !== "render-pass" || extrusion.renderer !== "extrusion")
+    throw new Error("Streets requires its building extrusion pass");
+  const { renderStack: roadsStack, ...overviewRoads } = streetsOverviewRoads(source.modules?.roads);
+  return defineMap7({
+    ...base,
+    modules: {
+      ...source.modules,
+      roads: withRenderStack8(
+        {
+          ...overviewRoads,
+          pathGround: {
+            greenColor: token7.color("roads.path.green"),
+            groundColor: token7.color("roads.path.ground"),
+            opacity: token7.number("roads.path.groundOpacity"),
+            widthScale: 0.92
+          }
+        },
+        {
+          ...roadsStack,
+          accessOverview: streetsAccessOverview
+        }
+      ),
+      land: withRenderStack8(
+        {
+          ...withoutStack(land8),
+          // The climate underlay is paused until it has a shared URL and visibility-aware loading.
+          // Its source, generator and attribution are retained in assets/streets/climate.
+          background: { ...land8.background, color: streetsGroundBackground },
+          landcover: {
+            ...land8.landcover,
+            farmland: {
+              ...land8.landcover?.farmland,
+              fill: { ...land8.landcover?.farmland?.fill, color: streetsAgriculturalColor }
+            }
+          }
+        },
+        {
+          ...landStack,
+          businessArea: renderPass10({
+            placement: { above: "land.landuse.residential.fill" },
+            feature: "landuse",
+            renderer: "fill",
+            selector: { field: "class", kind: "compare", operator: "eq", value: "business_area" },
+            style: {
+              color: token7.color("landuse.businessCorridor"),
+              minZoom: 11,
+              opacity: zoom11.linear([
+                [15, 1],
+                [15.5, 0.75],
+                [16.25, 0]
+              ])
+            }
+          })
+        }
+      ),
+      buildings: withRenderStack8(
+        {
+          ...withoutStack(buildings7),
+          flat: {
+            fill: {
+              color: buildingColor2(),
+              minZoom: 15.25,
+              opacity: zoom11.linear([
+                [15.25, 0],
+                [15.5, 0.75],
+                [15.75, 1]
+              ])
+            },
+            outline: {
+              color: buildingColor2(true),
+              minZoom: 16,
+              opacity: zoom11.linear([
+                [16, 0],
+                [16.5, 0.4],
+                [18, 0.58],
+                [20, 0.68]
+              ]),
+              width: zoom11.linear([
+                [16, 0.35],
+                [16.5, 0.5],
+                [18, 0.65],
+                [20, 0.8]
+              ])
+            }
+          }
+        },
+        {
+          ...buildingStack,
+          visibleFlatFill: refineRenderTarget5({
+            target: "buildings.flat.fill",
+            renderer: "fill",
+            selector: visibleBuilding,
+            style: {}
+          }),
+          visibleFlatOutline: refineRenderTarget5({
+            target: "buildings.flat.outline",
+            renderer: "line",
+            selector: visibleBuilding,
+            style: {}
+          }),
+          extrusion: { ...extrusion, style: { ...extrusion.style, color: buildingColor2(false, true) } },
+          flatShadow: renderPass10({
+            selector: visibleBuilding,
+            placement: { below: "buildings.flat.fill" },
+            feature: "building",
+            renderer: "line",
+            style: {
+              blur: 2,
+              color: token7.color("buildings.shadow"),
+              minZoom: 17.5,
+              opacity: zoom11.linear([
+                [17.5, 0],
+                [19, 0.035],
+                [20, 0.04]
+              ]),
+              translate: [0.5, 0.75],
+              translateAnchor: "viewport",
+              width: zoom11.linear([
+                [17.5, 0.5],
+                [19, 1.5],
+                [20, 2]
+              ])
+            }
+          })
+        }
+      ),
+      vegetation: vegetationAppearance,
+      poi: { ...poi5, maxRankByType: { ...poi5.maxRankByType, garden: 1 } }
+    }
+  });
+}
+function stackOf(module) {
+  return "renderStack" in module ? module.renderStack : {};
+}
+function withoutStack(module) {
+  const result = { ...module };
+  if ("renderStack" in result) delete result.renderStack;
+  return result;
+}
+
 // src/official/streets-construction.ts
 import {
-  expr as expr9,
-  field as field8,
-  renderPass as renderPass8,
-  token as token5,
-  withRenderStack as withRenderStack8
+  expr as expr11,
+  field as field11,
+  renderPass as renderPass11,
+  token as token8,
+  withRenderStack as withRenderStack9
 } from "@tileflow/core";
 function withStreetsConstruction(module, stack) {
-  const constructionPath = expr9.eq(expr9.get(field8("class")), "path_construction");
+  const constructionPath = expr11.eq(expr11.get(field11("class")), "path_construction");
   const marks = Object.fromEntries(
     [
       "motorway",
@@ -8331,14 +8721,14 @@ function withStreetsConstruction(module, stack) {
       return [
         [
           `construction-${roadClass}-underlay`,
-          renderPass8({
+          renderPass11({
             feature: "road",
             placement: "below-roads",
             selector,
             renderer: "line",
             style: {
               ...fill,
-              color: token5.color("roads.default"),
+              color: token8.color("roads.default"),
               dash: [1, 0],
               opacity: 0.16
             }
@@ -8346,7 +8736,7 @@ function withStreetsConstruction(module, stack) {
         ],
         [
           `construction-${roadClass}`,
-          renderPass8({
+          renderPass11({
             feature: "road",
             placement: "below-roads",
             selector,
@@ -8357,7 +8747,7 @@ function withStreetsConstruction(module, stack) {
               minZoom: Math.max(fill.minZoom ?? 0, 14),
               cap: "butt",
               join: "round",
-              color: token5.color("roads.default"),
+              color: token8.color("roads.default"),
               // Short transverse strokes with flat ends avoid the former round capsules.
               dash: [0.1, 0.18],
               opacity: 0.9
@@ -8367,7 +8757,7 @@ function withStreetsConstruction(module, stack) {
       ];
     })
   );
-  return withRenderStack8(
+  return withRenderStack9(
     {
       ...module,
       modifiers: {
@@ -8378,14 +8768,14 @@ function withStreetsConstruction(module, stack) {
             // its dash expression otherwise forces ordinary borders through the SDF shader.
             casing: { dash: [1, 0], opacity: 0 },
             fill: {
-              color: token5.color("roads.default"),
+              color: token8.color("roads.default"),
               // Footpaths keep their existing treatment; hatching is for carriageways.
-              dash: expr9.case(
-                [{ when: constructionPath, value: expr9.literal([1.5, 1]) }],
-                expr9.literal([1, 0])
+              dash: expr11.case(
+                [{ when: constructionPath, value: expr11.literal([1.5, 1]) }],
+                expr11.literal([1, 0])
               ),
               // The separate underlay supplies carriageway ground below all live roads.
-              opacity: expr9.case([{ when: constructionPath, value: 0.96 }], 0)
+              opacity: expr11.case([{ when: constructionPath, value: 0.96 }], 0)
             }
           }
         }
@@ -8397,9 +8787,9 @@ function withStreetsConstruction(module, stack) {
 
 // src/official/streets-poi.ts
 import {
-  expr as expr10,
-  field as field9,
-  token as token6
+  expr as expr12,
+  field as field12,
+  token as token9
 } from "@tileflow/core";
 
 // src/official/streets-transit-icons.ts
@@ -8652,7 +9042,7 @@ var streetsPoiCategoryPictograms = Object.freeze({
   "visitor-amenity": "services"
 });
 function streetsPoiPictogramToken(id) {
-  return token6.image(`poi.pictogram.${id}`);
+  return token9.image(`poi.pictogram.${id}`);
 }
 function streetsPoiImageTokens(variant) {
   const suffix = {
@@ -8679,11 +9069,11 @@ function streetsPoiImage() {
       value: streetsPoiPictogramToken(id)
     }));
     const [first, ...rest] = types;
-    const categoryRole = token6.image(`poi.${category}`);
+    const categoryRole = token9.image(`poi.${category}`);
     return {
       labels: category,
-      value: first ? expr10.match(
-        expr10.get(field9("poiType")),
+      value: first ? expr12.match(
+        expr12.get(field12("poiType")),
         [first, ...rest],
         categoryRole
       ) : categoryRole
@@ -8694,25 +9084,25 @@ function streetsPoiImage() {
     labels: [...labels8],
     value: streetsPoiPictogramToken(id)
   }));
-  const genericImage = expr10.match(
-    expr10.get(field9("mode")),
+  const genericImage = expr12.match(
+    expr12.get(field12("mode")),
     [firstMode, ...otherModes],
-    expr10.match(
-      expr10.get(field9("poiCategory")),
+    expr12.match(
+      expr12.get(field12("poiCategory")),
       [firstCategory, ...otherCategories],
-      token6.image("poi.landmark")
+      token9.image("poi.landmark")
     )
   );
   const [firstNetwork, ...otherNetworks] = streetsTransitNetworks.map(({ id, networks }) => ({
     labels: [...networks],
-    value: token6.image(`poi.network.${id}`)
+    value: token9.image(`poi.network.${id}`)
   }));
-  return expr10.case(
+  return expr12.case(
     [
       {
-        when: expr10.eq(expr10.get(field9("poiCategory")), "transport"),
-        value: expr10.match(
-          expr10.get(field9("network")),
+        when: expr12.eq(expr12.get(field12("poiCategory")), "transport"),
+        value: expr12.match(
+          expr12.get(field12("network")),
           [firstNetwork, ...otherNetworks],
           genericImage
         )
@@ -8723,18 +9113,22 @@ function streetsPoiImage() {
 }
 
 // src/official/streets-themes.ts
-import { defineTheme as defineTheme3, token as token7 } from "@tileflow/core";
+import { defineTheme as defineTheme4, token as token11 } from "@tileflow/core";
 
 // src/official/streets-building-colors.ts
-function streetsBuildingColors(base, dark) {
+function streetsBuildingColors(base, dark, monochrome = false) {
   const rgb = [1, 3, 5].map((offset) => parseInt(base.slice(offset, offset + 2), 16));
-  const gray = rgb.reduce((sum, value) => sum + value, 0) / 3;
   const hex2 = (values) => "#" + values.map((v) => Math.round(v).toString(16).padStart(2, "0")).join("").toUpperCase();
   return {
     "buildings.modelSurface": base,
-    "buildings.modelSecondary": hex2(rgb.map((v) => v + (255 - v) * (dark ? 0.018 : 0.24))),
-    "buildings.modelRoof": hex2(rgb.map((v) => (v * 0.8 + gray * 0.2) * 0.97)),
-    "buildings.modelAccent": hex2(rgb.map((v) => v + (255 - v) * (dark ? 0.025 : 0.34)))
+    "buildings.modelGlass": hex2(
+      rgb.map((v, channel) => v * (monochrome ? 0.86 : [0.78, 0.88, 0.95][channel]))
+    ),
+    "buildings.modelSecondary": hex2(rgb.map((v) => v + (255 - v) * (dark ? 0.018 : 0.2))),
+    "buildings.modelRoof": hex2(
+      rgb.map((v, channel) => v * (monochrome ? 0.92 : [0.94, 0.92, 0.9][channel]))
+    ),
+    "buildings.modelAccent": hex2(rgb.map((v) => v + (255 - v) * (dark ? 0.025 : 0.4)))
   };
 }
 
@@ -9965,10 +10359,453 @@ var rows = [
 function streetsCartographyColors(theme, preset) {
   const column = profiles.indexOf(`${theme}-${preset}`);
   return Object.fromEntries(
-    rows.flatMap(([roles, colors]) => roles.split(" ").map((role) => [role, colors[column]]))
+    rows.flatMap(([roles, colors2]) => roles.split(" ").map((role) => [role, colors2[column]]))
   );
 }
 
+// src/official/streets-cartography-themes.ts
+import { defineTheme as defineTheme3, resolveTileflowTheme as resolveTileflowTheme3, token as token10 } from "@tileflow/core";
+
+// src/official/streets-day-colors.ts
+var streetsDayColors = {
+  "boundaries.admin": "#FF668C",
+  "boundaries.default": "#FF668C",
+  "boundaries.disputed": "#FF668C",
+  "boundaries.halo": "#FFFFFF",
+  "boundaries.major": "#FF668C",
+  "boundaries.maritime": "#FF668C",
+  "boundaries.regional": "#FF809A",
+  "buildings.active": "#EBECDE",
+  "buildings.businessCorridor": "#F9EFDD",
+  "buildings.businessCorridorOutline": "#D7D1C2",
+  "buildings.civic": "#EBECDE",
+  "buildings.commercial": "#EBECDE",
+  "buildings.contactShadow": "#888378",
+  "buildings.destination": "#EBECDE",
+  "buildings.extrusion": "#EFEBDE",
+  "buildings.fill": "#EBECDE",
+  "buildings.flat.active": "#EFEBDE",
+  "buildings.flat.activeOutline": "#D8CEBE",
+  "buildings.flat.neutral": "#E7EBEA",
+  "buildings.flat.neutralOutline": "#D3DAD8",
+  "buildings.floodLight": "#FFFFFF",
+  "buildings.generic": "#EBECDE",
+  "buildings.industrial": "#EBECDE",
+  "buildings.modelEmission": "#FFFFFF",
+  "buildings.modelRoof": "#FAF3E7",
+  "buildings.modelVegetation": "#9CD1B0",
+  "buildings.modelWater": "#91DFF7",
+  "buildings.modelWood": "#BED4B5",
+  "buildings.outline": "#CEC89B",
+  "buildings.residential": "#EBECDE",
+  "buildings.shadow": "#B5B9B4",
+  "hydro.depth.m0": "rgba(145, 223, 247, 0.35)",
+  "hydro.depth.m200": "rgba(100, 209, 247, 0.35)",
+  "hydro.depth.m2000": "rgba(89, 205, 247, 0.35)",
+  "hydro.depth.m7000": "rgba(51, 196, 248, 0.35)",
+  "hydro.ferry": "#2FA0E6",
+  "hydro.label": "#0094DC",
+  "hydro.ocean": "#91DFF7",
+  "hydro.water": "#91DFF7",
+  "hydro.water.overview": "#91DFF7",
+  "hydro.water.regional": "#91DFF7",
+  "hydro.waterway": "#91DFF7",
+  "labels.address": "#808080",
+  "labels.aerodrome": "#195DCC",
+  "labels.country": "#000000",
+  "labels.ferry": "#0185D7",
+  "labels.ferryHalo": "#92E0F8",
+  "labels.halo": "#FFFFFF",
+  "labels.muted": "#61615F",
+  "labels.neighborhood": "#61615F",
+  "labels.overview": "#61615F",
+  "labels.placeHalo": "#FFFFFF",
+  "labels.poi": "#50717F",
+  "labels.primary": "#61615F",
+  "labels.road": "#404040",
+  "labels.roadHalo": "#F2F2F2",
+  "labels.settlement": "#000000",
+  "labels.shield.dark": "#171E27",
+  "labels.shield.light": "#FFFFFF",
+  "labels.strong": "#404040",
+  "labels.water": "#0094DC",
+  "labels.waterHalo": "rgba(240, 242, 238, 0.72)",
+  "land.fence": "#D8D8D8",
+  "land.wall": "#C3C7C2",
+  "landcover.barren": "#F9FAF8",
+  "landcover.farmland": "#D0F1DC",
+  "landcover.flowerbed": "#A5E9B9",
+  "landcover.global.barren": "#F9FAF8",
+  "landcover.global.crop": "#C9F2D0",
+  "landcover.global.grass": "#D9F5DA",
+  "landcover.global.shrub": "#ECFAF2",
+  "landcover.global.snow": "#FEFEFE",
+  "landcover.global.trees": "#B7F0C9",
+  "landcover.global.urban": "#F0F2EE",
+  "landcover.grass": "#ABEFBF",
+  "landcover.greenspace": "#A5E9B9",
+  "landcover.greenspaceDark": "#A5E9B9",
+  "landcover.hedge": "#90C59C",
+  "landcover.hedgeShade": "#6F9F7A",
+  "landcover.ice": "#E7F5F7",
+  "landcover.meadow": "#ABEFBF",
+  "landcover.protected": "rgba(198, 227, 208, 0.5)",
+  "landcover.recreationGround": "#A5E9B9",
+  "landcover.rock": "#F9FAF8",
+  "landcover.sand": "#E8EEC6",
+  "landcover.scrub": "#ABEFBF",
+  "landcover.urbanPark": "#A5E9B9",
+  "landcover.villageGreen": "#ABEFBF",
+  "landcover.wetland": "#C1F2CF",
+  "landcover.wood": "#9BE1AF",
+  "landuse.businessCorridor": "#F9EFDD",
+  "landuse.businessCorridorOutline": "#E0DAC9",
+  "landuse.cemetery": "#BCECCB",
+  "landuse.civic": "#F0F2EE",
+  "landuse.commercial": "#F9EFDD",
+  "landuse.education": "#E7E8D2",
+  "landuse.government": "#F0F2EE",
+  "landuse.industrial": "#E4EAE9",
+  "landuse.medical": "#F3E0D9",
+  "landuse.military": "#F0F2EE",
+  "landuse.parking": "#E8EEC6",
+  "landuse.parkingOutline": "#E8EEC6",
+  "landuse.railway": "#E4EAE9",
+  "landuse.recreation": "#C5F6CE",
+  "landuse.recreationOutline": "#8AE6A7",
+  "landuse.residential": "#F0F2EE",
+  "poi.arts-entertainment": "#D6239F",
+  "poi.education": "#8A6529",
+  "poi.food-drink": "#BB5B00",
+  "poi.halo": "#FFFFFF",
+  "poi.icon": "#50717F",
+  "poi.label": "#50717F",
+  "poi.landmark": "#D6239F",
+  "poi.lodging": "#5C50E8",
+  "poi.medical": "#E32A1B",
+  "poi.park-nature": "#1B7A1D",
+  "poi.public-services": "#50717F",
+  "poi.religion": "#50717F",
+  "poi.retail": "#007AC6",
+  "poi.sport-leisure": "#008291",
+  "poi.transport": "#195DCC",
+  "poi.visitor-amenity": "#50717F",
+  "roads.bridge": "#B9CED5",
+  "roads.casing": "#8DB0BC",
+  "roads.city.casing": "#8DB0BC",
+  "roads.city.minor": "#DDE2E5",
+  "roads.city.primary": "#D5DBDF",
+  "roads.city.secondary": "#DEE3E6",
+  "roads.city.tertiary": "#E3E7E9",
+  "roads.city.tunnel": "#DEE7E9",
+  "roads.city.tunnelCasing": "#8DB0BC",
+  "roads.cycleway": "#61CD72",
+  "roads.default": "#B9CED5",
+  "roads.default.casing": "#8DB0BC",
+  "roads.default.tunnel": "#DEE7E9",
+  "roads.detail.casing": "#8AA7B0",
+  "roads.ferry": "#2FA0E6",
+  "roads.major": "#A4BCC4",
+  "roads.minor": "#B9CED5",
+  "roads.motorway": "#A4BCC4",
+  "roads.motorway.casing": "#759AA6",
+  "roads.motorway.tunnel": "#C5D4D8",
+  "roads.parkPath": "#E7ECF0",
+  "roads.path": "#E7ECF0",
+  "roads.path.casing": "#C9C9C1",
+  "roads.path.transition": "#F5F7F7",
+  "roads.path.tunnel": "#EEF2F3",
+  "roads.pedestrian.surface": "#F6F6F4",
+  "roads.primary": "#A4BCC4",
+  "roads.rail": "#A5A5A5",
+  "roads.railTransit": "#A5A5A5",
+  "roads.secondary": "#B9CED5",
+  "roads.sidewalk.surface": "rgba(0, 0, 0, 0.06)",
+  "roads.tertiary": "#B9CED5",
+  "roads.trunk": "#A4BCC4",
+  "roads.trunk.casing": "#6293A3",
+  "roads.trunk.tunnel": "#C1D1D6",
+  "roads.tunnel": "#D8E2E2",
+  "sky.color": "#4AA0E2",
+  "sky.glow": "#F5EBB9",
+  "sky.horizon": "#D9EDF3",
+  "surface.background": "#F0F2EE",
+  "surface.background.overview": "#F0F2EE",
+  "surface.building": "#EBECDE",
+  "surface.land": "#F0F2EE",
+  "surface.park": "#A5E9B9",
+  "surface.water": "#91DFF7",
+  "terrain.hillshade.accent": "#A0AD95",
+  "terrain.hillshade.highlight": "#FFFFFF",
+  "terrain.hillshade.shadow": "#6D7C68",
+  "transit.primary": "#A5A5A5",
+  "transit.rail": "#A5A5A5",
+  "vegetation.tree.bark": "#BED4B5",
+  "vegetation.tree.broadleaf.a": "#87BFA8",
+  "vegetation.tree.broadleaf.b": "#9CD1B0",
+  "vegetation.tree.broadleaf.c": "#ABDDA9",
+  "vegetation.tree.broadleaf.d": "#B8E6C4",
+  "vegetation.tree.conifer.a": "#80B098",
+  "vegetation.tree.conifer.b": "#8EBDA1",
+  "vegetation.tree.conifer.c": "#9CCDAD"
+};
+var streetsDayImages = {
+  "poi.education": "unified-day-education",
+  "poi.food-drink": "unified-day-food",
+  "poi.lodging": "unified-day-lodging",
+  "poi.medical": "unified-day-doctor",
+  "poi.park-nature": "unified-day-nature",
+  "poi.pictogram.aerialway": "unified-day-aerialway",
+  "poi.pictogram.airport": "unified-day-airport",
+  "poi.pictogram.bank": "unified-day-bank",
+  "poi.pictogram.bar": "unified-day-bar",
+  "poi.pictogram.beach": "unified-day-beach",
+  "poi.pictogram.beauty": "unified-day-beauty",
+  "poi.pictogram.bookstore": "unified-day-bookstore",
+  "poi.pictogram.buddhist": "unified-day-buddhist",
+  "poi.pictogram.bus": "unified-day-bus",
+  "poi.pictogram.campsite": "unified-day-campsite",
+  "poi.pictogram.car": "unified-day-car",
+  "poi.pictogram.car-repair": "unified-day-car-repair",
+  "poi.pictogram.charging-station": "unified-day-charging-station",
+  "poi.pictogram.christian": "unified-day-christian",
+  "poi.pictogram.clothing": "unified-day-clothing",
+  "poi.pictogram.coffee": "unified-day-coffee",
+  "poi.pictogram.college": "unified-day-college",
+  "poi.pictogram.community": "unified-day-community",
+  "poi.pictogram.convenience": "unified-day-convenience",
+  "poi.pictogram.dentist": "unified-day-dentist",
+  "poi.pictogram.doctor": "unified-day-doctor",
+  "poi.pictogram.dog-park": "unified-day-dog-park",
+  "poi.pictogram.drinking-water": "unified-day-drinking-water",
+  "poi.pictogram.education": "unified-day-education",
+  "poi.pictogram.electronics": "unified-day-electronics",
+  "poi.pictogram.embassy": "unified-day-embassy",
+  "poi.pictogram.fast-food": "unified-day-fast-food",
+  "poi.pictogram.ferry": "unified-day-ferry",
+  "poi.pictogram.fire-station": "unified-day-fire-station",
+  "poi.pictogram.fitness": "unified-day-fitness",
+  "poi.pictogram.florist": "unified-day-florist",
+  "poi.pictogram.food": "unified-day-food",
+  "poi.pictogram.fuel": "unified-day-fuel",
+  "poi.pictogram.garden": "unified-day-garden",
+  "poi.pictogram.golf": "unified-day-golf",
+  "poi.pictogram.grocery": "unified-day-grocery",
+  "poi.pictogram.harbor": "unified-day-harbor",
+  "poi.pictogram.hardware": "unified-day-hardware",
+  "poi.pictogram.health": "unified-day-health",
+  "poi.pictogram.jewish": "unified-day-jewish",
+  "poi.pictogram.laundry": "unified-day-laundry",
+  "poi.pictogram.library": "unified-day-library",
+  "poi.pictogram.lodging": "unified-day-lodging",
+  "poi.pictogram.major-transit": "unified-day-major-transit",
+  "poi.pictogram.mountain": "unified-day-mountain",
+  "poi.pictogram.muslim": "unified-day-muslim",
+  "poi.pictogram.natural": "unified-day-natural",
+  "poi.pictogram.nature": "unified-day-nature",
+  "poi.pictogram.parking": "unified-day-parking",
+  "poi.pictogram.parking-garage": "unified-day-parking-garage",
+  "poi.pictogram.pharmacy": "unified-day-pharmacy",
+  "poi.pictogram.playground": "unified-day-playground",
+  "poi.pictogram.plaza": "unified-day-plaza",
+  "poi.pictogram.police": "unified-day-police",
+  "poi.pictogram.post": "unified-day-post",
+  "poi.pictogram.prison": "unified-day-prison",
+  "poi.pictogram.rail": "unified-day-rail",
+  "poi.pictogram.rail-light": "unified-day-rail-light",
+  "poi.pictogram.services": "unified-day-services",
+  "poi.pictogram.shopping": "unified-day-shopping",
+  "poi.pictogram.sport": "unified-day-sport",
+  "poi.pictogram.stadium": "unified-day-stadium",
+  "poi.pictogram.swimming": "unified-day-swimming",
+  "poi.pictogram.toilet": "unified-day-toilet",
+  "poi.pictogram.town-hall": "unified-day-town-hall",
+  "poi.pictogram.waterfall": "unified-day-waterfall",
+  "poi.pictogram.worship": "unified-day-worship",
+  "poi.public-services": "unified-day-town-hall",
+  "poi.religion": "unified-day-worship",
+  "poi.retail": "unified-day-shopping",
+  "poi.sport-leisure": "unified-day-sport",
+  "poi.transport": "unified-day-major-transit",
+  "poi.visitor-amenity": "unified-day-services"
+};
+
+// src/official/streets-time-colors.ts
+function parse(value) {
+  if (value.startsWith("#")) {
+    const hex2 = value.slice(1);
+    const expanded = hex2.length < 5 ? [...hex2].map((digit) => digit + digit).join("") : hex2;
+    return {
+      rgb: [0, 2, 4].map((offset) => parseInt(expanded.slice(offset, offset + 2), 16)),
+      alpha: expanded.length === 8 ? parseInt(expanded.slice(6), 16) / 255 : 1
+    };
+  }
+  const channels2 = value.match(/[\d.]+/g)?.map(Number);
+  if (!channels2 || channels2.length < 3) throw new Error(`Unsupported Streets color: ${value}`);
+  return { rgb: channels2.slice(0, 3), alpha: channels2[3] ?? 1 };
+}
+var gray = (rgb) => rgb[0] * 0.2126 + rgb[1] * 0.7152 + rgb[2] * 0.0722;
+function transfer(value, from, to) {
+  return to < from ? value * (to / from) : from < 255 ? value + (255 - value) * ((to - from) / (255 - from)) : value;
+}
+function referenceRole(role) {
+  if (/^buildings\.(?:raised\.|model(?:Surface|Glass|Secondary|Roof|Accent)$)/.test(role))
+    return "buildings.extrusion";
+  if (role.startsWith("buildings.flat."))
+    return role.endsWith("Outline") ? "buildings.outline" : "buildings.extrusion";
+  if (role === "buildings.modelWater") return "hydro.water";
+  if (role === "buildings.modelVegetation") return "vegetation.tree.broadleaf.b";
+  if (role === "buildings.modelWood") return "vegetation.tree.bark";
+  if (role === "vegetation.tree.outline") return "surface.park";
+  if (role.startsWith("roads.overview."))
+    return role.includes("casing") ? "roads.detail.casing" : "roads.motorway";
+  if (role === "roads.accessOverview") return "roads.default";
+  if (role === "roads.path.ground" || role === "roads.path.green") return "roads.path";
+  if (role === "surface.background.transition") return "surface.background";
+  if (role === "landcover.orchard" || role === "landcover.nursery") return "landcover.greenspace";
+  return role;
+}
+function streetsTimeColors(day, referenceDay, referenceTime, monochrome, preset) {
+  const temperature = {
+    day: [1, 1, 1],
+    dawn: [1.035, 1, 0.93],
+    dusk: [1.045, 1, 0.97],
+    night: [0.92, 0.97, 1.06]
+  }[preset];
+  return Object.fromEntries(
+    Object.entries(day).map(([role, value]) => {
+      if (role.startsWith("sky.") || /^(?:buildings\.(?:floodLight|modelEmission))$/.test(role))
+        return [role, referenceTime[role] ?? value];
+      if (role.startsWith("labels.shield.") || role === "roads.sidewalk.surface")
+        return [role, referenceTime[role] ?? value];
+      const anchor = referenceRole(role);
+      const from = referenceDay[anchor];
+      const to = referenceTime[anchor];
+      if (!from || !to) throw new Error(`Missing Streets time-of-day anchor: ${role}`);
+      const color = parse(value);
+      if (role === "labels.waterHalo") color.alpha = parse(to).alpha;
+      const source = parse(from).rgb;
+      const target = parse(to).rgb;
+      const rgb = monochrome ? Array(3).fill(transfer(gray(color.rgb), gray(source), gray(target))) : color.rgb.map(
+        (channel, i) => transfer(channel, gray(source), gray(target)) * temperature[i]
+      );
+      const channels2 = rgb.map((channel) => Math.round(Math.max(0, Math.min(255, channel))));
+      return [
+        role,
+        color.alpha < 1 ? `rgba(${channels2.join(", ")}, ${color.alpha})` : "#" + channels2.map((channel) => channel.toString(16).padStart(2, "0")).join("").toUpperCase()
+      ];
+    })
+  );
+}
+
+// src/official/streets-cartography-themes.ts
+var palettes = {
+  day: ["#E8EAED", "#F3E9DF", "#D5D8DD", "#DDCCC0"],
+  dawn: ["#E9E6E8", "#F6EDDF", "#D7D2D5", "#E2D4C2"],
+  dusk: ["#383B46", "#474238", "#494D59", "#605746"],
+  night: ["#2B2F3A", "#37352F", "#3A404D", "#4D483C"]
+};
+function colors(name) {
+  const preset = name.startsWith("dark") ? "night" : name.startsWith("dusk") ? "dusk" : name.startsWith("dawn") ? "dawn" : "day";
+  const values = palettes[preset].map((hex2) => {
+    let rgb = [1, 3, 5].map((offset) => parseInt(hex2.slice(offset, offset + 2), 16));
+    if (name.includes("monochrome")) {
+      const gray2 = rgb[0] * 0.2126 + rgb[1] * 0.7152 + rgb[2] * 0.0722;
+      rgb = [gray2, gray2, gray2];
+    } else if (name.includes("faded")) {
+      rgb = rgb.map((value) => value + (255 - value) * 0.08);
+    }
+    return "#" + rgb.map((value) => Math.round(value).toString(16).padStart(2, "0")).join("");
+  });
+  return Object.fromEntries(
+    ["neutral", "active", "neutralOutline", "activeOutline"].map((role, index) => [
+      `buildings.flat.${role}`,
+      values[index]
+    ])
+  );
+}
+function streetsCartographyThemes(base) {
+  const themes = Object.fromEntries(
+    Object.entries(base).map(([name, theme]) => [
+      name,
+      defineTheme3(theme, {
+        id: `streets-${name}`,
+        version: 1,
+        colorScheme: theme.colorScheme,
+        typography: base.light.typography,
+        tokens: {
+          color: {
+            ...colors(name),
+            ...name === "light" ? streetsDayColors : {},
+            "roads.accessOverview": colors(name)["buildings.flat.neutral"],
+            "roads.path.ground": token10.color("roads.path"),
+            "roads.path.green": "#FFFFFF",
+            "surface.background.transition": token10.color(
+              name === "light" ? "surface.background" : "surface.background.overview"
+            ),
+            "vegetation.tree.outline": name === "light" ? "#A0E5B5" : token10.color("surface.park"),
+            "landcover.orchard": token10.color("landcover.farmland"),
+            "landcover.nursery": token10.color("landcover.farmland"),
+            "roads.overview.casing": token10.color("roads.detail.casing"),
+            "roads.overview.major": token10.color("roads.motorway"),
+            "roads.overview.majorClose": token10.color("roads.motorway"),
+            "roads.overview.casingClose": token10.color("roads.detail.casing"),
+            ...name === "light" ? streetsDayGroundColors : {},
+            ...name === "light" ? streetsNetworkDayColors : {},
+            // The ordinary city stays in warm limestone; authored parts add material contrast.
+            "buildings.raised.neutral": name === "light" ? "#ECE8DE" : colors(name)["buildings.flat.neutral"],
+            ...streetsBuildingColors(
+              name === "light" ? "#EEEAE1" : colors(name)["buildings.flat.neutral"],
+              theme.colorScheme === "dark",
+              name.includes("monochrome")
+            ),
+            ...name === "light" ? {
+              "vegetation.tree.bark": "#C6B493",
+              "buildings.modelWood": "#C6B493",
+              "buildings.flat.neutralOutline": "#B9BFBA",
+              "buildings.flat.activeOutline": "#B9BFBA",
+              "roads.path.ground": "#D5DAD7",
+              "landcover.global.crop": "rgba(0, 0, 0, 0)"
+            } : {}
+          },
+          font: base.light.tokens.font,
+          image: { ...theme.tokens.image, ...name === "light" ? streetsDayImages : {} },
+          number: Object.fromEntries([
+            ["roads.path.groundOpacity", 1],
+            ["labels.shield.spacing11", 420],
+            ["labels.shield.spacing13", 480],
+            ...[100, 85, 78, 55, 25].map((value) => [
+              `land.climate.opacity${value === 100 ? "" : value}`,
+              value / 100
+            ])
+          ])
+        }
+      })
+    ])
+  );
+  const day = resolveTileflowTheme3(themes.light).tokens.color;
+  const referenceDay = resolveTileflowTheme3(base.light).tokens.color;
+  for (const [name, theme] of Object.entries(themes)) {
+    if (!/^(?:dawn|dusk|dark)(?:-|$)/.test(name)) continue;
+    const referenceTime = resolveTileflowTheme3(base[name]).tokens.color;
+    themes[name] = defineTheme3(theme, {
+      id: `streets-${name}`,
+      version: 1,
+      colorScheme: theme.colorScheme,
+      tokens: {
+        color: streetsTimeColors(
+          { ...day, "landcover.global.crop": streetsDayGroundColors["landcover.global.crop"] },
+          referenceDay,
+          referenceTime,
+          name.includes("monochrome"),
+          name.startsWith("dawn") ? "dawn" : name.startsWith("dusk") ? "dusk" : "night"
+        )
+      }
+    });
+  }
+  return themes;
+}
+
 // src/official/streets-lighting.ts
 var defaultLighting = {
   dawn: {
@@ -9985,11 +10822,11 @@ var defaultLighting = {
     sun: {
       azimuth: 180,
       altitude: 70,
-      color: "#FFFFFF",
-      intensity: 0.2,
-      shadowIntensity: 1
+      color: "#FFF5E8",
+      intensity: 0.3,
+      shadowIntensity: 0.8
     },
-    ambient: { color: "#FFFFFF", intensity: 0.8 }
+    ambient: { color: "#E2EBF7", intensity: 0.7 }
   },
   dusk: {
     sun: {
@@ -10013,51 +10850,42 @@ var defaultLighting = {
     ambient: { color: "#001638", intensity: 0.5 }
   }
 };
-var fadedLighting = {
+function withLightColors(colors2) {
+  return Object.fromEntries(
+    Object.keys(defaultLighting).map((preset) => [
+      preset,
+      {
+        sun: { ...defaultLighting[preset].sun, color: colors2[preset].sun },
+        ambient: { ...defaultLighting[preset].ambient, color: colors2[preset].ambient }
+      }
+    ])
+  );
+}
+var fadedLighting = withLightColors({
   dawn: {
-    sun: { ...defaultLighting.dawn.sun, color: "rgb(252.513725, 222.937729, 169.273879)" },
-    ambient: { color: "rgb(254, 244.681815, 235.980392)", intensity: 0.75 }
+    sun: "rgb(252.513725, 222.937729, 169.273879)",
+    ambient: "rgb(254, 244.681815, 235.980392)"
   },
-  day: defaultLighting.day,
+  day: { sun: "#FFF8EF", ambient: "#EBF0F8" },
   dusk: {
-    sun: { ...defaultLighting.dusk.sun, color: "rgb(252.513725, 217.250027, 164.945083)" },
-    ambient: { color: "rgb(87.776471, 97.427724, 126.419608)", intensity: 0.8 }
+    sun: "rgb(252.513725, 217.250027, 164.945083)",
+    ambient: "rgb(87.776471, 97.427724, 126.419608)"
   },
-  night: {
-    sun: { ...defaultLighting.night.sun, color: "rgb(97.815686, 102.955556, 118.333333)" },
-    ambient: { color: "rgb(2, 38.117647, 86.886275)", intensity: 0.5 }
-  }
-};
-var monochromeLighting = {
+  night: { sun: "rgb(97.815686, 102.955556, 118.333333)", ambient: "rgb(2, 38.117647, 86.886275)" }
+});
+var monochromeLighting = withLightColors({
   dawn: {
-    sun: {
-      ...defaultLighting.dawn.sun,
-      altitude: 50,
-      color: "rgb(226.147143, 226.147143, 226.147143)",
-      intensity: 0.35
-    },
-    ambient: { color: "rgb(245.703576, 245.703576, 245.703576)", intensity: 0.75 }
-  },
-  day: {
-    sun: defaultLighting.day.sun,
-    ambient: { ...defaultLighting.day.ambient, intensity: 0.85 }
+    sun: "rgb(226.147143, 226.147143, 226.147143)",
+    ambient: "rgb(245.703576, 245.703576, 245.703576)"
   },
+  day: { sun: "#FFFFFF", ambient: "#FFFFFF" },
   dusk: {
-    sun: {
-      ...defaultLighting.dusk.sun,
-      altitude: 60,
-      color: "rgb(163.817309, 163.817309, 163.817309)",
-      intensity: 0.15
-    },
-    ambient: { color: "rgb(126.294118, 126.294118, 126.294118)", intensity: 0.1 }
+    sun: "rgb(163.817309, 163.817309, 163.817309)",
+    ambient: "rgb(126.294118, 126.294118, 126.294118)"
   },
-  night: {
-    // Standard's monochrome LUT maps a black light input to #353535. Feeding the
-    // raw black into the scene would incorrectly remove all night illumination.
-    sun: { ...defaultLighting.night.sun, color: "#353535", intensity: 0.25 },
-    ambient: { color: "#353535", intensity: 0 }
-  }
-};
+  // Retain legible artistic moonlight; black would remove all night illumination.
+  night: { sun: "#353535", ambient: "#353535" }
+});
 var streetsLighting = {
   default: defaultLighting,
   faded: fadedLighting,
@@ -10226,9 +11054,9 @@ function hex(rgb) {
 }
 function inFamily(color, family) {
   const rgb = channels(color);
-  const gray = rgb[0] * 0.2126 + rgb[1] * 0.7152 + rgb[2] * 0.0722;
-  if (family === "monochrome") return hex([gray, gray, gray]);
-  if (family === "faded") return hex(rgb.map((channel) => channel + (gray - channel) * 0.35));
+  const gray2 = rgb[0] * 0.2126 + rgb[1] * 0.7152 + rgb[2] * 0.0722;
+  if (family === "monochrome") return hex([gray2, gray2, gray2]);
+  if (family === "faded") return hex(rgb.map((channel) => channel + (gray2 - channel) * 0.35));
   return color;
 }
 function streetsSkyTokens(preset, family) {
@@ -10748,17 +11576,17 @@ function formatStreetsColor({ a, b, g, r }, format) {
   const hex2 = (value) => channel(value).toString(16).padStart(2, "0").toUpperCase();
   return `#${hex2(r)}${hex2(g)}${hex2(b)}${format.length === 9 ? hex2(a * 255) : ""}`;
 }
-function adjustStreetsColors(colors, transform) {
+function adjustStreetsColors(colors2, transform) {
   return Object.fromEntries(
-    Object.entries(colors).map(([role, value]) => [
+    Object.entries(colors2).map(([role, value]) => [
       role,
       formatStreetsColor(transform(role, parseStreetsColor(value)), value)
     ])
   );
 }
 function grayscale(color) {
-  const gray = color.r * 0.2126 + color.g * 0.7152 + color.b * 0.0722;
-  return { ...color, r: gray, g: gray, b: gray };
+  const gray2 = color.r * 0.2126 + color.g * 0.7152 + color.b * 0.0722;
+  return { ...color, r: gray2, g: gray2, b: gray2 };
 }
 function isDarkStreetsPreset(preset) {
   return preset === "dusk" || preset === "night";
@@ -10767,8 +11595,8 @@ function transferStreetsColor(color, from, to, monochrome) {
   const source = parseStreetsColor(from);
   const target = parseStreetsColor(to);
   if (monochrome) {
-    const gray = grayscale(color).r + target.r - grayscale(source).r;
-    return { ...color, r: gray, g: gray, b: gray };
+    const gray2 = grayscale(color).r + target.r - grayscale(source).r;
+    return { ...color, r: gray2, g: gray2, b: gray2 };
   }
   return {
     ...color,
@@ -10785,7 +11613,7 @@ function calibratedStreetsColors(preset, theme) {
   const roadCasings = streetsRoadCasingProfiles[`${theme}-${preset}`];
   const baseline = streetsSurfaceProfiles[dark ? "default-night" : "default-day"];
   const monochrome = theme === "monochrome";
-  const colors = adjustStreetsColors(base, (role, color) => {
+  const colors2 = adjustStreetsColors(base, (role, color) => {
     if (role.startsWith("labels.shield.") || role === "roads.sidewalk.surface") return color;
     const shift = (from, to) => transferStreetsColor(color, from, to, monochrome);
     const foreground = () => monochrome ? grayscale(color) : color;
@@ -10839,7 +11667,7 @@ function calibratedStreetsColors(preset, theme) {
       return shift(base["surface.background"], profile.land);
     return foreground();
   });
-  return { ...colors, "roads.detail.casing": roadCasings.hd };
+  return { ...colors2, "roads.detail.casing": roadCasings.hd };
 }
 function streetsPaletteColors(preset, colorTheme) {
   const palette = {
@@ -10855,7 +11683,11 @@ function streetsPaletteColors(preset, colorTheme) {
     "buildings.modelWood": palette["vegetation.tree.bark"],
     "buildings.floodLight": !isDarkStreetsPreset(preset) ? "#FFFFFF" : colorTheme === "monochrome" ? "#E5E5E5" : colorTheme === "faded" ? "#F8E4C4" : "#F5CFA8",
     ...streetsModelLighting(preset, colorTheme).colors,
-    ...streetsBuildingColors(palette["buildings.extrusion"], isDarkStreetsPreset(preset)),
+    ...streetsBuildingColors(
+      palette["buildings.extrusion"],
+      isDarkStreetsPreset(preset),
+      colorTheme === "monochrome"
+    ),
     ...streetsSkyTokens(preset, colorTheme).colors
   };
 }
@@ -10896,7 +11728,7 @@ var streetsImages = {
   "roads.shield.rectangleYellow": "road-shield-rectangle-yellow",
   "roads.sidewalkPattern": "sidewalk-dot"
 };
-var streetsLightTheme = defineTheme3({
+var streetsLightTheme = defineTheme4({
   id: "streets-light",
   version: 1,
   colorScheme: "light",
@@ -10907,11 +11739,11 @@ var streetsLightTheme = defineTheme3({
     image: { ...streetsImages, ...streetsPoiImageTokens("light") }
   },
   typography: {
-    font: token7.font("default"),
-    places: { font: token7.font("places") },
-    poi: { font: token7.font("default") },
-    roads: { font: token7.font("default") },
-    water: { font: token7.font("default") }
+    font: token11.font("default"),
+    places: { font: token11.font("places") },
+    poi: { font: token11.font("default") },
+    roads: { font: token11.font("default") },
+    water: { font: token11.font("default") }
   },
   lighting: {
     ...streetsLighting.default.day,
@@ -10922,29 +11754,14 @@ var streetsLightTheme = defineTheme3({
     position: [1.15, 180, 20]
   }
 });
-var streetsDarkTheme = defineTheme3({
+var streetsDarkTheme = defineTheme4(streetsLightTheme, {
   id: "streets-dark",
   version: 1,
   colorScheme: "dark",
   tokens: {
+    image: { ...streetsImages, ...streetsPoiImageTokens("dark") },
     color: streetsPaletteColors("night", "default"),
-    number: streetsLightingNumbers("night", "default"),
-    font: streetsFonts2,
-    image: {
-      ...streetsImages,
-      ...streetsPoiImageTokens("dark"),
-      ...Object.fromEntries(
-        Object.entries(streetsImages).filter(([role]) => role.startsWith("vegetation.tree.")).map(([role, image2]) => [role, `${image2}-dark`])
-      ),
-      "roads.sidewalkPattern": "sidewalk-dot-dark"
-    }
-  },
-  typography: {
-    font: token7.font("default"),
-    places: { font: token7.font("places") },
-    poi: { font: token7.font("default") },
-    roads: { font: token7.font("default") },
-    water: { font: token7.font("default") }
+    number: streetsLightingNumbers("night", "default")
   },
   lighting: {
     ...streetsLighting.default.night,
@@ -10958,84 +11775,90 @@ var streetsDarkTheme = defineTheme3({
 });
 function defineStreetsPaletteTheme(name, preset, colorTheme) {
   const isDark = isDarkStreetsPreset(preset);
-  const imageVariant = colorTheme === "monochrome" ? isDark ? "monochrome-dark" : "monochrome" : void 0;
-  return defineTheme3(isDark ? streetsDarkTheme : streetsLightTheme, {
+  return defineTheme4(isDark ? streetsDarkTheme : streetsLightTheme, {
     id: `streets-${name}`,
     version: 1,
     colorScheme: isDark ? "dark" : "light",
     lighting: streetsLighting[colorTheme][preset],
     tokens: {
+      image: {
+        ...streetsImages,
+        ...streetsPoiImageTokens(
+          colorTheme === "monochrome" ? isDark ? "monochrome-dark" : "monochrome" : isDark ? "dark" : "light"
+        )
+      },
       color: streetsPaletteColors(preset, colorTheme),
-      number: streetsLightingNumbers(preset, colorTheme),
-      ...imageVariant ? { image: streetsPoiImageTokens(imageVariant) } : {}
+      number: streetsLightingNumbers(preset, colorTheme)
     }
   });
 }
-var streetsThemes = Object.freeze({
-  light: streetsLightTheme,
-  dark: streetsDarkTheme,
-  dawn: defineStreetsPaletteTheme("dawn", "dawn", "default"),
-  dusk: defineStreetsPaletteTheme("dusk", "dusk", "default"),
-  faded: defineStreetsPaletteTheme("faded", "day", "faded"),
-  monochrome: defineStreetsPaletteTheme("monochrome", "day", "monochrome"),
-  "dawn-faded": defineStreetsPaletteTheme("dawn-faded", "dawn", "faded"),
-  "dawn-monochrome": defineStreetsPaletteTheme("dawn-monochrome", "dawn", "monochrome"),
-  "dusk-faded": defineStreetsPaletteTheme("dusk-faded", "dusk", "faded"),
-  "dusk-monochrome": defineStreetsPaletteTheme("dusk-monochrome", "dusk", "monochrome"),
-  "dark-faded": defineStreetsPaletteTheme("dark-faded", "night", "faded"),
-  "dark-monochrome": defineStreetsPaletteTheme("dark-monochrome", "night", "monochrome")
-});
+var streetsThemes = Object.freeze(
+  streetsCartographyThemes({
+    light: streetsLightTheme,
+    dark: streetsDarkTheme,
+    dawn: defineStreetsPaletteTheme("dawn", "dawn", "default"),
+    dusk: defineStreetsPaletteTheme("dusk", "dusk", "default"),
+    faded: defineStreetsPaletteTheme("faded", "day", "faded"),
+    monochrome: defineStreetsPaletteTheme("monochrome", "day", "monochrome"),
+    "dawn-faded": defineStreetsPaletteTheme("dawn-faded", "dawn", "faded"),
+    "dawn-monochrome": defineStreetsPaletteTheme("dawn-monochrome", "dawn", "monochrome"),
+    "dusk-faded": defineStreetsPaletteTheme("dusk-faded", "dusk", "faded"),
+    "dusk-monochrome": defineStreetsPaletteTheme("dusk-monochrome", "dusk", "monochrome"),
+    "dark-faded": defineStreetsPaletteTheme("dark-faded", "night", "faded"),
+    "dark-monochrome": defineStreetsPaletteTheme("dark-monochrome", "night", "monochrome")
+  })
+);
 var streetsVisual = {
   boundary: {
-    admin: token7.color("boundaries.admin"),
-    halo: token7.color("boundaries.halo"),
-    regional: token7.color("boundaries.regional"),
-    overviewLabel: token7.color("labels.overview")
+    admin: token11.color("boundaries.admin"),
+    halo: token11.color("boundaries.halo"),
+    regional: token11.color("boundaries.regional"),
+    overviewLabel: token11.color("labels.overview")
   },
   building: {
-    contactShadow: token7.color("buildings.contactShadow"),
-    extrusion: token7.color("buildings.extrusion"),
-    fill: token7.color("buildings.fill"),
-    outline: token7.color("buildings.outline"),
-    shadow: token7.color("buildings.shadow")
+    contactShadow: token11.color("buildings.contactShadow"),
+    extrusion: token11.color("buildings.extrusion"),
+    fill: token11.color("buildings.fill"),
+    outline: token11.color("buildings.outline"),
+    shadow: token11.color("buildings.shadow")
   },
   terrain: {
-    accent: token7.color("terrain.hillshade.accent"),
-    highlight: token7.color("terrain.hillshade.highlight"),
-    shadow: token7.color("terrain.hillshade.shadow")
+    accent: token11.color("terrain.hillshade.accent"),
+    highlight: token11.color("terrain.hillshade.highlight"),
+    shadow: token11.color("terrain.hillshade.shadow")
   },
   hydro: {
-    depth0: token7.color("hydro.depth.m0"),
-    depth200: token7.color("hydro.depth.m200"),
-    depth2000: token7.color("hydro.depth.m2000"),
-    depth7000: token7.color("hydro.depth.m7000"),
-    ocean: token7.color("hydro.ocean"),
-    water: token7.color("hydro.water"),
-    overview: token7.color("hydro.water.overview"),
-    regional: token7.color("hydro.water.regional"),
-    waterway: token7.color("hydro.waterway")
+    depth0: token11.color("hydro.depth.m0"),
+    depth200: token11.color("hydro.depth.m200"),
+    depth2000: token11.color("hydro.depth.m2000"),
+    depth7000: token11.color("hydro.depth.m7000"),
+    ocean: token11.color("hydro.ocean"),
+    water: token11.color("hydro.water"),
+    overview: token11.color("hydro.water.overview"),
+    regional: token11.color("hydro.water.regional"),
+    waterway: token11.color("hydro.waterway")
   },
   label: {
-    address: token7.color("labels.address"),
-    aerodrome: token7.color("labels.aerodrome"),
-    country: token7.color("labels.country"),
-    ferry: token7.color("labels.ferry"),
-    ferryHalo: token7.color("labels.ferryHalo"),
-    halo: token7.color("labels.halo"),
-    muted: token7.color("labels.muted"),
-    neighborhood: token7.color("labels.neighborhood"),
-    overview: token7.color("labels.overview"),
-    poi: token7.color("labels.poi"),
-    primary: token7.color("labels.primary"),
-    road: token7.color("labels.road"),
-    settlement: token7.color("labels.settlement"),
-    shieldDark: token7.color("labels.shield.dark"),
-    shieldLight: token7.color("labels.shield.light"),
-    strong: token7.color("labels.strong"),
-    water: token7.color("labels.water"),
-    waterHalo: token7.color("labels.waterHalo"),
-    placeHalo: token7.color("labels.placeHalo"),
-    roadHalo: token7.color("labels.roadHalo")
+    address: token11.color("labels.address"),
+    aerodrome: token11.color("labels.aerodrome"),
+    country: token11.color("labels.country"),
+    ferry: token11.color("labels.ferry"),
+    ferryHalo: token11.color("labels.ferryHalo"),
+    halo: token11.color("labels.halo"),
+    muted: token11.color("labels.muted"),
+    neighborhood: token11.color("labels.neighborhood"),
+    overview: token11.color("labels.overview"),
+    poi: token11.color("labels.poi"),
+    primary: token11.color("labels.primary"),
+    road: token11.color("labels.road"),
+    settlement: token11.color("labels.settlement"),
+    shieldDark: token11.color("labels.shield.dark"),
+    shieldLight: token11.color("labels.shield.light"),
+    strong: token11.color("labels.strong"),
+    water: token11.color("labels.water"),
+    waterHalo: token11.color("labels.waterHalo"),
+    placeHalo: token11.color("labels.placeHalo"),
+    roadHalo: token11.color("labels.roadHalo")
   },
   landcover: Object.fromEntries(
     [
@@ -11056,12 +11879,12 @@ var streetsVisual = {
       "villageGreen",
       "wetland",
       "wood"
-    ].map((name) => [name, token7.color(`landcover.${name}`)])
+    ].map((name) => [name, token11.color(`landcover.${name}`)])
   ),
   globalLandcover: Object.fromEntries(
     ["barren", "crop", "grass", "shrub", "snow", "trees", "urban"].map((name) => [
       name,
-      token7.color(`landcover.global.${name}`)
+      token11.color(`landcover.global.${name}`)
     ])
   ),
   landuse: Object.fromEntries(
@@ -11082,7 +11905,7 @@ var streetsVisual = {
       "recreation",
       "recreationOutline",
       "residential"
-    ].map((name) => [name, token7.color(`landuse.${name}`)])
+    ].map((name) => [name, token11.color(`landuse.${name}`)])
   ),
   poi: Object.fromEntries(
     [
@@ -11102,120 +11925,120 @@ var streetsVisual = {
       "sport-leisure",
       "transport",
       "visitor-amenity"
-    ].map((name) => [name, token7.color(`poi.${name}`)])
+    ].map((name) => [name, token11.color(`poi.${name}`)])
   ),
   road: {
-    casing: token7.color("roads.default.casing"),
-    detailCasing: token7.color("roads.detail.casing"),
-    cityCasing: token7.color("roads.city.casing"),
-    cityMinor: token7.color("roads.city.minor"),
-    cityPrimary: token7.color("roads.city.primary"),
-    citySecondary: token7.color("roads.city.secondary"),
-    cityTertiary: token7.color("roads.city.tertiary"),
-    cityTunnel: token7.color("roads.city.tunnel"),
-    cityTunnelCasing: token7.color("roads.city.tunnelCasing"),
-    cycleway: token7.color("roads.cycleway"),
-    default: token7.color("roads.default"),
-    ferry: token7.color("roads.ferry"),
-    motorway: token7.color("roads.motorway"),
-    motorwayCasing: token7.color("roads.motorway.casing"),
-    motorwayTunnel: token7.color("roads.motorway.tunnel"),
-    parkPath: token7.color("roads.parkPath"),
-    path: token7.color("roads.path"),
-    pathCasing: token7.color("roads.path.casing"),
-    pathTransition: token7.color("roads.path.transition"),
-    pathTunnel: token7.color("roads.path.tunnel"),
-    pedestrianSurface: token7.color("roads.pedestrian.surface"),
-    primary: token7.color("roads.primary"),
-    rail: token7.color("roads.rail"),
-    railTransit: token7.color("roads.railTransit"),
-    sidewalkSurface: token7.color("roads.sidewalk.surface"),
-    trunk: token7.color("roads.trunk"),
-    trunkCasing: token7.color("roads.trunk.casing"),
-    trunkTunnel: token7.color("roads.trunk.tunnel"),
-    tunnel: token7.color("roads.default.tunnel")
+    casing: token11.color("roads.default.casing"),
+    detailCasing: token11.color("roads.detail.casing"),
+    cityCasing: token11.color("roads.city.casing"),
+    cityMinor: token11.color("roads.city.minor"),
+    cityPrimary: token11.color("roads.city.primary"),
+    citySecondary: token11.color("roads.city.secondary"),
+    cityTertiary: token11.color("roads.city.tertiary"),
+    cityTunnel: token11.color("roads.city.tunnel"),
+    cityTunnelCasing: token11.color("roads.city.tunnelCasing"),
+    cycleway: token11.color("roads.cycleway"),
+    default: token11.color("roads.default"),
+    ferry: token11.color("roads.ferry"),
+    motorway: token11.color("roads.motorway"),
+    motorwayCasing: token11.color("roads.motorway.casing"),
+    motorwayTunnel: token11.color("roads.motorway.tunnel"),
+    parkPath: token11.color("roads.parkPath"),
+    path: token11.color("roads.path"),
+    pathCasing: token11.color("roads.path.casing"),
+    pathTransition: token11.color("roads.path.transition"),
+    pathTunnel: token11.color("roads.path.tunnel"),
+    pedestrianSurface: token11.color("roads.pedestrian.surface"),
+    primary: token11.color("roads.primary"),
+    rail: token11.color("roads.rail"),
+    railTransit: token11.color("roads.railTransit"),
+    sidewalkSurface: token11.color("roads.sidewalk.surface"),
+    trunk: token11.color("roads.trunk"),
+    trunkCasing: token11.color("roads.trunk.casing"),
+    trunkTunnel: token11.color("roads.trunk.tunnel"),
+    tunnel: token11.color("roads.default.tunnel")
   },
   surface: {
-    background: token7.color("surface.background"),
-    backgroundOverview: token7.color("surface.background.overview"),
-    building: token7.color("surface.building"),
-    land: token7.color("surface.land"),
-    park: token7.color("surface.park"),
-    water: token7.color("surface.water")
+    background: token11.color("surface.background"),
+    backgroundOverview: token11.color("surface.background.overview"),
+    building: token11.color("surface.building"),
+    land: token11.color("surface.land"),
+    park: token11.color("surface.park"),
+    water: token11.color("surface.water")
   },
-  transit: token7.color("transit.primary"),
+  transit: token11.color("transit.primary"),
   barrier: {
-    fence: token7.color("land.fence"),
-    hedge: token7.color("landcover.hedge"),
-    hedgeShade: token7.color("landcover.hedgeShade"),
-    wall: token7.color("land.wall")
+    fence: token11.color("land.fence"),
+    hedge: token11.color("landcover.hedge"),
+    hedgeShade: token11.color("landcover.hedgeShade"),
+    wall: token11.color("land.wall")
   },
   tree: {
-    bark: token7.color("vegetation.tree.bark"),
+    bark: token11.color("vegetation.tree.bark"),
     broadleaf: ["a", "b", "c", "d"].map(
-      (suffix) => token7.color(`vegetation.tree.broadleaf.${suffix}`)
+      (suffix) => token11.color(`vegetation.tree.broadleaf.${suffix}`)
     ),
-    conifer: ["a", "b", "c"].map((suffix) => token7.color(`vegetation.tree.conifer.${suffix}`))
+    conifer: ["a", "b", "c"].map((suffix) => token11.color(`vegetation.tree.conifer.${suffix}`))
   },
   image: {
-    crosswalk: token7.image("roads.crosswalk"),
-    oneway: token7.image("roads.oneway"),
-    shieldCircleNeutral: token7.image("roads.shield.circleNeutral"),
-    shieldRectangleBlue: token7.image("roads.shield.rectangleBlue"),
-    shieldRectangleGreen: token7.image("roads.shield.rectangleGreen"),
-    shieldRectangleNeutral: token7.image("roads.shield.rectangleNeutral"),
-    shieldRectangleOrange: token7.image("roads.shield.rectangleOrange"),
-    shieldRectangleRed: token7.image("roads.shield.rectangleRed"),
-    shieldRectangleYellow: token7.image("roads.shield.rectangleYellow"),
-    sidewalkPattern: token7.image("roads.sidewalkPattern")
+    crosswalk: token11.image("roads.crosswalk"),
+    oneway: token11.image("roads.oneway"),
+    shieldCircleNeutral: token11.image("roads.shield.circleNeutral"),
+    shieldRectangleBlue: token11.image("roads.shield.rectangleBlue"),
+    shieldRectangleGreen: token11.image("roads.shield.rectangleGreen"),
+    shieldRectangleNeutral: token11.image("roads.shield.rectangleNeutral"),
+    shieldRectangleOrange: token11.image("roads.shield.rectangleOrange"),
+    shieldRectangleRed: token11.image("roads.shield.rectangleRed"),
+    shieldRectangleYellow: token11.image("roads.shield.rectangleYellow"),
+    sidewalkPattern: token11.image("roads.sidewalkPattern")
   },
   font: {
-    default: token7.font("default"),
-    navigation: token7.font("navigation"),
-    shield: token7.font("shield"),
-    places: token7.font("places"),
-    regular: token7.font("regular"),
-    water: token7.font("water")
+    default: token11.font("default"),
+    navigation: token11.font("navigation"),
+    shield: token11.font("shield"),
+    places: token11.font("places"),
+    regular: token11.font("regular"),
+    water: token11.font("water")
   }
 };
 
 // src/official/streets-trees.ts
 import {
-  expr as expr11,
-  field as field10,
-  renderPass as renderPass9,
-  token as token8,
+  expr as expr13,
+  field as field13,
+  renderPass as renderPass12,
+  token as token12,
   vegetation as vegetation5,
-  withRenderStack as withRenderStack9,
-  zoom as zoom9
+  withRenderStack as withRenderStack10,
+  zoom as zoom12
 } from "@tileflow/core";
-var seed = expr11.toNumber(expr11.id(), 0);
-var genus = expr11.get(field10("genus"));
-var leaf = expr11.get(field10("leafType"));
-var named = (names) => expr11.match(
+var seed = expr13.toNumber(expr13.id(), 0);
+var genus = expr13.get(field13("genus"));
+var leaf = expr13.get(field13("leafType"));
+var named = (names) => expr13.match(
   genus,
   [{ labels: names.flatMap((name) => [name, name.toLowerCase()]), value: true }],
   false
 );
-var image = (form) => token8.image(`vegetation.tree.${form}`);
-var broadleaf = expr11.match(
-  expr11.modulo(seed, 3),
+var image = (form) => token12.image(`vegetation.tree.${form}`);
+var broadleaf = expr13.match(
+  expr13.modulo(seed, 3),
   [
     { labels: [0], value: image("round") },
     { labels: [1], value: image("open") }
   ],
   image("tall")
 );
-var palm = expr11.match(
-  expr11.modulo(seed, 2),
+var palm = expr13.match(
+  expr13.modulo(seed, 2),
   [{ labels: [0], value: image("palm-feather") }],
   image("palm-fan")
 );
-var crownImage = expr11.case(
+var crownImage = expr13.case(
   [
     {
-      when: expr11.any(
-        expr11.eq(leaf, "palm"),
+      when: expr13.any(
+        expr13.eq(leaf, "palm"),
         named([
           "Acoelorrhaphe",
           "Adonidia",
@@ -11254,8 +12077,8 @@ var crownImage = expr11.case(
     },
     { when: named(["Cupressus", "Calocedrus", "Thuja"]), value: image("columnar") },
     {
-      when: expr11.any(
-        expr11.eq(leaf, "needleleaved"),
+      when: expr13.any(
+        expr13.eq(leaf, "needleleaved"),
         named([
           "Abies",
           "Araucaria",
@@ -11337,16 +12160,16 @@ var crownImage = expr11.case(
   ],
   broadleaf
 );
-var diameter = expr11.toNumber(expr11.get(field10("diameterCrown")), 0);
-var crownFactor = expr11.divide(
-  expr11.max(3, expr11.min(18, expr11.case([{ when: expr11.gt(diameter, 0), value: diameter }], 7))),
+var diameter = expr13.toNumber(expr13.get(field13("diameterCrown")), 0);
+var crownFactor = expr13.divide(
+  expr13.max(3, expr13.min(18, expr13.case([{ when: expr13.gt(diameter, 0), value: diameter }], 7))),
   7
 );
-var size = (divisor) => expr11.interpolate({ kind: "exponential", base: 2 }, expr11.zoom(), [
-  [15, expr11.multiply(crownFactor, 2.1 / divisor)],
-  [22, expr11.multiply(crownFactor, 268.8 / divisor)]
+var size = (divisor) => expr13.interpolate({ kind: "exponential", base: 2 }, expr13.zoom(), [
+  [15, expr13.multiply(crownFactor, 2.1 / divisor)],
+  [22, expr13.multiply(crownFactor, 268.8 / divisor)]
 ]);
-var streetsTrees = withRenderStack9(
+var streetsTrees = withRenderStack10(
   vegetation5({
     // Models stay 3D in overhead and tilted views; unsupported renderers omit trees.
     mode: "3d",
@@ -11354,9 +12177,9 @@ var streetsTrees = withRenderStack9(
     visible: true,
     flat: {
       minZoom: 15.5,
-      color: token8.color("vegetation.tree.broadleaf.a"),
+      color: token12.color("vegetation.tree.broadleaf.a"),
       radius: size(2),
-      opacity: zoom9.linear([
+      opacity: zoom12.linear([
         [15.5, 0],
         [16, 0.12]
       ]),
@@ -11366,34 +12189,76 @@ var streetsTrees = withRenderStack9(
       strokeOpacity: 0
     },
     threeDimensional: {
-      barkColor: token8.color("vegetation.tree.bark"),
+      barkColor: token12.color("vegetation.tree.bark"),
       broadleafColors: ["a", "b", "c", "d"].map(
-        (shade) => token8.color(`vegetation.tree.broadleaf.${shade}`)
+        (shade) => token12.color(`vegetation.tree.broadleaf.${shade}`)
       ),
       coniferColors: ["a", "b", "c"].map(
-        (shade) => token8.color(`vegetation.tree.conifer.${shade}`)
+        (shade) => token12.color(`vegetation.tree.conifer.${shade}`)
       ),
-      palmColors: ["a", "b", "c"].map((shade) => token8.color(`vegetation.tree.broadleaf.${shade}`)),
+      palmColors: ["a", "b", "c"].map((shade) => token12.color(`vegetation.tree.broadleaf.${shade}`)),
       // The flat hedge's shade and fill, so a hedge keeps its colour as it rises.
-      hedgeColors: [token8.color("landcover.hedgeShade"), token8.color("landcover.hedge")],
+      hedgeColors: [token12.color("landcover.hedgeShade"), token12.color("landcover.hedge")],
       crownScale: 1,
       heightScale: 1,
-      minimumHeight: 8,
+      minimumHeight: 6.4,
       materialVariation: 1,
       finish: "smooth",
       edges: 0,
       forms: {
-        round: { models: ["streets-tree-round", "streets-tree-open"] },
-        open: { models: ["streets-tree-open"] },
-        tall: { models: ["streets-tree-tall", "streets-tree-open"] },
-        conifer: { models: ["streets-tree-conifer"] },
-        columnar: { models: ["streets-tree-columnar"] },
-        palm: { models: ["streets-tree-palm-feather", "streets-tree-palm-fan"] }
+        round: {
+          heightScale: 0.8,
+          crownScale: 0.8,
+          sizeAnchor: 8.5,
+          crownAnchor: 4.8,
+          sizeCompression: 0.5,
+          models: ["streets-tree-round"]
+        },
+        open: {
+          heightScale: 0.8,
+          crownScale: 0.8,
+          sizeAnchor: 8,
+          crownAnchor: 5.2,
+          sizeCompression: 0.5,
+          models: ["streets-tree-open"]
+        },
+        tall: {
+          heightScale: 0.8,
+          crownScale: 0.8,
+          sizeAnchor: 9.5,
+          crownAnchor: 4.6,
+          sizeCompression: 0.5,
+          models: ["streets-tree-tall"]
+        },
+        conifer: {
+          heightScale: 0.8,
+          crownScale: 0.8,
+          sizeAnchor: 9,
+          crownAnchor: 4.5,
+          sizeCompression: 0.5,
+          models: ["streets-tree-conifer"]
+        },
+        columnar: {
+          heightScale: 0.8,
+          crownScale: 0.8,
+          sizeAnchor: 10,
+          crownAnchor: 2.4,
+          sizeCompression: 0.5,
+          models: ["streets-tree-columnar"]
+        },
+        palm: {
+          heightScale: 0.8,
+          crownScale: 0.8,
+          sizeAnchor: 11,
+          crownAnchor: 6,
+          sizeCompression: 0.5,
+          models: ["streets-tree-palm-feather", "streets-tree-palm-fan"]
+        }
       }
     }
   }),
   {
-    crowns: renderPass9({
+    crowns: renderPass12({
       placement: { above: "vegetation.trees" },
       // Inherit the optional tree binding from the anchor; generic OpenMapTiles omits it.
       requirements: ["vegetation"],
@@ -11404,12 +12269,12 @@ var streetsTrees = withRenderStack9(
         icon: {
           image: crownImage,
           size: size(52),
-          opacity: zoom9.linear([
+          opacity: zoom12.linear([
             [15.5, 0],
             [16, 0.88],
             [18, 1]
           ]),
-          rotate: expr11.modulo(expr11.multiply(seed, 137.508), 360),
+          rotate: expr13.modulo(expr13.multiply(seed, 137.508), 360),
           rotationAlignment: "map",
           pitchAlignment: "map",
           allowOverlap: true,
@@ -11453,7 +12318,7 @@ var mapboxRoadPalette = {
 };
 var mapboxRailColor = streetsVisual.road.railTransit;
 var streetsSurfacePalette = {
-  background: zoom10.linear([
+  background: zoom13.linear([
     [13, streetsVisual.surface.backgroundOverview],
     [14, streetsVisual.surface.background]
   ]),
@@ -11484,14 +12349,14 @@ var streetsSurfacePalette = {
   scrub: streetsVisual.landcover.scrub,
   urbanPark: streetsVisual.landcover.urbanPark,
   villageGreen: streetsVisual.landcover.villageGreen,
-  water: expr12.interpolate({ kind: "linear" }, expr12.zoom(), [
+  water: expr14.interpolate({ kind: "linear" }, expr14.zoom(), [
     [5, streetsVisual.hydro.overview],
     [7, streetsVisual.hydro.regional],
     [13, streetsVisual.hydro.regional],
     [
       14,
-      expr12.match(
-        expr12.get(field11("class")),
+      expr14.match(
+        expr14.get(field14("class")),
         [{ labels: ["ocean", "sea"], value: streetsVisual.hydro.ocean }],
         streetsVisual.hydro.water
       )
@@ -11514,7 +12379,7 @@ var streetsGlobalLandcoverPalette = {
   trees: streetsVisual.globalLandcover.trees,
   urban: streetsVisual.globalLandcover.urban
 };
-var globalLandcoverOpacity = zoom10.linear([
+var globalLandcoverOpacity = zoom13.linear([
   // At world and country zooms the source classes are the terrain palette.
   // Blending them into the neutral land token desaturates forests and crops
   // into one pale wash, so keep the authored colours intact until the detailed
@@ -11529,26 +12394,26 @@ var globalLandcoverOpacity = zoom10.linear([
   [10.75, 0.25],
   [11, 0]
 ]);
-var detailedLandcoverOpacity = zoom10.linear([
+var detailedLandcoverOpacity = zoom13.linear([
   [7, 0],
   [8, 0.35],
   [9, 0.7],
   [10, 0.9],
   [11, 1]
 ]);
-var detailedUrbanGreenOpacity = zoom10.linear([
+var detailedUrbanGreenOpacity = zoom13.linear([
   [8, 0],
   [9, 1]
 ]);
-var protectedAreaOpacity = zoom10.linear([
+var protectedAreaOpacity = zoom13.linear([
   [5, 0],
   [6, 1]
 ]);
 function streetsPoiStyle(category) {
-  const filterRank = expr12.toNumber(expr12.get(field11("poiFilterRank")), 6);
-  const sizeRank = expr12.toNumber(expr12.get(field11("poiSizeRank")), 17);
-  const featured = expr12.all(expr12.lte(filterRank, 0), expr12.lt(sizeRank, 5));
-  const featuredDetail = expr12.all(expr12.lte(filterRank, 1), expr12.lt(sizeRank, 13));
+  const filterRank = expr14.toNumber(expr14.get(field14("poiFilterRank")), 6);
+  const sizeRank = expr14.toNumber(expr14.get(field14("poiSizeRank")), 17);
+  const featured = expr14.all(expr14.lte(filterRank, 0), expr14.lt(sizeRank, 5));
+  const featuredDetail = expr14.all(expr14.lte(filterRank, 1), expr14.lt(sizeRank, 13));
   return {
     icon: {
       image: streetsPoiImage(),
@@ -11567,12 +12432,12 @@ function streetsPoiStyle(category) {
       maxWidth: 9,
       anchor: "top",
       offset: [0, 0.8],
-      padding: zoom10.linear([
+      padding: zoom13.linear([
         [16, 6],
         [17, 4]
       ]),
-      size: category === "transport" ? 13 : expr12.step(expr12.zoom(), expr12.case([{ when: featured, value: 18 }], 13), [
-        [17, expr12.case([{ when: featuredDetail, value: 18 }], 13)]
+      size: category === "transport" ? 13 : expr14.step(expr14.zoom(), expr14.case([{ when: featured, value: 18 }], 13), [
+        [17, expr14.case([{ when: featuredDetail, value: 18 }], 13)]
       ])
     }
   };
@@ -11613,7 +12478,7 @@ function cityRoadCasingColorStops(minZoom) {
     minZoom,
     streetsDetailPalette.roadCasing,
     mapboxRoadPalette.detailCasing
-  );
+  ).map(([level, color]) => [level === 13 ? 14 : level, color]);
 }
 var roadBorderZoom = 15;
 var roadBorderTotalWidth = 1;
@@ -11663,35 +12528,35 @@ var groundedBuilding3dSelector = {
     }
   ]
 };
-var building3dHeight = expr12.max(
+var building3dHeight = expr14.max(
   0,
-  expr12.toNumber(expr12.coalesce(expr12.get(field11("renderHeight")), 5), 5)
+  expr14.toNumber(expr14.coalesce(expr14.get(field14("renderHeight")), 5), 5)
 );
-var building3dBase = expr12.max(
+var building3dBase = expr14.max(
   0,
-  expr12.min(
-    expr12.toNumber(expr12.coalesce(expr12.get(field11("renderMinHeight")), 0), 0),
+  expr14.min(
+    expr14.toNumber(expr14.coalesce(expr14.get(field14("renderMinHeight")), 0), 0),
     building3dHeight
   )
 );
-var roadLineCap = zoom10.step([
+var roadLineCap = zoom13.step([
   [3, "butt"],
   [14, "round"]
 ]);
-var roadLineJoin = zoom10.step([
+var roadLineJoin = zoom13.step([
   [3, "miter"],
   [14, "round"]
 ]);
-var pathLineCap = zoom10.step([
+var pathLineCap = zoom13.step([
   [12, "butt"],
   [16, "round"]
 ]);
-var pathLineJoin = zoom10.step([
+var pathLineJoin = zoom13.step([
   [12, "miter"],
   [16, "round"]
 ]);
-var circularRoadBaseWidth = expr12.match(
-  expr12.coalesce(expr12.get(field11("class")), "minor"),
+var circularRoadBaseWidth = expr14.match(
+  expr14.coalesce(expr14.get(field14("class")), "minor"),
   [
     { labels: "motorway", value: 6 },
     { labels: "trunk", value: 5.5 },
@@ -11703,15 +12568,15 @@ var circularRoadBaseWidth = expr12.match(
   ],
   3
 );
-var circularRoadFallbackWidth = expr12.interpolate(
+var circularRoadFallbackWidth = expr14.interpolate(
   { kind: "exponential", base: 2 },
-  expr12.zoom(),
+  expr14.zoom(),
   [
     [15, circularRoadBaseWidth],
     ...Array.from({ length: 9 }, (_, index) => {
       const level = 16 + index;
       const scale = 1 + (1.35 ** (level - 15) - 1) / (1.35 ** 7 - 1) * 1.2;
-      return [level, expr12.multiply(circularRoadBaseWidth, scale)];
+      return [level, expr14.multiply(circularRoadBaseWidth, scale)];
     })
   ]
 );
@@ -11721,14 +12586,14 @@ var tunnelBorderWidth = 1;
 function roadWidth(widths2, oneWayScale, rampWidths) {
   const augmentedWidths = [...widths2].sort(([left], [right]) => left - right);
   const widthOutput = (level, width) => {
-    const ordinaryWidth = oneWayScale === 1 ? width : expr12.match(
-      expr12.get(field11("oneway")),
+    const ordinaryWidth = oneWayScale === 1 ? width : expr14.match(
+      expr14.get(field14("oneway")),
       [{ labels: [1, -1], value: width * oneWayScale }],
       width
     );
     const rampWidth = rampWidths ? sampleRoadWidth(rampWidths, level) : void 0;
-    const surfaceWidth = rampWidth === void 0 ? ordinaryWidth : expr12.case(
-      [{ when: expr12.eq(expr12.get(field11("ramp")), 1), value: rampWidth }],
+    const surfaceWidth = rampWidth === void 0 ? ordinaryWidth : expr14.case(
+      [{ when: expr14.eq(expr14.get(field14("ramp")), 1), value: rampWidth }],
       ordinaryWidth
     );
     return surfaceWidth;
@@ -11738,7 +12603,7 @@ function roadWidth(widths2, oneWayScale, rampWidths) {
   );
   const firstWidthStop = widthStops[0];
   if (firstWidthStop === void 0) throw new Error("Road widths require at least one zoom stop.");
-  return expr12.interpolate({ base: roadWidthInterpolationBase, kind: "exponential" }, expr12.zoom(), [
+  return expr14.interpolate({ base: roadWidthInterpolationBase, kind: "exponential" }, expr14.zoom(), [
     firstWidthStop,
     ...widthStops.slice(1)
   ]);
@@ -11765,20 +12630,20 @@ function cityRoadWidths(widths2, at12, at14) {
   ];
 }
 function roadCasingWidth(major) {
-  return expr12.interpolate({ kind: "exponential", base: 1.5 }, expr12.zoom(), [
+  return expr14.interpolate({ kind: "exponential", base: 1.5 }, expr14.zoom(), [
     [
       14,
-      major ? expr12.case([{ when: expr12.eq(expr12.get(field11("ramp")), 1), value: 0.8 }], 1) : 0.8
+      major ? expr14.case([{ when: expr14.eq(expr14.get(field14("ramp")), 1), value: 0.8 }], 1) : 0.8
     ],
     [22, 2]
   ]);
 }
-var pathCasingStrokeWidth = zoom10.exponential(1.5, [
+var pathCasingStrokeWidth = zoom13.exponential(1.5, [
   [14, 0.5],
   [18, 1],
   [22, 2]
 ]);
-var pathTunnelCasingWidth = zoom10.linear([
+var pathTunnelCasingWidth = zoom13.linear([
   [15, 0],
   [15.5, tunnelBorderWidth],
   [22, tunnelBorderWidth]
@@ -11788,8 +12653,8 @@ var mapboxPathWidthStops = [
   [18, 6],
   [22, 80]
 ];
-var contextualPathLineWidth = zoom10.exponential(1.5, mapboxPathWidthStops);
-var contextualPathColor = expr12.interpolate({ kind: "linear" }, expr12.zoom(), [
+var contextualPathLineWidth = zoom13.exponential(1.5, mapboxPathWidthStops);
+var contextualPathColor = expr14.interpolate({ kind: "linear" }, expr14.zoom(), [
   [15, mapboxRoadPalette.pathAtZ15],
   [16, mapboxRoadPalette.pathFromZ16]
 ]);
@@ -11800,7 +12665,7 @@ function parkPathRefinements() {
       (roadClass) => ["surface", "bridge"].flatMap((structure) => [
         [
           `${roadClass}-${structure}-fill`,
-          refineRenderTarget5({
+          refineRenderTarget6({
             renderer: "line",
             style: {
               color: roadClass === "steps" ? mapboxRoadPalette.pathFromZ16 : contextualPathColor,
@@ -11813,7 +12678,7 @@ function parkPathRefinements() {
         ],
         [
           `${roadClass}-${structure}-casing`,
-          refineRenderTarget5({
+          refineRenderTarget6({
             renderer: "line",
             style: {
               color: mapboxRoadPalette.pathCasing,
@@ -11869,7 +12734,7 @@ var namedCitySelector = {
 };
 function streetsBoundaryRenderStack() {
   return {
-    admin2Background: renderPass10({
+    admin2Background: renderPass13({
       placement: { below: "boundaries.admin4" },
       feature: "boundary",
       renderer: "line",
@@ -11895,23 +12760,23 @@ function streetsBoundaryRenderStack() {
         ]
       },
       style: {
-        blur: zoom10.linear([
+        blur: zoom13.linear([
           [3, 0],
           [12, 2]
         ]),
         color: streetsVisual.boundary.halo,
         minZoom: 1,
-        opacity: zoom10.linear([
+        opacity: zoom13.linear([
           [3, 0],
           [4, 0.5]
         ]),
-        width: zoom10.linear([
+        width: zoom13.linear([
           [3, 4],
           [12, 8]
         ])
       }
     }),
-    admin4Background: renderPass10({
+    admin4Background: renderPass13({
       placement: { below: "boundaries.admin4" },
       feature: "boundary",
       renderer: "line",
@@ -11937,17 +12802,17 @@ function streetsBoundaryRenderStack() {
         ]
       },
       style: {
-        blur: zoom10.linear([
+        blur: zoom13.linear([
           [3, 0],
           [12, 1]
         ]),
         color: streetsVisual.boundary.halo,
         minZoom: 2,
-        opacity: zoom10.linear([
+        opacity: zoom13.linear([
           [2, 0],
           [4, 0.42]
         ]),
-        width: zoom10.linear([
+        width: zoom13.linear([
           [3, 2.4],
           [6, 3.1],
           [12, 4.2]
@@ -11958,7 +12823,7 @@ function streetsBoundaryRenderStack() {
     // module deliberately exposes only the stable admin-2/admin-4 pair.
     // Standard uses the next tier as a restrained dotted municipal cue from
     // metro zooms onward, so Streets adds it as an explicit semantic pass.
-    admin6: renderPass10({
+    admin6: renderPass13({
       placement: { above: "boundaries.admin4" },
       feature: "boundary",
       renderer: "line",
@@ -11987,12 +12852,12 @@ function streetsBoundaryRenderStack() {
         color: streetsVisual.boundary.regional,
         dash: [1, 1.5],
         minZoom: 8,
-        opacity: zoom10.linear([
+        opacity: zoom13.linear([
           [8, 0],
           [9, 0.5],
           [12, 0.68]
         ]),
-        width: zoom10.linear([
+        width: zoom13.linear([
           [8, 0.45],
           [10, 0.7],
           [12, 0.95]
@@ -12005,7 +12870,7 @@ function streetsLandRenderStack() {
   return {
     // Core orders general cover, parks, lawn detail and mapped built surfaces.
     // Streets adds only its own business-corridor treatment.
-    businessArea: renderPass10({
+    businessArea: renderPass13({
       placement: { above: "land.landuse.residential.fill" },
       feature: "landuse",
       renderer: "fill",
@@ -12018,7 +12883,7 @@ function streetsLandRenderStack() {
     })
   };
 }
-var hedgeWidth = zoom10.linear([
+var hedgeWidth = zoom13.linear([
   [15, 0.6],
   [16, 1],
   [18, 2],
@@ -12029,7 +12894,7 @@ var streetsBarriers = {
     line: {
       color: streetsVisual.barrier.fence,
       minZoom: 16,
-      width: zoom10.linear([
+      width: zoom13.linear([
         [16, 1],
         [20, 3]
       ])
@@ -12039,7 +12904,7 @@ var streetsBarriers = {
     line: {
       color: streetsVisual.barrier.wall,
       minZoom: 16,
-      width: zoom10.linear([
+      width: zoom13.linear([
         [16, 1],
         [20, 3.5]
       ])
@@ -12052,7 +12917,7 @@ var streetsBarriers = {
       color: streetsVisual.barrier.hedgeShade,
       join: "round",
       minZoom: 17,
-      opacity: zoom10.linear([
+      opacity: zoom13.linear([
         [17, 0],
         [18, 0.7]
       ]),
@@ -12073,7 +12938,7 @@ function streetsBuildingRenderStack() {
     // Keep just enough ambient separation for dense footprint clusters. The
     // fill and its close-colour outline carry the 2D building hierarchy; a
     // dark shadow at z15 would turn every footprint into a heavy sticker.
-    flatShadow: renderPass10({
+    flatShadow: renderPass13({
       placement: { below: "buildings.flat.fill" },
       feature: "building",
       renderer: "line",
@@ -12081,7 +12946,7 @@ function streetsBuildingRenderStack() {
         blur: 2,
         color: buildingShadowColor,
         minZoom: 15.5,
-        opacity: zoom10.linear([
+        opacity: zoom13.linear([
           [15.5, 0],
           [16, 0.03],
           [18, 0.08],
@@ -12089,7 +12954,7 @@ function streetsBuildingRenderStack() {
         ]),
         translate: [0.5, 0.75],
         translateAnchor: "viewport",
-        width: zoom10.linear([
+        width: zoom13.linear([
           [15.5, 0.5],
           [16, 1],
           [18, 3],
@@ -12097,7 +12962,7 @@ function streetsBuildingRenderStack() {
         ])
       }
     }),
-    shadowSoft: renderPass10({
+    shadowSoft: renderPass13({
       placement: { below: "buildings.flat.fill" },
       feature: "building",
       renderer: "line",
@@ -12105,7 +12970,7 @@ function streetsBuildingRenderStack() {
       style: {
         // A diffuse contact band, not a displaced footprint. It stays attached
         // to the walls when the camera rotates and fades in at street detail.
-        blur: zoom10.linear([
+        blur: zoom13.linear([
           [15.5, 2],
           [18, 6],
           [20, 10]
@@ -12114,14 +12979,14 @@ function streetsBuildingRenderStack() {
         color: streetsVisual.building.contactShadow,
         join: "round",
         minZoom: 15.5,
-        opacity: zoom10.linear([
+        opacity: zoom13.linear([
           [15.5, 0],
           [16.5, 0.12],
           [18, 0.22],
           [20, 0.24]
         ]),
         visibilityGroup: "building",
-        width: zoom10.linear([
+        width: zoom13.linear([
           [15.5, 1],
           [16.5, 4],
           [18, 10],
@@ -12129,13 +12994,13 @@ function streetsBuildingRenderStack() {
         ])
       }
     }),
-    shadowCore: renderPass10({
+    shadowCore: renderPass13({
       placement: { below: "buildings.flat.fill" },
       feature: "building",
       renderer: "line",
       selector: groundedBuilding3dSelector,
       style: {
-        blur: zoom10.linear([
+        blur: zoom13.linear([
           [15.5, 0.5],
           [18, 1.5],
           [20, 2.5]
@@ -12144,14 +13009,14 @@ function streetsBuildingRenderStack() {
         color: streetsVisual.building.contactShadow,
         join: "round",
         minZoom: 15.5,
-        opacity: zoom10.linear([
+        opacity: zoom13.linear([
           [15.5, 0],
           [16.5, 0.08],
           [18, 0.16],
           [20, 0.18]
         ]),
         visibilityGroup: "building",
-        width: zoom10.linear([
+        width: zoom13.linear([
           [15.5, 0.5],
           [16.5, 1],
           [18, 2.5],
@@ -12159,7 +13024,7 @@ function streetsBuildingRenderStack() {
         ])
       }
     }),
-    extrusion: renderPass10({
+    extrusion: renderPass13({
       // Keep raised geometry after the ground names, which already cover flat footprints.
       placement: "above-buildings",
       feature: "building",
@@ -12179,7 +13044,7 @@ function streetsBuildingRenderStack() {
 }
 function streetsLabelRenderStack() {
   return {
-    ferry: renderPass10({
+    ferry: renderPass13({
       feature: "roadName",
       placement: "below-labels",
       renderer: "symbol",
@@ -12202,7 +13067,7 @@ function streetsLabelRenderStack() {
         placement: "line",
         spacing: 250,
         text: {
-          field: expr12.get(field11("name")),
+          field: expr14.get(field14("name")),
           font: streetsVisual.font.default,
           color: streetsVisual.label.ferry,
           haloColor: streetsVisual.label.ferryHalo,
@@ -12213,7 +13078,7 @@ function streetsLabelRenderStack() {
           padding: 1,
           pitchAlignment: "viewport",
           rotationAlignment: "map",
-          size: zoom10.linear([
+          size: zoom13.linear([
             [10, 6.5],
             [18, 13]
           ]),
@@ -12221,7 +13086,7 @@ function streetsLabelRenderStack() {
         }
       }
     }),
-    settlementMarker: renderPass10({
+    settlementMarker: renderPass13({
       placement: { below: "labels.places.city" },
       feature: "place",
       renderer: "circle",
@@ -12230,7 +13095,7 @@ function streetsLabelRenderStack() {
         color: streetsVisual.label.settlement,
         maxZoom: 8,
         minZoom: 2,
-        radius: expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 3, [
+        radius: expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 3, [
           [3, 2.5],
           [7, 2]
         ]),
@@ -12238,7 +13103,7 @@ function streetsLabelRenderStack() {
         strokeWidth: 0.8
       }
     }),
-    country: refineRenderTarget5({
+    country: refineRenderTarget6({
       renderer: "symbol",
       selector: {
         kind: "all",
@@ -12258,7 +13123,7 @@ function streetsLabelRenderStack() {
       style: {},
       target: "labels.places.country"
     }),
-    state: refineRenderTarget5({
+    state: refineRenderTarget6({
       renderer: "symbol",
       selector: {
         kind: "all",
@@ -12282,13 +13147,13 @@ function streetsLabelRenderStack() {
       style: {},
       target: "labels.places.state"
     }),
-    city: refineRenderTarget5({
+    city: refineRenderTarget6({
       renderer: "symbol",
       selector: namedCitySelector,
       style: {},
       target: "labels.places.city"
     }),
-    town: refineRenderTarget5({
+    town: refineRenderTarget6({
       renderer: "symbol",
       selector: {
         kind: "all",
@@ -12309,7 +13174,7 @@ function streetsLabelRenderStack() {
       style: {},
       target: "labels.places.town"
     }),
-    village: refineRenderTarget5({
+    village: refineRenderTarget6({
       renderer: "symbol",
       selector: {
         kind: "all",
@@ -12331,7 +13196,7 @@ function streetsLabelRenderStack() {
       style: {},
       target: "labels.places.village"
     }),
-    neighborhood: refineRenderTarget5({
+    neighborhood: refineRenderTarget6({
       renderer: "symbol",
       selector: {
         kind: "all",
@@ -12370,14 +13235,14 @@ function cityRoadSurfaceColor(roadClass) {
   const outputs = stops.map(
     ([level, color]) => [
       level,
-      expr12.case(
+      expr14.case(
         [
           {
-            when: expr12.eq(expr12.get(field11("class")), `${roadClass}_construction`),
+            when: expr14.eq(expr14.get(field14("class")), `${roadClass}_construction`),
             value: roadSurfaceColor
           },
           {
-            when: expr12.eq(expr12.get(field11("surface")), "unpaved"),
+            when: expr14.eq(expr14.get(field14("surface")), "unpaved"),
             value: level >= 12 && level < 15 ? streetsCityRoadPalette[roadClass] : roadSurfaceColor
           }
         ],
@@ -12385,7 +13250,7 @@ function cityRoadSurfaceColor(roadClass) {
       )
     ]
   );
-  return expr12.interpolate({ kind: "linear" }, expr12.zoom(), [
+  return expr14.interpolate({ kind: "linear" }, expr14.zoom(), [
     outputs[0],
     ...outputs.slice(1)
   ]);
@@ -12395,7 +13260,7 @@ function streetsRoadEligibility() {
     ["motorway", "trunk", "primary", "secondary", "tertiary"].flatMap(
       (roadClass) => ["fill", "rampFill"].map((phase) => [
         `${roadClass}-surface-${phase}-eligibility`,
-        refineRenderTarget5({
+        refineRenderTarget6({
           renderer: "line",
           selector: {
             kind: "all",
@@ -12444,7 +13309,7 @@ function streetsRoadEligibility() {
 }
 function streetsRoadRenderStack() {
   return {
-    pedestrianGround: refineRenderTarget5({
+    pedestrianGround: refineRenderTarget6({
       // Walkable ground covers commercial zoning, while explicit grass, gardens
       // and parks remain above broad pedestrian complexes. Share the canonical
       // anchor with the earlier business-area pass; replacement land modules do
@@ -12455,17 +13320,17 @@ function streetsRoadRenderStack() {
     }),
     ...parkPathRefinements(),
     ...streetsRoadEligibility(),
-    minorSurfaceColor: refineRenderTarget5({
+    minorSurfaceColor: refineRenderTarget6({
       renderer: "line",
       style: { color: cityRoadSurfaceColor("minor") },
       target: "roads.classes.minor.surface.fill"
     }),
-    minorLinkColor: refineRenderTarget5({
+    minorLinkColor: refineRenderTarget6({
       renderer: "line",
       style: { color: cityRoadSurfaceColor("minor") },
       target: "roads.classes.minor.surface.rampFill"
     }),
-    oneWayMarkers: refineRenderTarget5({
+    oneWayMarkers: refineRenderTarget6({
       renderer: "symbol",
       style: {
         icon: {
@@ -12473,19 +13338,19 @@ function streetsRoadRenderStack() {
           ignorePlacement: true,
           image: streetsVisual.image.oneway,
           keepUpright: false,
-          opacity: expr12.interpolate({ kind: "linear" }, expr12.zoom(), [
+          opacity: expr14.interpolate({ kind: "linear" }, expr14.zoom(), [
             [16.5, 0],
             [17, 0.92],
             [17.5, 1]
           ]),
           padding: 0,
           pitchAlignment: "map",
-          rotate: expr12.case(
-            [{ when: expr12.eq(expr12.get(field11("oneway")), -1), value: 180 }],
+          rotate: expr14.case(
+            [{ when: expr14.eq(expr14.get(field14("oneway")), -1), value: 180 }],
             0
           ),
           rotationAlignment: "map",
-          size: expr12.interpolate({ kind: "linear" }, expr12.zoom(), [
+          size: expr14.interpolate({ kind: "linear" }, expr14.zoom(), [
             [15, 0.38],
             [17, 0.55],
             [19, 0.7],
@@ -12493,7 +13358,7 @@ function streetsRoadRenderStack() {
           ])
         },
         minZoom: 16.5,
-        spacing: expr12.interpolate({ kind: "linear" }, expr12.zoom(), [
+        spacing: expr14.interpolate({ kind: "linear" }, expr14.zoom(), [
           [15, 95],
           [17, 115],
           [19, 150],
@@ -12501,8 +13366,8 @@ function streetsRoadRenderStack() {
         ]),
         text: {
           allowOverlap: true,
-          field: expr12.case(
-            [{ when: expr12.eq(expr12.get(field11("oneway")), -1), value: "\u2190" }],
+          field: expr14.case(
+            [{ when: expr14.eq(expr14.get(field14("oneway")), -1), value: "\u2190" }],
             "\u2192"
           ),
           ignorePlacement: true,
@@ -12511,7 +13376,7 @@ function streetsRoadRenderStack() {
           padding: 0,
           pitchAlignment: "map",
           rotationAlignment: "map",
-          size: expr12.interpolate({ kind: "linear" }, expr12.zoom(), [
+          size: expr14.interpolate({ kind: "linear" }, expr14.zoom(), [
             [15, 11],
             [17, 17],
             [19, 20],
@@ -12556,12 +13421,12 @@ function cityRoadStyle(color, widths2, options = {}) {
     tunnelVisible = true
   } = options;
   const zoomRange = minZoom === void 0 ? {} : { minZoom };
-  const opacity = zoom10.linear([
+  const opacity = zoom13.linear([
     [3, 0],
     [3.5, 1]
   ]);
-  const surfaceColor = colorStops ? zoom10.linear(colorStops) : color;
-  const resolvedCasingColor = zoom10.linear(roadCasingColorStops(casingColorStops));
+  const surfaceColor = colorStops ? zoom13.linear(colorStops) : color;
+  const resolvedCasingColor = zoom13.linear(roadCasingColorStops(casingColorStops));
   const fill = {
     ...zoomRange,
     cap: roadLineCap,
@@ -12587,8 +13452,6 @@ function cityRoadStyle(color, widths2, options = {}) {
     surface: { casing, fill },
     bridge: {
       casing: { ...casing, cap: "butt", join: "miter", width: roadCasingWidth((minZoom ?? 0) < 12) },
-      // Local structures join their streets at z12; major structures take over
-      // the continuous overview strokes at z13.
       fill: {
         ...fill,
         cap: "round",
@@ -12603,7 +13466,7 @@ function cityRoadStyle(color, widths2, options = {}) {
         join: "miter",
         minZoom: minZoom === 3 ? 13 : (minZoom ?? 0) < 12 ? 14 : minZoom === 12 ? 15 : 16,
         // Standard's HD setting unifies carriageway borders at z15, including tunnels.
-        color: expr12.step(expr12.zoom(), tunnelCasingColor, [
+        color: expr14.step(expr14.zoom(), tunnelCasingColor, [
           [15, mapboxRoadPalette.detailCasing]
         ]),
         dash: tunnelBorderDash,
@@ -12617,7 +13480,7 @@ function cityRoadStyle(color, widths2, options = {}) {
         join: "miter",
         minZoom: Math.max(minZoom ?? 0, minZoom === 12 ? 12 : 13),
         color: tunnelColor,
-        opacity: zoom10.linear([
+        opacity: zoom13.linear([
           [3, 0],
           [3.5, 0.8]
         ])
@@ -12635,7 +13498,7 @@ function cityRoadStyle(color, widths2, options = {}) {
 }
 function pathRoadStyle(color, widths2, options = {}) {
   const zoomRange = options.minZoom === void 0 ? {} : { minZoom: options.minZoom };
-  const surfaceColor = options.colorStops ? zoom10.linear(options.colorStops) : color;
+  const surfaceColor = options.colorStops ? zoom13.linear(options.colorStops) : color;
   const cap = options.steps ? "butt" : pathLineCap;
   const tunnelCap = "butt";
   const join = options.steps ? "round" : pathLineJoin;
@@ -12696,8 +13559,8 @@ function roadLabelStyle(kind, minZoom) {
     minZoom,
     // Resolve dense parallel streets by road hierarchy, not incidental tile order.
     // All classes share this expression so the compiler retains one collision network.
-    priority: expr12.match(
-      expr12.coalesce(expr12.get(field11("class")), "minor"),
+    priority: expr14.match(
+      expr14.coalesce(expr14.get(field14("class")), "minor"),
       [
         { labels: ["motorway", "motorway_construction"], value: 6 },
         { labels: ["trunk", "trunk_construction"], value: 5 },
@@ -12710,7 +13573,7 @@ function roadLabelStyle(kind, minZoom) {
     ),
     // World name geometry is split into more short segments at street detail.
     // Increase repeat distance gently without thinning the overview network.
-    spacing: zoom10.linear([
+    spacing: zoom13.linear([
       [13, 250],
       [15, 300],
       [17, 400],
@@ -12726,14 +13589,14 @@ function roadLabelStyle(kind, minZoom) {
       maxAngle: 30,
       // Screen-space breathing room at city overview. Restore normal padding by z14
       // so the same policy does not suppress useful names on the neighbourhood view.
-      padding: zoom10.linear([
+      padding: zoom13.linear([
         [13, 5],
         [14, 1]
       ]),
       // Follow the road's bearing while retaining readable glyph height in perspective.
       pitchAlignment: "viewport",
       rotationAlignment: "map",
-      size: zoom10.linear([
+      size: zoom13.linear([
         [10, startSize],
         [18, endSize]
       ]),
@@ -12741,8 +13604,8 @@ function roadLabelStyle(kind, minZoom) {
     }
   };
 }
-var streets = bindOfficialMapTheme(
-  defineMap7({
+var streetsBase = bindOfficialMapTheme(
+  defineMap8({
     id: "streets",
     version: 1,
     name: "Streets",
@@ -12762,12 +13625,13 @@ var streets = bindOfficialMapTheme(
     systemThemes: { light: "light", dark: "dark" },
     projection: "globe",
     // 'globe' | 'mercator'. Globe becomes planar at street zooms.
+    camera: { adaptivePerspective: true, pitchLimit: { maxZoom: 15, maxPitch: 38 } },
     // Each theme paints the sky seen when the camera tilts up the street; night shows stars.
     sky: {
-      color: token9.color("sky.color"),
-      horizonColor: token9.color("sky.horizon"),
-      horizonBlend: token9.number("sky.horizonBlend"),
-      glowColor: token9.color("sky.glow"),
+      color: token13.color("sky.color"),
+      horizonColor: token13.color("sky.horizon"),
+      horizonBlend: token13.number("sky.horizonBlend"),
+      glowColor: token13.color("sky.glow"),
       starIntensity: 0.6
     },
     data: {
@@ -12813,14 +13677,14 @@ var streets = bindOfficialMapTheme(
             haloWidth: 1,
             maxWidth: 10,
             padding: 20,
-            size: zoom10.linear([
+            size: zoom13.linear([
               [18, 11],
               [20, 13]
             ])
           }
         }
       }),
-      land: withRenderStack10(
+      land: withRenderStack11(
         land7({
           barriers: streetsBarriers,
           background: {
@@ -12828,8 +13692,8 @@ var streets = bindOfficialMapTheme(
             opacity: 1
           },
           globalLandcover: {
-            color: expr12.match(
-              expr12.get(field11("class")),
+            color: expr14.match(
+              expr14.get(field14("class")),
               [
                 { labels: "barren", value: streetsGlobalLandcoverPalette.barren },
                 { labels: "crop", value: streetsGlobalLandcoverPalette.crop },
@@ -12995,9 +13859,9 @@ var streets = bindOfficialMapTheme(
       water: water7({
         bathymetry: {
           antialias: false,
-          color: expr12.interpolate(
+          color: expr14.interpolate(
             { kind: "linear" },
-            expr12.multiply(-1, expr12.toNumber(expr12.get(field11("bathymetryMinDepth")), 0)),
+            expr14.multiply(-1, expr14.toNumber(expr14.get(field14("bathymetryMinDepth")), 0)),
             [
               [0, streetsSurfacePalette.waterDepth0],
               [200, streetsSurfacePalette.waterDepth200],
@@ -13007,7 +13871,7 @@ var streets = bindOfficialMapTheme(
           ),
           maxZoom: 8,
           minZoom: 0,
-          opacity: zoom10.linear([
+          opacity: zoom13.linear([
             [0, 1],
             [6, 1],
             [8, 0]
@@ -13037,7 +13901,7 @@ var streets = bindOfficialMapTheme(
             join: "round",
             minZoom: 8,
             opacity: 0.96,
-            width: zoom10.linear([
+            width: zoom13.linear([
               [8, 0.35],
               [13, 1.05],
               [16, 2.2]
@@ -13049,7 +13913,7 @@ var streets = bindOfficialMapTheme(
             join: "round",
             minZoom: 12,
             opacity: 0.92,
-            width: zoom10.linear([
+            width: zoom13.linear([
               [12, 0.35],
               [14, 0.8],
               [16, 1.4]
@@ -13061,7 +13925,7 @@ var streets = bindOfficialMapTheme(
             join: "round",
             minZoom: 6,
             opacity: 0.96,
-            width: zoom10.linear([
+            width: zoom13.linear([
               [6, 0.45],
               [13, 1.25],
               [16, 3.2]
@@ -13073,7 +13937,7 @@ var streets = bindOfficialMapTheme(
             join: "round",
             minZoom: 10,
             opacity: 0.94,
-            width: zoom10.linear([
+            width: zoom13.linear([
               [10, 0.3],
               [12, 0.55],
               [13, 0.9],
@@ -13084,7 +13948,7 @@ var streets = bindOfficialMapTheme(
         }
       }),
       vegetation: streetsTrees,
-      boundaries: withRenderStack10(
+      boundaries: withRenderStack11(
         boundaries7({
           // Mapbox Standard's admin-0/admin-1 layers map to OpenMapTiles
           // admin_level 2/4 respectively.
@@ -13093,7 +13957,7 @@ var streets = bindOfficialMapTheme(
             dash: [10, 0],
             minZoom: 1,
             opacity: 1,
-            width: zoom10.linear([
+            width: zoom13.linear([
               [3, 0.8],
               [6, 1.35],
               [12, 2.1]
@@ -13103,11 +13967,11 @@ var streets = bindOfficialMapTheme(
             color: streetsOverviewPalette.admin1,
             dash: [3, 2],
             minZoom: 2,
-            opacity: zoom10.linear([
+            opacity: zoom13.linear([
               [2, 0],
               [3, 1]
             ]),
-            width: zoom10.linear([
+            width: zoom13.linear([
               [3, 0.7],
               [6, 1.2],
               [12, 1.8]
@@ -13115,12 +13979,12 @@ var streets = bindOfficialMapTheme(
           },
           disputed: {
             color: streetsOverviewPalette.admin0,
-            dash: expr12.step(expr12.zoom(), expr12.literal([3, 2, 5]), [
-              [7, expr12.literal([2, 1.5])]
+            dash: expr14.step(expr14.zoom(), expr14.literal([3, 2, 5]), [
+              [7, expr14.literal([2, 1.5])]
             ]),
             minZoom: 1,
             opacity: 1,
-            width: zoom10.linear([
+            width: zoom13.linear([
               [3, 0.5],
               [12, 2]
             ])
@@ -13151,7 +14015,7 @@ var streets = bindOfficialMapTheme(
             // At city detail these white markings wash out otherwise matching
             // road fills. Introduce them with the closer street-level detail.
             minZoom: 16.5,
-            opacity: zoom10.linear([
+            opacity: zoom13.linear([
               [16.5, 0],
               [17, 1]
             ])
@@ -13484,14 +14348,14 @@ var streets = bindOfficialMapTheme(
             cycleway: pathRoadStyle(mapboxRoadPalette.cycleway, mapboxPathWidthStops, {
               casingColor: mapboxRoadPalette.pathCasing,
               casingGapWidth: roadWidth(mapboxPathWidthStops, 1),
-              fillOpacity: zoom10.linear([
+              fillOpacity: zoom13.linear([
                 [15, 0],
                 [16, 1]
               ]),
               minZoom: 15,
               underlay: {
                 cap: pathLineCap,
-                color: zoom10.linear([
+                color: zoom13.linear([
                   [15, mapboxRoadPalette.pathAtZ15],
                   [16, mapboxRoadPalette.pathFromZ16]
                 ]),
@@ -13500,7 +14364,7 @@ var streets = bindOfficialMapTheme(
                 opacity: 1,
                 width: roadWidth(mapboxPathWidthStops, 1)
               },
-              width: zoom10.linear([
+              width: zoom13.linear([
                 [12, 0],
                 [18, 2],
                 [22, 20]
@@ -13534,88 +14398,80 @@ var streets = bindOfficialMapTheme(
         ferry: {
           color: streetsVisual.road.ferry,
           minZoom: 8,
-          dash: expr12.step(expr12.zoom(), expr12.literal([1, 0]), [
-            [13, expr12.literal([12, 4])]
+          dash: expr14.step(expr14.zoom(), expr14.literal([1, 0]), [
+            [13, expr14.literal([12, 4])]
           ]),
-          opacity: zoom10.linear([
+          opacity: zoom13.linear([
             [8, 0],
             [17, 1]
           ]),
-          width: zoom10.exponential(1.5, [
+          width: zoom13.exponential(1.5, [
             [14, 0.5],
             [20, 1]
           ])
         }
       }),
-      buildings: withRenderStack10(
+      buildings: withRenderStack11(
         buildings6({
           // Footprints; the render stack's extrusion pass raises them from z15, and its shadows
           // stand beside the flat fill, so they require this mode.
           mode: "flat",
           threeDimensional: {
+            flatFootprints: false,
+            entrance: { buildings: [14.25, 14.25], models: [14.25, 14.25] },
             edgeRadius: 1.5,
-            groundOcclusion: 0.12,
+            groundOcclusion: 0.1,
+            groundOcclusionRadius: 1.5,
             // Models name pools, planting and timber with these parts to follow the map's colours.
             modelColors: {
-              surface: token9.color("buildings.modelSurface"),
-              secondary: token9.color("buildings.modelSecondary"),
-              roof: token9.color("buildings.modelRoof"),
-              accent: token9.color("buildings.modelAccent"),
-              water: token9.color("buildings.modelWater"),
-              vegetation: token9.color("buildings.modelVegetation"),
-              wood: token9.color("buildings.modelWood")
+              surface: token13.color("buildings.modelSurface"),
+              secondary: token13.color("buildings.modelSecondary"),
+              roof: token13.color("buildings.modelRoof"),
+              accent: token13.color("buildings.modelAccent"),
+              glass: token13.color("buildings.modelGlass"),
+              water: token13.color("buildings.modelWater"),
+              vegetation: token13.color("buildings.modelVegetation"),
+              wood: token13.color("buildings.modelWood")
             },
             floodLight: {
-              intensity: token9.number("buildings.floodLight.intensity"),
-              brightnessScale: token9.number("buildings.floodLight.brightnessScale"),
-              color: token9.color("buildings.floodLight")
+              intensity: token13.number("buildings.floodLight.intensity"),
+              brightnessScale: token13.number("buildings.floodLight.brightnessScale"),
+              color: token13.color("buildings.floodLight")
             },
             modelLighting: {
               wall: {
                 shading: "map",
-                ambientOcclusion: 0.32,
-                color: token9.color("buildings.modelSurface"),
+                ambientOcclusion: 0.5,
+                color: token13.color("buildings.modelSurface"),
                 roughness: 1,
                 metallic: 0
               },
               roof: {
                 shading: "map",
-                ambientOcclusion: 0.32,
-                color: token9.color("buildings.modelRoof"),
+                ambientOcclusion: 0.45,
+                color: token13.color("buildings.modelRoof"),
                 roughness: 1,
                 metallic: 0
               },
               window: {
-                // Glass keeps its original role colour even on a shared stone part.
+                shading: "map",
+                ambientOcclusion: 0.4,
+                color: token13.color("buildings.modelGlass"),
+                colorScale: 0.96,
+                // Glazing keeps its material even when it shares a named stone part.
                 partColorMix: 0,
-                roughness: 0,
-                metallic: 1,
-                emissiveStrength: token9.number("buildings.modelWindow.strength"),
-                emissiveVariation: token9.number("buildings.modelWindow.variation"),
-                emissiveHeight: [0, 0.9, 0, 1, 0.5],
-                colorVariation: {
-                  hue: [
-                    token9.number("buildings.modelWindow.hueLow"),
-                    token9.number("buildings.modelWindow.hueHigh")
-                  ],
-                  saturation: [
-                    token9.number("buildings.modelWindow.saturationLow"),
-                    token9.number("buildings.modelWindow.saturationHigh")
-                  ],
-                  lightness: [
-                    token9.number("buildings.modelWindow.lightnessLow"),
-                    token9.number("buildings.modelWindow.lightnessHigh")
-                  ],
-                  space: "linear"
-                }
+                roughness: 1,
+                metallic: 0,
+                emissiveStrength: 0,
+                emissiveVariation: 0
               },
               ...Object.fromEntries(
                 ["unclassified", "door", "lamp", "logo"].map((role) => [
                   role,
                   {
                     shading: "map",
-                    ambientOcclusion: 0.32,
-                    color: token9.color("buildings.modelSurface"),
+                    ambientOcclusion: 0.5,
+                    color: token13.color("buildings.modelSurface"),
                     roughness: 1,
                     metallic: 0
                   }
@@ -13634,7 +14490,7 @@ var streets = bindOfficialMapTheme(
             fill: {
               color: buildingFillColor,
               minZoom: 14.25,
-              opacity: zoom10.linear([
+              opacity: zoom13.linear([
                 [14.25, 0],
                 [14.75, 0.5],
                 [15, 1]
@@ -13643,14 +14499,14 @@ var streets = bindOfficialMapTheme(
             outline: {
               color: buildingOutlineColor,
               minZoom: 14.5,
-              opacity: zoom10.linear([
+              opacity: zoom13.linear([
                 [14.5, 0],
                 [15, 0.6],
                 [16, 0.82],
                 [17, 0.96],
                 [18, 1]
               ]),
-              width: zoom10.linear([
+              width: zoom13.linear([
                 [14.5, 0.25],
                 [15, 0.4],
                 [16, 0.65],
@@ -13662,7 +14518,7 @@ var streets = bindOfficialMapTheme(
         }),
         streetsBuildingRenderStack()
       ),
-      labels: withRenderStack10(
+      labels: withRenderStack11(
         labels7({
           collisionPriority: "navigation",
           language: "local",
@@ -13728,12 +14584,12 @@ var streets = bindOfficialMapTheme(
                   letterSpacing: 0.05,
                   lineHeight: 1.1,
                   maxWidth: 6,
-                  opacity: zoom10.linear([
+                  opacity: zoom13.linear([
                     [0, 0.8],
                     [1.5, 0.5],
                     [2.5, 0.5]
                   ]),
-                  size: zoom10.exponential(0.5, [
+                  size: zoom13.exponential(0.5, [
                     [0, 10],
                     [2.5, 15]
                   ]),
@@ -13752,24 +14608,24 @@ var streets = bindOfficialMapTheme(
                   lineHeight: 1.1,
                   maxWidth: 6,
                   padding: 3,
-                  radialOffset: zoom10.step([
+                  radialOffset: zoom13.step([
                     [1, 0.6],
                     [8, 0]
                   ]),
-                  size: expr12.interpolate(
+                  size: expr14.interpolate(
                     { kind: "cubic-bezier", x1: 0.2, x2: 0.7, y1: 0, y2: 1 },
-                    expr12.zoom(),
+                    expr14.zoom(),
                     [
                       [
                         1,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 11, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 11, [
                           [4, 9],
                           [5, 8]
                         ])
                       ],
                       [
                         9,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 22, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 22, [
                           [4, 19],
                           [5, 17]
                         ])
@@ -13791,20 +14647,20 @@ var streets = bindOfficialMapTheme(
                   letterSpacing: 0.15,
                   maxWidth: 6,
                   opacity: 0.5,
-                  size: expr12.interpolate(
+                  size: expr14.interpolate(
                     { kind: "cubic-bezier", x1: 0.85, x2: 0.65, y1: 0.7, y2: 1 },
-                    expr12.zoom(),
+                    expr14.zoom(),
                     [
                       [
                         4,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 9, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 9, [
                           [6, 8],
                           [7, 7]
                         ])
                       ],
                       [
                         9,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 21, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 21, [
                           [6, 16],
                           [7, 14]
                         ])
@@ -13817,9 +14673,9 @@ var streets = bindOfficialMapTheme(
               city: {
                 minZoom: 2,
                 maxZoom: 15,
-                priority: expr12.subtract(100, expr12.coalesce(expr12.get(field11("rank")), 20)),
+                priority: expr14.subtract(100, expr14.coalesce(expr14.get(field14("rank")), 20)),
                 text: {
-                  color: zoom10.linear([
+                  color: zoom13.linear([
                     [2, streetsOverviewPalette.label],
                     [4, streetsOverviewPalette.label],
                     [6, streetsVisual.label.settlement]
@@ -13830,32 +14686,32 @@ var streets = bindOfficialMapTheme(
                   lineHeight: 1.1,
                   maxWidth: 7,
                   padding: 1,
-                  radialOffset: zoom10.step([
+                  radialOffset: zoom13.step([
                     [2, 0.6],
                     [8, 0]
                   ]),
-                  size: expr12.interpolate(
+                  size: expr14.interpolate(
                     { kind: "cubic-bezier", x1: 0.2, x2: 0.9, y1: 0, y2: 1 },
-                    expr12.zoom(),
+                    expr14.zoom(),
                     [
-                      [3, expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 13, [[6, 11]])],
+                      [3, expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 13, [[6, 11]])],
                       [
                         6,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 18, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 18, [
                           [6, 16],
                           [7, 14]
                         ])
                       ],
                       [
                         8,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 20, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 20, [
                           [9, 16],
                           [10, 14]
                         ])
                       ],
                       [
                         15,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 24, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 24, [
                           [9, 20],
                           [12, 16],
                           [15, 14]
@@ -13870,7 +14726,7 @@ var streets = bindOfficialMapTheme(
               town: {
                 minZoom: 2,
                 maxZoom: 13,
-                priority: expr12.subtract(80, expr12.coalesce(expr12.get(field11("rank")), 20)),
+                priority: expr14.subtract(80, expr14.coalesce(expr14.get(field14("rank")), 20)),
                 text: {
                   color: streetsVisual.label.settlement,
                   haloColor: streetsVisual.label.placeHalo,
@@ -13879,25 +14735,25 @@ var streets = bindOfficialMapTheme(
                   lineHeight: 1.1,
                   maxWidth: 7,
                   padding: 1,
-                  radialOffset: zoom10.step([
+                  radialOffset: zoom13.step([
                     [2, 0.55],
                     [8, 0]
                   ]),
-                  size: expr12.interpolate(
+                  size: expr14.interpolate(
                     { kind: "cubic-bezier", x1: 0.2, x2: 0.9, y1: 0, y2: 1 },
-                    expr12.zoom(),
+                    expr14.zoom(),
                     [
-                      [3, expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 11, [[9, 10]])],
+                      [3, expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 11, [[9, 10]])],
                       [
                         6,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 14, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 14, [
                           [9, 12],
                           [12, 10]
                         ])
                       ],
                       [
                         8,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 16, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 16, [
                           [9, 14],
                           [12, 12],
                           [15, 10]
@@ -13905,7 +14761,7 @@ var streets = bindOfficialMapTheme(
                       ],
                       [
                         13,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 22, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 22, [
                           [9, 20],
                           [12, 16],
                           [15, 14]
@@ -13929,7 +14785,7 @@ var streets = bindOfficialMapTheme(
               village: {
                 minZoom: 2,
                 maxZoom: 13,
-                priority: expr12.subtract(65, expr12.coalesce(expr12.get(field11("rank")), 20)),
+                priority: expr14.subtract(65, expr14.coalesce(expr14.get(field14("rank")), 20)),
                 text: {
                   color: streetsVisual.label.settlement,
                   haloColor: streetsVisual.label.placeHalo,
@@ -13938,25 +14794,25 @@ var streets = bindOfficialMapTheme(
                   lineHeight: 1.1,
                   maxWidth: 7,
                   padding: 1,
-                  radialOffset: zoom10.step([
+                  radialOffset: zoom13.step([
                     [2, 0.55],
                     [8, 0]
                   ]),
-                  size: expr12.interpolate(
+                  size: expr14.interpolate(
                     { kind: "cubic-bezier", x1: 0.2, x2: 0.9, y1: 0, y2: 1 },
-                    expr12.zoom(),
+                    expr14.zoom(),
                     [
-                      [3, expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 11, [[9, 10]])],
+                      [3, expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 11, [[9, 10]])],
                       [
                         6,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 14, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 14, [
                           [9, 12],
                           [12, 10]
                         ])
                       ],
                       [
                         8,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 16, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 16, [
                           [9, 14],
                           [12, 12],
                           [15, 10]
@@ -13964,7 +14820,7 @@ var streets = bindOfficialMapTheme(
                       ],
                       [
                         13,
-                        expr12.step(expr12.coalesce(expr12.get(field11("rank")), 99), 22, [
+                        expr14.step(expr14.coalesce(expr14.get(field14("rank")), 99), 22, [
                           [9, 20],
                           [12, 16],
                           [15, 14]
@@ -13988,37 +14844,37 @@ var streets = bindOfficialMapTheme(
               neighborhood: {
                 minZoom: 10,
                 maxZoom: 15,
-                priority: expr12.subtract(65, expr12.coalesce(expr12.get(field11("rank")), 20)),
+                priority: expr14.subtract(65, expr14.coalesce(expr14.get(field14("rank")), 20)),
                 text: {
                   font: streetsVisual.font.default,
                   color: streetsVisual.label.neighborhood,
                   haloColor: streetsVisual.label.placeHalo,
                   haloBlur: 0,
                   haloWidth: 1.3,
-                  letterSpacing: expr12.match(
-                    expr12.get(field11("class")),
+                  letterSpacing: expr14.match(
+                    expr14.get(field14("class")),
                     [{ labels: "suburb", value: 0.15 }],
                     0.05
                   ),
                   lineHeight: 1.1,
                   maxWidth: 7,
                   padding: 3,
-                  size: expr12.interpolate(
+                  size: expr14.interpolate(
                     { kind: "cubic-bezier", x1: 0.5, x2: 1, y1: 0, y2: 1 },
-                    expr12.zoom(),
+                    expr14.zoom(),
                     [
                       [
                         11,
-                        expr12.match(
-                          expr12.get(field11("class")),
+                        expr14.match(
+                          expr14.get(field14("class")),
                           [{ labels: "suburb", value: 12 }],
                           11.5
                         )
                       ],
                       [
                         15,
-                        expr12.match(
-                          expr12.get(field11("class")),
+                        expr14.match(
+                          expr14.get(field14("class")),
                           [{ labels: "suburb", value: 16 }],
                           15
                         )
@@ -14038,7 +14894,7 @@ var streets = bindOfficialMapTheme(
                   haloColor: streetsVisual.label.placeHalo,
                   haloBlur: 0.5,
                   haloWidth: 1,
-                  size: zoom10.linear([
+                  size: zoom13.linear([
                     [11, 10],
                     [15, 14]
                   ])
@@ -14090,12 +14946,11 @@ var streets = bindOfficialMapTheme(
                 minZoom: 6
               },
               detail: {
-                // World splits route lines more often than the reference source. A shorter
-                // interval keeps route references available in regional views; collision
-                // still suppresses adjacent shields, and street-scale repetition stays sparse.
-                spacing: zoom10.linear([
-                  [11, 220],
-                  [13, 300],
+                // Reserve room for the road network in metropolitan views; retain the
+                // existing street-detail interval from z14.
+                spacing: zoom13.linear([
+                  [11, token13.number("labels.shield.spacing11")],
+                  [13, token13.number("labels.shield.spacing13")],
                   [14, 600]
                 ])
               },
@@ -14124,7 +14979,7 @@ var streets = bindOfficialMapTheme(
                   haloColor: streetsVisual.label.waterHalo,
                   haloWidth: 0,
                   letterSpacing: 0.25,
-                  size: zoom10.linear([
+                  size: zoom13.linear([
                     [1, 12],
                     [8, 18]
                   ])
@@ -14139,7 +14994,7 @@ var streets = bindOfficialMapTheme(
                   color: streetsDetailPalette.waterText,
                   haloColor: streetsVisual.label.waterHalo,
                   haloWidth: 0,
-                  size: zoom10.linear([
+                  size: zoom13.linear([
                     [5, 11],
                     [14, 16]
                   ])
@@ -14154,8 +15009,8 @@ var streets = bindOfficialMapTheme(
                   color: streetsDetailPalette.waterText,
                   haloColor: streetsVisual.label.waterHalo,
                   haloWidth: 0,
-                  letterSpacing: expr12.match(
-                    expr12.get(field11("class")),
+                  letterSpacing: expr14.match(
+                    expr14.get(field14("class")),
                     [
                       { labels: "ocean", value: 0.25 },
                       { labels: ["sea", "bay"], value: 0.15 }
@@ -14163,7 +15018,7 @@ var streets = bindOfficialMapTheme(
                     0
                   ),
                   maxAngle: 30,
-                  size: zoom10.linear([
+                  size: zoom13.linear([
                     [1, 12],
                     [8, 18]
                   ])
@@ -14172,7 +15027,7 @@ var streets = bindOfficialMapTheme(
               waterway: {
                 minZoom: 13,
                 placement: "line",
-                spacing: zoom10.linear([
+                spacing: zoom13.linear([
                   [15, 250],
                   [17, 400]
                 ]),
@@ -14182,7 +15037,7 @@ var streets = bindOfficialMapTheme(
                   haloColor: streetsVisual.label.waterHalo,
                   haloWidth: 0,
                   maxAngle: 30,
-                  size: zoom10.linear([
+                  size: zoom13.linear([
                     [13, 12],
                     [18, 18]
                   ])
@@ -14200,7 +15055,7 @@ var streets = bindOfficialMapTheme(
                 letterSpacing: 0.01,
                 lineHeight: 1.1,
                 maxWidth: 9,
-                size: zoom10.linear([
+                size: zoom13.linear([
                   [8, 12],
                   [14, 15]
                 ])
@@ -14236,7 +15091,9 @@ var streets = bindOfficialMapTheme(
         detailZoom: 18,
         // World also calls botanical collections gardens. Keep only the main destinations;
         // zooming in must not turn individual planting sections into named POIs.
-        maxRankByType: { garden: 1 },
+        // Generic airport POIs can describe travel businesses or misplaced listings.
+        // Keep only the highest rank; mapped airports use labels.aerodrome.
+        maxRankByType: { airport: 0, garden: 1 },
         densityByCategory: {
           lodging: 1,
           "park-nature": 3,
@@ -14279,6 +15136,7 @@ var streets = bindOfficialMapTheme(
     }
   })
 );
+var streets = bindOfficialMapTheme(withStreetsCartography(streetsBase));
 
 // src/index.ts
 var baedeker2 = freezeOfficialMap(baedeker);