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

package/dist/build.js

@@ -6771,10 +6771,10 @@ function roadWidth(roadClass, scale) {
       [16, 3.4]
     ]
   };
-  return zoom.linear(stops[roadClass].map(([z7, value]) => [z7, value * scale]));
+  return zoom.linear(stops[roadClass].map(([z9, value]) => [z9, value * scale]));
 }
 function widen(value, addition) {
-  return zoom.linear(value.stops.map(([z7, width]) => [z7, width + addition]));
+  return zoom.linear(value.stops.map(([z9, width]) => [z9, width + addition]));
 }
 function structureFilter(field2, structure) {
   if (structure === "surface") {
@@ -7984,7 +7984,7 @@ function insertTileflowOverlays(input) {
   for (const placement of tileflowOverlayPlacements) {
     const overlayLayers = groups.get(placement);
     if (!overlayLayers?.length) continue;
-    const index = insertionIndex(layers, placement);
+    const index = tileflowOverlayInsertionIndex(layers, placement);
     layers = [...layers.slice(0, index), ...overlayLayers, ...layers.slice(index)];
   }
   return { identities, layers };
@@ -8011,7 +8011,7 @@ function cloneJson18(value) {
     Object.entries(value).map(([key, child]) => [key, cloneJson18(child)])
   );
 }
-function insertionIndex(layers, placement) {
+function tileflowOverlayInsertionIndex(layers, placement) {
   const threshold = {
     "above-water": tileflowLayerSlots.indexOf("building-areas"),
     "below-roads": tileflowLayerSlots.indexOf("transport-areas"),
@@ -8420,8 +8420,60 @@ 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 z3 } from "zod";
+var tileflowIconSourceLimit = 32;
+var slug = "[a-z0-9]+(?:-[a-z0-9]+)*";
+var tileflowIconSetReferenceSchema = z3.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 = z3.object({
+  kind: z3.literal("icon-set"),
+  reference: tileflowIconSetReferenceSchema
+}).strict();
+var tileflowIconSetIdSchema = z3.string().regex(/^ics_[A-Za-z0-9_-]{16}$/u);
+var tileflowIconSetVersionIdSchema = z3.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u);
+var tileflowIconSetPackageIdSchema = z3.string().regex(/^icp_[A-Za-z0-9_-]{16,64}$/u);
+var tileflowIconSetTeamIdSchema = z3.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 z4 } from "zod";
 
 // src/cartography/data-expression.ts
 var tileflowDataExpressionLimits = Object.freeze({
@@ -10384,11 +10436,11 @@ var TileflowResolvedMapValidationError = class extends Error {
     this.messages = messages;
   }
 };
-var identifierSchema = z3.string().trim().regex(/^[A-Za-z0-9_-]+$/, "Expected letters, numbers, underscores, or hyphens").refine((value) => value !== "__proto__", "Expected a safe identifier");
-var revisionSchema = z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Expected a portable data revision");
-var zoomNumberSchema = z3.number().finite().min(0).max(24);
+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);
 function zoomValueSchemaFor(valueSchema) {
-  const stops = z3.array(z3.tuple([zoomNumberSchema, valueSchema])).min(1).superRefine((entries, context) => {
+  const stops = z4.array(z4.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({
@@ -10399,105 +10451,105 @@ function zoomValueSchemaFor(valueSchema) {
       }
     }
   });
-  return z3.discriminatedUnion("interpolation", [
-    z3.object({
-      base: z3.number().finite().positive(),
-      interpolation: z3.literal("exponential"),
-      kind: z3.literal("zoom"),
+  return z4.discriminatedUnion("interpolation", [
+    z4.object({
+      base: z4.number().finite().positive(),
+      interpolation: z4.literal("exponential"),
+      kind: z4.literal("zoom"),
       stops
     }).strict(),
-    z3.object({
-      interpolation: z3.literal("linear"),
-      kind: z3.literal("zoom"),
+    z4.object({
+      interpolation: z4.literal("linear"),
+      kind: z4.literal("zoom"),
       stops
     }).strict(),
-    z3.object({
-      interpolation: z3.literal("step"),
-      kind: z3.literal("zoom"),
+    z4.object({
+      interpolation: z4.literal("step"),
+      kind: z4.literal("zoom"),
       stops
     }).strict()
   ]);
 }
-var themeTokenNameSchema = z3.string().regex(
+var themeTokenNameSchema = z4.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 = z3.object({
-  category: z3.enum(tileflowThemeTokenCategories),
-  kind: z3.literal("theme-token"),
+var themeTokenReferenceSchema = z4.object({
+  category: z4.enum(tileflowThemeTokenCategories),
+  kind: z4.literal("theme-token"),
   token: themeTokenNameSchema
 }).strict();
 var themeNumberReferenceSchema = themeTokenReferenceSchema.extend({
-  category: z3.literal("number")
+  category: z4.literal("number")
 });
-var fixedNumberSchema = z3.object({
-  kind: z3.literal("theme-fixed"),
-  reason: z3.string().trim().min(1),
-  value: z3.number().finite()
+var fixedNumberSchema = z4.object({
+  kind: z4.literal("theme-fixed"),
+  reason: z4.string().trim().min(1),
+  value: z4.number().finite()
 }).strict();
-var fixedNumberArraySchema = z3.object({
-  kind: z3.literal("theme-fixed"),
-  reason: z3.string().trim().min(1),
-  value: z3.array(z3.number().finite())
+var fixedNumberArraySchema = z4.object({
+  kind: z4.literal("theme-fixed"),
+  reason: z4.string().trim().min(1),
+  value: z4.array(z4.number().finite())
 }).strict();
-var fixedNumberOffsetSchema = z3.object({
-  kind: z3.literal("theme-fixed"),
-  reason: z3.string().trim().min(1),
-  value: z3.tuple([z3.number().finite(), z3.number().finite()])
+var fixedNumberOffsetSchema = z4.object({
+  kind: z4.literal("theme-fixed"),
+  reason: z4.string().trim().min(1),
+  value: z4.tuple([z4.number().finite(), z4.number().finite()])
 }).strict();
-var fixedNumberInsetsSchema = z3.object({
-  kind: z3.literal("theme-fixed"),
-  reason: z3.string().trim().min(1),
-  value: z3.tuple([
-    z3.number().finite(),
-    z3.number().finite(),
-    z3.number().finite(),
-    z3.number().finite()
+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()
   ])
 }).strict();
-var fixedStringSchema = z3.object({ kind: z3.literal("theme-fixed"), reason: z3.string().trim().min(1), value: z3.string() }).strict();
-var themeColorOperationSchema = z3.lazy(
-  () => z3.discriminatedUnion("operation", [
-    z3.object({
+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({
       color: themeColorValueSchema,
-      kind: z3.literal("theme-color"),
+      kind: z4.literal("theme-color"),
       opacity: themeNumberValueSchema,
-      operation: z3.literal("alpha")
+      operation: z4.literal("alpha")
     }).strict(),
-    z3.object({
+    z4.object({
       amount: themeNumberValueSchema,
       from: themeColorValueSchema,
-      kind: z3.literal("theme-color"),
-      operation: z3.literal("mix"),
-      space: z3.literal("oklch"),
+      kind: z4.literal("theme-color"),
+      operation: z4.literal("mix"),
+      space: z4.literal("oklch"),
       to: themeColorValueSchema
     }).strict()
   ])
 );
-var themeNumberValueSchema = z3.lazy(
-  () => z3.union([z3.number().finite(), fixedNumberSchema, themeNumberReferenceSchema])
+var themeNumberValueSchema = z4.lazy(
+  () => z4.union([z4.number().finite(), fixedNumberSchema, themeNumberReferenceSchema])
 );
-var themeColorValueSchema = z3.lazy(
-  () => z3.union([
-    z3.string().min(1),
+var themeColorValueSchema = z4.lazy(
+  () => z4.union([
+    z4.string().min(1),
     fixedStringSchema,
-    themeTokenReferenceSchema.extend({ category: z3.literal("color") }),
+    themeTokenReferenceSchema.extend({ category: z4.literal("color") }),
     themeColorOperationSchema
   ])
 );
-var themeFontValueSchema = z3.union([
-  z3.string().min(1),
+var themeFontValueSchema = z4.union([
+  z4.string().min(1),
   fixedStringSchema,
-  themeTokenReferenceSchema.extend({ category: z3.literal("font") })
+  themeTokenReferenceSchema.extend({ category: z4.literal("font") })
 ]);
-var themeImageValueSchema = z3.union([
-  z3.string().min(1),
+var themeImageValueSchema = z4.union([
+  z4.string().min(1),
   fixedStringSchema,
-  themeTokenReferenceSchema.extend({ category: z3.literal("image") })
+  themeTokenReferenceSchema.extend({ category: z4.literal("image") })
 ]);
 function expressionSchemaFor(expectedCategory) {
   const category = expectedCategory ?? "structural";
-  return z3.object({ kind: z3.literal("expression"), value: z3.array(z3.unknown()).min(1) }).strict().superRefine((expression2, context) => {
+  return z4.object({ kind: z4.literal("expression"), value: z4.array(z4.unknown()).min(1) }).strict().superRefine((expression2, context) => {
     for (const issue of validateTileflowDataExpression(expression2.value)) {
       context.addIssue({
         code: "custom",
@@ -10551,7 +10603,7 @@ function validateExpressionThemeValues(value, expectedCategory, context, path) {
     return;
   }
   if (candidate.kind === "theme-fixed") {
-    const parsed = expectedCategory === "number" ? z3.union([fixedNumberSchema, fixedNumberArraySchema]).safeParse(candidate) : expectedCategory === "color" || expectedCategory === "image" ? fixedStringSchema.safeParse(candidate) : void 0;
+    const parsed = expectedCategory === "number" ? z4.union([fixedNumberSchema, fixedNumberArraySchema]).safeParse(candidate) : expectedCategory === "color" || expectedCategory === "image" ? fixedStringSchema.safeParse(candidate) : void 0;
     if (!parsed?.success) {
       context.addIssue({
         code: "custom",
@@ -10582,71 +10634,71 @@ var structuralExpressionSchema = expressionSchemaFor(void 0);
 var numberZoomValueSchema = zoomValueSchemaFor(themeNumberValueSchema);
 var colorZoomValueSchema = zoomValueSchemaFor(themeColorValueSchema);
 var imageZoomValueSchema = zoomValueSchemaFor(themeImageValueSchema);
-var stringZoomValueSchema = zoomValueSchemaFor(z3.string());
-var numberValueSchema = z3.union([
+var stringZoomValueSchema = zoomValueSchemaFor(z4.string());
+var numberValueSchema = z4.union([
   themeNumberValueSchema,
   numberExpressionSchema,
   numberZoomValueSchema
 ]);
-var structuralNumberValueSchema = z3.union([
-  z3.number().finite(),
+var structuralNumberValueSchema = z4.union([
+  z4.number().finite(),
   structuralExpressionSchema,
-  zoomValueSchemaFor(z3.number().finite())
+  zoomValueSchemaFor(z4.number().finite())
 ]);
-var colorValueSchema = z3.union([
+var colorValueSchema = z4.union([
   themeColorValueSchema,
   colorExpressionSchema,
   colorZoomValueSchema
 ]);
-var imageValueSchema = z3.union([
+var imageValueSchema = z4.union([
   themeImageValueSchema,
   imageExpressionSchema,
   imageZoomValueSchema
 ]);
-var stringValueSchema = z3.union([z3.string(), structuralExpressionSchema, stringZoomValueSchema]);
-var themeNumberArraySchema = z3.array(themeNumberValueSchema);
-var themeNumberArrayValueSchema = z3.union([themeNumberArraySchema, fixedNumberArraySchema]);
-var numberArrayValueSchema = z3.union([
+var stringValueSchema = z4.union([z4.string(), structuralExpressionSchema, stringZoomValueSchema]);
+var themeNumberArraySchema = z4.array(themeNumberValueSchema);
+var themeNumberArrayValueSchema = z4.union([themeNumberArraySchema, fixedNumberArraySchema]);
+var numberArrayValueSchema = z4.union([
   themeNumberArrayValueSchema,
   numberExpressionSchema,
   zoomValueSchemaFor(themeNumberArrayValueSchema)
 ]);
-var themeNumberOffsetSchema = z3.tuple([themeNumberValueSchema, themeNumberValueSchema]);
-var themeNumberOffsetValueSchema = z3.union([themeNumberOffsetSchema, fixedNumberOffsetSchema]);
-var numberOffsetValueSchema = z3.union([
+var themeNumberOffsetSchema = z4.tuple([themeNumberValueSchema, themeNumberValueSchema]);
+var themeNumberOffsetValueSchema = z4.union([themeNumberOffsetSchema, fixedNumberOffsetSchema]);
+var numberOffsetValueSchema = z4.union([
   themeNumberOffsetValueSchema,
   numberExpressionSchema,
   zoomValueSchemaFor(themeNumberOffsetValueSchema)
 ]);
-var themeNumberInsetsSchema = z3.tuple([
+var themeNumberInsetsSchema = z4.tuple([
   themeNumberValueSchema,
   themeNumberValueSchema,
   themeNumberValueSchema,
   themeNumberValueSchema
 ]);
-var themeNumberInsetsValueSchema = z3.union([themeNumberInsetsSchema, fixedNumberInsetsSchema]);
-var numberInsetsValueSchema = z3.union([
+var themeNumberInsetsValueSchema = z4.union([themeNumberInsetsSchema, fixedNumberInsetsSchema]);
+var numberInsetsValueSchema = z4.union([
   themeNumberInsetsValueSchema,
   numberExpressionSchema,
   zoomValueSchemaFor(themeNumberInsetsValueSchema)
 ]);
-var lineCapSchema = z3.enum(["butt", "round", "square"]);
-var lineCapValueSchema = z3.union([
+var lineCapSchema = z4.enum(["butt", "round", "square"]);
+var lineCapValueSchema = z4.union([
   lineCapSchema,
   structuralExpressionSchema,
   zoomValueSchemaFor(lineCapSchema)
 ]);
-var lineJoinSchema = z3.enum(["bevel", "miter", "round"]);
-var lineJoinValueSchema = z3.union([
+var lineJoinSchema = z4.enum(["bevel", "miter", "round"]);
+var lineJoinValueSchema = z4.union([
   lineJoinSchema,
   structuralExpressionSchema,
   zoomValueSchemaFor(lineJoinSchema)
 ]);
-var exactFontFaceSchema = z3.string().min(1).max(100).refine(
+var exactFontFaceSchema = z4.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 = z3.array(exactFontFaceSchema).max(8).superRefine((fallbacks, context) => {
+var fontFallbacksSchema = z4.array(exactFontFaceSchema).max(8).superRefine((fallbacks, context) => {
   const seen = /* @__PURE__ */ new Set();
   for (const [index, fallback] of fallbacks.entries()) {
     if (seen.has(fallback)) {
@@ -10659,16 +10711,16 @@ var fontFallbacksSchema = z3.array(exactFontFaceSchema).max(8).superRefine((fall
     seen.add(fallback);
   }
 });
-var moduleFontValueSchema = z3.union([
+var moduleFontValueSchema = z4.union([
   exactFontFaceSchema,
   fixedStringSchema,
-  themeTokenReferenceSchema.extend({ category: z3.literal("font") })
+  themeTokenReferenceSchema.extend({ category: z4.literal("font") })
 ]);
-var moduleFontFallbacksSchema = z3.array(moduleFontValueSchema).max(8);
-var hexColorSchema = z3.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
+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})$/, {
   message: "Expected a hex color like #F6F7F3 or #F6F7F3FF"
 });
-var rgbColorSchema = z3.string().refine((value) => {
+var rgbColorSchema = z4.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
   );
@@ -10677,21 +10729,21 @@ var rgbColorSchema = z3.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 = z3.union([hexColorSchema, rgbColorSchema]);
-var terrainColorValueSchema = z3.union([
+var terrainColorLiteralSchema = z4.union([hexColorSchema, rgbColorSchema]);
+var terrainColorValueSchema = z4.union([
   terrainColorLiteralSchema,
   fixedStringSchema.extend({ value: terrainColorLiteralSchema }),
-  themeTokenReferenceSchema.extend({ category: z3.literal("color") }),
+  themeTokenReferenceSchema.extend({ category: z4.literal("color") }),
   themeColorOperationSchema
 ]);
 function terrainNumberValueSchema(schema) {
-  return z3.union([schema, fixedNumberSchema.extend({ value: schema }), themeNumberReferenceSchema]);
+  return z4.union([schema, fixedNumberSchema.extend({ value: schema }), themeNumberReferenceSchema]);
 }
-var themeTypographyStyleSchema = z3.object({
-  fallbacks: z3.array(themeFontValueSchema).max(8).optional(),
+var themeTypographyStyleSchema = z4.object({
+  fallbacks: z4.array(themeFontValueSchema).max(8).optional(),
   font: themeFontValueSchema.optional(),
   letterSpacing: themeNumberValueSchema.optional(),
-  transform: z3.enum(["lowercase", "none", "uppercase"]).optional()
+  transform: z4.enum(["lowercase", "none", "uppercase"]).optional()
 }).strict();
 var themeTypographySchema = themeTypographyStyleSchema.extend({
   places: themeTypographyStyleSchema.optional(),
@@ -10699,46 +10751,46 @@ var themeTypographySchema = themeTypographyStyleSchema.extend({
   roads: themeTypographyStyleSchema.optional(),
   water: themeTypographyStyleSchema.optional()
 });
-var themeLightingSchema = z3.object({
-  anchor: z3.enum(["map", "viewport"]).optional(),
+var themeLightingSchema = z4.object({
+  anchor: z4.enum(["map", "viewport"]).optional(),
   color: themeColorValueSchema.optional(),
   intensity: themeNumberValueSchema.optional(),
-  position: z3.tuple([themeNumberValueSchema, themeNumberValueSchema, themeNumberValueSchema]).optional()
+  position: z4.tuple([themeNumberValueSchema, themeNumberValueSchema, themeNumberValueSchema]).optional()
 }).strict();
-var tileflowThemeSchema = z3.object({
-  colorScheme: z3.enum(["light", "dark"]),
+var tileflowThemeSchema = z4.object({
+  colorScheme: z4.enum(["light", "dark"]),
   id: tileflowThemeNameSchema,
   lighting: themeLightingSchema,
-  tokens: z3.object({
-    color: z3.record(themeTokenNameSchema, themeColorValueSchema),
-    font: z3.record(themeTokenNameSchema, themeFontValueSchema),
-    image: z3.record(themeTokenNameSchema, themeImageValueSchema),
-    number: z3.record(themeTokenNameSchema, themeNumberValueSchema)
+  tokens: z4.object({
+    color: z4.record(themeTokenNameSchema, themeColorValueSchema),
+    font: z4.record(themeTokenNameSchema, themeFontValueSchema),
+    image: z4.record(themeTokenNameSchema, themeImageValueSchema),
+    number: z4.record(themeTokenNameSchema, themeNumberValueSchema)
   }).strict(),
   typography: themeTypographySchema,
-  version: z3.number().int().positive()
+  version: z4.number().int().positive()
 }).strict();
 var rangeShape = {
   maxZoom: zoomNumberSchema.optional(),
   minZoom: zoomNumberSchema.optional(),
-  visible: z3.boolean().optional()
+  visible: z4.boolean().optional()
 };
-var backgroundStyleSchema = z3.object({
+var backgroundStyleSchema = z4.object({
   ...rangeShape,
   color: colorValueSchema.optional(),
   opacity: numberValueSchema.optional(),
   pattern: imageValueSchema.optional()
 }).strict();
-var fillStyleSchema = z3.object({
+var fillStyleSchema = z4.object({
   ...rangeShape,
-  antialias: z3.boolean().optional(),
+  antialias: z4.boolean().optional(),
   color: colorValueSchema.optional(),
   opacity: numberValueSchema.optional(),
   pattern: imageValueSchema.optional(),
   translate: numberOffsetValueSchema.optional(),
-  translateAnchor: z3.enum(["map", "viewport"]).optional()
+  translateAnchor: z4.enum(["map", "viewport"]).optional()
 }).strict();
-var lineStyleSchema = z3.object({
+var lineStyleSchema = z4.object({
   ...rangeShape,
   blur: numberValueSchema.optional(),
   cap: lineCapValueSchema.optional(),
@@ -10752,13 +10804,13 @@ var lineStyleSchema = z3.object({
   pattern: imageValueSchema.optional(),
   roundLimit: numberValueSchema.optional(),
   translate: numberOffsetValueSchema.optional(),
-  translateAnchor: z3.enum(["map", "viewport"]).optional(),
+  translateAnchor: z4.enum(["map", "viewport"]).optional(),
   width: numberValueSchema.optional()
 }).strict();
-var textStyleSchema = z3.object({
+var textStyleSchema = z4.object({
   ...rangeShape,
-  allowOverlap: z3.boolean().optional(),
-  anchor: z3.enum([
+  allowOverlap: z4.boolean().optional(),
+  anchor: z4.enum([
     "bottom",
     "bottom-left",
     "bottom-right",
@@ -10776,25 +10828,25 @@ var textStyleSchema = z3.object({
   haloBlur: numberValueSchema.optional(),
   haloColor: colorValueSchema.optional(),
   haloWidth: numberValueSchema.optional(),
-  ignorePlacement: z3.boolean().optional(),
-  justify: z3.enum(["auto", "center", "left", "right"]).optional(),
-  keepUpright: z3.boolean().optional(),
+  ignorePlacement: z4.boolean().optional(),
+  justify: z4.enum(["auto", "center", "left", "right"]).optional(),
+  keepUpright: z4.boolean().optional(),
   letterSpacing: numberValueSchema.optional(),
   lineHeight: numberValueSchema.optional(),
   maxAngle: numberValueSchema.optional(),
   maxWidth: numberValueSchema.optional(),
   offset: numberOffsetValueSchema.optional(),
-  optional: z3.boolean().optional(),
+  optional: z4.boolean().optional(),
   opacity: numberValueSchema.optional(),
   padding: numberValueSchema.optional(),
-  pitchAlignment: z3.enum(["auto", "map", "viewport"]).optional(),
+  pitchAlignment: z4.enum(["auto", "map", "viewport"]).optional(),
   radialOffset: numberValueSchema.optional(),
   rotate: numberValueSchema.optional(),
-  rotationAlignment: z3.enum(["auto", "map", "viewport"]).optional(),
+  rotationAlignment: z4.enum(["auto", "map", "viewport"]).optional(),
   size: numberValueSchema.optional(),
-  transform: z3.enum(["lowercase", "none", "uppercase"]).optional(),
-  variableAnchors: z3.array(
-    z3.enum([
+  transform: z4.enum(["lowercase", "none", "uppercase"]).optional(),
+  variableAnchors: z4.array(
+    z4.enum([
       "bottom",
       "bottom-left",
       "bottom-right",
@@ -10807,10 +10859,10 @@ var textStyleSchema = z3.object({
     ])
   ).min(1).optional()
 }).strict();
-var iconStyleSchema = z3.object({
+var iconStyleSchema = z4.object({
   ...rangeShape,
-  allowOverlap: z3.boolean().optional(),
-  anchor: z3.enum([
+  allowOverlap: z4.boolean().optional(),
+  anchor: z4.enum([
     "bottom",
     "bottom-left",
     "bottom-right",
@@ -10825,60 +10877,60 @@ var iconStyleSchema = z3.object({
   haloBlur: numberValueSchema.optional(),
   haloColor: colorValueSchema.optional(),
   haloWidth: numberValueSchema.optional(),
-  ignorePlacement: z3.boolean().optional(),
+  ignorePlacement: z4.boolean().optional(),
   image: imageValueSchema.optional(),
   offset: numberOffsetValueSchema.optional(),
   opacity: numberValueSchema.optional(),
-  keepUpright: z3.boolean().optional(),
-  optional: z3.boolean().optional(),
+  keepUpright: z4.boolean().optional(),
+  optional: z4.boolean().optional(),
   padding: numberValueSchema.optional(),
-  pitchAlignment: z3.enum(["auto", "map", "viewport"]).optional(),
+  pitchAlignment: z4.enum(["auto", "map", "viewport"]).optional(),
   rotate: numberValueSchema.optional(),
-  rotationAlignment: z3.enum(["auto", "map", "viewport"]).optional(),
+  rotationAlignment: z4.enum(["auto", "map", "viewport"]).optional(),
   size: numberValueSchema.optional(),
-  textFit: z3.enum(["both", "height", "none", "width"]).optional(),
+  textFit: z4.enum(["both", "height", "none", "width"]).optional(),
   textFitPadding: numberInsetsValueSchema.optional()
 }).strict();
 var symbolPlacementShape = {
   ...rangeShape,
-  placement: z3.enum(["line", "line-center", "point"]).optional(),
+  placement: z4.enum(["line", "line-center", "point"]).optional(),
   priority: structuralNumberValueSchema.optional(),
-  priorityOrder: z3.enum(["higher-first", "lower-first"]).optional(),
+  priorityOrder: z4.enum(["higher-first", "lower-first"]).optional(),
   spacing: numberValueSchema.optional(),
-  zOrder: z3.enum(["auto", "source", "viewport-y"]).optional()
+  zOrder: z4.enum(["auto", "source", "viewport-y"]).optional()
 };
-var circleStyleSchema = z3.object({
+var circleStyleSchema = z4.object({
   ...rangeShape,
   blur: numberValueSchema.optional(),
   color: colorValueSchema.optional(),
   opacity: numberValueSchema.optional(),
-  pitchAlignment: z3.enum(["map", "viewport"]).optional(),
-  pitchScale: z3.enum(["map", "viewport"]).optional(),
+  pitchAlignment: z4.enum(["map", "viewport"]).optional(),
+  pitchScale: z4.enum(["map", "viewport"]).optional(),
   priority: structuralNumberValueSchema.optional(),
-  priorityOrder: z3.enum(["higher-first", "lower-first"]).optional(),
+  priorityOrder: z4.enum(["higher-first", "lower-first"]).optional(),
   radius: numberValueSchema.optional(),
   strokeColor: colorValueSchema.optional(),
   strokeOpacity: numberValueSchema.optional(),
   strokeWidth: numberValueSchema.optional(),
   translate: numberOffsetValueSchema.optional(),
-  translateAnchor: z3.enum(["map", "viewport"]).optional()
+  translateAnchor: z4.enum(["map", "viewport"]).optional()
 }).strict();
-var extrusionStyleSchema = z3.object({
+var extrusionStyleSchema = z4.object({
   ...rangeShape,
   base: numberValueSchema.optional(),
   color: colorValueSchema.optional(),
   height: numberValueSchema.optional(),
   opacity: numberValueSchema.optional(),
   pattern: imageValueSchema.optional(),
-  verticalGradient: z3.boolean().optional()
+  verticalGradient: z4.boolean().optional()
 }).strict();
-var areaStyleSchema = z3.object({ fill: fillStyleSchema.optional(), outline: lineStyleSchema.optional() }).strict();
-var lineStackStyleSchema = z3.object({
+var areaStyleSchema = z4.object({ fill: fillStyleSchema.optional(), outline: lineStyleSchema.optional() }).strict();
+var lineStackStyleSchema = z4.object({
   casing: lineStyleSchema.optional(),
   fill: lineStyleSchema.optional(),
   shadow: lineStyleSchema.optional()
 }).strict();
-var lineHatchStyleSchema = z3.object({
+var lineHatchStyleSchema = z4.object({
   ...rangeShape,
   angle: numberValueSchema.optional(),
   color: colorValueSchema.optional(),
@@ -10927,62 +10979,62 @@ var lineHatchStyleSchema = z3.object({
   }
 });
 var roadLayerStyleSchema = lineStackStyleSchema.extend({ hatch: lineHatchStyleSchema.optional() }).strict();
-var symbolStyleSchema = z3.object({
+var symbolStyleSchema = z4.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: z3.union([z3.literal(1), z3.literal(2), z3.literal(3), z3.literal(4), z3.literal(5)]).optional()
+  density: z4.union([z4.literal(1), z4.literal(2), z4.literal(3), z4.literal(4), z4.literal(5)]).optional()
 }).strict();
-var renderScalarSchema = z3.union([z3.boolean(), z3.number().finite(), z3.string()]);
-var renderTargetSchema = z3.string().regex(tileflowSemanticTargetPattern, "Expected a semantic target");
-var renderStackOperationNameSchema = z3.string().regex(
+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(
   tileflowRenderStackOperationNamePattern,
   "Expected a lowercase-initial portable render-stack operation name without dots"
 );
 var renderFieldNormalizationShape = {
-  coerce: z3.literal("number").optional(),
+  coerce: z4.literal("number").optional(),
   fallback: renderScalarSchema.optional(),
-  field: z3.enum(tileflowSemanticFieldNames)
+  field: z4.enum(tileflowSemanticFieldNames)
 };
-var renderSelectorNodeSchema = z3.lazy(
-  () => z3.discriminatedUnion("kind", [
-    z3.object({ kind: z3.literal("literal"), value: z3.boolean() }).strict(),
-    z3.object({ kind: z3.literal("geometry"), geometry: z3.enum(tileflowRenderSelectorGeometries) }).strict(),
-    z3.object({ kind: z3.literal("has"), field: z3.enum(tileflowSemanticFieldNames) }).strict(),
-    z3.object({
+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({
       ...renderFieldNormalizationShape,
-      kind: z3.literal("compare"),
-      operator: z3.enum(tileflowRenderSelectorComparisons),
+      kind: z4.literal("compare"),
+      operator: z4.enum(tileflowRenderSelectorComparisons),
       value: renderScalarSchema
     }).strict(),
-    z3.object({
+    z4.object({
       ...renderFieldNormalizationShape,
-      kind: z3.literal("in"),
-      values: z3.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
+      kind: z4.literal("in"),
+      values: z4.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
     }).strict(),
-    z3.object({
+    z4.object({
       ...renderFieldNormalizationShape,
-      branches: z3.array(
-        z3.object({
-          result: z3.boolean(),
-          values: z3.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
+      branches: z4.array(
+        z4.object({
+          result: z4.boolean(),
+          values: z4.array(renderScalarSchema).min(1).max(tileflowRenderStackLimits.maxScalarValues)
         }).strict()
       ).min(1).max(tileflowRenderStackLimits.maxMatchBranches),
-      kind: z3.literal("match"),
-      otherwise: z3.boolean()
+      kind: z4.literal("match"),
+      otherwise: z4.boolean()
     }).strict(),
-    z3.object({ kind: z3.literal("not"), selector: renderSelectorNodeSchema }).strict(),
-    z3.object({
-      kind: z3.enum(["all", "any"]),
-      selectors: z3.array(renderSelectorNodeSchema).min(1).max(tileflowRenderStackLimits.maxSelectorChildren)
+    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)
     }).strict(),
-    z3.object({
+    z4.object({
       fallback: renderSelectorNodeSchema,
-      kind: z3.literal("step"),
-      stops: z3.array(z3.object({ selector: renderSelectorNodeSchema, zoom: zoomNumberSchema }).strict()).min(1).max(tileflowRenderStackLimits.maxStepStops)
+      kind: z4.literal("step"),
+      stops: z4.array(z4.object({ selector: renderSelectorNodeSchema, zoom: zoomNumberSchema }).strict()).min(1).max(tileflowRenderStackLimits.maxStepStops)
     }).strict()
   ])
 );
@@ -10993,7 +11045,7 @@ var renderSelectorSchema = renderSelectorNodeSchema.superRefine(
     }
   }
 );
-var renderVisibilitySchema = z3.object({ visibilityGroup: z3.literal("building").optional() });
+var renderVisibilitySchema = z4.object({ visibilityGroup: z4.literal("building").optional() });
 var renderStyleSchemas = {
   background: backgroundStyleSchema.extend(renderVisibilitySchema.shape).strict(),
   circle: circleStyleSchema.extend(renderVisibilitySchema.shape).strict(),
@@ -11002,7 +11054,7 @@ var renderStyleSchemas = {
   line: lineStyleSchema.extend(renderVisibilitySchema.shape).strict(),
   symbol: symbolStyleSchema.extend(renderVisibilitySchema.shape).strict()
 };
-var renderRequirementsSchema = z3.array(z3.enum(tileflowLayerDomains)).min(1).max(tileflowRenderStackLimits.maxRequirements).superRefine((requirements, context) => {
+var renderRequirementsSchema = z4.array(z4.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)) {
@@ -11016,40 +11068,40 @@ var renderRequirementsSchema = z3.array(z3.enum(tileflowLayerDomains)).min(1).ma
   }
 });
 var vectorRenderPassSchemas = tileflowRenderStackRenderers.filter((renderer) => renderer !== "background").map(
-  (renderer) => z3.object({
+  (renderer) => z4.object({
     attachTo: renderTargetSchema,
-    feature: z3.enum(tileflowSemanticLayerNames).optional(),
-    kind: z3.literal("render-pass"),
-    phase: z3.enum(tileflowRenderStackPhases),
-    renderer: z3.literal(renderer),
+    feature: z4.enum(tileflowSemanticLayerNames).optional(),
+    kind: z4.literal("render-pass"),
+    phase: z4.enum(tileflowRenderStackPhases),
+    renderer: z4.literal(renderer),
     requirements: renderRequirementsSchema.optional(),
     selector: renderSelectorSchema.optional(),
     style: renderStyleSchemas[renderer]
   }).strict()
 );
-var renderPassSchema = z3.discriminatedUnion("renderer", [
-  z3.object({
+var renderPassSchema = z4.discriminatedUnion("renderer", [
+  z4.object({
     attachTo: renderTargetSchema,
-    kind: z3.literal("render-pass"),
-    phase: z3.enum(tileflowRenderStackPhases),
-    renderer: z3.literal("background"),
+    kind: z4.literal("render-pass"),
+    phase: z4.enum(tileflowRenderStackPhases),
+    renderer: z4.literal("background"),
     requirements: renderRequirementsSchema.optional(),
     style: renderStyleSchemas.background
   }).strict(),
   ...vectorRenderPassSchemas
 ]);
 var renderRefinementSchemas = tileflowRenderStackRenderers.map(
-  (renderer) => z3.object({
-    kind: z3.literal("refine-render-target"),
+  (renderer) => z4.object({
+    kind: z4.literal("refine-render-target"),
     requirements: renderRequirementsSchema.optional(),
-    renderer: z3.literal(renderer),
+    renderer: z4.literal(renderer),
     ...renderer === "background" ? {} : { selector: renderSelectorSchema.optional() },
     style: renderStyleSchemas[renderer],
     target: renderTargetSchema
   }).strict()
 );
-var renderStackOperationSchema = z3.union([renderPassSchema, ...renderRefinementSchemas]);
-var renderStackSchema = z3.record(renderStackOperationNameSchema, renderStackOperationSchema).superRefine((stack, context) => {
+var renderStackOperationSchema = z4.union([renderPassSchema, ...renderRefinementSchemas]);
+var renderStackSchema = z4.record(renderStackOperationNameSchema, renderStackOperationSchema).superRefine((stack, context) => {
   const size = Object.keys(stack).length;
   if (size === 0) {
     context.addIssue({
@@ -11064,19 +11116,19 @@ var renderStackSchema = z3.record(renderStackOperationNameSchema, renderStackOpe
     });
   }
 }).describe("tileflow-render-stack");
-var roadClassSchema = z3.enum(tileflowRoadClasses);
-var roadClassStyleSchema = z3.object({
-  enabled: z3.boolean().optional(),
+var roadClassSchema = z4.enum(tileflowRoadClasses);
+var roadClassStyleSchema = z4.object({
+  enabled: z4.boolean().optional(),
   bridge: roadLayerStyleSchema.optional(),
   surface: roadLayerStyleSchema.optional(),
   tunnel: roadLayerStyleSchema.optional()
 }).strict();
-var roadStructureMapSchema = z3.object({
+var roadStructureMapSchema = z4.object({
   bridge: roadLayerStyleSchema.optional(),
   surface: roadLayerStyleSchema.optional(),
   tunnel: roadLayerStyleSchema.optional()
 }).strict();
-var roadTreatmentLayerStyleSchema = z3.object({
+var roadTreatmentLayerStyleSchema = z4.object({
   casing: lineStyleSchema.pick({
     blur: true,
     color: true,
@@ -11105,19 +11157,19 @@ var roadTreatmentLayerStyleSchema = z3.object({
     width: true
   }).optional()
 }).strict();
-var roadTreatmentStyleSchema = z3.object({
+var roadTreatmentStyleSchema = z4.object({
   bridge: roadTreatmentLayerStyleSchema.optional(),
-  enabled: z3.boolean().optional(),
+  enabled: z4.boolean().optional(),
   surface: roadTreatmentLayerStyleSchema.optional(),
   tunnel: roadTreatmentLayerStyleSchema.optional(),
   widthScale: themeNumberValueSchema.optional()
 }).strict();
-var landModuleSchema = z3.object({
-  type: z3.literal("land"),
+var landModuleSchema = z4.object({
+  type: z4.literal("land"),
   background: backgroundStyleSchema.optional(),
-  enabled: z3.boolean().optional(),
+  enabled: z4.boolean().optional(),
   globalLandcover: fillStyleSchema.optional(),
-  landcover: z3.object({
+  landcover: z4.object({
     farmland: areaStyleSchema.optional(),
     flowerbed: areaStyleSchema.optional(),
     grass: areaStyleSchema.optional(),
@@ -11133,7 +11185,7 @@ var landModuleSchema = z3.object({
     wetland: areaStyleSchema.optional(),
     wood: areaStyleSchema.optional()
   }).strict().optional(),
-  landuse: z3.object({
+  landuse: z4.object({
     cemetery: areaStyleSchema.optional(),
     civic: areaStyleSchema.optional(),
     commercial: areaStyleSchema.optional(),
@@ -11149,99 +11201,99 @@ var landModuleSchema = z3.object({
   }).strict().optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var waterModuleSchema = z3.object({
-  type: z3.literal("water"),
+var waterModuleSchema = z4.object({
+  type: z4.literal("water"),
   bathymetry: fillStyleSchema.optional(),
   bathymetryContours: lineStyleSchema.optional(),
   bathymetryLabels: symbolStyleSchema.optional(),
   bodies: areaStyleSchema.optional(),
-  enabled: z3.boolean().optional(),
-  intermittent: z3.object({ bodies: areaStyleSchema.optional(), waterways: lineStyleSchema.optional() }).strict().optional(),
+  enabled: z4.boolean().optional(),
+  intermittent: z4.object({ bodies: areaStyleSchema.optional(), waterways: lineStyleSchema.optional() }).strict().optional(),
   renderStack: renderStackSchema.optional(),
-  waterways: z3.object({
+  waterways: z4.object({
     canal: lineStyleSchema.optional(),
     other: lineStyleSchema.optional(),
     river: lineStyleSchema.optional(),
     stream: lineStyleSchema.optional()
   }).strict().optional()
 }).strict();
-var buildingsModuleSchema = z3.object({
-  type: z3.literal("buildings"),
+var buildingsModuleSchema = z4.object({
+  type: z4.literal("buildings"),
   businessCorridor: areaStyleSchema.optional(),
-  enabled: z3.boolean().optional(),
+  enabled: z4.boolean().optional(),
   extrusion: extrusionStyleSchema.optional(),
   flat: areaStyleSchema.optional(),
-  mode: z3.enum(["3d", "flat"]).optional(),
+  mode: z4.enum(["3d", "flat"]).optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var addressesModuleSchema = z3.object({
-  type: z3.literal("addresses"),
-  enabled: z3.boolean().optional(),
+var addressesModuleSchema = z4.object({
+  type: z4.literal("addresses"),
+  enabled: z4.boolean().optional(),
   labels: symbolStyleSchema.optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var landformClassSchema = z3.enum(tileflowLandformClasses);
-var landformsModuleSchema = z3.object({
-  type: z3.literal("landforms"),
-  classes: z3.partialRecord(landformClassSchema, symbolStyleSchema).optional(),
-  elevation: z3.boolean().optional(),
-  enabled: z3.boolean().optional(),
+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(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var boundariesModuleSchema = z3.object({
-  type: z3.literal("boundaries"),
+var boundariesModuleSchema = z4.object({
+  type: z4.literal("boundaries"),
   admin2: lineStyleSchema.optional(),
   admin4: lineStyleSchema.optional(),
   disputed: lineStyleSchema.optional(),
-  enabled: z3.boolean().optional(),
+  enabled: z4.boolean().optional(),
   maritime: lineStyleSchema.optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var aerowaysModuleSchema = z3.object({
-  type: z3.literal("aeroways"),
+var aerowaysModuleSchema = z4.object({
+  type: z4.literal("aeroways"),
   area: areaStyleSchema.optional(),
-  enabled: z3.boolean().optional(),
+  enabled: z4.boolean().optional(),
   runway: lineStackStyleSchema.optional(),
   runwayRef: symbolStyleSchema.optional(),
   renderStack: renderStackSchema.optional(),
   taxiway: lineStackStyleSchema.optional()
 }).strict();
-var transitModuleSchema = z3.object({
-  type: z3.literal("transit"),
+var transitModuleSchema = z4.object({
+  type: z4.literal("transit"),
   cableway: lineStyleSchema.optional(),
-  enabled: z3.boolean().optional(),
+  enabled: z4.boolean().optional(),
   ferry: lineStyleSchema.optional(),
-  rail: z3.object({
+  rail: z4.object({
     bridge: lineStyleSchema.optional(),
     surface: lineStyleSchema.optional(),
     tunnel: lineStyleSchema.optional()
   }).strict().optional(),
-  railHatching: z3.object({
+  railHatching: z4.object({
     bridge: lineStyleSchema.optional(),
     surface: lineStyleSchema.optional(),
     tunnel: lineStyleSchema.optional()
   }).strict().optional(),
-  serviceRail: z3.object({
+  serviceRail: z4.object({
     bridge: lineStyleSchema.optional(),
     surface: lineStyleSchema.optional(),
     tunnel: lineStyleSchema.optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional()
 }).strict();
-var roadsModuleSchema = z3.object({
-  type: z3.literal("roads"),
-  areas: z3.object({
+var roadsModuleSchema = z4.object({
+  type: z4.literal("roads"),
+  areas: z4.object({
     pedestrian: areaStyleSchema.optional(),
     pier: areaStyleSchema.optional(),
     road: areaStyleSchema.optional()
   }).strict().optional(),
-  classes: z3.partialRecord(roadClassSchema, roadClassStyleSchema).optional(),
+  classes: z4.partialRecord(roadClassSchema, roadClassStyleSchema).optional(),
   crossings: iconStyleSchema.extend({ image: imageValueSchema }).strict().optional(),
-  detail: z3.enum(["none", "highways", "major", "streets", "all"]).optional(),
-  enabled: z3.boolean().optional(),
-  extras: z3.object({ paths: z3.boolean().optional() }).strict().optional(),
-  hierarchy: z3.enum(["subtle", "clear", "strong"]).optional(),
-  modifiers: z3.object({
+  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({
     construction: roadTreatmentStyleSchema.optional(),
     expressway: roadTreatmentStyleSchema.optional(),
     indoor: roadTreatmentStyleSchema.optional(),
@@ -11249,7 +11301,7 @@ var roadsModuleSchema = z3.object({
     ramp: roadTreatmentStyleSchema.optional(),
     unpaved: roadTreatmentStyleSchema.optional()
   }).strict().optional(),
-  mountainBike: z3.object({
+  mountainBike: z4.object({
     "0": roadTreatmentStyleSchema.optional(),
     "0+": roadTreatmentStyleSchema.optional(),
     "1": roadTreatmentStyleSchema.optional(),
@@ -11262,9 +11314,9 @@ var roadsModuleSchema = z3.object({
     "5": roadTreatmentStyleSchema.optional(),
     "6": roadTreatmentStyleSchema.optional()
   }).strict().optional(),
-  oneWayMarkers: z3.boolean().optional(),
-  outline: z3.enum(["none", "subtle", "strong"]).optional(),
-  restrictions: z3.object({
+  oneWayMarkers: z4.boolean().optional(),
+  outline: z4.enum(["none", "subtle", "strong"]).optional(),
+  restrictions: z4.object({
     access: roadTreatmentStyleSchema.optional(),
     bicycle: roadTreatmentStyleSchema.optional(),
     foot: roadTreatmentStyleSchema.optional(),
@@ -11272,24 +11324,24 @@ var roadsModuleSchema = z3.object({
     toll: roadTreatmentStyleSchema.optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional(),
-  roundabouts: z3.object({ casing: circleStyleSchema.optional(), fill: circleStyleSchema.optional() }).strict().optional(),
-  serviceTypes: z3.object({
+  roundabouts: z4.object({ casing: circleStyleSchema.optional(), fill: circleStyleSchema.optional() }).strict().optional(),
+  serviceTypes: z4.object({
     alley: roadTreatmentStyleSchema.optional(),
     crossover: roadTreatmentStyleSchema.optional(),
     driveway: roadTreatmentStyleSchema.optional(),
     parkingAisle: roadTreatmentStyleSchema.optional(),
     yard: roadTreatmentStyleSchema.optional()
   }).strict().optional(),
-  sidewalks: z3.object({
+  sidewalks: z4.object({
     outline: lineStyleSchema.optional(),
     pattern: fillStyleSchema.optional(),
     surface: fillStyleSchema.optional()
   }).strict().optional(),
   structures: roadStructureMapSchema.optional(),
-  weight: z3.enum(["thin", "regular", "bold"]).optional(),
-  widthScale: z3.partialRecord(roadClassSchema, themeNumberValueSchema).optional()
+  weight: z4.enum(["thin", "regular", "bold"]).optional(),
+  widthScale: z4.partialRecord(roadClassSchema, themeNumberValueSchema).optional()
 }).strict();
-var placeLabelStylesSchema = z3.object({
+var placeLabelStylesSchema = z4.object({
   city: symbolStyleSchema.optional(),
   continent: symbolStyleSchema.optional(),
   country: symbolStyleSchema.optional(),
@@ -11299,65 +11351,65 @@ var placeLabelStylesSchema = z3.object({
   town: symbolStyleSchema.optional(),
   village: symbolStyleSchema.optional()
 }).strict();
-var waterLabelStylesSchema = z3.object({
+var waterLabelStylesSchema = z4.object({
   line: symbolStyleSchema.optional(),
   ocean: symbolStyleSchema.optional(),
   other: symbolStyleSchema.optional(),
   waterway: symbolStyleSchema.optional()
 }).strict();
-var labelsModuleSchema = z3.object({
-  type: z3.literal("labels"),
-  aerodromeCodes: z3.enum(["none", "iata", "all"]).optional(),
-  collisionPriority: z3.enum(["balanced", "navigation"]).optional(),
-  enabled: z3.boolean().optional(),
-  junctions: z3.boolean().optional(),
-  language: z3.string().trim().min(1).optional(),
-  places: z3.enum(["none", "major", "all"]).optional(),
-  roadClasses: z3.array(roadClassSchema).min(1).optional(),
+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(),
   renderStack: renderStackSchema.optional(),
-  roads: z3.enum(["none", "highways", "major", "streets", "all"]).optional(),
-  styles: z3.object({
+  roads: z4.enum(["none", "highways", "major", "streets", "all"]).optional(),
+  styles: z4.object({
     aerodrome: symbolStyleSchema.optional(),
     junctions: symbolStyleSchema.optional(),
     places: placeLabelStylesSchema.optional(),
-    roads: z3.partialRecord(roadClassSchema, symbolStyleSchema).optional(),
-    shields: z3.object({
+    roads: z4.partialRecord(roadClassSchema, symbolStyleSchema).optional(),
+    shields: z4.object({
       default: symbolStyleSchema.optional(),
       detail: symbolStyleSchema.optional(),
-      kinds: z3.record(identifierSchema, z3.object({ image: themeImageValueSchema }).strict()).optional(),
+      kinds: z4.record(identifierSchema, z4.object({ image: themeImageValueSchema }).strict()).optional(),
       overview: symbolStyleSchema.optional(),
-      textColors: z3.record(identifierSchema, z3.object({ color: themeColorValueSchema }).strict()).optional()
+      textColors: z4.record(identifierSchema, z4.object({ color: themeColorValueSchema }).strict()).optional()
     }).strict().optional(),
     water: waterLabelStylesSchema.optional()
   }).strict().optional(),
-  shields: z3.enum(["none", "major", "all"]).optional(),
-  water: z3.enum(["none", "major", "all"]).optional()
+  shields: z4.enum(["none", "major", "all"]).optional(),
+  water: z4.enum(["none", "major", "all"]).optional()
 }).strict();
-var poiModuleSchema = z3.object({
-  type: z3.literal("poi"),
-  categories: z3.array(z3.enum(tileflowPoiCategories)).optional(),
-  color: z3.enum(["uniform", "category"]).optional(),
-  density: z3.union([z3.literal(1), z3.literal(2), z3.literal(3), z3.literal(4), z3.literal(5)]).optional(),
-  enabled: z3.boolean().optional(),
-  icons: z3.boolean().optional(),
-  labels: z3.boolean().optional(),
+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(),
   minZoom: zoomNumberSchema.optional(),
-  placement: z3.object({
-    coupleIconAndLabel: z3.boolean().optional(),
-    iconPadding: z3.number().finite().min(0).optional(),
-    textPadding: z3.number().finite().min(0).optional()
+  placement: z4.object({
+    coupleIconAndLabel: z4.boolean().optional(),
+    iconPadding: z4.number().finite().min(0).optional(),
+    textPadding: z4.number().finite().min(0).optional()
   }).strict().optional(),
   renderStack: renderStackSchema.optional(),
-  styles: z3.partialRecord(z3.enum(tileflowPoiCategories), poiCategoryStyleSchema).optional()
+  styles: z4.partialRecord(z4.enum(tileflowPoiCategories), poiCategoryStyleSchema).optional()
 }).strict();
-var nauticalModuleSchema = z3.object({
-  type: z3.literal("nautical"),
+var nauticalModuleSchema = z4.object({
+  type: z4.literal("nautical"),
   aids: markerSymbolStyleSchema.optional(),
   coverage: areaStyleSchema.optional(),
-  enabled: z3.boolean().optional(),
+  enabled: z4.boolean().optional(),
   hazardAreas: areaStyleSchema.optional(),
   hazards: markerSymbolStyleSchema.optional(),
-  labels: z3.object({
+  labels: z4.object({
     coverage: symbolStyleSchema.optional(),
     hazards: symbolStyleSchema.optional(),
     navigationAreas: symbolStyleSchema.optional(),
@@ -11373,7 +11425,7 @@ var nauticalModuleSchema = z3.object({
   wreckAreas: areaStyleSchema.optional(),
   wrecks: markerSymbolStyleSchema.optional()
 }).strict();
-var modulesSchema = z3.object({
+var modulesSchema = z4.object({
   addresses: addressesModuleSchema.optional(),
   aeroways: aerowaysModuleSchema.optional(),
   boundaries: boundariesModuleSchema.optional(),
@@ -11385,152 +11437,152 @@ var modulesSchema = z3.object({
   poi: poiModuleSchema.optional(),
   roads: roadsModuleSchema.optional(),
   transit: transitModuleSchema.optional(),
-  vegetation: z3.object({
-    type: z3.literal("vegetation"),
-    enabled: z3.boolean().optional(),
+  vegetation: z4.object({
+    type: z4.literal("vegetation"),
+    enabled: z4.boolean().optional(),
     flat: circleStyleSchema.optional(),
     minZoom: zoomNumberSchema.optional(),
-    mode: z3.enum(["3d", "flat"]).optional(),
+    mode: z4.enum(["3d", "flat"]).optional(),
     renderStack: renderStackSchema.optional(),
-    threeDimensional: z3.object({
+    threeDimensional: z4.object({
       barkColor: themeColorValueSchema.optional(),
-      broadleafColors: z3.array(themeColorValueSchema).min(1).max(8).optional(),
-      coniferColors: z3.array(themeColorValueSchema).min(1).max(8).optional(),
-      crownScale: z3.union([
-        z3.number().finite().positive().max(10),
+      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),
         themeNumberReferenceSchema,
-        z3.object({
-          kind: z3.literal("theme-fixed"),
-          reason: z3.string().trim().min(1),
-          value: z3.number().finite().positive().max(10)
+        z4.object({
+          kind: z4.literal("theme-fixed"),
+          reason: z4.string().trim().min(1),
+          value: z4.number().finite().positive().max(10)
         }).strict()
       ]).optional(),
-      heightScale: z3.union([
-        z3.number().finite().positive().max(10),
+      heightScale: z4.union([
+        z4.number().finite().positive().max(10),
         themeNumberReferenceSchema,
-        z3.object({
-          kind: z3.literal("theme-fixed"),
-          reason: z3.string().trim().min(1),
-          value: z3.number().finite().positive().max(10)
+        z4.object({
+          kind: z4.literal("theme-fixed"),
+          reason: z4.string().trim().min(1),
+          value: z4.number().finite().positive().max(10)
         }).strict()
       ]).optional()
     }).strict().optional()
   }).strict().optional(),
   water: waterModuleSchema.optional()
 }).strict();
-var layerBindingsSchema = z3.object({
-  aerodromeLabel: z3.string().trim().min(1),
-  aeroway: z3.string().trim().min(1),
-  boundary: z3.string().trim().min(1),
-  building: z3.string().trim().min(1),
-  bathymetry: z3.string().trim().min(1).optional(),
-  businessCorridor: z3.string().trim().min(1).optional(),
-  circularFeature: z3.string().trim().min(1).optional(),
-  globalLandcover: z3.string().trim().min(1).optional(),
-  houseNumber: z3.string().trim().min(1),
-  landcover: z3.string().trim().min(1),
-  landuse: z3.string().trim().min(1),
-  mountainPeak: z3.string().trim().min(1),
-  park: z3.string().trim().min(1),
-  place: z3.string().trim().min(1),
-  poi: z3.string().trim().min(1),
-  road: z3.string().trim().min(1),
-  roadName: z3.string().trim().min(1),
-  roadShield: z3.string().trim().min(1).optional(),
-  sidewalk: z3.string().trim().min(1).optional(),
-  streetFurniture: z3.string().trim().min(1).optional(),
-  tree: z3.string().trim().min(1).optional(),
-  water: z3.string().trim().min(1),
-  waterName: z3.string().trim().min(1),
-  waterway: z3.string().trim().min(1)
+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)
 }).strict();
-var fieldBindingsSchema = z3.object({
-  access: z3.string().trim().min(1),
-  activityScore: z3.string().trim().min(1),
-  adminLevel: z3.string().trim().min(1),
-  bicycle: z3.string().trim().min(1),
-  bathymetryMinDepth: z3.string().trim().min(1).optional(),
-  bathymetrySortKey: z3.string().trim().min(1).optional(),
-  brunnel: z3.string().trim().min(1),
-  buildingKind: z3.string().trim().min(1),
-  buildingTone: z3.string().trim().min(1),
-  capital: z3.string().trim().min(1),
-  circularClearanceExtraAtZoom15: z3.string().trim().min(1).optional(),
-  circularKind: z3.string().trim().min(1).optional(),
-  circularRadiusAtZoom15: z3.string().trim().min(1).optional(),
-  circularRadiusMeters: z3.string().trim().min(1).optional(),
-  circularInnerRadiusMeters: z3.string().trim().min(1).optional(),
-  circularOuterRadiusMeters: z3.string().trim().min(1).optional(),
-  class: z3.string().trim().min(1),
-  crossing: z3.string().trim().min(1),
-  classificationConfidence: z3.string().trim().min(1),
-  confidence: z3.string().trim().min(1),
-  circumference: z3.string().trim().min(1),
-  diameterCrown: z3.string().trim().min(1),
-  disputed: z3.string().trim().min(1),
-  direction: z3.string().trim().min(1).optional(),
-  elevation: z3.string().trim().min(1),
-  elevationFeet: z3.string().trim().min(1),
-  expressway: z3.string().trim().min(1),
-  foot: z3.string().trim().min(1),
-  height: z3.string().trim().min(1),
-  hasBusiness: z3.string().trim().min(1),
-  hasParts: z3.string().trim().min(1).optional(),
-  hide3d: z3.string().trim().min(1),
-  horse: z3.string().trim().min(1),
-  houseNumber: z3.string().trim().min(1),
-  importanceTier: z3.string().trim().min(1).optional(),
-  iata: z3.string().trim().min(1),
-  icao: z3.string().trim().min(1),
-  indoor: z3.string().trim().min(1),
-  intermittent: z3.string().trim().min(1),
-  genus: z3.string().trim().min(1),
-  layer: z3.string().trim().min(1),
-  leafCycle: z3.string().trim().min(1),
-  leafType: z3.string().trim().min(1),
-  level: z3.string().trim().min(1),
-  maritime: z3.string().trim().min(1),
-  markings: z3.string().trim().min(1),
-  minHeight: z3.string().trim().min(1),
-  minZoom: z3.string().trim().min(1),
-  mtbScale: z3.string().trim().min(1),
-  name: z3.string().trim().min(1),
-  nameEnglish: z3.string().trim().min(1),
-  nameLatin: z3.string().trim().min(1),
-  network: z3.string().trim().min(1),
-  official: z3.string().trim().min(1),
-  oneway: z3.string().trim().min(1),
-  poiCategory: z3.string().trim().min(1),
-  poiFilterRank: z3.string().trim().min(1),
-  poiIcon: z3.string().trim().min(1),
-  poiSizeRank: z3.string().trim().min(1),
-  poiType: z3.string().trim().min(1),
-  ramp: z3.string().trim().min(1),
-  rank: z3.string().trim().min(1),
-  ref: z3.string().trim().min(1),
-  refLength: z3.string().trim().min(1),
-  renderHeight: z3.string().trim().min(1),
-  renderMinZoom: z3.string().trim().min(1),
-  renderMinHeight: z3.string().trim().min(1),
-  shieldKind: z3.string().trim().min(1).optional(),
-  shieldLineLengthMeters: z3.string().trim().min(1).optional(),
-  shieldNetwork: z3.string().trim().min(1).optional(),
-  shieldRank: z3.string().trim().min(1).optional(),
-  shieldText: z3.string().trim().min(1).optional(),
-  shieldTextColor: z3.string().trim().min(1).optional(),
-  service: z3.string().trim().min(1),
-  species: z3.string().trim().min(1),
-  speciesWikidata: z3.string().trim().min(1),
-  subclass: z3.string().trim().min(1),
-  surface: z3.string().trim().min(1),
-  toll: z3.string().trim().min(1)
+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)
 }).strict();
-var openMapTilesSchema = z3.object({
-  type: z3.literal("openmaptiles"),
-  contractVersion: z3.literal(openMapTilesContractVersion),
+var openMapTilesSchema = z4.object({
+  type: z4.literal("openmaptiles"),
+  contractVersion: z4.literal(openMapTilesContractVersion),
   fields: fieldBindingsSchema.partial().optional(),
   layers: layerBindingsSchema.partial().optional(),
-  semantics: z3.object({ parkLayer: z3.enum(["mixed", "protected-only"]).optional() }).strict().optional()
+  semantics: z4.object({ parkLayer: z4.enum(["mixed", "protected-only"]).optional() }).strict().optional()
 }).strict().transform(
   (schema) => openMapTiles({
     capabilities: schema.layers === void 0 ? void 0 : {
@@ -11545,12 +11597,12 @@ var openMapTilesSchema = z3.object({
   })
 );
 var vectorDataShape = {
-  type: z3.literal("vector-tiles"),
-  attribution: z3.string().trim().min(1),
+  type: z4.literal("vector-tiles"),
+  attribution: z4.string().trim().min(1),
   revision: revisionSchema.optional(),
   schema: openMapTilesSchema
 };
-var publicVectorUrlSchema = z3.string().min(1).max(4096).superRefine((value, context) => {
+var publicVectorUrlSchema = z4.string().min(1).max(4096).superRefine((value, context) => {
   try {
     validatePublicVectorUrl(value);
   } catch (error) {
@@ -11560,8 +11612,8 @@ var publicVectorUrlSchema = z3.string().min(1).max(4096).superRefine((value, con
     });
   }
 }).describe("tileflow-public-vector-url");
-var marineSourceSchema = z3.object({
-  attribution: z3.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
+var marineSourceSchema = z4.object({
+  attribution: z4.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
   sourceId: identifierSchema.optional(),
   url: publicVectorUrlSchema.optional()
 }).strict();
@@ -11569,24 +11621,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 = z3.object({
+var bathymetryReliefSchema = z4.object({
   accentColor: terrainColorValueSchema.optional(),
-  attribution: z3.string().min(1).max(2048).refine((value) => value === value.trim()).optional(),
-  encoding: z3.enum(["mapbox", "terrarium"]).optional(),
-  exaggeration: terrainNumberValueSchema(z3.number().finite().min(0).max(1)).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(),
   highlightColor: terrainColorValueSchema.optional(),
-  illuminationAltitude: terrainNumberValueSchema(z3.number().finite().min(0).max(90)).optional(),
-  illuminationAnchor: z3.enum(["map", "viewport"]).optional(),
-  illuminationDirection: terrainNumberValueSchema(z3.number().finite().min(0).max(359)).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(),
   maxZoom: zoomNumberSchema.optional(),
   minZoom: zoomNumberSchema.optional(),
-  multidirectional: z3.boolean().optional(),
-  opacity: terrainNumberValueSchema(z3.number().finite().min(0).max(1)).optional(),
+  multidirectional: z4.boolean().optional(),
+  opacity: terrainNumberValueSchema(z4.number().finite().min(0).max(1)).optional(),
   shadowColor: terrainColorValueSchema.optional(),
   sourceId: identifierSchema.optional(),
-  tileSize: z3.union([z3.literal(256), z3.literal(512)]).optional(),
+  tileSize: z4.union([z4.literal(256), z4.literal(512)]).optional(),
   url: bathymetryDemUrlSchema.optional(),
-  visible: z3.boolean().optional()
+  visible: z4.boolean().optional()
 }).strict().superRefine((relief, context) => {
   if (relief.minZoom !== void 0 && relief.maxZoom !== void 0 && relief.minZoom > relief.maxZoom) {
     context.addIssue({
@@ -11596,33 +11648,33 @@ var bathymetryReliefSchema = z3.object({
     });
   }
 });
-var bathymetryConfigSchema = z3.object({
+var bathymetryConfigSchema = z4.object({
   ...marineSourceSchema.shape,
-  bands: z3.union([z3.literal(false), fillStyleSchema]).optional(),
-  contours: z3.union([z3.literal(false), lineStyleSchema]).optional(),
-  display: z3.enum(["bands", "relief", "hybrid"]).optional(),
-  labels: z3.union([z3.literal(false), symbolStyleSchema]).optional(),
-  relief: z3.union([z3.literal(false), bathymetryReliefSchema]).optional(),
-  type: z3.literal("bathymetry")
+  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")
 }).strict();
-var marineSchema = z3.union([
-  z3.enum(["none", "bathymetry", "nautical", "chart"]),
-  z3.object({
-    bathymetry: z3.union([z3.literal(false), marineSourceSchema, bathymetryConfigSchema]).optional(),
-    nautical: z3.union([z3.literal(false), marineSourceSchema]).optional()
+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()
   }).strict()
 ]);
-var directVectorDataSchema = z3.object({
+var directVectorDataSchema = z4.object({
   ...vectorDataShape,
-  bounds: z3.tuple([
-    z3.number().finite().min(-180).max(180),
-    z3.number().finite().min(-90).max(90),
-    z3.number().finite().min(-180).max(180),
-    z3.number().finite().min(-90).max(90)
+  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)
   ]).optional(),
-  maxzoom: z3.number().int().min(0).max(30).optional(),
-  minzoom: z3.number().int().min(0).max(30).optional(),
-  tiles: z3.array(publicVectorUrlSchema).min(1).max(8)
+  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)
 }).strict().refine(
   (value) => value.minzoom === void 0 || value.maxzoom === void 0 || value.minzoom <= value.maxzoom,
   { message: "minzoom must not exceed maxzoom", path: ["minzoom"] }
@@ -11630,34 +11682,34 @@ var directVectorDataSchema = z3.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 = z3.union([
-  z3.object({
-    type: z3.literal("tileflow-world"),
-    generation: z3.literal(tileflowWorldGeneration),
-    selection: z3.discriminatedUnion("kind", [
-      z3.object({ kind: z3.literal("current"), product: z3.literal("world-v1") }).strict(),
-      z3.object({
-        kind: z3.literal("release"),
-        product: z3.literal("world-v1"),
-        release: z3.object({
-          descriptorSha256: z3.string().regex(/^[0-9a-f]{64}$/u),
+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),
           releaseId: tileflowWorldReleaseIdSchema
         }).strict()
       }).strict()
     ])
   }).strict(),
-  z3.object({ ...vectorDataShape, url: publicVectorUrlSchema }).strict(),
+  z4.object({ ...vectorDataShape, url: publicVectorUrlSchema }).strict(),
   directVectorDataSchema
 ]);
-var hostedTilesetSourceSchema = z3.object({
-  attribution: z3.string().trim().min(1).max(4096),
-  kind: z3.literal("hosted-tileset"),
-  local: z3.string().refine(isSafeLocalPmtilesPath, {
+var hostedTilesetSourceSchema = z4.object({
+  attribution: z4.string().trim().min(1).max(4096),
+  kind: z4.literal("hosted-tileset"),
+  local: z4.string().refine(isSafeLocalPmtilesPath, {
     message: "Expected a safe relative .pmtiles path beginning with ./ or ../"
   }),
-  tileset: z3.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: z3.union([z3.literal(256), z3.literal(512)]).optional(),
-  type: z3.enum(["raster", "vector"])
+  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"])
 }).strict().superRefine((source, context) => {
   if (source.type === "vector" && source.tileSize !== void 0) {
     context.addIssue({
@@ -11667,7 +11719,7 @@ var hostedTilesetSourceSchema = z3.object({
     });
   }
 });
-var hostedSourcesSchema = z3.record(tileflowMapIdSchema, hostedTilesetSourceSchema).superRefine((sources, context) => {
+var hostedSourcesSchema = z4.record(tileflowMapIdSchema, hostedTilesetSourceSchema).superRefine((sources, context) => {
   if (Object.keys(sources).length > tileflowHostedSourceLimit) {
     context.addIssue({
       code: "too_big",
@@ -11676,7 +11728,7 @@ var hostedSourcesSchema = z3.record(tileflowMapIdSchema, hostedTilesetSourceSche
     });
   }
 });
-var maplibreOverlayLayerSchema = z3.record(z3.string(), z3.unknown()).superRefine((layer, context) => {
+var maplibreOverlayLayerSchema = z4.record(z4.string(), z4.unknown()).superRefine((layer, context) => {
   if (!tileflowMapIdSchema.safeParse(layer.id).success) {
     context.addIssue({ code: "custom", message: "Expected a portable layer ID", path: ["id"] });
   }
@@ -11694,30 +11746,41 @@ var maplibreOverlayLayerSchema = z3.record(z3.string(), z3.unknown()).superRefin
     });
   }
 });
-var maplibreOverlaySchema = z3.object({
-  kind: z3.literal("maplibre-overlay"),
-  layers: z3.array(maplibreOverlayLayerSchema).min(1),
-  placement: z3.enum(tileflowOverlayPlacements),
+var maplibreOverlaySchema = z4.object({
+  kind: z4.literal("maplibre-overlay"),
+  layers: z4.array(maplibreOverlayLayerSchema).min(1),
+  placement: z4.enum(tileflowOverlayPlacements),
   source: tileflowMapIdSchema
 }).strict();
-var overlaysSchema = z3.record(tileflowMapIdSchema, maplibreOverlaySchema);
-var localAssetDirectorySchema = z3.string().min(3).max(tileflowLocalDirectoryMaximumLength).refine(isTileflowLocalDirectory, { message: tileflowLocalDirectoryMessage });
-var packageAssetDirectorySchema = z3.object({
-  kind: z3.literal("package-directory"),
-  package: z3.string().regex(
+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(
     /^(?:@[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: z3.string().min(1).max(512).refine(
+  path: z4.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 = z3.union([localAssetDirectorySchema, packageAssetDirectorySchema]);
-var iconDirectoriesSchema = z3.array(assetDirectorySchema).max(32);
-var fontDirectoriesSchema = z3.array(assetDirectorySchema).max(16);
-var fontStacksSchema = z3.array(
-  z3.string().min(1).max(200).refine(
+var assetDirectorySchema = z4.union([localAssetDirectorySchema, packageAssetDirectorySchema]);
+var iconDirectoriesSchema = z4.array(
+  z4.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 = z4.array(assetDirectorySchema).max(16);
+var fontStacksSchema = z4.array(
+  z4.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"
   )
@@ -11734,10 +11797,10 @@ var fontStacksSchema = z3.array(
     seen.add(fontStack);
   }
 });
-var glyphsSchema = z3.object({
+var glyphsSchema = z4.object({
   fontStacks: fontStacksSchema,
-  kind: z3.literal("url"),
-  url: z3.string().min(1).refine(
+  kind: z4.literal("url"),
+  url: z4.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")
@@ -11745,34 +11808,34 @@ var glyphsSchema = z3.object({
 var terrainLayerRangeShape = {
   maxZoom: zoomNumberSchema.optional(),
   minZoom: zoomNumberSchema.optional(),
-  visible: z3.boolean().optional()
+  visible: z4.boolean().optional()
 };
-var terrainHillshadeSchema = z3.object({
+var terrainHillshadeSchema = z4.object({
   ...terrainLayerRangeShape,
   accentColor: terrainColorValueSchema.optional(),
-  exaggeration: terrainNumberValueSchema(z3.number().finite().min(0).max(1)).optional(),
+  exaggeration: terrainNumberValueSchema(z4.number().finite().min(0).max(1)).optional(),
   highlightColor: terrainColorValueSchema.optional(),
-  illuminationAnchor: z3.enum(["map", "viewport"]).optional(),
-  illuminationDirection: terrainNumberValueSchema(z3.number().finite().min(0).max(359)).optional(),
+  illuminationAnchor: z4.enum(["map", "viewport"]).optional(),
+  illuminationDirection: terrainNumberValueSchema(z4.number().finite().min(0).max(359)).optional(),
   shadowColor: terrainColorValueSchema.optional()
 }).strict();
-var terrainContourLineSchema = z3.object({
+var terrainContourLineSchema = z4.object({
   ...terrainLayerRangeShape,
   color: terrainColorValueSchema.optional(),
-  opacity: terrainNumberValueSchema(z3.number().finite().min(0).max(1)).optional(),
-  width: terrainNumberValueSchema(z3.number().finite().min(0).max(32)).optional()
+  opacity: terrainNumberValueSchema(z4.number().finite().min(0).max(1)).optional(),
+  width: terrainNumberValueSchema(z4.number().finite().min(0).max(32)).optional()
 }).strict();
-var terrainContourLabelSchema = z3.object({
+var terrainContourLabelSchema = z4.object({
   ...terrainLayerRangeShape,
   color: terrainColorValueSchema.optional(),
   font: moduleFontValueSchema.optional(),
   haloColor: terrainColorValueSchema.optional(),
-  haloWidth: terrainNumberValueSchema(z3.number().finite().min(0).max(16)).optional(),
-  opacity: terrainNumberValueSchema(z3.number().finite().min(0).max(1)).optional(),
-  size: terrainNumberValueSchema(z3.number().finite().min(1).max(64)).optional(),
-  spacing: terrainNumberValueSchema(z3.number().finite().min(1).max(1e3)).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()
 }).strict();
-var terrainContourThresholdPairSchema = z3.tuple([z3.number().finite().min(1e-3).max(1e5), z3.number().finite().min(1e-3).max(1e5)]).refine(([minor, index]) => minor <= index, {
+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, {
   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"
@@ -11781,7 +11844,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 = z3.record(z3.string().regex(/^(?:0|[1-9]|1\d|2[0-4])$/u), terrainContourThresholdPairSchema).superRefine((thresholds, context) => {
+var terrainContourThresholdsSchema = z4.record(z4.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({
@@ -11790,19 +11853,19 @@ var terrainContourThresholdsSchema = z3.record(z3.string().regex(/^(?:0|[1-9]|1\
     });
   }
 });
-var terrainContoursSchema = z3.object({
-  demMaxZoom: z3.number().int().min(0).max(24),
-  demUrl: z3.string().min(1).max(2048).refine(
+var terrainContoursSchema = z4.object({
+  demMaxZoom: z4.number().int().min(0).max(24),
+  demUrl: z4.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: z3.number().int().min(0).max(24).optional(),
+  maxZoom: z4.number().int().min(0).max(24).optional(),
   minZoom: zoomNumberSchema.optional(),
   minor: terrainContourLineSchema.optional(),
-  multiplier: z3.number().finite().min(1e-3).max(100).optional(),
-  overzoom: z3.number().int().min(0).max(8).optional(),
+  multiplier: z4.number().finite().min(1e-3).max(100).optional(),
+  overzoom: z4.number().int().min(0).max(8).optional(),
   sourceId: identifierSchema.optional(),
   thresholds: terrainContourThresholdsSchema
 }).strict().superRefine((contours, context) => {
@@ -11866,26 +11929,26 @@ var terrainContoursSchema = z3.object({
     }
   }
 });
-var terrainSchema = z3.union([
-  z3.enum(["none", "hillshade", "3d"]),
-  z3.object({
-    attribution: z3.string().optional(),
+var terrainSchema = z4.union([
+  z4.enum(["none", "hillshade", "3d"]),
+  z4.object({
+    attribution: z4.string().optional(),
     contours: terrainContoursSchema.optional(),
-    encoding: z3.enum(["mapbox", "terrarium"]).optional(),
-    exaggeration: z3.number().finite().min(0).max(10).optional(),
+    encoding: z4.enum(["mapbox", "terrarium"]).optional(),
+    exaggeration: z4.number().finite().min(0).max(10).optional(),
     hillshade: terrainHillshadeSchema.optional(),
-    mode: z3.enum(["none", "hillshade", "3d"]).optional(),
-    sourceId: z3.string().trim().min(1).optional(),
-    url: z3.string().trim().min(1).optional()
+    mode: z4.enum(["none", "hillshade", "3d"]).optional(),
+    sourceId: z4.string().trim().min(1).optional(),
+    url: z4.string().trim().min(1).optional()
   }).strict()
 ]);
-var viewSchema = z3.object({
-  bearing: z3.number().finite().min(-180).max(180).optional(),
-  center: z3.tuple([z3.number().finite().min(-180).max(180), z3.number().finite().min(-90).max(90)]).optional(),
-  pitch: z3.number().finite().min(0).max(85).optional(),
+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(),
   zoom: zoomNumberSchema.optional()
 }).strict();
-var themesSchema = z3.record(tileflowThemeNameSchema, tileflowThemeSchema).superRefine((themes, context) => {
+var themesSchema = z4.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" });
@@ -11909,8 +11972,8 @@ var themesSchema = z3.record(tileflowThemeNameSchema, tileflowThemeSchema).super
     }
   }
 }).describe("tileflow-themes");
-var systemThemesSchema = z3.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict();
-var resolvedTileflowMapSchema = z3.object({
+var systemThemesSchema = z4.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict();
+var resolvedTileflowMapSchema = z4.object({
   data: dataSchema.optional(),
   defaultTheme: tileflowThemeNameSchema,
   fonts: fontDirectoriesSchema.optional(),
@@ -11919,14 +11982,14 @@ var resolvedTileflowMapSchema = z3.object({
   id: tileflowMapIdSchema,
   marine: marineSchema.optional(),
   modules: modulesSchema.optional(),
-  name: z3.string().trim().min(1),
+  name: z4.string().trim().min(1),
   overlays: overlaysSchema.optional(),
-  projection: z3.enum(["globe", "mercator"]).optional(),
+  projection: z4.enum(["globe", "mercator"]).optional(),
   sources: hostedSourcesSchema.optional(),
   systemThemes: systemThemesSchema.optional(),
   terrain: terrainSchema.optional(),
   themes: themesSchema,
-  version: z3.number().int().positive(),
+  version: z4.number().int().positive(),
   view: viewSchema.optional()
 }).strict().superRefine((map, context) => {
   if (map.fonts !== void 0 && map.glyphs !== void 0) {
@@ -12483,6 +12546,55 @@ function isSafeArtifactName(value) {
   });
 }
 
+// src/cartography/overlay-placement-manifest.ts
+var tileflowOverlayPlacementManifestMetadataKey = "tileflow:overlay-placement-manifest";
+var tileflowOverlayPlacementManifestSchemaVersion = 1;
+function createTileflowOverlayPlacementManifest(layers) {
+  const anchors = Object.fromEntries(
+    tileflowOverlayPlacements.map((placement) => {
+      const index = tileflowOverlayInsertionIndex(layers, placement);
+      const id = index < layers.length ? layers[index]?.id : void 0;
+      if (id !== void 0 && typeof id !== "string") {
+        throw new Error(`Tileflow overlay placement ${placement} resolved an invalid layer ID.`);
+      }
+      return [placement, id ?? null];
+    })
+  );
+  return {
+    anchors,
+    schemaVersion: tileflowOverlayPlacementManifestSchemaVersion
+  };
+}
+function assertTileflowOverlayPlacementManifestLayers(manifest, layers) {
+  if (manifest.schemaVersion !== tileflowOverlayPlacementManifestSchemaVersion) {
+    throw new Error("Tileflow overlay placement manifest schema version is unsupported.");
+  }
+  const keys = Object.keys(manifest.anchors);
+  if (keys.length !== tileflowOverlayPlacements.length || keys.some((key, index) => key !== tileflowOverlayPlacements[index])) {
+    throw new Error("Tileflow overlay placement manifest keys are invalid.");
+  }
+  const layerIndexes = new Map(
+    layers.flatMap(
+      (layer, index) => typeof layer.id === "string" ? [[layer.id, index]] : []
+    )
+  );
+  let previous = -1;
+  for (const placement of tileflowOverlayPlacements) {
+    const anchor = manifest.anchors[placement];
+    const index = anchor === null ? layers.length : layerIndexes.get(anchor);
+    if (index === void 0) {
+      throw new Error(`Tileflow overlay placement manifest references missing layer: ${anchor}`);
+    }
+    if (index < previous) {
+      throw new Error("Tileflow overlay placement manifest anchor order is invalid.");
+    }
+    previous = index;
+  }
+  if (manifest.anchors["above-labels"] !== null) {
+    throw new Error("Tileflow above-labels placement must not have a physical anchor.");
+  }
+}
+
 // src/cartography/physical-planner.ts
 var roadHighZoom = 15;
 var linePaintDefaults = {
@@ -13563,11 +13675,19 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       type: data.schema.fields.poiType
     })
   );
+  const overlayPlacementManifest = runCompilationPhase(
+    "finalization",
+    () => createTileflowOverlayPlacementManifest(plannedLayers)
+  );
   const layers = runCompilationPhase("finalization", () => finalizeTileflowLayers(plannedLayers));
   runCompilationPhase(
     "finalization",
     () => assertTileflowInteractionManifestLayers(interactionManifest, layers)
   );
+  runCompilationPhase(
+    "finalization",
+    () => assertTileflowOverlayPlacementManifestLayers(overlayPlacementManifest, layers)
+  );
   const glyphs = runCompilationPhase("assets", () => resolveGlyphs(config));
   const sprite = options.preparedAssets?.icons?.sprite;
   const primarySource = {
@@ -13632,6 +13752,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       ...Object.keys(loweredOverlays.identities).length > 0 ? { "tileflow:overlays": loweredOverlays.identities } : {},
       "tileflow:sourceRequirements": sourceRequirements,
       ...interactionManifest ? { [tileflowInteractionManifestMetadataKey]: interactionManifest } : {},
+      [tileflowOverlayPlacementManifestMetadataKey]: overlayPlacementManifest,
       "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord9(module) || module.enabled !== false).map(([name]) => name).sort(),
       ...config.view ? { "tileflow:view": config.view } : {}
     }
@@ -13891,46 +14012,46 @@ function semanticReportKey(...parts) {
 }
 
 // src/manifest.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var tileflowRuntimeManifestVersion = 1;
 var tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
-var safeTextSchema = z4.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");
+var 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");
 var publicResourceUrlSchema = safeTextSchema.refine(isPublicResourceUrl, {
   message: "Expected an HTTP(S), root-relative, or path-relative public URL"
 });
 var apiOriginSchema = safeTextSchema.refine(isApiOrigin, {
   message: "Expected an absolute HTTP(S) origin without path, credentials, query, or fragment"
 });
-var viewSchema2 = 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(),
-  zoom: z4.number().finite().min(0).max(24).optional()
+var 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()
 }).strict();
-var fontFaceSchema = z4.object({
+var fontFaceSchema = z5.object({
   family: safeTextSchema.max(100),
   source: publicResourceUrlSchema,
-  style: z4.enum(["italic", "normal", "oblique"]).optional(),
-  weight: z4.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"]).optional()
+  style: z5.enum(["italic", "normal", "oblique"]).optional(),
+  weight: z5.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"]).optional()
 }).strict();
-var fontFacesSchema = z4.array(fontFaceSchema).max(16).superRefine(validateUniqueFontFaces);
-var manifestThemeSchema = z4.object({
-  colorScheme: z4.enum(["dark", "light"]),
+var fontFacesSchema = z5.array(fontFaceSchema).max(16).superRefine(validateUniqueFontFaces);
+var manifestThemeSchema = z5.object({
+  colorScheme: z5.enum(["dark", "light"]),
   fontFaces: fontFacesSchema.optional(),
   revision: safeTextSchema.max(128).optional(),
   styleId: safeTextSchema.max(128).optional(),
   styleUrl: publicResourceUrlSchema
 }).strict();
-var manifestMapSchema = z4.object({
+var manifestMapSchema = z5.object({
   apiUrl: apiOriginSchema.optional(),
   defaultTheme: tileflowThemeNameSchema,
   environment: safeTextSchema.max(128).optional(),
   mapId: safeTextSchema.max(128).optional(),
-  systemThemes: z4.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
-  themes: z4.record(tileflowThemeNameSchema, manifestThemeSchema),
-  usageMode: z4.literal("session").optional(),
+  systemThemes: z5.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
+  themes: z5.record(tileflowThemeNameSchema, manifestThemeSchema),
+  usageMode: z5.literal("session").optional(),
   view: viewSchema2.optional(),
-  worldGeneration: z4.literal("v1").optional()
+  worldGeneration: z5.literal("v1").optional()
 }).strict().superRefine((entry, context) => {
   const names = Object.keys(entry.themes);
   if (names.length === 0) {
@@ -13977,10 +14098,10 @@ var manifestMapSchema = z4.object({
     });
   }
 });
-var canonicalManifestSchema = z4.object({
+var canonicalManifestSchema = z5.object({
   apiUrl: apiOriginSchema.optional(),
-  maps: z4.record(tileflowPortableIdSchema, manifestMapSchema),
-  version: z4.literal(tileflowRuntimeManifestVersion)
+  maps: z5.record(tileflowPortableIdSchema, manifestMapSchema),
+  version: z5.literal(tileflowRuntimeManifestVersion)
 }).strict().superRefine((manifest, context) => {
   const mapCount = Object.keys(manifest.maps).length;
   if (mapCount === 0) {
@@ -13998,7 +14119,7 @@ var canonicalManifestSchema = z4.object({
     });
   }
 });
-var safeManifestInputSchema = z4.unknown().superRefine((input, context) => {
+var safeManifestInputSchema = z5.unknown().superRefine((input, context) => {
   const unsafe = findUnsafeManifestStructure(input);
   if (unsafe) {
     context.addIssue({
@@ -14089,7 +14210,7 @@ function findUnsafeManifestStructure(input) {
 }
 
 // src/capture-scene.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var tileflowCaptureSceneLimits = Object.freeze({
   applicationPathLength: 2048,
   boundsPadding: { maximum: 1024, minimum: 0 },
@@ -14100,26 +14221,26 @@ var tileflowCaptureSceneLimits = Object.freeze({
   viewport: { maximum: 4096, minimum: 64 },
   zoom: { maximum: 24, minimum: 0 }
 });
-var finiteLongitudeSchema = z5.number().finite().min(-180).max(180);
-var finiteLatitudeSchema = z5.number().finite().min(-90).max(90);
-var bearingSchema = z5.number().finite().min(-180).max(180).optional();
-var pitchSchema = z5.number().finite().min(tileflowCaptureSceneLimits.pitch.minimum).max(tileflowCaptureSceneLimits.pitch.maximum).optional();
-var tileflowCaptureCenterCameraSchema = z5.object({
-  type: z5.literal("center"),
-  center: z5.tuple([finiteLongitudeSchema, finiteLatitudeSchema]),
-  zoom: z5.number().finite().min(tileflowCaptureSceneLimits.zoom.minimum).max(tileflowCaptureSceneLimits.zoom.maximum),
+var finiteLongitudeSchema = z6.number().finite().min(-180).max(180);
+var finiteLatitudeSchema = z6.number().finite().min(-90).max(90);
+var bearingSchema = z6.number().finite().min(-180).max(180).optional();
+var pitchSchema = z6.number().finite().min(tileflowCaptureSceneLimits.pitch.minimum).max(tileflowCaptureSceneLimits.pitch.maximum).optional();
+var tileflowCaptureCenterCameraSchema = z6.object({
+  type: z6.literal("center"),
+  center: z6.tuple([finiteLongitudeSchema, finiteLatitudeSchema]),
+  zoom: z6.number().finite().min(tileflowCaptureSceneLimits.zoom.minimum).max(tileflowCaptureSceneLimits.zoom.maximum),
   bearing: bearingSchema,
   pitch: pitchSchema
 }).strict();
-var tileflowCaptureBoundsCameraSchema = z5.object({
-  type: z5.literal("bounds"),
-  bounds: z5.tuple([
+var tileflowCaptureBoundsCameraSchema = z6.object({
+  type: z6.literal("bounds"),
+  bounds: z6.tuple([
     finiteLongitudeSchema,
     finiteLatitudeSchema,
     finiteLongitudeSchema,
     finiteLatitudeSchema
   ]),
-  padding: z5.number().finite().min(tileflowCaptureSceneLimits.boundsPadding.minimum).max(tileflowCaptureSceneLimits.boundsPadding.maximum).optional(),
+  padding: z6.number().finite().min(tileflowCaptureSceneLimits.boundsPadding.minimum).max(tileflowCaptureSceneLimits.boundsPadding.maximum).optional(),
   bearing: bearingSchema,
   pitch: pitchSchema
 }).strict().superRefine((camera, context) => {
@@ -14139,14 +14260,14 @@ var tileflowCaptureBoundsCameraSchema = z5.object({
     });
   }
 });
-var tileflowCaptureCameraSchema = z5.discriminatedUnion("type", [
+var tileflowCaptureCameraSchema = z6.discriminatedUnion("type", [
   tileflowCaptureCenterCameraSchema,
   tileflowCaptureBoundsCameraSchema
 ]);
-var tileflowCaptureViewportSchema = z5.object({
-  width: z5.number().int().min(tileflowCaptureSceneLimits.viewport.minimum).max(tileflowCaptureSceneLimits.viewport.maximum),
-  height: z5.number().int().min(tileflowCaptureSceneLimits.viewport.minimum).max(tileflowCaptureSceneLimits.viewport.maximum),
-  dpr: z5.union([z5.literal(1), z5.literal(2)]).optional()
+var tileflowCaptureViewportSchema = z6.object({
+  width: z6.number().int().min(tileflowCaptureSceneLimits.viewport.minimum).max(tileflowCaptureSceneLimits.viewport.maximum),
+  height: z6.number().int().min(tileflowCaptureSceneLimits.viewport.minimum).max(tileflowCaptureSceneLimits.viewport.maximum),
+  dpr: z6.union([z6.literal(1), z6.literal(2)]).optional()
 }).strict().superRefine((viewport, context) => {
   const dpr = viewport.dpr ?? 1;
   const physicalWidth = viewport.width * dpr;
@@ -14160,22 +14281,22 @@ var tileflowCaptureViewportSchema = z5.object({
     });
   }
 });
-var tileflowCaptureIdSchema = z5.string().min(1).max(tileflowCaptureSceneLimits.captureIdLength).regex(/^[A-Za-z0-9_-]+$/, {
+var tileflowCaptureIdSchema = z6.string().min(1).max(tileflowCaptureSceneLimits.captureIdLength).regex(/^[A-Za-z0-9_-]+$/, {
   message: "Expected letters, numbers, underscores, or hyphens"
 }).refine((name) => name !== "__proto__", {
   message: "Expected an identifier that cannot mutate an object prototype"
 });
 var tileflowCaptureSceneNameSchema = tileflowPortableIdSchema;
-var applicationPathSchema = z5.string().min(1).max(tileflowCaptureSceneLimits.applicationPathLength).refine(isPortableApplicationPath, {
+var applicationPathSchema = z6.string().min(1).max(tileflowCaptureSceneLimits.applicationPathLength).refine(isPortableApplicationPath, {
   message: "Expected a root-relative application path without an origin, credentials, fragment, backslash, or control character"
 });
-var tileflowCaptureMapTargetSchema = z5.object({ kind: z5.literal("map") }).strict();
-var tileflowCaptureApplicationTargetSchema = z5.object({
-  kind: z5.literal("application"),
+var tileflowCaptureMapTargetSchema = z6.object({ kind: z6.literal("map") }).strict();
+var tileflowCaptureApplicationTargetSchema = z6.object({
+  kind: z6.literal("application"),
   path: applicationPathSchema,
   captureId: tileflowCaptureIdSchema.optional(),
-  selector: z5.string().trim().min(1).max(tileflowCaptureSceneLimits.selectorLength).optional(),
-  frame: z5.enum(["map", "viewport"]).optional()
+  selector: z6.string().trim().min(1).max(tileflowCaptureSceneLimits.selectorLength).optional(),
+  frame: z6.enum(["map", "viewport"]).optional()
 }).strict().superRefine((target, context) => {
   if (target.captureId && target.selector) {
     context.addIssue({
@@ -14185,11 +14306,11 @@ var tileflowCaptureApplicationTargetSchema = z5.object({
     });
   }
 });
-var tileflowCaptureTargetSchema = z5.discriminatedUnion("kind", [
+var tileflowCaptureTargetSchema = z6.discriminatedUnion("kind", [
   tileflowCaptureMapTargetSchema,
   tileflowCaptureApplicationTargetSchema
 ]);
-var tileflowCaptureSceneSchema = z5.object({
+var tileflowCaptureSceneSchema = z6.object({
   map: tileflowPortableIdSchema,
   theme: tileflowThemeNameSchema,
   camera: tileflowCaptureCameraSchema,
@@ -14292,8 +14413,11 @@ function isPlainRecord5(value) {
   return prototype === Object.prototype || prototype === null;
 }
 
+// src/icon-composition.ts
+import { z as z8 } from "zod";
+
 // src/icon-package.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var tileflowIconIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 var tileflowIconPackageLimits = {
   decodeConcurrency: 4,
@@ -14312,16 +14436,17 @@ var tileflowHostedAlphaCompatibility = {
   },
   maxMapsPerDeploy: 20
 };
-var sha256Schema = z6.string().regex(/^[a-f0-9]{64}$/);
-var tileflowIconIdSchema = z6.string().max(64).regex(tileflowIconIdPattern);
-var tileflowRenderedIconManifestEntrySchema = z6.object({
+var sha256Schema = z7.string().regex(/^[a-f0-9]{64}$/);
+var tileflowIconPackageContentHashSchema = sha256Schema;
+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",
@@ -14341,32 +14466,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(compareCodeUnits8);
@@ -14454,8 +14579,113 @@ function containsControlCharacter(value) {
   });
 }
 
+// src/icon-composition.ts
+var tileflowIconCompositionMaximumBytes = 1024 * 1024;
+var idsSchema = z8.array(tileflowIconIdSchema).max(tileflowIconPackageLimits.maxIconCount).refine(
+  (ids) => new Set(ids).size === ids.length && ids.every((id, index) => index === 0 || compareCodeUnits8(ids[index - 1], id) < 0),
+  "Icon exports must be unique and sorted by code unit"
+);
+var localContributorSchema = z8.object({ kind: z8.literal("local"), iconIds: idsSchema }).strict();
+var packageContributorSchema = z8.object({
+  kind: z8.literal("package"),
+  package: z8.string().max(214).regex(/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u),
+  iconIds: idsSchema
+}).strict();
+var setContributorSchema = z8.object({
+  kind: z8.literal("icon-set"),
+  reference: tileflowIconSetReferenceSchema,
+  teamId: tileflowIconSetTeamIdSchema,
+  setId: tileflowIconSetIdSchema,
+  versionId: tileflowIconSetVersionIdSchema,
+  version: z8.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  packageId: tileflowIconSetPackageIdSchema,
+  contentHash: tileflowIconPackageContentHashSchema,
+  iconIds: idsSchema.min(1)
+}).strict();
+var tileflowRenderedIconIdentitySchema = z8.object({
+  kind: z8.literal("rendered-icon"),
+  id: tileflowIconIdSchema,
+  width: z8.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
+  height: z8.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
+  pixelSha256: z8.object({
+    oneX: tileflowIconPackageContentHashSchema,
+    twoX: tileflowIconPackageContentHashSchema
+  }).strict()
+}).strict();
+var tileflowIconCompositionSchema = z8.object({
+  format: z8.literal("tileflow-icon-composition-v1"),
+  compositionVersion: z8.literal(1),
+  packageHash: tileflowIconPackageContentHashSchema,
+  contributors: z8.array(
+    z8.discriminatedUnion("kind", [
+      localContributorSchema,
+      packageContributorSchema,
+      setContributorSchema
+    ])
+  ).min(1).max(tileflowIconSourceLimit),
+  winners: z8.array(
+    tileflowRenderedIconIdentitySchema.omit({ kind: true }).extend({
+      contributor: z8.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(compareCodeUnits8);
+  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;
+}
+
 // src/map-build-manifest.ts
 var tileflowMapRevisionSchemaVersion = 1;
+var tileflowSharedIconMapRevisionSchemaVersion = 2;
 var tileflowMapRevisionCanonicalization = "tileflow-canonical-json-v1";
 var tileflowMapBuildManifestSchemaVersion = 1;
 var tileflowMapBuildManifestFileName = "build-manifest.json";
@@ -14495,6 +14725,7 @@ async function createTileflowMapBuildManifest(maps, options = {}) {
           defaultTheme: map.defaultTheme,
           lineage,
           mapRevisionSha256,
+          ...sourceAssets.iconComposition ? { mapRevisionSchemaVersion: 2 } : {},
           mapVersion: map.version,
           semanticCompiler: { ...tileflowSemanticCompilerIdentity },
           sourceAssets,
@@ -14570,6 +14801,8 @@ async function hashTileflowMapRevision(input, sourceAssets) {
     view: _view,
     ...effectiveCartography
   } = map;
+  const normalizedSources = normalizeSourceAssets(sourceAssets);
+  assertIconCompositionMatchesMap(map, normalizedSources);
   const revisionDocument = {
     canonicalization: tileflowMapRevisionCanonicalization,
     effectiveCartography: {
@@ -14577,10 +14810,11 @@ async function hashTileflowMapRevision(input, sourceAssets) {
       // The semantic language is map semantics. Its compiler ABI version remains a separate axis.
       semanticLanguage: tileflowSemanticCompilerIdentity.name
     },
-    schemaVersion: tileflowMapRevisionSchemaVersion,
-    sourceAssets: normalizeSourceAssets(sourceAssets)
+    schemaVersion: normalizedSources.iconComposition ? tileflowSharedIconMapRevisionSchemaVersion : tileflowMapRevisionSchemaVersion,
+    sourceAssets: normalizedSources
   };
-  return sha256Hex(`${tileflowMapRevisionDomain}${serializeCanonicalJson(revisionDocument)}`);
+  const domain = normalizedSources.iconComposition ? "tileflow-map-revision-v2\0" : tileflowMapRevisionDomain;
+  return sha256Hex(`${domain}${serializeCanonicalJson(revisionDocument)}`);
 }
 function normalizeRevisionCartography(input) {
   if (!input.sources) return input;
@@ -14642,6 +14876,7 @@ function normalizeLineage(input, map) {
 }
 function normalizeSourceAssets(input) {
   const icons = [...input.icons].map((icon) => {
+    if (icon.kind === "rendered-icon") return tileflowRenderedIconIdentitySchema.parse(icon);
     assertSha256(icon.sha256, `icon ${icon.id}`);
     return { ...icon };
   }).sort((left, right) => compareCodeUnits8(left.id, right.id));
@@ -14655,7 +14890,10 @@ function normalizeSourceAssets(input) {
   if (new Set(fonts.map(fontIdentity)).size !== fonts.length) {
     throw new Error("Effective Tileflow font source identities must have unique faces.");
   }
-  return { fonts, icons };
+  const iconComposition = input.iconComposition === void 0 ? void 0 : parseTileflowIconComposition(input.iconComposition);
+  if (icons.some((icon) => icon.kind === "rendered-icon") && !iconComposition)
+    throw new Error("Rendered icon identities require an explicit composition receipt");
+  return { fonts, icons, ...iconComposition ? { iconComposition } : {} };
 }
 function fontIdentity(font) {
   return `${font.family}\0${font.style}\0${font.weight}`;
@@ -14670,6 +14908,37 @@ function assertPortableAssetName(value) {
     throw new Error(`Invalid Tileflow map asset name: ${value}`);
   }
 }
+function assertIconCompositionMatchesMap(map, sources) {
+  const declared = map.icons ?? [];
+  const references = collectTileflowIconSetReferences(declared);
+  const receipt = sources.iconComposition;
+  if (references.length === 0 && receipt === void 0) return;
+  if (!receipt || receipt.contributors.length !== declared.length)
+    throw new Error("Shared icon dependencies require their complete ordered composition receipt");
+  for (const [ordinal, source] of declared.entries()) {
+    const contributor = receipt.contributors[ordinal];
+    if (typeof source === "string") {
+      if (contributor.kind !== "local") throw new Error("Icon contributor kind mismatch");
+    } else if (source.kind === "icon-set") {
+      if (contributor.kind !== "icon-set" || contributor.reference !== source.reference)
+        throw new Error("Icon dependency reference mismatch");
+    } else if (contributor.kind !== "package" || contributor.package !== source.package)
+      throw new Error("Package icon contributor mismatch");
+  }
+  if (sources.icons.length !== receipt.winners.length)
+    throw new Error("Effective icon identities must cover the entire winner closure");
+  for (const [ordinal, winner] of receipt.winners.entries()) {
+    const identity = sources.icons[ordinal];
+    if (identity.id !== winner.id) throw new Error("Effective icon identity mismatch");
+    if (receipt.contributors[winner.contributor].kind === "icon-set") {
+      if (identity.kind !== "rendered-icon" || identity.width !== winner.width || identity.height !== winner.height || identity.pixelSha256.oneX !== winner.pixelSha256.oneX || identity.pixelSha256.twoX !== winner.pixelSha256.twoX)
+        throw new Error(
+          "Shared icon identity must match verified rendered pixels, not original-source hashes"
+        );
+    } else if (identity.kind === "rendered-icon")
+      throw new Error("Local originals must retain their existing source identity");
+  }
+}
 
 // src/style-inspection.ts
 function createStyleWithInspection(config, options = {}) {
@@ -14831,6 +15100,7 @@ export {
   tileflowMapBuildManifestSchemaVersion,
   tileflowMapRevisionCanonicalization,
   tileflowMapRevisionSchemaVersion,
+  tileflowSharedIconMapRevisionSchemaVersion,
   tileflowStyleInspectionSchemaVersion,
   validateTileflowDataCompatibility
 };