@tileflow/core 0.1.0-alpha.13 → 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) {
@@ -512,858 +544,1070 @@ function rgbToHex(r, g, b) {
   return `#${[r, g, b].map((value) => value.toString(16).padStart(2, "0")).join("")}`;
 }
 
-// src/modules/labels/index.ts
-var moduleLabelDefaults = {
-  language: "auto",
-  places: "major",
-  roads: "major",
-  water: "major"
+// src/modules/roads/index.ts
+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 majorPlaceClasses = ["continent", "country", "state", "city", "town"];
 var highwayRoadClasses = ["motorway", "trunk"];
 var arterialRoadClasses = ["primary", "secondary", "tertiary"];
 var majorRoadClasses = [...highwayRoadClasses, ...arterialRoadClasses];
-var majorRoadClassSet = new Set(majorRoadClasses);
 var streetRoadClasses = ["minor"];
 var serviceRoadClasses = ["service", "track"];
-var majorWaterClasses = ["ocean", "sea", "lake"];
-var majorWaterwayClasses = ["river"];
-function labels(options = {}) {
+var majorRoadClassSet = new Set(majorRoadClasses);
+function roadClassesForDetail(detail) {
+  if (detail === "none") return [];
+  return [
+    ...detail === "highways" ? highwayRoadClasses : majorRoadClasses,
+    ...detail === "streets" || detail === "all" ? streetRoadClasses : [],
+    ...detail === "all" ? serviceRoadClasses : []
+  ];
+}
+function isMajorRoadClass(roadClass) {
+  return majorRoadClassSet.has(roadClass);
+}
+function roads(options = {}) {
   return {
-    type: "labels",
-    ...options.language ? { language: options.language } : {},
-    ...options.places ? { places: options.places } : {},
-    ...options.roads ? { roads: options.roads } : {},
-    ...options.water ? { water: options.water } : {}
+    type: "roads",
+    ...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.widthScale ? { widthScale: { ...options.widthScale } } : {}
   };
 }
-function resolveLabels(legacyLabels, moduleConfig, fallback) {
-  const fallbackMode = legacyLabels ?? fallback;
-  const defaults = moduleConfig ? moduleLabelDefaults : labelDefaultsFromLegacyMode(fallbackMode);
+function resolveRoads(legacyRoads, moduleConfig, fallback) {
+  const fallbackMode = legacyRoads ?? fallback;
+  const defaults = moduleConfig ? moduleRoadDefaults : roadDefaultsFromLegacyMode(fallbackMode);
   const resolved = {
-    language: moduleConfig?.language ?? defaults.language,
-    places: moduleConfig?.places ?? defaults.places,
-    roads: moduleConfig?.roads ?? defaults.roads,
-    water: moduleConfig?.water ?? defaults.water
+    detail: moduleConfig?.detail ?? defaults.detail,
+    extras: {
+      ferry: moduleConfig?.extras?.ferry ?? defaults.extras.ferry,
+      paths: moduleConfig?.extras?.paths ?? defaults.extras.paths,
+      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,
+    ...moduleConfig?.widthScale ? { widthScale: { ...defaultRoadWidthScale, ...moduleConfig.widthScale } } : {}
   };
   return {
     ...resolved,
-    mode: moduleConfig ? legacyModeFromResolvedLabels(resolved) : fallbackMode
+    mode: legacyModeFromResolvedRoads(resolved)
   };
 }
-function labelLayers(source, sourceLayers, colors, labelsConfig, roadsConfig, typography) {
-  return [
-    ...placeLabelLayers(source, sourceLayers.place, colors, labelsConfig, typography),
-    ...roadLabelLayers(
-      source,
-      sourceLayers.roadName,
-      colors,
-      labelsConfig,
-      roadsConfig,
-      typography
-    ),
-    ...waterLabelLayers(
-      source,
-      sourceLayers.waterName,
-      sourceLayers.waterway,
-      colors,
-      labelsConfig,
-      typography
-    )
-  ];
+function roadStyleMetrics(options) {
+  const hierarchy = {
+    subtle: {
+      majorOpacity: 0.92,
+      majorWidthScale: 1,
+      minorOpacity: 0.82,
+      minorWidthScale: 0.94
+    },
+    clear: {
+      majorOpacity: 0.92,
+      majorWidthScale: 1,
+      minorOpacity: 0.68,
+      minorWidthScale: 0.84
+    },
+    strong: {
+      majorOpacity: 0.92,
+      majorWidthScale: 1,
+      minorOpacity: 0.52,
+      minorWidthScale: 0.7
+    }
+  }[options.hierarchy];
+  const weightScale = {
+    thin: 0.78,
+    regular: 1,
+    bold: 1.24
+  }[options.weight];
+  const outlineOpacity = {
+    none: 0,
+    subtle: 0.18,
+    strong: 0.34
+  }[options.outline];
+  return {
+    ...hierarchy,
+    outlineOpacity,
+    weightScale
+  };
 }
-function placeLabelLayers(source, sourceLayer, colors, labelsConfig, typography) {
-  if (labelsConfig.places === "none") return [];
-  return [
-    {
-      id: "place-labels",
-      type: "symbol",
+function roadLayers(source, sourceLayer, colors, options, typography) {
+  if (options.detail === "none") {
+    return [];
+  }
+  const metrics = roadStyleMetrics(options);
+  const roadClasses = roadClassesForDetail(options.detail);
+  const selectedMajorRoadClasses = roadClasses.filter(isMajorRoadClass);
+  const showsStreetRoads = roadClasses.includes("minor");
+  const showsServiceRoads = roadClasses.includes("service");
+  const transportClasses = [
+    ...roadClasses,
+    ...options.extras.paths ? ["path"] : [],
+    ...options.extras.rail ? ["rail", "transit"] : [],
+    ...options.extras.ferry ? ["ferry"] : []
+  ];
+  const roadClassColor = roadClassColorExpression(colors);
+  const nonTunnelRoadFilter = ["!=", ["get", "brunnel"], "tunnel"];
+  const majorFilter = classFilter(selectedMajorRoadClasses);
+  const streetFilter = classFilter(streetRoadClasses);
+  const serviceFilter = classFilter(serviceRoadClasses);
+  const roadFilter = classFilter(roadClasses);
+  const transportFilter = classFilter(transportClasses);
+  const layers = [];
+  if (options.outline !== "none") {
+    layers.push({
+      id: "roads-tunnels-casing",
+      type: "line",
       source,
       "source-layer": sourceLayer,
-      minzoom: 0,
-      filter: labelsConfig.places === "major" ? ["all", ["has", "name"], classFilter(majorPlaceClasses)] : ["has", "name"],
-      layout: {
-        "text-field": labelTextField(labelsConfig.language),
-        "text-font": textFont(typography),
-        "text-size": ["interpolate", ["linear"], ["zoom"], 3, 10, 8, 13, 14, 17],
-        "text-letter-spacing": 0,
-        "text-padding": 4
-      },
+      minzoom: 10,
+      filter: ["all", ["==", ["get", "brunnel"], "tunnel"], transportFilter],
       paint: {
-        "text-color": colors.labels.primary,
-        "text-halo-color": colors.labels.halo,
-        "text-halo-width": 1.2
+        "line-color": colors.roads.tunnel,
+        "line-dasharray": [0.6, 0.8],
+        "line-opacity": roadOpacityExpression(
+          metrics.outlineOpacity * 0.85,
+          metrics.outlineOpacity * 0.85
+        ),
+        "line-width": roadWidthExpression(
+          [
+            [10, 0.8],
+            [14, 2.2],
+            [16, 4.8]
+          ],
+          metrics,
+          options.widthScale
+        )
       }
+    });
+  }
+  layers.push({
+    id: "roads-tunnels",
+    type: "line",
+    source,
+    "source-layer": sourceLayer,
+    minzoom: 10,
+    filter: ["all", ["==", ["get", "brunnel"], "tunnel"], transportFilter],
+    paint: {
+      "line-color": roadClassColor,
+      "line-dasharray": [0.6, 0.8],
+      "line-opacity": roadOpacityExpression(
+        metrics.majorOpacity * 0.28,
+        metrics.minorOpacity * 0.28
+      ),
+      "line-width": roadWidthExpression(
+        [
+          [10, 0.25],
+          [14, 1],
+          [16, 2.4]
+        ],
+        metrics,
+        options.widthScale
+      )
     }
-  ];
-}
-function roadLabelLayers(source, sourceLayer, colors, labelsConfig, roadsConfig, typography) {
-  const classes = visibleRoadLabelClasses(labelsConfig.roads, roadsConfig);
-  const majorClasses = classes.filter((roadClass) => majorRoadClassSet.has(roadClass));
-  const minorClasses = classes.filter((roadClass) => !majorRoadClassSet.has(roadClass));
-  if (classes.length === 0) return [];
-  const layers = [];
-  const sharedLayout = {
-    "symbol-placement": "line",
-    "text-field": labelTextField(labelsConfig.language),
-    "text-font": textFont(typography),
-    "text-rotation-alignment": "map",
-    "text-size": ["interpolate", ["linear"], ["zoom"], 11, 11, 14, 13, 17, 15]
-  };
-  const sharedPaint = {
-    "text-color": colors.labels.road,
-    "text-halo-color": colors.labels.halo,
-    "text-halo-width": 1
-  };
-  if (majorClasses.length > 0) {
-    const namedMajorClasses = majorClasses.filter((roadClass) => roadClass !== "motorway");
+  });
+  if (options.outline !== "none") {
     layers.push({
-      id: "road-shields",
-      type: "symbol",
+      id: "roads-casing",
+      type: "line",
       source,
       "source-layer": sourceLayer,
-      minzoom: 8,
-      filter: ["all", ["has", "ref"], classFilter(majorClasses)],
-      layout: {
-        "symbol-placement": "line",
-        "symbol-spacing": 240,
-        "text-field": ["get", "ref"],
-        "text-font": textFont(typography),
-        "text-rotation-alignment": "viewport",
-        "text-size": 10
-      },
-      paint: sharedPaint
+      minzoom: 5,
+      filter: ["all", nonTunnelRoadFilter, roadFilter],
+      paint: {
+        "line-color": colors.roads.casing,
+        "line-opacity": roadOpacityExpression(metrics.outlineOpacity, metrics.outlineOpacity),
+        "line-width": roadWidthExpression(
+          [
+            [6, 0.7],
+            [12, 1.8],
+            [16, 5.4]
+          ],
+          metrics,
+          options.widthScale
+        )
+      }
     });
-    if (namedMajorClasses.length > 0) {
-      layers.unshift({
-        id: "road-labels-major",
-        type: "symbol",
-        source,
-        "source-layer": sourceLayer,
-        minzoom: 10,
-        filter: ["all", ["has", "name"], classFilter(namedMajorClasses)],
-        layout: sharedLayout,
-        paint: sharedPaint
-      });
-    }
   }
-  if (minorClasses.length > 0) {
+  if (options.extras.ferry) {
     layers.push({
-      id: "road-labels-minor",
-      type: "symbol",
+      id: "roads-ferry",
+      type: "line",
       source,
       "source-layer": sourceLayer,
-      minzoom: 14,
-      filter: ["all", ["has", "name"], classFilter(minorClasses)],
-      layout: sharedLayout,
-      paint: sharedPaint
+      minzoom: 5,
+      filter: ["all", nonTunnelRoadFilter, classFilter(["ferry"])],
+      paint: {
+        "line-color": colors.roads.ferry,
+        "line-dasharray": [1.2, 1.1],
+        "line-opacity": metrics.majorOpacity * 0.8,
+        "line-width": zoomWidth(
+          [
+            [5, 0.25],
+            [12, 0.8],
+            [16, 2.6]
+          ],
+          metrics.weightScale
+        )
+      }
     });
   }
-  return layers;
-}
-function waterLabelLayers(source, waterNameSourceLayer, waterwaySourceLayer, colors, labelsConfig, typography) {
-  if (labelsConfig.water === "none") return [];
-  const waterFilter = labelsConfig.water === "major" ? ["all", ["has", "name"], classFilter(majorWaterClasses)] : ["has", "name"];
-  const waterwayFilter = labelsConfig.water === "major" ? ["all", ["has", "name"], classFilter(majorWaterwayClasses)] : ["has", "name"];
-  const paint = {
-    "text-color": colors.labels.water,
-    "text-halo-color": colors.labels.halo,
-    "text-halo-width": 1
-  };
-  return [
-    {
-      id: "water-labels",
-      type: "symbol",
+  if (options.extras.paths) {
+    layers.push({
+      id: "roads-paths",
+      type: "line",
       source,
-      "source-layer": waterNameSourceLayer,
-      minzoom: 3,
-      filter: ["all", ["==", ["geometry-type"], "Point"], waterFilter],
-      layout: {
-        "text-field": labelTextField(labelsConfig.language),
-        "text-font": textFont(typography),
-        "text-size": ["interpolate", ["linear"], ["zoom"], 3, 11, 8, 14]
-      },
-      paint
-    },
+      "source-layer": sourceLayer,
+      minzoom: 10,
+      filter: ["all", nonTunnelRoadFilter, classFilter(["path"])],
+      paint: {
+        "line-color": colors.roads.path,
+        "line-dasharray": [0.7, 0.7],
+        "line-opacity": metrics.minorOpacity * 0.77,
+        "line-width": zoomWidth(
+          [
+            [10, 0.25],
+            [14, 0.8],
+            [16, 2.2]
+          ],
+          metrics.weightScale * metrics.minorWidthScale * (options.widthScale?.path ?? 1)
+        )
+      }
+    });
+  }
+  if (options.extras.rail) {
+    layers.push({
+      id: "roads-rail",
+      type: "line",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 7,
+      filter: ["all", nonTunnelRoadFilter, classFilter(["rail", "transit"])],
+      paint: {
+        "line-color": colors.roads.rail,
+        "line-opacity": metrics.minorOpacity * 0.65,
+        "line-width": zoomWidth(
+          [
+            [7, 0.35],
+            [12, 0.9],
+            [16, 2.4]
+          ],
+          metrics.weightScale * metrics.minorWidthScale
+        )
+      }
+    });
+  }
+  if (showsServiceRoads) {
+    layers.push({
+      id: "roads-service",
+      type: "line",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 14,
+      filter: ["all", nonTunnelRoadFilter, serviceFilter],
+      paint: {
+        "line-color": roadClassColor,
+        "line-opacity": metrics.minorOpacity,
+        "line-width": zoomWidth(
+          [
+            [14, 0.6],
+            [16, 2.2]
+          ],
+          metrics.weightScale * metrics.minorWidthScale,
+          options.widthScale
+        )
+      }
+    });
+  }
+  if (showsStreetRoads) {
+    layers.push({
+      id: "roads-minor",
+      type: "line",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 12,
+      filter: ["all", nonTunnelRoadFilter, streetFilter],
+      paint: {
+        "line-color": roadClassColor,
+        "line-opacity": metrics.minorOpacity,
+        "line-width": zoomWidth(
+          [
+            [12, 0.8],
+            [16, 3]
+          ],
+          metrics.weightScale * metrics.minorWidthScale,
+          options.widthScale
+        )
+      }
+    });
+  }
+  layers.push(
     {
-      id: "water-line-labels",
-      type: "symbol",
+      id: "roads-major",
+      type: "line",
       source,
-      "source-layer": waterNameSourceLayer,
+      "source-layer": sourceLayer,
       minzoom: 5,
-      filter: ["all", ["==", ["geometry-type"], "LineString"], waterFilter],
-      layout: {
-        "symbol-placement": "line",
-        "text-field": labelTextField(labelsConfig.language),
-        "text-font": textFont(typography),
-        "text-size": 13
-      },
-      paint
+      filter: ["all", nonTunnelRoadFilter, majorFilter],
+      paint: {
+        "line-color": roadClassColor,
+        "line-opacity": metrics.majorOpacity,
+        "line-width": zoomWidth(
+          [
+            [5, 0.35],
+            [12, 1.2],
+            [16, 4]
+          ],
+          metrics.weightScale * metrics.majorWidthScale,
+          options.widthScale
+        )
+      }
     },
     {
-      id: "waterway-labels",
-      type: "symbol",
+      id: "roads-bridges",
+      type: "line",
       source,
-      "source-layer": waterwaySourceLayer,
+      "source-layer": sourceLayer,
       minzoom: 10,
-      filter: ["all", ["==", ["geometry-type"], "LineString"], waterwayFilter],
-      layout: {
-        "symbol-placement": "line",
-        "symbol-spacing": 320,
-        "text-field": labelTextField(labelsConfig.language),
-        "text-font": textFont(typography),
-        "text-size": 12
-      },
-      paint
+      filter: ["all", ["==", ["get", "brunnel"], "bridge"], transportFilter],
+      paint: {
+        "line-color": colors.roads.bridge,
+        "line-opacity": roadOpacityExpression(metrics.majorOpacity, metrics.minorOpacity),
+        "line-width": roadWidthExpression(
+          [
+            [10, 0.45],
+            [14, 1.6],
+            [16, 4.4]
+          ],
+          metrics,
+          options.widthScale
+        )
+      }
     }
-  ];
-}
-function visibleRoadLabelClasses(detail, roadsConfig) {
-  if (detail === "none" || roadsConfig.detail === "none") return [];
-  const visibleRoadClasses = roadsConfig.detail === "highways" ? [...highwayRoadClasses] : [
-    ...majorRoadClasses,
-    ...roadsConfig.detail === "streets" || roadsConfig.detail === "all" ? streetRoadClasses : [],
-    ...roadsConfig.detail === "all" ? serviceRoadClasses : [],
-    ...roadsConfig.extras.paths ? ["path"] : []
-  ];
-  const requestedClasses = detail === "major" ? [...majorRoadClasses] : [...majorRoadClasses, ...streetRoadClasses, ...serviceRoadClasses, "path"];
-  const visible = new Set(visibleRoadClasses);
-  return requestedClasses.filter((roadClass) => visible.has(roadClass));
-}
-function labelDefaultsFromLegacyMode(mode) {
-  if (mode === "none") {
-    return { language: "auto", places: "none", roads: "none", water: "none" };
-  }
-  if (mode === "essential") {
-    return { language: "auto", places: "major", roads: "major", water: "major" };
+  );
+  if (options.oneWayMarkers) {
+    layers.push(oneWayMarkerLayer(source, sourceLayer, colors, typography));
   }
-  return { language: "auto", places: "all", roads: "all", water: "all" };
+  return layers;
 }
-function legacyModeFromResolvedLabels(options) {
-  if (options.places === "none" && options.roads === "none" && options.water === "none") {
-    return "none";
+function roadDefaultsFromLegacyMode(mode) {
+  if (mode === "hidden") {
+    return {
+      detail: "none",
+      extras: { ferry: false, paths: false, rail: false },
+      hierarchy: "clear",
+      oneWayMarkers: false,
+      outline: "subtle",
+      weight: "regular"
+    };
   }
-  if (options.places === "major" && options.roads === "major" && options.water === "major") {
-    return "essential";
+  if (mode === "soft") {
+    return {
+      detail: "streets",
+      extras: { ferry: false, paths: false, rail: false },
+      hierarchy: "subtle",
+      oneWayMarkers: false,
+      outline: "subtle",
+      weight: "thin"
+    };
   }
-  return "balanced";
+  if (mode === "detailed") {
+    return {
+      detail: "all",
+      extras: { ferry: true, paths: true, rail: true },
+      hierarchy: "clear",
+      oneWayMarkers: false,
+      outline: "strong",
+      weight: "regular"
+    };
+  }
+  return {
+    detail: "streets",
+    extras: { ferry: true, paths: true, rail: true },
+    hierarchy: "clear",
+    oneWayMarkers: false,
+    outline: "subtle",
+    weight: "regular"
+  };
+}
+function legacyModeFromResolvedRoads(options) {
+  if (options.detail === "none") return "hidden";
+  if (options.hierarchy === "subtle") return "soft";
+  if (options.hierarchy === "strong" || options.detail === "all") return "detailed";
+  return "standard";
 }
 function classFilter(classes) {
   return ["match", ["get", "class"], classes, true, false];
 }
-function labelTextField(language) {
-  if (language === "local") {
-    return ["coalesce", ["get", "name"], ["get", "name:latin"], ["get", "name:en"]];
-  }
-  if (language === "auto") {
-    return ["coalesce", ["get", "name:latin"], ["get", "name"], ["get", "name:en"]];
-  }
-  return ["coalesce", ["get", `name:${language}`], ["get", "name:latin"], ["get", "name"]];
+function roadOpacityExpression(majorOpacity, minorOpacity) {
+  return [
+    "step",
+    ["zoom"],
+    roadOpacityAtZoom(majorOpacity, minorOpacity, 0, 0),
+    12,
+    roadOpacityAtZoom(majorOpacity, minorOpacity, minorOpacity, 0),
+    14,
+    roadOpacityAtZoom(majorOpacity, minorOpacity, minorOpacity, minorOpacity)
+  ];
 }
-
-// src/modules/poi/index.ts
-var defaultPoiMinZoom = {
-  none: 24,
-  minimal: 15,
-  balanced: 13,
-  full: 11
-};
-function poi(options = {}) {
-  return {
-    type: "poi",
-    ...options.categories ? { categories: options.categories } : {},
-    ...options.icons !== void 0 ? { icons: options.icons } : {},
-    ...options.labels ? { labels: options.labels } : {},
-    ...options.minZoom !== void 0 ? { minZoom: options.minZoom } : {},
-    ...options.preset ? { preset: options.preset } : {}
-  };
-}
-function resolvePoi(legacyPoi, moduleConfig, fallback) {
-  const mode = moduleConfig?.preset ?? legacyPoi ?? fallback;
-  return {
-    categories: moduleConfig?.categories,
-    icons: moduleConfig?.icons ?? (mode === "none" ? false : "essential"),
-    labels: moduleConfig?.labels ?? poiLabelsFromMode(mode),
-    minZoom: moduleConfig?.minZoom ?? defaultPoiMinZoom[mode],
-    mode
-  };
-}
-function poiLayers(source, sourceLayer, colors, poiConfig, typography, customIconSpriteId2, customIconMapping) {
-  if (poiConfig.mode === "none") {
-    return [];
-  }
-  const layout = {
-    "text-field": labelTextField("auto"),
-    "text-font": textFont(typography),
-    "text-size": ["interpolate", ["linear"], ["zoom"], poiConfig.minZoom, 10, 17, 12],
-    "text-letter-spacing": 0,
-    "text-padding": 2
-  };
-  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-size"] = ["interpolate", ["linear"], ["zoom"], poiConfig.minZoom, 0.85, 17, 1];
-    layout["text-anchor"] = "top";
-    layout["text-offset"] = [0, 0.75];
-  }
+function roadOpacityAtZoom(majorOpacity, minorOpacity, streetOpacity, serviceOpacity) {
   return [
-    {
-      id: "poi-labels",
-      type: "symbol",
-      source,
-      "source-layer": sourceLayer,
-      minzoom: poiConfig.minZoom,
-      ...poiConfig.categories ? { filter: poiCategoryFilter(poiConfig.categories) } : {},
-      layout,
-      paint: {
-        "text-color": colors.poi.label,
-        "text-halo-color": colors.poi.halo ?? alpha(colors.background, 0.78),
-        "text-halo-width": 1
-      }
-    }
+    "case",
+    classFilter(majorRoadClasses),
+    majorOpacity,
+    classFilter(streetRoadClasses),
+    streetOpacity,
+    classFilter(serviceRoadClasses),
+    serviceOpacity,
+    minorOpacity
   ];
 }
-function poiLabelsFromMode(mode) {
-  if (mode === "none") return "none";
-  if (mode === "minimal") return "minimal";
-  if (mode === "full") return "full";
-  return "balanced";
+function roadWidthExpression(stops, metrics, widthScale) {
+  return [
+    "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 poiCategoryFilter(categories) {
-  return ["in", "class", ...categories.flatMap((category) => poiCategoryClasses(category))];
+function zoomWidth(stops, scale, widthScale) {
+  return [
+    "interpolate",
+    ["linear"],
+    ["zoom"],
+    ...stops.flatMap(([zoom, width]) => [
+      zoom,
+      widthScale ? ["*", width * scale, roadClassWidthScaleExpression(widthScale)] : width * scale
+    ])
+  ];
 }
-function poiIconImageExpression(customIconSpriteId2, customIconMapping = {}) {
-  const matchParts = [];
-  for (const [className, iconName] of Object.entries(poiClassIconNames)) {
-    matchParts.push(
-      className,
-      poiIconImageFallback(iconName, customIconSpriteId2, customIconMapping)
-    );
-  }
+function roadClassWidthScaleExpression(widthScale) {
   return [
     "match",
     ["get", "class"],
-    ...matchParts,
-    poiIconImageFallback("default", customIconSpriteId2, customIconMapping)
+    ...Object.entries(widthScale).flatMap(([roadClass, scale]) => [roadClass, scale]),
+    1
   ];
 }
-function poiCategoryClasses(category) {
-  return poiCategoryClassNames[category] ?? [category];
+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 poiIconImageFallback(iconName, customIconSpriteId2, customIconMapping) {
-  const osmBrightIcon = `${osmBrightIconNameForSemanticIcon(iconName)}_11`;
-  const customIconName = customIconMapping[iconName] ?? iconName;
-  if (!customIconSpriteId2) {
-    return ["coalesce", ["image", customIconName], ["image", osmBrightIcon]];
-  }
+function roadClassColorExpression(colors) {
   return [
-    "coalesce",
-    ["image", `${customIconSpriteId2}:${customIconName}`],
-    ["image", osmBrightIcon]
+    "match",
+    ["get", "class"],
+    "motorway",
+    colors.roads.motorway,
+    "trunk",
+    colors.roads.trunk,
+    "primary",
+    colors.roads.primary,
+    "secondary",
+    colors.roads.secondary,
+    "rail",
+    colors.roads.rail,
+    "transit",
+    colors.roads.rail,
+    "ferry",
+    colors.roads.ferry,
+    "path",
+    colors.roads.path,
+    "track",
+    colors.roads.path,
+    colors.roads.minor
   ];
 }
-function osmBrightIconNameForSemanticIcon(iconName) {
-  return semanticToOsmBrightIconName[iconName] ?? "marker";
-}
-var poiCategoryClassNames = {
-  coffee: ["cafe"],
-  culture: ["museum", "gallery", "theatre", "cinema", "library", "attraction"],
-  education: ["school", "college", "university"],
-  food: ["restaurant", "fast_food", "bar", "pub", "biergarten"],
-  health: ["hospital", "pharmacy", "doctors", "dentist"],
-  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 semanticToOsmBrightIconName = {
-  coffee: "cafe",
-  culture: "museum",
-  default: "marker",
-  education: "school",
-  food: "restaurant",
-  health: "hospital",
-  lodging: "lodging",
-  services: "marker",
-  shopping: "shop",
-  transit: "railway"
-};
 
-// src/modules/roads/index.ts
-var moduleRoadDefaults = {
-  detail: "streets",
-  extras: { ferry: false, paths: false, rail: false },
-  hierarchy: "clear",
-  outline: "subtle",
-  weight: "regular"
+// src/modules/labels/index.ts
+var moduleLabelDefaults = {
+  language: "auto",
+  places: "major",
+  roads: "major",
+  water: "major"
 };
-var highwayRoadClasses2 = ["motorway", "trunk"];
-var arterialRoadClasses2 = ["primary", "secondary", "tertiary"];
-var majorRoadClasses2 = [...highwayRoadClasses2, ...arterialRoadClasses2];
-var streetRoadClasses2 = ["minor"];
-var serviceRoadClasses2 = ["service", "track"];
-function roads(options = {}) {
+var majorPlaceClasses = ["continent", "country", "state", "city", "town"];
+var majorWaterClasses = ["ocean", "sea", "lake"];
+var majorWaterwayClasses = ["river"];
+function labels(options = {}) {
   return {
-    type: "roads",
-    ...options.detail ? { detail: options.detail } : {},
-    ...options.extras ? { extras: { ...options.extras } } : {},
-    ...options.hierarchy ? { hierarchy: options.hierarchy } : {},
-    ...options.outline ? { outline: options.outline } : {},
-    ...options.weight ? { weight: options.weight } : {}
+    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 } : {}
   };
 }
-function resolveRoads(legacyRoads, moduleConfig, fallback) {
-  const fallbackMode = legacyRoads ?? fallback;
-  const defaults = moduleConfig ? moduleRoadDefaults : roadDefaultsFromLegacyMode(fallbackMode);
+function resolveLabels(legacyLabels, moduleConfig, fallback) {
+  const fallbackMode = legacyLabels ?? fallback;
+  const defaults = moduleConfig ? moduleLabelDefaults : labelDefaultsFromLegacyMode(fallbackMode);
   const resolved = {
-    detail: moduleConfig?.detail ?? defaults.detail,
-    extras: {
-      ferry: moduleConfig?.extras?.ferry ?? defaults.extras.ferry,
-      paths: moduleConfig?.extras?.paths ?? defaults.extras.paths,
-      rail: moduleConfig?.extras?.rail ?? defaults.extras.rail
-    },
-    hierarchy: moduleConfig?.hierarchy ?? defaults.hierarchy,
-    outline: moduleConfig?.outline ?? defaults.outline,
-    weight: moduleConfig?.weight ?? defaults.weight
+    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
   };
   return {
     ...resolved,
-    mode: legacyModeFromResolvedRoads(resolved)
-  };
-}
-function roadStyleMetrics(options) {
-  const hierarchy = {
-    subtle: {
-      majorOpacity: 0.92,
-      majorWidthScale: 1,
-      minorOpacity: 0.82,
-      minorWidthScale: 0.94
-    },
-    clear: {
-      majorOpacity: 0.92,
-      majorWidthScale: 1,
-      minorOpacity: 0.68,
-      minorWidthScale: 0.84
-    },
-    strong: {
-      majorOpacity: 0.92,
-      majorWidthScale: 1,
-      minorOpacity: 0.52,
-      minorWidthScale: 0.7
-    }
-  }[options.hierarchy];
-  const weightScale = {
-    thin: 0.78,
-    regular: 1,
-    bold: 1.24
-  }[options.weight];
-  const outlineOpacity = {
-    none: 0,
-    subtle: 0.18,
-    strong: 0.34
-  }[options.outline];
-  return {
-    ...hierarchy,
-    outlineOpacity,
-    weightScale
+    mode: moduleConfig ? legacyModeFromResolvedLabels(resolved) : fallbackMode
   };
 }
-function roadLayers(source, sourceLayer, colors, options) {
-  if (options.detail === "none") {
-    return [];
-  }
-  const metrics = roadStyleMetrics(options);
-  const selectedMajorRoadClasses = options.detail === "highways" ? [...highwayRoadClasses2] : [...majorRoadClasses2];
-  const showsStreetRoads = options.detail === "streets" || options.detail === "all";
-  const showsServiceRoads = options.detail === "all";
-  const roadClasses = [
-    ...selectedMajorRoadClasses,
-    ...showsStreetRoads ? streetRoadClasses2 : [],
-    ...showsServiceRoads ? serviceRoadClasses2 : []
-  ];
-  const transportClasses = [
-    ...roadClasses,
-    ...options.extras.paths ? ["path"] : [],
-    ...options.extras.rail ? ["rail", "transit"] : [],
-    ...options.extras.ferry ? ["ferry"] : []
-  ];
-  const roadClassColor = roadClassColorExpression(colors);
-  const nonTunnelRoadFilter = ["!=", ["get", "brunnel"], "tunnel"];
-  const majorFilter = classFilter2(selectedMajorRoadClasses);
-  const streetFilter = classFilter2(streetRoadClasses2);
-  const serviceFilter = classFilter2(serviceRoadClasses2);
-  const roadFilter = classFilter2(roadClasses);
-  const transportFilter = classFilter2(transportClasses);
-  const layers = [];
-  if (options.outline !== "none") {
-    layers.push({
-      id: "roads-tunnels-casing",
-      type: "line",
-      source,
-      "source-layer": sourceLayer,
-      minzoom: 10,
-      filter: ["all", ["==", ["get", "brunnel"], "tunnel"], transportFilter],
-      paint: {
-        "line-color": colors.roads.tunnel,
-        "line-dasharray": [0.6, 0.8],
-        "line-opacity": roadOpacityExpression(
-          metrics.outlineOpacity * 0.85,
-          metrics.outlineOpacity * 0.85
-        ),
-        "line-width": roadWidthExpression(
-          [
-            [10, 0.8],
-            [14, 2.2],
-            [16, 4.8]
-          ],
-          metrics
-        )
-      }
-    });
-  }
-  layers.push({
-    id: "roads-tunnels",
-    type: "line",
-    source,
-    "source-layer": sourceLayer,
-    minzoom: 10,
-    filter: ["all", ["==", ["get", "brunnel"], "tunnel"], transportFilter],
-    paint: {
-      "line-color": roadClassColor,
-      "line-dasharray": [0.6, 0.8],
-      "line-opacity": roadOpacityExpression(
-        metrics.majorOpacity * 0.28,
-        metrics.minorOpacity * 0.28
-      ),
-      "line-width": roadWidthExpression(
-        [
-          [10, 0.25],
-          [14, 1],
-          [16, 2.4]
-        ],
-        metrics
-      )
-    }
-  });
-  if (options.outline !== "none") {
-    layers.push({
-      id: "roads-casing",
-      type: "line",
+function labelLayers(source, sourceLayers, colors, labelsConfig, roadsConfig, typography) {
+  return [
+    ...placeLabelLayers(source, sourceLayers.place, colors, labelsConfig, typography),
+    ...roadLabelLayers(
       source,
-      "source-layer": sourceLayer,
-      minzoom: 5,
-      filter: ["all", nonTunnelRoadFilter, roadFilter],
-      paint: {
-        "line-color": colors.roads.casing,
-        "line-opacity": roadOpacityExpression(metrics.outlineOpacity, metrics.outlineOpacity),
-        "line-width": roadWidthExpression(
-          [
-            [6, 0.7],
-            [12, 1.8],
-            [16, 5.4]
-          ],
-          metrics
-        )
-      }
-    });
-  }
-  if (options.extras.ferry) {
-    layers.push({
-      id: "roads-ferry",
-      type: "line",
+      sourceLayers.roadName,
+      colors,
+      labelsConfig,
+      roadsConfig,
+      typography
+    ),
+    ...waterLabelLayers(
       source,
-      "source-layer": sourceLayer,
-      minzoom: 5,
-      filter: ["all", nonTunnelRoadFilter, classFilter2(["ferry"])],
-      paint: {
-        "line-color": colors.roads.ferry,
-        "line-dasharray": [1.2, 1.1],
-        "line-opacity": metrics.majorOpacity * 0.8,
-        "line-width": zoomWidth(
-          [
-            [5, 0.25],
-            [12, 0.8],
-            [16, 2.6]
-          ],
-          metrics.weightScale
-        )
-      }
-    });
-  }
-  if (options.extras.paths) {
-    layers.push({
-      id: "roads-paths",
-      type: "line",
+      sourceLayers.waterName,
+      sourceLayers.waterway,
+      colors,
+      labelsConfig,
+      typography
+    )
+  ];
+}
+function placeLabelLayers(source, sourceLayer, colors, labelsConfig, typography) {
+  if (labelsConfig.places === "none") return [];
+  return [
+    {
+      id: "place-labels",
+      type: "symbol",
       source,
       "source-layer": sourceLayer,
-      minzoom: 10,
-      filter: ["all", nonTunnelRoadFilter, classFilter2(["path"])],
+      minzoom: 0,
+      filter: labelsConfig.places === "major" ? ["all", ["has", "name"], classFilter2(majorPlaceClasses)] : ["has", "name"],
+      layout: {
+        "text-field": labelTextField(labelsConfig.language),
+        "text-font": textFont(typography, "places"),
+        "text-size": ["interpolate", ["linear"], ["zoom"], 3, 10, 8, 13, 14, 17],
+        "text-letter-spacing": 0,
+        "text-padding": 4
+      },
       paint: {
-        "line-color": colors.roads.path,
-        "line-dasharray": [0.7, 0.7],
-        "line-opacity": metrics.minorOpacity * 0.77,
-        "line-width": zoomWidth(
-          [
-            [10, 0.25],
-            [14, 0.8],
-            [16, 2.2]
-          ],
-          metrics.weightScale * metrics.minorWidthScale
-        )
+        "text-color": colors.labels.primary,
+        "text-halo-color": colors.labels.halo,
+        "text-halo-width": 1.2
       }
-    });
-  }
-  if (options.extras.rail) {
+    }
+  ];
+}
+function roadLabelLayers(source, sourceLayer, colors, labelsConfig, roadsConfig, typography) {
+  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 [];
+  const layers = [];
+  const sharedLayout = {
+    "symbol-placement": "line",
+    "text-field": labelTextField(labelsConfig.language),
+    "text-font": textFont(typography, "roads"),
+    "text-rotation-alignment": "map",
+    "text-size": ["interpolate", ["linear"], ["zoom"], 11, 11, 14, 13, 17, 15]
+  };
+  const sharedPaint = {
+    "text-color": colors.labels.road,
+    "text-halo-color": colors.labels.halo,
+    "text-halo-width": 1
+  };
+  if (majorClasses.length > 0) {
+    const namedMajorClasses = majorClasses.filter((roadClass) => roadClass !== "motorway");
     layers.push({
-      id: "roads-rail",
-      type: "line",
+      id: "road-shields",
+      type: "symbol",
       source,
       "source-layer": sourceLayer,
-      minzoom: 7,
-      filter: ["all", nonTunnelRoadFilter, classFilter2(["rail", "transit"])],
-      paint: {
-        "line-color": colors.roads.rail,
-        "line-opacity": metrics.minorOpacity * 0.65,
-        "line-width": zoomWidth(
-          [
-            [7, 0.35],
-            [12, 0.9],
-            [16, 2.4]
-          ],
-          metrics.weightScale * metrics.minorWidthScale
-        )
-      }
+      minzoom: 8,
+      filter: ["all", ["has", "ref"], classFilter2(majorClasses)],
+      layout: {
+        "symbol-placement": "line",
+        "symbol-spacing": 240,
+        "text-field": ["get", "ref"],
+        "text-font": textFont(typography, "roads"),
+        "text-rotation-alignment": "viewport",
+        "text-size": 10
+      },
+      paint: sharedPaint
     });
+    if (namedMajorClasses.length > 0) {
+      layers.unshift({
+        id: "road-labels-major",
+        type: "symbol",
+        source,
+        "source-layer": sourceLayer,
+        minzoom: 10,
+        filter: ["all", ["has", "name"], classFilter2(namedMajorClasses)],
+        layout: sharedLayout,
+        paint: sharedPaint
+      });
+    }
   }
-  if (showsServiceRoads) {
+  if (minorClasses.length > 0) {
     layers.push({
-      id: "roads-service",
-      type: "line",
+      id: "road-labels-minor",
+      type: "symbol",
       source,
       "source-layer": sourceLayer,
       minzoom: 14,
-      filter: ["all", nonTunnelRoadFilter, serviceFilter],
-      paint: {
-        "line-color": roadClassColor,
-        "line-opacity": metrics.minorOpacity,
-        "line-width": zoomWidth(
-          [
-            [14, 0.6],
-            [16, 2.2]
-          ],
-          metrics.weightScale * metrics.minorWidthScale
-        )
-      }
-    });
-  }
-  if (showsStreetRoads) {
-    layers.push({
-      id: "roads-minor",
-      type: "line",
-      source,
-      "source-layer": sourceLayer,
-      minzoom: 12,
-      filter: ["all", nonTunnelRoadFilter, streetFilter],
-      paint: {
-        "line-color": roadClassColor,
-        "line-opacity": metrics.minorOpacity,
-        "line-width": zoomWidth(
-          [
-            [12, 0.8],
-            [16, 3]
-          ],
-          metrics.weightScale * metrics.minorWidthScale
-        )
-      }
+      filter: ["all", ["has", "name"], classFilter2(minorClasses)],
+      layout: sharedLayout,
+      paint: sharedPaint
     });
   }
-  layers.push(
+  return layers;
+}
+function waterLabelLayers(source, waterNameSourceLayer, waterwaySourceLayer, colors, labelsConfig, typography) {
+  if (labelsConfig.water === "none") return [];
+  const waterFilter = labelsConfig.water === "major" ? ["all", ["has", "name"], classFilter2(majorWaterClasses)] : ["has", "name"];
+  const waterwayFilter = labelsConfig.water === "major" ? ["all", ["has", "name"], classFilter2(majorWaterwayClasses)] : ["has", "name"];
+  const paint = {
+    "text-color": colors.labels.water,
+    "text-halo-color": colors.labels.halo,
+    "text-halo-width": 1
+  };
+  return [
     {
-      id: "roads-major",
-      type: "line",
+      id: "water-labels",
+      type: "symbol",
       source,
-      "source-layer": sourceLayer,
-      minzoom: 5,
-      filter: ["all", nonTunnelRoadFilter, majorFilter],
-      paint: {
-        "line-color": roadClassColor,
-        "line-opacity": metrics.majorOpacity,
-        "line-width": zoomWidth(
-          [
-            [5, 0.35],
-            [12, 1.2],
-            [16, 4]
-          ],
-          metrics.weightScale * metrics.majorWidthScale
-        )
-      }
+      "source-layer": waterNameSourceLayer,
+      minzoom: 3,
+      filter: ["all", ["==", ["geometry-type"], "Point"], waterFilter],
+      layout: {
+        "text-field": labelTextField(labelsConfig.language),
+        "text-font": textFont(typography, "water"),
+        "text-size": ["interpolate", ["linear"], ["zoom"], 3, 11, 8, 14]
+      },
+      paint
     },
     {
-      id: "roads-bridges",
-      type: "line",
+      id: "water-line-labels",
+      type: "symbol",
       source,
-      "source-layer": sourceLayer,
+      "source-layer": waterNameSourceLayer,
+      minzoom: 5,
+      filter: ["all", ["==", ["geometry-type"], "LineString"], waterFilter],
+      layout: {
+        "symbol-placement": "line",
+        "text-field": labelTextField(labelsConfig.language),
+        "text-font": textFont(typography, "water"),
+        "text-size": 13
+      },
+      paint
+    },
+    {
+      id: "waterway-labels",
+      type: "symbol",
+      source,
+      "source-layer": waterwaySourceLayer,
       minzoom: 10,
-      filter: ["all", ["==", ["get", "brunnel"], "bridge"], transportFilter],
-      paint: {
-        "line-color": colors.roads.bridge,
-        "line-opacity": roadOpacityExpression(metrics.majorOpacity, metrics.minorOpacity),
-        "line-width": roadWidthExpression(
-          [
-            [10, 0.45],
-            [14, 1.6],
-            [16, 4.4]
-          ],
-          metrics
-        )
-      }
+      filter: ["all", ["==", ["geometry-type"], "LineString"], waterwayFilter],
+      layout: {
+        "symbol-placement": "line",
+        "symbol-spacing": 320,
+        "text-field": labelTextField(labelsConfig.language),
+        "text-font": textFont(typography, "water"),
+        "text-size": 12
+      },
+      paint
     }
+  ];
+}
+function visibleRoadLabelClasses(detail, roadsConfig, eligibleClasses) {
+  if (detail === "none" || roadsConfig.detail === "none") return [];
+  const visibleRoadClasses = [
+    ...roadClassesForDetail(roadsConfig.detail),
+    ...roadsConfig.extras.paths ? ["path"] : []
+  ];
+  const requestedClasses = roadLabelClasses(detail);
+  const visible = new Set(visibleRoadClasses);
+  const eligible = eligibleClasses ? new Set(eligibleClasses) : void 0;
+  return requestedClasses.filter(
+    (roadClass) => visible.has(roadClass) && (!eligible || eligible.has(roadClass))
   );
-  return layers;
 }
-function roadDefaultsFromLegacyMode(mode) {
-  if (mode === "hidden") {
-    return {
-      detail: "none",
-      extras: { ferry: false, paths: false, rail: false },
-      hierarchy: "clear",
-      outline: "subtle",
-      weight: "regular"
-    };
+function roadLabelClasses(detail) {
+  return [...roadClassesForDetail(detail), ...detail === "all" ? ["path"] : []];
+}
+function labelDefaultsFromLegacyMode(mode) {
+  if (mode === "none") {
+    return { language: "auto", places: "none", roads: "none", water: "none" };
   }
-  if (mode === "soft") {
-    return {
-      detail: "streets",
-      extras: { ferry: false, paths: false, rail: false },
-      hierarchy: "subtle",
-      outline: "subtle",
-      weight: "thin"
-    };
+  if (mode === "essential") {
+    return { language: "auto", places: "major", roads: "major", water: "major" };
   }
-  if (mode === "detailed") {
-    return {
-      detail: "all",
-      extras: { ferry: true, paths: true, rail: true },
-      hierarchy: "clear",
-      outline: "strong",
-      weight: "regular"
-    };
+  return { language: "auto", places: "all", roads: "all", water: "all" };
+}
+function legacyModeFromResolvedLabels(options) {
+  if (options.places === "none" && options.roads === "none" && options.water === "none") {
+    return "none";
+  }
+  if (options.places === "major" && options.roads === "major" && options.water === "major") {
+    return "essential";
+  }
+  return "balanced";
+}
+function classFilter2(classes) {
+  return ["match", ["get", "class"], classes, true, false];
+}
+function labelTextField(language) {
+  if (language === "local") {
+    return ["coalesce", ["get", "name"], ["get", "name:latin"], ["get", "name:en"]];
+  }
+  if (language === "auto") {
+    return ["coalesce", ["get", "name:latin"], ["get", "name"], ["get", "name:en"]];
   }
+  return ["coalesce", ["get", `name:${language}`], ["get", "name:latin"], ["get", "name"]];
+}
+
+// src/modules/poi/index.ts
+var defaultPoiMinZoom = {
+  none: 24,
+  minimal: 15,
+  balanced: 13,
+  full: 11
+};
+function poi(options = {}) {
   return {
-    detail: "streets",
-    extras: { ferry: true, paths: true, rail: true },
-    hierarchy: "clear",
-    outline: "subtle",
-    weight: "regular"
+    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 legacyModeFromResolvedRoads(options) {
-  if (options.detail === "none") return "hidden";
-  if (options.hierarchy === "subtle") return "soft";
-  if (options.hierarchy === "strong" || options.detail === "all") return "detailed";
-  return "standard";
+function resolvePoi(legacyPoi, moduleConfig, fallback) {
+  const mode = moduleConfig?.preset ?? legacyPoi ?? fallback;
+  const density = moduleConfig?.density;
+  return {
+    ...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] + (density === void 0 ? 0 : poiDensityZoomOffset(density)),
+    mode,
+    placement: {
+      coupleIconAndLabel: moduleConfig?.placement?.coupleIconAndLabel ?? false,
+      iconPadding: moduleConfig?.placement?.iconPadding ?? 2,
+      textPadding: moduleConfig?.placement?.textPadding ?? 2
+    }
+  };
 }
-function classFilter2(classes) {
-  return ["match", ["get", "class"], classes, true, false];
+function poiLayers(source, sourceLayer, colors, poiConfig, typography, customIconSpriteId2, customIconMapping) {
+  if (poiConfig.mode === "none") {
+    return [];
+  }
+  const layout = {
+    "text-field": labelTextField("auto"),
+    "text-font": textFont(typography, "poi"),
+    "text-size": ["interpolate", ["linear"], ["zoom"], poiConfig.minZoom, 10, 17, 12],
+    "text-letter-spacing": 0,
+    "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,
+      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 [
+    {
+      id: "poi-labels",
+      type: "symbol",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: poiConfig.minZoom,
+      ...poiFilter(poiConfig) ? { filter: poiFilter(poiConfig) } : {},
+      layout,
+      paint: {
+        "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
+      }
+    }
+  ];
 }
-function roadOpacityExpression(majorOpacity, minorOpacity) {
+function poiLabelsFromMode(mode) {
+  if (mode === "none") return "none";
+  if (mode === "minimal") return "minimal";
+  if (mode === "full") return "full";
+  return "balanced";
+}
+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 = {}, classMapping = poiCategoryClassNames) {
+  const matchParts = Object.keys(classMapping).flatMap((category) => [
+    category,
+    poiIconImageFallback(category, customIconSpriteId2, customIconMapping)
+  ]);
   return [
-    "case",
-    classFilter2(majorRoadClasses2),
-    majorOpacity,
-    classFilter2(streetRoadClasses2),
-    ["step", ["zoom"], 0, 12, minorOpacity],
-    classFilter2(serviceRoadClasses2),
-    ["step", ["zoom"], 0, 14, minorOpacity],
-    minorOpacity
+    "match",
+    poiCategoryExpression("default", classMapping),
+    ...matchParts,
+    poiIconImageFallback("default", customIconSpriteId2, customIconMapping)
   ];
 }
-function roadWidthExpression(stops, metrics) {
+function poiCategoryExpression(fallback = "", classMapping = poiCategoryClassNames) {
+  const categoryMatches = poiCategoryMatchParts(classMapping);
   return [
-    "case",
-    classFilter2(majorRoadClasses2),
-    zoomWidth(stops, metrics.weightScale * metrics.majorWidthScale),
-    zoomWidth(stops, metrics.weightScale * metrics.minorWidthScale)
+    "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 zoomWidth(stops, scale) {
+function poiDensityFilter(density, classMapping = poiCategoryClassNames) {
+  if (density === "dense") return void 0;
+  const cutoffs = poiDensityRankCutoffs[density];
   return [
-    "interpolate",
-    ["linear"],
-    ["zoom"],
-    ...stops.flatMap(([zoom, width]) => [zoom, width * scale])
+    "any",
+    ...Object.keys(classMapping).map((category) => [
+      "all",
+      poiCategoryFilter([category], classMapping),
+      ["any", ["!has", "rank"], ["<=", "rank", cutoffs[category] ?? cutoffs.default]]
+    ])
   ];
 }
-function roadClassColorExpression(colors) {
+function poiCategoryColorExpression(colors, classMapping = poiCategoryClassNames) {
   return [
     "match",
-    ["get", "class"],
-    "motorway",
-    colors.roads.motorway,
-    "trunk",
-    colors.roads.trunk,
-    "primary",
-    colors.roads.primary,
-    "secondary",
-    colors.roads.secondary,
-    "rail",
-    colors.roads.rail,
-    "transit",
-    colors.roads.rail,
-    "ferry",
-    colors.roads.ferry,
-    "path",
-    colors.roads.path,
-    "track",
-    colors.roads.path,
-    colors.roads.minor
+    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`;
+  const customIconName = customIconMapping[iconName] ?? iconName;
+  if (!customIconSpriteId2) {
+    return ["coalesce", ["image", customIconName], ["image", osmBrightIcon]];
+  }
+  return [
+    "coalesce",
+    ["image", `${customIconSpriteId2}:${customIconName}`],
+    ["image", osmBrightIcon]
   ];
 }
+function osmBrightIconNameForSemanticIcon(iconName) {
+  return semanticToOsmBrightIconName[iconName] ?? "marker";
+}
+var poiCategoryClassNames = {
+  coffee: ["cafe"],
+  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: ["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 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",
+  culture: "museum",
+  default: "marker",
+  education: "school",
+  food: "restaurant",
+  health: "hospital",
+  lodging: "lodging",
+  services: "marker",
+  shopping: "shop",
+  transit: "railway"
+};
 
 // src/basemaps/osm/layers.ts
 function openMapTilesLayers(source, sourceLayers, colors, options) {
@@ -1375,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,
@@ -1384,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(
@@ -1399,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,
@@ -1411,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 [];
   }
@@ -1478,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)
       }
     },
     {
@@ -1489,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 [
     {
@@ -1545,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;
@@ -1577,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(),
@@ -1616,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",
@@ -1665,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",
@@ -1716,169 +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 roadsModuleSchema = z.object({
-  type: z.literal("roads"),
-  detail: z.enum(["none", "highways", "major", "streets", "all"]).optional(),
-  extras: z.object({
-    ferry: z.boolean().optional(),
-    paths: z.boolean().optional(),
-    rail: z.boolean().optional()
+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: 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(),
-  roads: 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 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 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 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 = 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 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()
-}).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()
+  allowedOrigins: z2.array(z2.string().trim().min(1).max(253)).max(20).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);
@@ -1935,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) {
@@ -2015,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),
@@ -2037,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`,
@@ -2051,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]);
@@ -2136,6 +2760,7 @@ function applyOsmBrightControls(layers, options) {
       return applyPoiLayerControls(
         layer,
         options.poi,
+        options.colors,
         options.customIconSpriteId,
         options.customIconMapping
       );
@@ -2162,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") {
@@ -2183,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;
@@ -2241,10 +2883,10 @@ function applyLabelLayerControls(layer, labels2, roads2) {
   if ("text-field" in layout && !isHighwayShieldLayer(id)) {
     layout["text-field"] = labelTextField(labels2.language);
   }
-  if (group === "roads" && roads2) {
-    const allowedClasses = visibleRoadLabelClasses(detail, roads2).filter(
-      (roadClass) => roadLabelLayerClasses(id).includes(roadClass)
-    );
+  if (group === "roads") {
+    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");
     }
@@ -2260,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"];
@@ -2278,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) {
@@ -4907,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) => {
@@ -4948,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;
       }
     }
@@ -4962,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;
@@ -5181,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,
@@ -5220,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));
 }
@@ -5234,7 +5919,9 @@ function remapOsmBrightSource(layer, sourceId) {
 }
 
 // src/compiler.ts
+var tileflowHostedNotoSansWeights = ["regular", "bold"];
 var defaultSourceLayers = {
+  landcover: "landcover",
   landuse: "landuse",
   park: "park",
   water: "water",
@@ -5300,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,
@@ -5307,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";
@@ -5322,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);
@@ -5338,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({
@@ -5378,6 +6085,7 @@ function createStyle(input = {}, options = {}) {
       theme,
       tilesUrl,
       typography,
+      typographyOverridden: Boolean(config.typography) || theme.typographyOverridden,
       labelsModule: resolvedLabels,
       poi: poi2,
       poiModule: resolvedPoi,
@@ -5400,6 +6108,7 @@ function createStyle(input = {}, options = {}) {
   );
   const layers = openMapTilesLayers(sourceId, sourceLayers, colors, {
     buildings,
+    buildingStyle: config.buildingStyle,
     density,
     labels: resolvedLabels,
     poi: resolvedPoi,
@@ -5437,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}`);
   }
@@ -5456,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 } : {}
       }
     },
@@ -5499,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;
 }
@@ -5517,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));
 }
@@ -5529,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;
@@ -5571,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";
@@ -5855,6 +7032,7 @@ function getTileflowLocationOrigin() {
   return window.location.origin;
 }
 export {
+  compareCodeUnits,
   configSchema,
   createManifest,
   createStyle,
@@ -5863,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,
@@ -5878,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