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

package/dist/index.js

@@ -64,6 +64,7 @@ var init_manifest_schema_classic = __esm({
         return z2.enum(values);
       },
       literal: (value) => z2.literal(value),
+      union: (left, right) => z2.union([classic(left), classic(right)]),
       tuplePair(left, right) {
         return z2.tuple([classic(left), classic(right)]);
       },
@@ -296,26 +297,26 @@ function toMapLibreStyleValue(value) {
   return cloneJson2(value);
 }
 function isTileflowExpression(value) {
-  return isRecord(value) && value.kind === "expression" && Array.isArray(value.value);
+  return isRecord2(value) && value.kind === "expression" && Array.isArray(value.value);
 }
 function isTileflowZoomValue(value) {
-  return isRecord(value) && value.kind === "zoom" && Array.isArray(value.stops);
+  return isRecord2(value) && value.kind === "zoom" && Array.isArray(value.stops);
 }
 function isTileflowThemeTokenReference(value) {
-  return isRecord(value) && hasExactOwnKeys(value, ["category", "kind", "token"]) && value.kind === "theme-token" && typeof value.token === "string" && /^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)*$/.test(value.token) && tileflowThemeTokenCategories.includes(value.category);
+  return isRecord2(value) && hasExactOwnKeys(value, ["category", "kind", "token"]) && value.kind === "theme-token" && typeof value.token === "string" && /^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)*$/.test(value.token) && tileflowThemeTokenCategories.includes(value.category);
 }
 function isTileflowFixedValue(value) {
-  return isRecord(value) && hasExactOwnKeys(value, ["kind", "reason", "value"]) && value.kind === "theme-fixed" && typeof value.reason === "string" && Boolean(value.reason.trim()) && Object.hasOwn(value, "value");
+  return isRecord2(value) && hasExactOwnKeys(value, ["kind", "reason", "value"]) && value.kind === "theme-fixed" && typeof value.reason === "string" && Boolean(value.reason.trim()) && Object.hasOwn(value, "value");
 }
 function isTileflowThemeColorOperation(value) {
-  if (!isRecord(value) || value.kind !== "theme-color") return false;
+  if (!isRecord2(value) || value.kind !== "theme-color") return false;
   if (value.operation === "alpha") {
     return hasExactOwnKeys(value, ["color", "kind", "opacity", "operation"]) && Object.hasOwn(value, "color") && Object.hasOwn(value, "opacity");
   }
   return value.operation === "mix" && hasExactOwnKeys(value, ["amount", "from", "kind", "operation", "space", "to"]) && value.space === "oklch" && Object.hasOwn(value, "amount") && Object.hasOwn(value, "from") && Object.hasOwn(value, "to");
 }
 function isTileflowThemeValueNode(value) {
-  return isRecord(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
+  return isRecord2(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
 }
 function createZoomValue(interpolation, stops, base) {
   if (stops.length === 0) {
@@ -368,7 +369,7 @@ function cloneJson2(value) {
   }
   return JSON.parse(serialized);
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function hasExactOwnKeys(value, expectedKeys) {
@@ -440,6 +441,63 @@ var init_values = __esm({
   }
 });
 
+// src/time-of-day.ts
+function isTileflowTimeOfDay(value) {
+  return typeof value === "string" && tileflowTimesOfDay.includes(value);
+}
+function validateTileflowTimeOfDayVariants(variants, themes) {
+  const issues = [];
+  const owners = /* @__PURE__ */ new Map();
+  const families = Object.entries(variants);
+  for (const [family, moments] of families) {
+    if (!isTileflowThemeName(family) || !Object.hasOwn(themes, family)) {
+      issues.push({ path: [family], message: "Time-of-day family must name an existing theme" });
+    }
+    if (!Object.values(moments).includes(family)) {
+      issues.push({ path: [family], message: "A family must include its own theme in its presets" });
+    }
+    for (const [moment, name] of Object.entries(moments)) {
+      if (name === void 0) continue;
+      if (!isTileflowTimeOfDay(moment) || !isTileflowThemeName(name) || !Object.hasOwn(themes, name)) {
+        issues.push({
+          path: [family, moment],
+          message: "Expected a supported moment and an existing theme"
+        });
+      }
+      const owner = owners.get(name);
+      if (owner !== void 0 && owner !== family) {
+        issues.push({
+          path: [family, moment],
+          message: `Theme "${name}" already belongs to family "${owner}"`
+        });
+      }
+      owners.set(name, family);
+    }
+  }
+  return issues;
+}
+function resolveTileflowTimeOfDayTheme(variants, theme, timeOfDay) {
+  if (timeOfDay === void 0 || variants === void 0) return theme;
+  if (!isTileflowTimeOfDay(timeOfDay)) throw new TypeError("Expected day, dawn, dusk, or night");
+  const family = Object.hasOwn(variants, theme) ? variants[theme] : Object.values(variants).find((moments) => Object.values(moments).includes(theme));
+  if (!family) return theme;
+  const result = family[timeOfDay];
+  if (result === void 0) {
+    throw new Error(
+      `Theme "${theme}" does not offer timeOfDay="${timeOfDay}". Available: ${Object.keys(family).join(", ")}.`
+    );
+  }
+  return result;
+}
+var tileflowTimesOfDay;
+var init_time_of_day = __esm({
+  "src/time-of-day.ts"() {
+    "use strict";
+    init_portable_identity_rules();
+    tileflowTimesOfDay = ["day", "dawn", "dusk", "night"];
+  }
+});
+
 // src/theme-blend.ts
 function mixTileflowColours(from, to, t) {
   const a = oklab(from);
@@ -662,9 +720,9 @@ function tileflowSunMetadata(preset) {
   return Object.freeze({ version: 1, ...preset });
 }
 function readTileflowSunPreset(metadata) {
-  if (!isRecord6(metadata)) return void 0;
+  if (!isRecord5(metadata)) return void 0;
   const value = metadata[tileflowSunMetadataKey];
-  if (!isRecord6(value) || value.version !== 1 || !isRecord6(value.ambient)) return void 0;
+  if (!isRecord5(value) || value.version !== 1 || !isRecord5(value.ambient)) return void 0;
   const { azimuth, altitude, color: color3, intensity, shadowIntensity } = value;
   const ambient = value.ambient;
   if (!isFiniteNumber(azimuth) || !isFiniteNumber(altitude) || !isUnit(intensity) || !isUnit(shadowIntensity) || !isUnit(ambient.intensity) || !isColour(color3) || !isColour(ambient.color))
@@ -681,7 +739,7 @@ function readTileflowSunPreset(metadata) {
 function tileflowStyleSunPreset(style) {
   const published = readTileflowSunPreset(style?.metadata);
   if (published) return published;
-  const light = isRecord6(style?.light) ? style.light : void 0;
+  const light = isRecord5(style?.light) ? style.light : void 0;
   const position = light?.position;
   if (!position) return tileflowDefaultSunPreset;
   return Object.freeze({
@@ -719,7 +777,7 @@ function smoothstep2(from, to, value) {
 function clamp01(value) {
   return Math.min(1, Math.max(0, Number.isFinite(value) ? value : 0));
 }
-function isRecord6(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isFiniteNumber(value) {
@@ -933,7 +991,7 @@ function resolveThemeValues(value, theme, path = "value") {
   if (errors.length > 0) throw new TileflowThemeAuditError(errors);
   return resolved;
 }
-function resolveThemeSelection(map, requested) {
+function resolveThemeSelection(map, requested, timeOfDay) {
   const name = requested ?? map.defaultTheme;
   if (name === "system") {
     throw new Error(
@@ -950,7 +1008,8 @@ function resolveThemeSelection(map, requested) {
     const available = Object.keys(map.themes).sort().join(", ") || "<none>";
     throw new Error(`Unknown Tileflow theme "${name}"; available themes: ${available}.`);
   }
-  return { name, theme };
+  const resolvedName = resolveTileflowTimeOfDayTheme(map.timeOfDay, name, timeOfDay);
+  return { name: resolvedName, theme: map.themes[resolvedName] };
 }
 function auditTileflowThemeValues(value, path = "value", context = inferAuditContext(path)) {
   const diagnostics = [];
@@ -963,7 +1022,7 @@ function auditTileflowThemeValues(value, path = "value", context = inferAuditCon
   return diagnostics.sort(compareAuditDiagnostics);
 }
 function auditTileflowMapThemeValues(map) {
-  const modules = isRecord7(map.modules) ? map.modules : void 0;
+  const modules = isRecord6(map.modules) ? map.modules : void 0;
   const moduleDiagnostics = modules ? Object.keys(modules).sort(compareCodeUnits2).flatMap(
     (owner) => auditTileflowThemeValues(modules[owner], `modules.${owner}`, {
       owner,
@@ -1070,7 +1129,7 @@ function isThemePrimitiveForCategory(value, category) {
   return category === "number" ? typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every((entry) => typeof entry === "number" && Number.isFinite(entry)) : typeof value === "string" && value.length > 0;
 }
 function isThemeValueCandidate(value) {
-  return isRecord7(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
+  return isRecord6(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
 }
 function visitAuditableValue(value, path, category, state, intentRequired = false) {
   if (isThemeStructuralPath(path)) category = void 0;
@@ -1086,7 +1145,7 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     visitAuditableArray(value, path, category, state, false, intentRequired);
     return;
   }
-  if (!isRecord7(value)) return;
+  if (!isRecord6(value)) return;
   if (value.kind === "expression" && Array.isArray(value.value)) {
     visitAuditableArray(value.value, `${path}.value`, category, state, true, intentRequired);
     return;
@@ -1469,7 +1528,7 @@ function assertThemeLighting(value, path) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord7(value)) {
+  if (!isRecord6(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -1830,11 +1889,11 @@ function cloneJson14(value) {
   if (serialized === void 0) throw new Error("Tileflow themes must be JSON-serializable.");
   return JSON.parse(serialized);
 }
-function isRecord7(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord(value) {
-  if (!isRecord7(value)) return false;
+  if (!isRecord6(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -1845,6 +1904,7 @@ var tileflowThemeLimits, TileflowThemeAuditError, defaultTypography, themeDocume
 var init_model = __esm({
   "src/themes/model.ts"() {
     "use strict";
+    init_time_of_day();
     init_expression_operators();
     init_values();
     init_portable_identity_rules();
@@ -1947,7 +2007,7 @@ var init_model = __esm({
         if (Array.isArray(value)) {
           return value.map((entry, index) => this.resolveTree(entry, `${path}[${index}]`, category));
         }
-        if (!isRecord7(value)) return value;
+        if (!isRecord6(value)) return value;
         if (value.kind === "expression" && Array.isArray(value.value)) {
           return {
             ...value,
@@ -2170,12 +2230,31 @@ var init_model = __esm({
   }
 });
 
+// src/time-of-day-schema.ts
+function createTileflowTimeOfDaySchema(operations2, themeName) {
+  return operations2.record(
+    themeName,
+    operations2.object({
+      day: operations2.optional(themeName),
+      dawn: operations2.optional(themeName),
+      dusk: operations2.optional(themeName),
+      night: operations2.optional(themeName)
+    })
+  );
+}
+var init_time_of_day_schema = __esm({
+  "src/time-of-day-schema.ts"() {
+    "use strict";
+  }
+});
+
 // src/manifest-types.ts
-var tileflowRuntimeManifestVersion, tileflowRuntimeManifestLimits;
+var tileflowRuntimeManifestVersion, tileflowTimeOfDayManifestVersion, tileflowRuntimeManifestLimits;
 var init_manifest_types = __esm({
   "src/manifest-types.ts"() {
     "use strict";
     tileflowRuntimeManifestVersion = 1;
+    tileflowTimeOfDayManifestVersion = 2;
     tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
   }
 });
@@ -2252,12 +2331,24 @@ function createTileflowRuntimeManifestSchema(primitives, operations2, identities
         })
       ),
       themes: operations2.record(tileflowThemeNameSchema2, manifestThemeSchema),
+      timeOfDay: operations2.optional(
+        createTileflowTimeOfDaySchema(operations2, tileflowThemeNameSchema2)
+      ),
       usageMode: operations2.optional(operations2.literal("session")),
       view: operations2.optional(viewSchema2),
       worldGeneration: operations2.optional(operations2.literal("v1"))
     }),
     (entry, context) => {
       const names = Object.keys(entry.themes);
+      if (entry.timeOfDay) {
+        for (const issue of validateTileflowTimeOfDayVariants(entry.timeOfDay, entry.themes)) {
+          context.addIssue({
+            code: "custom",
+            message: issue.message,
+            path: ["timeOfDay", ...issue.path]
+          });
+        }
+      }
       if (names.length === 0) {
         context.addIssue({
           code: "custom",
@@ -2311,10 +2402,23 @@ function createTileflowRuntimeManifestSchema(primitives, operations2, identities
     operations2.object({
       apiUrl: operations2.optional(apiOriginSchema),
       maps: operations2.record(tileflowPortableIdSchema2, manifestMapSchema),
-      version: operations2.literal(tileflowRuntimeManifestVersion)
+      version: operations2.union(
+        operations2.literal(tileflowRuntimeManifestVersion),
+        operations2.literal(2)
+      )
     }),
     (manifest, context) => {
       const mapCount = Object.keys(manifest.maps).length;
+      if (manifest.version === 1) {
+        for (const [name, map] of Object.entries(manifest.maps)) {
+          if (map.timeOfDay !== void 0)
+            context.addIssue({
+              code: "custom",
+              message: "timeOfDay requires manifest version 2",
+              path: ["maps", name, "timeOfDay"]
+            });
+        }
+      }
       if (mapCount === 0) {
         context.addIssue({ code: "custom", message: "Expected at least one map", path: ["maps"] });
       }
@@ -2427,6 +2531,8 @@ var init_manifest_schema = __esm({
     init_portable_identity_schema();
     init_runtime_view_schema();
     init_model();
+    init_time_of_day();
+    init_time_of_day_schema();
   }
 });
 
@@ -2437,7 +2543,8 @@ __export(manifest_exports, {
   safeParseTileflowRuntimeManifest: () => safeParseTileflowRuntimeManifest,
   tileflowRuntimeManifestLimits: () => tileflowRuntimeManifestLimits,
   tileflowRuntimeManifestSchema: () => tileflowRuntimeManifestSchema,
-  tileflowRuntimeManifestVersion: () => tileflowRuntimeManifestVersion
+  tileflowRuntimeManifestVersion: () => tileflowRuntimeManifestVersion,
+  tileflowTimeOfDayManifestVersion: () => tileflowTimeOfDayManifestVersion
 });
 function parseTileflowRuntimeManifest(input) {
   return tileflowRuntimeManifestSchema.parse(input);
@@ -2464,6 +2571,277 @@ var init_manifest = __esm({
   }
 });
 
+// ../../node_modules/.pnpm/meshoptimizer@1.3.0/node_modules/meshoptimizer/meshopt_decoder.mjs
+var meshopt_decoder_exports = {};
+__export(meshopt_decoder_exports, {
+  MeshoptDecoder: () => MeshoptDecoder
+});
+var MeshoptDecoder;
+var init_meshopt_decoder = __esm({
+  "../../node_modules/.pnpm/meshoptimizer@1.3.0/node_modules/meshoptimizer/meshopt_decoder.mjs"() {
+    "use strict";
+    MeshoptDecoder = (function() {
+      var wasm_base = "b9H79Tebbbe8Fv9Gbb9Gvuuuuueu9Giuuub9Geueu9Giuuueuixkbeeeddddillviebeoweuecj:Gdkr;Neqo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bb8A9TW79O9V9Wt9F9KW9J9V9KW9wWVtW949c919M9MWVbeY9TW79O9V9Wt9F9KW9J9V9KW69U9KW949c919M9MWVbdE9TW79O9V9Wt9F9KW9J9V9KW69U9KW949tWG91W9U9JWbiL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9p9JtblK9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9r919HtbvL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVT949WboY9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVJ9V29VVbrl79IV9Rbwq;X8:kdbk:kYi5ud9:du8Jjjjjbcjq9Rgv8Kjjjjbc9:hodnalTmbcuhoaiRbbgrc;WeGc:Ge9hmbarcsGgwce0mbc9:hoalcufadcd4cbawEgDadfgrcKcaawEgqaraq0Egk6mbaicefhxcj;abad9Uc;WFbGcjdadca0EhmaialfgPar9Rgoadfhsavaoadz:jjjjbgzceVhHcbhOdndninaeaO9nmeaPax9RaD6mdamaeaO9RaOamfgoae6EgAcsfglc9WGhCaAcethXaxaDfhiaOaeaoaeao6E9RhQalcl4cifcd4hLazcjdfaAfhKcbhYabaOad2fg8AhEaHh3incbh5dnawTmbaxaYcd4fRbbh5kcbh8Eazcjdfhqinaih8Fdndndndna5a8Ecet4ciGgoc9:fPdebdkaPa8F9RaA6mrazcjdfa8EaA2fa8FaAz:jjjjb8Aa8FaAfhixdkazcjdfa8EaA2fcbaAz:kjjjb8Aa8FhixekaPa8F9RaL6mva8FaLfhidnaCTmbaPai9RcK6mbaocdtc:q:G:cjbfcj:G:cjbawEhaczhrcbhlinargoc9Wfghaqfhrdndndndndndnaaa8Fahco4fRbbalcoG4ciGcdtfydbPDbedvivvvlvkar9cb83bwar9cb83bbxlkarcbaiRbdai8Xbb9c:c:qj:bw9:9c:q;c1:I1e:d9c:b:c:e1z9:gg9cjjjjjz:dg8J9qE86bbaqaofgrcGfcbaicdfa8J9c8N1:NfghRbbag9cjjjjjw:dg8J9qE86bbarcVfcbaha8J9c8M1:NfghRbbag9cjjjjjl:dg8J9qE86bbarc7fcbaha8J9c8L1:NfghRbbag9cjjjjjd:dg8J9qE86bbarctfcbaha8J9c8K1:NfghRbbag9cjjjjje:dg8J9qE86bbarc91fcbaha8J9c8J1:NfghRbbag9cjjjj;ab:dg8J9qE86bbarc4fcbaha8J9cg1:NfghRbbag9cjjjja:dg8J9qE86bbarc93fcbaha8J9ch1:NfghRbbag9cjjjjz:dgg9qE86bbarc94fcbahag9ca1:NfghRbbai8Xbe9c:c:qj:bw9:9c:q;c1:I1e:d9c:b:c:e1z9:gg9cjjjjjz:dg8J9qE86bbarc95fcbaha8J9c8N1:NfgiRbbag9cjjjjjw:dg8J9qE86bbarc96fcbaia8J9c8M1:NfgiRbbag9cjjjjjl:dg8J9qE86bbarc97fcbaia8J9c8L1:NfgiRbbag9cjjjjjd:dg8J9qE86bbarc98fcbaia8J9c8K1:NfgiRbbag9cjjjjje:dg8J9qE86bbarc99fcbaia8J9c8J1:NfgiRbbag9cjjjj;ab:dg8J9qE86bbarc9:fcbaia8J9cg1:NfgiRbbag9cjjjja:dg8J9qE86bbarcufcbaia8J9ch1:NfgiRbbag9cjjjjz:dgg9qE86bbaiag9ca1:NfhixikaraiRblaiRbbghco4g8Ka8KciSg8KE86bbaqaofgrcGfaiclfa8Kfg8KRbbahcl4ciGg8La8LciSg8LE86bbarcVfa8Ka8Lfg8KRbbahcd4ciGg8La8LciSg8LE86bbarc7fa8Ka8Lfg8KRbbahciGghahciSghE86bbarctfa8Kahfg8KRbbaiRbeghco4g8La8LciSg8LE86bbarc91fa8Ka8Lfg8KRbbahcl4ciGg8La8LciSg8LE86bbarc4fa8Ka8Lfg8KRbbahcd4ciGg8La8LciSg8LE86bbarc93fa8Ka8Lfg8KRbbahciGghahciSghE86bbarc94fa8Kahfg8KRbbaiRbdghco4g8La8LciSg8LE86bbarc95fa8Ka8Lfg8KRbbahcl4ciGg8La8LciSg8LE86bbarc96fa8Ka8Lfg8KRbbahcd4ciGg8La8LciSg8LE86bbarc97fa8Ka8Lfg8KRbbahciGghahciSghE86bbarc98fa8KahfghRbbaiRbigico4g8Ka8KciSg8KE86bbarc99faha8KfghRbbaicl4ciGg8Ka8KciSg8KE86bbarc9:faha8KfghRbbaicd4ciGg8Ka8KciSg8KE86bbarcufaha8KfgrRbbaiciGgiaiciSgiE86bbaraifhixdkaraiRbwaiRbbghcl4g8Ka8KcsSg8KE86bbaqaofgrcGfaicwfa8Kfg8KRbbahcsGghahcsSghE86bbarcVfa8KahfghRbbaiRbeg8Kcl4g8La8LcsSg8LE86bbarc7faha8LfghRbba8KcsGg8Ka8KcsSg8KE86bbarctfaha8KfghRbbaiRbdg8Kcl4g8La8LcsSg8LE86bbarc91faha8LfghRbba8KcsGg8Ka8KcsSg8KE86bbarc4faha8KfghRbbaiRbig8Kcl4g8La8LcsSg8LE86bbarc93faha8LfghRbba8KcsGg8Ka8KcsSg8KE86bbarc94faha8KfghRbbaiRblg8Kcl4g8La8LcsSg8LE86bbarc95faha8LfghRbba8KcsGg8Ka8KcsSg8KE86bbarc96faha8KfghRbbaiRbvg8Kcl4g8La8LcsSg8LE86bbarc97faha8LfghRbba8KcsGg8Ka8KcsSg8KE86bbarc98faha8KfghRbbaiRbog8Kcl4g8La8LcsSg8LE86bbarc99faha8LfghRbba8KcsGg8Ka8KcsSg8KE86bbarc9:faha8KfghRbbaiRbrgicl4g8Ka8KcsSg8KE86bbarcufaha8KfgrRbbaicsGgiaicsSgiE86bbaraifhixekarai8Pbw83bwarai8Pbb83bbaiczfhikdnaoaC9pmbalcdfhlaoczfhraPai9RcL0mekkaoaC6moaimexokaCmva8FTmvkaqaAfhqa8Ecefg8Ecl9hmbkdndndndnawTmbasaYcd4fRbbgociGPlbedrbkaATmdazaYfh8Fazcjdfhhcbh8EaEhaina8FRbbhraahocbhlinaoahalfRbbgqce4cbaqceG9R7arfgr86bbaoadfhoaAalcefgl9hmbkaacefhaa8Fcefh8FahaAfhha8Ecefg8Ecl9hmbxikkaATmeazaYfhaazcjdfhhcbhoceh8EaKh8FinaEaofhlaa8Vbbhrcbhoinala8FaofRbbcwtahaofRbbgqVc;:FiGce4cbaqceG9R7arfgr87bbaladfhlaQaocefgofmbka8FaXfh8FcdhoaacdfhaahaXfhha8EceGhlcbh8EalmbxdkkaATmbaocl4h8EazaYfRbbhqcwhoa3hlinalRbbaotaqVhqalcefhlaocwfgoca9hmbkcbhhaEh8FaKhainazcjdfahfRbbhrcwhoaahlinalRbbaotarVhralaAfhlaocwfgoca9hmbkara8E94aq7hqcbhoa8Fhlinalaqao486bbalcefhlaocwfgoca9hmbka8Fadfh8FaacefhaahcefghaA9hmbkkaEclfhEa3clfh3aYclfgYad6mbkaza8AaAcufad2fadz:jjjjb8AaAaOfhOaihxaimbkc9:hoxdkcbc99aPax9RakSEhoxekc9:hokavcjqf8Kjjjjbaok:bsesu8Jjjjjbc;ae9Rgv8Kjjjjbc9:hodnalaeci9UgrcHf6mbcuhoaiRbbgwc;WeGc;Ge9hmbawcsGgwce0mbavc;abfcFecjez:kjjjb8Aav9cu83iUav9cu83i8Wav9cu83iyav9cu83iaav9cu83iKav9cu83izav9cu83iwav9cu83ibaialfc9WfhDaicefgiarfhqdndnaeci9pmbaqhexekcmcsawceSEhkcbhxcbhmaqhecbhlcbhoindndnaiRbbgrc;Ve0mbavc;abfaoarcu7gPcl4fcsGcitfgwydlhsawydbhzdndnarcsGgwak9pmbavalaPfcsGcdtfydbaxawEhraxawTgHfhxxekdnaeaD9nmbc9:hoxokdndnawcsSmbcehHamawcetfcWfhrxekaecefhrae8SbbgwcFeGhPdndnawcu9mmbarhexekaecvfheaPcFbGhPcrhwdninar8SbbgHcFbGawtaPVhPaHcu9kmearcefhrawcrfgwc8J9hmbxdkkarcefhekcehHaPce4cbaPceG9R7amfhrkarhmkavc;abfaocitfgwarBdbawasBdlavalcdtfarBdbavc;abfaocefcsGcitfgwazBdbawarBdlaocdfhoaHalfhldnadcd9hmbabar87elabas87edabaz87ebabcofhbxdkabarBdwabasBdlabazBdbabcxfhbxekdnarcpe0mbavalaDarcsGfRbbgwcl4gP9RcsGcdtfydbaxcefgsaPEhravalaw9RcsGcdtfydbasaPTgzfgsawcsGgPEhwaPThPdndnadcd9hmbabaw87elabar87edabax87ebcohHxekabawBdwabarBdlabaxBdbcxhHkavalcdtfaxBdbavc;abfaocitfgOarBdbaOaxBdlavalcefglcsGcdtfarBdbavc;abfaocefcsGcitfgOawBdbaOarBdlavalazfglcsGcdtfawBdbavc;abfaocdfcsGcitfgraxBdbarawBdlaocifhoabaHfhbalaPfhlasaPfhxxekdnaeaD9nmbc9:hoxlkaxcbaeRbbgwEgHarc;:eSgrfhsawcsGhOdndnawcl4gAmbascefhzxekashzavalaA9RcsGcdtfydbhskdndnaOmbazcefhxxekazhxavalaw9RcsGcdtfydbhzkdndnarTmbaecefhrxekaecdfhrae8SbegPcFeGhwdnaPcu9kmbaecofhHawcFbGhwcrhedninar8SbbgPcFbGaetawVhwaPcu9kmearcefhraecrfgec8J9hmbkaHhrxekarcefhrkawce4cbawceG9R7amfgmhHkdndnaAcsSmbarhwxekarcefhwar8SbbgecFeGhPdnaecu9kmbarcvfhsaPcFbGhPcrhedninaw8SbbgrcFbGaetaPVhParcu9kmeawcefhwaecrfgec8J9hmbkashwxekawcefhwkaPce4cbaPceG9R7amfgmhskdndnaOcsSmbawhexekawcefheaw8SbbgrcFeGhPdnarcu9kmbawcvfhzaPcFbGhPcrhrdninae8SbbgwcFbGartaPVhPawcu9kmeaecefhearcrfgrc8J9hmbkazhexekaecefhekaPce4cbaPceG9R7amfgmhzkdndnadcd9hmbabaz87elabas87edabaH87ebcohrxekabazBdwabasBdlabaHBdbcxhrkavc;abfaocitfgwasBdbawaHBdlavalcdtfaHBdbavc;abfaocefcsGcitfgwazBdbawasBdlavalcefglcsGcdtfasBdbavc;abfaocdfcsGcitfgwaHBdbawazBdlavalaATaAcsSVfglcsGcdtfazBdbalaOTaOcsSVfhlaocifhoabarfhbkaocsGhoalcsGhlaicefgiaq6mbkkcbc99aeaDSEhokavc;aef8Kjjjjbaok:clevu8Jjjjjbcz9Rhvdnalaecvf9pmbc9:skdnaiRbbc;:eGc;qeSmbcuskav9cb83iwaicefhoaialfc98fhrdnaeTmbdnadcdSmbcbhwindnaoar6mbc9:skaocefhlao8SbbgicFeGhddndnaicu9mmbalhoxekaocvfhoadcFbGhdcrhidninal8SbbgDcFbGaitadVhdaDcu9kmealcefhlaicrfgic8J9hmbxdkkalcefhokabawcdtfadc8Etc8F91adcd47avcwfadceGcdtVglydbfgiBdbalaiBdbawcefgwae9hmbxdkkcbhwindnaoar6mbc9:skaocefhlao8SbbgicFeGhddndnaicu9mmbalhoxekaocvfhoadcFbGhdcrhidninal8SbbgDcFbGaitadVhdaDcu9kmealcefhlaicrfgic8J9hmbxdkkalcefhokabawcetfadc8Etc8F91adcd47avcwfadceGcdtVglydbfgi87ebalaiBdbawcefgwae9hmbkkcbc99aoarSEk:Lvoeue99dud99eud99dndnadcl9hmbaeTmeindndnabcdfgd8Sbb:Yab8Sbbgi:Ygl:l:tabcefgv8Sbbgo:Ygr:l:tgwJbb;:9cawawNJbbbbawawJbbbb9GgDEgq:mgkaqaicb9iEalMgwawNakaqaocb9iEarMgqaqNMM:r:vglNJbbbZJbbb:;aDEMgr:lJbbb9p9DTmbar:Ohixekcjjjj94hikadai86bbdndnaqalNJbbbZJbbb:;aqJbbbb9GEMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkavad86bbdndnawalNJbbbZJbbb:;awJbbbb9GEMgw:lJbbb9p9DTmbaw:Ohdxekcjjjj94hdkabad86bbabclfhbaecufgembxdkkaeTmbindndnabclfgd8Ueb:Yab8Uebgi:Ygl:l:tabcdfgv8Uebgo:Ygr:l:tgwJb;:FSawawNJbbbbawawJbbbb9GgDEgq:mgkaqaicb9iEalMgwawNakaqaocb9iEarMgqaqNMM:r:vglNJbbbZJbbb:;aDEMgr:lJbbb9p9DTmbar:Ohixekcjjjj94hikadai87ebdndnaqalNJbbbZJbbb:;aqJbbbb9GEMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkavad87ebdndnawalNJbbbZJbbb:;awJbbbb9GEMgw:lJbbb9p9DTmbaw:Ohdxekcjjjj94hdkabad87ebabcwfhbaecufgembkkk:4ioiue99dud99dud99dnaeTmbcbhiabhlindndnal8Uebgv:YgoJ:ji:1Salcof8UebgrciVgw:Y:vgDNJbbbZJbbb:;avcu9kEMgq:lJbbb9p9DTmbaq:Ohkxekcjjjj94hkkalclf8Uebhvalcdf8UebhxalarcefciGcetfak87ebdndnax:YgqaDNJbbbZJbbb:;axcu9kEMgm:lJbbb9p9DTmbam:Ohxxekcjjjj94hxkabaiarciGgkfcd7cetfax87ebdndnav:YgmaDNJbbbZJbbb:;avcu9kEMgP:lJbbb9p9DTmbaP:Ohvxekcjjjj94hvkalarcufciGcetfav87ebdndnawaw2:ZgPaPMaoaoN:taqaqN:tamamN:tgoJbbbbaoJbbbb9GE:raDNJbbbZMgD:lJbbb9p9DTmbaD:Ohrxekcjjjj94hrkalakcetfar87ebalcwfhlaiclfhiaecufgembkkk9mbdnadcd4ae2gdTmbinababydbgecwtcw91:Yaece91cjjj98Gcjjj;8if::NUdbabclfhbadcufgdmbkkk:Tvirud99eudndnadcl9hmbaeTmeindndnabRbbgiabcefgl8Sbbgvabcdfgo8Sbbgrf9R:YJbbuJabcifgwRbbgdce4adVgDcd4aDVgDcl4aDVgD:Z:vgqNJbbbZMgk:lJbbb9p9DTmbak:Ohxxekcjjjj94hxkaoax86bbdndnaraif:YaqNJbbbZMgk:lJbbb9p9DTmbak:Ohoxekcjjjj94hokalao86bbdndnavaifar9R:YaqNJbbbZMgk:lJbbb9p9DTmbak:Ohixekcjjjj94hikabai86bbdndnaDadcetGadceGV:ZaqNJbbbZMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkawad86bbabclfhbaecufgembxdkkaeTmbindndnab8Vebgiabcdfgl8Uebgvabclfgo8Uebgrf9R:YJbFu9habcofgw8Vebgdce4adVgDcd4aDVgDcl4aDVgDcw4aDVgD:Z:vgqNJbbbZMgk:lJbbb9p9DTmbak:Ohxxekcjjjj94hxkaoax87ebdndnaraif:YaqNJbbbZMgk:lJbbb9p9DTmbak:Ohoxekcjjjj94hokalao87ebdndnavaifar9R:YaqNJbbbZMgk:lJbbb9p9DTmbak:Ohixekcjjjj94hikabai87ebdndnaDadcetGadceGV:ZaqNJbbbZMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkawad87ebabcwfhbaecufgembkkk9teiucbcbyd:K:G:cjbgeabcifc98GfgbBd:K:G:cjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaik;LeeeudndnaeabVciGTmbabhixekdndnadcz9pmbabhixekabhiinaiaeydbBdbaiclfaeclfydbBdbaicwfaecwfydbBdbaicxfaecxfydbBdbaeczfheaiczfhiadc9Wfgdcs0mbkkadcl6mbinaiaeydbBdbaeclfheaiclfhiadc98fgdci0mbkkdnadTmbinaiaeRbb86bbaicefhiaecefheadcufgdmbkkabk;aeedudndnabciGTmbabhixekaecFeGc:b:c:ew2hldndnadcz9pmbabhixekabhiinaialBdbaicxfalBdbaicwfalBdbaiclfalBdbaiczfhiadc9Wfgdcs0mbkkadcl6mbinaialBdbaiclfhiadc98fgdci0mbkkdnadTmbinaiae86bbaicefhiadcufgdmbkkabkk83dbcj:Gdk8Kbbbbdbbblbbbwbbbbbbbebbbdbbblbbbwbbbbc:K:Gdkl8W:qbb";
+      var wasm_simd = "b9H79TebbbeKl9Gbb9Gvuuuuueu9Giuuub9Geueuixkbbebeeddddilve9Weeeviebeoweuecj:Gdkr;Neqo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bb8A9TW79O9V9Wt9F9KW9J9V9KW9wWVtW949c919M9MWVbdY9TW79O9V9Wt9F9KW9J9V9KW69U9KW949c919M9MWVblE9TW79O9V9Wt9F9KW9J9V9KW69U9KW949tWG91W9U9JWbvL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9p9JtboK9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9r919HtbrL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVT949WbwY9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVJ9V29VVbDl79IV9Rbqq:I9Dklbzik94evu8Jjjjjbcz9Rhbcbheincbhdcbhiinabcwfadfaicjuaead4ceGglE86bbaialfhiadcefgdcw9hmbkaeai86b:q:W:cjbaecitab8Piw83i:q:G:cjbaecefgecjd9hmbkk:SBlEud97dur978Jjjjjbcj;kb9Rgv8Kjjjjbc9:hodnalTmbcuhoaiRbbgrc;WeGc:Ge9hmbarcsGgwce0mbc9:hoalcufadcd4cbawEgDadfgrcKcaawEgqaraq0Egk6mbaialfgxar9RhodnadTgmmbavaoad;8qbbkaicefhPcj;abad9Uc;WFbGcjdadca0EhsdndndnadTmbaoadfhzcbhHinaeaH9nmdaxaP9RaD6miabaHad2fgOavcjdfasaeaH9RaHasfae6EgAaAcsfgoc9WGgCSEhXaPaDfhQaocl4cifcd4hLavcj;cbfaCcetfhKavcj;cbfaCci2fhYavcj;cbfaCfh8AcbhEaoc;ab6h3incbh5dnawTmbaPaEcd4fRbbh5kcbh8Eavcj;cbfh8Findndndndna5a8Ecet4ciGgoc9:fPdebdkaxaQ9RaC6mwdnaCTmbavcj;cbfa8EaC2faQaC;8qbbkaQaAfhQxdkaCTmeavcj;cbfa8EaC2fcbaC;8kbxekaxaQ9RaL6moaoclVcbawEhraQaLfhocbhidna3mbaxao9Rc;Gb6mbcbhlina8FalfhidndndndndndnaQalco4fRbbgqciGarfPDbedibledibkaipxbbbbbbbbbbbbbbbbpklbxlkaiaopbblaopbbbgaclp:meaapmbzeHdOiAlCvXoQrLgacdp:meaapmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9oghpxiiiiiiiiiiiiiiiip8Jgap5b9cjF;8;4;W;G;ab9:9cU1:Nggcitpbi:q:G:cjbagRb:q:W:cjbggpsaap5e9cjF;8;4;W;G;ab9:9cU1:Ng8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPahaap9spklbagaoclffa8JRb:q:W:cjbfhoxikaiaopbbwaopbbbgaclp:meaapmbzeHdOiAlCvXoQrLpxssssssssssssssssp9oghpxssssssssssssssssp8Jgap5b9cjF;8;4;W;G;ab9:9cU1:Nggcitpbi:q:G:cjbagRb:q:W:cjbggpsaap5e9cjF;8;4;W;G;ab9:9cU1:Ng8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPahaap9spklbagaocwffa8JRb:q:W:cjbfhoxdkaiaopbbbpklbaoczfhoxekaiaopbbdaoRbbggcitpbi:q:G:cjbagRb:q:W:cjbggpsaoRbeg8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPpklbagaocdffa8JRb:q:W:cjbfhokdndndndndndnaqcd4ciGarfPDbedibledibkaiczfpxbbbbbbbbbbbbbbbbpklbxlkaiczfaopbblaopbbbgaclp:meaapmbzeHdOiAlCvXoQrLgacdp:meaapmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9oghpxiiiiiiiiiiiiiiiip8Jgap5b9cjF;8;4;W;G;ab9:9cU1:Nggcitpbi:q:G:cjbagRb:q:W:cjbggpsaap5e9cjF;8;4;W;G;ab9:9cU1:Ng8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPahaap9spklbagaoclffa8JRb:q:W:cjbfhoxikaiczfaopbbwaopbbbgaclp:meaapmbzeHdOiAlCvXoQrLpxssssssssssssssssp9oghpxssssssssssssssssp8Jgap5b9cjF;8;4;W;G;ab9:9cU1:Nggcitpbi:q:G:cjbagRb:q:W:cjbggpsaap5e9cjF;8;4;W;G;ab9:9cU1:Ng8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPahaap9spklbagaocwffa8JRb:q:W:cjbfhoxdkaiczfaopbbbpklbaoczfhoxekaiczfaopbbdaoRbbggcitpbi:q:G:cjbagRb:q:W:cjbggpsaoRbeg8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPpklbagaocdffa8JRb:q:W:cjbfhokdndndndndndnaqcl4ciGarfPDbedibledibkaicafpxbbbbbbbbbbbbbbbbpklbxlkaicafaopbblaopbbbgaclp:meaapmbzeHdOiAlCvXoQrLgacdp:meaapmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9oghpxiiiiiiiiiiiiiiiip8Jgap5b9cjF;8;4;W;G;ab9:9cU1:Nggcitpbi:q:G:cjbagRb:q:W:cjbggpsaap5e9cjF;8;4;W;G;ab9:9cU1:Ng8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPahaap9spklbagaoclffa8JRb:q:W:cjbfhoxikaicafaopbbwaopbbbgaclp:meaapmbzeHdOiAlCvXoQrLpxssssssssssssssssp9oghpxssssssssssssssssp8Jgap5b9cjF;8;4;W;G;ab9:9cU1:Nggcitpbi:q:G:cjbagRb:q:W:cjbggpsaap5e9cjF;8;4;W;G;ab9:9cU1:Ng8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPahaap9spklbagaocwffa8JRb:q:W:cjbfhoxdkaicafaopbbbpklbaoczfhoxekaicafaopbbdaoRbbggcitpbi:q:G:cjbagRb:q:W:cjbggpsaoRbeg8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPpklbagaocdffa8JRb:q:W:cjbfhokdndndndndndnaqco4arfPDbedibledibkaic8Wfpxbbbbbbbbbbbbbbbbpklbxlkaic8Wfaopbblaopbbbgaclp:meaapmbzeHdOiAlCvXoQrLgacdp:meaapmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9oghpxiiiiiiiiiiiiiiiip8Jgap5b9cjF;8;4;W;G;ab9:9cU1:Ngicitpbi:q:G:cjbaiRb:q:W:cjbgipsaap5e9cjF;8;4;W;G;ab9:9cU1:Ngqcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPahaap9spklbaiaoclffaqRb:q:W:cjbfhoxikaic8Wfaopbbwaopbbbgaclp:meaapmbzeHdOiAlCvXoQrLpxssssssssssssssssp9oghpxssssssssssssssssp8Jgap5b9cjF;8;4;W;G;ab9:9cU1:Ngicitpbi:q:G:cjbaiRb:q:W:cjbgipsaap5e9cjF;8;4;W;G;ab9:9cU1:Ngqcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPahaap9spklbaiaocwffaqRb:q:W:cjbfhoxdkaic8Wfaopbbbpklbaoczfhoxekaic8WfaopbbdaoRbbgicitpbi:q:G:cjbaiRb:q:W:cjbgipsaoRbegqcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPpklbaiaocdffaqRb:q:W:cjbfhokalc;abfhialcjefaC0meaihlaxao9Rc;Fb0mbkkdnaiaC9pmbaici4hlinaxao9RcK6mwa8FaifhqdndndndndndnaQaico4fRbbalcoG4ciGarfPDbedibledibkaqpxbbbbbbbbbbbbbbbbpkbbxlkaqaopbblaopbbbgaclp:meaapmbzeHdOiAlCvXoQrLgacdp:meaapmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9oghpxiiiiiiiiiiiiiiiip8Jgap5b9cjF;8;4;W;G;ab9:9cU1:Nggcitpbi:q:G:cjbagRb:q:W:cjbggpsaap5e9cjF;8;4;W;G;ab9:9cU1:Ng8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPahaap9spkbbagaoclffa8JRb:q:W:cjbfhoxikaqaopbbwaopbbbgaclp:meaapmbzeHdOiAlCvXoQrLpxssssssssssssssssp9oghpxssssssssssssssssp8Jgap5b9cjF;8;4;W;G;ab9:9cU1:Nggcitpbi:q:G:cjbagRb:q:W:cjbggpsaap5e9cjF;8;4;W;G;ab9:9cU1:Ng8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPahaap9spkbbagaocwffa8JRb:q:W:cjbfhoxdkaqaopbbbpkbbaoczfhoxekaqaopbbdaoRbbggcitpbi:q:G:cjbagRb:q:W:cjbggpsaoRbeg8Jcitpbi:q:G:cjbp9UpmbedilvorzHOACXQLpPpkbbagaocdffa8JRb:q:W:cjbfhokalcdfhlaiczfgiaC6mbkkaohQaoTmoka8FaCfh8Fa8Ecefg8Ecl9hmbkdndndndnawTmbazaEcd4fRbbglciGPlbedwbkaCTmdaXaEfhlavaEfpbdbh8Kcbhoinalavcj;cbfaofpblbg8La8Aaofpblbg8MpmbzeHdOiAlCvXoQrLg8NaKaofpblbgyaYaofpblbg8PpmbzeHdOiAlCvXoQrLgIpmbezHdiOAlvCXorQLgacep9Taapxeeeeeeeeeeeeeeeeghp9op9Hp9rgaa8Kp9Ug8Kp9Abbbaladfgla8Kaaaapmlvorlvorlvorlvorp9Ug8Kp9Abbbaladfgla8KaaaapmwDqkwDqkwDqkwDqkp9Ug8Kp9Abbbaladfgla8KaaaapmxmPsxmPsxmPsxmPsp9Ug8Kp9Abbbaladfgla8Ka8NaIpmwDKYqk8AExm35Ps8E8Fgacep9Taaahp9op9Hp9rgap9Ug8Kp9Abbbaladfgla8Kaaaapmlvorlvorlvorlvorp9Ug8Kp9Abbbaladfgla8KaaaapmwDqkwDqkwDqkwDqkp9Ug8Kp9Abbbaladfgla8KaaaapmxmPsxmPsxmPsxmPsp9Ug8Kp9Abbbaladfgla8Ka8La8MpmwKDYq8AkEx3m5P8Es8Fg8Laya8PpmwKDYq8AkEx3m5P8Es8Fg8MpmbezHdiOAlvCXorQLgacep9Taaahp9op9Hp9rgap9Ug8Kp9Abbbaladfgla8Kaaaapmlvorlvorlvorlvorp9Ug8Kp9Abbbaladfgla8KaaaapmwDqkwDqkwDqkwDqkp9Ug8Kp9Abbbaladfgla8KaaaapmxmPsxmPsxmPsxmPsp9Ug8Kp9Abbbaladfgla8Ka8La8MpmwDKYqk8AExm35Ps8E8Fgacep9Taaahp9op9Hp9rgap9Ughp9Abbbaladfglahaaaapmlvorlvorlvorlvorp9Ughp9AbbbaladfglahaaaapmwDqkwDqkwDqkwDqkp9Ughp9AbbbaladfglahaaaapmxmPsxmPsxmPsxmPsp9Ug8Kp9AbbbaladfhlaoczfgoaC6mbxikkaCTmeaXaEfhlavaEfpbdbh8Kcbhoinalavcj;cbfaofpblbg8La8Aaofpblbg8MpmbzeHdOiAlCvXoQrLg8NaKaofpblbgyaYaofpblbg8PpmbzeHdOiAlCvXoQrLgIpmbezHdiOAlvCXorQLgacep:neaapxebebebebebebebebghp9op:bep9rgaa8Kp:oeg8Kp9Abbbaladfgla8Kaaaapmlvorlvorlvorlvorp:oeg8Kp9Abbbaladfgla8KaaaapmwDqkwDqkwDqkwDqkp:oeg8Kp9Abbbaladfgla8KaaaapmxmPsxmPsxmPsxmPsp:oeg8Kp9Abbbaladfgla8Ka8NaIpmwDKYqk8AExm35Ps8E8Fgacep:neaaahp9op:bep9rgap:oeg8Kp9Abbbaladfgla8Kaaaapmlvorlvorlvorlvorp:oeg8Kp9Abbbaladfgla8KaaaapmwDqkwDqkwDqkwDqkp:oeg8Kp9Abbbaladfgla8KaaaapmxmPsxmPsxmPsxmPsp:oeg8Kp9Abbbaladfgla8Ka8La8MpmwKDYq8AkEx3m5P8Es8Fg8Laya8PpmwKDYq8AkEx3m5P8Es8Fg8MpmbezHdiOAlvCXorQLgacep:neaaahp9op:bep9rgap:oeg8Kp9Abbbaladfgla8Kaaaapmlvorlvorlvorlvorp:oeg8Kp9Abbbaladfgla8KaaaapmwDqkwDqkwDqkwDqkp:oeg8Kp9Abbbaladfgla8KaaaapmxmPsxmPsxmPsxmPsp:oeg8Kp9Abbbaladfgla8Ka8La8MpmwDKYqk8AExm35Ps8E8Fgacep:neaaahp9op:bep9rgap:oeghp9Abbbaladfglahaaaapmlvorlvorlvorlvorp:oeghp9AbbbaladfglahaaaapmwDqkwDqkwDqkwDqkp:oeghp9AbbbaladfglahaaaapmxmPsxmPsxmPsxmPsp:oeg8Kp9AbbbaladfhlaoczfgoaC6mbxdkkaCTmbaXaEfhrcbhocbalcl4gl9Rc8FGhiavaEfpbdbhhinaravcj;cbfaofpblbg8Ka8Aaofpblbg8LpmbzeHdOiAlCvXoQrLg8MaKaofpblbg8NaYaofpblbgypmbzeHdOiAlCvXoQrLg8PpmbezHdiOAlvCXorQLgaaip:Reaaalp:Tep9qgaahp9rghp9Abbbaradfgrahaaaapmlvorlvorlvorlvorp9rghp9AbbbaradfgrahaaaapmwDqkwDqkwDqkwDqkp9rghp9AbbbaradfgrahaaaapmxmPsxmPsxmPsxmPsp9rghp9Abbbaradfgraha8Ma8PpmwDKYqk8AExm35Ps8E8Fgaaip:Reaaalp:Tep9qgap9rghp9Abbbaradfgrahaaaapmlvorlvorlvorlvorp9rghp9AbbbaradfgrahaaaapmwDqkwDqkwDqkwDqkp9rghp9AbbbaradfgrahaaaapmxmPsxmPsxmPsxmPsp9rghp9Abbbaradfgraha8Ka8LpmwKDYq8AkEx3m5P8Es8Fg8Ka8NaypmwKDYq8AkEx3m5P8Es8Fg8LpmbezHdiOAlvCXorQLgaaip:Reaaalp:Tep9qgap9rghp9Abbbaradfgrahaaaapmlvorlvorlvorlvorp9rghp9AbbbaradfgrahaaaapmwDqkwDqkwDqkwDqkp9rghp9AbbbaradfgrahaaaapmxmPsxmPsxmPsxmPsp9rghp9Abbbaradfgraha8Ka8LpmwDKYqk8AExm35Ps8E8Fgaaip:Reaaalp:Tep9qgap9rghp9Abbbaradfgrahaaaapmlvorlvorlvorlvorp9rghp9AbbbaradfgrahaaaapmwDqkwDqkwDqkwDqkp9rghp9AbbbaradfgrahaaaapmxmPsxmPsxmPsxmPsp9rghp9AbbbaradfhraoczfgoaC6mbkkaEclfgEad6mbkdnaXavcjdf9hmbaAad2goTmbaOavcjdfao;8qbbkdnammbavaXaAcufad2fad;8qbbkaAaHfhHc9:hoaQhPaQmbxlkkaeTmbaDalfhrcbhocuhlinaralaD9RglfaD6mdasaeao9Raoasfae6Eaofgoae6mbkaial9RhPkcbc99axaP9RakSEhoxekc9:hokavcj;kbf8Kjjjjbaokwbz:bjjjbkpPesu8Jjjjjbc;ae9Rgv8Kjjjjbc9:hodnalaeci9UgrcHf6mbcuhoaiRbbgwc;WeGc;Ge9hmbawcsGgwce0mbavc;abfcFecje;8kbav9cu83iUav9cu83i8Wav9cu83iyav9cu83iaav9cu83iKav9cu83izav9cu83iwav9cu83ibaialfc9WfhDaicefgiarfhqdndnaeci9pmbaqhexekcmcsawceSEhkcbhxcbhmaqhecbhlcbhoindndnaiRbbgrc;Ve0mbavc;abfaoarcu7gPcl4fcsGcitfgwydlhsawydbhzdndnarcsGgwak9pmbavalaPfcsGcdtfydbaxawEhraxawTgHfhxxekdnaeaD9nmbc9:hoxokdndnawcsSmbcehHamawcetfcWfhrxekaecefhrae8SbbgwcFeGhPdndnawcu9mmbarhexekaecvfheaPcFbGhPcrhwdninar8SbbgHcFbGawtaPVhPaHcu9kmearcefhrawcrfgwc8J9hmbxdkkarcefhekcehHaPce4cbaPceG9R7amfhrkarhmkavc;abfaocitfgwarBdbawasBdlavalcdtfarBdbavc;abfaocefcsGcitfgwazBdbawarBdlaocdfhoaHalfhldnadcd9hmbabar87elabas87edabaz87ebabcofhbxdkabarBdwabasBdlabazBdbabcxfhbxekdnarcpe0mbavalaDarcsGfRbbgwcl4gP9RcsGcdtfydbaxcefgsaPEhravalaw9RcsGcdtfydbasaPTgzfgsawcsGgPEhwaPThPdndnadcd9hmbabaw87elabar87edabax87ebcohHxekabawBdwabarBdlabaxBdbcxhHkavalcdtfaxBdbavc;abfaocitfgOarBdbaOaxBdlavalcefglcsGcdtfarBdbavc;abfaocefcsGcitfgOawBdbaOarBdlavalazfglcsGcdtfawBdbavc;abfaocdfcsGcitfgraxBdbarawBdlaocifhoabaHfhbalaPfhlasaPfhxxekdnaeaD9nmbc9:hoxlkaxcbaeRbbgwEgHarc;:eSgrfhsawcsGhOdndnawcl4gAmbascefhzxekashzavalaA9RcsGcdtfydbhskdndnaOmbazcefhxxekazhxavalaw9RcsGcdtfydbhzkdndnarTmbaecefhrxekaecdfhrae8SbegPcFeGhwdnaPcu9kmbaecofhHawcFbGhwcrhedninar8SbbgPcFbGaetawVhwaPcu9kmearcefhraecrfgec8J9hmbkaHhrxekarcefhrkawce4cbawceG9R7amfgmhHkdndnaAcsSmbarhwxekarcefhwar8SbbgecFeGhPdnaecu9kmbarcvfhsaPcFbGhPcrhedninaw8SbbgrcFbGaetaPVhParcu9kmeawcefhwaecrfgec8J9hmbkashwxekawcefhwkaPce4cbaPceG9R7amfgmhskdndnaOcsSmbawhexekawcefheaw8SbbgrcFeGhPdnarcu9kmbawcvfhzaPcFbGhPcrhrdninae8SbbgwcFbGartaPVhPawcu9kmeaecefhearcrfgrc8J9hmbkazhexekaecefhekaPce4cbaPceG9R7amfgmhzkdndnadcd9hmbabaz87elabas87edabaH87ebcohrxekabazBdwabasBdlabaHBdbcxhrkavc;abfaocitfgwasBdbawaHBdlavalcdtfaHBdbavc;abfaocefcsGcitfgwazBdbawasBdlavalcefglcsGcdtfasBdbavc;abfaocdfcsGcitfgwaHBdbawazBdlavalaATaAcsSVfglcsGcdtfazBdbalaOTaOcsSVfhlaocifhoabarfhbkaocsGhoalcsGhlaicefgiaq6mbkkcbc99aeaDSEhokavc;aef8Kjjjjbaok:clevu8Jjjjjbcz9Rhvdnalaecvf9pmbc9:skdnaiRbbc;:eGc;qeSmbcuskav9cb83iwaicefhoaialfc98fhrdnaeTmbdnadcdSmbcbhwindnaoar6mbc9:skaocefhlao8SbbgicFeGhddndnaicu9mmbalhoxekaocvfhoadcFbGhdcrhidninal8SbbgDcFbGaitadVhdaDcu9kmealcefhlaicrfgic8J9hmbxdkkalcefhokabawcdtfadc8Etc8F91adcd47avcwfadceGcdtVglydbfgiBdbalaiBdbawcefgwae9hmbxdkkcbhwindnaoar6mbc9:skaocefhlao8SbbgicFeGhddndnaicu9mmbalhoxekaocvfhoadcFbGhdcrhidninal8SbbgDcFbGaitadVhdaDcu9kmealcefhlaicrfgic8J9hmbxdkkalcefhokabawcetfadc8Etc8F91adcd47avcwfadceGcdtVglydbfgi87ebalaiBdbawcefgwae9hmbkkcbc99aoarSEk;Toio97eue97aec98Ghedndnadcl9hmbaeTmecbhdinababpbbbgicKp:RecKp:Sep;6eglaicwp:RecKp:Sep;6ealp;Geaiczp:RecKp:Sep;6egvp;Gep;Kep;Legopxbbbbbbbbbbbbbbbbp:2egralpxbbbjbbbjbbbjbbbjgwp9op9rp;Keglpxbb;:9cbb;:9cbb;:9cbb;:9calalp;Meaoaop;Meavaravawp9op9rp;Keglalp;Mep;Kep;Kep;Jep;Negvp;Mepxbbn0bbn0bbn0bbn0grp;KepxFbbbFbbbFbbbFbbbp9oaipxbbbFbbbFbbbFbbbFp9op9qalavp;Mearp;Kecwp:RepxbFbbbFbbbFbbbFbbp9op9qaoavp;Mearp;Keczp:RepxbbFbbbFbbbFbbbFbp9op9qpkbbabczfhbadclfgdae6mbxdkkaeTmbcbhdinabczfgDaDpbbbgipxbbbbbbFFbbbbbbFFgwp9oabpbbbgoaipmbediwDqkzHOAKY8AEgvczp:Reczp:Sep;6eglaoaipmlvorxmPsCXQL358E8FpxFubbFubbFubbFubbp9op;6eavczp:Sep;6egvp;Gealp;Gep;Kep;Legipxbbbbbbbbbbbbbbbbp:2egralpxbbbjbbbjbbbjbbbjgqp9op9rp;Keglpxb;:FSb;:FSb;:FSb;:FSalalp;Meaiaip;Meavaravaqp9op9rp;Keglalp;Mep;Kep;Kep;Jep;Negvp;Mepxbbn0bbn0bbn0bbn0grp;KepxFFbbFFbbFFbbFFbbp9oaiavp;Mearp;Keczp:Rep9qgialavp;Mearp;KepxFFbbFFbbFFbbFFbbp9oglpmwDKYqk8AExm35Ps8E8Fp9qpkbbabaoawp9oaialpmbezHdiOAlvCXorQLp9qpkbbabcafhbadclfgdae6mbkkk;2ileue97euo97dnaec98GgiTmbcbheinabcKfpx:ji:1S:ji:1S:ji:1S:ji:1SabpbbbglabczfgvpbbbgopmlvorxmPsCXQL358E8Fgrczp:Segwpxibbbibbbibbbibbbp9qp;6egDp;NegqaDaDp;MegDaDp;KealaopmbediwDqkzHOAKY8AEgDczp:Reczp:Sep;6eglalp;MeaDczp:Sep;6egoaop;Mearczp:Reczp:Sep;6egrarp;Mep;Kep;Kep;Lepxbbbbbbbbbbbbbbbbp:4ep;Jep;Mepxbbn0bbn0bbn0bbn0gDp;KepxFFbbFFbbFFbbFFbbgkp9oaqaop;MeaDp;Keczp:Rep9qgoaqalp;MeaDp;Keakp9oaqarp;MeaDp;Keczp:Rep9qgDpmwDKYqk8AExm35Ps8E8Fglp5eawclp:RegqpEi:T:j83ibavalp5baqpEd:T:j83ibabcwfaoaDpmbezHdiOAlvCXorQLgDp5eaqpEe:T:j83ibabaDp5baqpEb:T:j83ibabcafhbaeclfgeai6mbkkkuee97dnadcd4ae2c98GgeTmbcbhdinababpbbbgicwp:Recwp:Sep;6eaicep:SepxbbjFbbjFbbjFbbjFp9opxbbjZbbjZbbjZbbjZp:Uep;Mepkbbabczfhbadclfgdae6mbkkk:Sodw97euaec98Ghedndnadcl9hmbaeTmecbhdinabpxbbuJbbuJbbuJbbuJabpbbbgicKp:TeglaicYp:Tep9qgvcdp:Teavp9qgvclp:Teavp9qgop;6ep;Negvaicwp:RecKp:SegraipxFbbbFbbbFbbbFbbbgwp9ogDp:Uep;6ep;Mepxbbn0bbn0bbn0bbn0gqp;Kecwp:RepxbFbbbFbbbFbbbFbbp9oavaDarp:Xeaiczp:RecKp:Segip:Uep;6ep;Meaqp;Keawp9op9qavaDaraip:Uep:Xep;6ep;Meaqp;Keczp:RepxbbFbbbFbbbFbbbFbp9op9qavaoalcep:Rep9oalpxebbbebbbebbbebbbp9op9qp;6ep;Meaqp;KecKp:Rep9qpkbbabczfhbadclfgdae6mbxdkkaeTmbcbhdinabczfgkpxbFu9hbFu9hbFu9hbFu9habpbbbglakpbbbgrpmlvorxmPsCXQL358E8Fgvczp:TegqavcHp:Tep9qgicdp:Teaip9qgiclp:Teaip9qgicwp:Teaip9qgop;6ep;NegialarpmbediwDqkzHOAKY8AEgDpxFFbbFFbbFFbbFFbbglp9ograDczp:Segwp:Ueavczp:Reczp:SegDp:Xep;6ep;Mepxbbn0bbn0bbn0bbn0gvp;Kealp9oaiarawaDp:Uep:Xep;6ep;Meavp;Keczp:Rep9qgwaiaoaqcep:Rep9oaqpxebbbebbbebbbebbbp9op9qp;6ep;Meavp;Keczp:ReaiaDarp:Uep;6ep;Meavp;Kealp9op9qgipmwDKYqk8AExm35Ps8E8FpkbbabawaipmbezHdiOAlvCXorQLpkbbabcafhbadclfgdae6mbkkk9teiucbcbydj:G:cjbgeabcifc98GfgbBdj:G:cjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaikkxebcj:Gdklz:zbb";
+      var detector = new Uint8Array([
+        0,
+        97,
+        115,
+        109,
+        1,
+        0,
+        0,
+        0,
+        1,
+        4,
+        1,
+        96,
+        0,
+        0,
+        3,
+        3,
+        2,
+        0,
+        0,
+        5,
+        3,
+        1,
+        0,
+        1,
+        12,
+        1,
+        0,
+        10,
+        22,
+        2,
+        12,
+        0,
+        65,
+        0,
+        65,
+        0,
+        65,
+        0,
+        252,
+        10,
+        0,
+        0,
+        11,
+        7,
+        0,
+        65,
+        0,
+        253,
+        15,
+        26,
+        11
+      ]);
+      var wasmpack = new Uint8Array([
+        32,
+        0,
+        65,
+        2,
+        1,
+        106,
+        34,
+        33,
+        3,
+        128,
+        11,
+        4,
+        13,
+        64,
+        6,
+        253,
+        10,
+        7,
+        15,
+        116,
+        127,
+        5,
+        8,
+        12,
+        40,
+        16,
+        19,
+        54,
+        20,
+        9,
+        27,
+        255,
+        113,
+        17,
+        42,
+        67,
+        24,
+        23,
+        146,
+        148,
+        18,
+        14,
+        22,
+        45,
+        70,
+        69,
+        56,
+        114,
+        101,
+        21,
+        25,
+        63,
+        75,
+        136,
+        108,
+        28,
+        118,
+        29,
+        73,
+        115
+      ]);
+      if (typeof WebAssembly !== "object") {
+        return {
+          supported: false
+        };
+      }
+      var wasm = WebAssembly.validate(detector) ? unpack(wasm_simd) : unpack(wasm_base);
+      var instance;
+      var ready = WebAssembly.instantiate(wasm, {}).then(function(result) {
+        instance = result.instance;
+        instance.exports.__wasm_call_ctors();
+      });
+      function unpack(data) {
+        var result = new Uint8Array(data.length);
+        for (var i = 0; i < data.length; ++i) {
+          var ch = data.charCodeAt(i);
+          result[i] = ch > 96 ? ch - 97 : ch > 64 ? ch - 39 : ch + 4;
+        }
+        var write = 0;
+        for (var i = 0; i < data.length; ++i) {
+          result[write++] = result[i] < 60 ? wasmpack[result[i]] : (result[i] - 60) * 64 + result[++i];
+        }
+        return result.buffer.slice(0, write);
+      }
+      function decode(instance2, fun, target, count, size, source, filter) {
+        var sbrk = instance2.exports.sbrk;
+        var count4 = count + 3 & ~3;
+        var tp = sbrk(count4 * size);
+        var sp = sbrk(source.length);
+        var heap = new Uint8Array(instance2.exports.memory.buffer);
+        heap.set(source, sp);
+        var res = fun(tp, count, size, sp, source.length);
+        if (res == 0 && filter) {
+          filter(tp, count4, size);
+        }
+        target.set(heap.subarray(tp, tp + count * size));
+        sbrk(tp - sbrk(0));
+        if (res != 0) {
+          throw new Error("Malformed buffer data: " + res);
+        }
+      }
+      var filters = {
+        NONE: "",
+        OCTAHEDRAL: "meshopt_decodeFilterOct",
+        QUATERNION: "meshopt_decodeFilterQuat",
+        EXPONENTIAL: "meshopt_decodeFilterExp",
+        COLOR: "meshopt_decodeFilterColor"
+      };
+      var decoders = {
+        ATTRIBUTES: "meshopt_decodeVertexBuffer",
+        TRIANGLES: "meshopt_decodeIndexBuffer",
+        INDICES: "meshopt_decodeIndexSequence"
+      };
+      var workers = [];
+      var requestId = 0;
+      function createWorker(url) {
+        var worker = {
+          object: new Worker(url),
+          pending: 0,
+          requests: {}
+        };
+        worker.object.onmessage = function(event) {
+          var data = event.data;
+          worker.pending -= data.count;
+          worker.requests[data.id][data.action](data.value);
+          delete worker.requests[data.id];
+        };
+        return worker;
+      }
+      function initWorkers(count) {
+        var source = "self.ready = WebAssembly.instantiate(new Uint8Array([" + new Uint8Array(wasm) + "]), {}).then(function(result) { result.instance.exports.__wasm_call_ctors(); return result.instance; });self.onmessage = " + workerProcess.name + ";" + decode.toString() + workerProcess.toString();
+        var blob = new Blob([source], { type: "text/javascript" });
+        var url = URL.createObjectURL(blob);
+        for (var i = workers.length; i < count; ++i) {
+          workers[i] = createWorker(url);
+        }
+        for (var i = count; i < workers.length; ++i) {
+          workers[i].object.postMessage({});
+        }
+        workers.length = count;
+        URL.revokeObjectURL(url);
+      }
+      function decodeWorker(count, size, source, mode, filter) {
+        var worker = workers[0];
+        for (var i = 1; i < workers.length; ++i) {
+          if (workers[i].pending < worker.pending) {
+            worker = workers[i];
+          }
+        }
+        return new Promise(function(resolve, reject) {
+          var data = new Uint8Array(source);
+          var id2 = ++requestId;
+          worker.pending += count;
+          worker.requests[id2] = { resolve, reject };
+          worker.object.postMessage({ id: id2, count, size, source: data, mode, filter }, [data.buffer]);
+        });
+      }
+      function workerProcess(event) {
+        var data = event.data;
+        self.ready.then(function(instance2) {
+          if (!data.id) {
+            return self.close();
+          }
+          try {
+            var target = new Uint8Array(data.count * data.size);
+            decode(instance2, instance2.exports[data.mode], target, data.count, data.size, data.source, instance2.exports[data.filter]);
+            self.postMessage({ id: data.id, count: data.count, action: "resolve", value: target }, [target.buffer]);
+          } catch (error) {
+            self.postMessage({ id: data.id, count: data.count, action: "reject", value: error });
+          }
+        });
+      }
+      return {
+        ready,
+        supported: true,
+        useWorkers: function(count) {
+          initWorkers(count);
+        },
+        decodeVertexBuffer: function(target, count, size, source, filter) {
+          decode(instance, instance.exports.meshopt_decodeVertexBuffer, target, count, size, source, instance.exports[filters[filter]]);
+        },
+        decodeIndexBuffer: function(target, count, size, source) {
+          decode(instance, instance.exports.meshopt_decodeIndexBuffer, target, count, size, source);
+        },
+        decodeIndexSequence: function(target, count, size, source) {
+          decode(instance, instance.exports.meshopt_decodeIndexSequence, target, count, size, source);
+        },
+        decodeGltfBuffer: function(target, count, size, source, mode, filter) {
+          decode(instance, instance.exports[decoders[mode]], target, count, size, source, instance.exports[filters[filter]]);
+        },
+        decodeGltfBufferAsync: function(count, size, source, mode, filter) {
+          if (workers.length > 0) {
+            return decodeWorker(count, size, source, decoders[mode], filters[filter]);
+          }
+          return ready.then(function() {
+            var target = new Uint8Array(count * size);
+            decode(instance, instance.exports[decoders[mode]], target, count, size, source, instance.exports[filters[filter]]);
+            return target;
+          });
+        }
+      };
+    })();
+  }
+});
+
 // src/capture-scene.ts
 init_portable_identity();
 import { z as z3 } from "zod";
@@ -2984,6 +3362,192 @@ function compileTileflowSky(options) {
   };
 }
 
+// src/models-3d-model.ts
+var tileflowModelParts = Object.freeze({
+  surface: 0,
+  secondary: 1,
+  glass: 2,
+  accent: 3,
+  roof: 4
+});
+var tileflowModelLimits = Object.freeze({
+  /** Levels of detail, nearest first. */
+  levels: 3,
+  /** Vertices of one level. */
+  vertices: 2e5,
+  /** Triangles of one level. */
+  triangles: 2e5,
+  /** Points of the footprint's rings, together. */
+  footprintPoints: 4096,
+  /** Half the model's widest extent, in metres. */
+  radius: 2e3,
+  /** The model's height, in metres. */
+  height: 1e3,
+  /** Models in one prepared file, as a landmark tile holds them. */
+  models: 512,
+  /** Bytes of one prepared file. */
+  bytes: 16 * 1024 * 1024
+});
+var tileflowModelVertexBytes = 16;
+function tileflowInsideRings(rings, px, py) {
+  for (const ring of rings) {
+    let inside = false;
+    for (let a = 0, b = ring.length - 2; a < ring.length; b = a, a += 2) {
+      const ax = ring[a];
+      const ay = ring[a + 1];
+      const bx = ring[b];
+      const by = ring[b + 1];
+      if (ay > py !== by > py && px < (bx - ax) * (py - ay) / (by - ay) + ax) inside = !inside;
+    }
+    if (inside) return true;
+  }
+  return false;
+}
+function tileflowRingsOverlap(outline, footprints, margin) {
+  for (const footprint of footprints) {
+    const [fl, ft, fr, fb] = boxOf(footprint);
+    for (const ring of outline) {
+      const [left, top, right, bottom] = boxOf(ring);
+      if (left > fr - margin || right < fl + margin || top > fb - margin || bottom < ft + margin)
+        continue;
+      if (reachesInto(ring, footprint, margin) || reachesInto(footprint, ring, margin)) return true;
+    }
+  }
+  return false;
+}
+function reachesInto(ring, into, margin) {
+  const deep = (x, y) => tileflowInsideRings([into], x, y) && distanceToRing(into, x, y) > margin;
+  for (let a = 0; a + 1 < ring.length; a += 2) if (deep(ring[a], ring[a + 1])) return true;
+  for (let a = 0, b = ring.length - 2; a < ring.length; b = a, a += 2) {
+    const [ax, ay, bx, by] = [ring[b], ring[b + 1], ring[a], ring[a + 1]];
+    const cuts = [0, 1];
+    for (let c = 0, d = into.length - 2; c < into.length; d = c, c += 2) {
+      const t = crossingOf(ax, ay, bx, by, into[d], into[d + 1], into[c], into[c + 1]);
+      if (t !== void 0) cuts.push(t);
+    }
+    if (cuts.length === 2) continue;
+    cuts.sort((p, q) => p - q);
+    for (let at = 1; at < cuts.length; at += 1) {
+      const t = (cuts[at - 1] + cuts[at]) / 2;
+      if (deep(ax + (bx - ax) * t, ay + (by - ay) * t)) return true;
+    }
+  }
+  return false;
+}
+function crossingOf(ax, ay, bx, by, cx, cy, dx, dy) {
+  const rx = bx - ax;
+  const ry = by - ay;
+  const sx = dx - cx;
+  const sy = dy - cy;
+  const denominator = rx * sy - ry * sx;
+  if (denominator === 0) return void 0;
+  const t = ((cx - ax) * sy - (cy - ay) * sx) / denominator;
+  const u = ((cx - ax) * ry - (cy - ay) * rx) / denominator;
+  return t > 0 && t < 1 && u >= 0 && u <= 1 ? t : void 0;
+}
+function distanceToRing(ring, px, py) {
+  let nearest = Infinity;
+  for (let a = 0, b = ring.length - 2; a < ring.length; b = a, a += 2) {
+    const [ax, ay, bx, by] = [ring[b], ring[b + 1], ring[a], ring[a + 1]];
+    const length = (bx - ax) ** 2 + (by - ay) ** 2;
+    const t = length > 0 ? Math.max(0, Math.min(1, ((px - ax) * (bx - ax) + (py - ay) * (by - ay)) / length)) : 0;
+    nearest = Math.min(nearest, Math.hypot(px - (ax + (bx - ax) * t), py - (ay + (by - ay) * t)));
+  }
+  return nearest;
+}
+function boxOf(ring) {
+  let [left, top, right, bottom] = [Infinity, Infinity, -Infinity, -Infinity];
+  for (let at = 0; at + 1 < ring.length; at += 2) {
+    left = Math.min(left, ring[at]);
+    right = Math.max(right, ring[at]);
+    top = Math.min(top, ring[at + 1]);
+    bottom = Math.max(bottom, ring[at + 1]);
+  }
+  return [left, top, right, bottom];
+}
+
+// src/buildings-3d-design.ts
+var tileflowBuildingsMetadataKey = "tileflow:buildings";
+var tileflowDefaultBuildings3DDesign = Object.freeze({
+  source: "tileflow",
+  layers: Object.freeze({ building: "building", places: "poi" }),
+  color: "#d8d0c0",
+  edges: 0,
+  lighting: "style",
+  colorVariation: 0,
+  verticalGradient: true,
+  nightLight: 0,
+  windows: false,
+  shadows: false,
+  occlusion: false
+});
+function tileflowBuildingsMetadata(design) {
+  return { version: 1, ...design };
+}
+function readTileflowBuildings3D(metadata) {
+  if (!isRecord(metadata)) return void 0;
+  const value = metadata[tileflowBuildingsMetadataKey];
+  if (!isRecord(value) || value.version !== 1) return void 0;
+  const { source, layers, color: color3 } = value;
+  if (typeof source !== "string" || !isRecord(layers) || typeof layers.building !== "string")
+    return void 0;
+  if (typeof color3 !== "string" && !Array.isArray(color3)) return void 0;
+  const within = (number, high, fallback) => typeof number === "number" && number >= 0 && number <= high ? number : fallback;
+  return {
+    source,
+    layers: {
+      building: layers.building,
+      ...typeof layers.places === "string" ? { places: layers.places } : {}
+    },
+    color: color3,
+    edges: within(value.edges, 1, 0),
+    lighting: value.lighting === "sun" ? "sun" : "style",
+    colorVariation: within(value.colorVariation, 1, 0),
+    verticalGradient: value.verticalGradient !== false,
+    ...typeof value.edgeColor === "string" ? { edgeColor: value.edgeColor } : {},
+    nightLight: within(value.nightLight, 2, 0),
+    windows: value.windows === true,
+    shadows: value.shadows === true,
+    occlusion: value.occlusion === true,
+    ...modelsOf(value.models),
+    ...modelColorsOf(value.modelColors),
+    ...landmarksOf(value.landmarks)
+  };
+}
+var modelId = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var tileflowBuildingModelPlacementLimit = 256;
+function modelsOf(value) {
+  if (!Array.isArray(value)) return {};
+  const models = [];
+  for (const entry of value.slice(0, tileflowBuildingModelPlacementLimit)) {
+    if (!isRecord(entry)) continue;
+    const { model, url, at, heading } = entry;
+    if (typeof model !== "string" || !modelId.test(model) || typeof url !== "string" || !url)
+      continue;
+    if (!Array.isArray(at) || at.length !== 2) continue;
+    const [longitude, latitude] = at;
+    if (typeof longitude !== "number" || typeof latitude !== "number" || !(longitude >= -180 && longitude <= 180) || !(latitude >= -85 && latitude <= 85))
+      continue;
+    const turn = typeof heading === "number" && Number.isFinite(heading) ? heading : 0;
+    models.push({ model, url, at: [longitude, latitude], heading: (turn % 360 + 360) % 360 });
+  }
+  return models.length > 0 ? { models } : {};
+}
+function modelColorsOf(value) {
+  if (!isRecord(value)) return {};
+  const colors = {};
+  for (const part of Object.keys(tileflowModelParts))
+    if (typeof value[part] === "string") colors[part] = value[part];
+  return Object.keys(colors).length > 0 ? { modelColors: colors } : {};
+}
+function landmarksOf(value) {
+  if (!isRecord(value) || typeof value.url !== "string" || !value.url) return {};
+  return { landmarks: { url: value.url } };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/data/world-generation.ts
 var tileflowWorldGeneration = "v1";
 var tileflowWorldTileJsonUrl = "https://api.tileflow.dev/tiles/world/tiles.json";
@@ -3075,6 +3639,7 @@ var canonicalFields = {
   markings: "markings",
   minHeight: "min_height",
   minZoom: "min_zoom",
+  mode: "mode",
   mtbScale: "mtb_scale",
   name: "name",
   nameEnglish: "name:en",
@@ -3872,7 +4437,16 @@ var tileflowBathymetrySourceId = "tileflow-bathymetry";
 var tileflowBathymetryDemSourceId = "tileflow-bathymetry-dem";
 var tileflowNauticalSourceId = "tileflow-nautical";
 var tileflowBathymetryV1Schema = Object.freeze({
-  fields: Object.freeze({ minDepth: "min_depth", sortKey: "sort_key" }),
+  fields: Object.freeze({
+    class: "class",
+    depth: "depth",
+    id: "id",
+    maxZoom: "max_zoom",
+    minDepth: "min_depth",
+    minZoom: "min_zoom",
+    name: "name",
+    sortKey: "sort_key"
+  }),
   layer: "bathymetry",
   layers: Object.freeze({
     bands: "bathymetry",
@@ -3937,6 +4511,7 @@ var tileflowNauticalV1Schema = Object.freeze({
   product: "nautical-v1",
   schemaVersion: 1
 });
+var tileflowBathymetryNameLayerLimits = Object.freeze({ maxZoomRanges: 128 });
 function bathymetry(options = {}) {
   return { type: "bathymetry", ...cloneJson(options) };
 }
@@ -3979,6 +4554,7 @@ function resolveBathymetry(input, apiBaseUrl) {
     ...advanced?.contours === void 0 ? {} : { contours: advanced.contours },
     display,
     ...advanced?.labels === void 0 ? {} : { labels: advanced.labels },
+    ...advanced?.vectorLayers === void 0 ? {} : { vectorLayers: cloneJson(advanced.vectorLayers) },
     ...reliefVisible ? { relief: resolveBathymetryRelief(reliefConfig ?? {}, apiBaseUrl) } : {},
     ...usesVector ? {
       vector: resolveMarineSource({
@@ -4153,20 +4729,20 @@ function createTileflowLineBackgroundFontStack(source, metrics = {}) {
   return stack;
 }
 function parseTileflowLineBackgroundFontStack(stack) {
-  const match2 = STACK_PATTERN.exec(stack);
-  if (!match2 || stack.length > MAX_STACK_LENGTH || !SOURCE_PATTERN.test(match2[1]))
+  const match3 = STACK_PATTERN.exec(stack);
+  if (!match3 || stack.length > MAX_STACK_LENGTH || !SOURCE_PATTERN.test(match3[1]))
     return void 0;
   const metrics = {
-    letterSpacing: Number(match2[2]) / 1e3,
-    lineHeight: Number(match2[3]) / 1e3,
-    padding: Number(match2[4]) / 1e3
+    letterSpacing: Number(match3[2]) / 1e3,
+    lineHeight: Number(match3[3]) / 1e3,
+    padding: Number(match3[4]) / 1e3
   };
   try {
     const normalized = normalizeTileflowLineBackgroundMetrics(metrics);
-    if (`lines-v1-t${thousandths(normalized.letterSpacing)}-l${thousandths(normalized.lineHeight)}-p${thousandths(normalized.padding)}` !== stack.slice(match2[1].length + 1)) {
+    if (`lines-v1-t${thousandths(normalized.letterSpacing)}-l${thousandths(normalized.lineHeight)}-p${thousandths(normalized.padding)}` !== stack.slice(match3[1].length + 1)) {
       return void 0;
     }
-    return { metrics: normalized, source: match2[1] };
+    return { metrics: normalized, source: match3[1] };
   } catch {
     return void 0;
   }
@@ -4276,15 +4852,15 @@ var GlyphReader = class {
   varint() {
     let result = 0;
     let shift = 0;
-    let byte;
+    let byte2;
     do {
       if (this.position >= this.bytes.length || shift > 49) {
         throw new RangeError("Invalid glyph PBF varint.");
       }
-      byte = this.bytes[this.position++];
-      result += (byte & 127) * 2 ** shift;
+      byte2 = this.bytes[this.position++];
+      result += (byte2 & 127) * 2 ** shift;
       shift += 7;
-    } while (byte & 128);
+    } while (byte2 & 128);
     return result;
   }
   signed() {
@@ -4731,10 +5307,10 @@ function mergeTileflowDesign(base, ...overlays) {
 }
 function mergeValue(base, overlay) {
   if (overlay === void 0) return cloneJson3(base);
-  if (Array.isArray(overlay) || isTileflowExpression(overlay) || isTileflowThemeValueNode(overlay) || isTileflowZoomValue(overlay) || !isRecord2(overlay)) {
+  if (Array.isArray(overlay) || isTileflowExpression(overlay) || isTileflowThemeValueNode(overlay) || isTileflowZoomValue(overlay) || !isRecord3(overlay)) {
     return cloneJson3(overlay);
   }
-  const baseRecord = isRecord2(base) ? base : {};
+  const baseRecord = isRecord3(base) ? base : {};
   const result = {};
   for (const key of /* @__PURE__ */ new Set([...Object.keys(baseRecord), ...Object.keys(overlay)])) {
     const overlayValue = overlay[key];
@@ -4750,7 +5326,7 @@ function cloneJson3(value) {
   if (value === void 0) return value;
   return JSON.parse(JSON.stringify(value));
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -4854,13 +5430,13 @@ function tileflowVegetationMetadata(vegetation2) {
   return { version: 1, ...vegetation2 };
 }
 function readTileflowVegetation3D(metadata) {
-  if (!isRecord3(metadata)) return void 0;
+  if (!isRecord4(metadata)) return void 0;
   const value = metadata[tileflowVegetationMetadataKey];
-  if (!isRecord3(value) || value.version !== 1) return void 0;
+  if (!isRecord4(value) || value.version !== 1) return void 0;
   const { source, layers, fields, colors, heightScale, crownScale, unknownForms, regions: regions2 } = value;
-  if (typeof source !== "string" || !isRecord3(layers) || typeof layers.tree !== "string")
+  if (typeof source !== "string" || !isRecord4(layers) || typeof layers.tree !== "string")
     return void 0;
-  if (!isRecord3(fields) || !isRecord3(colors) || typeof colors.bark !== "string") return void 0;
+  if (!isRecord4(fields) || !isRecord4(colors) || typeof colors.bark !== "string") return void 0;
   const palette = (list) => Array.isArray(list) && list.length > 0 && list.every((entry) => typeof entry === "string") ? list : void 0;
   const broadleaf = palette(colors.broadleaf);
   const conifer = palette(colors.conifer);
@@ -4869,18 +5445,18 @@ function readTileflowVegetation3D(metadata) {
   const scale = (number) => typeof number === "number" && number > 0 && number <= 10 ? number : 1;
   const mix2 = tileflowTreeFormMixProblem(unknownForms) === void 0 ? unknownForms : void 0;
   const models = Object.fromEntries(
-    Object.entries(isRecord3(value.models) ? value.models : {}).filter(
-      ([id2, model]) => tileflowTreeModelIdPattern.test(id2) && isRecord3(model) && typeof model.near === "string" && (model.far === void 0 || typeof model.far === "string")
+    Object.entries(isRecord4(value.models) ? value.models : {}).filter(
+      ([id2, model]) => tileflowTreeModelIdPattern.test(id2) && isRecord4(model) && typeof model.near === "string" && (model.far === void 0 || typeof model.far === "string")
     ).slice(0, 16).map(([id2, model]) => {
       const { near, far } = model;
       return [id2, far === void 0 ? { near } : { near, far }];
     })
   );
-  const ownScales = isRecord3(value.forms) ? value.forms : {};
+  const ownScales = isRecord4(value.forms) ? value.forms : {};
   const forms = Object.fromEntries(
     tileflowTreeForms.flatMap((form) => {
       const own = ownScales[form];
-      if (!isRecord3(own)) return [];
+      if (!isRecord4(own)) return [];
       const drawn = Array.isArray(own.models) ? [...new Set(own.models)].filter((id2) => typeof id2 === "string" && id2 in models).slice(0, 4) : [];
       return [
         [
@@ -4897,7 +5473,7 @@ function readTileflowVegetation3D(metadata) {
   const finish = tileflowTreeFinishes.find((name) => name === value.finish) ?? "faceted";
   const edges = typeof value.edges === "number" && value.edges >= 0 && value.edges <= 1 ? value.edges : 0;
   const zones = Array.isArray(regions2) ? regions2.filter(
-    (region) => isRecord3(region) && tileflowTreeRegionProblem(region) === void 0
+    (region) => isRecord4(region) && tileflowTreeRegionProblem(region) === void 0
   ) : [];
   const named = Object.fromEntries(
     Object.entries(tileflowWorldTreeFields).map(([key, fallback]) => [
@@ -4926,7 +5502,7 @@ function readTileflowVegetation3D(metadata) {
   };
 }
 function tileflowTreeRegionProblem(region) {
-  if (!isRecord3(region)) return "a region is an object with bounds and unknownForms";
+  if (!isRecord4(region)) return "a region is an object with bounds and unknownForms";
   const bounds = region.bounds;
   if (!Array.isArray(bounds) || bounds.length !== 4 || !bounds.every((value) => typeof value === "number" && Number.isFinite(value)))
     return "bounds are [west, south, east, north] in degrees";
@@ -4937,7 +5513,7 @@ function tileflowTreeRegionProblem(region) {
   const mix2 = tileflowTreeFormMixProblem(region.unknownForms);
   return mix2 ? `unknownForms: ${mix2}` : void 0;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -5004,7 +5580,7 @@ function compileVegetation(request, context) {
 }
 function tileflowVegetationDescription(request, context) {
   const { schema } = context.data;
-  if (request?.enabled === false || (request?.mode ?? "3d") !== "3d" || !schema.layers.tree)
+  if (request?.enabled === false || request?.mode === "flat" || !schema.layers.tree)
     return void 0;
   const tree = context.colors.vegetation.tree;
   const style = request?.threeDimensional ?? {};
@@ -5067,153 +5643,6 @@ function tileflowVegetationDescription(request, context) {
   };
 }
 
-// src/buildings-3d-design.ts
-var tileflowBuildingsMetadataKey = "tileflow:buildings";
-var tileflowDefaultBuildings3DDesign = Object.freeze({
-  source: "tileflow",
-  layers: Object.freeze({ building: "building", places: "poi" }),
-  color: "#d8d0c0",
-  edges: 1,
-  nightLight: 1,
-  windows: false,
-  shadows: true,
-  occlusion: true
-});
-function tileflowBuildingsMetadata(design) {
-  return { version: 1, ...design };
-}
-function readTileflowBuildings3D(metadata) {
-  if (!isRecord4(metadata)) return void 0;
-  const value = metadata[tileflowBuildingsMetadataKey];
-  if (!isRecord4(value) || value.version !== 1) return void 0;
-  const { source, layers, color: color3 } = value;
-  if (typeof source !== "string" || !isRecord4(layers) || typeof layers.building !== "string")
-    return void 0;
-  if (typeof color3 !== "string" && !Array.isArray(color3)) return void 0;
-  const within = (number, high, fallback) => typeof number === "number" && number >= 0 && number <= high ? number : fallback;
-  return {
-    source,
-    layers: {
-      building: layers.building,
-      ...typeof layers.places === "string" ? { places: layers.places } : {}
-    },
-    color: color3,
-    edges: within(value.edges, 1, 1),
-    ...typeof value.edgeColor === "string" ? { edgeColor: value.edgeColor } : {},
-    nightLight: within(value.nightLight, 2, 1),
-    windows: value.windows === true,
-    shadows: value.shadows !== false,
-    occlusion: value.occlusion !== false
-  };
-}
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/street-lights.ts
-init_theme_blend();
-var tileflowStreetLightsMetadataKey = "tileflow:street-lights";
-var tileflowDefaultStreetLightsDesign = Object.freeze({
-  source: "tileflow",
-  layers: Object.freeze({
-    streetFurniture: "street_furniture",
-    transportation: "transportation",
-    sidewalk: "sidewalk"
-  }),
-  estimate: "lit",
-  color: "#ffcf8f",
-  intensity: 1
-});
-function tileflowStreetLightsMetadata(design) {
-  return { version: 1, ...design };
-}
-function readTileflowStreetLights(metadata) {
-  if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata))
-    return void 0;
-  const value = metadata[tileflowStreetLightsMetadataKey];
-  if (typeof value !== "object" || value === null || value.version !== 1) return void 0;
-  const layers = value.layers;
-  if (typeof value.source !== "string" || typeof layers?.streetFurniture !== "string" || typeof layers.transportation !== "string")
-    return void 0;
-  const estimate = ["lit", "streets", "none"].find((name) => name === value.estimate);
-  const intensity = typeof value.intensity === "number" && value.intensity >= 0 && value.intensity <= 2 ? value.intensity : 1;
-  return {
-    source: value.source,
-    layers: {
-      streetFurniture: layers.streetFurniture,
-      transportation: layers.transportation,
-      ...typeof layers.sidewalk === "string" ? { sidewalk: layers.sidewalk } : {}
-    },
-    estimate: estimate ?? "lit",
-    color: typeof value.color === "string" && tileflowColourChannels(value.color) ? value.color : tileflowDefaultStreetLightsDesign.color,
-    intensity
-  };
-}
-
-// src/cartography/scene-3d-metadata.ts
-init_values();
-var colourSources = [
-  ["tileflow-buildings-render-extrusion", "fill-extrusion-color"],
-  ["tileflow-buildings-3d", "fill-extrusion-color"],
-  ["tileflow-buildings-fill", "fill-color"]
-];
-function tileflowBuildings3DDesignOf(module, context, layers) {
-  const config = isRecord5(module) ? module : {};
-  if (config.enabled === false) return void 0;
-  const style = config.threeDimensional ?? {};
-  let color3;
-  for (const [id2, property] of colourSources) {
-    const value = layers.find((layer) => layer.id === id2)?.paint?.[property];
-    if (typeof value === "string" || Array.isArray(value)) {
-      color3 = value;
-      break;
-    }
-  }
-  const number = (value, fallback) => {
-    const resolved = value === void 0 ? void 0 : toMapLibreStyleValue(value);
-    return typeof resolved === "number" ? resolved : fallback;
-  };
-  const edgeColor = style.edgeColor === void 0 ? void 0 : toMapLibreStyleValue(style.edgeColor);
-  return {
-    source: context.data.sourceId,
-    layers: {
-      building: context.data.schema.layers.building,
-      ...context.data.schema.layers.poi ? { places: context.data.schema.layers.poi } : {}
-    },
-    color: color3 ?? context.colors.buildings.generic,
-    edges: number(style.edges, 1),
-    ...typeof edgeColor === "string" ? { edgeColor } : {},
-    nightLight: number(style.nightLight, 1),
-    windows: style.windows === true,
-    shadows: style.shadows !== false,
-    occlusion: style.occlusion !== false
-  };
-}
-function tileflowStreetLightsDesignOf(module, context) {
-  const config = isRecord5(module) ? module : {};
-  const layers = context.data.schema.layers;
-  const style = config.streetLights ?? {};
-  if (config.enabled === false || style.enabled === false || !layers.streetFurniture)
-    return void 0;
-  const color3 = style.color === void 0 ? void 0 : toMapLibreStyleValue(style.color);
-  const intensity = style.intensity === void 0 ? void 0 : toMapLibreStyleValue(style.intensity);
-  const estimate = style.estimate;
-  return {
-    source: context.data.sourceId,
-    layers: {
-      streetFurniture: layers.streetFurniture,
-      transportation: layers.road,
-      ...layers.sidewalk ? { sidewalk: layers.sidewalk } : {}
-    },
-    estimate: estimate === "streets" || estimate === "none" || estimate === "lit" ? estimate : "lit",
-    color: typeof color3 === "string" ? color3 : tileflowDefaultStreetLightsDesign.color,
-    intensity: typeof intensity === "number" ? intensity : 1
-  };
-}
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 // src/cartography/contributions.ts
 var tileflowLayerSlots = [
   "background",
@@ -5776,7 +6205,21 @@ function buildingColorExpression(context) {
     colors.destination,
     ["==", ["coalesce", ["get", fields.buildingTone], ""], "commercial"],
     colors.commercial,
-    colors.generic
+    // Without a tone, World's use class: housing, shops and offices, public buildings and works
+    // each take their theme colour; a shed, a garage or an unknown use the generic one.
+    [
+      "match",
+      ["coalesce", ["get", fields.class], ""],
+      "residential",
+      colors.residential,
+      "commercial",
+      colors.commercial,
+      ["civic", "education", "entertainment", "medical", "military", "religious", "transportation"],
+      colors.civic,
+      ["agricultural", "industrial", "service"],
+      colors.industrial,
+      colors.generic
+    ]
   ];
 }
 function buildingVisibilityFilter() {
@@ -6041,6 +6484,9 @@ init_values();
 function labelField(language, context) {
   return expression(labelFieldExpression(language, context));
 }
+function labelNameFields(language, context) {
+  return labelFieldExpression(language, context).slice(1).map((entry) => entry[1]);
+}
 function labelFieldExpression(language, context) {
   const fields = context.data.schema.fields;
   if (language === "local") {
@@ -6900,12 +7346,12 @@ function compileLand(request, context) {
     if (name === "recreation") continue;
     appendLanduse(name, classes);
   }
-  for (const [name, match2] of landcoverClasses) {
+  for (const [name, match3] of landcoverClasses) {
     const style = config.landcover?.[name];
     if (!style) continue;
     const protectedSource = name === "protected";
     const sourceLayer = protectedSource ? schema.layers.park : schema.layers.landcover;
-    const filter = protectedSource && schema.semantics.parkLayer === "protected-only" ? void 0 : landcoverFilter(classField, subclassField, match2);
+    const filter = protectedSource && schema.semantics.parkLayer === "protected-only" ? void 0 : landcoverFilter(classField, subclassField, match3);
     for (const area of createAreaLayers(
       {
         id: `tileflow-landcover-${name}`,
@@ -6961,11 +7407,11 @@ function compileLand(request, context) {
 function classFilter2(field2, classes) {
   return ["match", ["get", field2], classes, true, false];
 }
-function landcoverFilter(classField, subclassField, match2) {
-  const filter = classFilter2(classField, match2.class);
-  if (match2.subclass) return ["all", filter, classFilter2(subclassField, match2.subclass)];
-  if (match2.excludeSubclass) {
-    return ["all", filter, ["!", classFilter2(subclassField, match2.excludeSubclass)]];
+function landcoverFilter(classField, subclassField, match3) {
+  const filter = classFilter2(classField, match3.class);
+  if (match3.subclass) return ["all", filter, classFilter2(subclassField, match3.subclass)];
+  if (match3.excludeSubclass) {
+    return ["all", filter, ["!", classFilter2(subclassField, match3.excludeSubclass)]];
   }
   return filter;
 }
@@ -7642,184 +8088,595 @@ function lightLabel(fields) {
     ["case", ["has", fields.name], ["concat", " ", ["to-string", ["get", fields.name]]], ""]
   ]);
 }
-
-// src/types.ts
-var tileflowPoiCategories = [
-  "arts-entertainment",
-  "education",
-  "food-drink",
-  "landmark",
-  "lodging",
-  "medical",
-  "park-nature",
-  "public-services",
-  "religion",
-  "retail",
-  "sport-leisure",
-  "transport",
-  "visitor-amenity"
-];
-
-// src/modules/poi/index.ts
-var tileflowPoiImageRoles = Object.freeze({
-  "arts-entertainment": { fallback: "culture", token: "poi.arts-entertainment" },
-  education: { fallback: "education", token: "poi.education" },
-  "food-drink": { fallback: "food", token: "poi.food-drink" },
-  landmark: { fallback: "culture", token: "poi.landmark" },
-  lodging: { fallback: "lodging", token: "poi.lodging" },
-  medical: { fallback: "health", token: "poi.medical" },
-  "park-nature": { fallback: "services", token: "poi.park-nature" },
-  "public-services": { fallback: "services", token: "poi.public-services" },
-  religion: { fallback: "culture", token: "poi.religion" },
-  retail: { fallback: "shopping", token: "poi.retail" },
-  "sport-leisure": { fallback: "culture", token: "poi.sport-leisure" },
-  transport: { fallback: "major-transit", token: "poi.transport" },
-  "visitor-amenity": { fallback: "services", token: "poi.visitor-amenity" }
-});
-function poi(options = {}) {
-  return { type: "poi", ...cloneJson13(options) };
+
+// src/types.ts
+var tileflowPoiCategories = [
+  "arts-entertainment",
+  "education",
+  "food-drink",
+  "landmark",
+  "lodging",
+  "medical",
+  "park-nature",
+  "public-services",
+  "religion",
+  "retail",
+  "sport-leisure",
+  "transport",
+  "visitor-amenity"
+];
+
+// src/modules/poi/index.ts
+var tileflowPoiImageRoles = Object.freeze({
+  "arts-entertainment": { fallback: "culture", token: "poi.arts-entertainment" },
+  education: { fallback: "education", token: "poi.education" },
+  "food-drink": { fallback: "food", token: "poi.food-drink" },
+  landmark: { fallback: "culture", token: "poi.landmark" },
+  lodging: { fallback: "lodging", token: "poi.lodging" },
+  medical: { fallback: "health", token: "poi.medical" },
+  "park-nature": { fallback: "services", token: "poi.park-nature" },
+  "public-services": { fallback: "services", token: "poi.public-services" },
+  religion: { fallback: "culture", token: "poi.religion" },
+  retail: { fallback: "shopping", token: "poi.retail" },
+  "sport-leisure": { fallback: "culture", token: "poi.sport-leisure" },
+  transport: { fallback: "major-transit", token: "poi.transport" },
+  "visitor-amenity": { fallback: "services", token: "poi.visitor-amenity" }
+});
+var tileflowPoiIconOnlyTypes = Object.freeze([
+  "parking",
+  "parking_garage",
+  "parking_lot",
+  "public_restroom"
+]);
+function poi(options = {}) {
+  return { type: "poi", ...cloneJson13(options) };
+}
+function resolvePoi(request) {
+  return {
+    categories: [...new Set(request?.categories ?? tileflowPoiCategories)],
+    color: request?.color ?? "uniform",
+    density: request?.density ?? 3,
+    icons: request?.icons ?? true,
+    labels: request?.labels ?? true,
+    minZoom: request?.minZoom ?? 0,
+    placement: {
+      coupleIconAndLabel: request?.placement?.coupleIconAndLabel ?? false,
+      iconOnlyTypes: [...request?.placement?.iconOnlyTypes ?? tileflowPoiIconOnlyTypes],
+      iconPadding: request?.placement?.iconPadding ?? 2,
+      order: request?.placement?.order ?? "importance",
+      ...request?.placement?.prominentRank === void 0 ? {} : { prominentRank: request.placement.prominentRank },
+      textPadding: request?.placement?.textPadding ?? 2
+    }
+  };
+}
+function cloneJson13(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/poi/compiler.ts
+init_values();
+
+// src/modules/poi/placement.ts
+init_expression_operators();
+var tileflowPoiFeatureVaryingProperties = Object.freeze({
+  circle: Object.freeze({
+    "circle-blur": 0,
+    "circle-color": "#000000",
+    "circle-opacity": 1,
+    "circle-radius": 5,
+    "circle-sort-key": void 0,
+    "circle-stroke-color": "#000000",
+    "circle-stroke-opacity": 1,
+    "circle-stroke-width": 0
+  }),
+  symbol: Object.freeze({
+    "icon-anchor": "center",
+    "icon-color": "#000000",
+    "icon-halo-blur": 0,
+    "icon-halo-color": "rgba(0, 0, 0, 0)",
+    "icon-halo-width": 0,
+    // An empty image draws no icon, so a category without one stays text-only.
+    "icon-image": "",
+    "icon-offset": [0, 0],
+    "icon-opacity": 1,
+    "icon-padding": [2],
+    "icon-rotate": 0,
+    "icon-size": 1,
+    "symbol-sort-key": void 0,
+    "text-anchor": "center",
+    "text-color": "#000000",
+    "text-field": "",
+    // MapLibre can vary `text-font` per feature, but Tileflow prepares glyphs for a static font
+    // stack, so the font stays a layer-wide property.
+    "text-halo-blur": 0,
+    "text-halo-color": "rgba(0, 0, 0, 0)",
+    "text-halo-width": 0,
+    "text-justify": "center",
+    "text-letter-spacing": 0,
+    "text-max-width": 10,
+    "text-offset": [0, 0],
+    "text-opacity": 1,
+    "text-radial-offset": 0,
+    "text-rotate": 0,
+    "text-size": 16,
+    "text-transform": "none",
+    "text-variable-anchor-offset": void 0
+  })
+});
+var tileflowPoiLayerPropertyDefaults = Object.freeze({
+  "circle-pitch-alignment": "viewport",
+  "circle-pitch-scale": "map",
+  "circle-translate": [0, 0],
+  "circle-translate-anchor": "map",
+  "icon-allow-overlap": false,
+  "icon-ignore-placement": false,
+  "icon-keep-upright": false,
+  "icon-optional": false,
+  "icon-pitch-alignment": "auto",
+  "icon-rotation-alignment": "auto",
+  "icon-text-fit": "none",
+  "icon-text-fit-padding": [0, 0, 0, 0],
+  "symbol-avoid-edges": false,
+  "symbol-placement": "point",
+  "symbol-spacing": 250,
+  "symbol-z-order": "auto",
+  "text-allow-overlap": false,
+  "text-ignore-placement": false,
+  "text-keep-upright": true,
+  "text-line-height": 1.2,
+  "text-max-angle": 45,
+  "text-optional": false,
+  "text-padding": 2,
+  "text-pitch-alignment": "auto",
+  "text-rotation-alignment": "auto",
+  visibility: "visible"
+});
+var TileflowPoiPlacementError = class extends Error {
+  code = "TILEFLOW_POI_PLACEMENT_CONFLICT";
+  constructor(message) {
+    super(message);
+    this.name = "TileflowPoiPlacementError";
+  }
+};
+function mergePoiCategoryLayers(entries, options) {
+  const [first] = entries;
+  if (!first) throw new TileflowPoiPlacementError("A POI placement layer needs a category.");
+  const kind = first.layer.type === "circle" ? "circle" : "symbol";
+  const varying = tileflowPoiFeatureVaryingProperties[kind];
+  const categories = entries.map(({ category }) => category);
+  for (const property of ["type", "source", "source-layer", "minzoom", "maxzoom"]) {
+    requireShared(entries, property, (layer) => layer[property]);
+  }
+  const result = {
+    ...first.layer,
+    id: options.id,
+    filter: options.filter
+  };
+  for (const part of ["layout", "paint"]) {
+    const records = entries.map(({ layer }) => asRecord3(layer[part]));
+    const properties = [...new Set(records.flatMap((record2) => Object.keys(record2)))].sort();
+    const merged = {};
+    for (const property of properties) {
+      const fallback = Object.hasOwn(varying, property) ? varying[property] : tileflowPoiLayerPropertyDefaults[property];
+      const values = records.map(
+        (record2) => Object.hasOwn(record2, property) ? record2[property] : fallback
+      );
+      if (values.every((value) => sameJson(value, values[0]))) {
+        if (values[0] !== void 0) merged[property] = values[0];
+        continue;
+      }
+      if (!Object.hasOwn(varying, property)) {
+        throw conflict(entries, property, (layer) => asRecord3(layer[part])[property]);
+      }
+      if (values.some((value) => value === void 0)) {
+        throw new TileflowPoiPlacementError(
+          `POI categories ${categories.join(", ")} set ${property} for only some categories, and MapLibre has no default to fill in for the rest. Set it for every category.`
+        );
+      }
+      merged[property] = matchByCategory(
+        property,
+        categories.map((category, index) => [category, values[index]]),
+        ["get", options.categoryField]
+      );
+    }
+    if (Object.keys(merged).length) result[part] = merged;
+    else delete result[part];
+  }
+  return result;
+}
+function requireShared(entries, property, read) {
+  const value = read(entries[0].layer);
+  if (entries.every(({ layer }) => sameJson(read(layer), value))) return;
+  throw conflict(entries, property, read);
+}
+function conflict(entries, property, read) {
+  const described = entries.map(({ category, layer }) => `${category}: ${JSON.stringify(read(layer)) ?? "unset"}`).join("; ");
+  return new TileflowPoiPlacementError(
+    `POI categories need different ${property} values (${described}), but MapLibre keeps ${property} constant within one layer. Give them the same ${property}, or set placement.order to 'categories' to place each category in its own layer.`
+  );
+}
+function matchByCategory(property, values, input) {
+  const curves = values.map(([, value]) => zoomCurve(value));
+  const present = curves.filter((curve) => curve !== void 0);
+  if (present.length === 0) return match(input, values);
+  const reference = present[0];
+  for (const curve of present) {
+    if (curve.kind !== reference.kind || curve.kind === "interpolate" && reference.kind === "interpolate" && (curve.operator !== reference.operator || !sameJson(curve.interpolation, reference.interpolation))) {
+      throw new TileflowPoiPlacementError(
+        `POI categories use different kinds of zoom curve for ${property}. Use one kind of curve (linear, the same exponential base, or step) for every category, or set placement.order to 'categories'.`
+      );
+    }
+  }
+  const stops = [...new Set(present.flatMap((curve) => curve.stops.map(([zoom3]) => zoom3)))].sort(
+    (left, right) => left - right
+  );
+  const at = (zoom3) => match(
+    input,
+    values.map(([category, value], index) => [
+      category,
+      curves[index] ? evaluateCurve(property, curves[index], zoom3) : value
+    ])
+  );
+  if (reference.kind === "step") {
+    const base = match(
+      input,
+      values.map(([category, value], index) => {
+        const curve = curves[index];
+        return [category, curve?.kind === "step" ? curve.base : value];
+      })
+    );
+    return ["step", ["zoom"], base, ...stops.flatMap((zoom3) => [zoom3, at(zoom3)])];
+  }
+  return [
+    reference.operator,
+    reference.interpolation,
+    ["zoom"],
+    ...stops.flatMap((zoom3) => [zoom3, at(zoom3)])
+  ];
+}
+function match(input, values) {
+  const groups = [];
+  for (const [category, value] of values) {
+    const group = groups.find((candidate) => sameJson(candidate.value, value));
+    if (group) group.categories.push(category);
+    else groups.push({ categories: [category], value });
+  }
+  if (groups.length === 1) return groups[0].value;
+  const fallback = groups.reduce(
+    (largest, group) => group.categories.length > largest.categories.length ? group : largest
+  );
+  return [
+    "match",
+    input,
+    ...groups.filter((group) => group !== fallback).flatMap((group) => [
+      group.categories.length === 1 ? group.categories[0] : group.categories,
+      expressionValue(group.value)
+    ]),
+    expressionValue(fallback.value)
+  ];
+}
+function zoomCurve(value) {
+  if (!Array.isArray(value)) return void 0;
+  const [operator] = value;
+  if ((operator === "interpolate" || operator === "interpolate-hcl" || operator === "interpolate-lab") && isZoomInput3(value[2])) {
+    return {
+      kind: "interpolate",
+      operator,
+      interpolation: value[1],
+      stops: pairs(value.slice(3))
+    };
+  }
+  if (operator === "step" && isZoomInput3(value[1])) {
+    return { kind: "step", base: value[2], stops: pairs(value.slice(3)) };
+  }
+  return void 0;
+}
+function evaluateCurve(property, curve, zoom3) {
+  const { stops } = curve;
+  if (curve.kind === "step") {
+    let value2 = curve.base;
+    for (const [stop, output] of stops) if (stop <= zoom3) value2 = output;
+    return value2;
+  }
+  const exact = stops.find(([stop]) => stop === zoom3);
+  if (exact) return exact[1];
+  if (zoom3 < stops[0][0]) return stops[0][1];
+  if (zoom3 > stops.at(-1)[0]) return stops.at(-1)[1];
+  const upperIndex = stops.findIndex(([stop]) => stop > zoom3);
+  const [lowerZoom, lower] = stops[upperIndex - 1];
+  const [upperZoom, upper] = stops[upperIndex];
+  const t = interpolationFactor(curve.interpolation, zoom3, lowerZoom, upperZoom);
+  const value = interpolateOutput(lower, upper, t);
+  if (value === void 0) {
+    throw new TileflowPoiPlacementError(
+      `POI categories interpolate ${property} between values Tileflow cannot evaluate at zoom ${zoom3}. Give every category the same zoom stops for ${property}, or set placement.order to 'categories'.`
+    );
+  }
+  return value;
+}
+function interpolationFactor(interpolation, zoom3, lower, upper) {
+  const progress = zoom3 - lower;
+  const range2 = upper - lower;
+  if (Array.isArray(interpolation) && interpolation[0] === "exponential") {
+    const base = Number(interpolation[1]);
+    if (base !== 1) return (base ** progress - 1) / (base ** range2 - 1);
+  }
+  return progress / range2;
+}
+function interpolateOutput(lower, upper, t) {
+  if (typeof lower === "number" && typeof upper === "number") {
+    return roundOutput(lower + (upper - lower) * t);
+  }
+  const lowerArray = numericArray(lower);
+  const upperArray = numericArray(upper);
+  if (lowerArray && upperArray && lowerArray.length === upperArray.length) {
+    return [
+      "literal",
+      lowerArray.map((value, index) => roundOutput(value + (upperArray[index] - value) * t))
+    ];
+  }
+  if (isNumericOutput(lower) && isNumericOutput(upper)) {
+    return ["+", lower, ["*", roundOutput(t), ["-", upper, lower]]];
+  }
+  return void 0;
+}
+function isNumericOutput(value) {
+  if (typeof value === "number") return true;
+  if (!Array.isArray(value) || typeof value[0] !== "string") return false;
+  return isMapLibreExpressionOperator(value[0]) && !["literal", "array"].includes(value[0]);
+}
+function numericArray(value) {
+  const array = Array.isArray(value) && value[0] === "literal" && Array.isArray(value[1]) ? value[1] : value;
+  return Array.isArray(array) && array.every((entry) => typeof entry === "number") ? array : void 0;
+}
+function roundOutput(value) {
+  return Math.round(value * 1e6) / 1e6;
+}
+function expressionValue(value) {
+  if (!Array.isArray(value)) return value;
+  if (typeof value[0] === "string" && isMapLibreExpressionOperator(value[0])) return value;
+  return ["literal", value];
+}
+function pairs(values) {
+  const result = [];
+  for (let index = 0; index + 1 < values.length; index += 2) {
+    result.push([values[index], values[index + 1]]);
+  }
+  return result;
+}
+function isZoomInput3(value) {
+  return Array.isArray(value) && value.length === 1 && value[0] === "zoom";
 }
-function resolvePoi(request) {
-  return {
-    categories: [...new Set(request?.categories ?? tileflowPoiCategories)],
-    color: request?.color ?? "uniform",
-    density: request?.density ?? 3,
-    icons: request?.icons ?? true,
-    labels: request?.labels ?? true,
-    minZoom: request?.minZoom ?? 0,
-    placement: {
-      coupleIconAndLabel: request?.placement?.coupleIconAndLabel ?? false,
-      iconPadding: request?.placement?.iconPadding ?? 2,
-      textPadding: request?.placement?.textPadding ?? 2
-    }
-  };
+function sameJson(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
 }
-function cloneJson13(value) {
-  return JSON.parse(JSON.stringify(value));
+function asRecord3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
 // src/modules/poi/compiler.ts
-init_values();
+var representationOrder = {
+  marker: 0,
+  combined: 1,
+  icon: 1,
+  label: 2
+};
 function compilePoi(request, context, language = "auto") {
   if (request?.enabled === false) return [];
   const semantics = resolvePoi(request);
-  const result = [];
+  const selection2 = createPoiSelection(semantics, context, language);
+  const parts = semantics.categories.flatMap(
+    (category) => compileCategory(category, request, semantics, context, language, selection2)
+  );
+  if (semantics.placement.order === "categories") {
+    return parts.map((part) => {
+      const rank = semantics.categories.length - 1 - semantics.categories.indexOf(part.category);
+      const suffix = part.representation === "combined" ? "" : `.${part.representation}`;
+      return poiContribution(
+        `${part.category}${suffix}`,
+        rank * 4 + representationOrder[part.representation],
+        {
+          ...part.layer,
+          id: `tileflow-poi-${part.category}${suffix.replace(".", "-")}`,
+          filter: selection2.filter([part.category], part.representation)
+        }
+      );
+    });
+  }
+  const { prominentRank } = semantics.placement;
+  const filterRank = numericPoiField(context.data.schema.fields.poiFilterRank, 6);
+  return ["marker", "combined", "icon", "label"].flatMap((representation) => {
+    const entries = parts.filter((part) => part.representation === representation);
+    if (entries.length === 0) return [];
+    const suffix = representation === "combined" ? "" : `.${representation}`;
+    const filter = selection2.filter(
+      entries.map(({ category }) => category),
+      representation
+    );
+    const layer = mergePoiCategoryLayers(entries, {
+      categoryField: context.data.schema.fields.poiCategory,
+      filter,
+      id: `tileflow-poi${suffix.replace(".", "-")}`
+    });
+    if (prominentRank === void 0 || representation === "marker") {
+      return [poiContribution(suffix.slice(1), representationOrder[representation], layer)];
+    }
+    return [
+      poiContribution(suffix.slice(1), representationOrder[representation], {
+        ...layer,
+        filter: [...filter, [">", filterRank, prominentRank]]
+      }),
+      poiContribution(`prominent${suffix}`, 400 + representationOrder[representation], {
+        ...layer,
+        id: `tileflow-poi-prominent${suffix.replace(".", "-")}`,
+        filter: [...filter, ["<=", filterRank, prominentRank]]
+      })
+    ];
+  });
+}
+function compileCategory(category, request, semantics, context, language, selection2) {
   const { sourceId: source, schema } = context.data;
-  for (const [index, category] of semantics.categories.entries()) {
-    const requestedCategoryStyle = request?.styles?.[category];
-    const categoryDensity = requestedCategoryStyle?.density ?? semantics.density;
-    const { density: _density, ...categoryStyle } = requestedCategoryStyle ?? {};
-    const categoryColor = semantics.color === "category" ? context.colors.poi[category] ?? context.colors.poi.label : context.colors.poi.label;
-    const defaults4 = {
+  const coupled = semantics.placement.coupleIconAndLabel;
+  const categoryColor = semantics.color === "category" ? context.colors.poi[category] ?? context.colors.poi.label : context.colors.poi.label;
+  const defaults4 = {
+    icon: {
+      optional: !coupled,
+      padding: semantics.placement.iconPadding,
+      size: semantics.minZoom < 17 ? zoom.linear([
+        [semantics.minZoom, 0.85],
+        [17, 1]
+      ]) : 1
+    },
+    text: poiTextStyle(context, {
+      color: categoryColor,
+      field: labelField(language, context),
+      // A coupled POI is its pictogram and its name: it is placed only when both fit.
+      optional: !coupled,
+      padding: semantics.placement.textPadding,
+      size: semantics.minZoom < 17 ? zoom.linear([
+        [semantics.minZoom, 10],
+        [17, 12]
+      ]) : 12
+    })
+  };
+  let style = mergeTileflowDesign(defaults4, request?.styles?.[category] ?? {});
+  const markerStyle = style.marker ? resolveMarkerStyle(style) : void 0;
+  const hidden = style.visible === false;
+  const showText = !hidden && semantics.labels && style.text.visible !== false;
+  const showIcon = !hidden && semantics.icons && style.icon.visible !== false;
+  style = {
+    ...withoutVisibility(style),
+    icon: withoutVisibility(style.icon),
+    text: withoutVisibility(style.text)
+  };
+  if (showIcon && style.icon.image === void 0) {
+    style = {
+      ...style,
       icon: {
-        optional: !semantics.placement.coupleIconAndLabel,
-        padding: semantics.placement.iconPadding,
-        size: semantics.minZoom < 17 ? zoom.linear([
-          [semantics.minZoom, 0.85],
-          [17, 1]
-        ]) : 1
-      },
-      text: poiTextStyle(context, {
-        color: categoryColor,
-        field: labelField(language, context),
-        padding: semantics.placement.textPadding,
-        size: semantics.minZoom < 17 ? zoom.linear([
-          [semantics.minZoom, 10],
-          [17, 12]
-        ]) : 12
-      })
+        ...style.icon,
+        image: resolvePoiImage(category, context, schema.fields.poiIcon)
+      }
     };
-    let style = mergeTileflowDesign(defaults4, categoryStyle);
-    const markerStyle = style.marker ? resolveMarkerStyle(style) : void 0;
-    const showText = semantics.labels && style.text.visible !== false;
-    const showIcon = semantics.icons && style.icon.visible !== false;
-    if (showIcon && style.icon.image === void 0) {
-      style = {
-        ...style,
-        icon: {
-          ...style.icon,
-          image: resolvePoiImage(category, context, schema.fields.poiIcon)
-        }
-      };
-    }
-    style = withPoiTextClearance(style, showText && showIcon);
-    const symbolStyle2 = withoutMarker2(style);
-    if (markerStyle && markerStyle.visible !== false) {
-      const base = createPoiLayer({
-        category,
-        categoryField: schema.fields.poiCategory,
-        density: categoryDensity,
-        filterRankField: schema.fields.poiFilterRank,
-        id: `tileflow-poi-${category}-marker`,
-        minZoom: semantics.minZoom,
-        sizeRankField: schema.fields.poiSizeRank,
-        source,
-        sourceLayer: schema.layers.poi
-      });
-      const markerLayer = applyCircleStyle(
+  }
+  style = withPoiTextClearance(style, showText && showIcon);
+  const symbolStyle2 = withoutMarker2(style);
+  const base = () => ({
+    id: `tileflow-poi-${category}`,
+    type: "symbol",
+    source,
+    "source-layer": schema.layers.poi,
+    minzoom: semantics.minZoom,
+    layout: { "symbol-sort-key": poiSortKey(schema.fields.poiFilterRank, schema.fields.poiSizeRank) }
+  });
+  const parts = [];
+  selection2.register(category, { icon: showIcon, text: showText });
+  if (!hidden && markerStyle && markerStyle.visible !== false) {
+    const markerBase = base();
+    parts.push({
+      category,
+      representation: "marker",
+      layer: applyCircleStyle(
         {
-          ...base,
+          ...markerBase,
           type: "circle",
           layout: {
             "circle-sort-key": poiSortKey(schema.fields.poiFilterRank, schema.fields.poiSizeRank)
           }
         },
         markerStyle
-      );
-      result.push(poiContribution(`${category}.marker`, index * 4, markerLayer));
-    }
-    if (semantics.placement.coupleIconAndLabel && showText && showIcon) {
-      let layer = createPoiLayer({
-        category,
-        categoryField: schema.fields.poiCategory,
-        density: categoryDensity,
-        filterRankField: schema.fields.poiFilterRank,
-        id: `tileflow-poi-${category}`,
-        minZoom: semantics.minZoom,
-        sizeRankField: schema.fields.poiSizeRank,
-        source,
-        sourceLayer: schema.layers.poi
-      });
-      layer = applySymbolStyle(layer, symbolStyle2);
-      result.push(poiContribution(category, index * 4 + 1, layer));
-      continue;
-    }
-    if (showIcon) {
-      const layer = applySymbolStyle(
-        createPoiLayer({
-          category,
-          categoryField: schema.fields.poiCategory,
-          density: categoryDensity,
-          filterRankField: schema.fields.poiFilterRank,
-          id: `tileflow-poi-${category}-icon`,
-          minZoom: semantics.minZoom,
-          sizeRankField: schema.fields.poiSizeRank,
-          source,
-          sourceLayer: schema.layers.poi
-        }),
-        { ...symbolStyle2, text: void 0 }
-      );
-      result.push(poiContribution(`${category}.icon`, index * 4 + 1, layer));
-    }
-    if (showText) {
-      const layer = applySymbolStyle(
-        createPoiLayer({
-          category,
-          categoryField: schema.fields.poiCategory,
-          density: categoryDensity,
-          filterRankField: schema.fields.poiFilterRank,
-          id: `tileflow-poi-${category}-label`,
-          minZoom: semantics.minZoom,
-          sizeRankField: schema.fields.poiSizeRank,
-          source,
-          sourceLayer: schema.layers.poi
-        }),
-        { ...symbolStyle2, icon: void 0 }
-      );
-      result.push(poiContribution(`${category}.label`, index * 4 + 2, layer));
-    }
+      )
+    });
   }
-  return result;
+  const combined = coupled && (semantics.placement.order === "importance" ? semantics.icons && semantics.labels && (showIcon || showText) : showIcon && showText);
+  if (combined) {
+    const combinedStyle = {
+      ...symbolStyle2,
+      icon: showIcon ? symbolStyle2.icon : { image: "" },
+      text: showText ? { ...symbolStyle2.text, field: selection2.textField(symbolStyle2.text.field) } : { field: "" }
+    };
+    parts.push({
+      category,
+      representation: "combined",
+      layer: applySymbolStyle(base(), combinedStyle)
+    });
+    return parts;
+  }
+  if (showIcon) {
+    parts.push({
+      category,
+      representation: "icon",
+      layer: applySymbolStyle(base(), { ...symbolStyle2, text: void 0 })
+    });
+  }
+  if (showText) {
+    parts.push({
+      category,
+      representation: "label",
+      layer: applySymbolStyle(base(), { ...symbolStyle2, icon: void 0 })
+    });
+  }
+  return parts;
+}
+function createPoiSelection(semantics, context, language) {
+  const { fields } = context.data.schema;
+  const shown = /* @__PURE__ */ new Map();
+  const iconOnlyTypes = [...new Set(semantics.placement.iconOnlyTypes)];
+  const iconOnly = () => iconOnlyTypes.length ? ["match", ["get", fields.poiType], iconOnlyTypes, true, false] : ["literal", false];
+  const inCategories = (categories) => categories.length === 1 ? ["==", ["get", fields.poiCategory], categories[0]] : ["match", ["get", fields.poiCategory], [...categories], true, false];
+  const named = () => [
+    "any",
+    ...labelNameFields(language, context).map((field2) => ["has", field2])
+  ];
+  return {
+    register(category, parts) {
+      shown.set(category, parts);
+    },
+    textField(field2) {
+      if (!iconOnlyTypes.length || field2 === void 0) return field2;
+      return expression([
+        "match",
+        ["get", fields.poiType],
+        iconOnlyTypes,
+        "",
+        fieldValue(field2)
+      ]);
+    },
+    filter(categories, representation) {
+      const filterRank = numericPoiField(fields.poiFilterRank, 6);
+      const sizeRank = numericPoiField(fields.poiSizeRank, 17);
+      const result = [
+        "all",
+        inCategories(categories),
+        ["has", fields.poiFilterRank],
+        [">=", filterRank, 0],
+        ["<=", filterRank, poiRankThreshold(semantics.density)],
+        ["has", fields.poiSizeRank],
+        [">=", sizeRank, 0],
+        ["<=", sizeRank, 16]
+      ];
+      if (!semantics.icons || !semantics.labels) return result;
+      const textless = categories.filter((category) => !shown.get(category)?.text);
+      const iconless = categories.filter((category) => !shown.get(category)?.icon);
+      if (representation === "label") {
+        if (iconless.length === categories.length || !iconOnlyTypes.length) return result;
+        const keep = ["!", iconOnly()];
+        return [...result, iconless.length ? ["any", inCategories(iconless), keep] : keep];
+      }
+      if (textless.length === categories.length) return result;
+      return [
+        ...result,
+        [
+          "any",
+          named(),
+          ...iconOnlyTypes.length ? [iconOnly()] : [],
+          ...textless.length ? [inCategories(textless)] : []
+        ]
+      ];
+    }
+  };
+}
+function fieldValue(field2) {
+  return typeof field2 === "object" && field2 !== null && "kind" in field2 && field2.kind === "expression" ? field2.value : field2;
 }
 function resolvePoiImage(category, context, iconField) {
   const role = `poi.${category}`;
@@ -7842,28 +8699,6 @@ function resolveMarkerStyle(style) {
     style.marker
   );
 }
-function createPoiLayer(options) {
-  const filterRank = numericPoiField(options.filterRankField, 6);
-  const sizeRank = numericPoiField(options.sizeRankField, 17);
-  return {
-    id: options.id,
-    type: "symbol",
-    source: options.source,
-    "source-layer": options.sourceLayer,
-    minzoom: options.minZoom,
-    filter: [
-      "all",
-      ["==", ["get", options.categoryField], options.category],
-      ["has", options.filterRankField],
-      [">=", filterRank, 0],
-      ["<=", filterRank, poiRankThreshold(options.density)],
-      ["has", options.sizeRankField],
-      [">=", sizeRank, 0],
-      ["<=", sizeRank, 16]
-    ],
-    layout: { "symbol-sort-key": poiSortKey(options.filterRankField, options.sizeRankField) }
-  };
-}
 function poiRankThreshold(density) {
   return ["+", ["step", ["zoom"], 0, 16, 1, 17, 2], density];
 }
@@ -7880,7 +8715,7 @@ function poiContribution(target, localOrder, layer) {
     localOrder: 1e3 + localOrder,
     owner: "poi",
     slot: "symbols",
-    target: `poi.${target}`
+    target: target ? `poi.${target}` : "poi"
   };
 }
 function poiTextStyle(context, overrides) {
@@ -7890,8 +8725,7 @@ function poiTextStyle(context, overrides) {
       color: context.colors.poi.label,
       ...typographyTextStyle(context.typography.poi),
       haloColor: context.colors.poi.halo,
-      haloWidth: 1,
-      optional: true
+      haloWidth: 1
     },
     overrides
   );
@@ -7914,6 +8748,10 @@ function withoutMarker2(style) {
   delete result.marker;
   return result;
 }
+function withoutVisibility(value) {
+  const { visible: _visible, ...rest } = value;
+  return rest;
+}
 
 // src/modules/roads/compiler.ts
 init_values();
@@ -8867,9 +9705,10 @@ function compileRoundabouts(request, context, contributions) {
     contributions.push({
       kind: "layer",
       layer: applyCircleStyle({ ...base, id: "tileflow-road-circular-casing" }, config.casing),
-      localOrder: 10,
+      localOrder: 900,
       owner: "roads",
-      slot: "transport-symbols",
+      // Approach fills must cover the circular casing where the roads meet.
+      slot: "transport-surface-casing",
       target: "roads.roundabouts.casing"
     });
   }
@@ -8877,9 +9716,9 @@ function compileRoundabouts(request, context, contributions) {
     contributions.push({
       kind: "layer",
       layer: applyCircleStyle({ ...base, id: "tileflow-road-circular-fill" }, config.fill),
-      localOrder: 20,
+      localOrder: 900,
       owner: "roads",
-      slot: "transport-symbols",
+      slot: "transport-surface-fill",
       target: "roads.roundabouts.fill"
     });
   }
@@ -8944,7 +9783,7 @@ var circularRoadBorderTotalWidth = 1;
 function circularRoadInnerRadius(fields, casing) {
   const values = circularRoadValues(fields);
   const stops = [];
-  for (let level = 15; level <= 22; level += 1) {
+  for (let level = 15; level <= 24; level += 1) {
     const centerlineRadius = level === 15 ? values.radiusAtZoom15 : ["*", values.radiusAtZoom15, 2 ** (level - 15)];
     const physicalInnerRadius = [
       "*",
@@ -8961,13 +9800,13 @@ function circularRoadInnerRadius(fields, casing) {
       casing ? ["-", innerRadius, circularRoadBorderTotalWidth / 2] : innerRadius
     ]);
   }
-  return ["interpolate", ["linear"], ["zoom"], ...stops];
+  return ["interpolate", ["exponential", 2], ["zoom"], ...stops];
 }
 function circularRoadStrokeWidth(fields, casing) {
   const values = circularRoadValues(fields);
   const baseWidth = circularRoadBaseWidth(fields.class);
   const stops = [];
-  for (let level = 15; level <= 22; level += 1) {
+  for (let level = 15; level <= 24; level += 1) {
     const centerlineRadius = level === 15 ? values.radiusAtZoom15 : ["*", values.radiusAtZoom15, 2 ** (level - 15)];
     const physicalWidth = [
       "*",
@@ -8982,7 +9821,7 @@ function circularRoadStrokeWidth(fields, casing) {
       casing ? ["+", fallbackWidth, circularRoadBorderTotalWidth] : fallbackWidth
     ]);
   }
-  return ["interpolate", ["linear"], ["zoom"], ...stops];
+  return ["interpolate", ["exponential", 2], ["zoom"], ...stops];
 }
 function circularRoadBaseWidth(classField) {
   return [
@@ -9146,6 +9985,10 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
       return value === void 0 ? [] : [{ condition, resolve: () => expressionOutput(value) }];
     });
     if (branches.length > 0) {
+      if (property === "dash" && isSolidRoadDash(result[property] ?? treatmentPaintDefaults.dash) && branches.every(({ resolve }) => isSolidRoadDash(resolve()))) {
+        delete result[property];
+        continue;
+      }
       result[property] = conditionalStyleValue(
         result[property],
         branches,
@@ -9162,9 +10005,21 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
       widthScales,
       treatmentPaintDefaults.width
     );
+    if (result.gapWidth !== void 0 && result.gapWidth !== 0) {
+      result.gapWidth = conditionalWidthScaleValue(
+        result.gapWidth,
+        widthScales,
+        treatmentPaintDefaults.gapWidth
+      );
+    }
   }
   return result;
 }
+function isSolidRoadDash(value) {
+  const output = expressionOutput(value);
+  const dash = Array.isArray(output) && output[0] === "literal" ? output[1] : output;
+  return Array.isArray(dash) && dash.length === 2 && dash[0] === 1 && dash[1] === 0;
+}
 function roadTreatmentPhaseConditions(treatments, structure, phase) {
   return treatments.flatMap(
     ({ condition, style }) => style[structure]?.[phase] === void 0 ? [] : [condition]
@@ -9249,10 +10104,10 @@ function isExpressionOutput(value) {
 }
 function rewriteZoomOutputs(value, rewrite) {
   if (!Array.isArray(value)) return rewrite(value);
-  if (value[0] === "interpolate" && isZoomInput3(value[2])) {
+  if (value[0] === "interpolate" && isZoomInput4(value[2])) {
     return value.map((entry, index) => index >= 4 && index % 2 === 0 ? rewrite(entry) : entry);
   }
-  if (value[0] === "step" && isZoomInput3(value[1])) {
+  if (value[0] === "step" && isZoomInput4(value[1])) {
     return value.map(
       (entry, index) => index === 2 || index >= 4 && index % 2 === 0 ? rewrite(entry) : entry
     );
@@ -9262,7 +10117,7 @@ function rewriteZoomOutputs(value, rewrite) {
 function expressionOutput(value) {
   return Array.isArray(value) && typeof value[0] !== "string" ? ["literal", value] : value;
 }
-function isZoomInput3(value) {
+function isZoomInput4(value) {
   return Array.isArray(value) && value.length === 1 && value[0] === "zoom";
 }
 function restrictedAccessFilter(field2) {
@@ -9643,7 +10498,7 @@ var waterwayClasses = {
   river: ["river"],
   stream: ["stream"]
 };
-function compileWater(request, context) {
+function compileWater(request, context, language = "auto") {
   const config = mergeTileflowDesign(
     {
       type: "water",
@@ -9795,8 +10650,11 @@ function compileWater(request, context) {
     appendBathymetryRelief(contributions, bathymetryProduct.relief, context);
   }
   const productContours = bathymetryProduct?.contours;
+  const nativeContours = sidecarBathymetry && bathymetryProduct?.vectorLayers?.contours === true;
+  const contourLayer = nativeContours ? tileflowBathymetryV1Schema.layers.contours : bathymetryLayer;
+  const contourDepthField = nativeContours ? tileflowBathymetryV1Schema.fields.depth : bathymetryDepthField;
   const contourRequest = productContours === false ? void 0 : productContours === void 0 ? request?.bathymetryContours : mergeTileflowDesign(productContours, request?.bathymetryContours);
-  if (contourRequest !== void 0 && bathymetryLayer && bathymetryDepthField) {
+  if (contourRequest !== void 0 && contourLayer && contourDepthField) {
     const bathymetryContours = mergeTileflowDesign(
       {
         color: context.colors.hydro.label,
@@ -9819,12 +10677,12 @@ function compileWater(request, context) {
             id: "tileflow-bathymetry-contours",
             type: "line",
             source: bathymetrySource,
-            "source-layer": bathymetryLayer,
+            "source-layer": contourLayer,
             filter: [
               "all",
-              ["==", ["geometry-type"], "Polygon"],
-              ["has", bathymetryDepthField],
-              ["<", ["to-number", ["get", bathymetryDepthField], 0], 0]
+              ["==", ["geometry-type"], nativeContours ? "LineString" : "Polygon"],
+              ["has", contourDepthField],
+              ["<", ["to-number", ["get", contourDepthField], 0], 0]
             ]
           },
           bathymetryContours
@@ -9838,19 +10696,19 @@ function compileWater(request, context) {
   }
   const productLabels = bathymetryProduct?.labels;
   const labelRequest = productLabels === false ? void 0 : productLabels === void 0 ? request?.bathymetryLabels : mergeTileflowDesign(productLabels, request?.bathymetryLabels);
-  if (labelRequest !== void 0 && bathymetryLayer && bathymetryDepthField) {
+  if (labelRequest !== void 0 && contourLayer && contourDepthField) {
     const bathymetryLabels = mergeTileflowDesign(
       {
         maxZoom: 10,
         minZoom: 3,
-        placement: "point",
+        placement: nativeContours ? "line" : "point",
         priority: 5,
         text: {
           allowOverlap: false,
           color: context.colors.hydro.label,
           field: expression([
             "to-string",
-            ["abs", ["to-number", ["get", bathymetryDepthField], 0]]
+            ["abs", ["to-number", ["get", contourDepthField], 0]]
           ]),
           ...typographyTextStyle(context.typography.water),
           haloColor: context.colors.hydro.water,
@@ -9871,8 +10729,13 @@ function compileWater(request, context) {
             id: "tileflow-bathymetry-labels",
             type: "symbol",
             source: bathymetrySource,
-            "source-layer": bathymetryLayer,
-            filter: ["all", ["==", ["geometry-type"], "Polygon"], ["has", bathymetryDepthField]]
+            "source-layer": contourLayer,
+            filter: [
+              "all",
+              ["==", ["geometry-type"], nativeContours ? "LineString" : "Polygon"],
+              ["has", contourDepthField],
+              ...nativeContours ? [["<", ["to-number", ["get", contourDepthField], 0], 0]] : []
+            ]
           },
           bathymetryLabels
         ),
@@ -9883,6 +10746,37 @@ function compileWater(request, context) {
       });
     }
   }
+  if (sidecarBathymetry) {
+    const { layers: marineLayers } = tileflowBathymetryV1Schema;
+    const landforms2 = bathymetryProduct?.vectorLayers?.landforms;
+    const waterNames = bathymetryProduct?.vectorLayers?.waterNames;
+    if (landforms2) {
+      appendBathymetryNames(contributions, {
+        availability: landforms2,
+        context,
+        language,
+        localOrder: -300,
+        source: sidecarBathymetry.sourceId,
+        sourceLayer: marineLayers.landforms,
+        style: config.bathymetryLandforms,
+        target: "water.bathymetryLandforms",
+        id: "tileflow-bathymetry-landforms"
+      });
+    }
+    if (waterNames) {
+      appendBathymetryNames(contributions, {
+        availability: waterNames,
+        context,
+        language,
+        localOrder: -150,
+        source: sidecarBathymetry.sourceId,
+        sourceLayer: marineLayers.waterNames,
+        style: config.bathymetryWaterNames,
+        target: "water.bathymetryWaterNames",
+        id: "tileflow-bathymetry-water-names"
+      });
+    }
+  }
   let localOrder = 10;
   for (const [name, classes] of Object.entries(waterwayClasses)) {
     const style = config.waterways?.[name];
@@ -9946,6 +10840,99 @@ function compileWater(request, context) {
   }
   return contributions;
 }
+function appendBathymetryNames(contributions, options) {
+  const { context, language } = options;
+  const { fields } = tileflowBathymetryV1Schema;
+  const localName = ["to-string", ["coalesce", ["get", fields.name], ""]];
+  const name = language === "auto" || language === "local" ? localName : [
+    "case",
+    ["!=", ["to-string", ["coalesce", ["get", `name:${language}`], ""]], ""],
+    ["to-string", ["get", `name:${language}`]],
+    localName
+  ];
+  const style = mergeTileflowDesign(
+    {
+      minZoom: 0,
+      placement: "point",
+      priority: expression(["to-number", ["get", fields.sortKey], 0]),
+      priorityOrder: "lower-first",
+      text: {
+        ...typographyTextStyle(context.typography.water),
+        allowOverlap: false,
+        ignorePlacement: false,
+        color: context.colors.hydro.label,
+        field: expression(name),
+        haloColor: context.colors.hydro.water,
+        haloWidth: 1,
+        optional: false,
+        padding: 12,
+        size: 11
+      }
+    },
+    options.style
+  );
+  if (style.visible === false || style.text?.visible === false) return;
+  const layer = applySymbolStyle(
+    {
+      id: options.id,
+      type: "symbol",
+      source: options.source,
+      "source-layer": options.sourceLayer,
+      filter: [
+        "all",
+        ["match", ["geometry-type"], ["Point", "LineString", "Polygon"], true, false],
+        ["!=", name, ""]
+      ]
+    },
+    style
+  );
+  const sourceMinimum = ["to-number", ["coalesce", ["get", fields.minZoom], 0], 0];
+  const sourceMaximum = ["to-number", ["coalesce", ["get", fields.maxZoom], 24], 24];
+  const baseFilter = layer.filter;
+  const append = (result, target, order = 0) => {
+    contributions.push({
+      kind: "layer",
+      layer: result,
+      localOrder: options.localOrder + order,
+      owner: "water",
+      slot: "symbols",
+      target
+    });
+  };
+  if (options.availability === true) {
+    append(
+      {
+        ...layer,
+        filter: [...baseFilter, [">=", ["zoom"], sourceMinimum], ["<", ["zoom"], sourceMaximum]]
+      },
+      options.target
+    );
+    return;
+  }
+  const ranges = [...options.availability.zoomRanges].sort(
+    (left, right) => left.minZoom - right.minZoom || left.maxZoom - right.maxZoom
+  );
+  for (const [index, range2] of ranges.entries()) {
+    const minzoom = Math.max(Number(layer.minzoom ?? 0), range2.minZoom);
+    const maxzoom = Math.min(Number(layer.maxzoom ?? 24), range2.maxZoom);
+    if (minzoom >= maxzoom) continue;
+    append(
+      {
+        ...layer,
+        id: `${options.id}-cohort-${index}`,
+        minzoom,
+        maxzoom,
+        filter: [
+          ...baseFilter,
+          ["==", sourceMinimum, range2.minZoom],
+          ["==", sourceMaximum, range2.maxZoom]
+        ]
+      },
+      `${options.target}.cohort${index}`,
+      index
+    );
+  }
+}
 function appendBathymetryRelief(contributions, relief, context) {
   const { sourceId, style } = relief;
   const opacity = resolvedNumber(style.opacity, 0.22, "bathymetry relief opacity");
@@ -10154,12 +11141,6 @@ var tileflowSemanticDomainRegistry = Object.freeze([
     dependencies: {},
     name: "land"
   }),
-  defineDomain({
-    compile: ({ context, module }) => compileWater(module, context),
-    defaultModule: water(),
-    dependencies: {},
-    name: "water"
-  }),
   defineDomain({
     compile: ({ context, module }) => compileNautical(module, context),
     defaultModule: nautical(),
@@ -10248,6 +11229,12 @@ var tileflowSemanticDomainRegistry = Object.freeze([
     provides: ["language"],
     resolveServices: ({ module }) => ({ language: resolveLabels(module).language })
   }),
+  defineDomain({
+    compile: ({ context, dependencies, module }) => compileWater(module, context, dependencies.service("language")),
+    defaultModule: water(),
+    dependencies: { services: ["language"] },
+    name: "water"
+  }),
   defineDomain({
     compile: ({ context, dependencies, module }) => compileLandforms(module, dependencies.service("language"), context),
     defaultModule: landforms(),
@@ -10366,7 +11353,7 @@ function createTileflowCompilerProvenance(owner, slot, target) {
   return [{ operations: [], owner, slot, target }];
 }
 function readTileflowCompilerProvenance(layer) {
-  const metadata = asRecord3(layer.metadata);
+  const metadata = asRecord4(layer.metadata);
   const raw = metadata[tileflowCompilerProvenanceMetadataKey];
   if (Array.isArray(raw)) {
     const parsed = raw.flatMap((value) => {
@@ -10394,7 +11381,7 @@ function createTileflowStyleInspection(map, theme, layers) {
   };
 }
 function parseContribution(value) {
-  const input = asRecord3(value);
+  const input = asRecord4(value);
   const owner = requireLayerDomain(input.owner);
   const slot = requireLayerSlot(input.slot);
   const target = input.target;
@@ -10408,7 +11395,7 @@ function parseContribution(value) {
   return { operations: operations2, owner, slot, target };
 }
 function parseRenderOperation(value) {
-  const input = asRecord3(value);
+  const input = asRecord4(value);
   const owner = requireLayerDomain(input.owner);
   const target = input.target;
   if (input.kind !== "pass" && input.kind !== "refinement" || !owner || typeof target !== "string" || !tileflowSemanticTargetPattern.test(target)) {
@@ -10422,7 +11409,7 @@ function requireLayerDomain(value) {
 function requireLayerSlot(value) {
   return typeof value === "string" && tileflowLayerSlots.includes(value) ? value : void 0;
 }
-function asRecord3(value) {
+function asRecord4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
@@ -10779,7 +11766,7 @@ function not(value) {
 function has(reference) {
   return make(["has", reference]);
 }
-function match(input, branches, fallback) {
+function match2(input, branches, fallback) {
   validateBranchCount(branches.length, "expr.match");
   validateMatchLabels(branches);
   return make([
@@ -10877,7 +11864,7 @@ function limitError(message) {
   return new Error(site ? `${message} Called at ${site}.` : message);
 }
 function authoringCallSite(stack) {
-  const locations = (stack ?? "").split("\n").slice(1).map((line) => /\(?([^()\s]+?):(\d+):(\d+)\)?$/.exec(line.trim())).filter((match2) => match2 !== null).map(([, file, line, column]) => ({ file: file.replace(/^file:\/\//, ""), line, column }));
+  const locations = (stack ?? "").split("\n").slice(1).map((line) => /\(?([^()\s]+?):(\d+):(\d+)\)?$/.exec(line.trim())).filter((match3) => match3 !== null).map(([, file, line, column]) => ({ file: file.replace(/^file:\/\//, ""), line, column }));
   const own = locations[0]?.file;
   const site = locations.find(({ file }) => file !== own && !file.startsWith("node:"));
   return site ? `${site.file}:${site.line}:${site.column}` : void 0;
@@ -11262,7 +12249,7 @@ var expr = Object.freeze({
   literal,
   lt: (left, right) => compare("<", left, right),
   lte: (left, right) => compare("<=", left, right),
-  match,
+  match: match2,
   max: maximum,
   min: minimum,
   modulo,
@@ -11286,6 +12273,12 @@ var tileflowSemanticFieldNames = Object.freeze(
 var tileflowSemanticLayerNames = Object.freeze(
   Object.keys(completeSemanticDataContract.layers).sort(compareCodeUnits5)
 );
+var auxiliaryFieldBindings = Object.freeze({
+  bathymetryContourDepth: tileflowBathymetryV1Schema.fields.depth
+});
+var tileflowSemanticExpressionFieldNames = Object.freeze(
+  [...tileflowSemanticFieldNames, ...Object.keys(auxiliaryFieldBindings)].sort(compareCodeUnits5)
+);
 function field(name) {
   return Object.freeze({ kind: "tileflow-data-field", name });
 }
@@ -11317,6 +12310,9 @@ function bindSemanticReferences(value, data) {
 }
 function bindSemanticValue(value, schema, sourceId) {
   if (isDataFieldReference2(value)) {
+    if (Object.hasOwn(auxiliaryFieldBindings, value.name)) {
+      return auxiliaryFieldBindings[value.name];
+    }
     const binding = schema.fields[value.name];
     if (!binding) throw new Error(`Tileflow data schema does not provide field ${value.name}.`);
     return binding;
@@ -11328,21 +12324,21 @@ function bindSemanticValue(value, schema, sourceId) {
   }
   if (isDataSourceReference(value)) return sourceId;
   if (Array.isArray(value)) return value.map((item) => bindSemanticValue(item, schema, sourceId));
-  if (!isRecord8(value)) return value;
+  if (!isRecord7(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([key, item]) => [key, bindSemanticValue(item, schema, sourceId)])
   );
 }
 function isDataFieldReference2(value) {
-  return isRecord8(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
+  return isRecord7(value) && value.kind === "tileflow-data-field" && typeof value.name === "string";
 }
 function isDataLayerReference(value) {
-  return isRecord8(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
+  return isRecord7(value) && value.kind === "tileflow-data-layer" && typeof value.name === "string";
 }
 function isDataSourceReference(value) {
-  return isRecord8(value) && value.kind === "tileflow-data-source" && value.name === "primary";
+  return isRecord7(value) && value.kind === "tileflow-data-source" && value.name === "primary";
 }
-function isRecord8(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function compareCodeUnits5(left, right) {
@@ -11446,8 +12442,8 @@ function createTileflowLayerTemplateIR(layer, semanticKey) {
     renderer: type,
     ...filter === void 0 ? {} : { selector: cloneJson20(filter) },
     style: Object.freeze({
-      ...isRecord9(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
-      ...isRecord9(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
+      ...isRecord8(layout) ? { placement: Object.freeze(cloneJson20(layout)) } : {},
+      ...isRecord8(paint) ? { appearance: Object.freeze(cloneJson20(paint)) } : {}
     })
   });
 }
@@ -11521,72 +12517,77 @@ function emitLayer(family, resolvePhysicalId) {
 function physicalLayerIdForSemanticKey(semanticKey) {
   const exact = exactPhysicalLayerIds[semanticKey];
   if (exact) return exact;
-  let match2 = /^([A-Za-z0-9_-]+)\.render\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(
+  let match3 = /^([A-Za-z0-9_-]+)\.render\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(
     semanticKey
   );
-  if (match2) return `tileflow-${match2[1]}-render-${match2[2].replaceAll(".", "-")}`;
-  match2 = /^roads\.classes\.([^.]+)\.(tunnel|surface|bridge)\.(shadow|casing|fill|hatch)$/u.exec(
+  if (match3) return `tileflow-${match3[1]}-render-${match3[2].replaceAll(".", "-")}`;
+  match3 = /^roads\.classes\.([^.]+)\.(tunnel|surface|bridge)\.(shadow|casing|fill|hatch)$/u.exec(
     semanticKey
   );
-  if (match2) return `tileflow-road-${match2[2]}-${match2[1]}-${match2[3]}`;
-  match2 = /^roads\.cohorts\.(tunnel|surface|bridge)\.([^.]+)\.(shadow|casing|fill)$/u.exec(
+  if (match3) return `tileflow-road-${match3[2]}-${match3[1]}-${match3[3]}`;
+  match3 = /^roads\.cohorts\.(tunnel|surface|bridge)\.([^.]+)\.(shadow|casing|fill)$/u.exec(
     semanticKey
   );
-  if (match2) return `tileflow-road-${match2[1]}-highzoom-${match2[2]}-${match2[3]}`;
-  match2 = /^roads\.cohorts\.(tunnel|surface|bridge)\.hatch$/u.exec(semanticKey);
-  if (match2) return `tileflow-road-${match2[1]}-hatch`;
-  match2 = /^roads\.areas\.(road|pedestrian|pier)\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) {
-    const base = match2[1] === "road" ? "tileflow-road-area" : `tileflow-road-${match2[1]}-area`;
-    return match2[2] === "fill" ? base : `${base}-outline`;
-  }
-  match2 = /^land\.(landcover|landuse)\.([^.]+)\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) {
-    const base = `tileflow-${match2[1]}-${match2[2]}`;
-    return match2[3] === "fill" ? base : `${base}-outline`;
-  }
-  match2 = /^land\.compatibility\.legacyPark\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) {
-    return match2[1] === "fill" ? "tileflow-landcover-legacy-park" : "tileflow-landcover-legacy-park-outline";
-  }
-  match2 = /^land\.cohorts\.(landcover|landuse)(?:\.cohort(\d+))?$/u.exec(semanticKey);
-  if (match2) return `tileflow-${match2[1]}${match2[2] === void 0 ? "" : `-${match2[2]}`}`;
-  match2 = /^water\.(intermittent\.)?bodies\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) {
-    const base = `tileflow-water${match2[1] ? "-intermittent" : ""}`;
-    return match2[2] === "fill" ? base : `${base}-outline`;
-  }
-  match2 = /^water\.(intermittent\.)?waterways\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-waterway-${match2[2]}${match2[1] ? "-intermittent" : ""}`;
-  match2 = /^buildings\.(businessCorridor|flat)\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) {
-    const base = match2[1] === "businessCorridor" ? "tileflow-business-corridor" : "tileflow-buildings-fill";
-    return match2[2] === "fill" ? base : `${base}-outline`;
-  }
-  match2 = /^aeroways\.area\.(fill|outline)$/u.exec(semanticKey);
-  if (match2) return match2[1] === "fill" ? "tileflow-aeroway-area" : "tileflow-aeroway-area-outline";
-  match2 = /^aeroways\.(taxiway|runway)\.(shadow|casing|fill)$/u.exec(semanticKey);
-  if (match2) return `tileflow-aeroway-${match2[1]}-${match2[2]}`;
-  match2 = /^transit\.([A-Za-z0-9_-]+)(?:\.(tunnel|surface|bridge))?$/u.exec(semanticKey);
-  if (match2) return `tileflow-transit-${match2[1]}${match2[2] ? `-${match2[2]}` : ""}`;
-  match2 = /^boundaries\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(semanticKey);
-  if (match2) return `tileflow-boundary-${match2[1].replaceAll(".", "-")}`;
-  match2 = /^labels\.places\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-place-${match2[1]}`;
-  match2 = /^labels\.roads\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-road-${match2[1]}`;
-  match2 = /^labels\.shields\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-road-shield-${match2[1]}`;
-  match2 = /^labels\.water\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-water-${match2[1]}`;
-  match2 = /^labels\.cohorts\.roads\.(major|local)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-road-${match2[1]}`;
-  match2 = /^labels\.cohorts\.roads\.cohort(\d+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-label-road-cohort-${match2[1]}`;
-  match2 = /^landforms\.classes\.([^.]+)$/u.exec(semanticKey);
-  if (match2) return `tileflow-landform-${match2[1]}`;
-  match2 = /^poi\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(semanticKey);
-  if (match2) return `tileflow-poi-${match2[1].replaceAll(".", "-")}`;
+  if (match3) return `tileflow-road-${match3[1]}-highzoom-${match3[2]}-${match3[3]}`;
+  match3 = /^roads\.cohorts\.(tunnel|surface|bridge)\.hatch$/u.exec(semanticKey);
+  if (match3) return `tileflow-road-${match3[1]}-hatch`;
+  match3 = /^roads\.areas\.(road|pedestrian|pier)\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) {
+    const base = match3[1] === "road" ? "tileflow-road-area" : `tileflow-road-${match3[1]}-area`;
+    return match3[2] === "fill" ? base : `${base}-outline`;
+  }
+  match3 = /^land\.(landcover|landuse)\.([^.]+)\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) {
+    const base = `tileflow-${match3[1]}-${match3[2]}`;
+    return match3[3] === "fill" ? base : `${base}-outline`;
+  }
+  match3 = /^land\.compatibility\.legacyPark\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) {
+    return match3[1] === "fill" ? "tileflow-landcover-legacy-park" : "tileflow-landcover-legacy-park-outline";
+  }
+  match3 = /^land\.cohorts\.(landcover|landuse)(?:\.cohort(\d+))?$/u.exec(semanticKey);
+  if (match3) return `tileflow-${match3[1]}${match3[2] === void 0 ? "" : `-${match3[2]}`}`;
+  match3 = /^water\.(intermittent\.)?bodies\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) {
+    const base = `tileflow-water${match3[1] ? "-intermittent" : ""}`;
+    return match3[2] === "fill" ? base : `${base}-outline`;
+  }
+  match3 = /^water\.(intermittent\.)?waterways\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-waterway-${match3[2]}${match3[1] ? "-intermittent" : ""}`;
+  match3 = /^buildings\.(businessCorridor|flat)\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) {
+    const base = match3[1] === "businessCorridor" ? "tileflow-business-corridor" : "tileflow-buildings-fill";
+    return match3[2] === "fill" ? base : `${base}-outline`;
+  }
+  match3 = /^aeroways\.area\.(fill|outline)$/u.exec(semanticKey);
+  if (match3) return match3[1] === "fill" ? "tileflow-aeroway-area" : "tileflow-aeroway-area-outline";
+  match3 = /^aeroways\.(taxiway|runway)\.(shadow|casing|fill)$/u.exec(semanticKey);
+  if (match3) return `tileflow-aeroway-${match3[1]}-${match3[2]}`;
+  match3 = /^transit\.([A-Za-z0-9_-]+)(?:\.(tunnel|surface|bridge))?$/u.exec(semanticKey);
+  if (match3) return `tileflow-transit-${match3[1]}${match3[2] ? `-${match3[2]}` : ""}`;
+  match3 = /^boundaries\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(semanticKey);
+  if (match3) return `tileflow-boundary-${match3[1].replaceAll(".", "-")}`;
+  match3 = /^labels\.places\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-place-${match3[1]}`;
+  match3 = /^labels\.roads\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-road-${match3[1]}`;
+  match3 = /^labels\.shields\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-road-shield-${match3[1]}`;
+  match3 = /^labels\.water\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-water-${match3[1]}`;
+  match3 = /^labels\.cohorts\.roads\.(major|local)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-road-${match3[1]}`;
+  match3 = /^labels\.cohorts\.roads\.cohort(\d+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-label-road-cohort-${match3[1]}`;
+  match3 = /^landforms\.classes\.([^.]+)$/u.exec(semanticKey);
+  if (match3) return `tileflow-landform-${match3[1]}`;
+  match3 = /^water\.(bathymetryLandforms|bathymetryWaterNames)\.cohort(\d+)$/u.exec(semanticKey);
+  if (match3) {
+    const base = match3[1] === "bathymetryLandforms" ? "landforms" : "water-names";
+    return `tileflow-bathymetry-${base}-cohort-${match3[2]}`;
+  }
+  match3 = /^poi\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(semanticKey);
+  if (match3) return `tileflow-poi-${match3[1].replaceAll(".", "-")}`;
   const nautical2 = nauticalPhysicalLayerId(semanticKey);
   if (nautical2) return nautical2;
   throw new TileflowDomainIRError(
@@ -11603,6 +12604,7 @@ var exactPhysicalLayerIds = Object.freeze({
   "labels.junctions": "tileflow-label-road-junction",
   "land.background": "tileflow-background",
   "land.globalLandcover": "tileflow-global-landcover",
+  poi: "tileflow-poi",
   "landforms.classes": "tileflow-landforms",
   "roads.crossings": "tileflow-road-crossing",
   "roads.oneWayMarkers": "tileflow-road-oneway",
@@ -11619,6 +12621,8 @@ var exactPhysicalLayerIds = Object.freeze({
   "water.bathymetry": "tileflow-bathymetry",
   "water.bathymetryContours": "tileflow-bathymetry-contours",
   "water.bathymetryLabels": "tileflow-bathymetry-labels",
+  "water.bathymetryLandforms": "tileflow-bathymetry-landforms",
+  "water.bathymetryWaterNames": "tileflow-bathymetry-water-names",
   "water.bathymetryRelief.color": "tileflow-bathymetry-color-relief",
   "water.bathymetryRelief.hillshade": "tileflow-bathymetry-relief"
 });
@@ -11643,15 +12647,15 @@ var nauticalPhysicalBases = Object.freeze({
 function nauticalPhysicalLayerId(semanticKey) {
   const direct = nauticalPhysicalBases[semanticKey];
   if (direct) return direct;
-  const match2 = /^(nautical\.[A-Za-z0-9_.-]+)\.(fill|outline|marker|symbol)$/u.exec(semanticKey);
-  if (!match2) return void 0;
-  const base = nauticalPhysicalBases[match2[1]];
+  const match3 = /^(nautical\.[A-Za-z0-9_.-]+)\.(fill|outline|marker|symbol)$/u.exec(semanticKey);
+  if (!match3) return void 0;
+  const base = nauticalPhysicalBases[match3[1]];
   if (!base) return void 0;
-  if (match2[2] === "fill" || match2[2] === "symbol") return base;
-  return `${base}-${match2[2]}`;
+  if (match3[2] === "fill" || match3[2] === "symbol") return base;
+  return `${base}-${match3[2]}`;
 }
 function publicMetadata(value) {
-  const metadata = { ...asRecord4(value) };
+  const metadata = { ...asRecord5(value) };
   delete metadata[tileflowCompilerProvenanceMetadataKey];
   for (const key of Object.values(tileflowCompilerMetadataKeys)) delete metadata[key];
   return Object.keys(metadata).length > 0 ? cloneJson20(metadata) : void 0;
@@ -11687,21 +12691,21 @@ function visitReferences(value, counts, visited = /* @__PURE__ */ new WeakSet())
   }
 }
 function isSemanticFieldReference(value) {
-  return isRecord9(value) && value.kind === "tileflow-data-field";
+  return isRecord8(value) && value.kind === "tileflow-data-field";
 }
 function isSemanticLayerReference(value) {
-  return isRecord9(value) && value.kind === "tileflow-data-layer";
+  return isRecord8(value) && value.kind === "tileflow-data-layer";
 }
 function isSemanticSourceReference(value) {
-  return isRecord9(value) && value.kind === "tileflow-data-source";
+  return isRecord8(value) && value.kind === "tileflow-data-source";
 }
 function cloneJson20(value) {
   return JSON.parse(JSON.stringify(value));
 }
-function asRecord4(value) {
-  return isRecord9(value) ? value : {};
+function asRecord5(value) {
+  return isRecord8(value) ? value : {};
 }
-function isRecord9(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -11765,7 +12769,7 @@ function validateTileflowRenderSelectorConstraints(input) {
   };
   while (pending.length > 0) {
     const current = pending.pop();
-    if (!isRecord10(current.selector) || typeof current.selector.kind !== "string") {
+    if (!isRecord9(current.selector) || typeof current.selector.kind !== "string") {
       addIssue(
         "invalid-selector",
         "a render selector must be a semantic selector node",
@@ -11826,7 +12830,7 @@ function validateTileflowRenderSelectorConstraints(input) {
         }
         for (const [index, branch] of current.selector.branches.entries()) {
           const branchPath = [...branchesPath, index];
-          if (!isRecord10(branch)) {
+          if (!isRecord9(branch)) {
             addIssue("invalid-selector", "match selector branch must be an object", branchPath);
             continue;
           }
@@ -11857,14 +12861,14 @@ function validateTileflowRenderSelectorConstraints(input) {
         for (let index = current.selector.stops.length - 1; index >= 0; index -= 1) {
           const stop = current.selector.stops[index];
           const stopPath = [...stopsPath, index];
-          if (!isRecord10(stop)) {
+          if (!isRecord9(stop)) {
             addIssue("invalid-selector", "step selector stop must be an object", stopPath);
             continue;
           }
           pushChild(stop.selector, current.depth + 1, [...stopPath, "selector"]);
         }
         for (const [index, stop] of current.selector.stops.entries()) {
-          if (!isRecord10(stop)) continue;
+          if (!isRecord9(stop)) continue;
           const zoom3 = stop.zoom;
           const zoomPath = [...stopsPath, index, "zoom"];
           if (typeof zoom3 !== "number" || !Number.isFinite(zoom3) || zoom3 < 0 || zoom3 > 24) {
@@ -12075,8 +13079,8 @@ function applyCompiledRenderStacks(input, operations2) {
       const index2 = findTargetIndex(layers, operation.target);
       moved.set(operation.target, requireRefinementOwner(layers[index2], operation));
       layers = [...layers.slice(0, index2), ...layers.slice(index2 + 1)];
-      for (const [placed, target] of lastPlaced) {
-        if (target === operation.target) lastPlaced.delete(placed);
+      for (const [placed2, target] of lastPlaced) {
+        if (target === operation.target) lastPlaced.delete(placed2);
       }
     }
     const placement = first.placement;
@@ -12242,12 +13246,12 @@ function applyRendererStyle(layer, renderer, style) {
   if (!visibilityGroup) return result;
   return {
     ...result,
-    layout: { ...asRecord5(result.layout), visibility: "none" },
-    metadata: { ...asRecord5(result.metadata), "tileflow:3d-toggle": visibilityGroup }
+    layout: { ...asRecord6(result.layout), visibility: "none" },
+    metadata: { ...asRecord6(result.metadata), "tileflow:3d-toggle": visibilityGroup }
   };
 }
 function lowerSelector(selector, data) {
-  if (!isRecord10(selector) || typeof selector.kind !== "string") {
+  if (!isRecord9(selector) || typeof selector.kind !== "string") {
     throw renderStackError(
       "invalid-selector",
       "A render selector must be a semantic selector node."
@@ -12450,7 +13454,7 @@ function requireRenderer(value) {
 function requirePlacement(value) {
   if (typeof value === "string") {
     if (tileflowBandPlacements.includes(value)) return;
-  } else if (isRecord10(value)) {
+  } else if (isRecord9(value)) {
     const keys = Object.keys(value);
     if (keys.length === 1 && (keys[0] === "above" || keys[0] === "below")) {
       requirePortableTarget(value[keys[0]], "render placement target");
@@ -12477,7 +13481,7 @@ function validateRefinementShape(operation) {
   validateStyle(operation.renderer, operation.style);
 }
 function validateStyle(renderer, style) {
-  if (!isRecord10(style)) {
+  if (!isRecord9(style)) {
     throw renderStackError(
       "invalid-style",
       `A ${renderer} render operation requires a style object.`
@@ -12579,7 +13583,7 @@ function normalizeRequirements(requirements) {
   return [...requirements];
 }
 function requireRenderStackEntries(stack) {
-  if (!isRecord10(stack)) {
+  if (!isRecord9(stack)) {
     throw renderStackError("invalid-stack", "A render stack must be a named operation record.");
   }
   const entries = Object.entries(stack);
@@ -12725,10 +13729,10 @@ function compareCodeUnits6(left, right) {
 function cloneJson21(value) {
   return JSON.parse(JSON.stringify(value));
 }
-function asRecord5(value) {
-  return isRecord10(value) ? value : {};
+function asRecord6(value) {
+  return isRecord9(value) ? value : {};
 }
-function isRecord10(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -12795,6 +13799,9 @@ function collectTileflowIconSetReferences(sources) {
   return references;
 }
 
+// src/resolved-map-schema.ts
+init_manifest_schema_classic();
+
 // src/maps/assets.ts
 var tileflowLocalDirectoryMaximumLength = 512;
 var tileflowLocalDirectoryMessage = "Expected a canonical relative directory beginning with ./ or ../; only leading .. segments are allowed and segments must be non-empty, without backslashes or controls";
@@ -12939,6 +13946,8 @@ function isLoopbackHostname(hostname) {
 }
 
 // src/resolved-map-schema.ts
+init_time_of_day();
+init_time_of_day_schema();
 var TileflowResolvedMapValidationError = class extends Error {
   code = "CONFIG_INVALID";
   messages;
@@ -13085,7 +14094,7 @@ function validateExpressionFieldNames(value, context, path) {
   }
   if (!value || typeof value !== "object") return;
   const candidate = value;
-  if (candidate.kind === "tileflow-data-field" && (typeof candidate.name !== "string" || !Object.hasOwn(fieldBindingsSchema.shape, candidate.name))) {
+  if (candidate.kind === "tileflow-data-field" && (typeof candidate.name !== "string" || !tileflowSemanticExpressionFieldNames.some((name) => name === candidate.name))) {
     context.addIssue({
       code: "custom",
       message: "Expected a registered semantic field name.",
@@ -13239,12 +14248,12 @@ var hexColorSchema = z7.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a
   message: "Expected a hex color like #F6F7F3 or #F6F7F3FF"
 });
 var rgbColorSchema = z7.string().refine((value) => {
-  const match2 = value.match(
+  const match3 = value.match(
     /^rgba?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)(?:\s*,\s*(\d+(?:\.\d+)?))?\s*\)$/iu
   );
-  if (!match2) return false;
-  const channels = match2.slice(1, 4).map(Number);
-  const alpha2 = Number(match2[4] ?? 1);
+  if (!match3) return false;
+  const channels = match3.slice(1, 4).map(Number);
+  const alpha2 = Number(match3[4] ?? 1);
   return channels.every((channel) => channel >= 0 && channel <= 255) && alpha2 >= 0 && alpha2 <= 1;
 }, "Expected a Tileflow hex, rgb(), or rgba() color");
 var terrainColorLiteralSchema = z7.union([hexColorSchema, rgbColorSchema]);
@@ -13521,9 +14530,7 @@ var symbolStyleSchema = z7.object({
   text: textStyleSchema.optional()
 }).strict();
 var markerSymbolStyleSchema = symbolStyleSchema.extend({ marker: circleStyleSchema.optional() }).strict();
-var poiCategoryStyleSchema = markerSymbolStyleSchema.omit({ priority: true, priorityOrder: true }).extend({
-  density: z7.union([z7.literal(1), z7.literal(2), z7.literal(3), z7.literal(4), z7.literal(5)]).optional()
-}).strict();
+var poiCategoryStyleSchema = markerSymbolStyleSchema.omit({ priority: true, priorityOrder: true }).strict();
 var renderScalarSchema = z7.union([z7.boolean(), z7.number().finite(), z7.string()]);
 var renderTargetSchema = z7.string().regex(tileflowSemanticTargetPattern, "Expected a semantic target");
 var renderStackOperationNameSchema = z7.string().regex(
@@ -13756,6 +14763,8 @@ var waterModuleSchema = z7.object({
   bathymetry: fillStyleSchema.optional(),
   bathymetryContours: lineStyleSchema.optional(),
   bathymetryLabels: symbolStyleSchema.optional(),
+  bathymetryLandforms: symbolStyleSchema.optional(),
+  bathymetryWaterNames: symbolStyleSchema.optional(),
   bodies: areaStyleSchema.optional(),
   enabled: z7.boolean().optional(),
   intermittent: z7.object({ bodies: areaStyleSchema.optional(), waterways: lineStyleSchema.optional() }).strict().optional(),
@@ -13787,12 +14796,43 @@ var buildingsModuleSchema = z7.object({
   mode: z7.enum(["3d", "flat"]).optional(),
   renderStack: renderStackSchema.optional(),
   threeDimensional: z7.object({
+    lighting: z7.enum(["style", "sun"]).optional(),
+    colorVariation: boundedThemeNumberSchema(0, 1).optional(),
     edges: boundedThemeNumberSchema(0, 1).optional(),
     edgeColor: themeColorValueSchema.optional(),
     nightLight: boundedThemeNumberSchema(0, 2).optional(),
     occlusion: z7.boolean().optional(),
     shadows: z7.boolean().optional(),
-    windows: z7.boolean().optional()
+    windows: z7.boolean().optional(),
+    models: z7.array(
+      z7.object({
+        model: z7.string().max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u),
+        at: z7.tuple([z7.number().min(-180).max(180), z7.number().min(-85).max(85)]),
+        heading: z7.number().finite().optional(),
+        url: z7.url().max(2048).refine((value) => new URL(value).protocol === "https:", {
+          message: "A model served elsewhere has an HTTPS address."
+        }).optional()
+      }).strict()
+    ).max(256).optional(),
+    modelColors: z7.object({
+      surface: themeColorValueSchema.optional(),
+      secondary: themeColorValueSchema.optional(),
+      glass: themeColorValueSchema.optional(),
+      accent: themeColorValueSchema.optional(),
+      roof: themeColorValueSchema.optional()
+    }).strict().optional(),
+    landmarks: z7.union([
+      z7.boolean(),
+      z7.object({
+        url: z7.url().max(2048).refine(
+          (value) => {
+            const url = new URL(value);
+            return url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+          },
+          { message: "A landmarks tileset has an HTTPS address, or a local one." }
+        )
+      }).strict()
+    ]).optional()
   }).strict().optional()
 }).strict();
 var addressesModuleSchema = z7.object({
@@ -13971,7 +15011,10 @@ var poiModuleSchema = z7.object({
   minZoom: zoomNumberSchema.optional(),
   placement: z7.object({
     coupleIconAndLabel: z7.boolean().optional(),
+    iconOnlyTypes: z7.array(z7.string().regex(/^[a-z0-9]+(?:_[a-z0-9]+)*$/u, "Expected a World POI type")).max(64).optional(),
     iconPadding: z7.number().finite().min(0).optional(),
+    order: z7.enum(["categories", "importance"]).optional(),
+    prominentRank: z7.number().int().min(0).max(5).optional(),
     textPadding: z7.number().finite().min(0).optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional(),
@@ -14026,7 +15069,9 @@ var modulesSchema = z7.object({
     type: z7.literal("vegetation"),
     enabled: z7.boolean().optional(),
     flat: circleStyleSchema.optional(),
-    mode: z7.enum(["3d", "flat"]).optional(),
+    mode: z7.enum(["3d", "flat", "auto"]).optional(),
+    fallback: z7.enum(["flat", "none"]).optional(),
+    visible: z7.boolean().optional(),
     renderStack: renderStackSchema.optional(),
     threeDimensional: z7.object({
       barkColor: themeColorValueSchema.optional(),
@@ -14163,6 +15208,7 @@ var fieldBindingsSchema = z7.object({
   markings: z7.string().trim().min(1),
   minHeight: z7.string().trim().min(1),
   minZoom: z7.string().trim().min(1),
+  mode: z7.string().trim().min(1),
   mtbScale: z7.string().trim().min(1),
   name: z7.string().trim().min(1),
   nameEnglish: z7.string().trim().min(1),
@@ -14266,6 +15312,32 @@ var bathymetryReliefSchema = z7.object({
     });
   }
 });
+var bathymetryNameLayerSchema = z7.union([
+  z7.boolean(),
+  z7.object({
+    zoomRanges: z7.array(z7.object({ minZoom: zoomNumberSchema, maxZoom: zoomNumberSchema }).strict()).min(1).max(tileflowBathymetryNameLayerLimits.maxZoomRanges).superRefine((ranges, context) => {
+      const seen = /* @__PURE__ */ new Set();
+      for (const [index, range2] of ranges.entries()) {
+        if (range2.minZoom >= range2.maxZoom) {
+          context.addIssue({
+            code: "custom",
+            message: "Expected minZoom < maxZoom",
+            path: [index, "maxZoom"]
+          });
+        }
+        const key = `${range2.minZoom}/${range2.maxZoom}`;
+        if (seen.has(key)) {
+          context.addIssue({
+            code: "custom",
+            message: "Expected unique nominal zoom ranges",
+            path: [index]
+          });
+        }
+        seen.add(key);
+      }
+    })
+  }).strict()
+]);
 var bathymetryConfigSchema = z7.object({
   ...marineSourceSchema.shape,
   bands: z7.union([z7.literal(false), fillStyleSchema]).optional(),
@@ -14273,7 +15345,12 @@ var bathymetryConfigSchema = z7.object({
   display: z7.enum(["bands", "relief", "hybrid"]).optional(),
   labels: z7.union([z7.literal(false), symbolStyleSchema]).optional(),
   relief: z7.union([z7.literal(false), bathymetryReliefSchema]).optional(),
-  type: z7.literal("bathymetry")
+  type: z7.literal("bathymetry"),
+  vectorLayers: z7.object({
+    contours: z7.boolean().optional(),
+    landforms: bathymetryNameLayerSchema.optional(),
+    waterNames: bathymetryNameLayerSchema.optional()
+  }).strict().optional()
 }).strict();
 var marineSchema = z7.union([
   z7.enum(["none", "bathymetry", "nautical", "chart"]),
@@ -14628,6 +15705,10 @@ var resolvedTileflowMapSchema = z7.object({
   systemThemes: systemThemesSchema.optional(),
   terrain: terrainSchema.optional(),
   themes: themesSchema,
+  timeOfDay: createTileflowTimeOfDaySchema(
+    classicManifestSchemaOperations,
+    tileflowThemeNameSchema
+  ).optional(),
   version: z7.number().int().positive(),
   view: viewSchema.optional()
 }).strict().superRefine((map, context) => {
@@ -14652,6 +15733,15 @@ var resolvedTileflowMapSchema = z7.object({
       path: ["defaultTheme"]
     });
   }
+  if (map.timeOfDay) {
+    for (const issue of validateTileflowTimeOfDayVariants(map.timeOfDay, map.themes)) {
+      context.addIssue({
+        code: "custom",
+        message: issue.message,
+        path: ["timeOfDay", ...issue.path]
+      });
+    }
+  }
   const themeEntries = Object.entries(map.themes).sort(
     ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
   );
@@ -14874,6 +15964,46 @@ function tileflowRouteMetadata(inks) {
   return Object.freeze({ version: 1, ...inks });
 }
 
+// src/street-lights.ts
+init_theme_blend();
+var tileflowStreetLightsMetadataKey = "tileflow:street-lights";
+var tileflowDefaultStreetLightsDesign = Object.freeze({
+  source: "tileflow",
+  layers: Object.freeze({
+    streetFurniture: "street_furniture",
+    transportation: "transportation",
+    sidewalk: "sidewalk"
+  }),
+  estimate: "lit",
+  color: "#ffcf8f",
+  intensity: 1
+});
+function tileflowStreetLightsMetadata(design) {
+  return { version: 1, ...design };
+}
+function readTileflowStreetLights(metadata) {
+  if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata))
+    return void 0;
+  const value = metadata[tileflowStreetLightsMetadataKey];
+  if (typeof value !== "object" || value === null || value.version !== 1) return void 0;
+  const layers = value.layers;
+  if (typeof value.source !== "string" || typeof layers?.streetFurniture !== "string" || typeof layers.transportation !== "string")
+    return void 0;
+  const estimate = ["lit", "streets", "none"].find((name) => name === value.estimate);
+  const intensity = typeof value.intensity === "number" && value.intensity >= 0 && value.intensity <= 2 ? value.intensity : 1;
+  return {
+    source: value.source,
+    layers: {
+      streetFurniture: layers.streetFurniture,
+      transportation: layers.transportation,
+      ...typeof layers.sidewalk === "string" ? { sidewalk: layers.sidewalk } : {}
+    },
+    estimate: estimate ?? "lit",
+    color: typeof value.color === "string" && tileflowColourChannels(value.color) ? value.color : tileflowDefaultStreetLightsDesign.color,
+    intensity
+  };
+}
+
 // src/cartography/streets.ts
 init_sun();
 
@@ -15055,7 +16185,7 @@ function terrainContribution(target, localOrder, layer) {
   };
 }
 function applyLayerRange2(layer, range2) {
-  const layout = { ...asRecord6(layer.layout) };
+  const layout = { ...asRecord7(layer.layout) };
   if (range2.visible !== void 0) layout.visibility = range2.visible ? "visible" : "none";
   return {
     ...layer,
@@ -15064,10 +16194,39 @@ function applyLayerRange2(layer, range2) {
     ...Object.keys(layout).length === 0 ? {} : { layout }
   };
 }
-function asRecord6(value) {
+function asRecord7(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
+// src/vegetation-display.ts
+var tileflowVegetationDisplayMetadataKey = "tileflow:vegetation-display";
+function readTileflowVegetationDisplay(metadata) {
+  if (!metadata || typeof metadata !== "object") return void 0;
+  const value = metadata[tileflowVegetationDisplayMetadataKey];
+  if (value && typeof value === "object") {
+    const policy = value;
+    if (policy.version !== 1 || !["3d", "flat", "auto"].includes(policy.mode ?? "") || !["flat", "none"].includes(policy.fallback ?? "") || typeof policy.visible !== "boolean" || !Array.isArray(policy.flatLayers) || !policy.flatLayers.every(
+      (layer) => layer && typeof layer.id === "string" && typeof layer.visible === "boolean"
+    ))
+      return void 0;
+    return policy;
+  }
+  const legacy = readTileflowVegetation3D(metadata);
+  return legacy ? {
+    version: 1,
+    mode: "3d",
+    fallback: "flat",
+    visible: true,
+    flatLayers: legacy.flatLayers.map((id2) => ({ id: id2, visible: true }))
+  } : void 0;
+}
+function resolveTileflowVegetationRepresentation(policy, options) {
+  if (!policy || !(options.visible ?? policy.visible)) return "none";
+  if (policy.mode === "flat" || policy.mode === "auto" && options.viewMode !== "3d")
+    return "flat";
+  return options.supports3D ? "3d" : policy.fallback;
+}
+
 // src/cartography/graph.ts
 function assembleTileflowLayerFamilies(families, extraConstraints = []) {
   const slotOrder = resolveSlotOrder(extraConstraints);
@@ -15470,14 +16629,16 @@ function defaultPaint(image, key, names, appearances, ids) {
 
 // src/cartography/interaction-manifest.ts
 var tileflowInteractionManifestMetadataKey = "tileflow:interaction-manifest";
-var tileflowInteractionManifestVersion = 2;
+var tileflowInteractionManifestVersion = 3;
 function createTileflowInteractionManifest(layers, fields) {
   const poiLayers = layers.flatMap((layer, priority) => {
     const id2 = typeof layer.id === "string" ? layer.id : void 0;
     const source = typeof layer.source === "string" ? layer.source : void 0;
     const sourceLayer = typeof layer["source-layer"] === "string" ? layer["source-layer"] : void 0;
     const target = semanticTarget(layer);
-    if (!id2 || !source || !sourceLayer || !target?.startsWith("poi.")) return [];
+    if (!id2 || !source || !sourceLayer || target !== "poi" && !target?.startsWith("poi.")) {
+      return [];
+    }
     const parsed = parsePoiTarget(target);
     if (!parsed) return [];
     return [
@@ -15525,7 +16686,7 @@ function assertTileflowInteractionManifestLayers(manifest, layers) {
     );
   }
   for (const layer of poiLayers) {
-    if (!isTileflowPoiCategory(layer.category) || !isSafeArtifactName(layer.layerId) || !isSafeArtifactName(layer.source) || !isSafeArtifactName(layer.sourceLayer)) {
+    if (!isSafeArtifactName(layer.layerId) || !isSafeArtifactName(layer.source) || !isSafeArtifactName(layer.sourceLayer)) {
       throw new Error("Tileflow interaction manifest contains an invalid physical POI lookup.");
     }
     const finalized = layersById.get(layer.layerId);
@@ -15548,25 +16709,26 @@ function assertTileflowInteractionManifestLayers(manifest, layers) {
 }
 function parsePoiTarget(target) {
   const segments = target.split(".");
-  if (segments[0] !== "poi" || segments.length < 2 || segments.length > 3) return void 0;
-  const category = segments[1];
-  if (!isTileflowPoiCategory(category)) return void 0;
-  const suffix = segments[2];
-  if (suffix === void 0) return { category, representation: "combined" };
-  if (suffix === "icon" || suffix === "label" || suffix === "marker") {
-    return { category, representation: suffix };
-  }
-  return void 0;
+  if (segments[0] !== "poi" || segments.length > 3) return void 0;
+  const [, first, second] = segments;
+  if (first === void 0) return { representation: "combined" };
+  if (segments.length === 2 && isRepresentationPart(first)) return { representation: first };
+  if (first !== "prominent" && !isTileflowPoiCategory(first)) return void 0;
+  if (second === void 0) return { representation: "combined" };
+  return isRepresentationPart(second) ? { representation: second } : void 0;
+}
+function isRepresentationPart(value) {
+  return value === "icon" || value === "label" || value === "marker";
 }
 function isTileflowPoiCategory(value) {
   return typeof value === "string" && tileflowPoiCategories.includes(value);
 }
 function semanticTarget(layer) {
-  if (!isRecord11(layer.metadata)) return void 0;
+  if (!isRecord10(layer.metadata)) return void 0;
   const value = layer.metadata[tileflowCompilerMetadataKeys.target];
   return typeof value === "string" ? value : void 0;
 }
-function isRecord11(value) {
+function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSafeArtifactName(value) {
@@ -16228,12 +17390,12 @@ function combinePatternValues(entries, minimumRelevantZoom) {
   if (entries.some(({ value }) => containsZoom(value) && !isZoomStep(value))) {
     return { ok: false };
   }
-  const steps = entries.flatMap(({ value }) => isZoomStep(value) ? [value] : []);
-  if (steps.length === 0) {
+  const steps2 = entries.flatMap(({ value }) => isZoomStep(value) ? [value] : []);
+  if (steps2.length === 0) {
     return { ok: true, value: conditionalExpression(entries, entries[0]?.value) };
   }
   const stops = /* @__PURE__ */ new Set([minimumRelevantZoom]);
-  for (const step2 of steps) {
+  for (const step2 of steps2) {
     for (let index = 3; index < step2.length; index += 2) {
       const stop = step2[index];
       if (typeof stop === "number" && stop >= minimumRelevantZoom) stops.add(stop);
@@ -16291,7 +17453,7 @@ function conditionalExpression(entries, fallback) {
     ];
   }
   const classMatches = entries.map(({ condition }) => splitClassMatch(condition));
-  if (classMatches.every((match2) => match2 !== void 0) && allEqual(classMatches.map((match2) => match2?.field)) && allEqual(classMatches.map((match2) => match2?.remainder)) && classMatchLabelsAreDisjoint(classMatches.map((match2) => match2.labels))) {
+  if (classMatches.every((match3) => match3 !== void 0) && allEqual(classMatches.map((match3) => match3?.field)) && allEqual(classMatches.map((match3) => match3?.remainder)) && classMatchLabelsAreDisjoint(classMatches.map((match3) => match3.labels))) {
     return [
       "match",
       ["get", classMatches[0].field],
@@ -16455,6 +17617,115 @@ function stableSerialize(value) {
   return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableSerialize(entry)}`).join(",")}}`;
 }
 
+// src/cartography/scene-3d-metadata.ts
+init_values();
+var colourSources = [
+  ["tileflow-buildings-render-extrusion", "fill-extrusion-color"],
+  ["tileflow-buildings-3d", "fill-extrusion-color"],
+  ["tileflow-buildings-fill", "fill-color"]
+];
+function tileflowBuildings3DDesignOf(module, context, layers, buildingModels, tileflowLandmarks) {
+  const config = isRecord11(module) ? module : {};
+  if (config.enabled === false) return void 0;
+  const style = config.threeDimensional ?? {};
+  let color3;
+  let verticalGradient = true;
+  for (const [id2, property] of colourSources) {
+    const value = layers.find((layer) => layer.id === id2)?.paint?.[property];
+    if (typeof value === "string" || Array.isArray(value)) {
+      color3 = value;
+      verticalGradient = layers.find((layer) => layer.id === id2)?.paint?.["fill-extrusion-vertical-gradient"] !== false;
+      break;
+    }
+  }
+  const number = (value, fallback) => {
+    const resolved = value === void 0 ? void 0 : toMapLibreStyleValue(value);
+    return typeof resolved === "number" ? resolved : fallback;
+  };
+  const edgeColor = style.edgeColor === void 0 ? void 0 : toMapLibreStyleValue(style.edgeColor);
+  return {
+    source: context.data.sourceId,
+    layers: {
+      building: context.data.schema.layers.building,
+      ...context.data.schema.layers.poi ? { places: context.data.schema.layers.poi } : {}
+    },
+    color: color3 ?? context.colors.buildings.generic,
+    lighting: style.lighting === "sun" ? "sun" : "style",
+    colorVariation: number(style.colorVariation, 0),
+    verticalGradient,
+    edges: number(style.edges, 0),
+    ...typeof edgeColor === "string" ? { edgeColor } : {},
+    nightLight: number(style.nightLight, 0),
+    windows: style.windows === true,
+    shadows: style.shadows === true,
+    occlusion: style.occlusion === true,
+    ...placedModels(style.models, buildingModels),
+    ...modelColours(style.modelColors),
+    ...landmarksOf2(style.landmarks, tileflowLandmarks)
+  };
+}
+function landmarksOf2(value, tileflowLandmarks) {
+  if (value === false) return {};
+  if (isRecord11(value) && typeof value.url === "string") return { landmarks: { url: value.url } };
+  return tileflowLandmarks ? { landmarks: { url: tileflowLandmarks } } : {};
+}
+function placedModels(value, served) {
+  if (!Array.isArray(value) || value.length === 0) return {};
+  const placements = value;
+  const missing = [
+    ...new Set(
+      placements.filter((entry) => !entry.url).map((entry) => entry.model).filter((id2) => !served?.[id2])
+    )
+  ].sort();
+  if (missing.length > 0)
+    throw new Error(
+      `The buildings module places missing 3D models: ${missing.join(", ")}. Add ${missing.map((id2) => `${id2}.glb`).join(
+        ", "
+      )} to a map.models directory, with materials named surface, secondary, glass, accent or roof, and run the Node build so the directories are prepared.`
+    );
+  return {
+    models: placements.map((entry) => ({
+      model: entry.model,
+      url: entry.url ?? served[entry.model],
+      at: [entry.at[0], entry.at[1]],
+      heading: ((entry.heading ?? 0) % 360 + 360) % 360
+    }))
+  };
+}
+function modelColours(value) {
+  if (!isRecord11(value)) return {};
+  const colours = {};
+  for (const [part, colour] of Object.entries(value)) {
+    const resolved = colour === void 0 ? void 0 : toMapLibreStyleValue(colour);
+    if (typeof resolved === "string") colours[part] = resolved;
+  }
+  return Object.keys(colours).length > 0 ? { modelColors: colours } : {};
+}
+function tileflowStreetLightsDesignOf(module, context) {
+  const config = isRecord11(module) ? module : {};
+  const layers = context.data.schema.layers;
+  const style = config.streetLights ?? {};
+  if (config.enabled === false || style.enabled === false || !layers.streetFurniture)
+    return void 0;
+  const color3 = style.color === void 0 ? void 0 : toMapLibreStyleValue(style.color);
+  const intensity = style.intensity === void 0 ? void 0 : toMapLibreStyleValue(style.intensity);
+  const estimate = style.estimate;
+  return {
+    source: context.data.sourceId,
+    layers: {
+      streetFurniture: layers.streetFurniture,
+      transportation: layers.road,
+      ...layers.sidewalk ? { sidewalk: layers.sidewalk } : {}
+    },
+    estimate: estimate === "streets" || estimate === "none" || estimate === "lit" ? estimate : "lit",
+    color: typeof color3 === "string" ? color3 : tileflowDefaultStreetLightsDesign.color,
+    intensity: typeof intensity === "number" ? intensity : 1
+  };
+}
+function isRecord11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/cartography/semantic-compiler.ts
 var tileflowSemanticCompilerIdentity = Object.freeze({
   name: "tileflow-semantic",
@@ -16504,7 +17775,10 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     suggestion,
     ...target ? { target } : {}
   }));
-  const selected = runCompilationPhase("theme", () => resolveThemeSelection(input, options.theme));
+  const selected = runCompilationPhase(
+    "theme",
+    () => resolveThemeSelection(input, options.theme, options.timeOfDay)
+  );
   const resolvedTheme = runCompilationPhase("theme", () => resolveTileflowTheme(selected.theme));
   const { overlays, themes: _themes, ...themeableConfig } = input;
   const resolvedThemeConfig = runCompilationPhase(
@@ -16785,7 +18059,9 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   const buildings3D = tileflowBuildings3DDesignOf(
     modules.buildings,
     context,
-    layers
+    layers,
+    options.preparedAssets?.buildingModels,
+    data.kind === "tileflow-world" ? `${apiBaseUrl}/landmarks/tiles.json` : void 0
   );
   const streetLights = tileflowStreetLightsDesignOf(
     modules.roads,
@@ -16838,6 +18114,24 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       layers
     })
   );
+  const flatVegetationLayers = layers.filter((layer) => {
+    const metadata = layer.metadata;
+    return metadata?.["tileflow:vegetation-mode"] !== void 0 || metadata?.["tileflow:domain"] === "vegetation";
+  });
+  const vegetationDisplay = flatVegetationLayers.length || vegetation3D ? {
+    version: 1,
+    mode: modules.vegetation?.mode ?? "3d",
+    fallback: modules.vegetation?.fallback ?? "flat",
+    visible: modules.vegetation?.visible ?? true,
+    flatLayers: flatVegetationLayers.map((layer) => ({
+      id: String(layer.id),
+      visible: layer.layout?.visibility !== "none"
+    }))
+  } : void 0;
+  if (vegetationDisplay && (!vegetationDisplay.visible || vegetationDisplay.mode === "3d" && vegetationDisplay.fallback === "none")) {
+    for (const layer of flatVegetationLayers)
+      layer.layout = { ...layer.layout, visibility: "none" };
+  }
   const atmosphere = resolveTileflowAtmosphere(config.atmosphere);
   const style = {
     ...atmosphere ? { sky: compileTileflowSky(atmosphere) } : {},
@@ -16877,12 +18171,10 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
         [tileflowVegetationMetadataKey]: tileflowVegetationMetadata({
           ...bindSemanticReferences(vegetation3D, semanticData),
           // The layers that draw the trees flat: the module's own and its render passes.
-          flatLayers: layers.filter((layer) => {
-            const metadata = layer.metadata;
-            return metadata?.["tileflow:vegetation-mode"] !== void 0 || metadata?.["tileflow:domain"] === "vegetation";
-          }).map((layer) => String(layer.id))
+          flatLayers: flatVegetationLayers.map((layer) => String(layer.id))
         })
       } : {},
+      ...vegetationDisplay ? { [tileflowVegetationDisplayMetadataKey]: vegetationDisplay } : {},
       "tileflow:data": data.identity,
       "tileflow:sources": sourceIdentities,
       ...Object.keys(loweredOverlays.identities).length > 0 ? { "tileflow:overlays": loweredOverlays.identities } : {},
@@ -17268,6 +18560,7 @@ var tileflowMapMergeStrategies = {
   systemThemes: "atomic",
   terrain: "atomic",
   themes: "atomic",
+  timeOfDay: "atomic",
   version: "identity",
   view: "deep"
 };
@@ -17282,7 +18575,10 @@ function resolveMap(map, options = {}) {
   for (let index = lineage.length - 1; index >= 0; index -= 1) {
     const current = lineage[index];
     const currentId = current.id;
-    if (current.themes !== void 0) delete design.systemThemes;
+    if (current.themes !== void 0) {
+      delete design.systemThemes;
+      delete design.timeOfDay;
+    }
     for (const key of Object.keys(current)) {
       const value = current[key];
       const strategy = tileflowMapMergeStrategies[key];
@@ -18472,7 +19768,7 @@ function analyzeTileflowStylePerformance(style, zooms = defaultZoomSamples(style
 function isLayerActive(layer, zoom3) {
   const minimum2 = typeof layer.minzoom === "number" ? layer.minzoom : 0;
   const maximum2 = typeof layer.maxzoom === "number" ? layer.maxzoom : Infinity;
-  const layout = asRecord7(layer.layout);
+  const layout = asRecord8(layer.layout);
   return minimum2 <= zoom3 && zoom3 < maximum2 && layout.visibility !== "none";
 }
 function bucketSignature(layer) {
@@ -18513,7 +19809,7 @@ function stableStringify(value) {
 function compareCodeUnits10(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
-function asRecord7(value) {
+function asRecord8(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
@@ -18667,7 +19963,7 @@ async function sha256Hex(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("");
+  return Array.from(new Uint8Array(digest), (byte2) => byte2.toString(16).padStart(2, "0")).join("");
 }
 async function hashTileflowIconPackageManifest(input) {
   return sha256Hex(serializeTileflowIconPackageManifest(input));
@@ -18916,6 +20212,7 @@ function packageBytes(manifest) {
 
 // src/runtime.ts
 init_portable_identity_rules();
+init_time_of_day();
 var defaultTileflowManifestUrl = "/tileflow/manifest.json";
 var defaultTileflowRuntimeView = Object.freeze({
   bearing: 0,
@@ -18997,7 +20294,8 @@ function resolveTileflowRuntimeStyle(options) {
     const theme = resolveTileflowRuntimeTheme(
       options.manifestMap,
       options.theme,
-      options.colorScheme
+      options.colorScheme,
+      options.timeOfDay
     );
     return {
       analytics: {
@@ -19014,7 +20312,7 @@ function resolveTileflowRuntimeStyle(options) {
   }
   return null;
 }
-function resolveTileflowRuntimeTheme(map, selection2, colorScheme) {
+function resolveTileflowRuntimeTheme(map, selection2, colorScheme, timeOfDay) {
   let name;
   if (selection2 === void 0) {
     name = map.defaultTheme;
@@ -19036,6 +20334,8 @@ function resolveTileflowRuntimeTheme(map, selection2, colorScheme) {
       `Tileflow resolved invalid theme ${JSON.stringify(name)} for map "${map.name}"; expected a concrete portable theme name.`
     );
   }
+  if (Object.hasOwn(map.themes, name))
+    name = resolveTileflowTimeOfDayTheme(map.timeOfDay, name, timeOfDay);
   const theme = Object.hasOwn(map.themes, name) ? map.themes[name] : void 0;
   if (!theme) {
     const available = Object.keys(map.themes).sort().join(", ");
@@ -19571,6 +20871,7 @@ function resolveTileflowManifestMap(manifest, mapName) {
     defaultTheme: entry.defaultTheme,
     ...entry.environment ? { environment: entry.environment } : {},
     ...entry.systemThemes ? { systemThemes: { ...entry.systemThemes } } : {},
+    ...entry.timeOfDay ? { timeOfDay: entry.timeOfDay } : {},
     themes: entry.themes,
     usageMode: entry.usageMode,
     view: entry.view,
@@ -19588,7 +20889,12 @@ function resolveTileflowStaticImageUrl(input) {
   const apiUrl = normalizeTileflowUrl(input.manifestMap.apiUrl ?? "https://api.tileflow.dev");
   const mapId = encodeURIComponent(input.manifestMap.mapId);
   const url = new URL(`/maps/${mapId}/static.png`, apiUrl);
-  const theme = resolveTileflowRuntimeTheme(input.manifestMap, input.theme, input.colorScheme);
+  const theme = resolveTileflowRuntimeTheme(
+    input.manifestMap,
+    input.theme,
+    input.colorScheme,
+    input.timeOfDay
+  );
   url.searchParams.set("center", input.center.join(","));
   url.searchParams.set("theme", theme.name);
   url.searchParams.set("zoom", String(input.zoom));
@@ -19704,13 +21010,13 @@ function assertSafeManifestRequestUrl(value) {
 function inferTileflowAnalyticsFromStyleUrl(styleUrl) {
   try {
     const url = new URL(styleUrl, getTileflowLocationOrigin());
-    const match2 = url.pathname.match(/^\/maps\/([^/]+)\/style\.json$/);
-    if (!match2?.[1]) {
+    const match3 = url.pathname.match(/^\/maps\/([^/]+)\/style\.json$/);
+    if (!match3?.[1]) {
       return void 0;
     }
     return {
       apiUrl: url.origin,
-      mapId: match2[1],
+      mapId: match3[1],
       styleId: url.toString()
     };
   } catch {
@@ -20220,7 +21526,7 @@ function decodeTileflowTreeModel(text, level) {
   } catch {
     return void 0;
   }
-  if (bytes.length < headerBytes || magic.some((byte, index) => bytes[index] !== byte))
+  if (bytes.length < headerBytes || magic.some((byte2, index) => bytes[index] !== byte2))
     return void 0;
   const view = new DataView(bytes.buffer);
   const count = view.getUint16(6, true);
@@ -20257,6 +21563,653 @@ function decodeTileflowTreeModel(text, level) {
 function clamp(value, low, high) {
   return Number.isFinite(value) ? Math.min(high, Math.max(low, value)) : 0;
 }
+
+// src/models-3d-file.ts
+var tileflowModelContentType = "model/gltf-binary";
+var levelNames = ["near", "mid", "far"];
+var meshopt = "EXT_meshopt_compression";
+var quantisation = "KHR_mesh_quantization";
+var steps = 32767;
+var partCount2 = Object.keys(tileflowModelParts).length;
+var modelId2 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var [glbMagic, jsonChunk, binChunk] = [1179937895, 1313821514, 5130562];
+var [short, byte, unsignedByte, unsignedShort, unsignedInt] = [5122, 5120, 5121, 5123, 5125];
+function encodeTileflowModels(models, compressor) {
+  if (models.length < 1 || models.length > tileflowModelLimits.models)
+    throw new RangeError(`A model file holds 1 to ${tileflowModelLimits.models} models.`);
+  if (new Set(models.map((model) => model.id)).size !== models.length)
+    throw new RangeError("The models of a file have different ids.");
+  const extensions = compressor ? [meshopt, quantisation] : [quantisation];
+  const nodes = [];
+  const meshes = [];
+  const accessors = [];
+  const bufferViews = [];
+  const roots = [];
+  const blobs = [];
+  let binLength = 0;
+  let fallbackLength = 0;
+  const addBlob = (bytes) => {
+    const padding = (4 - binLength % 4) % 4;
+    if (padding) blobs.push(new Uint8Array(padding));
+    const offset = binLength + padding;
+    blobs.push(bytes);
+    binLength = offset + bytes.byteLength;
+    return offset;
+  };
+  const addView = (bytes, count, stride, vertices) => {
+    const target = vertices ? 34962 : 34963;
+    if (!compressor) {
+      const byteOffset2 = addBlob(bytes);
+      bufferViews.push({
+        buffer: 0,
+        byteOffset: byteOffset2,
+        byteLength: bytes.byteLength,
+        ...vertices ? { byteStride: stride } : {},
+        target
+      });
+      return bufferViews.length - 1;
+    }
+    const mode = vertices ? "ATTRIBUTES" : "TRIANGLES";
+    const packed = compressor.encodeGltfBuffer(bytes, count, stride, mode);
+    const byteOffset = addBlob(packed);
+    const fallbackOffset = fallbackLength;
+    fallbackLength += bytes.byteLength + (4 - bytes.byteLength % 4) % 4;
+    bufferViews.push({
+      buffer: 1,
+      byteOffset: fallbackOffset,
+      byteLength: bytes.byteLength,
+      ...vertices ? { byteStride: stride } : {},
+      target,
+      extensions: {
+        [meshopt]: {
+          buffer: 0,
+          byteOffset,
+          byteLength: packed.byteLength,
+          byteStride: stride,
+          count,
+          mode
+        }
+      }
+    });
+    return bufferViews.length - 1;
+  };
+  for (const model of models) {
+    checkModel(model);
+    const children = [];
+    for (const [index, mesh] of model.levels.entries()) {
+      const level = quantise(mesh, compressor);
+      const vertexView = addView(level.vertices, level.count, tileflowModelVertexBytes, true);
+      const width = level.indices instanceof Uint32Array ? 4 : 2;
+      const indexView = addView(
+        new Uint8Array(level.indices.buffer, level.indices.byteOffset, level.indices.byteLength),
+        level.indices.length,
+        width,
+        false
+      );
+      const first = accessors.length;
+      accessors.push(
+        {
+          bufferView: vertexView,
+          byteOffset: 0,
+          componentType: short,
+          count: level.count,
+          type: "VEC3",
+          min: level.min,
+          max: level.max
+        },
+        {
+          bufferView: vertexView,
+          byteOffset: 8,
+          componentType: byte,
+          normalized: true,
+          count: level.count,
+          type: "VEC3"
+        },
+        {
+          bufferView: vertexView,
+          byteOffset: 12,
+          componentType: unsignedByte,
+          count: level.count,
+          type: "VEC3"
+        },
+        {
+          bufferView: indexView,
+          componentType: width === 4 ? unsignedInt : unsignedShort,
+          count: level.indices.length,
+          type: "SCALAR"
+        }
+      );
+      meshes.push({
+        primitives: [
+          {
+            attributes: { POSITION: first, NORMAL: first + 1, _PAINT: first + 2 },
+            indices: first + 3,
+            mode: 4
+          }
+        ]
+      });
+      children.push(nodes.length);
+      nodes.push({
+        name: levelNames[index],
+        mesh: meshes.length - 1,
+        translation: [...level.centre],
+        scale: [level.step, level.step, level.step]
+      });
+    }
+    roots.push(nodes.length);
+    nodes.push({
+      name: model.id,
+      children,
+      extras: {
+        tileflow: {
+          model: model.id,
+          footprint: model.footprint.map((ring) => ring.map((value) => round2(value, 100))),
+          ...model.at ? { at: [model.at[0], model.at[1]] } : {},
+          ...model.heading !== void 0 ? { heading: model.heading } : {}
+        }
+      }
+    });
+  }
+  const json = {
+    asset: { version: "2.0", generator: "Tileflow" },
+    extensionsUsed: extensions,
+    extensionsRequired: extensions,
+    scene: 0,
+    scenes: [{ nodes: roots }],
+    nodes,
+    meshes,
+    accessors,
+    bufferViews,
+    buffers: [
+      { byteLength: binLength },
+      ...compressor ? [{ byteLength: fallbackLength, extensions: { [meshopt]: { fallback: true } } }] : []
+    ]
+  };
+  const file = glb(new TextEncoder().encode(JSON.stringify(json)), blobs, binLength);
+  if (file.byteLength > tileflowModelLimits.bytes)
+    throw new RangeError(`A prepared model file is at most ${tileflowModelLimits.bytes} bytes.`);
+  return file;
+}
+async function decodeTileflowModels(buffer, decompressor) {
+  try {
+    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    const { json, bin } = readGlb(bytes);
+    const required = Array.isArray(json.extensionsRequired) ? json.extensionsRequired : [];
+    if (json.asset?.version !== "2.0" || required.some((name) => name !== meshopt && name !== quantisation))
+      return void 0;
+    const views = json.bufferViews ?? [];
+    const compressed = views.some((view) => view?.extensions?.[meshopt]);
+    const decoder = compressed ? decompressor ?? await meshoptDecoder() : void 0;
+    const decoded = /* @__PURE__ */ new Map();
+    const viewBytes = (index, stride, length) => {
+      const view = views[index];
+      if (!Number.isInteger(index) || !view || view.byteLength !== length) throw new Error();
+      if ((view.byteStride ?? stride) !== stride) throw new Error();
+      const cached = decoded.get(index);
+      if (cached) return cached;
+      const packed = view.extensions?.[meshopt];
+      let out;
+      if (packed) {
+        const {
+          buffer: source,
+          byteOffset = 0,
+          byteLength,
+          byteStride,
+          count,
+          mode,
+          filter
+        } = packed;
+        if (source !== 0 || byteStride !== stride || count * byteStride !== length)
+          throw new Error();
+        if (filter !== void 0 && filter !== "NONE") throw new Error();
+        if (mode !== (stride === tileflowModelVertexBytes ? "ATTRIBUTES" : "TRIANGLES"))
+          throw new Error();
+        out = new Uint8Array(length);
+        decoder.decodeGltfBuffer(out, count, byteStride, slice(bin, byteOffset, byteLength), mode);
+      } else {
+        if (view.buffer !== 0) throw new Error();
+        out = slice(bin, view.byteOffset ?? 0, length).slice();
+      }
+      decoded.set(index, out);
+      return out;
+    };
+    const roots = json.scenes?.[json.scene ?? 0]?.nodes ?? [];
+    if (roots.length < 1 || roots.length > tileflowModelLimits.models) return void 0;
+    const models = [];
+    for (const root of roots) {
+      const node2 = json.nodes?.[root];
+      const model = readModelNode(node2);
+      const children = Array.isArray(node2.children) ? node2.children : [];
+      if (children.length < 1 || children.length > tileflowModelLimits.levels) return void 0;
+      const levels = [];
+      const bounds = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+      for (const [at, child] of children.entries()) {
+        const level = readLevelNode(
+          json,
+          json.nodes?.[child],
+          levelNames[at],
+          viewBytes
+        );
+        const low = level.min.map((value, axis) => level.centre[axis] + value * level.step);
+        const high = level.max.map((value, axis) => level.centre[axis] + value * level.step);
+        const box = [low[0], -high[2], low[1], high[0], -low[2], high[1]];
+        for (let axis = 0; axis < 3; axis += 1) {
+          bounds[axis] = Math.min(bounds[axis], box[axis]);
+          bounds[axis + 3] = Math.max(bounds[axis + 3], box[axis + 3]);
+        }
+        levels.push({
+          vertices: level.vertices,
+          indices: level.indices,
+          centre: level.centre,
+          step: level.step
+        });
+      }
+      models.push({
+        ...model,
+        bounds,
+        levels
+      });
+    }
+    return models;
+  } catch {
+    return void 0;
+  }
+}
+var decoderLoad;
+function meshoptDecoder() {
+  decoderLoad ??= Promise.resolve().then(() => (init_meshopt_decoder(), meshopt_decoder_exports)).then(
+    async ({ MeshoptDecoder: MeshoptDecoder2 }) => {
+      await MeshoptDecoder2.ready;
+      return MeshoptDecoder2;
+    },
+    (error) => {
+      decoderLoad = void 0;
+      throw error;
+    }
+  );
+  return decoderLoad;
+}
+function quantise(mesh, compressor) {
+  const count = mesh.positions.length / 3;
+  const axes = (index) => [
+    mesh.positions[index * 3],
+    mesh.positions[index * 3 + 2],
+    -mesh.positions[index * 3 + 1]
+  ];
+  const low = [Infinity, Infinity, Infinity];
+  const high = [-Infinity, -Infinity, -Infinity];
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    const point = axes(vertex);
+    for (let axis = 0; axis < 3; axis += 1) {
+      low[axis] = Math.min(low[axis], point[axis]);
+      high[axis] = Math.max(high[axis], point[axis]);
+    }
+  }
+  const centre = low.map((value, axis) => round2((value + high[axis]) / 2, 1e3));
+  const reach = Math.max(
+    ...low.map((value, axis) => Math.max(centre[axis] - value, high[axis] - centre[axis]))
+  );
+  const step2 = Math.max(reach, 1e-3) / steps;
+  const raw = new Uint8Array(count * tileflowModelVertexBytes);
+  const view = new DataView(raw.buffer);
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    const at = vertex * tileflowModelVertexBytes;
+    const point = axes(vertex);
+    for (let axis = 0; axis < 3; axis += 1)
+      view.setInt16(
+        at + axis * 2,
+        clamp2(Math.round((point[axis] - centre[axis]) / step2), -steps, steps),
+        true
+      );
+    const [nx, ny, nz] = [
+      mesh.normals[vertex * 3],
+      mesh.normals[vertex * 3 + 1],
+      mesh.normals[vertex * 3 + 2]
+    ];
+    const length = Math.hypot(nx, ny, nz) || 1;
+    const normal = [nx / length, nz / length, -ny / length];
+    for (let axis = 0; axis < 3; axis += 1)
+      view.setInt8(at + 8 + axis, clamp2(Math.round(normal[axis] * 127), -127, 127));
+    const part = mesh.parts[vertex];
+    if (!Number.isInteger(part) || part < 0 || part >= partCount2)
+      throw new RangeError(`Vertex ${vertex} has no part.`);
+    raw[at + 12] = part;
+    raw[at + 13] = Math.round((clamp2(mesh.shades[vertex], -1, 1) + 1) / 2 * 255);
+    raw[at + 14] = Math.round(clamp2(mesh.occlusion[vertex], 0, 1) * 255);
+  }
+  const words = new Uint32Array(raw.buffer);
+  const seen = /* @__PURE__ */ new Map();
+  const weld = new Uint32Array(count);
+  const kept = [];
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    const w = vertex * 4;
+    const key = `${words[w]},${words[w + 1]},${words[w + 2]},${words[w + 3]}`;
+    let index = seen.get(key);
+    if (index === void 0) {
+      index = kept.length;
+      seen.set(key, index);
+      kept.push(vertex);
+    }
+    weld[vertex] = index;
+  }
+  const indices = new Uint32Array(mesh.indices.length);
+  for (const [position, vertex] of mesh.indices.entries()) {
+    if (!Number.isInteger(vertex) || vertex < 0 || vertex >= count)
+      throw new RangeError(`Index ${position} names no vertex.`);
+    indices[position] = weld[vertex];
+  }
+  let order = kept;
+  if (compressor) {
+    const [remap, unique] = compressor.reorderMesh(indices, true, true);
+    order = new Array(unique);
+    for (const [index, vertex] of kept.entries())
+      if (remap[index] !== 4294967295) order[remap[index]] = vertex;
+  }
+  const vertices = new Uint8Array(order.length * tileflowModelVertexBytes);
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (const [index, vertex] of order.entries()) {
+    vertices.set(
+      raw.subarray(vertex * tileflowModelVertexBytes, (vertex + 1) * tileflowModelVertexBytes),
+      index * tileflowModelVertexBytes
+    );
+    for (let axis = 0; axis < 3; axis += 1) {
+      const value = view.getInt16(vertex * tileflowModelVertexBytes + axis * 2, true);
+      min[axis] = Math.min(min[axis], value);
+      max[axis] = Math.max(max[axis], value);
+    }
+  }
+  return {
+    vertices,
+    indices: order.length > 65535 ? indices : Uint16Array.from(indices),
+    count: order.length,
+    centre,
+    step: step2,
+    min,
+    max
+  };
+}
+function checkModel(model) {
+  const { id: id2, levels, footprint } = model;
+  if (!modelId2.test(id2) || id2.length > 64)
+    throw new RangeError(`"${id2}" is not a model id: lower-case words joined by hyphens.`);
+  if (levels.length < 1 || levels.length > tileflowModelLimits.levels)
+    throw new RangeError(`A model has 1 to ${tileflowModelLimits.levels} levels of detail.`);
+  const bounds = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+  for (const [at, level] of levels.entries()) {
+    const count = level.positions.length / 3;
+    const triangles = level.indices.length / 3;
+    if (!Number.isInteger(count) || count < 3 || count > tileflowModelLimits.vertices)
+      throw new RangeError(`Level ${at} has 3 to ${tileflowModelLimits.vertices} vertices.`);
+    if (!Number.isInteger(triangles) || triangles < 1 || triangles > tileflowModelLimits.triangles)
+      throw new RangeError(`Level ${at} has 1 to ${tileflowModelLimits.triangles} triangles.`);
+    if (level.normals.length !== count * 3)
+      throw new RangeError(`Every vertex of level ${at} needs a position and a normal.`);
+    for (const list of [level.parts, level.shades, level.occlusion])
+      if (list.length !== count)
+        throw new RangeError(`Every vertex of level ${at} needs a part, a shade and a light.`);
+    for (let index = 0; index < count; index += 1)
+      for (let axis = 0; axis < 3; axis += 1) {
+        const value = level.positions[index * 3 + axis];
+        if (!Number.isFinite(value)) throw new RangeError(`Level ${at} has a vertex at no place.`);
+        bounds[axis] = Math.min(bounds[axis], value);
+        bounds[axis + 3] = Math.max(bounds[axis + 3], value);
+      }
+  }
+  const radius = Math.max(...[0, 1, 3, 4].map((axis) => Math.abs(bounds[axis])));
+  if (radius > tileflowModelLimits.radius)
+    throw new RangeError(
+      `A model reaches at most ${tileflowModelLimits.radius} m from its origin.`
+    );
+  if (bounds[2] < -0.5)
+    throw new RangeError("A model stands on the ground: no vertex lies more than 0.5 m below it.");
+  if (bounds[5] > tileflowModelLimits.height)
+    throw new RangeError(`A model is at most ${tileflowModelLimits.height} m tall.`);
+  if (footprint.some((ring) => ring.length < 6 || ring.length % 2 !== 0))
+    throw new RangeError("A footprint ring has at least three points.");
+  if (footprint.some((ring) => ring.some((value) => !Number.isFinite(value))))
+    throw new RangeError("A footprint point has no place.");
+  if (footprint.reduce((sum, ring) => sum + ring.length / 2, 0) > tileflowModelLimits.footprintPoints)
+    throw new RangeError(
+      `A footprint has at most ${tileflowModelLimits.footprintPoints} points in all.`
+    );
+  if (model.at && !placed(model.at))
+    throw new RangeError(`Model ${id2} stands at no place on the map.`);
+  if (model.heading !== void 0 && !(model.heading >= 0 && model.heading < 360))
+    throw new RangeError(`Model ${id2} is turned 0 to 360 degrees.`);
+}
+function readModelNode(node2) {
+  const own = node2?.extras?.tileflow;
+  if (!own || typeof own.model !== "string" || !modelId2.test(own.model)) throw new Error();
+  const footprint = Array.isArray(own.footprint) ? own.footprint : [];
+  let points = 0;
+  for (const ring of footprint) {
+    if (!Array.isArray(ring) || ring.length < 6 || ring.length % 2 !== 0) throw new Error();
+    if (ring.some((value) => typeof value !== "number" || !Number.isFinite(value)))
+      throw new Error();
+    points += ring.length / 2;
+  }
+  if (points > tileflowModelLimits.footprintPoints) throw new Error();
+  if (own.at !== void 0 && !placed(own.at)) throw new Error();
+  if (own.heading !== void 0 && !(typeof own.heading === "number" && own.heading >= 0 && own.heading < 360))
+    throw new Error();
+  return {
+    id: own.model,
+    footprint,
+    ...own.at ? { at: [own.at[0], own.at[1]] } : {},
+    ...own.heading !== void 0 ? { heading: own.heading } : {}
+  };
+}
+function readLevelNode(json, node2, name, viewBytes) {
+  if (node2?.name !== name || node2.matrix !== void 0 || node2.rotation !== void 0)
+    throw new Error();
+  const centre = node2.translation;
+  const scale = node2.scale;
+  if (!Array.isArray(centre) || centre.length !== 3 || !centre.every(Number.isFinite))
+    throw new Error();
+  if (!Array.isArray(scale) || scale.length !== 3 || !(scale[0] > 0) || scale.some((value) => value !== scale[0]))
+    throw new Error();
+  const primitives = json.meshes?.[node2.mesh]?.primitives;
+  if (!Array.isArray(primitives) || primitives.length !== 1) throw new Error();
+  const primitive = primitives[0];
+  const names = Object.keys(primitive.attributes ?? {}).sort();
+  if ((primitive.mode ?? 4) !== 4 || names.join() !== "NORMAL,POSITION,_PAINT") throw new Error();
+  const accessor = (index2) => json.accessors?.[index2];
+  const position = accessor(primitive.attributes.POSITION);
+  const normal = accessor(primitive.attributes.NORMAL);
+  const paint = accessor(primitive.attributes._PAINT);
+  const index = accessor(primitive.indices);
+  const count = position?.count;
+  if (!Number.isInteger(count) || count < 3 || count > tileflowModelLimits.vertices)
+    throw new Error();
+  const attribute = (value, offset, type, normalized) => value?.bufferView === position.bufferView && (value.byteOffset ?? 0) === offset && value.componentType === type && (value.normalized ?? false) === normalized && value.type === "VEC3" && value.count === count;
+  if (!attribute(position, 0, short, false) || !attribute(normal, 8, byte, true) || !attribute(paint, 12, unsignedByte, false))
+    throw new Error();
+  const min = position.min;
+  const max = position.max;
+  if (![min, max].every(
+    (list) => Array.isArray(list) && list.length === 3 && list.every(Number.isFinite)
+  ))
+    throw new Error();
+  const width = index?.componentType === unsignedInt ? 4 : index?.componentType === unsignedShort ? 2 : 0;
+  const indexCount = index?.count;
+  if (!width || index.type !== "SCALAR" || (index.byteOffset ?? 0) !== 0 || !Number.isInteger(indexCount) || indexCount < 3 || indexCount % 3 !== 0 || indexCount / 3 > tileflowModelLimits.triangles)
+    throw new Error();
+  const vertices = viewBytes(
+    position.bufferView,
+    tileflowModelVertexBytes,
+    count * tileflowModelVertexBytes
+  );
+  for (let vertex = 0; vertex < count; vertex += 1)
+    if (vertices[vertex * tileflowModelVertexBytes + 12] >= partCount2) throw new Error();
+  const indexBytes = viewBytes(index.bufferView, width, indexCount * width);
+  const indices = width === 4 ? new Uint32Array(indexBytes.buffer, indexBytes.byteOffset, indexCount) : new Uint16Array(indexBytes.buffer, indexBytes.byteOffset, indexCount);
+  for (const vertex of indices) if (vertex >= count) throw new Error();
+  return {
+    vertices,
+    indices,
+    centre: [centre[0], centre[1], centre[2]],
+    step: scale[0],
+    min,
+    max
+  };
+}
+function readGlb(bytes) {
+  if (bytes.byteLength < 20 || bytes.byteLength > tileflowModelLimits.bytes) throw new Error();
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint32(0, true) !== glbMagic || view.getUint32(4, true) !== 2) throw new Error();
+  if (view.getUint32(8, true) !== bytes.byteLength) throw new Error();
+  const jsonLength = view.getUint32(12, true);
+  if (view.getUint32(16, true) !== jsonChunk || 20 + jsonLength > bytes.byteLength)
+    throw new Error();
+  const json = JSON.parse(new TextDecoder().decode(bytes.subarray(20, 20 + jsonLength)));
+  let bin = new Uint8Array(0);
+  const at = 20 + jsonLength;
+  if (at + 8 <= bytes.byteLength) {
+    const binLength = view.getUint32(at, true);
+    if (view.getUint32(at + 4, true) !== binChunk || at + 8 + binLength > bytes.byteLength)
+      throw new Error();
+    bin = bytes.subarray(at + 8, at + 8 + binLength);
+  }
+  if (typeof json !== "object" || json === null) throw new Error();
+  return { json, bin };
+}
+function glb(json, blobs, binLength) {
+  const jsonLength = json.byteLength + (4 - json.byteLength % 4) % 4;
+  const binPadded = binLength + (4 - binLength % 4) % 4;
+  const total = 12 + 8 + jsonLength + (binLength > 0 ? 8 + binPadded : 0);
+  const out = new Uint8Array(total);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, glbMagic, true);
+  view.setUint32(4, 2, true);
+  view.setUint32(8, total, true);
+  view.setUint32(12, jsonLength, true);
+  view.setUint32(16, jsonChunk, true);
+  out.set(json, 20);
+  out.fill(32, 20 + json.byteLength, 20 + jsonLength);
+  if (binLength > 0) {
+    const at = 20 + jsonLength;
+    view.setUint32(at, binPadded, true);
+    view.setUint32(at + 4, binChunk, true);
+    let offset = at + 8;
+    for (const blob of blobs) {
+      out.set(blob, offset);
+      offset += blob.byteLength;
+    }
+  }
+  return out;
+}
+function slice(bin, offset, length) {
+  if (!Number.isInteger(offset) || !Number.isInteger(length)) throw new Error();
+  const start = offset;
+  const end = start + length;
+  if (start < 0 || end > bin.byteLength) throw new Error();
+  return bin.subarray(start, end);
+}
+function placed(at) {
+  if (!Array.isArray(at) || at.length !== 2) return false;
+  const [longitude, latitude] = at;
+  return typeof longitude === "number" && typeof latitude === "number" && longitude >= -180 && longitude <= 180 && latitude >= -85 && latitude <= 85;
+}
+function round2(value, scale) {
+  return Math.round(value * scale) / scale;
+}
+function clamp2(value, low, high) {
+  return Number.isFinite(value) ? Math.min(high, Math.max(low, value)) : 0;
+}
+
+// src/models-3d-landmarks.ts
+var tileflowLandmarkTileZoom = 14;
+var tileflowLandmarkRegionZoom = 6;
+var sha256 = /^[a-f0-9]{64}$/u;
+function tileflowLandmarkTileOf(at) {
+  const [longitude, latitude] = at;
+  if (!(longitude >= -180 && longitude <= 180 && latitude >= -85 && latitude <= 85))
+    throw new RangeError("A landmark stands at a longitude and a latitude on the map.");
+  const n = 2 ** tileflowLandmarkTileZoom;
+  const phi = latitude * Math.PI / 180;
+  return [
+    Math.min(n - 1, Math.floor((longitude + 180) / 360 * n)),
+    Math.floor((1 - Math.log(Math.tan(phi) + 1 / Math.cos(phi)) / Math.PI) / 2 * n)
+  ];
+}
+function tileflowLandmarkRegionOf(tile) {
+  const shift = 2 ** (tileflowLandmarkTileZoom - tileflowLandmarkRegionZoom);
+  return [Math.floor(tile[0] / shift), Math.floor(tile[1] / shift)];
+}
+function serializeTileflowLandmarkRegion(region) {
+  const [x, y] = region.region;
+  const regions2 = 2 ** tileflowLandmarkRegionZoom;
+  if (![x, y].every((value) => Number.isInteger(value) && value >= 0 && value < regions2))
+    throw new RangeError(`A region is a zoom-${tileflowLandmarkRegionZoom} tile.`);
+  const tiles = [...region.tiles].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  for (const [at, [tx, ty, hash]] of tiles.entries()) {
+    const [rx, ry] = tileflowLandmarkRegionOf([tx, ty]);
+    if (!Number.isInteger(tx) || !Number.isInteger(ty) || rx !== x || ry !== y)
+      throw new RangeError(`Tile ${tx}/${ty} lies outside region ${x}/${y}.`);
+    if (!sha256.test(hash)) throw new RangeError(`Tile ${tx}/${ty} has no SHA-256.`);
+    const before = tiles[at - 1];
+    if (before && before[0] === tx && before[1] === ty)
+      throw new RangeError(`Tile ${tx}/${ty} appears twice.`);
+  }
+  if (tiles.length === 0) throw new RangeError("A region index names at least one tile.");
+  return new TextEncoder().encode(
+    JSON.stringify({
+      format: "tileflow-landmark-region-v1",
+      zoom: tileflowLandmarkTileZoom,
+      region: [tileflowLandmarkRegionZoom, x, y],
+      tiles: tiles.map(([tx, ty, hash]) => [tx, ty, hash])
+    })
+  );
+}
+function readTileflowLandmarkRegion(json) {
+  if (!isRecord16(json) || json.format !== "tileflow-landmark-region-v1") return void 0;
+  const region = json.region;
+  if (json.zoom !== tileflowLandmarkTileZoom || !Array.isArray(region) || region.length !== 3 || region[0] !== tileflowLandmarkRegionZoom || !Array.isArray(json.tiles))
+    return void 0;
+  const [, x, y] = region;
+  if (!Number.isInteger(x) || !Number.isInteger(y)) return void 0;
+  const tiles = [];
+  for (const tile of json.tiles) {
+    if (!Array.isArray(tile) || tile.length !== 3) return void 0;
+    const [tx, ty, hash] = tile;
+    if (!Number.isInteger(tx) || !Number.isInteger(ty) || typeof hash !== "string")
+      return void 0;
+    if (!sha256.test(hash)) return void 0;
+    const [rx, ry] = tileflowLandmarkRegionOf([tx, ty]);
+    if (rx !== x || ry !== y) return void 0;
+    tiles.push([tx, ty, hash]);
+  }
+  return { region: [x, y], tiles };
+}
+function readTileflowLandmarksTileJson(json, url) {
+  if (!isRecord16(json) || json.format !== "tileflow-landmarks-v2") return void 0;
+  const tile = Array.isArray(json.tiles) ? json.tiles[0] : void 0;
+  const regions2 = json.regions;
+  if (typeof tile !== "string" || !tile.includes("{sha256}") || json.minzoom !== tileflowLandmarkTileZoom || json.maxzoom !== tileflowLandmarkTileZoom || !isRecord16(regions2) || regions2.zoom !== tileflowLandmarkRegionZoom || typeof regions2.url !== "string" || !regions2.url.includes("{x}") || !regions2.url.includes("{y}") || !Array.isArray(regions2.available))
+    return void 0;
+  const available = /* @__PURE__ */ new Set();
+  for (const region of regions2.available) {
+    if (!Array.isArray(region) || region.length !== 2) return void 0;
+    const [x, y] = region;
+    if (!Number.isInteger(x) || !Number.isInteger(y)) return void 0;
+    available.add(`${x}/${y}`);
+  }
+  return {
+    url,
+    tile,
+    region: regions2.url,
+    tileZoom: tileflowLandmarkTileZoom,
+    regionZoom: tileflowLandmarkRegionZoom,
+    regions: available
+  };
+}
+function isRecord16(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/index.ts
+init_time_of_day();
 export {
   TileflowIconSetError,
   TileflowMapResolutionError,
@@ -20285,6 +22238,7 @@ export {
   createTileflowLineBackgroundFontStack,
   createTileflowSessionController,
   createTileflowSessionId,
+  decodeTileflowModels,
   decodeTileflowTreeModel,
   defaultTileflowManifestUrl,
   defaultTileflowRuntimeView,
@@ -20294,6 +22248,7 @@ export {
   diffTileflowIconPackageManifests,
   diffTileflowMaps,
   disable,
+  encodeTileflowModels,
   encodeTileflowTreeModel,
   expr,
   field,
@@ -20316,6 +22271,7 @@ export {
   isTileflowLocalDirectory,
   isTileflowPortableId,
   isTileflowThemeName,
+  isTileflowTimeOfDay,
   isTileflowWorldReleaseId,
   labels,
   land,
@@ -20345,9 +22301,12 @@ export {
   poi,
   readTileflowBuildings3D,
   readTileflowIconLayout,
+  readTileflowLandmarkRegion,
+  readTileflowLandmarksTileJson,
   readTileflowStreetLights,
   readTileflowSunPreset,
   readTileflowVegetation3D,
+  readTileflowVegetationDisplay,
   refine,
   refineRenderTarget,
   remove,
@@ -20371,6 +22330,7 @@ export {
   resolveTileflowStaticImageUrl,
   resolveTileflowSun,
   resolveTileflowTheme,
+  resolveTileflowVegetationRepresentation,
   roads,
   safeParseTileflowRuntimeManifest,
   scaleTileflowIconLayout,
@@ -20379,6 +22339,7 @@ export {
   serializeTileflowFontBundleManifest,
   serializeTileflowIconPackageManifest,
   serializeTileflowIconsLockfile,
+  serializeTileflowLandmarkRegion,
   sha256Hex,
   shouldLoadTileflowManifest,
   startTileflowSession,
@@ -20386,8 +22347,10 @@ export {
   tileflowAuthoringManifestSchemaVersion,
   tileflowBandPlacements,
   tileflowBathymetryDemSourceId,
+  tileflowBathymetryNameLayerLimits,
   tileflowBathymetrySourceId,
   tileflowBathymetryV1Schema,
+  tileflowBuildingModelPlacementLimit,
   tileflowBuildingsMetadataKey,
   tileflowCaptureApplicationTargetSchema,
   tileflowCaptureBoundsCameraSchema,
@@ -20446,7 +22409,12 @@ export {
   tileflowIconsLockfileMaximumBytes,
   tileflowIconsLockfileName,
   tileflowIconsLockfileSchema,
+  tileflowInsideRings,
   tileflowLandformClasses,
+  tileflowLandmarkRegionOf,
+  tileflowLandmarkRegionZoom,
+  tileflowLandmarkTileOf,
+  tileflowLandmarkTileZoom,
   tileflowLayerBands,
   tileflowLineBackgroundDefaults,
   tileflowLineBackgroundHaloRatio,
@@ -20455,10 +22423,15 @@ export {
   tileflowLocalDirectoryMessage,
   tileflowMapDefaultMaxDepth,
   tileflowMapIdSchema,
+  tileflowModelContentType,
+  tileflowModelLimits,
+  tileflowModelParts,
+  tileflowModelVertexBytes,
   tileflowNauticalSourceId,
   tileflowNauticalV1Schema,
   tileflowOverlayPlacements,
   tileflowPoiCategories,
+  tileflowPoiIconOnlyTypes,
   tileflowPoiImageRoles,
   tileflowPortableIdMaximumLength,
   tileflowPortableIdSchema,
@@ -20470,6 +22443,7 @@ export {
   tileflowRenderStackRenderers,
   tileflowRenderedIconIdentitySchema,
   tileflowRenderedIconManifestEntrySchema,
+  tileflowRingsOverlap,
   tileflowRoadClasses,
   tileflowRouteMetadataKey,
   tileflowRouteTokens,
@@ -20488,10 +22462,12 @@ export {
   tileflowThemeLimits,
   tileflowThemeNameSchema,
   tileflowThemeTokenCategories,
+  tileflowTimesOfDay,
   tileflowTreeForms,
   tileflowTreeModelIdPattern,
   tileflowTreeModelLimits,
   tileflowTreeParts,
+  tileflowVegetationDisplayMetadataKey,
   tileflowVegetationMetadataKey,
   tileflowWorld,
   tileflowWorldGeneration,