@tileflow/core 0.1.0-alpha.14 → 0.1.0-alpha.16

package/dist/index.js

@@ -115,7 +115,11 @@ var themePresets = {
 var defaultTypography = {
   font: "Noto Sans",
   fontFamily: "Noto Sans",
-  weight: "regular"
+  weight: "regular",
+  places: { font: "Noto Sans", fontFamily: "Noto Sans", weight: "regular" },
+  roads: { font: "Noto Sans", fontFamily: "Noto Sans", weight: "regular" },
+  water: { font: "Noto Sans", fontFamily: "Noto Sans", weight: "regular" },
+  poi: { font: "Noto Sans", fontFamily: "Noto Sans", weight: "regular" }
 };
 var fontWeightLabels = {
   regular: "Regular",
@@ -219,6 +223,10 @@ function resolveColors(overrides = {}, defaults = defaultColors, moduleOverrides
   const buildingDefaults = {
     extrusion: mix(base.building, base.text, 0.08),
     fill: base.building,
+    highRise: base.building,
+    highRiseOutline: mix(base.building, base.text, 0.2),
+    lowRise: mix(base.building, base.land, 0.55),
+    lowRiseOutline: mix(base.building, base.land, 0.2),
     outline: mix(base.building, base.text, 0.2)
   };
   const boundaryDefaults = {
@@ -250,15 +258,35 @@ function resolveColors(overrides = {}, defaults = defaultColors, moduleOverrides
   };
 }
 function resolveTypography(overrides = {}, defaults = defaultTypography) {
-  const font = overrides.font ?? overrides.fontFamily ?? defaults.font;
+  const base = resolveTypographyStyle(overrides, defaults);
+  return {
+    ...base,
+    places: resolveTypographyDomain(overrides.places, overrides, defaults.places, base),
+    roads: resolveTypographyDomain(overrides.roads, overrides, defaults.roads, base),
+    water: resolveTypographyDomain(overrides.water, overrides, defaults.water, base),
+    poi: resolveTypographyDomain(overrides.poi, overrides, defaults.poi, base)
+  };
+}
+function textFont(typography, domain) {
+  const style = domain ? typography[domain] : typography;
+  return [`${style.font} ${fontWeightLabels[style.weight]}`];
+}
+function resolveTypographyStyle(overrides, defaults) {
+  const font = overrides?.font ?? overrides?.fontFamily ?? defaults.font;
   return {
     font,
     fontFamily: font,
-    weight: overrides.weight ?? defaults.weight
+    weight: overrides?.weight ?? defaults.weight
   };
 }
-function textFont(typography) {
-  return [`${typography.font} ${fontWeightLabels[typography.weight]}`];
+function resolveTypographyDomain(domainOverrides, globalOverrides, defaults, resolvedGlobal) {
+  const globalFontOverridden = Boolean(globalOverrides.font || globalOverrides.fontFamily);
+  const font = domainOverrides?.font ?? domainOverrides?.fontFamily ?? (globalFontOverridden ? resolvedGlobal.font : defaults.font);
+  return {
+    font,
+    fontFamily: font,
+    weight: domainOverrides?.weight ?? globalOverrides.weight ?? defaults.weight
+  };
 }
 function resolveLegacyTheme(theme) {
   const preset = themePresets[theme];
@@ -342,13 +370,17 @@ function isLegacyTheme(value) {
 function resolveThemeTypography(theme) {
   const font = theme.typography?.font ?? theme.typography?.fontFamily ?? theme.fonts?.labels ?? theme.fonts?.body;
   return {
+    ...theme.typography?.places ? { places: theme.typography.places } : {},
+    ...theme.typography?.poi ? { poi: theme.typography.poi } : {},
+    ...theme.typography?.roads ? { roads: theme.typography.roads } : {},
+    ...theme.typography?.water ? { water: theme.typography.water } : {},
     ...theme.typography?.weight ? { weight: theme.typography.weight } : {},
     ...font ? { font } : {}
   };
 }
 function hasTypographyConfig(theme) {
   return Boolean(
-    theme.typography?.font || theme.typography?.fontFamily || theme.typography?.weight || theme.fonts?.labels || theme.fonts?.body
+    theme.typography?.font || theme.typography?.fontFamily || theme.typography?.weight || theme.typography?.places || theme.typography?.poi || theme.typography?.roads || theme.typography?.water || theme.fonts?.labels || theme.fonts?.body
   );
 }
 function normalizeColorAliases(colors) {
@@ -517,9 +549,21 @@ var moduleRoadDefaults = {
   detail: "streets",
   extras: { ferry: false, paths: false, rail: false },
   hierarchy: "clear",
+  oneWayMarkers: false,
   outline: "subtle",
   weight: "regular"
 };
+var defaultRoadWidthScale = {
+  motorway: 1,
+  trunk: 1,
+  primary: 1,
+  secondary: 1,
+  tertiary: 1,
+  minor: 1,
+  service: 1,
+  track: 1,
+  path: 1
+};
 var highwayRoadClasses = ["motorway", "trunk"];
 var arterialRoadClasses = ["primary", "secondary", "tertiary"];
 var majorRoadClasses = [...highwayRoadClasses, ...arterialRoadClasses];
@@ -543,8 +587,10 @@ function roads(options = {}) {
     ...options.detail ? { detail: options.detail } : {},
     ...options.extras ? { extras: { ...options.extras } } : {},
     ...options.hierarchy ? { hierarchy: options.hierarchy } : {},
+    ...options.oneWayMarkers !== void 0 ? { oneWayMarkers: options.oneWayMarkers } : {},
     ...options.outline ? { outline: options.outline } : {},
-    ...options.weight ? { weight: options.weight } : {}
+    ...options.weight ? { weight: options.weight } : {},
+    ...options.widthScale ? { widthScale: { ...options.widthScale } } : {}
   };
 }
 function resolveRoads(legacyRoads, moduleConfig, fallback) {
@@ -558,8 +604,10 @@ function resolveRoads(legacyRoads, moduleConfig, fallback) {
       rail: moduleConfig?.extras?.rail ?? defaults.extras.rail
     },
     hierarchy: moduleConfig?.hierarchy ?? defaults.hierarchy,
+    oneWayMarkers: moduleConfig?.oneWayMarkers ?? defaults.oneWayMarkers,
     outline: moduleConfig?.outline ?? defaults.outline,
-    weight: moduleConfig?.weight ?? defaults.weight
+    weight: moduleConfig?.weight ?? defaults.weight,
+    ...moduleConfig?.widthScale ? { widthScale: { ...defaultRoadWidthScale, ...moduleConfig.widthScale } } : {}
   };
   return {
     ...resolved,
@@ -603,7 +651,7 @@ function roadStyleMetrics(options) {
     weightScale
   };
 }
-function roadLayers(source, sourceLayer, colors, options) {
+function roadLayers(source, sourceLayer, colors, options, typography) {
   if (options.detail === "none") {
     return [];
   }
@@ -647,7 +695,8 @@ function roadLayers(source, sourceLayer, colors, options) {
             [14, 2.2],
             [16, 4.8]
           ],
-          metrics
+          metrics,
+          options.widthScale
         )
       }
     });
@@ -672,7 +721,8 @@ function roadLayers(source, sourceLayer, colors, options) {
           [14, 1],
           [16, 2.4]
         ],
-        metrics
+        metrics,
+        options.widthScale
       )
     }
   });
@@ -693,7 +743,8 @@ function roadLayers(source, sourceLayer, colors, options) {
             [12, 1.8],
             [16, 5.4]
           ],
-          metrics
+          metrics,
+          options.widthScale
         )
       }
     });
@@ -739,7 +790,7 @@ function roadLayers(source, sourceLayer, colors, options) {
             [14, 0.8],
             [16, 2.2]
           ],
-          metrics.weightScale * metrics.minorWidthScale
+          metrics.weightScale * metrics.minorWidthScale * (options.widthScale?.path ?? 1)
         )
       }
     });
@@ -782,7 +833,8 @@ function roadLayers(source, sourceLayer, colors, options) {
             [14, 0.6],
             [16, 2.2]
           ],
-          metrics.weightScale * metrics.minorWidthScale
+          metrics.weightScale * metrics.minorWidthScale,
+          options.widthScale
         )
       }
     });
@@ -803,7 +855,8 @@ function roadLayers(source, sourceLayer, colors, options) {
             [12, 0.8],
             [16, 3]
           ],
-          metrics.weightScale * metrics.minorWidthScale
+          metrics.weightScale * metrics.minorWidthScale,
+          options.widthScale
         )
       }
     });
@@ -825,7 +878,8 @@ function roadLayers(source, sourceLayer, colors, options) {
             [12, 1.2],
             [16, 4]
           ],
-          metrics.weightScale * metrics.majorWidthScale
+          metrics.weightScale * metrics.majorWidthScale,
+          options.widthScale
         )
       }
     },
@@ -845,11 +899,15 @@ function roadLayers(source, sourceLayer, colors, options) {
             [14, 1.6],
             [16, 4.4]
           ],
-          metrics
+          metrics,
+          options.widthScale
         )
       }
     }
   );
