@tileflow/core 0.1.0-alpha.24 → 0.1.0-alpha.25

package/dist/index.js

@@ -2160,7 +2160,7 @@ __export(manifest_exports, {
   tileflowRuntimeManifestSchema: () => tileflowRuntimeManifestSchema,
   tileflowRuntimeManifestVersion: () => tileflowRuntimeManifestVersion
 });
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function parseTileflowRuntimeManifest(input) {
   return tileflowRuntimeManifestSchema.parse(input);
 }
@@ -2250,43 +2250,43 @@ var init_manifest = __esm({
     init_themes();
     tileflowRuntimeManifestVersion = 1;
     tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
-    safeTextSchema = z5.string().min(1).max(2048).refine((value) => value === value.trim(), "Expected text without surrounding whitespace").refine((value) => !/[\p{Cc}\\]/u.test(value), "Expected safe text");
+    safeTextSchema = z6.string().min(1).max(2048).refine((value) => value === value.trim(), "Expected text without surrounding whitespace").refine((value) => !/[\p{Cc}\\]/u.test(value), "Expected safe text");
     publicResourceUrlSchema = safeTextSchema.refine(isPublicResourceUrl, {
       message: "Expected an HTTP(S), root-relative, or path-relative public URL"
     });
     apiOriginSchema = safeTextSchema.refine(isApiOrigin, {
       message: "Expected an absolute HTTP(S) origin without path, credentials, query, or fragment"
     });
-    viewSchema2 = z5.object({
-      bearing: z5.number().finite().min(-180).max(180).optional(),
-      center: z5.tuple([z5.number().finite().min(-180).max(180), z5.number().finite().min(-90).max(90)]).optional(),
-      pitch: z5.number().finite().min(0).max(85).optional(),
-      zoom: z5.number().finite().min(0).max(24).optional()
+    viewSchema2 = z6.object({
+      bearing: z6.number().finite().min(-180).max(180).optional(),
+      center: z6.tuple([z6.number().finite().min(-180).max(180), z6.number().finite().min(-90).max(90)]).optional(),
+      pitch: z6.number().finite().min(0).max(85).optional(),
+      zoom: z6.number().finite().min(0).max(24).optional()
     }).strict();
-    fontFaceSchema = z5.object({
+    fontFaceSchema = z6.object({
       family: safeTextSchema.max(100),
       source: publicResourceUrlSchema,
-      style: z5.enum(["italic", "normal", "oblique"]).optional(),
-      weight: z5.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"]).optional()
+      style: z6.enum(["italic", "normal", "oblique"]).optional(),
+      weight: z6.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"]).optional()
     }).strict();
-    fontFacesSchema = z5.array(fontFaceSchema).max(16).superRefine(validateUniqueFontFaces);
-    manifestThemeSchema = z5.object({
-      colorScheme: z5.enum(["dark", "light"]),
+    fontFacesSchema = z6.array(fontFaceSchema).max(16).superRefine(validateUniqueFontFaces);
+    manifestThemeSchema = z6.object({
+      colorScheme: z6.enum(["dark", "light"]),
       fontFaces: fontFacesSchema.optional(),
       revision: safeTextSchema.max(128).optional(),
       styleId: safeTextSchema.max(128).optional(),
       styleUrl: publicResourceUrlSchema
     }).strict();
-    manifestMapSchema = z5.object({
+    manifestMapSchema = z6.object({
       apiUrl: apiOriginSchema.optional(),
       defaultTheme: tileflowThemeNameSchema,
       environment: safeTextSchema.max(128).optional(),
       mapId: safeTextSchema.max(128).optional(),
-      systemThemes: z5.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
-      themes: z5.record(tileflowThemeNameSchema, manifestThemeSchema),
-      usageMode: z5.literal("session").optional(),
+      systemThemes: z6.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
+      themes: z6.record(tileflowThemeNameSchema, manifestThemeSchema),
+      usageMode: z6.literal("session").optional(),
       view: viewSchema2.optional(),
-      worldGeneration: z5.literal("v1").optional()
+      worldGeneration: z6.literal("v1").optional()
     }).strict().superRefine((entry, context) => {
       const names = Object.keys(entry.themes);
       if (names.length === 0) {
@@ -2333,10 +2333,10 @@ var init_manifest = __esm({
         });
       }
     });
-    canonicalManifestSchema = z5.object({
+    canonicalManifestSchema = z6.object({
       apiUrl: apiOriginSchema.optional(),
-      maps: z5.record(tileflowPortableIdSchema, manifestMapSchema),
-      version: z5.literal(tileflowRuntimeManifestVersion)
+      maps: z6.record(tileflowPortableIdSchema, manifestMapSchema),
+      version: z6.literal(tileflowRuntimeManifestVersion)
     }).strict().superRefine((manifest, context) => {
       const mapCount = Object.keys(manifest.maps).length;
       if (mapCount === 0) {
@@ -2354,7 +2354,7 @@ var init_manifest = __esm({
         });
       }
     });
-    safeManifestInputSchema = z5.unknown().superRefine((input, context) => {
+    safeManifestInputSchema = z6.unknown().superRefine((input, context) => {
       const unsafe = findUnsafeManifestStructure(input);
       if (unsafe) {
         context.addIssue({
@@ -7756,10 +7756,10 @@ function roadWidth(roadClass, scale) {
       [16, 3.4]
     ]
   };
-  return zoom.linear(stops[roadClass].map(([z8, value]) => [z8, value * scale]));
+  return zoom.linear(stops[roadClass].map(([z12, value]) => [z12, value * scale]));
 }
 function widen(value, addition) {
-  return zoom.linear(value.stops.map(([z8, width]) => [z8, width + addition]));
+  return zoom.linear(value.stops.map(([z12, width]) => [z12, width + addition]));
 }
 function structureFilter(field2, structure) {
   if (structure === "surface") {
@@ -9469,8 +9469,68 @@ function assertNever(value) {
   throw new Error(`Unsupported Tileflow map merge strategy: ${String(value)}`);
 }
 
-// src/resolved-map-schema.ts
+// src/icon-set.ts
 import { z as z4 } from "zod";
+var tileflowIconSourceLimit = 32;
+var slug = "[a-z0-9]+(?:-[a-z0-9]+)*";
+var tileflowIconSetReferenceSchema = z4.string().max(130).regex(
+  new RegExp(`^@${slug}/${slug}$`, "u"),
+  "Expected a canonical @team/set reference without a version suffix"
+).refine(
+  (value) => value.slice(1).split("/").every((part) => part.length <= 64),
+  "Team and set slugs must contain at most 64 characters"
+);
+var tileflowIconSetSourceSchema = z4.object({
+  kind: z4.literal("icon-set"),
+  reference: tileflowIconSetReferenceSchema
+}).strict();
+function iconSet(reference) {
+  return Object.freeze(
+    tileflowIconSetSourceSchema.parse({ kind: "icon-set", reference })
+  );
+}
+function isTileflowIconSetSource(value) {
+  return tileflowIconSetSourceSchema.safeParse(value).success;
+}
+var tileflowIconSetIdSchema = z4.string().regex(/^ics_[A-Za-z0-9_-]{16}$/u);
+var tileflowIconSetVersionIdSchema = z4.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u);
+var tileflowIconSetPackageIdSchema = z4.string().regex(/^icp_[A-Za-z0-9_-]{16,64}$/u);
+var tileflowIconSetTeamIdSchema = z4.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var TileflowIconSetError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "TileflowIconSetError";
+  }
+  code;
+  phase = "icon-resolution";
+};
+function collectTileflowIconSetReferences(sources) {
+  if (sources.length > tileflowIconSourceLimit) {
+    throw new TileflowIconSetError(
+      "ICON_SET_INVALID",
+      `A map supports at most ${tileflowIconSourceLimit} icon contributors`
+    );
+  }
+  const references = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    if (typeof source !== "object" || source === null || source.kind !== "icon-set") continue;
+    const parsed = tileflowIconSetSourceSchema.safeParse(source);
+    if (!parsed.success || seen.has(source.reference)) {
+      throw new TileflowIconSetError(
+        "ICON_SET_INVALID",
+        "Icon set references must be canonical and unique within a map"
+      );
+    }
+    seen.add(source.reference);
+    references.push(source.reference);
+  }
+  return references;
+}
+
+// src/resolved-map-schema.ts
+import { z as z5 } from "zod";
 
 // src/cartography/data-expression.ts
 init_values();
@@ -11510,11 +11570,11 @@ var TileflowResolvedMapValidationError = class extends Error {
     this.messages = messages;
   }
 };
-var identifierSchema = z4.string().trim().regex(/^[A-Za-z0-9_-]+$/, "Expected letters, numbers, underscores, or hyphens").refine((value) => value !== "__proto__", "Expected a safe identifier");
-var revisionSchema = z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Expected a portable data revision");
-var zoomNumberSchema = z4.number().finite().min(0).max(24);
+var identifierSchema = z5.string().trim().regex(/^[A-Za-z0-9_-]+$/, "Expected letters, numbers, underscores, or hyphens").refine((value) => value !== "__proto__", "Expected a safe identifier");
+var revisionSchema = z5.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Expected a portable data revision");
+var zoomNumberSchema = z5.number().finite().min(0).max(24);
 function zoomValueSchemaFor(valueSchema) {
-  const stops = z4.array(z4.tuple([zoomNumberSchema, valueSchema])).min(1).superRefine((entries, context) => {
+  const stops = z5.array(z5.tuple([zoomNumberSchema, valueSchema])).min(1).superRefine((entries, context) => {
     for (let index = 1; index < entries.length; index += 1) {
       if (entries[index][0] <= entries[index - 1][0]) {
         context.addIssue({
@@ -11525,105 +11585,105 @@ function zoomValueSchemaFor(valueSchema) {
       }
     }
   });
-  return z4.discriminatedUnion("interpolation", [
-    z4.object({
-      base: z4.number().finite().positive(),
-      interpolation: z4.literal("exponential"),
-      kind: z4.literal("zoom"),
+  return z5.discriminatedUnion("interpolation", [
+    z5.object({
+      base: z5.number().finite().positive(),
+      interpolation: z5.literal("exponential"),
+      kind: z5.literal("zoom"),
       stops
     }).strict(),
-    z4.object({
-      interpolation: z4.literal("linear"),
-      kind: z4.literal("zoom"),
+    z5.object({
+      interpolation: z5.literal("linear"),
+      kind: z5.literal("zoom"),
       stops
     }).strict(),
-    z4.object({
-      interpolation: z4.literal("step"),
-      kind: z4.literal("zoom"),
+    z5.object({
+      interpolation: z5.literal("step"),
+      kind: z5.literal("zoom"),
       stops
     }).strict()
   ]);
 }
-var themeTokenNameSchema = z4.string().regex(
+var themeTokenNameSchema = z5.string().regex(
   /^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)*$/,
   "Expected a portable dot-separated semantic token name"
 );
-var themeTokenReferenceSchema = z4.object({
-  category: z4.enum(tileflowThemeTokenCategories),
-  kind: z4.literal("theme-token"),
+var themeTokenReferenceSchema = z5.object({
+  category: z5.enum(tileflowThemeTokenCategories),
+  kind: z5.literal("theme-token"),
   token: themeTokenNameSchema
 }).strict();
 var themeNumberReferenceSchema = themeTokenReferenceSchema.extend({
-  category: z4.literal("number")
+  category: z5.literal("number")
 });
-var fixedNumberSchema = z4.object({
-  kind: z4.literal("theme-fixed"),
-  reason: z4.string().trim().min(1),
-  value: z4.number().finite()
+var fixedNumberSchema = z5.object({
+  kind: z5.literal("theme-fixed"),
+  reason: z5.string().trim().min(1),
+  value: z5.number().finite()
 }).strict();
-var fixedNumberArraySchema = z4.object({
-  kind: z4.literal("theme-fixed"),
-  reason: z4.string().trim().min(1),
-  value: z4.array(z4.number().finite())
+var fixedNumberArraySchema = z5.object({
+  kind: z5.literal("theme-fixed"),
+  reason: z5.string().trim().min(1),
+  value: z5.array(z5.number().finite())
 }).strict();
-var fixedNumberOffsetSchema = z4.object({
-  kind: z4.literal("theme-fixed"),
-  reason: z4.string().trim().min(1),
-  value: z4.tuple([z4.number().finite(), z4.number().finite()])
+var fixedNumberOffsetSchema = z5.object({
+  kind: z5.literal("theme-fixed"),
+  reason: z5.string().trim().min(1),
+  value: z5.tuple([z5.number().finite(), z5.number().finite()])
 }).strict();
-var fixedNumberInsetsSchema = z4.object({
-  kind: z4.literal("theme-fixed"),
-  reason: z4.string().trim().min(1),
-  value: z4.tuple([
-    z4.number().finite(),
-    z4.number().finite(),
-    z4.number().finite(),
-    z4.number().finite()
+var fixedNumberInsetsSchema = z5.object({
+  kind: z5.literal("theme-fixed"),
+  reason: z5.string().trim().min(1),
+  value: z5.tuple([
+    z5.number().finite(),
+    z5.number().finite(),
+    z5.number().finite(),
+    z5.number().finite()
   ])
 }).strict();
-var fixedStringSchema = z4.object({ kind: z4.literal("theme-fixed"), reason: z4.string().trim().min(1), value: z4.string() }).strict();
-var themeColorOperationSchema = z4.lazy(
-  () => z4.discriminatedUnion("operation", [
-    z4.object({
+var fixedStringSchema = z5.object({ kind: z5.literal("theme-fixed"), reason: z5.string().trim().min(1), value: z5.string() }).strict();
+var themeColorOperationSchema = z5.lazy(
+  () => z5.discriminatedUnion("operation", [
+    z5.object({
       color: themeColorValueSchema,
-      kind: z4.literal("theme-color"),
+      kind: z5.literal("theme-color"),
       opacity: themeNumberValueSchema,
-      operation: z4.literal("alpha")
+      operation: z5.literal("alpha")
     }).strict(),
-    z4.object({
+    z5.object({
       amount: themeNumberValueSchema,
       from: themeColorValueSchema,
-      kind: z4.literal("theme-color"),
-      operation: z4.literal("mix"),
-      space: z4.literal("oklch"),
+      kind: z5.literal("theme-color"),
+      operation: z5.literal("mix"),
+      space: z5.literal("oklch"),
       to: themeColorValueSchema
     }).strict()
   ])
 );
-var themeNumberValueSchema = z4.lazy(
-  () => z4.union([z4.number().finite(), fixedNumberSchema, themeNumberReferenceSchema])
+var themeNumberValueSchema = z5.lazy(
+  () => z5.union([z5.number().finite(), fixedNumberSchema, themeNumberReferenceSchema])
 );
-var themeColorValueSchema = z4.lazy(
-  () => z4.union([
-    z4.string().min(1),
+var themeColorValueSchema = z5.lazy(
+  () => z5.union([
+    z5.string().min(1),
     fixedStringSchema,
-    themeTokenReferenceSchema.extend({ category: z4.literal("color") }),
+    themeTokenReferenceSchema.extend({ category: z5.literal("color") }),
     themeColorOperationSchema
   ])
 );
-var themeFontValueSchema = z4.union([
-  z4.string().min(1),
+var themeFontValueSchema = z5.union([
+  z5.string().min(1),
   fixedStringSchema,
-  themeTokenReferenceSchema.extend({ category: z4.literal("font") })
+  themeTokenReferenceSchema.extend({ category: z5.literal("font") })
 ]);
-var themeImageValueSchema = z4.union([
-  z4.string().min(1),
+var themeImageValueSchema = z5.union([
+  z5.string().min(1),
   fixedStringSchema,
-  themeTokenReferenceSchema.extend({ category: z4.literal("image") })
+  themeTokenReferenceSchema.extend({ category: z5.literal("image") })
 ]);
 function expressionSchemaFor(expectedCategory) {
   const category = expectedCategory ?? "structural";
-  return z4.object({ kind: z4.literal("expression"), value: z4.array(z4.unknown()).min(1) }).strict().superRefine((expression2, context) => {
+  return z5.object({ kind: z5.literal("expression"), value: z5.array(z5.unknown()).min(1) }).strict().superRefine((expression2, context) => {
     for (const issue of validateTileflowDataExpression(expression2.value)) {
       context.addIssue({
         code: "custom",
@@ -11677,7 +11737,7 @@ function validateExpressionThemeValues(value, expectedCategory, context, path) {
     return;
   }
   if (candidate.kind === "theme-fixed") {
-    const parsed = expectedCategory === "number" ? z4.union([fixedNumberSchema, fixedNumberArraySchema]).safeParse(candidate) : expectedCategory === "color" || expectedCategory === "image" ? fixedStringSchema.safeParse(candidate) : void 0;
+    const parsed = expectedCategory === "number" ? z5.union([fixedNumberSchema, fixedNumberArraySchema]).safeParse(candidate) : expectedCategory === "color" || expectedCategory === "image" ? fixedStringSchema.safeParse(candidate) : void 0;
     if (!parsed?.success) {
       context.addIssue({
         code: "custom",
@@ -11708,71 +11768,71 @@ var structuralExpressionSchema = expressionSchemaFor(void 0);
 var numberZoomValueSchema = zoomValueSchemaFor(themeNumberValueSchema);
 var colorZoomValueSchema = zoomValueSchemaFor(themeColorValueSchema);
 var imageZoomValueSchema = zoomValueSchemaFor(themeImageValueSchema);
-var stringZoomValueSchema = zoomValueSchemaFor(z4.string());
-var numberValueSchema = z4.union([
+var stringZoomValueSchema = zoomValueSchemaFor(z5.string());
+var numberValueSchema = z5.union([
   themeNumberValueSchema,
   numberExpressionSchema,
   numberZoomValueSchema
 ]);
-var structuralNumberValueSchema = z4.union([
-  z4.number().finite(),
+var structuralNumberValueSchema = z5.union([
+  z5.number().finite(),
   structuralExpressionSchema,
-  zoomValueSchemaFor(z4.number().finite())
+  zoomValueSchemaFor(z5.number().finite())
 ]);
-var colorValueSchema = z4.union([
+var colorValueSchema = z5.union([
   themeColorValueSchema,
   colorExpressionSchema,
   colorZoomValueSchema
 ]);
-var imageValueSchema = z4.union([
+var imageValueSchema = z5.union([
   themeImageValueSchema,
   imageExpressionSchema,
   imageZoomValueSchema
 ]);
-var stringValueSchema = z4.union([z4.string(), structuralExpressionSchema, stringZoomValueSchema]);
-var themeNumberArraySchema = z4.array(themeNumberValueSchema);
-var themeNumberArrayValueSchema = z4.union([themeNumberArraySchema, fixedNumberArraySchema]);
-var numberArrayValueSchema = z4.union([
+var stringValueSchema = z5.union([z5.string(), structuralExpressionSchema, stringZoomValueSchema]);
+var themeNumberArraySchema = z5.array(themeNumberValueSchema);
+var themeNumberArrayValueSchema = z5.union([themeNumberArraySchema, fixedNumberArraySchema]);
+var numberArrayValueSchema = z5.union([
   themeNumberArrayValueSchema,
   numberExpressionSchema,
   zoomValueSchemaFor(themeNumberArrayValueSchema)
 ]);
-var themeNumberOffsetSchema = z4.tuple([themeNumberValueSchema, themeNumberValueSchema]);
-var themeNumberOffsetValueSchema = z4.union([themeNumberOffsetSchema, fixedNumberOffsetSchema]);
-var numberOffsetValueSchema = z4.union([
+var themeNumberOffsetSchema = z5.tuple([themeNumberValueSchema, themeNumberValueSchema]);
+var themeNumberOffsetValueSchema = z5.union([themeNumberOffsetSchema, fixedNumberOffsetSchema]);
+var numberOffsetValueSchema = z5.union([
   themeNumberOffsetValueSchema,
   numberExpressionSchema,
   zoomValueSchemaFor(themeNumberOffsetValueSchema)
 ]);
-var themeNumberInsetsSchema = z4.tuple([
+var themeNumberInsetsSchema = z5.tuple([
   themeNumberValueSchema,
   themeNumberValueSchema,
   themeNumberValueSchema,
   themeNumberValueSchema
 ]);
-var themeNumberInsetsValueSchema = z4.union([themeNumberInsetsSchema, fixedNumberInsetsSchema]);
-var numberInsetsValueSchema = z4.union([
+var themeNumberInsetsValueSchema = z5.union([themeNumberInsetsSchema, fixedNumberInsetsSchema]);
+var numberInsetsValueSchema = z5.union([
   themeNumberInsetsValueSchema,
   numberExpressionSchema,
   zoomValueSchemaFor(themeNumberInsetsValueSchema)
 ]);
-var lineCapSchema = z4.enum(["butt", "round", "square"]);
-var lineCapValueSchema = z4.union([
+var lineCapSchema = z5.enum(["butt", "round", "square"]);
+var lineCapValueSchema = z5.union([
   lineCapSchema,
   structuralExpressionSchema,
   zoomValueSchemaFor(lineCapSchema)
 ]);
-var lineJoinSchema = z4.enum(["bevel", "miter", "round"]);
-var lineJoinValueSchema = z4.union([
+var lineJoinSchema = z5.enum(["bevel", "miter", "round"]);
+var lineJoinValueSchema = z5.union([
   lineJoinSchema,
   structuralExpressionSchema,
   zoomValueSchemaFor(lineJoinSchema)
 ]);
-var exactFontFaceSchema = z4.string().min(1).max(100).refine(
+var exactFontFaceSchema = z5.string().min(1).max(100).refine(
   (value) => value === value.trim() && value === value.normalize("NFC") && !/[\p{Cc}\\]/u.test(value),
   "Expected an exact NFC font face name without surrounding whitespace, controls, or backslashes"
 );
-var fontFallbacksSchema = z4.array(exactFontFaceSchema).max(8).superRefine((fallbacks, context) => {
+var fontFallbacksSchema = z5.array(exactFontFaceSchema).max(8).superRefine((fallbacks, context) => {
   const seen = /* @__PURE__ */ new Set();
   for (const [index, fallback] of fallbacks.entries()) {
     if (seen.has(fallback)) {
@@ -11785,16 +11845,16 @@ var fontFallbacksSchema = z4.array(exactFontFaceSchema).max(8).superRefine((fall
     seen.add(fallback);
   }
 });
-var moduleFontValueSchema = z4.union([
+var moduleFontValueSchema = z5.union([
   exactFontFaceSchema,
   fixedStringSchema,
-  themeTokenReferenceSchema.extend({ category: z4.literal("font") })
+  themeTokenReferenceSchema.extend({ category: z5.literal("font") })
 ]);
-var moduleFontFallbacksSchema = z4.array(moduleFontValueSchema).max(8);
-var hexColorSchema = z4.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
+var moduleFontFallbacksSchema = z5.array(moduleFontValueSchema).max(8);
+var hexColorSchema = z5.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
   message: "Expected a hex color like #F6F7F3 or #F6F7F3FF"
 });
-var rgbColorSchema = z4.string().refine((value) => {
+var rgbColorSchema = z5.string().refine((value) => {
   const match2 = value.match(
     /^rgba?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)(?:\s*,\s*(\d+(?:\.\d+)?))?\s*\)$/iu
   );
@@ -11803,21 +11863,21 @@ var rgbColorSchema = z4.string().refine((value) => {
   const alpha2 = Number(match2[4] ?? 1);
   return channels.every((channel) => channel >= 0 && channel <= 255) && alpha2 >= 0 && alpha2 <= 1;
 }, "Expected a Tileflow hex, rgb(), or rgba() color");
-var terrainColorLiteralSchema = z4.union([hexColorSchema, rgbColorSchema]);
-var terrainColorValueSchema = z4.union([
+var terrainColorLiteralSchema = z5.union([hexColorSchema, rgbColorSchema]);
+var terrainColorValueSchema = z5.union([
   terrainColorLiteralSchema,
   fixedStringSchema.extend({ value: terrainColorLiteralSchema }),
-  themeTokenReferenceSchema.extend({ category: z4.literal("color") }),
+  themeTokenReferenceSchema.extend({ category: z5.literal("color") }),
   themeColorOperationSchema
 ]);
 function terrainNumberValueSchema(schema) {
-  return z4.union([schema, fixedNumberSchema.extend({ value: schema }), themeNumberReferenceSchema]);
+  return z5.union([schema, fixedNumberSchema.extend({ value: schema }), themeNumberReferenceSchema]);
 }
-var themeTypographyStyleSchema = z4.object({
-  fallbacks: z4.array(themeFontValueSchema).max(8).optional(),
+var themeTypographyStyleSchema = z5.object({
+  fallbacks: z5.array(themeFontValueSchema).max(8).optional(),
   font: themeFontValueSchema.optional(),
   letterSpacing: themeNumberValueSchema.optional(),
-  transform: z4.enum(["lowercase", "none", "uppercase"]).optional()
+  transform: z5.enum(["lowercase", "none", "uppercase"]).optional()
 }).strict();
 var themeTypographySchema = themeTypographyStyleSchema.extend({
   places: themeTypographyStyleSchema.optional(),
@@ -11825,46 +11885,46 @@ var themeTypographySchema = themeTypographyStyleSchema.extend({
   roads: themeTypographyStyleSchema.optional(),
   water: themeTypographyStyleSchema.optional()
 });
-var themeLightingSchema = z4.object({
-  anchor: z4.enum(["map", "viewport"]).optional(),
+var themeLightingSchema = z5.object({
+  anchor: z5.enum(["map", "viewport"]).optional(),
   color: themeColorValueSchema.optional(),
   intensity: themeNumberValueSchema.optional(),
-  position: z4.tuple([themeNumberValueSchema, themeNumberValueSchema, themeNumberValueSchema]).optional()
+  position: z5.tuple([themeNumberValueSchema, themeNumberValueSchema, themeNumberValueSchema]).optional()
 }).strict();
-var tileflowThemeSchema = z4.object({
-  colorScheme: z4.enum(["light", "dark"]),
+var tileflowThemeSchema = z5.object({
+  colorScheme: z5.enum(["light", "dark"]),
   id: tileflowThemeNameSchema,
   lighting: themeLightingSchema,
-  tokens: z4.object({
-    color: z4.record(themeTokenNameSchema, themeColorValueSchema),
-    font: z4.record(themeTokenNameSchema, themeFontValueSchema),
-    image: z4.record(themeTokenNameSchema, themeImageValueSchema),
-    number: z4.record(themeTokenNameSchema, themeNumberValueSchema)
+  tokens: z5.object({
+    color: z5.record(themeTokenNameSchema, themeColorValueSchema),
+    font: z5.record(themeTokenNameSchema, themeFontValueSchema),
+    image: z5.record(themeTokenNameSchema, themeImageValueSchema),
+    number: z5.record(themeTokenNameSchema, themeNumberValueSchema)
   }).strict(),
   typography: themeTypographySchema,
-  version: z4.number().int().positive()
+  version: z5.number().int().positive()
 }).strict();
 var rangeShape = {
   maxZoom: zoomNumberSchema.optional(),
   minZoom: zoomNumberSchema.optional(),
-  visible: z4.boolean().optional()
+  visible: z5.boolean().optional()
 };
-var backgroundStyleSchema = z4.object({
+var backgroundStyleSchema = z5.object({
   ...rangeShape,
   color: colorValueSchema.optional(),
   opacity: numberValueSchema.optional(),
   pattern: imageValueSchema.optional()
 }).strict();
-var fillStyleSchema = z4.object({
+var fillStyleSchema = z5.object({
   ...rangeShape,
-  antialias: z4.boolean().optional(),
+  antialias: z5.boolean().optional(),
   color: colorValueSchema.optional(),
   opacity: numberValueSchema.optional(),
   pattern: imageValueSchema.optional(),
   translate: numberOffsetValueSchema.optional(),
-  translateAnchor: z4.enum(["map", "viewport"]).optional()
+  translateAnchor: z5.enum(["map", "viewport"]).optional()
 }).strict();
-var lineStyleSchema = z4.object({
+var lineStyleSchema = z5.object({
   ...rangeShape,
   blur: numberValueSchema.optional(),
   cap: lineCapValueSchema.optional(),
@@ -11878,13 +11938,13 @@ var lineStyleSchema = z4.object({
   pattern: imageValueSchema.optional(),
   roundLimit: numberValueSchema.optional(),
   translate: numberOffsetValueSchema.optional(),
-  translateAnchor: z4.enum(["map", "viewport"]).optional(),
+  translateAnchor: z5.enum(["map", "viewport"]).optional(),
   width: numberValueSchema.optional()
 }).strict();
-var textStyleSchema = z4.object({
+var textStyleSchema = z5.object({
   ...rangeShape,
-  allowOverlap: z4.boolean().optional(),
-  anchor: z4.enum([
+  allowOverlap: z5.boolean().optional(),
+  anchor: z5.enum([
     "bottom",
     "bottom-left",
     "bottom-right",
@@ -11902,25 +11962,25 @@ var textStyleSchema = z4.object({
   haloBlur: numberValueSchema.optional(),
   haloColor: colorValueSchema.optional(),
   haloWidth: numberValueSchema.optional(),
-  ignorePlacement: z4.boolean().optional(),
-  justify: z4.enum(["auto", "center", "left", "right"]).optional(),
-  keepUpright: z4.boolean().optional(),
+  ignorePlacement: z5.boolean().optional(),
+  justify: z5.enum(["auto", "center", "left", "right"]).optional(),
+  keepUpright: z5.boolean().optional(),
   letterSpacing: numberValueSchema.optional(),
   lineHeight: numberValueSchema.optional(),
   maxAngle: numberValueSchema.optional(),
   maxWidth: numberValueSchema.optional(),
   offset: numberOffsetValueSchema.optional(),
-  optional: z4.boolean().optional(),
+  optional: z5.boolean().optional(),
   opacity: numberValueSchema.optional(),
   padding: numberValueSchema.optional(),
-  pitchAlignment: z4.enum(["auto", "map", "viewport"]).optional(),
+  pitchAlignment: z5.enum(["auto", "map", "viewport"]).optional(),
   radialOffset: numberValueSchema.optional(),
   rotate: numberValueSchema.optional(),
-  rotationAlignment: z4.enum(["auto", "map", "viewport"]).optional(),
+  rotationAlignment: z5.enum(["auto", "map", "viewport"]).optional(),
   size: numberValueSchema.optional(),
-  transform: z4.enum(["lowercase", "none", "uppercase"]).optional(),
-  variableAnchors: z4.array(
-    z4.enum([
+  transform: z5.enum(["lowercase", "none", "uppercase"]).optional(),
+  variableAnchors: z5.array(
+    z5.enum([
       "bottom",
       "bottom-left",
       "bottom-right",
@@ -11933,10 +11993,10 @@ var textStyleSchema = z4.object({
     ])
   ).min(1).optional()
 }).strict();
-var iconStyleSchema = z4.object({
+var iconStyleSchema = z5.object({
   ...rangeShape,
-  allowOverlap: z4.boolean().optional(),
-  anchor: z4.enum([
+  allowOverlap: z5.boolean().optional(),
+  anchor: z5.enum([
     "bottom",
     "bottom-left",
     "bottom-right",
@@ -11951,60 +12011,60 @@ var iconStyleSchema = z4.object({
   haloBlur: numberValueSchema.optional(),
   haloColor: colorValueSchema.optional(),
   haloWidth: numberValueSchema.optional(),
-  ignorePlacement: z4.boolean().optional(),
+  ignorePlacement: z5.boolean().optional(),
   image: imageValueSchema.optional(),
   offset: numberOffsetValueSchema.optional(),
   opacity: numberValueSchema.optional(),
-  keepUpright: z4.boolean().optional(),
-  optional: z4.boolean().optional(),
+  keepUpright: z5.boolean().optional(),
+  optional: z5.boolean().optional(),
   padding: numberValueSchema.optional(),
-  pitchAlignment: z4.enum(["auto", "map", "viewport"]).optional(),
+  pitchAlignment: z5.enum(["auto", "map", "viewport"]).optional(),
   rotate: numberValueSchema.optional(),
-  rotationAlignment: z4.enum(["auto", "map", "viewport"]).optional(),
+  rotationAlignment: z5.enum(["auto", "map", "viewport"]).optional(),
   size: numberValueSchema.optional(),
-  textFit: z4.enum(["both", "height", "none", "width"]).optional(),
+  textFit: z5.enum(["both", "height", "none", "width"]).optional(),
   textFitPadding: numberInsetsValueSchema.optional()
 }).strict();
 var symbolPlacementShape = {
   ...rangeShape,
-  placement: z4.enum(["line", "line-center", "point"]).optional(),
+  placement: z5.enum(["line", "line-center", "point"]).optional(),
   priority: structuralNumberValueSchema.optional(),
-  priorityOrder: z4.enum(["higher-first", "lower-first"]).optional(),
+  priorityOrder: z5.enum(["higher-first", "lower-first"]).optional(),
   spacing: numberValueSchema.optional(),
-  zOrder: z4.enum(["auto", "source", "viewport-y"]).optional()
+  zOrder: z5.enum(["auto", "source", "viewport-y"]).optional()
 };
-var circleStyleSchema = z4.object({
+var circleStyleSchema = z5.object({
   ...rangeShape,
   blur: numberValueSchema.optional(),
   color: colorValueSchema.optional(),
   opacity: numberValueSchema.optional(),
-  pitchAlignment: z4.enum(["map", "viewport"]).optional(),
-  pitchScale: z4.enum(["map", "viewport"]).optional(),
+  pitchAlignment: z5.enum(["map", "viewport"]).optional(),
+  pitchScale: z5.enum(["map", "viewport"]).optional(),
   priority: structuralNumberValueSchema.optional(),
-  priorityOrder: z4.enum(["higher-first", "lower-first"]).optional(),
+  priorityOrder: z5.enum(["higher-first", "lower-first"]).optional(),
   radius: numberValueSchema.optional(),
   strokeColor: colorValueSchema.optional(),
   strokeOpacity: numberValueSchema.optional(),
   strokeWidth: numberValueSchema.optional(),
   translate: numberOffsetValueSchema.optional(),
-  translateAnchor: z4.enum(["map", "viewport"]).optional()
+  translateAnchor: z5.enum(["map", "viewport"]).optional()
 }).strict();
-var extrusionStyleSchema = z4.object({
+var extrusionStyleSchema = z5.object({
   ...rangeShape,
   base: numberValueSchema.optional(),
   color: colorValueSchema.optional(),
   height: numberValueSchema.optional(),
   opacity: numberValueSchema.optional(),
   pattern: imageValueSchema.optional(),
-  verticalGradient: z4.boolean().optional()
+  verticalGradient: z5.boolean().optional()
 }).strict();
-var areaStyleSchema = z4.object({ fill: fillStyleSchema.optional(), outline: lineStyleSchema.optional() }).strict();
-var lineStackStyleSchema = z4.object({
+var areaStyleSchema = z5.object({ fill: fillStyleSchema.optional(), outline: lineStyleSchema.optional() }).strict();
+var lineStackStyleSchema = z5.object({
   casing: lineStyleSchema.optional(),
   fill: lineStyleSchema.optional(),
   shadow: lineStyleSchema.optional()
 }).strict();
-var lineHatchStyleSchema = z4.object({
+var lineHatchStyleSchema = z5.object({
   ...rangeShape,
   angle: numberValueSchema.optional(),
   color: colorValueSchema.optional(),
@@ -12053,62 +12113,62 @@ var lineHatchStyleSchema = z4.object({
   }
 });
 var roadLayerStyleSchema = lineStackStyleSchema.extend({ hatch: lineHatchStyleSchema.optional() }).strict();
-var symbolStyleSchema = z4.object({
+var symbolStyleSchema = z5.object({
   ...symbolPlacementShape,
   icon: iconStyleSchema.optional(),
   text: textStyleSchema.optional()
 }).strict();
 var markerSymbolStyleSchema = symbolStyleSchema.extend({ marker: circleStyleSchema.optional() }).strict();
 var poiCategoryStyleSchema = markerSymbolStyleSchema.omit({ priority: true, priorityOrder: true }).extend({
-  density: z4.union([z4.literal(1), z4.literal(2), z4.literal(3), z4.literal(4), z4.literal(5)]).optional()
+  density: z5.union([z5.literal(1), z5.literal(2), z5.literal(3), z5.literal(4), z5.literal(5)]).optional()
 }).strict();
-var renderScalarSchema = z4.union([z4.boolean(), z4.number().finite(), z4.string()]);
-var renderTargetSchema = z4.string().regex(tileflowSemanticTargetPattern, "Expected a semantic target");
-var renderStackOperationNameSchema = z4.string().regex(
+var renderScalarSchema = z5.union([z5.boolean(), z5.number().finite(), z5.string()]);
+var renderTargetSchema = z5.string().regex(tileflowSemanticTargetPattern, "Expected a semantic target");
+var renderStackOperationNameSchema = z5.string().regex(
   tileflowRenderStackOperationNamePattern,
   "Expected a lowercase-initial portable render-stack operation name without dots"
 );
 var renderFieldNormalizationShape = {
-  coerce: z4.literal("number").optional(),
+  coerce: z5.literal("number").optional(),
   fallback: renderScalarSchema.optional(),
-  field: z4.enum(tileflowSemanticFieldNames)
+  field: z5.enum(tileflowSemanticFieldNames)
 };
-var renderSelectorNodeSchema = z4.lazy(
-  () => z4.discriminatedUnion("kind", [
-    z4.object({ kind: z4.literal("literal"), value: z4.boolean() }).strict(),
-    z4.object({ kind: z4.literal("geometry"), geometry: z4.enum(tileflowRenderSelectorGeometries) }).strict(),
-    z4.object({ kind: z4.literal("has"), field: z4.enum(tileflowSemanticFieldNames) }).strict(),
-    z4.object({
+var renderSelectorNodeSchema = z5.lazy(
+  () => z5.discriminatedUnion("kind", [
+    z5.object({ kind: z5.literal("literal"), value: z5.boolean() }).strict(),
+    z5.object({ kind: z5.literal("geometry"), geometry: z5.enum(tileflowRenderSelectorGeometries) }).strict(),
+    z5.object({ kind: z5.literal("has"), field: z5.enum(tileflowSemanticFieldNames) }).strict(),
+    z5.object({
       ...renderFieldNormalizationShape,
-      kind: z4.literal("compare"),
-      operator: z4.enum(tileflowRenderSelectorComparisons),
+      kind: z5.literal("compare"),
+      operator: z5.enum(tileflowRenderSelectorComparisons),
       value: renderScalarSchema
     }).strict(),
-    z4.object({
+    z5.object({
       ...renderFieldNormalizationShape,
-      kind: z4.literal("in"),
-      values: z4.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
+      kind: z5.literal("in"),
+      values: z5.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
     }).strict(),
-    z4.object({
+    z5.object({
       ...renderFieldNormalizationShape,
-      branches: z4.array(
-        z4.object({
-          result: z4.boolean(),
-          values: z4.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
+      branches: z5.array(
+        z5.object({
+          result: z5.boolean(),
+          values: z5.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
         }).strict()
       ).min(1).max(tileflowRenderStackLimits.maxMatchBranches),
-      kind: z4.literal("match"),
-      otherwise: z4.boolean()
+      kind: z5.literal("match"),
+      otherwise: z5.boolean()
     }).strict(),
-    z4.object({ kind: z4.literal("not"), selector: renderSelectorNodeSchema }).strict(),
-    z4.object({
-      kind: z4.enum(["all", "any"]),
-      selectors: z4.array(renderSelectorNodeSchema).min(1).max(tileflowRenderStackLimits.maxSelectorChildren)
+    z5.object({ kind: z5.literal("not"), selector: renderSelectorNodeSchema }).strict(),
+    z5.object({
+      kind: z5.enum(["all", "any"]),
+      selectors: z5.array(renderSelectorNodeSchema).min(1).max(tileflowRenderStackLimits.maxSelectorChildren)
     }).strict(),
-    z4.object({
+    z5.object({
       fallback: renderSelectorNodeSchema,
-      kind: z4.literal("step"),
-      stops: z4.array(z4.object({ selector: renderSelectorNodeSchema, zoom: zoomNumberSchema }).strict()).min(1).max(tileflowRenderStackLimits.maxStepStops)
+      kind: z5.literal("step"),
+      stops: z5.array(z5.object({ selector: renderSelectorNodeSchema, zoom: zoomNumberSchema }).strict()).min(1).max(tileflowRenderStackLimits.maxStepStops)
     }).strict()
   ])
 );
@@ -12119,7 +12179,7 @@ var renderSelectorSchema = renderSelectorNodeSchema.superRefine(
     }
   }
 );
-var renderVisibilitySchema = z4.object({ visibilityGroup: z4.literal("building").optional() });
+var renderVisibilitySchema = z5.object({ visibilityGroup: z5.literal("building").optional() });
 var renderStyleSchemas = {
   background: backgroundStyleSchema.extend(renderVisibilitySchema.shape).strict(),
   circle: circleStyleSchema.extend(renderVisibilitySchema.shape).strict(),
@@ -12128,7 +12188,7 @@ var renderStyleSchemas = {
   line: lineStyleSchema.extend(renderVisibilitySchema.shape).strict(),
   symbol: symbolStyleSchema.extend(renderVisibilitySchema.shape).strict()
 };
-var renderRequirementsSchema = z4.array(z4.enum(tileflowLayerDomains)).min(1).max(tileflowRenderStackLimits.maxRequirements).superRefine((requirements, context) => {
+var renderRequirementsSchema = z5.array(z5.enum(tileflowLayerDomains)).min(1).max(tileflowRenderStackLimits.maxRequirements).superRefine((requirements, context) => {
   const seen = /* @__PURE__ */ new Set();
   for (const [index, requirement] of requirements.entries()) {
     if (seen.has(requirement)) {
@@ -12142,40 +12202,40 @@ var renderRequirementsSchema = z4.array(z4.enum(tileflowLayerDomains)).min(1).ma
   }
 });
 var vectorRenderPassSchemas = tileflowRenderStackRenderers.filter((renderer) => renderer !== "background").map(
-  (renderer) => z4.object({
+  (renderer) => z5.object({
     attachTo: renderTargetSchema,
-    feature: z4.enum(tileflowSemanticLayerNames).optional(),
-    kind: z4.literal("render-pass"),
-    phase: z4.enum(tileflowRenderStackPhases),
-    renderer: z4.literal(renderer),
+    feature: z5.enum(tileflowSemanticLayerNames).optional(),
+    kind: z5.literal("render-pass"),
+    phase: z5.enum(tileflowRenderStackPhases),
+    renderer: z5.literal(renderer),
     requirements: renderRequirementsSchema.optional(),
     selector: renderSelectorSchema.optional(),
     style: renderStyleSchemas[renderer]
   }).strict()
 );
-var renderPassSchema = z4.discriminatedUnion("renderer", [
-  z4.object({
+var renderPassSchema = z5.discriminatedUnion("renderer", [
+  z5.object({
     attachTo: renderTargetSchema,
-    kind: z4.literal("render-pass"),
-    phase: z4.enum(tileflowRenderStackPhases),
-    renderer: z4.literal("background"),
+    kind: z5.literal("render-pass"),
+    phase: z5.enum(tileflowRenderStackPhases),
+    renderer: z5.literal("background"),
     requirements: renderRequirementsSchema.optional(),
     style: renderStyleSchemas.background
   }).strict(),
   ...vectorRenderPassSchemas
 ]);
 var renderRefinementSchemas = tileflowRenderStackRenderers.map(
-  (renderer) => z4.object({
-    kind: z4.literal("refine-render-target"),
+  (renderer) => z5.object({
+    kind: z5.literal("refine-render-target"),
     requirements: renderRequirementsSchema.optional(),
-    renderer: z4.literal(renderer),
+    renderer: z5.literal(renderer),
     ...renderer === "background" ? {} : { selector: renderSelectorSchema.optional() },
     style: renderStyleSchemas[renderer],
     target: renderTargetSchema
   }).strict()
 );
-var renderStackOperationSchema = z4.union([renderPassSchema, ...renderRefinementSchemas]);
-var renderStackSchema = z4.record(renderStackOperationNameSchema, renderStackOperationSchema).superRefine((stack, context) => {
+var renderStackOperationSchema = z5.union([renderPassSchema, ...renderRefinementSchemas]);
+var renderStackSchema = z5.record(renderStackOperationNameSchema, renderStackOperationSchema).superRefine((stack, context) => {
   const size = Object.keys(stack).length;
   if (size === 0) {
     context.addIssue({
@@ -12190,19 +12250,19 @@ var renderStackSchema = z4.record(renderStackOperationNameSchema, renderStackOpe
     });
   }
 }).describe("tileflow-render-stack");
-var roadClassSchema = z4.enum(tileflowRoadClasses);
-var roadClassStyleSchema = z4.object({
-  enabled: z4.boolean().optional(),
+var roadClassSchema = z5.enum(tileflowRoadClasses);
+var roadClassStyleSchema = z5.object({
+  enabled: z5.boolean().optional(),
   bridge: roadLayerStyleSchema.optional(),
   surface: roadLayerStyleSchema.optional(),
   tunnel: roadLayerStyleSchema.optional()
 }).strict();
-var roadStructureMapSchema = z4.object({
+var roadStructureMapSchema = z5.object({
   bridge: roadLayerStyleSchema.optional(),
   surface: roadLayerStyleSchema.optional(),
   tunnel: roadLayerStyleSchema.optional()
 }).strict();
-var roadTreatmentLayerStyleSchema = z4.object({
+var roadTreatmentLayerStyleSchema = z5.object({
   casing: lineStyleSchema.pick({
     blur: true,
     color: true,
@@ -12231,19 +12291,19 @@ var roadTreatmentLayerStyleSchema = z4.object({
     width: true
   }).optional()
 }).strict();
-var roadTreatmentStyleSchema = z4.object({
+var roadTreatmentStyleSchema = z5.object({
   bridge: roadTreatmentLayerStyleSchema.optional(),
-  enabled: z4.boolean().optional(),
+  enabled: z5.boolean().optional(),
   surface: roadTreatmentLayerStyleSchema.optional(),
   tunnel: roadTreatmentLayerStyleSchema.optional(),
   widthScale: themeNumberValueSchema.optional()
 }).strict();
-var landModuleSchema = z4.object({
-  type: z4.literal("land"),
+var landModuleSchema = z5.object({
+  type: z5.literal("land"),
   background: backgroundStyleSchema.optional(),
-  enabled: z4.boolean().optional(),
+  enabled: z5.boolean().optional(),
   globalLandcover: fillStyleSchema.optional(),
-  landcover: z4.object({
+  landcover: z5.object({
     farmland: areaStyleSchema.optional(),
     flowerbed: areaStyleSchema.optional(),
     grass: areaStyleSchema.optional(),
@@ -12259,7 +12319,7 @@ var landModuleSchema = z4.object({
     wetland: areaStyleSchema.optional(),
     wood: areaStyleSchema.optional()
   }).strict().optional(),
-  landuse: z4.object({
+  landuse: z5.object({
     cemetery: areaStyleSchema.optional(),
     civic: areaStyleSchema.optional(),
     commercial: areaStyleSchema.optional(),
@@ -12275,99 +12335,99 @@ var landModuleSchema = z4.object({
   }).strict().optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var waterModuleSchema = z4.object({
-  type: z4.literal("water"),
+var waterModuleSchema = z5.object({
+  type: z5.literal("water"),
   bathymetry: fillStyleSchema.optional(),
   bathymetryContours: lineStyleSchema.optional(),
   bathymetryLabels: symbolStyleSchema.optional(),
   bodies: areaStyleSchema.optional(),
-  enabled: z4.boolean().optional(),
-  intermittent: z4.object({ bodies: areaStyleSchema.optional(), waterways: lineStyleSchema.optional() }).strict().optional(),
+  enabled: z5.boolean().optional(),
+  intermittent: z5.object({ bodies: areaStyleSchema.optional(), waterways: lineStyleSchema.optional() }).strict().optional(),
   renderStack: renderStackSchema.optional(),
-  waterways: z4.object({
+  waterways: z5.object({
     canal: lineStyleSchema.optional(),
     other: lineStyleSchema.optional(),
     river: lineStyleSchema.optional(),
     stream: lineStyleSchema.optional()
   }).strict().optional()
 }).strict();
-var buildingsModuleSchema = z4.object({
-  type: z4.literal("buildings"),
+var buildingsModuleSchema = z5.object({
+  type: z5.literal("buildings"),
   businessCorridor: areaStyleSchema.optional(),
-  enabled: z4.boolean().optional(),
+  enabled: z5.boolean().optional(),
   extrusion: extrusionStyleSchema.optional(),
   flat: areaStyleSchema.optional(),
-  mode: z4.enum(["3d", "flat"]).optional(),
+  mode: z5.enum(["3d", "flat"]).optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var addressesModuleSchema = z4.object({
-  type: z4.literal("addresses"),
-  enabled: z4.boolean().optional(),
+var addressesModuleSchema = z5.object({
+  type: z5.literal("addresses"),
+  enabled: z5.boolean().optional(),
   labels: symbolStyleSchema.optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var landformClassSchema = z4.enum(tileflowLandformClasses);
-var landformsModuleSchema = z4.object({
-  type: z4.literal("landforms"),
-  classes: z4.partialRecord(landformClassSchema, symbolStyleSchema).optional(),
-  elevation: z4.boolean().optional(),
-  enabled: z4.boolean().optional(),
+var landformClassSchema = z5.enum(tileflowLandformClasses);
+var landformsModuleSchema = z5.object({
+  type: z5.literal("landforms"),
+  classes: z5.partialRecord(landformClassSchema, symbolStyleSchema).optional(),
+  elevation: z5.boolean().optional(),
+  enabled: z5.boolean().optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var boundariesModuleSchema = z4.object({
-  type: z4.literal("boundaries"),
+var boundariesModuleSchema = z5.object({
+  type: z5.literal("boundaries"),
   admin2: lineStyleSchema.optional(),
   admin4: lineStyleSchema.optional(),
   disputed: lineStyleSchema.optional(),
-  enabled: z4.boolean().optional(),
+  enabled: z5.boolean().optional(),
   maritime: lineStyleSchema.optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var aerowaysModuleSchema = z4.object({
-  type: z4.literal("aeroways"),
+var aerowaysModuleSchema = z5.object({
+  type: z5.literal("aeroways"),
   area: areaStyleSchema.optional(),
-  enabled: z4.boolean().optional(),
+  enabled: z5.boolean().optional(),
   runway: lineStackStyleSchema.optional(),
   runwayRef: symbolStyleSchema.optional(),
   renderStack: renderStackSchema.optional(),
   taxiway: lineStackStyleSchema.optional()
 }).strict();
-var transitModuleSchema = z4.object({
-  type: z4.literal("transit"),
+var transitModuleSchema = z5.object({
+  type: z5.literal("transit"),
   cableway: lineStyleSchema.optional(),
-  enabled: z4.boolean().optional(),
+  enabled: z5.boolean().optional(),
   ferry: lineStyleSchema.optional(),
-  rail: z4.object({
+  rail: z5.object({
     bridge: lineStyleSchema.optional(),
     surface: lineStyleSchema.optional(),
     tunnel: lineStyleSchema.optional()
   }).strict().optional(),
-  railHatching: z4.object({
+  railHatching: z5.object({
     bridge: lineStyleSchema.optional(),
     surface: lineStyleSchema.optional(),
     tunnel: lineStyleSchema.optional()
   }).strict().optional(),
-  serviceRail: z4.object({
+  serviceRail: z5.object({
     bridge: lineStyleSchema.optional(),
     surface: lineStyleSchema.optional(),
     tunnel: lineStyleSchema.optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var roadsModuleSchema = z4.object({
-  type: z4.literal("roads"),
-  areas: z4.object({
+var roadsModuleSchema = z5.object({
+  type: z5.literal("roads"),
+  areas: z5.object({
     pedestrian: areaStyleSchema.optional(),
     pier: areaStyleSchema.optional(),
     road: areaStyleSchema.optional()
   }).strict().optional(),
-  classes: z4.partialRecord(roadClassSchema, roadClassStyleSchema).optional(),
+  classes: z5.partialRecord(roadClassSchema, roadClassStyleSchema).optional(),
   crossings: iconStyleSchema.extend({ image: imageValueSchema }).strict().optional(),
-  detail: z4.enum(["none", "highways", "major", "streets", "all"]).optional(),
-  enabled: z4.boolean().optional(),
-  extras: z4.object({ paths: z4.boolean().optional() }).strict().optional(),
-  hierarchy: z4.enum(["subtle", "clear", "strong"]).optional(),
-  modifiers: z4.object({
+  detail: z5.enum(["none", "highways", "major", "streets", "all"]).optional(),
+  enabled: z5.boolean().optional(),
+  extras: z5.object({ paths: z5.boolean().optional() }).strict().optional(),
+  hierarchy: z5.enum(["subtle", "clear", "strong"]).optional(),
+  modifiers: z5.object({
     construction: roadTreatmentStyleSchema.optional(),
     expressway: roadTreatmentStyleSchema.optional(),
     indoor: roadTreatmentStyleSchema.optional(),
@@ -12375,7 +12435,7 @@ var roadsModuleSchema = z4.object({
     ramp: roadTreatmentStyleSchema.optional(),
     unpaved: roadTreatmentStyleSchema.optional()
   }).strict().optional(),
-  mountainBike: z4.object({
+  mountainBike: z5.object({
     "0": roadTreatmentStyleSchema.optional(),
     "0+": roadTreatmentStyleSchema.optional(),
     "1": roadTreatmentStyleSchema.optional(),
@@ -12388,9 +12448,9 @@ var roadsModuleSchema = z4.object({
     "5": roadTreatmentStyleSchema.optional(),
     "6": roadTreatmentStyleSchema.optional()
   }).strict().optional(),
-  oneWayMarkers: z4.boolean().optional(),
-  outline: z4.enum(["none", "subtle", "strong"]).optional(),
-  restrictions: z4.object({
+  oneWayMarkers: z5.boolean().optional(),
+  outline: z5.enum(["none", "subtle", "strong"]).optional(),
+  restrictions: z5.object({
     access: roadTreatmentStyleSchema.optional(),
     bicycle: roadTreatmentStyleSchema.optional(),
     foot: roadTreatmentStyleSchema.optional(),
@@ -12398,24 +12458,24 @@ var roadsModuleSchema = z4.object({
     toll: roadTreatmentStyleSchema.optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional(),
-  roundabouts: z4.object({ casing: circleStyleSchema.optional(), fill: circleStyleSchema.optional() }).strict().optional(),
-  serviceTypes: z4.object({
+  roundabouts: z5.object({ casing: circleStyleSchema.optional(), fill: circleStyleSchema.optional() }).strict().optional(),
+  serviceTypes: z5.object({
     alley: roadTreatmentStyleSchema.optional(),
     crossover: roadTreatmentStyleSchema.optional(),
     driveway: roadTreatmentStyleSchema.optional(),
     parkingAisle: roadTreatmentStyleSchema.optional(),
     yard: roadTreatmentStyleSchema.optional()
   }).strict().optional(),
-  sidewalks: z4.object({
+  sidewalks: z5.object({
     outline: lineStyleSchema.optional(),
     pattern: fillStyleSchema.optional(),
     surface: fillStyleSchema.optional()
   }).strict().optional(),
   structures: roadStructureMapSchema.optional(),
-  weight: z4.enum(["thin", "regular", "bold"]).optional(),
-  widthScale: z4.partialRecord(roadClassSchema, themeNumberValueSchema).optional()
+  weight: z5.enum(["thin", "regular", "bold"]).optional(),
+  widthScale: z5.partialRecord(roadClassSchema, themeNumberValueSchema).optional()
 }).strict();
-var placeLabelStylesSchema = z4.object({
+var placeLabelStylesSchema = z5.object({
   city: symbolStyleSchema.optional(),
   continent: symbolStyleSchema.optional(),
   country: symbolStyleSchema.optional(),
@@ -12425,65 +12485,65 @@ var placeLabelStylesSchema = z4.object({
   town: symbolStyleSchema.optional(),
   village: symbolStyleSchema.optional()
 }).strict();
-var waterLabelStylesSchema = z4.object({
+var waterLabelStylesSchema = z5.object({
   line: symbolStyleSchema.optional(),
   ocean: symbolStyleSchema.optional(),
   other: symbolStyleSchema.optional(),
   waterway: symbolStyleSchema.optional()
 }).strict();
-var labelsModuleSchema = z4.object({
-  type: z4.literal("labels"),
-  aerodromeCodes: z4.enum(["none", "iata", "all"]).optional(),
-  collisionPriority: z4.enum(["balanced", "navigation"]).optional(),
-  enabled: z4.boolean().optional(),
-  junctions: z4.boolean().optional(),
-  language: z4.string().trim().min(1).optional(),
-  places: z4.enum(["none", "major", "all"]).optional(),
-  roadClasses: z4.array(roadClassSchema).min(1).optional(),
+var labelsModuleSchema = z5.object({
+  type: z5.literal("labels"),
+  aerodromeCodes: z5.enum(["none", "iata", "all"]).optional(),
+  collisionPriority: z5.enum(["balanced", "navigation"]).optional(),
+  enabled: z5.boolean().optional(),
+  junctions: z5.boolean().optional(),
+  language: z5.string().trim().min(1).optional(),
+  places: z5.enum(["none", "major", "all"]).optional(),
+  roadClasses: z5.array(roadClassSchema).min(1).optional(),
   renderStack: renderStackSchema.optional(),
-  roads: z4.enum(["none", "highways", "major", "streets", "all"]).optional(),
-  styles: z4.object({
+  roads: z5.enum(["none", "highways", "major", "streets", "all"]).optional(),
+  styles: z5.object({
     aerodrome: symbolStyleSchema.optional(),
     junctions: symbolStyleSchema.optional(),
     places: placeLabelStylesSchema.optional(),
-    roads: z4.partialRecord(roadClassSchema, symbolStyleSchema).optional(),
-    shields: z4.object({
+    roads: z5.partialRecord(roadClassSchema, symbolStyleSchema).optional(),
+    shields: z5.object({
       default: symbolStyleSchema.optional(),
       detail: symbolStyleSchema.optional(),
-      kinds: z4.record(identifierSchema, z4.object({ image: themeImageValueSchema }).strict()).optional(),
+      kinds: z5.record(identifierSchema, z5.object({ image: themeImageValueSchema }).strict()).optional(),
       overview: symbolStyleSchema.optional(),
-      textColors: z4.record(identifierSchema, z4.object({ color: themeColorValueSchema }).strict()).optional()
+      textColors: z5.record(identifierSchema, z5.object({ color: themeColorValueSchema }).strict()).optional()
     }).strict().optional(),
     water: waterLabelStylesSchema.optional()
   }).strict().optional(),
-  shields: z4.enum(["none", "major", "all"]).optional(),
-  water: z4.enum(["none", "major", "all"]).optional()
+  shields: z5.enum(["none", "major", "all"]).optional(),
+  water: z5.enum(["none", "major", "all"]).optional()
 }).strict();
-var poiModuleSchema = z4.object({
-  type: z4.literal("poi"),
-  categories: z4.array(z4.enum(tileflowPoiCategories)).optional(),
-  color: z4.enum(["uniform", "category"]).optional(),
-  density: z4.union([z4.literal(1), z4.literal(2), z4.literal(3), z4.literal(4), z4.literal(5)]).optional(),
-  enabled: z4.boolean().optional(),
-  icons: z4.boolean().optional(),
-  labels: z4.boolean().optional(),
+var poiModuleSchema = z5.object({
+  type: z5.literal("poi"),
+  categories: z5.array(z5.enum(tileflowPoiCategories)).optional(),
+  color: z5.enum(["uniform", "category"]).optional(),
+  density: z5.union([z5.literal(1), z5.literal(2), z5.literal(3), z5.literal(4), z5.literal(5)]).optional(),
+  enabled: z5.boolean().optional(),
+  icons: z5.boolean().optional(),
+  labels: z5.boolean().optional(),
   minZoom: zoomNumberSchema.optional(),
-  placement: z4.object({
-    coupleIconAndLabel: z4.boolean().optional(),
-    iconPadding: z4.number().finite().min(0).optional(),
-    textPadding: z4.number().finite().min(0).optional()
+  placement: z5.object({
+    coupleIconAndLabel: z5.boolean().optional(),
+    iconPadding: z5.number().finite().min(0).optional(),
+    textPadding: z5.number().finite().min(0).optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional(),
-  styles: z4.partialRecord(z4.enum(tileflowPoiCategories), poiCategoryStyleSchema).optional()
+  styles: z5.partialRecord(z5.enum(tileflowPoiCategories), poiCategoryStyleSchema).optional()
 }).strict();
-var nauticalModuleSchema = z4.object({
-  type: z4.literal("nautical"),
+var nauticalModuleSchema = z5.object({
+  type: z5.literal("nautical"),
   aids: markerSymbolStyleSchema.optional(),
   coverage: areaStyleSchema.optional(),
-  enabled: z4.boolean().optional(),
+  enabled: z5.boolean().optional(),
   hazardAreas: areaStyleSchema.optional(),
   hazards: markerSymbolStyleSchema.optional(),
-  labels: z4.object({
+  labels: z5.object({
     coverage: symbolStyleSchema.optional(),
     hazards: symbolStyleSchema.optional(),
     navigationAreas: symbolStyleSchema.optional(),
@@ -12499,7 +12559,7 @@ var nauticalModuleSchema = z4.object({
   wreckAreas: areaStyleSchema.optional(),
   wrecks: markerSymbolStyleSchema.optional()
 }).strict();
-var modulesSchema = z4.object({
+var modulesSchema = z5.object({
   addresses: addressesModuleSchema.optional(),
   aeroways: aerowaysModuleSchema.optional(),
   boundaries: boundariesModuleSchema.optional(),
@@ -12511,152 +12571,152 @@ var modulesSchema = z4.object({
   poi: poiModuleSchema.optional(),
   roads: roadsModuleSchema.optional(),
   transit: transitModuleSchema.optional(),
-  vegetation: z4.object({
-    type: z4.literal("vegetation"),
-    enabled: z4.boolean().optional(),
+  vegetation: z5.object({
+    type: z5.literal("vegetation"),
+    enabled: z5.boolean().optional(),
     flat: circleStyleSchema.optional(),
     minZoom: zoomNumberSchema.optional(),
-    mode: z4.enum(["3d", "flat"]).optional(),
+    mode: z5.enum(["3d", "flat"]).optional(),
     renderStack: renderStackSchema.optional(),
-    threeDimensional: z4.object({
+    threeDimensional: z5.object({
       barkColor: themeColorValueSchema.optional(),
-      broadleafColors: z4.array(themeColorValueSchema).min(1).max(8).optional(),
-      coniferColors: z4.array(themeColorValueSchema).min(1).max(8).optional(),
-      crownScale: z4.union([
-        z4.number().finite().positive().max(10),
+      broadleafColors: z5.array(themeColorValueSchema).min(1).max(8).optional(),
+      coniferColors: z5.array(themeColorValueSchema).min(1).max(8).optional(),
+      crownScale: z5.union([
+        z5.number().finite().positive().max(10),
         themeNumberReferenceSchema,
-        z4.object({
-          kind: z4.literal("theme-fixed"),
-          reason: z4.string().trim().min(1),
-          value: z4.number().finite().positive().max(10)
+        z5.object({
+          kind: z5.literal("theme-fixed"),
+          reason: z5.string().trim().min(1),
+          value: z5.number().finite().positive().max(10)
         }).strict()
       ]).optional(),
-      heightScale: z4.union([
-        z4.number().finite().positive().max(10),
+      heightScale: z5.union([
+        z5.number().finite().positive().max(10),
         themeNumberReferenceSchema,
-        z4.object({
-          kind: z4.literal("theme-fixed"),
-          reason: z4.string().trim().min(1),
-          value: z4.number().finite().positive().max(10)
+        z5.object({
+          kind: z5.literal("theme-fixed"),
+          reason: z5.string().trim().min(1),
+          value: z5.number().finite().positive().max(10)
         }).strict()
       ]).optional()
     }).strict().optional()
   }).strict().optional(),
   water: waterModuleSchema.optional()
 }).strict();
-var layerBindingsSchema = z4.object({
-  aerodromeLabel: z4.string().trim().min(1),
-  aeroway: z4.string().trim().min(1),
-  boundary: z4.string().trim().min(1),
-  building: z4.string().trim().min(1),
-  bathymetry: z4.string().trim().min(1).optional(),
-  businessCorridor: z4.string().trim().min(1).optional(),
-  circularFeature: z4.string().trim().min(1).optional(),
-  globalLandcover: z4.string().trim().min(1).optional(),
-  houseNumber: z4.string().trim().min(1),
-  landcover: z4.string().trim().min(1),
-  landuse: z4.string().trim().min(1),
-  mountainPeak: z4.string().trim().min(1),
-  park: z4.string().trim().min(1),
-  place: z4.string().trim().min(1),
-  poi: z4.string().trim().min(1),
-  road: z4.string().trim().min(1),
-  roadName: z4.string().trim().min(1),
-  roadShield: z4.string().trim().min(1).optional(),
-  sidewalk: z4.string().trim().min(1).optional(),
-  streetFurniture: z4.string().trim().min(1).optional(),
-  tree: z4.string().trim().min(1).optional(),
-  water: z4.string().trim().min(1),
-  waterName: z4.string().trim().min(1),
-  waterway: z4.string().trim().min(1)
+var layerBindingsSchema = z5.object({
+  aerodromeLabel: z5.string().trim().min(1),
+  aeroway: z5.string().trim().min(1),
+  boundary: z5.string().trim().min(1),
+  building: z5.string().trim().min(1),
+  bathymetry: z5.string().trim().min(1).optional(),
+  businessCorridor: z5.string().trim().min(1).optional(),
+  circularFeature: z5.string().trim().min(1).optional(),
+  globalLandcover: z5.string().trim().min(1).optional(),
+  houseNumber: z5.string().trim().min(1),
+  landcover: z5.string().trim().min(1),
+  landuse: z5.string().trim().min(1),
+  mountainPeak: z5.string().trim().min(1),
+  park: z5.string().trim().min(1),
+  place: z5.string().trim().min(1),
+  poi: z5.string().trim().min(1),
+  road: z5.string().trim().min(1),
+  roadName: z5.string().trim().min(1),
+  roadShield: z5.string().trim().min(1).optional(),
+  sidewalk: z5.string().trim().min(1).optional(),
+  streetFurniture: z5.string().trim().min(1).optional(),
+  tree: z5.string().trim().min(1).optional(),
+  water: z5.string().trim().min(1),
+  waterName: z5.string().trim().min(1),
+  waterway: z5.string().trim().min(1)
 }).strict();
-var fieldBindingsSchema = z4.object({
-  access: z4.string().trim().min(1),
-  activityScore: z4.string().trim().min(1),
-  adminLevel: z4.string().trim().min(1),
-  bicycle: z4.string().trim().min(1),
-  bathymetryMinDepth: z4.string().trim().min(1).optional(),
-  bathymetrySortKey: z4.string().trim().min(1).optional(),
-  brunnel: z4.string().trim().min(1),
-  buildingKind: z4.string().trim().min(1),
-  buildingTone: z4.string().trim().min(1),
-  capital: z4.string().trim().min(1),
-  circularClearanceExtraAtZoom15: z4.string().trim().min(1).optional(),
-  circularKind: z4.string().trim().min(1).optional(),
-  circularRadiusAtZoom15: z4.string().trim().min(1).optional(),
-  circularRadiusMeters: z4.string().trim().min(1).optional(),
-  circularInnerRadiusMeters: z4.string().trim().min(1).optional(),
-  circularOuterRadiusMeters: z4.string().trim().min(1).optional(),
-  class: z4.string().trim().min(1),
-  crossing: z4.string().trim().min(1),
-  classificationConfidence: z4.string().trim().min(1),
-  confidence: z4.string().trim().min(1),
-  circumference: z4.string().trim().min(1),
-  diameterCrown: z4.string().trim().min(1),
-  disputed: z4.string().trim().min(1),
-  direction: z4.string().trim().min(1).optional(),
-  elevation: z4.string().trim().min(1),
-  elevationFeet: z4.string().trim().min(1),
-  expressway: z4.string().trim().min(1),
-  foot: z4.string().trim().min(1),
-  height: z4.string().trim().min(1),
-  hasBusiness: z4.string().trim().min(1),
-  hasParts: z4.string().trim().min(1).optional(),
-  hide3d: z4.string().trim().min(1),
-  horse: z4.string().trim().min(1),
-  houseNumber: z4.string().trim().min(1),
-  importanceTier: z4.string().trim().min(1).optional(),
-  iata: z4.string().trim().min(1),
-  icao: z4.string().trim().min(1),
-  indoor: z4.string().trim().min(1),
-  intermittent: z4.string().trim().min(1),
-  genus: z4.string().trim().min(1),
-  layer: z4.string().trim().min(1),
-  leafCycle: z4.string().trim().min(1),
-  leafType: z4.string().trim().min(1),
-  level: z4.string().trim().min(1),
-  maritime: z4.string().trim().min(1),
-  markings: z4.string().trim().min(1),
-  minHeight: z4.string().trim().min(1),
-  minZoom: z4.string().trim().min(1),
-  mtbScale: z4.string().trim().min(1),
-  name: z4.string().trim().min(1),
-  nameEnglish: z4.string().trim().min(1),
-  nameLatin: z4.string().trim().min(1),
-  network: z4.string().trim().min(1),
-  official: z4.string().trim().min(1),
-  oneway: z4.string().trim().min(1),
-  poiCategory: z4.string().trim().min(1),
-  poiFilterRank: z4.string().trim().min(1),
-  poiIcon: z4.string().trim().min(1),
-  poiSizeRank: z4.string().trim().min(1),
-  poiType: z4.string().trim().min(1),
-  ramp: z4.string().trim().min(1),
-  rank: z4.string().trim().min(1),
-  ref: z4.string().trim().min(1),
-  refLength: z4.string().trim().min(1),
-  renderHeight: z4.string().trim().min(1),
-  renderMinZoom: z4.string().trim().min(1),
-  renderMinHeight: z4.string().trim().min(1),
-  shieldKind: z4.string().trim().min(1).optional(),
-  shieldLineLengthMeters: z4.string().trim().min(1).optional(),
-  shieldNetwork: z4.string().trim().min(1).optional(),
-  shieldRank: z4.string().trim().min(1).optional(),
-  shieldText: z4.string().trim().min(1).optional(),
-  shieldTextColor: z4.string().trim().min(1).optional(),
-  service: z4.string().trim().min(1),
-  species: z4.string().trim().min(1),
-  speciesWikidata: z4.string().trim().min(1),
-  subclass: z4.string().trim().min(1),
-  surface: z4.string().trim().min(1),
-  toll: z4.string().trim().min(1)
+var fieldBindingsSchema = z5.object({
+  access: z5.string().trim().min(1),
+  activityScore: z5.string().trim().min(1),
+  adminLevel: z5.string().trim().min(1),
+  bicycle: z5.string().trim().min(1),
+  bathymetryMinDepth: z5.string().trim().min(1).optional(),
+  bathymetrySortKey: z5.string().trim().min(1).optional(),
+  brunnel: z5.string().trim().min(1),
+  buildingKind: z5.string().trim().min(1),
+  buildingTone: z5.string().trim().min(1),
+  capital: z5.string().trim().min(1),
+  circularClearanceExtraAtZoom15: z5.string().trim().min(1).optional(),
+  circularKind: z5.string().trim().min(1).optional(),
+  circularRadiusAtZoom15: z5.string().trim().min(1).optional(),
+  circularRadiusMeters: z5.string().trim().min(1).optional(),
+  circularInnerRadiusMeters: z5.string().trim().min(1).optional(),
+  circularOuterRadiusMeters: z5.string().trim().min(1).optional(),
+  class: z5.string().trim().min(1),
+  crossing: z5.string().trim().min(1),
+  classificationConfidence: z5.string().trim().min(1),
+  confidence: z5.string().trim().min(1),
+  circumference: z5.string().trim().min(1),
+  diameterCrown: z5.string().trim().min(1),
+  disputed: z5.string().trim().min(1),
+  direction: z5.string().trim().min(1).optional(),
+  elevation: z5.string().trim().min(1),
+  elevationFeet: z5.string().trim().min(1),
+  expressway: z5.string().trim().min(1),
+  foot: z5.string().trim().min(1),
+  height: z5.string().trim().min(1),
+  hasBusiness: z5.string().trim().min(1),
+  hasParts: z5.string().trim().min(1).optional(),
+  hide3d: z5.string().trim().min(1),
+  horse: z5.string().trim().min(1),
+  houseNumber: z5.string().trim().min(1),
+  importanceTier: z5.string().trim().min(1).optional(),
+  iata: z5.string().trim().min(1),
+  icao: z5.string().trim().min(1),
+  indoor: z5.string().trim().min(1),
+  intermittent: z5.string().trim().min(1),
+  genus: z5.string().trim().min(1),
+  layer: z5.string().trim().min(1),
+  leafCycle: z5.string().trim().min(1),
+  leafType: z5.string().trim().min(1),
+  level: z5.string().trim().min(1),
+  maritime: z5.string().trim().min(1),
+  markings: z5.string().trim().min(1),
+  minHeight: z5.string().trim().min(1),
+  minZoom: z5.string().trim().min(1),
+  mtbScale: z5.string().trim().min(1),
+  name: z5.string().trim().min(1),
+  nameEnglish: z5.string().trim().min(1),
+  nameLatin: z5.string().trim().min(1),
+  network: z5.string().trim().min(1),
+  official: z5.string().trim().min(1),
+  oneway: z5.string().trim().min(1),
+  poiCategory: z5.string().trim().min(1),
+  poiFilterRank: z5.string().trim().min(1),
+  poiIcon: z5.string().trim().min(1),
+  poiSizeRank: z5.string().trim().min(1),
+  poiType: z5.string().trim().min(1),
+  ramp: z5.string().trim().min(1),
+  rank: z5.string().trim().min(1),
+  ref: z5.string().trim().min(1),
+  refLength: z5.string().trim().min(1),
+  renderHeight: z5.string().trim().min(1),
+  renderMinZoom: z5.string().trim().min(1),
+  renderMinHeight: z5.string().trim().min(1),
+  shieldKind: z5.string().trim().min(1).optional(),
+  shieldLineLengthMeters: z5.string().trim().min(1).optional(),
+  shieldNetwork: z5.string().trim().min(1).optional(),
+  shieldRank: z5.string().trim().min(1).optional(),
+  shieldText: z5.string().trim().min(1).optional(),
+  shieldTextColor: z5.string().trim().min(1).optional(),
+  service: z5.string().trim().min(1),
+  species: z5.string().trim().min(1),
+  speciesWikidata: z5.string().trim().min(1),
+  subclass: z5.string().trim().min(1),
+  surface: z5.string().trim().min(1),
+  toll: z5.string().trim().min(1)
 }).strict();
-var openMapTilesSchema = z4.object({
-  type: z4.literal("openmaptiles"),
-  contractVersion: z4.literal(openMapTilesContractVersion),
+var openMapTilesSchema = z5.object({
+  type: z5.literal("openmaptiles"),
+  contractVersion: z5.literal(openMapTilesContractVersion),
   fields: fieldBindingsSchema.partial().optional(),
   layers: layerBindingsSchema.partial().optional(),
-  semantics: z4.object({ parkLayer: z4.enum(["mixed", "protected-only"]).optional() }).strict().optional()
+  semantics: z5.object({ parkLayer: z5.enum(["mixed", "protected-only"]).optional() }).strict().optional()
 }).strict().transform(
   (schema) => openMapTiles({
     capabilities: schema.layers === void 0 ? void 0 : {
@@ -12671,12 +12731,12 @@ var openMapTilesSchema = z4.object({
   })
 );
 var vectorDataShape = {
-  type: z4.literal("vector-tiles"),
-  attribution: z4.string().trim().min(1),
+  type: z5.literal("vector-tiles"),
+  attribution: z5.string().trim().min(1),
   revision: revisionSchema.optional(),
   schema: openMapTilesSchema
 };
-var publicVectorUrlSchema = z4.string().min(1).max(4096).superRefine((value, context) => {
+var publicVectorUrlSchema = z5.string().min(1).max(4096).superRefine((value, context) => {
   try {
     validatePublicVectorUrl(value);
   } catch (error) {
@@ -12686,8 +12746,8 @@ var publicVectorUrlSchema = z4.string().min(1).max(4096).superRefine((value, con
     });
   }
 }).describe("tileflow-public-vector-url");
-var marineSourceSchema = z4.object({
-  attribution: z4.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
+var marineSourceSchema = z5.object({
+  attribution: z5.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
   sourceId: identifierSchema.optional(),
   url: publicVectorUrlSchema.optional()
 }).strict();
@@ -12695,24 +12755,24 @@ var bathymetryDemUrlSchema = publicVectorUrlSchema.refine(
   (value) => !value.startsWith("pmtiles://"),
   "Expected an HTTPS, loopback HTTP, or root-relative DEM TileJSON URL"
 ).describe("tileflow-public-dem-url");
-var bathymetryReliefSchema = z4.object({
+var bathymetryReliefSchema = z5.object({
   accentColor: terrainColorValueSchema.optional(),
-  attribution: z4.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
-  encoding: z4.enum(["mapbox", "terrarium"]).optional(),
-  exaggeration: terrainNumberValueSchema(z4.number().finite().min(0).max(1)).optional(),
+  attribution: z5.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
+  encoding: z5.enum(["mapbox", "terrarium"]).optional(),
+  exaggeration: terrainNumberValueSchema(z5.number().finite().min(0).max(1)).optional(),
   highlightColor: terrainColorValueSchema.optional(),
-  illuminationAltitude: terrainNumberValueSchema(z4.number().finite().min(0).max(90)).optional(),
-  illuminationAnchor: z4.enum(["map", "viewport"]).optional(),
-  illuminationDirection: terrainNumberValueSchema(z4.number().finite().min(0).max(359)).optional(),
+  illuminationAltitude: terrainNumberValueSchema(z5.number().finite().min(0).max(90)).optional(),
+  illuminationAnchor: z5.enum(["map", "viewport"]).optional(),
+  illuminationDirection: terrainNumberValueSchema(z5.number().finite().min(0).max(359)).optional(),
   maxZoom: zoomNumberSchema.optional(),
   minZoom: zoomNumberSchema.optional(),
-  multidirectional: z4.boolean().optional(),
-  opacity: terrainNumberValueSchema(z4.number().finite().min(0).max(1)).optional(),
+  multidirectional: z5.boolean().optional(),
+  opacity: terrainNumberValueSchema(z5.number().finite().min(0).max(1)).optional(),
   shadowColor: terrainColorValueSchema.optional(),
   sourceId: identifierSchema.optional(),
-  tileSize: z4.union([z4.literal(256), z4.literal(512)]).optional(),
+  tileSize: z5.union([z5.literal(256), z5.literal(512)]).optional(),
   url: bathymetryDemUrlSchema.optional(),
-  visible: z4.boolean().optional()
+  visible: z5.boolean().optional()
 }).strict().superRefine((relief, context) => {
   if (relief.minZoom !== void 0 && relief.maxZoom !== void 0 && relief.minZoom > relief.maxZoom) {
     context.addIssue({
@@ -12722,33 +12782,33 @@ var bathymetryReliefSchema = z4.object({
     });
   }
 });
-var bathymetryConfigSchema = z4.object({
+var bathymetryConfigSchema = z5.object({
   ...marineSourceSchema.shape,
-  bands: z4.union([z4.literal(false), fillStyleSchema]).optional(),
-  contours: z4.union([z4.literal(false), lineStyleSchema]).optional(),
-  display: z4.enum(["bands", "relief", "hybrid"]).optional(),
-  labels: z4.union([z4.literal(false), symbolStyleSchema]).optional(),
-  relief: z4.union([z4.literal(false), bathymetryReliefSchema]).optional(),
-  type: z4.literal("bathymetry")
+  bands: z5.union([z5.literal(false), fillStyleSchema]).optional(),
+  contours: z5.union([z5.literal(false), lineStyleSchema]).optional(),
+  display: z5.enum(["bands", "relief", "hybrid"]).optional(),
+  labels: z5.union([z5.literal(false), symbolStyleSchema]).optional(),
+  relief: z5.union([z5.literal(false), bathymetryReliefSchema]).optional(),
+  type: z5.literal("bathymetry")
 }).strict();
-var marineSchema = z4.union([
-  z4.enum(["none", "bathymetry", "nautical", "chart"]),
-  z4.object({
-    bathymetry: z4.union([z4.literal(false), marineSourceSchema, bathymetryConfigSchema]).optional(),
-    nautical: z4.union([z4.literal(false), marineSourceSchema]).optional()
+var marineSchema = z5.union([
+  z5.enum(["none", "bathymetry", "nautical", "chart"]),
+  z5.object({
+    bathymetry: z5.union([z5.literal(false), marineSourceSchema, bathymetryConfigSchema]).optional(),
+    nautical: z5.union([z5.literal(false), marineSourceSchema]).optional()
   }).strict()
 ]);
-var directVectorDataSchema = z4.object({
+var directVectorDataSchema = z5.object({
   ...vectorDataShape,
-  bounds: z4.tuple([
-    z4.number().finite().min(-180).max(180),
-    z4.number().finite().min(-90).max(90),
-    z4.number().finite().min(-180).max(180),
-    z4.number().finite().min(-90).max(90)
+  bounds: z5.tuple([
+    z5.number().finite().min(-180).max(180),
+    z5.number().finite().min(-90).max(90),
+    z5.number().finite().min(-180).max(180),
+    z5.number().finite().min(-90).max(90)
   ]).optional(),
-  maxzoom: z4.number().int().min(0).max(30).optional(),
-  minzoom: z4.number().int().min(0).max(30).optional(),
-  tiles: z4.array(publicVectorUrlSchema).min(1).max(8)
+  maxzoom: z5.number().int().min(0).max(30).optional(),
+  minzoom: z5.number().int().min(0).max(30).optional(),
+  tiles: z5.array(publicVectorUrlSchema).min(1).max(8)
 }).strict().refine(
   (value) => value.minzoom === void 0 || value.maxzoom === void 0 || value.minzoom <= value.maxzoom,
   { message: "minzoom must not exceed maxzoom", path: ["minzoom"] }
@@ -12756,34 +12816,34 @@ var directVectorDataSchema = z4.object({
   (value) => value.bounds === void 0 || value.bounds[0] < value.bounds[2] && value.bounds[1] < value.bounds[3],
   { message: "bounds must have increasing axes", path: ["bounds"] }
 );
-var dataSchema = z4.union([
-  z4.object({
-    type: z4.literal("tileflow-world"),
-    generation: z4.literal(tileflowWorldGeneration),
-    selection: z4.discriminatedUnion("kind", [
-      z4.object({ kind: z4.literal("current"), product: z4.literal("world-v1") }).strict(),
-      z4.object({
-        kind: z4.literal("release"),
-        product: z4.literal("world-v1"),
-        release: z4.object({
-          descriptorSha256: z4.string().regex(/^[0-9a-f]{64}$/u),
+var dataSchema = z5.union([
+  z5.object({
+    type: z5.literal("tileflow-world"),
+    generation: z5.literal(tileflowWorldGeneration),
+    selection: z5.discriminatedUnion("kind", [
+      z5.object({ kind: z5.literal("current"), product: z5.literal("world-v1") }).strict(),
+      z5.object({
+        kind: z5.literal("release"),
+        product: z5.literal("world-v1"),
+        release: z5.object({
+          descriptorSha256: z5.string().regex(/^[0-9a-f]{64}$/u),
           releaseId: tileflowWorldReleaseIdSchema
         }).strict()
       }).strict()
     ])
   }).strict(),
-  z4.object({ ...vectorDataShape, url: publicVectorUrlSchema }).strict(),
+  z5.object({ ...vectorDataShape, url: publicVectorUrlSchema }).strict(),
   directVectorDataSchema
 ]);
-var hostedTilesetSourceSchema = z4.object({
-  attribution: z4.string().trim().min(1).max(4096),
-  kind: z4.literal("hosted-tileset"),
-  local: z4.string().refine(isSafeLocalPmtilesPath, {
+var hostedTilesetSourceSchema = z5.object({
+  attribution: z5.string().trim().min(1).max(4096),
+  kind: z5.literal("hosted-tileset"),
+  local: z5.string().refine(isSafeLocalPmtilesPath, {
     message: "Expected a safe relative .pmtiles path beginning with ./ or ../"
   }),
-  tileset: z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u).refine((value) => value !== "terrain" && value !== "world", "Expected a Team tileset ID"),
-  tileSize: z4.union([z4.literal(256), z4.literal(512)]).optional(),
-  type: z4.enum(["raster", "vector"])
+  tileset: z5.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u).refine((value) => value !== "terrain" && value !== "world", "Expected a Team tileset ID"),
+  tileSize: z5.union([z5.literal(256), z5.literal(512)]).optional(),
+  type: z5.enum(["raster", "vector"])
 }).strict().superRefine((source, context) => {
   if (source.type === "vector" && source.tileSize !== void 0) {
     context.addIssue({
@@ -12793,7 +12853,7 @@ var hostedTilesetSourceSchema = z4.object({
     });
   }
 });
-var hostedSourcesSchema = z4.record(tileflowMapIdSchema, hostedTilesetSourceSchema).superRefine((sources, context) => {
+var hostedSourcesSchema = z5.record(tileflowMapIdSchema, hostedTilesetSourceSchema).superRefine((sources, context) => {
   if (Object.keys(sources).length > tileflowHostedSourceLimit) {
     context.addIssue({
       code: "too_big",
@@ -12802,7 +12862,7 @@ var hostedSourcesSchema = z4.record(tileflowMapIdSchema, hostedTilesetSourceSche
     });
   }
 });
-var maplibreOverlayLayerSchema = z4.record(z4.string(), z4.unknown()).superRefine((layer, context) => {
+var maplibreOverlayLayerSchema = z5.record(z5.string(), z5.unknown()).superRefine((layer, context) => {
   if (!tileflowMapIdSchema.safeParse(layer.id).success) {
     context.addIssue({ code: "custom", message: "Expected a portable layer ID", path: ["id"] });
   }
@@ -12820,30 +12880,41 @@ var maplibreOverlayLayerSchema = z4.record(z4.string(), z4.unknown()).superRefin
     });
   }
 });
-var maplibreOverlaySchema = z4.object({
-  kind: z4.literal("maplibre-overlay"),
-  layers: z4.array(maplibreOverlayLayerSchema).min(1),
-  placement: z4.enum(tileflowOverlayPlacements),
+var maplibreOverlaySchema = z5.object({
+  kind: z5.literal("maplibre-overlay"),
+  layers: z5.array(maplibreOverlayLayerSchema).min(1),
+  placement: z5.enum(tileflowOverlayPlacements),
   source: tileflowMapIdSchema
 }).strict();
-var overlaysSchema = z4.record(tileflowMapIdSchema, maplibreOverlaySchema);
-var localAssetDirectorySchema = z4.string().min(3).max(tileflowLocalDirectoryMaximumLength).refine(isTileflowLocalDirectory, { message: tileflowLocalDirectoryMessage });
-var packageAssetDirectorySchema = z4.object({
-  kind: z4.literal("package-directory"),
-  package: z4.string().regex(
+var overlaysSchema = z5.record(tileflowMapIdSchema, maplibreOverlaySchema);
+var localAssetDirectorySchema = z5.string().min(3).max(tileflowLocalDirectoryMaximumLength).refine(isTileflowLocalDirectory, { message: tileflowLocalDirectoryMessage });
+var packageAssetDirectorySchema = z5.object({
+  kind: z5.literal("package-directory"),
+  package: z5.string().regex(
     /^(?:@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*|[a-z0-9][a-z0-9._-]*)$/u,
     "Expected a lowercase npm package name"
   ),
-  path: z4.string().min(1).max(512).refine(
+  path: z5.string().min(1).max(512).refine(
     (value) => !value.startsWith("/") && !value.includes("\\") && value.split("/").every((segment) => Boolean(segment) && segment !== "." && segment !== ".."),
     "Expected a portable package-relative directory"
   )
 }).strict();
-var assetDirectorySchema = z4.union([localAssetDirectorySchema, packageAssetDirectorySchema]);
-var iconDirectoriesSchema = z4.array(assetDirectorySchema).max(32);
-var fontDirectoriesSchema = z4.array(assetDirectorySchema).max(16);
-var fontStacksSchema = z4.array(
-  z4.string().min(1).max(200).refine(
+var assetDirectorySchema = z5.union([localAssetDirectorySchema, packageAssetDirectorySchema]);
+var iconDirectoriesSchema = z5.array(
+  z5.union([localAssetDirectorySchema, packageAssetDirectorySchema, tileflowIconSetSourceSchema])
+).max(tileflowIconSourceLimit).superRefine((sources, context) => {
+  try {
+    collectTileflowIconSetReferences(sources);
+  } catch (cause) {
+    context.addIssue({
+      code: "custom",
+      message: cause instanceof Error ? cause.message : "Invalid icon contributors"
+    });
+  }
+});
+var fontDirectoriesSchema = z5.array(assetDirectorySchema).max(16);
+var fontStacksSchema = z5.array(
+  z5.string().min(1).max(200).refine(
     (value) => value === value.trim() && value === value.normalize("NFC") && !/[\p{Cc}\\/]/u.test(value),
     "Expected an exact NFC MapLibre font-stack key without whitespace padding, controls, slashes, or backslashes"
   )
@@ -12860,10 +12931,10 @@ var fontStacksSchema = z4.array(
     seen.add(fontStack);
   }
 });
-var glyphsSchema = z4.object({
+var glyphsSchema = z5.object({
   fontStacks: fontStacksSchema,
-  kind: z4.literal("url"),
-  url: z4.string().min(1).refine(
+  kind: z5.literal("url"),
+  url: z5.string().min(1).refine(
     (value) => value.includes("{fontstack}") && value.includes("{range}"),
     "Expected {fontstack} and {range} placeholders"
   ).refine(isSafeGlyphUrl, "Expected an HTTP(S), root-relative, or path-relative glyph URL")
@@ -12871,34 +12942,34 @@ var glyphsSchema = z4.object({
 var terrainLayerRangeShape = {
   maxZoom: zoomNumberSchema.optional(),
   minZoom: zoomNumberSchema.optional(),
-  visible: z4.boolean().optional()
+  visible: z5.boolean().optional()
 };
-var terrainHillshadeSchema = z4.object({
+var terrainHillshadeSchema = z5.object({
   ...terrainLayerRangeShape,
   accentColor: terrainColorValueSchema.optional(),
-  exaggeration: terrainNumberValueSchema(z4.number().finite().min(0).max(1)).optional(),
+  exaggeration: terrainNumberValueSchema(z5.number().finite().min(0).max(1)).optional(),
   highlightColor: terrainColorValueSchema.optional(),
-  illuminationAnchor: z4.enum(["map", "viewport"]).optional(),
-  illuminationDirection: terrainNumberValueSchema(z4.number().finite().min(0).max(359)).optional(),
+  illuminationAnchor: z5.enum(["map", "viewport"]).optional(),
+  illuminationDirection: terrainNumberValueSchema(z5.number().finite().min(0).max(359)).optional(),
   shadowColor: terrainColorValueSchema.optional()
 }).strict();
-var terrainContourLineSchema = z4.object({
+var terrainContourLineSchema = z5.object({
   ...terrainLayerRangeShape,
   color: terrainColorValueSchema.optional(),
-  opacity: terrainNumberValueSchema(z4.number().finite().min(0).max(1)).optional(),
-  width: terrainNumberValueSchema(z4.number().finite().min(0).max(32)).optional()
+  opacity: terrainNumberValueSchema(z5.number().finite().min(0).max(1)).optional(),
+  width: terrainNumberValueSchema(z5.number().finite().min(0).max(32)).optional()
 }).strict();
-var terrainContourLabelSchema = z4.object({
+var terrainContourLabelSchema = z5.object({
   ...terrainLayerRangeShape,
   color: terrainColorValueSchema.optional(),
   font: moduleFontValueSchema.optional(),
   haloColor: terrainColorValueSchema.optional(),
-  haloWidth: terrainNumberValueSchema(z4.number().finite().min(0).max(16)).optional(),
-  opacity: terrainNumberValueSchema(z4.number().finite().min(0).max(1)).optional(),
-  size: terrainNumberValueSchema(z4.number().finite().min(1).max(64)).optional(),
-  spacing: terrainNumberValueSchema(z4.number().finite().min(1).max(1e3)).optional()
+  haloWidth: terrainNumberValueSchema(z5.number().finite().min(0).max(16)).optional(),
+  opacity: terrainNumberValueSchema(z5.number().finite().min(0).max(1)).optional(),
+  size: terrainNumberValueSchema(z5.number().finite().min(1).max(64)).optional(),
+  spacing: terrainNumberValueSchema(z5.number().finite().min(1).max(1e3)).optional()
 }).strict();
-var terrainContourThresholdPairSchema = z4.tuple([z4.number().finite().min(1e-3).max(1e5), z4.number().finite().min(1e-3).max(1e5)]).refine(([minor, index]) => minor <= index, {
+var terrainContourThresholdPairSchema = z5.tuple([z5.number().finite().min(1e-3).max(1e5), z5.number().finite().min(1e-3).max(1e5)]).refine(([minor, index]) => minor <= index, {
   message: "Expected the index contour interval to be greater than or equal to the minor interval"
 }).refine(([minor, index]) => isWholeContourMultiple2(index, minor), {
   message: "Expected the index contour interval to be a whole multiple of the minor interval"
@@ -12907,7 +12978,7 @@ function isWholeContourMultiple2(value, interval) {
   const ratio = value / interval;
   return Math.abs(ratio - Math.round(ratio)) <= Number.EPSILON * Math.max(1, ratio) * 8;
 }
-var terrainContourThresholdsSchema = z4.record(z4.string().regex(/^(?:0|[1-9]|1\d|2[0-4])$/u), terrainContourThresholdPairSchema).superRefine((thresholds, context) => {
+var terrainContourThresholdsSchema = z5.record(z5.string().regex(/^(?:0|[1-9]|1\d|2[0-4])$/u), terrainContourThresholdPairSchema).superRefine((thresholds, context) => {
   const count = Object.keys(thresholds).length;
   if (count === 0 || count > 25) {
     context.addIssue({
@@ -12916,19 +12987,19 @@ var terrainContourThresholdsSchema = z4.record(z4.string().regex(/^(?:0|[1-9]|1\
     });
   }
 });
-var terrainContoursSchema = z4.object({
-  demMaxZoom: z4.number().int().min(0).max(24),
-  demUrl: z4.string().min(1).max(2048).refine(
+var terrainContoursSchema = z5.object({
+  demMaxZoom: z5.number().int().min(0).max(24),
+  demUrl: z5.string().min(1).max(2048).refine(
     isSafeTileflowDemUrlTemplate,
     "Expected a safe HTTP(S) DEM URL template containing {z}, {x}, and {y}"
   ),
   index: terrainContourLineSchema.optional(),
   labels: terrainContourLabelSchema.optional(),
-  maxZoom: z4.number().int().min(0).max(24).optional(),
+  maxZoom: z5.number().int().min(0).max(24).optional(),
   minZoom: zoomNumberSchema.optional(),
   minor: terrainContourLineSchema.optional(),
-  multiplier: z4.number().finite().min(1e-3).max(100).optional(),
-  overzoom: z4.number().int().min(0).max(8).optional(),
+  multiplier: z5.number().finite().min(1e-3).max(100).optional(),
+  overzoom: z5.number().int().min(0).max(8).optional(),
   sourceId: identifierSchema.optional(),
   thresholds: terrainContourThresholdsSchema
 }).strict().superRefine((contours, context) => {
@@ -12992,26 +13063,26 @@ var terrainContoursSchema = z4.object({
     }
   }
 });
-var terrainSchema = z4.union([
-  z4.enum(["none", "hillshade", "3d"]),
-  z4.object({
-    attribution: z4.string().optional(),
+var terrainSchema = z5.union([
+  z5.enum(["none", "hillshade", "3d"]),
+  z5.object({
+    attribution: z5.string().optional(),
     contours: terrainContoursSchema.optional(),
-    encoding: z4.enum(["mapbox", "terrarium"]).optional(),
-    exaggeration: z4.number().finite().min(0).max(10).optional(),
+    encoding: z5.enum(["mapbox", "terrarium"]).optional(),
+    exaggeration: z5.number().finite().min(0).max(10).optional(),
     hillshade: terrainHillshadeSchema.optional(),
-    mode: z4.enum(["none", "hillshade", "3d"]).optional(),
-    sourceId: z4.string().trim().min(1).optional(),
-    url: z4.string().trim().min(1).optional()
+    mode: z5.enum(["none", "hillshade", "3d"]).optional(),
+    sourceId: z5.string().trim().min(1).optional(),
+    url: z5.string().trim().min(1).optional()
   }).strict()
 ]);
-var viewSchema = z4.object({
-  bearing: z4.number().finite().min(-180).max(180).optional(),
-  center: z4.tuple([z4.number().finite().min(-180).max(180), z4.number().finite().min(-90).max(90)]).optional(),
-  pitch: z4.number().finite().min(0).max(85).optional(),
+var viewSchema = z5.object({
+  bearing: z5.number().finite().min(-180).max(180).optional(),
+  center: z5.tuple([z5.number().finite().min(-180).max(180), z5.number().finite().min(-90).max(90)]).optional(),
+  pitch: z5.number().finite().min(0).max(85).optional(),
   zoom: zoomNumberSchema.optional()
 }).strict();
-var themesSchema = z4.record(tileflowThemeNameSchema, tileflowThemeSchema).superRefine((themes, context) => {
+var themesSchema = z5.record(tileflowThemeNameSchema, tileflowThemeSchema).superRefine((themes, context) => {
   const names = Object.keys(themes);
   if (names.length === 0) {
     context.addIssue({ code: "custom", message: "Expected at least one named theme" });
@@ -13035,8 +13106,8 @@ var themesSchema = z4.record(tileflowThemeNameSchema, tileflowThemeSchema).super
     }
   }
 }).describe("tileflow-themes");
-var systemThemesSchema = z4.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict();
-var resolvedTileflowMapSchema = z4.object({
+var systemThemesSchema = z5.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict();
+var resolvedTileflowMapSchema = z5.object({
   data: dataSchema.optional(),
   defaultTheme: tileflowThemeNameSchema,
   fonts: fontDirectoriesSchema.optional(),
@@ -13045,14 +13116,14 @@ var resolvedTileflowMapSchema = z4.object({
   id: tileflowMapIdSchema,
   marine: marineSchema.optional(),
   modules: modulesSchema.optional(),
-  name: z4.string().trim().min(1),
+  name: z5.string().trim().min(1),
   overlays: overlaysSchema.optional(),
-  projection: z4.enum(["globe", "mercator"]).optional(),
+  projection: z5.enum(["globe", "mercator"]).optional(),
   sources: hostedSourcesSchema.optional(),
   systemThemes: systemThemesSchema.optional(),
   terrain: terrainSchema.optional(),
   themes: themesSchema,
-  version: z4.number().int().positive(),
+  version: z5.number().int().positive(),
   view: viewSchema.optional()
 }).strict().superRefine((map, context) => {
   if (map.fonts !== void 0 && map.glyphs !== void 0) {
@@ -15885,7 +15956,7 @@ function asRecord7(value) {
 init_themes();
 
 // src/icon-package.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var tileflowIconPackageFileNames = [
   "sprite.json",
   "sprite.png",
@@ -15910,17 +15981,17 @@ var tileflowHostedAlphaCompatibility = {
   },
   maxMapsPerDeploy: 20
 };
-var sha256Schema = z6.string().regex(/^[a-f0-9]{64}$/);
+var sha256Schema = z7.string().regex(/^[a-f0-9]{64}$/);
 var tileflowIconPackageContentHashSchema = sha256Schema;
-var tileflowIconIdSchema = z6.string().max(64).regex(tileflowIconIdPattern);
-var tileflowRenderedIconManifestEntrySchema = z6.object({
+var tileflowIconIdSchema = z7.string().max(64).regex(tileflowIconIdPattern);
+var tileflowRenderedIconManifestEntrySchema = z7.object({
   name: tileflowIconIdSchema,
-  pixelSha256: z6.object({
+  pixelSha256: z7.object({
     oneX: sha256Schema,
     twoX: sha256Schema
   }).strict()
 }).strict();
-var tileflowIconPackageLabelSchema = z6.string().superRefine((value, context) => {
+var tileflowIconPackageLabelSchema = z7.string().superRefine((value, context) => {
   if (value !== value.trim() || value.length === 0) {
     context.addIssue({
       code: "custom",
@@ -15940,32 +16011,32 @@ var tileflowIconPackageLabelSchema = z6.string().superRefine((value, context) =>
     });
   }
 });
-var spriteDimensionsSchema = z6.object({
-  height: z6.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
-  pixelRatio: z6.union([z6.literal(1), z6.literal(2)]),
-  width: z6.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension)
+var spriteDimensionsSchema = z7.object({
+  height: z7.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
+  pixelRatio: z7.union([z7.literal(1), z7.literal(2)]),
+  width: z7.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension)
 }).strict();
 function iconPackageFileSchema(name, contentType) {
-  return z6.object({
-    byteLength: z6.number().int().nonnegative().max(tileflowIconPackageLimits.maxGeneratedFileBytes),
-    contentType: z6.literal(contentType),
-    name: z6.literal(name),
+  return z7.object({
+    byteLength: z7.number().int().nonnegative().max(tileflowIconPackageLimits.maxGeneratedFileBytes),
+    contentType: z7.literal(contentType),
+    name: z7.literal(name),
     sha256: sha256Schema
   }).strict();
 }
-var tileflowIconPackageManifestSchema = z6.object({
-  files: z6.tuple([
+var tileflowIconPackageManifestSchema = z7.object({
+  files: z7.tuple([
     iconPackageFileSchema("sprite.json", "application/json"),
     iconPackageFileSchema("sprite.png", "image/png"),
     iconPackageFileSchema("sprite@2x.json", "application/json"),
     iconPackageFileSchema("sprite@2x.png", "image/png")
   ]),
-  format: z6.literal("tileflow-icon-package-v1"),
-  iconNames: z6.array(tileflowIconIdSchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
-  renderedIcons: z6.array(tileflowRenderedIconManifestEntrySchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
-  sprites: z6.object({
-    oneX: spriteDimensionsSchema.extend({ pixelRatio: z6.literal(1) }),
-    twoX: spriteDimensionsSchema.extend({ pixelRatio: z6.literal(2) })
+  format: z7.literal("tileflow-icon-package-v1"),
+  iconNames: z7.array(tileflowIconIdSchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
+  renderedIcons: z7.array(tileflowRenderedIconManifestEntrySchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
+  sprites: z7.object({
+    oneX: spriteDimensionsSchema.extend({ pixelRatio: z7.literal(1) }),
+    twoX: spriteDimensionsSchema.extend({ pixelRatio: z7.literal(2) })
   }).strict()
 }).strict().superRefine((manifest, context) => {
   const sortedNames = [...manifest.iconNames].sort(compareCodeUnits11);
@@ -16091,7 +16162,7 @@ function containsControlCharacter(value) {
 }
 
 // src/font-bundle.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var tileflowFontBundleLimits = {
   maxFaceCount: 16,
   maxFileCount: 32,
@@ -16100,39 +16171,39 @@ var tileflowFontBundleLimits = {
   maxManifestBytes: 64 * 1024,
   maxPackageBytes: 20 * 1024 * 1024
 };
-var sha256Schema2 = z7.string().regex(/^[a-f0-9]{64}$/u);
-var fontFileNameSchema = z7.string().max(512).regex(/^fonts\/[a-z0-9]+(?:-[a-z0-9]+)*-[a-f0-9]{64}\.(?:otf|ttf|woff2)$/u);
-var licenseFileNameSchema = z7.string().max(512).regex(/^fonts\/licenses\/license-[a-f0-9]{64}\.txt$/u);
-var fontFamilySchema = z7.string().min(1).max(100).refine(
+var sha256Schema2 = z8.string().regex(/^[a-f0-9]{64}$/u);
+var fontFileNameSchema = z8.string().max(512).regex(/^fonts\/[a-z0-9]+(?:-[a-z0-9]+)*-[a-f0-9]{64}\.(?:otf|ttf|woff2)$/u);
+var licenseFileNameSchema = z8.string().max(512).regex(/^fonts\/licenses\/license-[a-f0-9]{64}\.txt$/u);
+var fontFamilySchema = z8.string().min(1).max(100).refine(
   (value) => value === value.trim() && !/[\p{Cc}\\]/u.test(value),
   "Font family must be printable, trimmed text"
 );
 var tileflowFontBundleContentHashSchema = sha256Schema2;
-var fontFileSchema = z7.object({
-  byteLength: z7.number().int().positive().max(tileflowFontBundleLimits.maxFontFileBytes),
-  contentType: z7.enum(["font/otf", "font/ttf", "font/woff2"]),
-  kind: z7.literal("font"),
+var fontFileSchema = z8.object({
+  byteLength: z8.number().int().positive().max(tileflowFontBundleLimits.maxFontFileBytes),
+  contentType: z8.enum(["font/otf", "font/ttf", "font/woff2"]),
+  kind: z8.literal("font"),
   name: fontFileNameSchema,
   sha256: sha256Schema2
 }).strict();
-var licenseFileSchema = z7.object({
-  byteLength: z7.number().int().positive().max(tileflowFontBundleLimits.maxLicenseFileBytes),
-  contentType: z7.literal("text/plain; charset=utf-8"),
-  kind: z7.literal("license"),
+var licenseFileSchema = z8.object({
+  byteLength: z8.number().int().positive().max(tileflowFontBundleLimits.maxLicenseFileBytes),
+  contentType: z8.literal("text/plain; charset=utf-8"),
+  kind: z8.literal("license"),
   name: licenseFileNameSchema,
   sha256: sha256Schema2
 }).strict();
-var fontFaceSchema2 = z7.object({
+var fontFaceSchema2 = z8.object({
   family: fontFamilySchema,
   file: fontFileNameSchema,
   licenseFile: licenseFileNameSchema,
-  style: z7.enum(["italic", "normal", "oblique"]),
-  weight: z7.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
+  style: z8.enum(["italic", "normal", "oblique"]),
+  weight: z8.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
 }).strict();
-var tileflowFontBundleManifestSchema = z7.object({
-  files: z7.array(z7.discriminatedUnion("kind", [fontFileSchema, licenseFileSchema])).min(2).max(tileflowFontBundleLimits.maxFileCount),
-  fontFaces: z7.array(fontFaceSchema2).min(1).max(tileflowFontBundleLimits.maxFaceCount),
-  format: z7.literal("tileflow-font-bundle-v1")
+var tileflowFontBundleManifestSchema = z8.object({
+  files: z8.array(z8.discriminatedUnion("kind", [fontFileSchema, licenseFileSchema])).min(2).max(tileflowFontBundleLimits.maxFileCount),
+  fontFaces: z8.array(fontFaceSchema2).min(1).max(tileflowFontBundleLimits.maxFaceCount),
+  format: z8.literal("tileflow-font-bundle-v1")
 }).strict().superRefine((manifest, context) => {
   const sortedFiles = [...manifest.files].sort(
     (left, right) => compareCodeUnits11(left.name, right.name)
@@ -17112,7 +17183,318 @@ function getTileflowLocationBaseUrl() {
   if (typeof window !== "undefined" && window.location.href) return window.location.href;
   return `${getTileflowLocationOrigin().replace(/\/+$/u, "")}/`;
 }
+
+// src/icon-lock.ts
+import { z as z9 } from "zod";
+
+// src/icon-json.ts
+function parseTileflowIconJson(text, maximumBytes) {
+  if (new TextEncoder().encode(text).byteLength > maximumBytes) {
+    throw new TileflowIconSetError("ICON_LOCK_INVALID", "Icon JSON exceeds its byte limit");
+  }
+  let position = 0;
+  const fail = () => {
+    throw new TileflowIconSetError(
+      "ICON_LOCK_INVALID",
+      `Invalid or duplicate-key icon JSON at offset ${position}`
+    );
+  };
+  const whitespace = () => {
+    while (position < text.length && /[\t\n\r ]/u.test(text[position])) position += 1;
+  };
+  const string = () => {
+    if (text[position] !== '"') return fail();
+    const start = position++;
+    while (position < text.length) {
+      const character = text[position++];
+      if (character === "\\") {
+        position += 1;
+      } else if (character === '"') {
+        try {
+          return JSON.parse(text.slice(start, position));
+        } catch {
+          return fail();
+        }
+      }
+    }
+    return fail();
+  };
+  const value = (depth) => {
+    if (depth > 32) return fail();
+    whitespace();
+    const character = text[position];
+    if (character === '"') return string();
+    if (character === "{") {
+      position += 1;
+      const result2 = {};
+      const keys = /* @__PURE__ */ new Set();
+      whitespace();
+      if (text[position] === "}") {
+        position += 1;
+        return result2;
+      }
+      while (true) {
+        whitespace();
+        const key = string();
+        if (keys.has(key)) return fail();
+        keys.add(key);
+        whitespace();
+        if (text[position++] !== ":") return fail();
+        Object.defineProperty(result2, key, {
+          value: value(depth + 1),
+          enumerable: true,
+          writable: true,
+          configurable: true
+        });
+        whitespace();
+        const delimiter = text[position++];
+        if (delimiter === "}") return result2;
+        if (delimiter !== ",") return fail();
+      }
+    }
+    if (character === "[") {
+      position += 1;
+      const result2 = [];
+      whitespace();
+      if (text[position] === "]") {
+        position += 1;
+        return result2;
+      }
+      while (true) {
+        result2.push(value(depth + 1));
+        whitespace();
+        const delimiter = text[position++];
+        if (delimiter === "]") return result2;
+        if (delimiter !== ",") return fail();
+      }
+    }
+    for (const [literal2, parsed] of [
+      ["true", true],
+      ["false", false],
+      ["null", null]
+    ]) {
+      if (text.startsWith(literal2, position)) {
+        position += literal2.length;
+        return parsed;
+      }
+    }
+    const number = text.slice(position).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u)?.[0];
+    if (!number || !Number.isFinite(Number(number))) return fail();
+    position += number.length;
+    return Number(number);
+  };
+  const result = value(0);
+  whitespace();
+  if (position !== text.length) return fail();
+  return result;
+}
+
+// src/icon-lock.ts
+var tileflowIconsLockfileName = "tileflow.icons.lock.json";
+var tileflowIconsLockfileMaximumBytes = 4 * 1024 * 1024;
+var tileflowIconSetPinSchema = z9.object({
+  teamId: tileflowIconSetTeamIdSchema,
+  setId: tileflowIconSetIdSchema,
+  versionId: tileflowIconSetVersionIdSchema,
+  version: z9.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  packageId: tileflowIconSetPackageIdSchema,
+  contentHash: tileflowIconPackageContentHashSchema,
+  manifest: tileflowIconPackageManifestSchema,
+  spriteUrl: z9.string().max(2048)
+}).strict().superRefine((pin, context) => {
+  try {
+    const url = new URL(pin.spriteUrl);
+    if (url.protocol !== "https:" || url.username || url.password || url.search || url.hash || url.href !== pin.spriteUrl || !url.pathname.endsWith(`/sprites/${pin.packageId}/sprite`)) {
+      throw new Error("Invalid delivery URL");
+    }
+  } catch {
+    context.addIssue({
+      code: "custom",
+      path: ["spriteUrl"],
+      message: "Expected a canonical HTTPS sprite URL for the exact package, without credentials, query or fragment"
+    });
+  }
+});
+var tileflowIconsLockfileSchema = z9.object({
+  lockfileVersion: z9.literal(1),
+  sets: z9.record(tileflowIconSetReferenceSchema, tileflowIconSetPinSchema)
+}).strict().superRefine((lock, context) => {
+  const entries = Object.entries(lock.sets);
+  if (entries.length > tileflowIconSourceLimit) {
+    context.addIssue({ code: "custom", path: ["sets"], message: "Too many locked icon sets" });
+  }
+  const teams = new Set(entries.map(([, pin]) => pin.teamId));
+  const slugs = new Set(entries.map(([reference]) => reference.split("/")[0]));
+  const ids = new Set(entries.map(([, pin]) => pin.setId));
+  if (teams.size > 1 || slugs.size > 1 || ids.size !== entries.length) {
+    context.addIssue({
+      code: "custom",
+      path: ["sets"],
+      message: "Locked sets must have distinct identities within one Team"
+    });
+  }
+});
+async function parseTileflowIconsLockfile(input, sources) {
+  try {
+    const lock = tileflowIconsLockfileSchema.parse(
+      typeof input === "string" ? parseTileflowIconJson(input, tileflowIconsLockfileMaximumBytes) : input
+    );
+    const serialized = serializeCanonicalJson(lock);
+    if (new TextEncoder().encode(serialized).byteLength > tileflowIconsLockfileMaximumBytes)
+      throw new Error("Lock exceeds its byte limit");
+    for (const pin of Object.values(lock.sets)) {
+      if (await hashTileflowIconPackageManifest(pin.manifest) !== pin.contentHash)
+        throw new Error("Locked manifest does not match its content hash");
+    }
+    if (sources) {
+      const required = collectTileflowIconSetReferences(sources).sort(compareCodeUnits11);
+      const actual = Object.keys(lock.sets).sort(compareCodeUnits11);
+      if (required.length !== actual.length || required.some((reference, index) => reference !== actual[index])) {
+        throw new Error(
+          "Lock must exactly match declared icon sets; explicitly install, update or pin it"
+        );
+      }
+    }
+    return lock;
+  } catch (cause) {
+    if (cause instanceof TileflowIconSetError) throw cause;
+    throw new TileflowIconSetError(
+      "ICON_LOCK_INVALID",
+      "Invalid icon lock: exact references, revisions, manifests and delivery URLs are required",
+      { cause }
+    );
+  }
+}
+async function serializeTileflowIconsLockfile(input) {
+  return `${serializeCanonicalJson(await parseTileflowIconsLockfile(input))}
+`;
+}
+
+// src/icon-composition.ts
+import { z as z10 } from "zod";
+var tileflowIconCompositionMaximumBytes = 1024 * 1024;
+var idsSchema = z10.array(tileflowIconIdSchema).max(tileflowIconPackageLimits.maxIconCount).refine(
+  (ids) => new Set(ids).size === ids.length && ids.every((id, index) => index === 0 || compareCodeUnits11(ids[index - 1], id) < 0),
+  "Icon exports must be unique and sorted by code unit"
+);
+var localContributorSchema = z10.object({ kind: z10.literal("local"), iconIds: idsSchema }).strict();
+var packageContributorSchema = z10.object({
+  kind: z10.literal("package"),
+  package: z10.string().max(214).regex(/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u),
+  iconIds: idsSchema
+}).strict();
+var setContributorSchema = z10.object({
+  kind: z10.literal("icon-set"),
+  reference: tileflowIconSetReferenceSchema,
+  teamId: tileflowIconSetTeamIdSchema,
+  setId: tileflowIconSetIdSchema,
+  versionId: tileflowIconSetVersionIdSchema,
+  version: z10.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  packageId: tileflowIconSetPackageIdSchema,
+  contentHash: tileflowIconPackageContentHashSchema,
+  iconIds: idsSchema.min(1)
+}).strict();
+var tileflowRenderedIconIdentitySchema = z10.object({
+  kind: z10.literal("rendered-icon"),
+  id: tileflowIconIdSchema,
+  width: z10.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
+  height: z10.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
+  pixelSha256: z10.object({
+    oneX: tileflowIconPackageContentHashSchema,
+    twoX: tileflowIconPackageContentHashSchema
+  }).strict()
+}).strict();
+var tileflowIconCompositionSchema = z10.object({
+  format: z10.literal("tileflow-icon-composition-v1"),
+  compositionVersion: z10.literal(1),
+  packageHash: tileflowIconPackageContentHashSchema,
+  contributors: z10.array(
+    z10.discriminatedUnion("kind", [
+      localContributorSchema,
+      packageContributorSchema,
+      setContributorSchema
+    ])
+  ).min(1).max(tileflowIconSourceLimit),
+  winners: z10.array(
+    tileflowRenderedIconIdentitySchema.omit({ kind: true }).extend({
+      contributor: z10.number().int().min(0).max(tileflowIconSourceLimit - 1)
+    })
+  ).min(1).max(tileflowIconPackageLimits.maxIconCount)
+}).strict().superRefine((receipt, context) => {
+  const expected = /* @__PURE__ */ new Map();
+  const references = /* @__PURE__ */ new Set();
+  const sets = /* @__PURE__ */ new Set();
+  const versions = /* @__PURE__ */ new Set();
+  const teams = /* @__PURE__ */ new Set();
+  const teamSlugs = /* @__PURE__ */ new Set();
+  for (const [ordinal, contributor] of receipt.contributors.entries()) {
+    if (contributor.kind === "icon-set") {
+      if (references.has(contributor.reference) || sets.has(contributor.setId) || versions.has(contributor.versionId)) {
+        context.addIssue({
+          code: "custom",
+          path: ["contributors", ordinal],
+          message: "Duplicate icon set dependency"
+        });
+      }
+      references.add(contributor.reference);
+      sets.add(contributor.setId);
+      versions.add(contributor.versionId);
+      teams.add(contributor.teamId);
+      teamSlugs.add(contributor.reference.split("/")[0]);
+    }
+    for (const id of contributor.iconIds) expected.set(id, ordinal);
+  }
+  if (teams.size !== 1 || teamSlugs.size !== 1)
+    context.addIssue({
+      code: "custom",
+      path: ["contributors"],
+      message: "A shared composition must contain exact dependencies from one Team"
+    });
+  const names = [...expected.keys()].sort(compareCodeUnits11);
+  if (names.length !== receipt.winners.length || receipt.winners.some(
+    (winner, index) => names[index] !== winner.id || expected.get(winner.id) !== winner.contributor
+  )) {
+    context.addIssue({
+      code: "custom",
+      path: ["winners"],
+      message: "Winners must exactly cover the sorted last-wins export closure"
+    });
+  }
+  if (new TextEncoder().encode(serializeCanonicalJson(receipt)).byteLength > tileflowIconCompositionMaximumBytes) {
+    context.addIssue({ code: "custom", message: "Composition receipt exceeds its byte limit" });
+  }
+});
+function parseTileflowIconComposition(input) {
+  const parsed = tileflowIconCompositionSchema.safeParse(input);
+  if (!parsed.success)
+    throw new TileflowIconSetError(
+      "ICON_COMPOSITION_INVALID",
+      "Invalid ordered icon composition receipt",
+      { cause: parsed.error }
+    );
+  return parsed.data;
+}
+async function hashTileflowIconComposition(input) {
+  return sha256Hex(
+    `tileflow-icon-composition-v1\0${serializeCanonicalJson(parseTileflowIconComposition(input))}`
+  );
+}
+
+// src/icon-sprite-index.ts
+import { z as z11 } from "zod";
+var tileflowIconSpriteIndexEntrySchema = z11.object({
+  height: z11.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
+  width: z11.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
+  pixelRatio: z11.union([z11.literal(1), z11.literal(2)]),
+  x: z11.number().int().nonnegative().max(tileflowIconPackageLimits.maxAtlasDimension),
+  y: z11.number().int().nonnegative().max(tileflowIconPackageLimits.maxAtlasDimension)
+}).strict();
+var tileflowIconSpriteIndexSchema = z11.record(tileflowIconIdSchema, tileflowIconSpriteIndexEntrySchema).refine(
+  (index) => Object.keys(index).length > 0 && Object.keys(index).length <= tileflowIconPackageLimits.maxIconCount,
+  "A generated sprite index must contain 1 through 256 icons"
+);
 export {
+  TileflowIconSetError,
   TileflowMapResolutionError,
   TileflowResolvedMapValidationError,
   TileflowThemeAuditError,
@@ -17128,6 +17510,7 @@ export {
   buildings,
   classifyTileflowVisualProperty,
   clearTileflowManifestCache,
+  collectTileflowIconSetReferences,
   color,
   compareCodeUnits11 as compareCodeUnits,
   createStyle,
@@ -17147,15 +17530,18 @@ export {
   getTileflowAnalyticsApiUrl,
   getTileflowStyleFontFaces,
   hashTileflowFontBundleManifest,
+  hashTileflowIconComposition,
   hashTileflowIconPackageManifest,
   hashTileflowRenderedIconPixels,
   hostedTileset,
+  iconSet,
   inferTileflowAnalyticsFromStyleUrl,
   inferTileflowDataRequirements,
   inferTileflowSourceRequirements,
   isCanonicalOpenMapTilesSchema,
   isSafeLocalPmtilesPath,
   isTileflowCompilationPhase,
+  isTileflowIconSetSource,
   isTileflowLocalDirectory,
   isTileflowPortableId,
   isTileflowThemeName,
@@ -17175,6 +17561,9 @@ export {
   openMapTiles,
   openMapTilesContractVersion,
   parseResolvedTileflowMap,
+  parseTileflowIconComposition,
+  parseTileflowIconJson,
+  parseTileflowIconsLockfile,
   parseTileflowMap,
   parseTileflowRuntimeManifest,
   poi,
@@ -17201,6 +17590,7 @@ export {
   serializeCanonicalJson,
   serializeTileflowFontBundleManifest,
   serializeTileflowIconPackageManifest,
+  serializeTileflowIconsLockfile,
   sha256Hex,
   shouldLoadTileflowManifest,
   startTileflowSession,
@@ -17229,6 +17619,8 @@ export {
   tileflowFontBundleManifestSchema,
   tileflowHostedAlphaCompatibility,
   tileflowHostedSourceLimit,
+  tileflowIconCompositionMaximumBytes,
+  tileflowIconCompositionSchema,
   tileflowIconIdPattern,
   tileflowIconIdSchema,
   tileflowIconPackageContentHashSchema,
@@ -17236,6 +17628,19 @@ export {
   tileflowIconPackageLabelSchema,
   tileflowIconPackageLimits,
   tileflowIconPackageManifestSchema,
+  tileflowIconSetIdSchema,
+  tileflowIconSetPackageIdSchema,
+  tileflowIconSetPinSchema,
+  tileflowIconSetReferenceSchema,
+  tileflowIconSetSourceSchema,
+  tileflowIconSetTeamIdSchema,
+  tileflowIconSetVersionIdSchema,
+  tileflowIconSourceLimit,
+  tileflowIconSpriteIndexEntrySchema,
+  tileflowIconSpriteIndexSchema,
+  tileflowIconsLockfileMaximumBytes,
+  tileflowIconsLockfileName,
+  tileflowIconsLockfileSchema,
   tileflowLandformClasses,
   tileflowLocalDirectoryMaximumLength,
   tileflowLocalDirectoryMessage,
@@ -17255,6 +17660,7 @@ export {
   tileflowRenderStackLimits,
   tileflowRenderStackPhases,
   tileflowRenderStackRenderers,
+  tileflowRenderedIconIdentitySchema,
   tileflowRenderedIconManifestEntrySchema,
   tileflowRoadClasses,
   tileflowRuntimeManifestLimits,