+  if (options.oneWayMarkers) {
+    layers.push(oneWayMarkerLayer(source, sourceLayer, colors, typography));
+  }
   return layers;
 }
 function roadDefaultsFromLegacyMode(mode) {
@@ -858,6 +916,7 @@ function roadDefaultsFromLegacyMode(mode) {
       detail: "none",
       extras: { ferry: false, paths: false, rail: false },
       hierarchy: "clear",
+      oneWayMarkers: false,
       outline: "subtle",
       weight: "regular"
     };
@@ -867,6 +926,7 @@ function roadDefaultsFromLegacyMode(mode) {
       detail: "streets",
       extras: { ferry: false, paths: false, rail: false },
       hierarchy: "subtle",
+      oneWayMarkers: false,
       outline: "subtle",
       weight: "thin"
     };
@@ -876,6 +936,7 @@ function roadDefaultsFromLegacyMode(mode) {
       detail: "all",
       extras: { ferry: true, paths: true, rail: true },
       hierarchy: "clear",
+      oneWayMarkers: false,
       outline: "strong",
       weight: "regular"
     };
@@ -884,6 +945,7 @@ function roadDefaultsFromLegacyMode(mode) {
     detail: "streets",
     extras: { ferry: true, paths: true, rail: true },
     hierarchy: "clear",
+    oneWayMarkers: false,
     outline: "subtle",
     weight: "regular"
   };
@@ -898,33 +960,101 @@ function classFilter(classes) {
   return ["match", ["get", "class"], classes, true, false];
 }
 function roadOpacityExpression(majorOpacity, minorOpacity) {
+  return [
+    "step",
+    ["zoom"],
+    roadOpacityAtZoom(majorOpacity, minorOpacity, 0, 0),
+    12,
+    roadOpacityAtZoom(majorOpacity, minorOpacity, minorOpacity, 0),
+    14,
+    roadOpacityAtZoom(majorOpacity, minorOpacity, minorOpacity, minorOpacity)
+  ];
+}
+function roadOpacityAtZoom(majorOpacity, minorOpacity, streetOpacity, serviceOpacity) {
   return [
     "case",
     classFilter(majorRoadClasses),
     majorOpacity,
     classFilter(streetRoadClasses),
-    ["step", ["zoom"], 0, 12, minorOpacity],
+    streetOpacity,
     classFilter(serviceRoadClasses),
-    ["step", ["zoom"], 0, 14, minorOpacity],
+    serviceOpacity,
     minorOpacity
   ];
 }
-function roadWidthExpression(stops, metrics) {
+function roadWidthExpression(stops, metrics, widthScale) {
   return [
-    "case",
-    classFilter(majorRoadClasses),
-    zoomWidth(stops, metrics.weightScale * metrics.majorWidthScale),
-    zoomWidth(stops, metrics.weightScale * metrics.minorWidthScale)
+    "interpolate",
+    ["linear"],
+    ["zoom"],
+    ...stops.flatMap(([zoom, width]) => [
+      zoom,
+      widthScale ? [
+        "*",
+        [
+          "case",
+          classFilter(majorRoadClasses),
+          width * metrics.weightScale * metrics.majorWidthScale,
+          width * metrics.weightScale * metrics.minorWidthScale
+        ],
+        roadClassWidthScaleExpression(widthScale)
+      ] : [
+        "case",
+        classFilter(majorRoadClasses),
+        width * metrics.weightScale * metrics.majorWidthScale,
+        width * metrics.weightScale * metrics.minorWidthScale
+      ]
+    ])
   ];
 }
-function zoomWidth(stops, scale) {
+function zoomWidth(stops, scale, widthScale) {
   return [
     "interpolate",
     ["linear"],
     ["zoom"],
-    ...stops.flatMap(([zoom, width]) => [zoom, width * scale])
+    ...stops.flatMap(([zoom, width]) => [
+      zoom,
+      widthScale ? ["*", width * scale, roadClassWidthScaleExpression(widthScale)] : width * scale
+    ])
+  ];
+}
+function roadClassWidthScaleExpression(widthScale) {
+  return [
+    "match",
+    ["get", "class"],
+    ...Object.entries(widthScale).flatMap(([roadClass, scale]) => [roadClass, scale]),
+    1
   ];
 }
+function oneWayMarkerLayer(source, sourceLayer, colors, typography) {
+  return {
+    id: "road-oneway-markers",
+    type: "symbol",
+    source,
+    "source-layer": sourceLayer,
+    minzoom: 15,
+    filter: [
+      "any",
+      ["==", ["get", "oneway"], 1],
+      ["==", ["get", "oneway"], "1"],
+      ["==", ["get", "oneway"], true]
+    ],
+    layout: {
+      "symbol-placement": "line",
+      "symbol-spacing": 88,
+      "text-field": "\u203A",
+      ...typography ? { "text-font": textFont(typography, "roads") } : {},
+      "text-keep-upright": false,
+      "text-rotation-alignment": "map",
+      "text-size": 15
+    },
+    paint: {
+      "text-color": colors.labels.road,
+      "text-halo-color": colors.labels.halo,
+      "text-halo-width": 0.5
+    }
+  };
+}
 function roadClassColorExpression(colors) {
   return [
     "match",
@@ -966,6 +1096,7 @@ function labels(options = {}) {
     type: "labels",
     ...options.language ? { language: options.language } : {},
     ...options.places ? { places: options.places } : {},
+    ...options.roadClasses ? { roadClasses: [...options.roadClasses] } : {},
     ...options.roads ? { roads: options.roads } : {},
     ...options.water ? { water: options.water } : {}
   };
@@ -976,6 +1107,7 @@ function resolveLabels(legacyLabels, moduleConfig, fallback) {
   const resolved = {
     language: moduleConfig?.language ?? defaults.language,
     places: moduleConfig?.places ?? defaults.places,
+    ...moduleConfig?.roadClasses ? { roadClasses: moduleConfig.roadClasses } : {},
     roads: moduleConfig?.roads ?? defaults.roads,
     water: moduleConfig?.water ?? defaults.water
   };
@@ -1017,7 +1149,7 @@ function placeLabelLayers(source, sourceLayer, colors, labelsConfig, typography)
       filter: labelsConfig.places === "major" ? ["all", ["has", "name"], classFilter2(majorPlaceClasses)] : ["has", "name"],
       layout: {
         "text-field": labelTextField(labelsConfig.language),
-        "text-font": textFont(typography),
+        "text-font": textFont(typography, "places"),
         "text-size": ["interpolate", ["linear"], ["zoom"], 3, 10, 8, 13, 14, 17],
         "text-letter-spacing": 0,
         "text-padding": 4
@@ -1031,7 +1163,11 @@ function placeLabelLayers(source, sourceLayer, colors, labelsConfig, typography)
   ];
 }
 function roadLabelLayers(source, sourceLayer, colors, labelsConfig, roadsConfig, typography) {
-  const classes = visibleRoadLabelClasses(labelsConfig.roads, roadsConfig);
+  const classes = visibleRoadLabelClasses(
+    labelsConfig.roads,
+    roadsConfig,
+    labelsConfig.roadClasses
+  );
   const majorClasses = classes.filter(isMajorRoadClass);
   const minorClasses = classes.filter((roadClass) => !isMajorRoadClass(roadClass));
   if (classes.length === 0) return [];
@@ -1039,7 +1175,7 @@ function roadLabelLayers(source, sourceLayer, colors, labelsConfig, roadsConfig,
   const sharedLayout = {
     "symbol-placement": "line",
     "text-field": labelTextField(labelsConfig.language),
-    "text-font": textFont(typography),
+    "text-font": textFont(typography, "roads"),
     "text-rotation-alignment": "map",
     "text-size": ["interpolate", ["linear"], ["zoom"], 11, 11, 14, 13, 17, 15]
   };
@@ -1061,7 +1197,7 @@ function roadLabelLayers(source, sourceLayer, colors, labelsConfig, roadsConfig,
         "symbol-placement": "line",
         "symbol-spacing": 240,
         "text-field": ["get", "ref"],
-        "text-font": textFont(typography),
+        "text-font": textFont(typography, "roads"),
         "text-rotation-alignment": "viewport",
         "text-size": 10
       },
@@ -1113,7 +1249,7 @@ function waterLabelLayers(source, waterNameSourceLayer, waterwaySourceLayer, col
       filter: ["all", ["==", ["geometry-type"], "Point"], waterFilter],
       layout: {
         "text-field": labelTextField(labelsConfig.language),
-        "text-font": textFont(typography),
+        "text-font": textFont(typography, "water"),
         "text-size": ["interpolate", ["linear"], ["zoom"], 3, 11, 8, 14]
       },
       paint
@@ -1128,7 +1264,7 @@ function waterLabelLayers(source, waterNameSourceLayer, waterwaySourceLayer, col
       layout: {
         "symbol-placement": "line",
         "text-field": labelTextField(labelsConfig.language),
-        "text-font": textFont(typography),
+        "text-font": textFont(typography, "water"),
         "text-size": 13
       },
       paint
@@ -1144,14 +1280,14 @@ function waterLabelLayers(source, waterNameSourceLayer, waterwaySourceLayer, col
         "symbol-placement": "line",
         "symbol-spacing": 320,
         "text-field": labelTextField(labelsConfig.language),
-        "text-font": textFont(typography),
+        "text-font": textFont(typography, "water"),
         "text-size": 12
       },
       paint
     }
   ];
 }
-function visibleRoadLabelClasses(detail, roadsConfig) {
+function visibleRoadLabelClasses(detail, roadsConfig, eligibleClasses) {
   if (detail === "none" || roadsConfig.detail === "none") return [];
   const visibleRoadClasses = [
     ...roadClassesForDetail(roadsConfig.detail),
@@ -1159,7 +1295,10 @@ function visibleRoadLabelClasses(detail, roadsConfig) {
   ];
   const requestedClasses = roadLabelClasses(detail);
   const visible = new Set(visibleRoadClasses);
-  return requestedClasses.filter((roadClass) => visible.has(roadClass));
+  const eligible = eligibleClasses ? new Set(eligibleClasses) : void 0;
+  return requestedClasses.filter(
+    (roadClass) => visible.has(roadClass) && (!eligible || eligible.has(roadClass))
+  );
 }
 function roadLabelClasses(detail) {
   return [...roadClassesForDetail(detail), ...detail === "all" ? ["path"] : []];
@@ -1206,20 +1345,33 @@ function poi(options = {}) {
   return {
     type: "poi",
     ...options.categories ? { categories: options.categories } : {},
+    ...options.classMapping ? { classMapping: { ...options.classMapping } } : {},
+    ...options.color ? { color: options.color } : {},
+    ...options.density ? { density: options.density } : {},
     ...options.icons !== void 0 ? { icons: options.icons } : {},
     ...options.labels ? { labels: options.labels } : {},
     ...options.minZoom !== void 0 ? { minZoom: options.minZoom } : {},
+    ...options.placement ? { placement: { ...options.placement } } : {},
     ...options.preset ? { preset: options.preset } : {}
   };
 }
 function resolvePoi(legacyPoi, moduleConfig, fallback) {
   const mode = moduleConfig?.preset ?? legacyPoi ?? fallback;
+  const density = moduleConfig?.density;
   return {
-    categories: moduleConfig?.categories,
+    ...moduleConfig?.categories ? { categories: moduleConfig.categories } : {},
+    classMapping: resolvePoiClassMapping(moduleConfig?.classMapping),
+    color: moduleConfig?.color ?? "uniform",
+    ...density ? { density } : {},
     icons: moduleConfig?.icons ?? (mode === "none" ? false : "essential"),
     labels: moduleConfig?.labels ?? poiLabelsFromMode(mode),
-    minZoom: moduleConfig?.minZoom ?? defaultPoiMinZoom[mode],
-    mode
+    minZoom: moduleConfig?.minZoom ?? defaultPoiMinZoom[mode] + (density === void 0 ? 0 : poiDensityZoomOffset(density)),
+    mode,
+    placement: {
+      coupleIconAndLabel: moduleConfig?.placement?.coupleIconAndLabel ?? false,
+      iconPadding: moduleConfig?.placement?.iconPadding ?? 2,
+      textPadding: moduleConfig?.placement?.textPadding ?? 2
+    }
   };
 }
 function poiLayers(source, sourceLayer, colors, poiConfig, typography, customIconSpriteId2, customIconMapping) {
@@ -1228,21 +1380,29 @@ function poiLayers(source, sourceLayer, colors, poiConfig, typography, customIco
   }
   const layout = {
     "text-field": labelTextField("auto"),
-    "text-font": textFont(typography),
+    "text-font": textFont(typography, "poi"),
     "text-size": ["interpolate", ["linear"], ["zoom"], poiConfig.minZoom, 10, 17, 12],
     "text-letter-spacing": 0,
-    "text-padding": 2
+    "text-padding": poiConfig.placement.textPadding
   };
+  if (poiConfig.density) {
+    layout["symbol-sort-key"] = poiPriorityExpression(poiConfig.classMapping);
+  }
   if (poiConfig.labels === "none") {
     delete layout["text-field"];
   }
   if (poiConfig.icons) {
-    layout["icon-image"] = poiIconImageExpression(customIconSpriteId2, customIconMapping);
-    layout["icon-optional"] = true;
-    layout["icon-padding"] = 2;
+    layout["icon-image"] = poiIconImageExpression(
+      customIconSpriteId2,
+      customIconMapping,
+      poiConfig.classMapping
+    );
+    layout["icon-optional"] = !poiConfig.placement.coupleIconAndLabel;
+    layout["icon-padding"] = poiConfig.placement.iconPadding;
     layout["icon-size"] = ["interpolate", ["linear"], ["zoom"], poiConfig.minZoom, 0.85, 17, 1];
     layout["text-anchor"] = "top";
     layout["text-offset"] = [0, 0.75];
+    if (poiConfig.placement.coupleIconAndLabel) layout["text-optional"] = false;
   }
   return [
     {
@@ -1251,10 +1411,10 @@ function poiLayers(source, sourceLayer, colors, poiConfig, typography, customIco
       source,
       "source-layer": sourceLayer,
       minzoom: poiConfig.minZoom,
-      ...poiConfig.categories ? { filter: poiCategoryFilter(poiConfig.categories) } : {},
+      ...poiFilter(poiConfig) ? { filter: poiFilter(poiConfig) } : {},
       layout,
       paint: {
-        "text-color": colors.poi.label,
+        "text-color": poiConfig.color === "category" ? poiCategoryColorExpression(colors, poiConfig.classMapping) : colors.poi.label,
         "text-halo-color": colors.poi.halo ?? alpha(colors.background, 0.78),
         "text-halo-width": 1
       }
@@ -1267,26 +1427,112 @@ function poiLabelsFromMode(mode) {
   if (mode === "full") return "full";
   return "balanced";
 }
-function poiCategoryFilter(categories) {
-  return ["in", "class", ...categories.flatMap((category) => poiCategoryClasses(category))];
+function poiCategoryFilter(categories, classMapping = poiCategoryClassNames) {
+  const classes = categories.flatMap((category) => poiCategoryClasses(category, classMapping));
+  return ["any", ["in", "class", ...classes], ["in", "subclass", ...classes]];
 }
-function poiIconImageExpression(customIconSpriteId2, customIconMapping = {}) {
-  const matchParts = [];
-  for (const [className, iconName] of Object.entries(poiClassIconNames)) {
-    matchParts.push(
-      className,
-      poiIconImageFallback(iconName, customIconSpriteId2, customIconMapping)
-    );
-  }
+function poiIconImageExpression(customIconSpriteId2, customIconMapping = {}, classMapping = poiCategoryClassNames) {
+  const matchParts = Object.keys(classMapping).flatMap((category) => [
+    category,
+    poiIconImageFallback(category, customIconSpriteId2, customIconMapping)
+  ]);
   return [
     "match",
-    ["get", "class"],
+    poiCategoryExpression("default", classMapping),
     ...matchParts,
     poiIconImageFallback("default", customIconSpriteId2, customIconMapping)
   ];
 }
-function poiCategoryClasses(category) {
-  return poiCategoryClassNames[category] ?? [category];
+function poiCategoryExpression(fallback = "", classMapping = poiCategoryClassNames) {
+  const categoryMatches = poiCategoryMatchParts(classMapping);
+  return [
+    "match",
+    ["get", "subclass"],
+    ...categoryMatches,
+    fallbackCategoryExpression(fallback, classMapping)
+  ];
+}
+function fallbackCategoryExpression(fallback, classMapping) {
+  const categoryMatches = poiCategoryMatchParts(classMapping);
+  return ["match", ["get", "class"], ...categoryMatches, fallback];
+}
+function poiCategoryMatchParts(classMapping) {
+  return Object.entries(classMapping).flatMap(([category, classes]) => [classes, category]);
+}
+function poiCategoryClasses(category, classMapping = poiCategoryClassNames) {
+  return [...classMapping[category] ?? [category]];
+}
+function poiPriorityExpression(classMapping = poiCategoryClassNames) {
+  const categoryPenalty = [
+    "match",
+    poiCategoryExpression("default", classMapping),
+    "transit",
+    0,
+    "culture",
+    1,
+    "health",
+    2,
+    "education",
+    3,
+    "lodging",
+    4,
+    "food",
+    5,
+    "coffee",
+    6,
+    "services",
+    7,
+    "shopping",
+    8,
+    9
+  ];
+  return ["+", ["*", categoryPenalty, 1e3], ["to-number", ["get", "rank"], 999]];
+}
+function poiDensityFilter(density, classMapping = poiCategoryClassNames) {
+  if (density === "dense") return void 0;
+  const cutoffs = poiDensityRankCutoffs[density];
+  return [
+    "any",
+    ...Object.keys(classMapping).map((category) => [
+      "all",
+      poiCategoryFilter([category], classMapping),
+      ["any", ["!has", "rank"], ["<=", "rank", cutoffs[category] ?? cutoffs.default]]
+    ])
+  ];
+}
+function poiCategoryColorExpression(colors, classMapping = poiCategoryClassNames) {
+  return [
+    "match",
+    poiCategoryExpression("default", classMapping),
+    ...Object.keys(classMapping).flatMap((category) => [
+      category,
+      colors.poi[category] ?? colors.poi.label
+    ]),
+    colors.poi.label
+  ];
+}
+function resolvePoiClassMapping(overrides) {
+  const categories = /* @__PURE__ */ new Set([
+    ...Object.keys(poiCategoryClassNames),
+    ...Object.keys(overrides ?? {})
+  ]);
+  return Object.fromEntries(
+    [...categories].map((category) => [
+      category,
+      [.../* @__PURE__ */ new Set([...poiCategoryClassNames[category] ?? [], ...overrides?.[category] ?? []])]
+    ])
+  );
+}
+function poiDensityZoomOffset(density) {
+  if (density === "sparse") return 1;
+  if (density === "dense") return -1;
+  return 0;
+}
+function poiFilter(poiConfig) {
+  const categoryFilter = poiConfig.categories ? poiCategoryFilter(poiConfig.categories, poiConfig.classMapping) : void 0;
+  const densityFilter = poiConfig.density ? poiDensityFilter(poiConfig.density, poiConfig.classMapping) : void 0;
+  if (categoryFilter && densityFilter) return ["all", categoryFilter, densityFilter];
+  return categoryFilter ?? densityFilter;
 }
 function poiIconImageFallback(iconName, customIconSpriteId2, customIconMapping) {
   const osmBrightIcon = `${osmBrightIconNameForSemanticIcon(iconName)}_11`;
@@ -1305,55 +1551,50 @@ function osmBrightIconNameForSemanticIcon(iconName) {
 }
 var poiCategoryClassNames = {
   coffee: ["cafe"],
-  culture: ["museum", "gallery", "theatre", "cinema", "library", "attraction"],
+  culture: [
+    "museum",
+    "gallery",
+    "art_gallery",
+    "theatre",
+    "cinema",
+    "library",
+    "attraction",
+    "garden",
+    "monument"
+  ],
   education: ["school", "college", "university"],
   food: ["restaurant", "fast_food", "bar", "pub", "biergarten"],
   health: ["hospital", "pharmacy", "doctors", "dentist"],
-  lodging: ["hotel", "motel", "hostel", "guest_house"],
+  lodging: ["lodging", "hotel", "motel", "hostel", "guest_house"],
   services: ["bank", "post", "toilet", "police", "fire_station", "town_hall"],
   shopping: ["shop", "mall", "supermarket", "marketplace"],
   transit: ["railway", "station", "bus", "bus_stop", "subway", "tram"]
 };
-var poiClassIconNames = {
-  attraction: "culture",
-  bank: "services",
-  bar: "food",
-  biergarten: "food",
-  bus: "transit",
-  bus_stop: "transit",
-  cafe: "coffee",
-  cinema: "culture",
-  college: "education",
-  dentist: "health",
-  doctors: "health",
-  fast_food: "food",
-  fire_station: "services",
-  gallery: "culture",
-  guest_house: "lodging",
-  hospital: "health",
-  hostel: "lodging",
-  hotel: "lodging",
-  library: "culture",
-  mall: "shopping",
-  marketplace: "shopping",
-  motel: "lodging",
-  museum: "culture",
-  pharmacy: "health",
-  police: "services",
-  post: "services",
-  pub: "food",
-  railway: "transit",
-  restaurant: "food",
-  school: "education",
-  shop: "shopping",
-  station: "transit",
-  subway: "transit",
-  supermarket: "shopping",
-  theatre: "culture",
-  toilet: "services",
-  town_hall: "services",
-  tram: "transit",
-  university: "education"
+var poiDensityRankCutoffs = {
+  sparse: {
+    coffee: 4,
+    culture: 10,
+    education: 8,
+    food: 6,
+    health: 8,
+    lodging: 8,
+    services: 6,
+    shopping: 4,
+    transit: 14,
+    default: 6
+  },
+  balanced: {
+    coffee: 10,
+    culture: 18,
+    education: 14,
+    food: 14,
+    health: 14,
+    lodging: 16,
+    services: 12,
+    shopping: 10,
+    transit: 24,
+    default: 12
+  }
 };
 var semanticToOsmBrightIconName = {
   coffee: "cafe",
@@ -1378,7 +1619,8 @@ function openMapTilesLayers(source, sourceLayers, colors, options) {
         "background-color": colors.background
       }
     },
-    fillLayer("landuse", source, sourceLayers.landuse, colors.landuse.residential, 0.42),
+    semanticLanduseLayer(source, sourceLayers.landuse, colors),
+    semanticLandcoverLayer(source, sourceLayers.landcover, colors),
     fillLayer(
       "parks",
       source,
@@ -1387,8 +1629,15 @@ function openMapTilesLayers(source, sourceLayers, colors, options) {
       parkOpacity(options.density)
     ),
     fillLayer("water", source, sourceLayers.water, colors.hydro.water, 1),
-    ...buildingLayers(source, sourceLayers.building, colors, options.density, options.buildings),
-    ...roadLayers(source, sourceLayers.road, colors, options.roads),
+    ...buildingLayers(
+      source,
+      sourceLayers.building,
+      colors,
+      options.density,
+      options.buildings,
+      options.buildingStyle
+    ),
+    ...roadLayers(source, sourceLayers.road, colors, options.roads, options.typography),
     ...boundaryLayers(source, sourceLayers.boundary, colors),
     ...labelLayers(source, sourceLayers, colors, options.labels, options.roads, options.typography),
     ...poiLayers(
@@ -1402,6 +1651,61 @@ function openMapTilesLayers(source, sourceLayers, colors, options) {
     )
   ];
 }
+function semanticLanduseLayer(source, sourceLayer, colors) {
+  return {
+    id: "landuse",
+    type: "fill",
+    source,
+    "source-layer": sourceLayer,
+    paint: {
+      "fill-color": [
+        "match",
+        ["get", "class"],
+        ["commercial", "retail"],
+        colors.landuse.commercial,
+        ["industrial", "railway"],
+        colors.landuse.industrial,
+        ["school", "university", "hospital", "civic"],
+        colors.landuse.civic,
+        "cemetery",
+        colors.landuse.cemetery,
+        colors.landuse.residential
+      ],
+      "fill-opacity": 0.62
+    }
+  };
+}
+function semanticLandcoverLayer(source, sourceLayer, colors) {
+  return {
+    id: "landcover",
+    type: "fill",
+    source,
+    "source-layer": sourceLayer,
+    filter: [
+      "match",
+      ["get", "class"],
+      ["grass", "wood", "forest", "scrub", "farmland", "sand", "beach", "ice", "glacier"],
+      true,
+      false
+    ],
+    paint: {
+      "fill-color": [
+        "match",
+        ["get", "class"],
+        ["wood", "forest"],
+        colors.landcover.wood,
+        ["scrub", "farmland"],
+        colors.landcover.protected,
+        ["sand", "beach"],
+        colors.landcover.sand,
+        ["ice", "glacier"],
+        colors.landcover.ice,
+        colors.landcover.grass
+      ],
+      "fill-opacity": 0.88
+    }
+  };
+}
 function fillLayer(id, source, sourceLayer, color, opacity) {
   return {
     id,
@@ -1414,7 +1718,7 @@ function fillLayer(id, source, sourceLayer, color, opacity) {
     }
   };
 }
-function buildingLayers(source, sourceLayer, colors, density, buildings) {
+function buildingLayers(source, sourceLayer, colors, density, buildings, buildingStyle) {
   if (buildings === "hidden") {
     return [];
   }
@@ -1481,8 +1785,12 @@ function buildingLayers(source, sourceLayer, colors, density, buildings) {
       "source-layer": sourceLayer,
       minzoom: 13,
       paint: {
-        "fill-color": colors.buildings.fill,
-        "fill-opacity": density === "dense" ? 0.62 : 0.5
+        "fill-color": buildingStyle ? buildingHeightColorExpression(
+          buildingStyle.heightThreshold ?? 12,
+          colors.buildings.lowRise,
+          colors.buildings.highRise
+        ) : colors.buildings.fill,
+        "fill-opacity": buildingStyle?.fillOpacity ?? (density === "dense" ? 0.62 : 0.5)
       }
     },
     {
@@ -1492,13 +1800,33 @@ function buildingLayers(source, sourceLayer, colors, density, buildings) {
       "source-layer": sourceLayer,
       minzoom: 15,
       paint: {
-        "line-color": colors.buildings.outline,
-        "line-opacity": 0.24,
-        "line-width": 0.6
+        "line-color": buildingStyle ? buildingHeightColorExpression(
+          buildingStyle.heightThreshold ?? 12,
+          colors.buildings.lowRiseOutline,
+          colors.buildings.highRiseOutline
+        ) : colors.buildings.outline,
+        "line-opacity": buildingStyle?.outlineOpacity ?? 0.24,
+        "line-width": buildingStyle?.outlineWidth ?? 0.6
       }
     }
   ];
 }
+function buildingHeightColorExpression(threshold, lowRise, highRise) {
+  return [
+    "case",
+    [
+      ">=",
+      [
+        "to-number",
+        ["coalesce", ["get", "render_height"], ["get", "height"], ["get", "levels"]],
+        0
+      ],
+      threshold
+    ],
+    highRise,
+    lowRise
+  ];
+}
 function boundaryLayers(source, sourceLayer, colors) {
   return [
     {
@@ -1548,12 +1876,15 @@ function applyLayerOverride(layers, layerId, override) {
     return insertLayer(layers, layer, override.before);
   }
   const previousLayer = layers[index];
+  const layout = mergeRecords(previousLayer.layout, override.layout);
+  const paint = mergeRecords(previousLayer.paint, override.paint);
+  const metadata = mergeRecords(previousLayer.metadata, override.metadata);
   const patchedLayer = stripControlFields({
     ...previousLayer,
     ...override,
-    layout: mergeRecords(previousLayer.layout, override.layout),
-    paint: mergeRecords(previousLayer.paint, override.paint),
-    metadata: mergeRecords(previousLayer.metadata, override.metadata)
+    ...layout ? { layout } : {},
+    ...paint ? { paint } : {},
+    ...metadata ? { metadata } : {}
   });
   const nextLayers = [...layers];
   nextLayers[index] = patchedLayer;
@@ -1580,28 +1911,206 @@ function mergeRecords(previous, next) {
 }
 function stripControlFields(layer) {
   const { before, ...styleLayer } = layer;
-  return styleLayer;
+  return Object.fromEntries(Object.entries(styleLayer).filter(([, value]) => value !== void 0));
 }
 function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
 // src/schema.ts
+import { z as z2 } from "zod";
+
+// src/capture-scene.ts
 import { z } from "zod";
+var tileflowCaptureSceneSchemaVersion = 1;
+var tileflowCaptureSceneLimits = Object.freeze({
+  applicationPathLength: 2048,
+  boundsPadding: { maximum: 1024, minimum: 0 },
+  captureIdLength: 64,
+  maximumPhysicalPixels: 16777216,
+  pitch: { maximum: 85, minimum: 0 },
+  selectorLength: 256,
+  viewport: { maximum: 4096, minimum: 64 },
+  zoom: { maximum: 24, minimum: 0 }
+});
+var finiteLongitudeSchema = z.number().finite().min(-180).max(180);
+var finiteLatitudeSchema = z.number().finite().min(-90).max(90);
+var bearingSchema = z.number().finite().min(-180).max(180).optional();
+var pitchSchema = z.number().finite().min(tileflowCaptureSceneLimits.pitch.minimum).max(tileflowCaptureSceneLimits.pitch.maximum).optional();
+var tileflowCaptureCenterCameraSchema = z.object({
+  type: z.literal("center"),
+  center: z.tuple([finiteLongitudeSchema, finiteLatitudeSchema]),
+  zoom: z.number().finite().min(tileflowCaptureSceneLimits.zoom.minimum).max(tileflowCaptureSceneLimits.zoom.maximum),
+  bearing: bearingSchema,
+  pitch: pitchSchema
+}).strict();
+var tileflowCaptureBoundsCameraSchema = z.object({
+  type: z.literal("bounds"),
+  bounds: z.tuple([
+    finiteLongitudeSchema,
+    finiteLatitudeSchema,
+    finiteLongitudeSchema,
+    finiteLatitudeSchema
+  ]),
+  padding: z.number().finite().min(tileflowCaptureSceneLimits.boundsPadding.minimum).max(tileflowCaptureSceneLimits.boundsPadding.maximum).optional(),
+  bearing: bearingSchema,
+  pitch: pitchSchema
+}).strict().superRefine((camera, context) => {
+  const [west, south, east, north] = camera.bounds;
+  if (south >= north) {
+    context.addIssue({
+      code: "custom",
+      message: "Expected south latitude to be less than north latitude",
+      path: ["bounds"]
+    });
+  }
+  if (west === east) {
+    context.addIssue({
+      code: "custom",
+      message: "Expected west and east longitude to define a non-empty span",
+      path: ["bounds"]
+    });
+  }
+});
+var tileflowCaptureCameraSchema = z.discriminatedUnion("type", [
+  tileflowCaptureCenterCameraSchema,
+  tileflowCaptureBoundsCameraSchema
+]);
+var tileflowCaptureViewportSchema = z.object({
+  width: z.number().int().min(tileflowCaptureSceneLimits.viewport.minimum).max(tileflowCaptureSceneLimits.viewport.maximum),
+  height: z.number().int().min(tileflowCaptureSceneLimits.viewport.minimum).max(tileflowCaptureSceneLimits.viewport.maximum),
+  dpr: z.union([z.literal(1), z.literal(2)]).optional()
+}).strict().superRefine((viewport, context) => {
+  const dpr = viewport.dpr ?? 1;
+  const physicalPixels = viewport.width * viewport.height * dpr * dpr;
+  if (physicalPixels > tileflowCaptureSceneLimits.maximumPhysicalPixels) {
+    context.addIssue({
+      code: "custom",
+      message: `Expected at most ${tileflowCaptureSceneLimits.maximumPhysicalPixels} physical pixels`,
+      path: ["dpr"]
+    });
+  }
+});
+var tileflowCaptureIdSchema = z.string().trim().min(1).max(tileflowCaptureSceneLimits.captureIdLength).regex(/^[A-Za-z0-9_-]+$/, {
+  message: "Expected letters, numbers, underscores, or hyphens"
+}).refine((name) => name !== "__proto__", {
+  message: "Expected an identifier that cannot mutate an object prototype"
+});
+var tileflowCaptureSceneNameSchema = tileflowCaptureIdSchema.refine(
+  (name) => !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
+  "Expected a portable scene name that is not a reserved filename or prototype key"
+);
+var applicationPathSchema = z.string().min(1).max(tileflowCaptureSceneLimits.applicationPathLength).refine(isPortableApplicationPath, {
+  message: "Expected a root-relative application path without an origin, credentials, fragment, backslash, or control character"
+});
+var tileflowCaptureMapTargetSchema = z.object({ kind: z.literal("map") }).strict();
+var tileflowCaptureApplicationTargetSchema = z.object({
+  kind: z.literal("application"),
+  path: applicationPathSchema,
+  captureId: tileflowCaptureIdSchema.optional(),
+  selector: z.string().trim().min(1).max(tileflowCaptureSceneLimits.selectorLength).optional(),
+  frame: z.enum(["map", "viewport"]).optional()
+}).strict().superRefine((target, context) => {
+  if (target.captureId && target.selector) {
+    context.addIssue({
+      code: "custom",
+      message: "Expected either captureId or selector, not both",
+      path: ["selector"]
+    });
+  }
+});
+var tileflowCaptureTargetSchema = z.discriminatedUnion("kind", [
+  tileflowCaptureMapTargetSchema,
+  tileflowCaptureApplicationTargetSchema
+]);
+var tileflowCaptureSceneSchema = z.object({
+  map: tileflowCaptureIdSchema,
+  camera: tileflowCaptureCameraSchema,
+  viewport: tileflowCaptureViewportSchema,
+  target: tileflowCaptureTargetSchema.optional()
+}).strict();
+function normalizeTileflowCaptureScene(input) {
+  const scene = tileflowCaptureSceneSchema.parse(input);
+  const camera = scene.camera.type === "center" ? {
+    type: scene.camera.type,
+    center: scene.camera.center,
+    zoom: scene.camera.zoom,
+    bearing: scene.camera.bearing ?? 0,
+    pitch: scene.camera.pitch ?? 0
+  } : {
+    type: scene.camera.type,
+    bounds: scene.camera.bounds,
+    padding: scene.camera.padding ?? 0,
+    bearing: scene.camera.bearing ?? 0,
+    pitch: scene.camera.pitch ?? 0
+  };
+  const target = scene.target ?? { kind: "map" };
+  return {
+    map: scene.map,
+    camera,
+    viewport: { ...scene.viewport, dpr: scene.viewport.dpr ?? 1 },
+    target: target.kind === "map" ? target : {
+      kind: target.kind,
+      path: target.path,
+      ...target.captureId ? { captureId: target.captureId } : {},
+      ...target.selector ? { selector: target.selector } : {},
+      frame: target.frame ?? "map"
+    }
+  };
+}
+function normalizeTileflowCaptureId(value) {
+  return value === void 0 ? void 0 : tileflowCaptureIdSchema.parse(value);
+}
+function isPortableApplicationPath(value) {
+  if (value !== value.trim() || !value.startsWith("/") || value.startsWith("//") || value.includes("#") || value.includes("\\") || hasControlCharacter(value)) {
+    return false;
+  }
+  try {
+    const base = new URL("http://tileflow.local");
+    const resolved = new URL(value, base);
+    return resolved.origin === base.origin && resolved.username === "" && resolved.password === "" && resolved.pathname.startsWith("/");
+  } catch {
+    return false;
+  }
+}
+function hasControlCharacter(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}
+
+// src/schema.ts
 var legacyThemeNames = /* @__PURE__ */ new Set(["standard", "light", "dark", "minimal", "osm-bright-2"]);
-var identifierSchema = z.string().trim().regex(/^[A-Za-z0-9_-]+$/, {
+var prototypeSafeInputSchema = z2.unknown().superRefine((value, context) => {
+  const unsafe = findUnsafeObjectStructure(value);
+  if (unsafe) {
+    context.addIssue({
+      code: "custom",
+      message: unsafe.reason === "key" ? "Expected an object without prototype-mutating keys" : "Expected plain configuration objects without inherited properties",
+      path: unsafe.path
+    });
+  }
+});
+var identifierSchema = z2.string().trim().regex(/^[A-Za-z0-9_-]+$/, {
   message: "Expected letters, numbers, underscores, or hyphens"
+}).refine((value) => value !== "__proto__", {
+  message: "Expected an identifier that cannot mutate an object prototype"
+});
+var sourceVersionSchema = z2.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, {
+  message: "Expected a portable source version"
 });
-var hexColorSchema = z.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
+var hexColorSchema = z2.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
   message: "Expected a hex color like #F6F7F3 or #F6F7F3FF"
 });
 function colorGroupSchema(keys) {
   const shape = Object.fromEntries(
     keys.map((key) => [key, hexColorSchema.optional()])
   );
-  return z.object(shape).strict();
+  return z2.object(shape).strict();
 }
-var colorConfigSchema = z.object({
+var colorConfigSchema = z2.object({
   accent: hexColorSchema.optional(),
   background: hexColorSchema.optional(),
   boundary: hexColorSchema.optional(),
@@ -1619,7 +2128,15 @@ var colorConfigSchema = z.object({
   textMuted: hexColorSchema.optional(),
   water: hexColorSchema.optional(),
   boundaries: colorGroupSchema(["admin", "disputed", "major", "maritime"]).optional(),
-  buildings: colorGroupSchema(["extrusion", "fill", "outline"]).optional(),
+  buildings: colorGroupSchema([
+    "extrusion",
+    "fill",
+    "highRise",
+    "highRiseOutline",
+    "lowRise",
+    "lowRiseOutline",
+    "outline"
+  ]).optional(),
   hydro: colorGroupSchema(["ferry", "label", "water", "waterway"]).optional(),
   labels: colorGroupSchema([
     "country",
@@ -1668,9 +2185,17 @@ var colorConfigSchema = z.object({
     "tunnel"
   ]).optional()
 }).strict();
-var themeModulesSchema = z.object({
+var themeModulesSchema = z2.object({
   boundaries: colorGroupSchema(["admin", "disputed", "major", "maritime"]).optional(),
-  buildings: colorGroupSchema(["extrusion", "fill", "outline"]).optional(),
+  buildings: colorGroupSchema([
+    "extrusion",
+    "fill",
+    "highRise",
+    "highRiseOutline",
+    "lowRise",
+    "lowRiseOutline",
+    "outline"
+  ]).optional(),
   hydro: colorGroupSchema(["ferry", "label", "water", "waterway"]).optional(),
   labels: colorGroupSchema([
     "country",
@@ -1719,170 +2244,228 @@ var themeModulesSchema = z.object({
     "tunnel"
   ]).optional()
 }).strict();
-var styleLayerOverrideSchema = z.object({
-  before: z.string().min(1).optional(),
-  filter: z.unknown().optional(),
-  layout: z.record(z.string(), z.unknown()).optional(),
-  maxzoom: z.number().finite().min(0).max(24).optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  minzoom: z.number().finite().min(0).max(24).optional(),
-  paint: z.record(z.string(), z.unknown()).optional(),
-  source: z.string().min(1).optional(),
-  "source-layer": z.string().min(1).optional(),
-  type: z.string().min(1).optional()
-}).catchall(z.unknown());
-var typographySchema = z.object({
-  font: z.string().trim().min(1).optional(),
-  fontFamily: z.string().trim().min(1).optional(),
-  weight: z.enum(["regular", "medium", "semibold", "bold"]).optional()
+var styleLayerOverrideSchema = z2.object({
+  before: z2.string().min(1).optional(),
+  filter: z2.unknown().optional(),
+  layout: z2.record(z2.string(), z2.unknown()).optional(),
+  maxzoom: z2.number().finite().min(0).max(24).optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).optional(),
+  minzoom: z2.number().finite().min(0).max(24).optional(),
+  paint: z2.record(z2.string(), z2.unknown()).optional(),
+  source: z2.string().min(1).optional(),
+  "source-layer": z2.string().min(1).optional(),
+  type: z2.string().min(1).optional()
+}).catchall(z2.unknown());
+var typographyStyleSchema = z2.object({
+  font: z2.string().trim().min(1).optional(),
+  fontFamily: z2.string().trim().min(1).optional(),
+  weight: z2.enum(["regular", "medium", "semibold", "bold"]).optional()
 }).strict();
-var fontsSchema = z.object({
-  body: z.string().trim().min(1).optional(),
-  labels: z.string().trim().min(1).optional()
+var typographySchema = typographyStyleSchema.extend({
+  places: typographyStyleSchema.optional(),
+  poi: typographyStyleSchema.optional(),
+  roads: typographyStyleSchema.optional(),
+  water: typographyStyleSchema.optional()
+});
+var fontsSchema = z2.object({
+  body: z2.string().trim().min(1).optional(),
+  labels: z2.string().trim().min(1).optional()
 }).strict();
-var tileflowThemeSchema = z.object({
+var tileflowThemeSchema = z2.object({
   colors: colorConfigSchema.optional(),
-  extends: z.string().trim().min(1).optional(),
+  extends: z2.string().trim().min(1).optional(),
   fonts: fontsSchema.optional(),
-  layers: z.record(z.string(), styleLayerOverrideSchema).optional(),
-  mode: z.enum(["light", "dark"]).optional(),
+  layers: z2.record(z2.string(), styleLayerOverrideSchema).optional(),
+  mode: z2.enum(["light", "dark"]).optional(),
   modules: themeModulesSchema.optional(),
   typography: typographySchema.optional()
 }).strict();
 var themeConfigSchema = tileflowThemeSchema;
-var sourceLayersSchema = z.object({
-  landuse: z.string().optional(),
-  park: z.string().optional(),
-  water: z.string().optional(),
-  waterName: z.string().optional(),
-  waterway: z.string().optional(),
-  road: z.string().optional(),
-  roadName: z.string().optional(),
-  building: z.string().optional(),
-  boundary: z.string().optional(),
-  place: z.string().optional(),
-  poi: z.string().optional()
+var sourceLayersSchema = z2.object({
+  landcover: z2.string().optional(),
+  landuse: z2.string().optional(),
+  park: z2.string().optional(),
+  water: z2.string().optional(),
+  waterName: z2.string().optional(),
+  waterway: z2.string().optional(),
+  road: z2.string().optional(),
+  roadName: z2.string().optional(),
+  building: z2.string().optional(),
+  boundary: z2.string().optional(),
+  place: z2.string().optional(),
+  poi: z2.string().optional()
 }).strict();
-var basemapSchema = z.object({
-  type: z.literal("osm"),
-  attribution: z.string().optional(),
-  glyphs: z.string().min(1).optional(),
-  sourceId: z.string().min(1).optional(),
+var basemapSchema = z2.object({
+  type: z2.literal("osm"),
+  attribution: z2.string().optional(),
+  glyphs: z2.string().min(1).optional(),
+  sourceId: z2.string().min(1).optional(),
   sourceLayers: sourceLayersSchema.optional(),
-  sprite: z.string().min(1).optional(),
-  tileset: z.string().trim().min(1).optional(),
-  url: z.url().optional()
+  sprite: z2.string().min(1).optional(),
+  tileset: z2.string().trim().min(1).optional(),
+  url: z2.url().optional(),
+  version: sourceVersionSchema.optional()
 }).strict();
-var roadDetailSchema = z.enum(["none", "highways", "major", "streets", "all"]);
-var roadsModuleSchema = z.object({
-  type: z.literal("roads"),
+var roadDetailSchema = z2.enum(["none", "highways", "major", "streets", "all"]);
+var roadClassSchema = z2.enum([
+  "motorway",
+  "trunk",
+  "primary",
+  "secondary",
+  "tertiary",
+  "minor",
+  "service",
+  "track",
+  "path"
+]);
+var roadsModuleSchema = z2.object({
+  type: z2.literal("roads"),
   detail: roadDetailSchema.optional(),
-  extras: z.object({
-    ferry: z.boolean().optional(),
-    paths: z.boolean().optional(),
-    rail: z.boolean().optional()
+  extras: z2.object({
+    ferry: z2.boolean().optional(),
+    paths: z2.boolean().optional(),
+    rail: z2.boolean().optional()
   }).strict().optional(),
-  hierarchy: z.enum(["subtle", "clear", "strong"]).optional(),
-  outline: z.enum(["none", "subtle", "strong"]).optional(),
-  weight: z.enum(["thin", "regular", "bold"]).optional()
+  hierarchy: z2.enum(["subtle", "clear", "strong"]).optional(),
+  oneWayMarkers: z2.boolean().optional(),
+  outline: z2.enum(["none", "subtle", "strong"]).optional(),
+  weight: z2.enum(["thin", "regular", "bold"]).optional(),
+  widthScale: z2.partialRecord(roadClassSchema, z2.number().finite().min(0.1).max(8)).optional()
 }).strict();
-var labelDetailSchema = z.enum(["none", "major", "all"]);
-var labelsModuleSchema = z.object({
-  type: z.literal("labels"),
-  language: z.string().trim().min(1).optional(),
+var labelDetailSchema = z2.enum(["none", "major", "all"]);
+var labelsModuleSchema = z2.object({
+  type: z2.literal("labels"),
+  language: z2.string().trim().min(1).optional(),
   places: labelDetailSchema.optional(),
+  roadClasses: z2.array(roadClassSchema).min(1).max(9).optional(),
   roads: roadDetailSchema.optional(),
   water: labelDetailSchema.optional()
 }).strict();
-var poiModuleSchema = z.object({
-  type: z.literal("poi"),
-  categories: z.array(identifierSchema).optional(),
-  icons: z.union([z.boolean(), z.enum(["essential", "full"])]).optional(),
-  labels: z.enum(["none", "minimal", "balanced", "full"]).optional(),
-  minZoom: z.number().finite().min(0).max(24).optional(),
-  preset: z.enum(["none", "minimal", "balanced", "full"]).optional()
+var poiModuleSchema = z2.object({
+  type: z2.literal("poi"),
+  categories: z2.array(identifierSchema).optional(),
+  classMapping: z2.record(identifierSchema, z2.array(identifierSchema).min(1).max(64)).optional(),
+  color: z2.enum(["uniform", "category"]).optional(),
+  density: z2.enum(["sparse", "balanced", "dense"]).optional(),
+  icons: z2.union([z2.boolean(), z2.enum(["essential", "full"])]).optional(),
+  labels: z2.enum(["none", "minimal", "balanced", "full"]).optional(),
+  minZoom: z2.number().finite().min(0).max(24).optional(),
+  placement: z2.object({
+    coupleIconAndLabel: z2.boolean().optional(),
+    iconPadding: z2.number().finite().min(0).max(64).optional(),
+    textPadding: z2.number().finite().min(0).max(64).optional()
+  }).strict().optional(),
+  preset: z2.enum(["none", "minimal", "balanced", "full"]).optional()
 }).strict();
-var styleOverrideModuleSchema = z.object({
-  type: z.literal("styleOverride"),
-  layers: z.record(z.string(), styleLayerOverrideSchema).optional(),
-  removeLayers: z.array(z.string().min(1)).optional()
+var styleOverrideModuleSchema = z2.object({
+  type: z2.literal("styleOverride"),
+  layers: z2.record(z2.string(), styleLayerOverrideSchema).optional(),
+  removeLayers: z2.array(z2.string().min(1)).optional()
 }).strict();
-var moduleSchema = z.discriminatedUnion("type", [
+var moduleSchema = z2.discriminatedUnion("type", [
   labelsModuleSchema,
   poiModuleSchema,
   roadsModuleSchema,
   styleOverrideModuleSchema
 ]);
-var iconSetSchema = z.union([
-  z.string().trim().min(1),
-  z.object({
-    extends: z.string().trim().min(1).optional(),
-    mapping: z.record(identifierSchema, z.string().trim().min(1)).optional(),
-    source: z.string().trim().min(1).optional(),
-    sprite: z.string().trim().min(1).optional()
+var iconSetSchema = z2.union([
+  z2.string().trim().min(1),
+  z2.object({
+    extends: z2.string().trim().min(1).optional(),
+    mapping: z2.record(identifierSchema, z2.string().trim().min(1)).optional(),
+    source: z2.string().trim().min(1).optional(),
+    sprite: z2.string().trim().min(1).optional()
   }).strict()
 ]);
-var viewSchema = z.object({
-  bearing: z.number().finite().min(-180).max(180).optional(),
-  center: z.tuple([z.number().finite(), z.number().finite()]).refine(([lng, lat]) => lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90, {
+var viewSchema = z2.object({
+  bearing: z2.number().finite().min(-180).max(180).optional(),
+  center: z2.tuple([z2.number().finite(), z2.number().finite()]).refine(([lng, lat]) => lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90, {
     message: "Expected center as [lng, lat] within world bounds"
   }).optional(),
-  zoom: z.number().finite().min(0).max(24).optional()
+  zoom: z2.number().finite().min(0).max(24).optional()
 }).strict();
-var terrainConfigSchema = z.object({
-  attribution: z.string().optional(),
-  encoding: z.enum(["mapbox", "terrarium"]).optional(),
-  exaggeration: z.number().min(0).max(10).optional(),
-  mode: z.enum(["none", "hillshade", "3d"]).optional(),
-  sourceId: z.string().min(1).optional(),
-  tileset: z.string().trim().min(1).optional(),
-  url: z.url().optional()
+var buildingStyleSchema = z2.object({
+  fillOpacity: z2.number().finite().min(0).max(1).optional(),
+  heightThreshold: z2.number().finite().min(0).max(1e3).optional(),
+  outlineOpacity: z2.number().finite().min(0).max(1).optional(),
+  outlineWidth: z2.number().finite().min(0).max(16).optional()
 }).strict();
-var tilesSchema = z.object({
-  sourceId: z.string().min(1).optional(),
-  tileset: z.string().trim().min(1).optional(),
-  url: z.url().optional(),
-  attribution: z.string().optional(),
-  sourceLayers: sourceLayersSchema.optional()
+var terrainConfigSchema = z2.object({
+  attribution: z2.string().optional(),
+  encoding: z2.enum(["mapbox", "terrarium"]).optional(),
+  exaggeration: z2.number().min(0).max(10).optional(),
+  mode: z2.enum(["none", "hillshade", "3d"]).optional(),
+  sourceId: z2.string().min(1).optional(),
+  tileset: z2.string().trim().min(1).optional(),
+  url: z2.url().optional()
+}).strict();
+var tilesSchema = z2.object({
+  sourceId: z2.string().min(1).optional(),
+  tileset: z2.string().trim().min(1).optional(),
+  url: z2.url().optional(),
+  attribution: z2.string().optional(),
+  sourceLayers: sourceLayersSchema.optional(),
+  version: sourceVersionSchema.optional()
 }).strict();
-var tileflowMapSchema = z.object({
+var tileflowMapSchema = z2.object({
   basemap: basemapSchema.optional(),
-  name: z.string().min(1).optional(),
-  tileset: z.string().trim().min(1).optional(),
-  theme: z.union([z.string().trim().min(1), themeConfigSchema]).optional(),
-  modules: z.array(moduleSchema).optional(),
-  layers: z.record(z.string(), styleLayerOverrideSchema).optional(),
+  name: z2.string().min(1).optional(),
+  tileset: z2.string().trim().min(1).optional(),
+  theme: z2.union([z2.string().trim().min(1), themeConfigSchema]).optional(),
+  modules: z2.array(moduleSchema).optional(),
+  layers: z2.record(z2.string(), styleLayerOverrideSchema).optional(),
   colors: colorConfigSchema.optional(),
   typography: typographySchema.optional(),
-  density: z.enum(["clean", "balanced", "dense"]).optional(),
-  roads: z.enum(["hidden", "soft", "standard", "detailed"]).optional(),
-  labels: z.enum(["none", "essential", "balanced", "full"]).optional(),
-  poi: z.enum(["none", "minimal", "balanced", "full"]).optional(),
-  buildings: z.enum(["hidden", "flat", "3d"]).optional(),
-  terrain: z.union([z.enum(["none", "hillshade", "3d"]), terrainConfigSchema]).optional(),
-  renderer: z.enum(["auto", "osm-bright", "generated"]).optional(),
-  glyphs: z.string().min(1).optional(),
+  density: z2.enum(["clean", "balanced", "dense"]).optional(),
+  roads: z2.enum(["hidden", "soft", "standard", "detailed"]).optional(),
+  labels: z2.enum(["none", "essential", "balanced", "full"]).optional(),
+  poi: z2.enum(["none", "minimal", "balanced", "full"]).optional(),
+  buildings: z2.enum(["hidden", "flat", "3d"]).optional(),
+  buildingStyle: buildingStyleSchema.optional(),
+  terrain: z2.union([z2.enum(["none", "hillshade", "3d"]), terrainConfigSchema]).optional(),
+  renderer: z2.enum(["auto", "osm-bright", "generated"]).optional(),
+  glyphs: z2.string().min(1).optional(),
   icons: iconSetSchema.optional(),
-  sprite: z.string().min(1).optional(),
+  sprite: z2.string().min(1).optional(),
   tiles: tilesSchema.optional(),
   view: viewSchema.optional(),
-  allowedOrigins: z.array(z.string().trim().min(1).max(253)).max(20).optional()
+  allowedOrigins: z2.array(z2.string().trim().min(1).max(253)).max(20).optional()
 }).strict();
-var configSchema = tileflowMapSchema;
-var tilesetConfigSchema = z.object({
-  id: z.string().trim().min(1).optional(),
-  name: z.string().trim().min(1).optional(),
-  attribution: z.string().optional(),
-  sourceLayers: sourceLayersSchema.optional()
-}).strict();
-var tileflowProjectSchema = z.object({
-  icons: z.record(identifierSchema, iconSetSchema).optional(),
-  themes: z.record(identifierSchema, themeConfigSchema).optional(),
-  tilesets: z.record(identifierSchema, tilesetConfigSchema).optional(),
-  maps: z.record(identifierSchema, configSchema).refine((maps) => {
-    return Object.keys(maps).length > 0;
-  }, "Expected at least one map")
+var configSchema = prototypeSafeInputSchema.pipe(tileflowMapSchema);
+var tilesetConfigSchema = z2.object({
+  id: z2.string().trim().min(1).optional(),
+  name: z2.string().trim().min(1).optional(),
+  attribution: z2.string().optional(),
+  sourceLayers: sourceLayersSchema.optional(),
+  version: sourceVersionSchema.optional()
 }).strict();
+var captureScenesSchema = z2.record(tileflowCaptureSceneNameSchema, tileflowCaptureSceneSchema).superRefine((scenes, context) => {
+  const namesByCaseFold = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(scenes).sort()) {
+    const folded = name.toLowerCase();
+    const existing = namesByCaseFold.get(folded);
+    if (existing !== void 0) {
+      context.addIssue({
+        code: "custom",
+        message: `Expected a portable scene name distinct from "${existing}" on case-insensitive filesystems`,
+        path: [name]
+      });
+    } else {
+      namesByCaseFold.set(folded, name);
+    }
+  }
+});
+var tileflowProjectSchema = prototypeSafeInputSchema.pipe(
+  z2.object({
+    icons: z2.record(identifierSchema, iconSetSchema).optional(),
+    scenes: captureScenesSchema.optional(),
+    themes: z2.record(identifierSchema, themeConfigSchema).optional(),
+    tilesets: z2.record(identifierSchema, tilesetConfigSchema).optional(),
+    maps: z2.record(identifierSchema, configSchema).refine((maps) => {
+      return Object.keys(maps).length > 0;
+    }, "Expected at least one map")
+  }).strict()
+);
 var projectConfigSchema = tileflowProjectSchema;
 function parseTileflowMap(input) {
   const parsed = configSchema.parse(input);
@@ -1939,17 +2522,54 @@ function validateConfig(input) {
 var validateTileflowConfig = validateConfig;
 function isProjectConfigLike(input) {
   return Boolean(
-    input && typeof input === "object" && "maps" in input && typeof input.maps === "object"
+    input && typeof input === "object" && Object.hasOwn(input, "maps") && typeof input.maps === "object"
   );
 }
+function findUnsafeObjectStructure(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const pending = [{ path: [], value: input }];
+  const visited = /* @__PURE__ */ new WeakSet();
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current || visited.has(current.value)) continue;
+    visited.add(current.value);
+    if (!Array.isArray(current.value)) {
+      const prototype = Object.getPrototypeOf(current.value);
+      if (prototype !== Object.prototype && prototype !== null) {
+        return { path: current.path, reason: "prototype" };
+      }
+    }
+    for (const key of Object.keys(current.value)) {
+      const path = [...current.path, Array.isArray(current.value) ? Number(key) : key];
+      if (key === "__proto__") return { path, reason: "key" };
+      const descriptor = Object.getOwnPropertyDescriptor(current.value, key);
+      if (descriptor && "value" in descriptor && descriptor.value && typeof descriptor.value === "object") {
+        pending.push({ path, value: descriptor.value });
+      }
+    }
+  }
+  return void 0;
+}
 function validateProjectThemeReferences(project) {
   const themeNames = new Set(Object.keys(project.themes ?? {}));
   const themeMessages = validateThemeExtends(project.themes, themeNames);
   const iconMessages = validateProjectIconReferences(project);
+  const sceneMessages = validateProjectSceneReferences(project);
   const mapMessages = Object.entries(project.maps).flatMap(
     ([mapName, mapConfig]) => validateMapThemeReference(mapConfig, themeNames, `maps.${mapName}.theme`)
   );
-  return [...themeMessages, ...iconMessages, ...mapMessages];
+  return [...themeMessages, ...iconMessages, ...sceneMessages, ...mapMessages];
+}
+function validateProjectSceneReferences(project) {
+  return Object.entries(project.scenes ?? {}).flatMap(
+    ([sceneName, scene]) => Object.hasOwn(project.maps, scene.map) ? [] : [
+      {
+        level: "error",
+        path: `scenes.${sceneName}.map`,
+        message: `Unknown Tileflow map "${scene.map}"`
+      }
+    ]
+  );
 }
 function validateMapThemeReference(config, themeNames, path) {
   if (!config.theme) {
@@ -2019,7 +2639,7 @@ function validateProjectIconReferences(project) {
   const iconSets = project.icons ?? {};
   for (const [iconSetName, iconSet] of Object.entries(iconSets)) {
     const extendedName = iconSetReference(iconSet);
-    if (extendedName && !iconSets[extendedName]) {
+    if (extendedName && !Object.hasOwn(iconSets, extendedName)) {
       messages.push({
         level: "error",
         path: iconSetExtendsPath(`icons.${iconSetName}`, iconSet),
@@ -2041,7 +2661,7 @@ function validateProjectIconReferences(project) {
     if (!isIconSetObject(mapConfig.icons) || !mapConfig.icons.extends) {
       continue;
     }
-    if (!iconSets[mapConfig.icons.extends]) {
+    if (!Object.hasOwn(iconSets, mapConfig.icons.extends)) {
       messages.push({
         level: "error",
         path: `maps.${mapName}.icons.extends`,
@@ -2055,8 +2675,8 @@ function findIconSetCycle(iconSetName, iconSets, path) {
   if (path.includes(iconSetName)) {
     return [...path, iconSetName];
   }
-  const nextIconSetName = iconSetReference(iconSets?.[iconSetName]);
-  if (!nextIconSetName || !iconSets?.[nextIconSetName]) {
+  const nextIconSetName = Object.hasOwn(iconSets ?? {}, iconSetName) ? iconSetReference(iconSets?.[iconSetName]) : void 0;
+  if (!nextIconSetName || !Object.hasOwn(iconSets ?? {}, nextIconSetName)) {
     return void 0;
   }
   return findIconSetCycle(nextIconSetName, iconSets, [...path, iconSetName]);
@@ -2140,6 +2760,7 @@ function applyOsmBrightControls(layers, options) {
       return applyPoiLayerControls(
         layer,
         options.poi,
+        options.colors,
         options.customIconSpriteId,
         options.customIconMapping
       );
@@ -2166,7 +2787,8 @@ function applyRoadLayerControls(layer, roads2) {
   const opacityScale = isCasing ? metrics.outlineOpacity : group === "highways" || group === "major" ? metrics.majorOpacity : group === "ferry" ? metrics.majorOpacity * 0.8 : group === "paths" ? metrics.minorOpacity * 0.77 : group === "rail" ? metrics.minorOpacity * 0.65 : metrics.minorOpacity;
   if (type === "line") {
     paint["line-opacity"] = scaleStyleValue(paint["line-opacity"], opacityScale, 1);
-    paint["line-width"] = scaleStyleValue(paint["line-width"], widthScale, 1);
+    const scaledWidth = scaleStyleValue(paint["line-width"], widthScale, 1);
+    paint["line-width"] = roads2.widthScale ? multiplyStyleValue(scaledWidth, roadClassWidthScaleExpression(roads2.widthScale)) : scaledWidth;
     nextLayer.paint = paint;
   }
   if (type === "fill") {
@@ -2187,6 +2809,22 @@ function applyRoadLayerControls(layer, roads2) {
   }
   return nextLayer;
 }
+function multiplyStyleValue(value, multiplier) {
+  return ["*", legacyCameraFunctionExpression(value), multiplier];
+}
+function legacyCameraFunctionExpression(value) {
+  if (!isRecord3(value) || !Array.isArray(value.stops)) return value;
+  const stops = value.stops.filter(
+    (stop) => Array.isArray(stop) && stop.length >= 2 && typeof stop[0] === "number"
+  );
+  if (stops.length === 0) return typeof value.default === "number" ? value.default : 1;
+  return [
+    "interpolate",
+    ["exponential", typeof value.base === "number" ? value.base : 1],
+    ["zoom"],
+    ...stops.flatMap(([zoom, output]) => [zoom, output])
+  ];
+}
 function isRoadLayerVisible(group, roads2) {
   if (roads2.detail === "none") return false;
   if (group === "paths") return roads2.extras.paths;
@@ -2246,7 +2884,9 @@ function applyLabelLayerControls(layer, labels2, roads2) {
     layout["text-field"] = labelTextField(labels2.language);
   }
   if (group === "roads") {
-    const allowedClasses = (roads2 ? visibleRoadLabelClasses(detail, roads2) : roadLabelClasses(detail)).filter((roadClass) => roadLabelLayerClasses(id).includes(roadClass));
+    const allowedClasses = (roads2 ? visibleRoadLabelClasses(detail, roads2, labels2.roadClasses) : roadLabelClasses(detail).filter(
+      (roadClass) => !labels2.roadClasses || labels2.roadClasses.includes(roadClass)
+    )).filter((roadClass) => roadLabelLayerClasses(id).includes(roadClass));
     if (allowedClasses.length === 0) {
       return setLayerVisibility(layer, "none");
     }
@@ -2262,15 +2902,24 @@ function applyLabelLayerControls(layer, labels2, roads2) {
   nextLayer.layout = layout;
   return nextLayer;
 }
-function applyPoiLayerControls(layer, poi2, customIconSpriteId2, customIconMapping) {
+function applyPoiLayerControls(layer, poi2, colors, customIconSpriteId2, customIconMapping) {
   if (poi2.mode === "none") {
     return setLayerVisibility(layer, "none");
   }
   const nextLayer = setLayerVisibility(layer, "visible");
   const layout = isRecord3(nextLayer.layout) ? { ...nextLayer.layout } : {};
+  const paint = isRecord3(nextLayer.paint) ? { ...nextLayer.paint } : {};
   nextLayer.minzoom = Math.max(numberValue(nextLayer.minzoom) ?? 0, poi2.minZoom);
   if (poi2.categories && sourceLayerValue(nextLayer) === "poi") {
-    nextLayer.filter = combineFilters(nextLayer.filter, poiCategoryFilter(poi2.categories));
+    nextLayer.filter = combineFilters(
+      nextLayer.filter,
+      poiCategoryFilter(poi2.categories, poi2.classMapping)
+    );
+  }
+  if (poi2.density && sourceLayerValue(nextLayer) === "poi") {
+    const densityFilter = poiDensityFilter(poi2.density, poi2.classMapping);
+    if (densityFilter) nextLayer.filter = combineFilters(nextLayer.filter, densityFilter);
+    layout["symbol-sort-key"] = poiPriorityExpression(poi2.classMapping);
   }
   if (poi2.labels === "none") {
     delete layout["text-field"];
@@ -2280,10 +2929,21 @@ function applyPoiLayerControls(layer, poi2, customIconSpriteId2, customIconMappi
   if (poi2.icons === false) {
     delete layout["icon-image"];
   } else if ("icon-image" in layout || customIconSpriteId2) {
-    layout["icon-image"] = poiIconImageExpression(customIconSpriteId2, customIconMapping);
-    layout["icon-optional"] = true;
+    layout["icon-image"] = poiIconImageExpression(
+      customIconSpriteId2,
+      customIconMapping,
+      poi2.classMapping
+    );
+    layout["icon-optional"] = !poi2.placement.coupleIconAndLabel;
+    layout["icon-padding"] = poi2.placement.iconPadding;
+  }
+  layout["text-padding"] = poi2.placement.textPadding;
+  if (poi2.placement.coupleIconAndLabel) layout["text-optional"] = false;
+  if (poi2.color === "category" && "text-color" in paint) {
+    paint["text-color"] = poiCategoryColorExpression(colors, poi2.classMapping);
   }
   nextLayer.layout = layout;
+  nextLayer.paint = paint;
   return nextLayer;
 }
 function labelGroupDetail(labels2, group) {
@@ -4909,8 +5569,8 @@ var style_default = {
 };
 
 // src/templates/osm-bright/theme.ts
-function applyOsmBrightTheme(layers, colors, theme, typography) {
-  if (!theme.custom && theme.name === "light") {
+function applyOsmBrightTheme(layers, colors, theme, typography, typographyOverridden = theme.typographyOverridden) {
+  if (!theme.custom && theme.name === "light" && !typographyOverridden) {
     return layers;
   }
   return layers.map((layer) => {
@@ -4950,8 +5610,8 @@ function applyOsmBrightTheme(layers, colors, theme, typography) {
         paint["text-halo-color"] = colors.labels.halo;
         paintChanged = true;
       }
-      if (theme.typographyOverridden && "text-font" in layout) {
-        layout["text-font"] = textFont(typography);
+      if (typographyOverridden && "text-font" in layout) {
+        layout["text-font"] = textFont(typography, typographyDomain(id, sourceLayer));
         layoutChanged = true;
       }
     }
@@ -4964,6 +5624,16 @@ function applyOsmBrightTheme(layers, colors, theme, typography) {
     return nextLayer;
   });
 }
+function typographyDomain(id, sourceLayer) {
+  if (sourceLayer === "poi" || id.startsWith("poi-")) return "poi";
+  if (sourceLayer === "transportation_name" || id.includes("highway-name") || id.includes("highway-shield")) {
+    return "roads";
+  }
+  if (sourceLayer === "water_name" || sourceLayer === "waterway" || id.includes("water-name")) {
+    return "water";
+  }
+  return "places";
+}
 function osmBrightFillColor(id, sourceLayer, colors, theme) {
   if (sourceLayer === "water" || id.includes("water")) {
     return hasBaseColor(theme, ["water"]) || hasNestedModuleColor(theme, "hydro", "water") ? colors.hydro.water : void 0;
@@ -5183,16 +5853,22 @@ function createOsmBrightStyle(options) {
     layers,
     options.colors,
     options.theme,
-    options.typography
+    options.typography,
+    options.typographyOverridden
   );
   const controlledLayers = applyOsmBrightControls(themedLayers, {
+    colors: options.colors,
     customIconMapping: options.customIconMapping,
     customIconSpriteId: options.customIconSpriteId,
     labels: options.labelsModule,
     poi: options.poiModule,
     roads: options.roadsModule
   });
-  const resolvedLayers = options.terrain ? withTerrainLayers(controlledLayers, options.terrain) : controlledLayers;
+  const semanticLayers = options.roadsModule?.oneWayMarkers ? insertBeforeRoadLabels(
+    controlledLayers,
+    oneWayMarkerLayer(options.sourceId, "transportation", options.colors, options.typography)
+  ) : controlledLayers;
+  const resolvedLayers = options.terrain ? withTerrainLayers(semanticLayers, options.terrain) : semanticLayers;
   return {
     ...template,
     name: options.name,
@@ -5222,6 +5898,13 @@ function createOsmBrightStyle(options) {
     }
   };
 }
+function insertBeforeRoadLabels(layers, layer) {
+  const index = layers.findIndex(
+    (candidate) => candidate.type === "symbol" && candidate["source-layer"] === "transportation_name"
+  );
+  if (index < 0) return [...layers, layer];
+  return [...layers.slice(0, index), layer, ...layers.slice(index)];
+}
 function cloneJson(value) {
   return JSON.parse(JSON.stringify(value));
 }
@@ -5236,7 +5919,9 @@ function remapOsmBrightSource(layer, sourceId) {
 }
 
 // src/compiler.ts
+var tileflowHostedNotoSansWeights = ["regular", "bold"];
 var defaultSourceLayers = {
+  landcover: "landcover",
   landuse: "landuse",
   park: "park",
   water: "water",
@@ -5302,6 +5987,15 @@ function createStyle(input = {}, options = {}) {
     theme.preset.roads ?? defaultConfig.roads
   );
   const { mode: resolvedRoadMode, ...resolvedRoadModule } = resolvedRoads;
+  const resolvedRoadModuleMetadata = {
+    detail: resolvedRoadModule.detail,
+    extras: resolvedRoadModule.extras,
+    hierarchy: resolvedRoadModule.hierarchy,
+    outline: resolvedRoadModule.outline,
+    weight: resolvedRoadModule.weight,
+    ...roadModule?.oneWayMarkers !== void 0 ? { oneWayMarkers: resolvedRoadModule.oneWayMarkers } : {},
+    ...roadModule?.widthScale ? { widthScale: resolvedRoadModule.widthScale } : {}
+  };
   const resolvedLabels = resolveLabels(
     config.labels,
     labelsModule,
@@ -5309,14 +6003,18 @@ function createStyle(input = {}, options = {}) {
   );
   const { mode: resolvedLabelsMode, ...resolvedLabelsModule } = resolvedLabels;
   const resolvedPoi = resolvePoi(config.poi, poiModule, theme.preset.poi ?? defaultConfig.poi);
+  const { mode: poi2, ...resolvedPoiModule } = resolvedPoi;
   const labels2 = resolvedLabelsMode;
-  const poi2 = resolvedPoi.mode;
   const buildings = config.buildings ?? "flat";
   const colors = resolveColors(config.colors, theme.colors, {}, theme.modules);
   const sourceId = config.tiles?.sourceId ?? basemap.sourceId ?? "tileflow";
   const tileBaseUrl = normalizeBaseUrl(options.tileBaseUrl);
   const tileset = options.tileset ?? config.tileset ?? config.tiles?.tileset ?? basemap.tileset ?? defaultTileset;
-  const tilesUrl = config.tiles?.url ?? basemap.url ?? `${tileBaseUrl}/tiles/${tileset}/tiles.json`;
+  const tilesetVersion = config.tiles?.version ?? basemap.version;
+  const tilesUrl = withArchiveVersion(
+    config.tiles?.url ?? basemap.url ?? `${tileBaseUrl}/tiles/${tileset}/tiles.json`,
+    tilesetVersion
+  );
   const typography = resolveTypography(config.typography, theme.typography);
   const terrain = resolveTerrain(config.terrain, tileBaseUrl);
   const rendererPreference = config.renderer ?? "auto";
@@ -5324,10 +6022,11 @@ function createStyle(input = {}, options = {}) {
   const useOsmBrightTemplate = rendererPreference === "osm-bright" || rendererPreference === "auto" && canUseOsmBrightTemplate;
   if (rendererPreference === "osm-bright" && !canUseOsmBrightTemplate) {
     throw new Error(
-      'Tileflow renderer "osm-bright" is not compatible with this config. Use renderer "auto" or "generated", or remove map-level color overrides, typography, density, legacy roads/buildings, custom source layers, and unsupported modules.'
+      'Tileflow renderer "osm-bright" is not compatible with this config. Use renderer "auto" or "generated", or remove map-level color overrides, density, legacy roads/buildings, custom source layers, and unsupported modules.'
     );
   }
   const glyphs = config.glyphs ?? basemap.glyphs ?? `${tileBaseUrl}/fonts/{fontstack}/{range}.pbf`;
+  validateHostedTypography(typography, glyphs, tileBaseUrl);
   const iconSet = resolveIconSet(config.icons, options.iconSets);
   const iconSprite = iconSet?.sprite;
   const basemapSprite = basemap.sprite ?? (basemap.type === "osm" ? `${tileBaseUrl}/sprites/osm-bright/sprite` : void 0);
@@ -5340,32 +6039,38 @@ function createStyle(input = {}, options = {}) {
     "tileflow:themeMode": theme.mode,
     "tileflow:density": density,
     "tileflow:roads": resolvedRoadMode,
-    "tileflow:roadsModule": roadModule ? resolvedRoadModule : void 0,
+    ...roadModule ? { "tileflow:roadsModule": resolvedRoadModuleMetadata } : {},
     "tileflow:labels": labels2,
-    "tileflow:labelsModule": labelsModule ? resolvedLabelsModule : void 0,
+    ...labelsModule ? { "tileflow:labelsModule": resolvedLabelsModule } : {},
     "tileflow:poi": poi2,
-    "tileflow:poiModule": poiModule,
-    "tileflow:icons": iconSet ? {
-      customSpriteId: customIconSpriteName,
-      mapping: iconSet.mapping,
-      sprite: iconSprite
-    } : void 0,
+    ...poiModule ? { "tileflow:poiModule": resolvedPoiModule } : {},
+    ...iconSet ? {
+      "tileflow:icons": {
+        ...customIconSpriteName ? { customSpriteId: customIconSpriteName } : {},
+        ...iconSet.mapping ? { mapping: iconSet.mapping } : {},
+        ...iconSprite ? { sprite: iconSprite } : {}
+      }
+    } : {},
     "tileflow:buildings": buildings,
+    ...config.buildingStyle ? { "tileflow:buildingStyle": config.buildingStyle } : {},
     "tileflow:modules": config.modules?.map((moduleConfig) => moduleConfig.type) ?? [],
     "tileflow:themeModules": Object.keys(theme.moduleOverrides),
-    "tileflow:terrain": terrain ? {
-      encoding: terrain.source.encoding,
-      mode: terrain.mode,
-      sourceId: terrain.sourceId
-    } : void 0,
+    ...terrain ? {
+      "tileflow:terrain": {
+        encoding: terrain.source.encoding,
+        mode: terrain.mode,
+        sourceId: terrain.sourceId
+      }
+    } : {},
     "tileflow:renderer": useOsmBrightTemplate ? "osm-bright" : "generated",
     "tileflow:rendererPreference": rendererPreference,
-    "tileflow:typography": typography,
+    "tileflow:typography": typographyMetadata(typography),
     "tileflow:colors": colors,
     "tileflow:tileBaseUrl": tileBaseUrl,
     "tileflow:tileset": tileset,
+    ...tilesetVersion ? { "tileflow:tilesetVersion": tilesetVersion } : {},
     "tileflow:tiles": "tileflow",
-    "tileflow:view": config.view
+    ...config.view ? { "tileflow:view": config.view } : {}
   };
   if (useOsmBrightTemplate) {
     const style2 = createOsmBrightStyle({
@@ -5380,6 +6085,7 @@ function createStyle(input = {}, options = {}) {
       theme,
       tilesUrl,
       typography,
+      typographyOverridden: Boolean(config.typography) || theme.typographyOverridden,
       labelsModule: resolvedLabels,
       poi: poi2,
       poiModule: resolvedPoi,
@@ -5402,6 +6108,7 @@ function createStyle(input = {}, options = {}) {
   );
   const layers = openMapTilesLayers(sourceId, sourceLayers, colors, {
     buildings,
+    buildingStyle: config.buildingStyle,
     density,
     labels: resolvedLabels,
     poi: resolvedPoi,
@@ -5439,7 +6146,7 @@ function createStyle(input = {}, options = {}) {
   return style;
 }
 function createStyleFromProject(projectConfig, mapName, options = {}) {
-  const config = projectConfig.maps[mapName];
+  const config = Object.hasOwn(projectConfig.maps, mapName) ? projectConfig.maps[mapName] : void 0;
   if (!config) {
     throw new Error(`Unknown Tileflow map: ${mapName}`);
   }
@@ -5458,11 +6165,13 @@ function createStyleFromProject(projectConfig, mapName, options = {}) {
         ...baseBasemap,
         tileset: resolvedTileset,
         attribution: baseBasemap.attribution ?? tilesetConfig?.attribution,
+        version: baseBasemap.version ?? tilesetConfig?.version,
         ...resolvedBasemapSourceLayers ? { sourceLayers: resolvedBasemapSourceLayers } : {}
       },
       tiles: {
         ...tileOptions,
         tileset: resolvedTileset,
+        version: tileOptions.version ?? baseBasemap.version ?? tilesetConfig?.version,
         ...resolvedTileSourceLayers ? { sourceLayers: resolvedTileSourceLayers } : {}
       }
     },
@@ -5501,7 +6210,7 @@ function resolveSourceLayers(mapLayers, tilesetLayers) {
 }
 function isOsmBrightTemplateCompatible(config, basemap, theme) {
   const templateTheme = theme.custom || theme.name === "light" || theme.name === "dark";
-  return basemap.type === "osm" && templateTheme && !hasEffectiveColorOverrides(config.colors) && !config.typography && !config.density && !config.roads && !config.buildings && !config.modules?.some(
+  return basemap.type === "osm" && templateTheme && !hasEffectiveColorOverrides(config.colors) && !config.density && !config.roads && !config.buildings && !config.buildingStyle && !config.modules?.some(
     (moduleConfig) => moduleConfig.type !== "styleOverride" && moduleConfig.type !== "labels" && moduleConfig.type !== "poi" && moduleConfig.type !== "roads"
   ) && !basemap.sourceLayers && !config.tiles?.sourceLayers;
 }
@@ -5519,6 +6228,23 @@ function hasEffectiveColorOverrides(colors) {
     return typeof value === "string";
   });
 }
+function typographyMetadata(typography) {
+  const base = {
+    font: typography.font,
+    fontFamily: typography.fontFamily,
+    weight: typography.weight
+  };
+  return {
+    ...base,
+    ...sameTypographyStyle(typography.places, base) ? {} : { places: typography.places },
+    ...sameTypographyStyle(typography.roads, base) ? {} : { roads: typography.roads },
+    ...sameTypographyStyle(typography.water, base) ? {} : { water: typography.water },
+    ...sameTypographyStyle(typography.poi, base) ? {} : { poi: typography.poi }
+  };
+}
+function sameTypographyStyle(left, right) {
+  return left.font === right.font && left.fontFamily === right.fontFamily && left.weight === right.weight;
+}
 function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -5531,6 +6257,12 @@ function normalizeStyleBaseUrl(value) {
 function normalizeUrl(value) {
   return value.replace(/\/+$/, "");
 }
+function withArchiveVersion(value, version) {
+  if (!version) return value;
+  const url = new URL(value);
+  url.searchParams.set("archiveVersion", version);
+  return url.toString();
+}
 function resolveIconSet(icons, iconSets, path = []) {
   if (!icons) {
     return void 0;
@@ -5573,12 +6305,455 @@ function resolveSprite(basemapSprite, iconSprite) {
 function isSpriteReference(value) {
   return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("/") || value.startsWith("data:");
 }
+function validateHostedTypography(typography, glyphs, tileBaseUrl) {
+  const hostedGlyphs = `${tileBaseUrl}/fonts/{fontstack}/{range}.pbf`;
+  if (glyphs !== hostedGlyphs) return;
+  for (const [domain, style] of [
+    ["default", typography],
+    ["places", typography.places],
+    ["roads", typography.roads],
+    ["water", typography.water],
+    ["poi", typography.poi]
+  ]) {
+    if (style.font === "Noto Sans" && !tileflowHostedNotoSansWeights.includes(style.weight)) {
+      throw new Error(
+        `Tileflow-hosted Noto Sans does not provide the ${style.weight} weight for ${domain} typography. Use regular or bold, or configure a custom glyphs URL that provides this font stack.`
+      );
+    }
+  }
+}
 
 // src/config.ts
 function defineTileflow(config) {
   return config;
 }
 
+// src/icon-package.ts
+import { z as z3 } from "zod";
+var tileflowIconPackageFileNames = [
+  "sprite.json",
+  "sprite.png",
+  "sprite@2x.json",
+  "sprite@2x.png"
+];
+var tileflowHostedIconIdPattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+var tileflowIconPackageLimits = {
+  decodeConcurrency: 4,
+  maxAtlasDimension: 2048,
+  maxDecodedPixelsPerIcon: 4194304,
+  maxGeneratedFileBytes: 4 * 1024 * 1024,
+  maxGeneratedPackageBytes: 8 * 1024 * 1024,
+  maxIconCount: 256,
+  maxSourceBytes: 32 * 1024 * 1024,
+  maxSourceFileBytes: 1024 * 1024
+};
+var tileflowHostedAlphaCompatibility = {
+  iconPackages: {
+    maxGeneratedBytesPerProject: 64 * 1024 * 1024,
+    maxRetainedPerProject: 24
+  },
+  maxMapsPerDeploy: 1
+};
+var sha256Schema = z3.string().regex(/^[a-f0-9]{64}$/);
+var tileflowIconPackageContentHashSchema = sha256Schema;
+var tileflowHostedIconIdSchema = z3.string().regex(tileflowHostedIconIdPattern);
+var tileflowRenderedIconManifestEntrySchema = z3.object({
+  name: z3.string().min(1).max(256),
+  pixelSha256: z3.object({
+    oneX: sha256Schema,
+    twoX: sha256Schema
+  }).strict()
+}).strict();
+var tileflowIconPackageLabelSchema = z3.string().superRefine((value, context) => {
+  if (value !== value.trim() || value.length === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Icon package labels must be non-empty and have no surrounding whitespace"
+    });
+  }
+  if (Array.from(value).length > 64) {
+    context.addIssue({
+      code: "custom",
+      message: "Icon package labels must contain at most 64 Unicode characters"
+    });
+  }
+  if (!isWellFormedUnicode(value) || containsControlCharacter(value)) {
+    context.addIssue({
+      code: "custom",
+      message: "Icon package labels must contain printable, well-formed Unicode"
+    });
+  }
+});
+var spriteDimensionsSchema = z3.object({
+  height: z3.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
+  pixelRatio: z3.union([z3.literal(1), z3.literal(2)]),
+  width: z3.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension)
+}).strict();
+function iconPackageFileSchema(name, contentType) {
+  return z3.object({
+    byteLength: z3.number().int().nonnegative().max(tileflowIconPackageLimits.maxGeneratedFileBytes),
+    contentType: z3.literal(contentType),
+    name: z3.literal(name),
+    sha256: sha256Schema
+  }).strict();
+}
+var tileflowIconPackageManifestSchema = z3.object({
+  files: z3.tuple([
+    iconPackageFileSchema("sprite.json", "application/json"),
+    iconPackageFileSchema("sprite.png", "image/png"),
+    iconPackageFileSchema("sprite@2x.json", "application/json"),
+    iconPackageFileSchema("sprite@2x.png", "image/png")
+  ]),
+  format: z3.literal("tileflow-icon-package-v1"),
+  iconNames: z3.array(z3.string().min(1).max(256)).min(1).max(tileflowIconPackageLimits.maxIconCount),
+  renderedIcons: z3.array(tileflowRenderedIconManifestEntrySchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
+  sprites: z3.object({
+    oneX: spriteDimensionsSchema.extend({ pixelRatio: z3.literal(1) }),
+    twoX: spriteDimensionsSchema.extend({ pixelRatio: z3.literal(2) })
+  }).strict()
+}).strict().superRefine((manifest, context) => {
+  const sortedNames = [...manifest.iconNames].sort(compareCodeUnits);
+  if (sortedNames.some((name, index) => name !== manifest.iconNames[index]) || new Set(manifest.iconNames).size !== manifest.iconNames.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Icon names must be unique and sorted by Unicode code unit",
+      path: ["iconNames"]
+    });
+  }
+  if (manifest.renderedIcons.length !== manifest.iconNames.length || manifest.renderedIcons.some((entry, index) => entry.name !== manifest.iconNames[index])) {
+    context.addIssue({
+      code: "custom",
+      message: "Rendered icon entries must exactly match iconNames in sorted order",
+      path: ["renderedIcons"]
+    });
+  }
+  const totalBytes = manifest.files.reduce((total, file) => total + file.byteLength, 0);
+  if (totalBytes > tileflowIconPackageLimits.maxGeneratedPackageBytes) {
+    context.addIssue({
+      code: "custom",
+      message: `Generated icon package exceeds ${tileflowIconPackageLimits.maxGeneratedPackageBytes} bytes`,
+      path: ["files"]
+    });
+  }
+  if (manifest.sprites.twoX.width !== manifest.sprites.oneX.width * 2 || manifest.sprites.twoX.height !== manifest.sprites.oneX.height * 2) {
+    context.addIssue({
+      code: "custom",
+      message: "The @2x sprite dimensions must be exactly twice the 1x dimensions",
+      path: ["sprites", "twoX"]
+    });
+  }
+});
+function compareCodeUnits(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+function serializeCanonicalJson(value) {
+  return JSON.stringify(sortJsonValue(value));
+}
+function serializeTileflowIconPackageManifest(input) {
+  const manifest = tileflowIconPackageManifestSchema.parse(input);
+  return serializeCanonicalJson(manifest);
+}
+async function sha256Hex(input) {
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const digestInput = new Uint8Array(bytes.byteLength);
+  digestInput.set(bytes);
+  const digest = await crypto.subtle.digest("SHA-256", digestInput.buffer);
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function hashTileflowIconPackageManifest(input) {
+  return sha256Hex(serializeTileflowIconPackageManifest(input));
+}
+async function hashTileflowRenderedIconPixels(input) {
+  if (!Number.isSafeInteger(input.width) || !Number.isSafeInteger(input.height) || input.width <= 0 || input.height <= 0 || input.width > tileflowIconPackageLimits.maxAtlasDimension || input.height > tileflowIconPackageLimits.maxAtlasDimension) {
+    throw new Error("Rendered icon dimensions are invalid");
+  }
+  if (input.pixelRatio !== 1 && input.pixelRatio !== 2) {
+    throw new Error("Rendered icon pixel ratio must be 1 or 2");
+  }
+  const pixelCount = input.width * input.height;
+  const expectedBytes = pixelCount * 4;
+  if (pixelCount > tileflowIconPackageLimits.maxDecodedPixelsPerIcon || input.rgba.byteLength !== expectedBytes) {
+    throw new Error(`Rendered icon RGBA must contain exactly ${expectedBytes} bytes`);
+  }
+  const normalized = new Uint8Array(input.rgba);
+  for (let offset = 0; offset < normalized.byteLength; offset += 4) {
+    if (normalized[offset + 3] === 0) {
+      normalized[offset] = 0;
+      normalized[offset + 1] = 0;
+      normalized[offset + 2] = 0;
+    }
+  }
+  const domain = new TextEncoder().encode("tileflow-rendered-icon-pixels-v1\0");
+  const frame = new Uint8Array(domain.byteLength + 9 + normalized.byteLength);
+  frame.set(domain);
+  frame[domain.byteLength] = input.pixelRatio;
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  view.setUint32(domain.byteLength + 1, input.width);
+  view.setUint32(domain.byteLength + 5, input.height);
+  frame.set(normalized, domain.byteLength + 9);
+  return sha256Hex(frame);
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => compareCodeUnits(left, right)).map(([key, child]) => [key, sortJsonValue(child)])
+    );
+  }
+  return value;
+}
+function isWellFormedUnicode(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next < 56320 || next > 57343) {
+        return false;
+      }
+      index += 1;
+      continue;
+    }
+    if (code >= 56320 && code <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function containsControlCharacter(value) {
+  return Array.from(value).some((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint < 32 || codePoint >= 127 && codePoint <= 159;
+  });
+}
+
+// src/icon-diff.ts
+function diffTileflowIconPackageManifests(before, after) {
+  const beforeIcons = new Map(
+    (before?.renderedIcons ?? []).map((entry) => [entry.name, entry.pixelSha256])
+  );
+  const afterIcons = new Map(
+    (after?.renderedIcons ?? []).map((entry) => [entry.name, entry.pixelSha256])
+  );
+  const names = [.../* @__PURE__ */ new Set([...beforeIcons.keys(), ...afterIcons.keys()])].sort(compareCodeUnits);
+  const added = [];
+  const modified = [];
+  const removed = [];
+  let unchangedCount = 0;
+  for (const name of names) {
+    const previous = beforeIcons.get(name);
+    const proposed = afterIcons.get(name);
+    if (!previous) {
+      added.push(name);
+    } else if (!proposed) {
+      removed.push(name);
+    } else if (previous.oneX !== proposed.oneX || previous.twoX !== proposed.twoX) {
+      modified.push(name);
+    } else {
+      unchangedCount += 1;
+    }
+  }
+  return {
+    added,
+    afterBytes: packageBytes(after),
+    beforeBytes: packageBytes(before),
+    modified,
+    removed,
+    unchangedCount
+  };
+}
+function diffTileflowIconMappings(before, after) {
+  const previous = before ?? {};
+  const proposed = after ?? {};
+  const keys = [.../* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(proposed)])].sort(
+    compareCodeUnits
+  );
+  const result = { added: [], changed: [], removed: [] };
+  for (const key of keys) {
+    const beforeTarget = previous[key];
+    const afterTarget = proposed[key];
+    if (beforeTarget === void 0 && afterTarget !== void 0) {
+      result.added.push({ after: afterTarget, key });
+    } else if (beforeTarget !== void 0 && afterTarget === void 0) {
+      result.removed.push({ before: beforeTarget, key });
+    } else if (beforeTarget !== afterTarget) {
+      result.changed.push({ after: afterTarget, before: beforeTarget, key });
+    }
+  }
+  return result;
+}
+function inspectTileflowIconReferences(project, mapName, availableIconNames) {
+  const map = Object.hasOwn(project.maps, mapName) ? project.maps[mapName] : void 0;
+  if (!map) {
+    throw new Error(`Unknown Tileflow map: ${mapName}`);
+  }
+  const available = new Set(availableIconNames);
+  const dangling = [];
+  const unanalyzable = [];
+  const mapping = resolveMappingReferences(project, mapName, map.icons);
+  for (const reference of mapping.values()) {
+    if (!available.has(reference.iconName)) {
+      dangling.push({ ...reference, kind: "mapping" });
+    }
+  }
+  const layers = [];
+  collectThemeLayers(project, mapName, map.theme, layers);
+  if (map.layers) {
+    layers.push({ layers: map.layers, path: `maps.${mapName}.layers` });
+  }
+  for (const [index, moduleConfig] of (map.modules ?? []).entries()) {
+    if (moduleConfig.type === "styleOverride" && moduleConfig.layers) {
+      layers.push({
+        layers: moduleConfig.layers,
+        path: `maps.${mapName}.modules.${index}.layers`
+      });
+    }
+  }
+  for (const layerGroup of layers) {
+    for (const [layerName, layer] of Object.entries(layerGroup.layers).sort(
+      ([left], [right]) => compareCodeUnits(left, right)
+    )) {
+      if (!layer.layout || !Object.prototype.hasOwnProperty.call(layer.layout, "icon-image")) {
+        continue;
+      }
+      const path = `${layerGroup.path}.${layerName}.layout.icon-image`;
+      const inspection = inspectIconImageValue(layer.layout["icon-image"]);
+      for (const iconName of inspection.managedIconNames) {
+        if (!available.has(iconName)) {
+          dangling.push({ iconName, kind: "style-override-literal", path });
+        }
+      }
+      if (!inspection.complete) {
+        unanalyzable.push({ kind: "style-override-expression", path });
+      }
+    }
+  }
+  const uniqueDangling = uniqueBy(
+    dangling,
+    (item) => `${item.kind}\0${item.path}\0${item.iconName}`
+  ).sort(compareReferences);
+  const uniqueUnanalyzable = uniqueBy(unanalyzable, (item) => `${item.kind}\0${item.path}`).sort(
+    (left, right) => compareCodeUnits(left.path, right.path)
+  );
+  return {
+    analysisComplete: uniqueUnanalyzable.length === 0,
+    dangling: uniqueDangling,
+    unanalyzable: uniqueUnanalyzable
+  };
+}
+function resolveTileflowIconMapping(project, mapName) {
+  const map = Object.hasOwn(project.maps, mapName) ? project.maps[mapName] : void 0;
+  if (!map) {
+    throw new Error(`Unknown Tileflow map: ${mapName}`);
+  }
+  return Object.fromEntries(
+    [...resolveMappingReferences(project, mapName, map.icons).entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([key, reference]) => [key, reference.iconName])
+  );
+}
+function packageBytes(manifest) {
+  return manifest?.files.reduce((total, file) => total + file.byteLength, 0) ?? 0;
+}
+function resolveMappingReferences(project, mapName, icons) {
+  const result = /* @__PURE__ */ new Map();
+  function apply(value, path, rootPath) {
+    if (!value) {
+      return;
+    }
+    if (typeof value === "string") {
+      const referenced = Object.hasOwn(project.icons ?? {}, value) ? project.icons?.[value] : void 0;
+      if (!referenced) {
+        return;
+      }
+      if (rootPath.includes(value)) {
+        throw new Error(`Circular Tileflow icon set extends: ${[...rootPath, value].join(" -> ")}`);
+      }
+      apply(referenced, `icons.${value}`, [...rootPath, value]);
+      return;
+    }
+    if (value.extends) {
+      apply(value.extends, path, rootPath);
+    }
+    for (const [key, iconName] of Object.entries(value.mapping ?? {}).sort(
+      ([left], [right]) => compareCodeUnits(left, right)
+    )) {
+      result.set(key, { iconName, path: `${path}.mapping.${key}` });
+    }
+  }
+  apply(icons, `maps.${mapName}.icons`, []);
+  return result;
+}
+function collectThemeLayers(project, mapName, theme, result) {
+  function apply(value, path, rootPath) {
+    if (!value) {
+      return;
+    }
+    if (typeof value === "string") {
+      const custom = Object.hasOwn(project.themes ?? {}, value) ? project.themes?.[value] : void 0;
+      if (!custom) {
+        return;
+      }
+      if (rootPath.includes(value)) {
+        throw new Error(`Circular Tileflow theme extends: ${[...rootPath, value].join(" -> ")}`);
+      }
+      apply(custom, `themes.${value}`, [...rootPath, value]);
+      return;
+    }
+    if (value.extends) {
+      apply(value.extends, path, rootPath);
+    }
+    if (value.layers) {
+      result.push({ layers: value.layers, path: `${path}.layers` });
+    }
+  }
+  apply(theme, `maps.${mapName}.theme`, []);
+}
+function inspectIconImageValue(value) {
+  if (typeof value === "string") {
+    const managed = managedIconName(value);
+    return { complete: true, managedIconNames: managed ? [managed] : [] };
+  }
+  if (!Array.isArray(value)) {
+    return { complete: false, managedIconNames: [] };
+  }
+  const managedIconNames = /* @__PURE__ */ new Set();
+  collectManagedImageLiterals(value, managedIconNames);
+  const isSingleLiteralImage = value.length === 2 && (value[0] === "image" || value[0] === "literal") && typeof value[1] === "string";
+  return {
+    complete: isSingleLiteralImage,
+    managedIconNames: [...managedIconNames].sort(compareCodeUnits)
+  };
+}
+function collectManagedImageLiterals(value, result) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  if ((value[0] === "image" || value[0] === "literal") && typeof value[1] === "string") {
+    const managed = managedIconName(value[1]);
+    if (managed) {
+      result.add(managed);
+    }
+  }
+  for (const child of value) {
+    collectManagedImageLiterals(child, result);
+  }
+}
+function managedIconName(value) {
+  return value.startsWith("tileflow:") && value.length > "tileflow:".length ? value.slice("tileflow:".length) : null;
+}
+function uniqueBy(values, key) {
+  return [...new Map(values.map((value) => [key(value), value])).values()];
+}
+function compareReferences(left, right) {
+  return compareCodeUnits(left.path, right.path) || compareCodeUnits(left.kind, right.kind) || compareCodeUnits(left.iconName, right.iconName);
+}
+
 // src/runtime.ts
 var defaultTileflowManifestUrl = "/tileflow/manifest.json";
 var defaultTileflowStyleBaseUrl = "http://localhost:3333";
@@ -5857,6 +7032,7 @@ function getTileflowLocationOrigin() {
   return window.location.origin;
 }
 export {
+  compareCodeUnits,
   configSchema,
   createManifest,
   createStyle,
@@ -5865,14 +7041,21 @@ export {
   defaultTileflowManifestUrl,
   defaultTileflowStyleBaseUrl,
   defineTileflow,
+  diffTileflowIconMappings,
+  diffTileflowIconPackageManifests,
   getDefaultColors2 as getDefaultColors,
   getDefaultTileflowStyleBaseUrl,
   getTileflowAnalyticsApiUrl,
+  hashTileflowIconPackageManifest,
+  hashTileflowRenderedIconPixels,
   inferTileflowAnalyticsFromStyleUrl,
+  inspectTileflowIconReferences,
   isTileflowLocalDevHost,
   labels,
   loadTileflowManifest,
   mergeTileflowAnalytics,
+  normalizeTileflowCaptureId,
+  normalizeTileflowCaptureScene,
   normalizeTileflowStaticImageSize,
   normalizeTileflowUrl,
   osm,
@@ -5880,17 +7063,43 @@ export {
   parseTileflowProject,
   poi,
   resolveTileflowAnalyticsRequestUrl,
+  resolveTileflowIconMapping,
   resolveTileflowManifestMap,
   resolveTileflowMapMode,
   resolveTileflowRuntimeStyle,
   resolveTileflowStaticImageUrl,
   resolveTileflowStyleUrl,
   roads,
+  serializeCanonicalJson,
+  serializeTileflowIconPackageManifest,
+  sha256Hex,
   shouldLoadTileflowManifest,
   startTileflowSession,
   styleOverride,
+  tileflowCaptureApplicationTargetSchema,
+  tileflowCaptureBoundsCameraSchema,
+  tileflowCaptureCameraSchema,
+  tileflowCaptureCenterCameraSchema,
+  tileflowCaptureIdSchema,
+  tileflowCaptureMapTargetSchema,
+  tileflowCaptureSceneLimits,
+  tileflowCaptureSceneNameSchema,
+  tileflowCaptureSceneSchema,
+  tileflowCaptureSceneSchemaVersion,
+  tileflowCaptureTargetSchema,
+  tileflowCaptureViewportSchema,
+  tileflowHostedAlphaCompatibility,
+  tileflowHostedIconIdPattern,
+  tileflowHostedIconIdSchema,
+  tileflowHostedNotoSansWeights,
+  tileflowIconPackageContentHashSchema,
+  tileflowIconPackageFileNames,
+  tileflowIconPackageLabelSchema,
+  tileflowIconPackageLimits,
+  tileflowIconPackageManifestSchema,
   tileflowMapSchema,
   tileflowProjectSchema,
+  tileflowRenderedIconManifestEntrySchema,
   tileflowThemeSchema,
   validateConfig,
   validateTileflowConfig