@tileflow/core 0.1.0-alpha.44 → 0.1.0-alpha.45

package/dist/build.js

@@ -1198,6 +1198,9 @@ function cloneJson6(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
+// src/building-layer-ids.ts
+var tileflowNativeBuildingsLayerId = "tileflow-buildings-native-extrusion";
+
 // src/modules/buildings/compiler.ts
 function compileBuildings(request, context) {
   const { colors } = context;
@@ -1277,7 +1280,7 @@ function compileBuildings(request, context) {
       kind: "layer",
       layer: applyExtrusionStyle(
         {
-          id: "tileflow-buildings-3d",
+          id: tileflowNativeBuildingsLayerId,
           type: "fill-extrusion",
           source,
           "source-layer": sourceLayer,
@@ -4834,7 +4837,7 @@ function appendNauticalLayer(contributions, options) {
   if (point.visible === false) return;
   const isLabel = options.target.startsWith("nautical.labels.");
   if (!isLabel && point.marker && point.marker.visible !== false) {
-    const marker = applyCircleStyle(
+    const marker2 = applyCircleStyle(
       base(
         `${options.id}-marker`,
         "circle",
@@ -4852,7 +4855,7 @@ function appendNauticalLayer(contributions, options) {
       nauticalContribution(
         `${options.target}.marker`,
         options.localOrder,
-        options.flash ? flashing(marker, ["circle-opacity", "circle-stroke-opacity"]) : marker,
+        options.flash ? flashing(marker2, ["circle-opacity", "circle-stroke-opacity"]) : marker2,
         "symbols"
       )
     );
@@ -5298,12 +5301,12 @@ function mergePoiCategoryLayers(entries, options) {
   };
   for (const part of ["layout", "paint"]) {
     const records = entries.map(({ layer }) => asRecord2(layer[part]));
-    const properties2 = [...new Set(records.flatMap((record5) => Object.keys(record5)))].sort();
+    const properties2 = [...new Set(records.flatMap((record7) => Object.keys(record7)))].sort();
     const merged = {};
     for (const property of properties2) {
       const fallback = Object.hasOwn(varying, property) ? varying[property] : tileflowPoiLayerPropertyDefaults[property];
       const values = records.map(
-        (record5) => Object.hasOwn(record5, property) ? record5[property] : fallback
+        (record7) => Object.hasOwn(record7, property) ? record7[property] : fallback
       );
       if (values.every((value) => sameJson(value, values[0]))) {
         if (values[0] !== void 0) merged[property] = values[0];
@@ -6334,8 +6337,8 @@ function lastPathKey(path) {
 }
 function visitAuditableArray(value, path, category, state, forceExpression = false, intentRequired = false) {
   const operator = typeof value[0] === "string" ? value[0] : void 0;
-  const isExpression2 = forceExpression || isMapLibreExpressionOperator(operator);
-  if (!isExpression2) {
+  const isExpression3 = forceExpression || isMapLibreExpressionOperator(operator);
+  if (!isExpression3) {
     for (const [index, entry] of value.entries()) {
       visitAuditableValue(entry, `${path}[${index}]`, category, state, intentRequired);
     }
@@ -6832,13 +6835,13 @@ function assertThemeIdentity(theme) {
   }
 }
 function assertThemeDocument(theme) {
-  const record5 = assertPlainThemeRecord(theme, "theme");
-  assertExactThemeKeys(record5, "theme", themeDocumentKeys);
-  assertRequiredThemeKeys(record5, "theme", themeDocumentKeys);
+  const record7 = assertPlainThemeRecord(theme, "theme");
+  assertExactThemeKeys(record7, "theme", themeDocumentKeys);
+  assertRequiredThemeKeys(record7, "theme", themeDocumentKeys);
   assertThemeIdentity(theme);
-  assertThemeTokens(record5.tokens, "theme.tokens", true);
-  assertThemeTypography(record5.typography, "theme.typography");
-  assertThemeLighting(record5.lighting, "theme.lighting");
+  assertThemeTokens(record7.tokens, "theme.tokens", true);
+  assertThemeTypography(record7.typography, "theme.typography");
+  assertThemeLighting(record7.lighting, "theme.lighting");
   cloneJson14(theme);
 }
 function assertThemeTokens(value, path, complete) {
@@ -7296,6 +7299,132 @@ function compareCodeUnits(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
+// src/color-program.ts
+var tileflowColorMetadataKey = "tileflow:colors";
+var marker = "__tileflow_color_program";
+function colorProgramMarker(value, program) {
+  return [
+    "let",
+    marker,
+    ["literal", program],
+    "__tileflow_color_value",
+    value,
+    ["var", "__tileflow_color_value"]
+  ];
+}
+function isColorProgramMarker(value) {
+  return Array.isArray(value) && value.length === 6 && value[0] === "let" && value[1] === marker && Array.isArray(value[2]) && value[2][0] === "literal";
+}
+function colorProgramValue(value) {
+  return isColorProgramMarker(value) ? value[4] : value;
+}
+function colorProgramOf(value) {
+  return isColorProgramMarker(value) ? value[2][1] : value;
+}
+function preserveThemeColorPrograms(authored, resolved, theme, insideExpression = false) {
+  if (isTileflowThemeTokenReference(authored) && authored.category === "color" || isTileflowThemeColorOperation(authored)) {
+    const value = colorProgramMarker(resolved, resolveProgramNumbers(authored, theme));
+    return insideExpression ? value : { kind: "expression", value };
+  }
+  if (Array.isArray(authored) && Array.isArray(resolved))
+    return resolved.map(
+      (value, index) => preserveThemeColorPrograms(authored[index], value, theme, insideExpression)
+    );
+  if (record(authored) && record(resolved)) {
+    if (authored.kind === "theme-fixed") return resolved;
+    return Object.fromEntries(
+      Object.entries(resolved).map(([key, value]) => [
+        key,
+        preserveThemeColorPrograms(
+          authored[key],
+          value,
+          theme,
+          insideExpression || authored.kind === "expression" || authored.kind === "zoom" && key === "stops"
+        )
+      ])
+    );
+  }
+  return resolved;
+}
+function resolveProgramNumbers(value, theme) {
+  if (isTileflowThemeTokenReference(value) && value.category === "number")
+    return resolveThemeValues({ opacity: value }, theme).opacity;
+  if (Array.isArray(value)) return value.map((node2) => resolveProgramNumbers(node2, theme));
+  if (record(value))
+    return Object.fromEntries(
+      Object.entries(value).map(([key, node2]) => [key, resolveProgramNumbers(node2, theme)])
+    );
+  return value;
+}
+function extractTileflowColorPrograms(style, tokens) {
+  const programs = [];
+  const ids = /* @__PURE__ */ new Map();
+  const bindings = [];
+  const visit2 = (node2, path) => {
+    if (record(node2) && node2.kind === "expression" && isColorProgramMarker(node2.value))
+      return visit2(node2.value, path);
+    if (isColorProgramMarker(node2)) {
+      const program = colorProgramOf(node2);
+      const key = JSON.stringify(program);
+      let id2 = ids.get(key);
+      if (id2 === void 0) {
+        id2 = programs.length;
+        ids.set(key, id2);
+        programs.push(program);
+      }
+      bindings.push([
+        path[0] === "layers" && path[2] === "paint" ? [path[1], ...path.slice(3)] : path,
+        id2
+      ]);
+      return colorProgramValue(node2);
+    }
+    if (Array.isArray(node2)) return node2.map((v, i) => visit2(v, [...path, i]));
+    if (record(node2))
+      return Object.fromEntries(
+        Object.entries(node2).filter(([key]) => key !== tileflowColorMetadataKey).map(([key, v]) => [key, visit2(v, [...path, key])])
+      );
+    return node2;
+  };
+  const result = visit2(style, []);
+  if (bindings.length)
+    result.metadata = {
+      ...result.metadata,
+      // Keep the declared catalog shape across presets. Per-preset pruning makes a shared
+      // object structurally different and repeats the entire catalog in the transport.
+      [tileflowColorMetadataKey]: { version: 1, programs, bindings, tokens }
+    };
+  return result;
+}
+function record(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function mapColorProgramsThrough(input, reader) {
+  return overlayColorPrograms(input, reader(stripColorPrograms(input)));
+}
+function stripColorPrograms(value) {
+  if (isColorProgramMarker(value)) return colorProgramValue(value);
+  if (record(value) && value.kind === "expression" && isColorProgramMarker(value.value))
+    return colorProgramValue(value.value);
+  if (Array.isArray(value)) return value.map(stripColorPrograms);
+  if (record(value))
+    return Object.fromEntries(
+      Object.entries(value).map(([key, node2]) => [key, stripColorPrograms(node2)])
+    );
+  return value;
+}
+function overlayColorPrograms(input, output) {
+  const candidate = record(input) && input.kind === "expression" ? input.value : input;
+  if (isColorProgramMarker(candidate) && typeof output === "string")
+    return colorProgramMarker(output, colorProgramOf(candidate));
+  if (Array.isArray(input) && Array.isArray(output))
+    return output.map((value, index) => overlayColorPrograms(input[index], value));
+  if (record(input) && record(output))
+    return Object.fromEntries(
+      Object.entries(output).map(([key, node2]) => [key, overlayColorPrograms(input[key], node2)])
+    );
+  return output;
+}
+
 // src/themes/index.ts
 var defaultColors = {
   background: "#F6F7F3",
@@ -7502,8 +7631,18 @@ var baseThemeColorRoles = {
 };
 var tileflowRequiredThemeColorRoles = Object.freeze(Object.values(baseThemeColorRoles));
 var baseThemeColorRoleSet = new Set(tileflowRequiredThemeColorRoles);
-function resolveThemeColors(theme, onDecision) {
-  const tokens = resolveTileflowTheme(theme).tokens.color;
+function resolveThemeColors(theme, onDecision, preservePrograms = false) {
+  if (onDecision && preservePrograms) {
+    const report = onDecision;
+    onDecision = (decision) => report({ ...decision, value: colorProgramValue(decision.value) });
+  }
+  const concrete = resolveTileflowTheme(theme).tokens.color;
+  const tokens = Object.fromEntries(
+    Object.entries(concrete).map(([name, value]) => [
+      name,
+      preservePrograms ? colorProgramMarker(value, { kind: "theme-token", category: "color", token: name }) : value
+    ])
+  );
   const requireColor = (name) => {
     const value = tokens[name];
     if (value !== void 0) {
@@ -7741,10 +7880,22 @@ function relativeLuminance(color2) {
   return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
 }
 function alpha(color2, opacity) {
+  if (isColorProgramMarker(color2))
+    return colorProgramMarker(alpha(colorProgramValue(color2), opacity), {
+      kind: "theme-color",
+      operation: "alpha",
+      color: colorProgramOf(color2),
+      opacity
+    });
   const { a, b, g, r } = hexToRgba(color2);
   return `rgba(${r}, ${g}, ${b}, ${roundAlpha(a * opacity)})`;
 }
 function mix(hexA, hexB, amount) {
+  if (isColorProgramMarker(hexA) || isColorProgramMarker(hexB))
+    return colorProgramMarker(
+      mix(colorProgramValue(hexA), colorProgramValue(hexB), amount),
+      ["srgb", colorProgramOf(hexA), colorProgramOf(hexB), amount]
+    );
   const a = hexToRgb(hexA);
   const b = hexToRgb(hexB);
   const r = Math.round(a.r + (b.r - a.r) * amount);
@@ -7757,6 +7908,7 @@ function hexToRgb(hex) {
   return { b, g, r };
 }
 function hexToRgba(hex) {
+  hex = colorProgramValue(hex);
   const rgbMatch = hex.match(
     /^rgba?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)(?:\s*,\s*(\d+(?:\.\d+)?))?\s*\)$/
   );
@@ -7778,6 +7930,11 @@ function hexToRgba(hex) {
   };
 }
 function cssColor(hex) {
+  if (isColorProgramMarker(hex))
+    return colorProgramMarker(
+      cssColor(colorProgramValue(hex)),
+      colorProgramOf(hex)
+    );
   const value = hex.replace("#", "");
   if (value.length !== 4 && value.length !== 8) {
     return hex;
@@ -7955,10 +8112,10 @@ function bindRepeated(curve) {
   for (let index = 0; index < 2; index += 1) {
     const json = /* @__PURE__ */ new Map();
     const found = /* @__PURE__ */ new Map();
-    const visit = (value) => {
+    const visit2 = (value) => {
       if (!Array.isArray(value) || value[0] === "literal")
         return { text: JSON.stringify(value), free: true };
-      const parts = value.map(visit);
+      const parts = value.map(visit2);
       const text = `[${parts.map((part) => part.text).join(",")}]`;
       json.set(value, text);
       const free = value[0] !== "zoom" && value[0] !== "var" && parts.every((part) => part.free);
@@ -7966,7 +8123,7 @@ function bindRepeated(curve) {
         found.set(text, (found.get(text) ?? 0) + 1);
       return { text, free };
     };
-    visit(tree);
+    visit2(tree);
     let best;
     let saving = 256;
     for (const [text, count] of found) {
@@ -8822,8 +8979,8 @@ function withinClasses(value, drawn) {
     if ((operator === "==" || operator === "!=") && operands.length === 2) {
       const label = isClass(operands[0]) ? operands[1] : isClass(operands[1]) ? operands[0] : null;
       if (typeof label !== "string") return void 0;
-      const equal2 = among([label]);
-      return equal2 === void 0 ? void 0 : operator === "==" ? equal2 : !equal2;
+      const equal3 = among([label]);
+      return equal3 === void 0 ? void 0 : operator === "==" ? equal3 : !equal3;
     }
     if (operator === "match" && operands.length === 4 && isClass(operands[0]) && typeof operands[2] === "boolean" && typeof operands[3] === "boolean") {
       const labels2 = Array.isArray(operands[1]) ? operands[1] : [operands[1]];
@@ -9470,7 +9627,10 @@ function tileflowVegetationDescription(request, context) {
     return void 0;
   const tree = context.colors.vegetation.tree;
   const style = request?.threeDimensional ?? {};
-  const colours = (value, fallback) => Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string") ? value : [...fallback];
+  const colours = (value, fallback) => {
+    const values = Array.isArray(value) ? value.map((entry) => toMapLibreStyleValue(entry)) : [];
+    return values.length && values.every((entry) => typeof entry === "string" || isColorProgramMarker(entry)) ? values : [...fallback];
+  };
   const number = (value) => {
     const resolved = value === void 0 ? void 0 : toMapLibreStyleValue(value);
     return typeof resolved === "number" && resolved > 0 ? resolved : 1;
@@ -9497,7 +9657,10 @@ function tileflowVegetationDescription(request, context) {
       hedge: field2("hedge", tileflowWorldTreeFields.hedge)
     },
     colors: {
-      bark: typeof style.barkColor === "string" ? style.barkColor : tree.bark,
+      bark: (() => {
+        const value = toMapLibreStyleValue(style.barkColor ?? tree.bark);
+        return typeof value === "string" || isColorProgramMarker(value) ? value : tree.bark;
+      })(),
       broadleaf: colours(style.broadleafColors, tree.broadleaf),
       conifer: colours(style.coniferColors, tree.conifer),
       palm: colours(style.palmColors, tree.palm),
@@ -9539,7 +9702,7 @@ function tileflowVegetationDescription(request, context) {
     })(),
     ...(() => {
       const edgeColor = style.edgeColor === void 0 ? void 0 : toMapLibreStyleValue(style.edgeColor);
-      return typeof edgeColor === "string" ? { edgeColor } : {};
+      return typeof edgeColor === "string" || isColorProgramMarker(edgeColor) ? { edgeColor } : {};
     })(),
     unknownForms: style.unknownForms ?? tileflowDefaultUnknownTreeForms,
     regions: style.regions ?? [],
@@ -10382,8 +10545,8 @@ function assertProvidedServices(domain, services) {
   }
 }
 function checkedModuleRecord(entries) {
-  const record5 = Object.fromEntries(entries);
-  const actual = Object.keys(record5).sort(compareCodeUnits2);
+  const record7 = Object.fromEntries(entries);
+  const actual = Object.keys(record7).sort(compareCodeUnits2);
   if (actual.length !== tileflowSemanticDomainRegistry.length || actual.some(
     (name, index) => name !== [...tileflowSemanticDomainRegistry.map(({ name: name2 }) => name2)].sort(compareCodeUnits2)[index]
   )) {
@@ -10391,7 +10554,7 @@ function checkedModuleRecord(entries) {
       "Tileflow semantic domain registry did not produce one value for every module."
     );
   }
-  return record5;
+  return record7;
 }
 function assertRegistryIsValid() {
   const names = /* @__PURE__ */ new Set();
@@ -10502,12 +10665,12 @@ import { z as z3 } from "zod";
 // src/native-zod-object.ts
 import { z as z2 } from "zod";
 function strictNativeObject(shape) {
-  const object2 = new z2.core.$ZodObject({
+  const object3 = new z2.core.$ZodObject({
     type: "object",
     shape,
     catchall: z2.never()
   });
-  return z2.lazy(() => object2);
+  return z2.lazy(() => object3);
 }
 
 // src/manifest-schema-classic.ts
@@ -10994,7 +11157,7 @@ var defaultBuildingFloodLight = Object.freeze({
 });
 var defaultModelEmissionGradient = [0, 1, 1, 1, 0];
 function readBuildingFloodLight(value) {
-  if (!record(value)) return void 0;
+  if (!record2(value)) return void 0;
   const defaults4 = defaultBuildingFloodLight;
   const radius = value.groundRadius;
   return {
@@ -11008,11 +11171,11 @@ function readBuildingFloodLight(value) {
   };
 }
 function readModelRoleLighting(value) {
-  if (!record(value)) return void 0;
+  if (!record2(value)) return void 0;
   const result = {};
   for (const role of Object.keys(tileflowModelLightingRoles)) {
     const entry = value[role];
-    if (!record(entry)) continue;
+    if (!record2(entry)) continue;
     const gradient = entry.emissiveHeight;
     result[role] = {
       emissiveStrength: bounded(entry.emissiveStrength, 0, 5, 0),
@@ -11035,7 +11198,7 @@ function readModelRoleLighting(value) {
   return Object.keys(result).length ? result : void 0;
 }
 function readRoleColorVariation(value) {
-  if (!record(value)) return {};
+  if (!record2(value)) return {};
   for (const [key, max] of [
     ["hue", 360],
     ["saturation", 100],
@@ -11051,16 +11214,16 @@ function readRoleColorVariation(value) {
 function bounded(value, min, max, fallback) {
   return typeof value === "number" && Number.isFinite(value) && value >= min && value <= max ? value : fallback;
 }
-function record(value) {
+function record2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/buildings-3d-surfaces.ts
 function readTileflowBuildingSurfaces(value) {
-  if (!record2(value)) return void 0;
+  if (!record3(value)) return void 0;
   const number = (value2, min, max, fallback) => typeof value2 === "number" && Number.isFinite(value2) && value2 >= min && value2 <= max ? value2 : fallback;
   const result = {};
-  if (record2(value.walls) && value.walls.kind === "brick") {
+  if (record3(value.walls) && value.walls.kind === "brick") {
     const size = Array.isArray(value.walls.size) ? value.walls.size : [];
     const width = number(size[0], 0.5, 100, 6);
     const height = number(size[1], 0.5, 100, 3);
@@ -11074,7 +11237,7 @@ function readTileflowBuildingSurfaces(value) {
       contrast: number(value.walls.contrast, 0, 1, 0.2)
     };
   }
-  if (record2(value.roof) && value.roof.kind === "tiles") {
+  if (record3(value.roof) && value.roof.kind === "tiles") {
     const size = number(value.roof.size, 0.5, 100, 8);
     result.roof = {
       kind: "tiles",
@@ -11083,14 +11246,14 @@ function readTileflowBuildingSurfaces(value) {
       contrast: number(value.roof.contrast, 0, 1, 0.1)
     };
   }
-  if (record2(value.cornice))
+  if (record3(value.cornice))
     result.cornice = {
       height: number(value.cornice.height, 0.05, 5, 0.6),
       contrast: number(value.cornice.contrast, 0, 1, 0.2)
     };
   return Object.keys(result).length ? result : void 0;
 }
-function record2(value) {
+function record3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
@@ -11117,8 +11280,9 @@ function tileflowBuildingsMetadata(design) {
   return { version: 1, ...design };
 }
 function readTileflowBuildingsEntrance(value) {
+  if (value === false) return { entrance: false };
   if (!isRecord5(value)) return {};
-  const band = (entry) => Array.isArray(entry) && entry.length === 2 && entry.every((zoom3) => typeof zoom3 === "number" && zoom3 >= 0 && zoom3 <= 24) && entry[0] < entry[1] ? [entry[0], entry[1]] : void 0;
+  const band = (entry) => Array.isArray(entry) && entry.length === 2 && entry.every((zoom3) => typeof zoom3 === "number" && zoom3 >= 0 && zoom3 <= 24) && entry[0] <= entry[1] ? [entry[0], entry[1]] : void 0;
   const buildings2 = band(value.buildings);
   const models = band(value.models);
   return buildings2 || models ? { entrance: { ...buildings2 ? { buildings: buildings2 } : {}, ...models ? { models } : {} } } : {};
@@ -11127,6 +11291,9 @@ function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/camera-limits.ts
+var tileflowMaxPitch = 85;
+
 // src/camera.ts
 var tileflowCameraMetadataKey = "tileflow:camera";
 
@@ -11269,11 +11436,11 @@ function collectFieldAccesses(value, fields2, dynamicAccesses, path) {
     return;
   }
   if (!value || typeof value !== "object") return;
-  const record5 = value;
-  if (typeof record5.property === "string" && Array.isArray(record5.stops)) {
-    fields2.set(record5.property, fields2.get(record5.property));
+  const record7 = value;
+  if (typeof record7.property === "string" && Array.isArray(record7.stops)) {
+    fields2.set(record7.property, fields2.get(record7.property));
   }
-  for (const [key, child] of Object.entries(record5)) {
+  for (const [key, child] of Object.entries(record7)) {
     collectFieldAccesses(child, fields2, dynamicAccesses, `${path}.${key}`);
   }
 }
@@ -11408,9 +11575,6 @@ function parsePathGroundRequest(value) {
 import { Color as Color3 } from "@maplibre/maplibre-gl-style-spec";
 import { z as z5 } from "zod";
 
-// src/camera-limits.ts
-var tileflowMaxPitch = 85;
-
 // src/cartography/data-expression.ts
 var tileflowDataExpressionLimits = Object.freeze({
   maxBranches: 16,
@@ -11676,7 +11840,7 @@ function visitExpression(value, path, variables, issues) {
   const branchLimit = tileflowDataExpressionLimits.maxBranches;
   const operandLimit = tileflowDataExpressionLimits.maxOperands;
   const stopLimit = tileflowDataExpressionLimits.maxStops;
-  const visit = (entry, index, scope = variables) => visitExpressionNode(entry, [...path, index], scope, issues);
+  const visit2 = (entry, index, scope = variables) => visitExpressionNode(entry, [...path, index], scope, issues);
   const exact = (length) => {
     if (value.length === length) return true;
     addExpressionIssue(
@@ -11738,18 +11902,18 @@ function visitExpression(value, path, variables, issues) {
       if (!exact(4)) return;
       if (!isNonEmptyString(value[1])) {
         addExpressionIssue(issues, [...path, 1], "Variable names must be non-empty strings.");
-        visit(value[2], 2);
-        visit(value[3], 3);
+        visit2(value[2], 2);
+        visit2(value[3], 3);
         return;
       }
-      visit(value[2], 2);
-      visit(value[3], 3, /* @__PURE__ */ new Set([...variables, value[1]]));
+      visit2(value[2], 2);
+      visit2(value[3], 3, /* @__PURE__ */ new Set([...variables, value[1]]));
       return;
     }
     case "abs":
     case "!":
     case "to-string": {
-      if (exact(2)) visit(value[1], 1);
+      if (exact(2)) visit2(value[1], 1);
       return;
     }
     case "boolean":
@@ -11758,7 +11922,7 @@ function visitExpression(value, path, variables, issues) {
         addExpressionIssue(issues, path, `Expression ${operator} expects one or two arguments.`);
         return;
       }
-      for (let index = 1; index < value.length; index += 1) visit(value[index], index);
+      for (let index = 1; index < value.length; index += 1) visit2(value[index], index);
       return;
     }
     case "-":
@@ -11771,8 +11935,8 @@ function visitExpression(value, path, variables, issues) {
     case ">":
     case ">=": {
       if (!exact(3)) return;
-      visit(value[1], 1);
-      visit(value[2], 2);
+      visit2(value[1], 1);
+      visit2(value[2], 2);
       return;
     }
     case "+":
@@ -11790,7 +11954,7 @@ function visitExpression(value, path, variables, issues) {
         );
         return;
       }
-      for (let index = 1; index < value.length; index += 1) visit(value[index], index);
+      for (let index = 1; index < value.length; index += 1) visit2(value[index], index);
       return;
     }
     case "all":
@@ -11804,7 +11968,7 @@ function visitExpression(value, path, variables, issues) {
         );
         return;
       }
-      for (let index = 1; index < value.length; index += 1) visit(value[index], index);
+      for (let index = 1; index < value.length; index += 1) visit2(value[index], index);
       return;
     }
     case "case": {
@@ -11824,7 +11988,7 @@ function visitExpression(value, path, variables, issues) {
         );
         return;
       }
-      for (let index = 1; index < value.length; index += 1) visit(value[index], index);
+      for (let index = 1; index < value.length; index += 1) visit2(value[index], index);
       return;
     }
     case "match": {
@@ -11844,10 +12008,10 @@ function visitExpression(value, path, variables, issues) {
         );
         return;
       }
-      visit(value[1], 1);
+      visit2(value[1], 1);
       validateSerializedMatchLabels(value, path, issues);
-      for (let index = 3; index < value.length; index += 2) visit(value[index], index);
-      visit(value.at(-1), value.length - 1);
+      for (let index = 3; index < value.length; index += 2) visit2(value[index], index);
+      visit2(value.at(-1), value.length - 1);
       return;
     }
     case "step": {
@@ -11863,10 +12027,10 @@ function visitExpression(value, path, variables, issues) {
         addExpressionIssue(issues, path, `Expression step exceeds ${stopLimit} stops.`);
         return;
       }
-      visit(value[1], 1);
-      visit(value[2], 2);
+      visit2(value[1], 1);
+      visit2(value[2], 2);
       validateSerializedStops(value, 3, path, issues);
-      for (let index = 4; index < value.length; index += 2) visit(value[index], index);
+      for (let index = 4; index < value.length; index += 2) visit2(value[index], index);
       return;
     }
     case "interpolate": {
@@ -11883,9 +12047,9 @@ function visitExpression(value, path, variables, issues) {
         return;
       }
       validateInterpolationArray(value[1], [...path, 1], issues);
-      visit(value[2], 2);
+      visit2(value[2], 2);
       validateSerializedStops(value, 3, path, issues);
-      for (let index = 4; index < value.length; index += 2) visit(value[index], index);
+      for (let index = 4; index < value.length; index += 2) visit2(value[index], index);
       return;
     }
     default:
@@ -12020,6 +12184,260 @@ var expr = Object.freeze({
   zoom: zoom2
 });
 
+// src/cartography/expression-compaction.ts
+function compactTileflowExpression(value, scope = /* @__PURE__ */ new Map()) {
+  if (isColorProgramMarker(value)) return value;
+  if (!isExpression(value) || value[0] === "literal" || value[0] === "var") return value;
+  if (value[0] === "let") return compactLet(value, scope);
+  const node2 = value.map((entry, index) => {
+    if (value[0] === "match" && index >= 2 && index < value.length - 1 && index % 2 === 0)
+      return entry;
+    if (index === 0 || value[0] === "interpolate" && index === 1) return entry;
+    return compactTileflowExpression(entry, scope);
+  });
+  if (node2[0] === "all" || node2[0] === "any") {
+    const operands = node2.slice(1).flatMap(
+      (entry) => Array.isArray(entry) && entry[0] === node2[0] ? entry.slice(1) : [entry]
+    );
+    return [node2[0], ...operands];
+  }
+  if (node2[0] === "case") {
+    while (node2.length >= 4 && equal(node2.at(-2), node2.at(-1)) && totalBoolean(node2.at(-3), scope))
+      node2.splice(node2.length - 3, 2);
+    return node2.length === 2 ? node2[1] : compactClassDispatch(node2, scope);
+  }
+  if (node2[0] === "match" && totalValue(node2[1], scope)) {
+    for (let index = node2.length - 3; index >= 2; index -= 2)
+      if (equal(node2[index + 1], node2.at(-1))) node2.splice(index, 2);
+    return node2.length === 3 ? node2[2] : node2;
+  }
+  if (node2[0] === "*" && node2.slice(1).every((entry) => numeric(entry, scope))) {
+    const operands = node2.slice(1).filter((entry) => entry !== 1);
+    return operands.length === 0 ? 1 : operands.length === 1 ? operands[0] : ["*", ...operands];
+  }
+  if (node2[0] === "interpolate" && numeric(node2[2], scope)) {
+    const outputs2 = node2.filter((_, index) => index >= 4 && index % 2 === 0);
+    if (outputs2.length > 0 && outputs2.every((entry) => equal(entry, outputs2[0]))) return outputs2[0];
+    if (typeof node2[2] === "number" && outputs2.every((output) => typeof output === "number" && Number.isFinite(output))) {
+      for (let index = 3; index < node2.length - 1; index += 2)
+        if (node2[index] === node2[2]) return node2[index + 1];
+    }
+  }
+  return node2;
+}
+function compactClassDispatch(node2, scope) {
+  if (node2.length < 6) return node2;
+  const branches = [];
+  const labels2 = /* @__PURE__ */ new Set();
+  let labelType;
+  for (let index = 1; index < node2.length - 1; index += 2) {
+    const condition = node2[index];
+    const parts = Array.isArray(condition) && condition[0] === "all" ? condition.slice(1) : [condition];
+    const at = parts.findIndex(
+      (part) => Array.isArray(part) && part[0] === "match" && part.length === 5 && part[3] === true && part[4] === false
+    );
+    if (at < 0 || !parts.every((part) => totalBoolean(part, scope))) return node2;
+    const match4 = parts[at];
+    const ownLabels = Array.isArray(match4[2]) ? match4[2] : [match4[2]];
+    if (ownLabels.length === 0) return node2;
+    for (const label of ownLabels) {
+      labelType ??= typeof label;
+      if (!["number", "string"].includes(labelType) || typeof label !== labelType) return node2;
+      const key = JSON.stringify(label);
+      if (labels2.has(key)) return node2;
+      labels2.add(key);
+    }
+    branches.push({
+      input: match4[1],
+      labels: ownLabels,
+      guards: parts.filter((_, i) => i !== at),
+      output: node2[index + 1]
+    });
+  }
+  const first = branches[0];
+  if (!branches.every(
+    (branch) => equal(branch.input, first.input) && equal(branch.guards, first.guards)
+  ))
+    return node2;
+  const fallback = node2.at(-1);
+  const match3 = [
+    "match",
+    first.input,
+    ...branches.flatMap((branch) => [branch.labels, branch.output]),
+    fallback
+  ];
+  const result = first.guards.length ? [
+    "case",
+    first.guards.length === 1 ? first.guards[0] : ["all", ...first.guards],
+    match3,
+    fallback
+  ] : match3;
+  return JSON.stringify(result).length < JSON.stringify(node2).length ? result : node2;
+}
+function compactLet(node2, scope) {
+  const inner = new Map(scope);
+  const bindings = [];
+  for (let index = 1; index < node2.length - 1; index += 2) {
+    const name = node2[index];
+    if (typeof name !== "string") return node2;
+    const value = compactTileflowExpression(node2[index + 1], scope);
+    bindings.push(name, value);
+    inner.set(name, { value, scope });
+  }
+  const result = compactTileflowExpression(node2.at(-1), inner);
+  if (Array.isArray(result) && result[0] === "var" && bindings.includes(result[1])) {
+    for (let index = bindings.length - 2; index >= 0; index -= 2)
+      if (bindings[index] === result[1]) return bindings[index + 1];
+  }
+  const retained = [];
+  for (let index = 0; index < bindings.length; index += 2)
+    if (usesVariable(result, bindings[index]))
+      retained.push(bindings[index], bindings[index + 1]);
+  return retained.length ? ["let", ...retained, result] : result;
+}
+function usesVariable(value, name) {
+  if (!Array.isArray(value) || value[0] === "literal") return false;
+  if (value[0] === "var") return value[1] === name;
+  return value.some((entry) => usesVariable(entry, name));
+}
+function numeric(value, scope) {
+  if (typeof value === "number") return Number.isFinite(value);
+  if (!Array.isArray(value)) return false;
+  if (value[0] === "zoom") return value.length === 1;
+  if (value[0] === "var" && typeof value[1] === "string") {
+    const binding = scope.get(value[1]);
+    return binding !== void 0 && numeric(binding.value, binding.scope);
+  }
+  if (value[0] === "*" || value[0] === "+" || value[0] === "-" || value[0] === "max" || value[0] === "min")
+    return value.length > 1 && value.slice(1).every((entry) => numeric(entry, scope));
+  if (value[0] === "case")
+    return value.slice(1, -1).every(
+      (entry, index) => index % 2 === 0 ? totalBoolean(entry, scope) : numeric(entry, scope)
+    ) && numeric(value.at(-1), scope);
+  if (value[0] === "interpolate")
+    return numeric(value[2], scope) && value.filter((_, index) => index >= 4 && index % 2 === 0).every((entry) => numeric(entry, scope));
+  return false;
+}
+function totalBoolean(value, scope) {
+  if (typeof value === "boolean") return true;
+  if (!Array.isArray(value)) return false;
+  if (value[0] === "has") return value.length === 2 && typeof value[1] === "string";
+  if (value[0] === "!" && value.length === 2) return totalBoolean(value[1], scope);
+  if (value[0] === "all" || value[0] === "any")
+    return value.slice(1).every((entry) => totalBoolean(entry, scope));
+  if ((value[0] === "==" || value[0] === "!=") && value.length === 3)
+    return totalValue(value[1], scope) && totalValue(value[2], scope);
+  if (value[0] === "match")
+    return totalValue(value[1], scope) && value.filter((_, index) => index >= 3 && index % 2 === 1).every((entry) => totalBoolean(entry, scope)) && totalBoolean(value.at(-1), scope);
+  return false;
+}
+function totalValue(value, scope) {
+  if (value === null || ["string", "boolean", "number"].includes(typeof value)) return true;
+  if (!Array.isArray(value)) return false;
+  if (value[0] === "literal") return true;
+  if (value[0] === "get" || value[0] === "has")
+    return value.length === 2 && typeof value[1] === "string";
+  if (value[0] === "geometry-type" || value[0] === "id") return value.length === 1;
+  if (value[0] === "to-string") return value.length === 2 && totalValue(value[1], scope);
+  return numeric(value, scope) || totalBoolean(value, scope);
+}
+function isExpression(value) {
+  return Array.isArray(value) && isMapLibreExpressionOperator(value[0]);
+}
+function equal(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function shareExpressions(value) {
+  if (!isExpression(value)) return value;
+  let result = value;
+  const bindings = [];
+  const serialized = /* @__PURE__ */ new WeakMap();
+  const textOf = (node2) => {
+    let text = serialized.get(node2);
+    if (text === void 0) {
+      text = JSON.stringify(node2);
+      serialized.set(node2, text);
+    }
+    return text;
+  };
+  const originalText = textOf(value);
+  for (let index = 0; index < 16; index += 1) {
+    let name = `__tf${index}`;
+    while (originalText.includes(JSON.stringify(name))) name += "_";
+    const candidates = /* @__PURE__ */ new Map();
+    visit(result, (node2) => {
+      if (textOf(node2).length < 48 || !selfContained(node2) || !(totalBoolean(node2, /* @__PURE__ */ new Map()) || numeric(node2, /* @__PURE__ */ new Map()) || stringOutput(node2)))
+        return node2;
+      const key = textOf(node2);
+      const entry = candidates.get(key);
+      if (entry) entry.count += 1;
+      else candidates.set(key, { node: node2, count: 1 });
+      return node2;
+    });
+    const reference = ["var", name];
+    const referenceLength = JSON.stringify(reference).length;
+    const best = [...candidates.entries()].map(([key, entry]) => ({
+      key,
+      ...entry,
+      saving: (entry.count - 1) * key.length - entry.count * referenceLength - name.length - 8
+    })).filter(({ count, saving }) => count > 1 && saving > 0).sort((a, b) => b.saving - a.saving || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0))[0];
+    if (!best) break;
+    bindings.push(name, best.node);
+    result = visit(result, (node2) => textOf(node2) === best.key ? reference : node2);
+  }
+  if (!bindings.length) return value;
+  const shared = ["let", ...bindings, result];
+  return JSON.stringify(shared).length < originalText.length ? shared : value;
+}
+function stringOutput(value) {
+  if (typeof value === "string") return true;
+  if (!Array.isArray(value)) return false;
+  if (value[0] === "case")
+    return value.slice(1, -1).every(
+      (entry, index) => index % 2 === 0 ? totalBoolean(entry, /* @__PURE__ */ new Map()) : stringOutput(entry)
+    ) && stringOutput(value.at(-1));
+  if (value[0] === "match")
+    return totalValue(value[1], /* @__PURE__ */ new Map()) && value.filter((_, index) => index >= 3 && index % 2 === 1).every(stringOutput) && stringOutput(value.at(-1));
+  return false;
+}
+function selfContained(value) {
+  if (!isExpression(value) || value[0] === "literal") return true;
+  if (value[0] === "var" || value[0] === "let" || value[0] === "zoom") return false;
+  return value.slice(1).every(selfContained);
+}
+function visit(value, transform) {
+  if (!isExpression(value) || value[0] === "literal") return value;
+  const replaced = transform(value);
+  if (replaced !== value) return replaced;
+  let changed = false;
+  const children = value.map((entry, index) => {
+    if (value[0] === "match" && index >= 2 && index < value.length - 1 && index % 2 === 0)
+      return entry;
+    const child = isExpression(entry) ? visit(entry, transform) : entry;
+    changed ||= child !== entry;
+    return child;
+  });
+  return changed ? children : value;
+}
+function compactTileflowLayer(layer) {
+  const result = { ...layer };
+  for (const group of ["paint", "layout"]) {
+    const properties2 = layer[group];
+    if (properties2 && typeof properties2 === "object" && !Array.isArray(properties2))
+      Object.assign(result, {
+        [group]: Object.fromEntries(
+          Object.entries(properties2).map(([key, value]) => [
+            key,
+            // Asset discovery enumerates these outputs before resource preparation. Keep
+            // their branches visible instead of hiding an image/font choice in a binding.
+            /(?:image|pattern|font)$/u.test(key) ? compactTileflowExpression(value) : shareExpressions(compactTileflowExpression(value))
+          ])
+        )
+      });
+  }
+  return result;
+}
+
 // src/cartography/semantic-bindings.ts
 var completeSemanticDataContract = tileflowWorldV1Schema();
 var tileflowSemanticFieldNames = Object.freeze(
@@ -12222,7 +12640,7 @@ function materializeTileflowLayerFamilyIR(template, semantics) {
 }
 function lowerTileflowDomainIR(families, data, resolvePhysicalId = physicalLayerIdForSemanticKey) {
   const layers2 = families.map(
-    (family) => bindSemanticReferences(emitLayer(family, resolvePhysicalId), data)
+    (family) => compactTileflowLayer(bindSemanticReferences(emitLayer(family, resolvePhysicalId), data))
   );
   assertNoSemanticReferences(layers2);
   const ids = /* @__PURE__ */ new Set();
@@ -12272,6 +12690,7 @@ function emitLayer(family, resolvePhysicalId) {
 function physicalLayerIdForSemanticKey(semanticKey) {
   const exact = exactPhysicalLayerIds[semanticKey];
   if (exact) return exact;
+  if (semanticKey === "buildings.render.extrusion") return tileflowNativeBuildingsLayerId;
   let match3 = /^([A-Za-z0-9_-]+)\.render\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/u.exec(
     semanticKey
   );
@@ -12370,7 +12789,7 @@ function physicalLayerIdForSemanticKey(semanticKey) {
 var exactPhysicalLayerIds = Object.freeze({
   "addresses.labels": "tileflow-addresses-labels",
   "aeroways.runwayRef": "tileflow-aeroway-runway-ref",
-  "buildings.extrusion": "tileflow-buildings-3d",
+  "buildings.extrusion": tileflowNativeBuildingsLayerId,
   "labels.aerodrome": "tileflow-label-aerodrome",
   "labels.junctions": "tileflow-label-road-junction",
   "land.background": "tileflow-background",
@@ -14545,7 +14964,7 @@ function boundedThemeNumberSchema(min, max) {
     }).strict()
   ]);
 }
-var entranceBandSchema = z5.tuple([z5.number().finite().min(0).max(24), z5.number().finite().min(0).max(24)]).refine(([from, to]) => from < to, "A band starts at a lower zoom than it ends.");
+var entranceBandSchema = z5.tuple([z5.number().finite().min(0).max(24), z5.number().finite().min(0).max(24)]).refine(([from, to]) => from <= to, "A band cannot end before it starts.");
 var modelRoleLightingSchema = z5.object({
   emissiveStrength: boundedThemeNumberSchema(0, 5).optional(),
   emissiveVariation: boundedThemeNumberSchema(0, 1).optional(),
@@ -14605,7 +15024,7 @@ var buildingsModuleSchema = z5.object({
       lamp: modelRoleLightingSchema.optional(),
       logo: modelRoleLightingSchema.optional()
     }).strict().optional(),
-    entrance: z5.object({ buildings: entranceBandSchema.optional(), models: entranceBandSchema.optional() }).strict().optional(),
+    entrance: z5.object({ buildings: entranceBandSchema.optional(), models: entranceBandSchema.optional() }).strict().or(z5.literal(false)).optional(),
     flatFootprints: z5.boolean().optional(),
     occlusion: z5.boolean().optional(),
     groundOcclusion: boundedThemeNumberSchema(0, 1).optional(),
@@ -15644,7 +16063,13 @@ var systemThemesSchema = z5.object({ dark: tileflowThemeNameSchema, light: tilef
 var resolvedTileflowMapSchema = z5.object({
   atmosphere: atmosphereSchema.optional(),
   boundaryAreas: boundaryAreasSchema.optional(),
-  camera: z5.object({ adaptivePerspective: z5.boolean().optional() }).strict().optional(),
+  camera: z5.object({
+    adaptivePerspective: z5.boolean().optional(),
+    pitchLimit: z5.object({
+      maxZoom: z5.number().finite().min(0).max(24),
+      maxPitch: z5.number().finite().min(0).max(tileflowMaxPitch)
+    }).strict().optional()
+  }).strict().optional(),
   data: dataSchema.optional(),
   defaultTheme: tileflowThemeNameSchema,
   fonts: fontDirectoriesSchema.optional(),
@@ -15819,8 +16244,8 @@ function isSafeGlyphUrl(value) {
 function validateZoomRanges(value, context, path = []) {
   if (!value || typeof value !== "object") return;
   if (!Array.isArray(value)) {
-    const record5 = value;
-    if (typeof record5.minZoom === "number" && typeof record5.maxZoom === "number" && record5.minZoom > record5.maxZoom) {
+    const record7 = value;
+    if (typeof record7.minZoom === "number" && typeof record7.maxZoom === "number" && record7.minZoom > record7.maxZoom) {
       context.addIssue({
         code: "custom",
         path: [...path, "maxZoom"],
@@ -16472,7 +16897,7 @@ function applyTileflowIconCapabilities(style, icons) {
       "line-pattern",
       "background-pattern"
     ]) {
-      const pattern = record3(layer.paint)[property];
+      const pattern = record4(layer.paint)[property];
       if (pattern !== void 0 && [...outputs(pattern, ids)].some((id2) => appearances[id2]?.representation === "sdf")) {
         throw Object.assign(new Error(`Layer "${layer.id}" cannot use an SDF icon as a pattern.`), {
           code: "TF_ICON_PATTERN_SDF",
@@ -16481,7 +16906,7 @@ function applyTileflowIconCapabilities(style, icons) {
         });
       }
     }
-    const image = record3(layer.layout)["icon-image"];
+    const image = record4(layer.layout)["icon-image"];
     if (image === void 0) continue;
     if (typeof image === "string" && /\{[^{}]+\}/u.test(image) || typeof image !== "string" && !Array.isArray(image)) {
       throw Object.assign(new Error(`Layer "${layer.id}" has an unproven legacy icon selection.`), {
@@ -16503,7 +16928,7 @@ function applyTileflowIconCapabilities(style, icons) {
         }
       );
     }
-    const paint = { ...record3(layer.paint) };
+    const paint = { ...record4(layer.paint) };
     for (const [property, limit] of [
       ["icon-halo-width", 2],
       ["icon-halo-blur", 1]
@@ -16533,7 +16958,7 @@ function applyTileflowIconCapabilities(style, icons) {
     layer.paint = paint;
   }
 }
-function record3(value) {
+function record4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function outputs(value, ids) {
@@ -17390,6 +17815,15 @@ function combineConditionalValues(entries, fallback, minimumRelevantZoom) {
   if (allEqual(entries.map(({ value }) => value))) {
     return { ok: true, value: entries[0]?.value };
   }
+  const atMinimumZoom = (value) => {
+    if (!isZoomStep(value)) return value;
+    const step2 = value;
+    const lastStop = step2[step2.length - 2];
+    return typeof lastStop === "number" && lastStop <= minimumRelevantZoom ? evaluateZoomStep(value, minimumRelevantZoom) : value;
+  };
+  entries = entries.map(({ condition, value }) => ({ condition, value: atMinimumZoom(value) }));
+  fallback = atMinimumZoom(fallback);
+  if (allEqual(entries.map(({ value }) => value))) return { ok: true, value: entries[0].value };
   const letValues = entries.map(
     ({ value }) => Array.isArray(value) && value.length === 4 && value[0] === "let" ? value : void 0
   );
@@ -17555,7 +17989,8 @@ function classMatchLabelsAreDisjoint(labels2) {
   return true;
 }
 function splitClassMatch(condition) {
-  const parts = condition[0] === "all" ? condition.slice(1) : [condition];
+  const conjuncts = (value) => Array.isArray(value) && value[0] === "all" ? value.slice(1).flatMap(conjuncts) : [value];
+  const parts = conjuncts(condition);
   const matchIndex = parts.findIndex(
     (part) => Array.isArray(part) && part.length === 5 && part[0] === "match" && Array.isArray(part[1]) && part[1][0] === "get" && part[1][1] !== void 0 && part.at(-2) === true && part.at(-1) === false
   );
@@ -17694,8 +18129,7 @@ function stableSerialize(value) {
 
 // src/cartography/scene-3d-metadata.ts
 var colourSources = [
-  ["tileflow-buildings-render-extrusion", "fill-extrusion-color"],
-  ["tileflow-buildings-3d", "fill-extrusion-color"],
+  [tileflowNativeBuildingsLayerId, "fill-extrusion-color"],
   ["tileflow-buildings-fill", "fill-color"]
 ];
 function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, tileflowLandmarks) {
@@ -17718,7 +18152,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
     return typeof resolved === "number" ? resolved : fallback;
   };
   const edgeColor = style.edgeColor === void 0 ? void 0 : toMapLibreStyleValue(style.edgeColor);
-  const surfaces = isRecord10(style.surfaces) ? readTileflowBuildingSurfaces(
+  const surfaces = isRecord10(style.surfaces) ? mapColorProgramsThrough(
     Object.fromEntries(
       Object.entries(style.surfaces).map(([key, entry]) => [
         key,
@@ -17729,7 +18163,8 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
           ])
         ) : entry
       ])
-    )
+    ),
+    readTileflowBuildingSurfaces
   ) : void 0;
   return {
     source: context.data.sourceId,
@@ -17743,18 +18178,21 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
     verticalGradient,
     edges: number(style.edges, 0),
     edgeRadius: number(style.edgeRadius, defaults4.edgeRadius),
-    ...typeof edgeColor === "string" ? { edgeColor } : {},
+    ...typeof edgeColor === "string" || isColorProgramMarker(edgeColor) ? { edgeColor } : {},
     nightLight: number(style.nightLight, 0),
     ...isRecord10(style.floodLight) ? {
-      floodLight: readBuildingFloodLight({
-        ...style.floodLight,
-        intensity: number(style.floodLight.intensity, 0),
-        brightnessScale: number(style.floodLight.brightnessScale, 1),
-        color: style.floodLight.color === void 0 ? void 0 : toMapLibreStyleValue(style.floodLight.color)
-      })
+      floodLight: mapColorProgramsThrough(
+        {
+          ...style.floodLight,
+          intensity: number(style.floodLight.intensity, 0),
+          brightnessScale: number(style.floodLight.brightnessScale, 1),
+          color: style.floodLight.color === void 0 ? void 0 : toMapLibreStyleValue(style.floodLight.color)
+        },
+        readBuildingFloodLight
+      )
     } : {},
     ...isRecord10(style.modelLighting) ? {
-      modelLighting: readModelRoleLighting(
+      modelLighting: mapColorProgramsThrough(
         Object.fromEntries(
           Object.entries(style.modelLighting).filter(([, entry]) => isRecord10(entry)).map(([role, entry]) => {
             const own = entry;
@@ -17785,7 +18223,8 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
               }
             ];
           })
-        )
+        ),
+        readModelRoleLighting
       )
     } : {},
     windows: style.windows === true,
@@ -17839,7 +18278,8 @@ function modelColours(value) {
   const colours = {};
   for (const [part, colour] of Object.entries(value)) {
     const resolved = colour === void 0 ? void 0 : toMapLibreStyleValue(colour);
-    if (typeof resolved === "string") colours[part] = resolved;
+    if (typeof resolved === "string" || isColorProgramMarker(resolved))
+      colours[part] = resolved;
   }
   return Object.keys(colours).length > 0 ? { modelColors: colours } : {};
 }
@@ -17860,7 +18300,7 @@ function tileflowStreetLightsDesignOf(module, context) {
       ...layers2.sidewalk ? { sidewalk: layers2.sidewalk } : {}
     },
     estimate: estimate === "streets" || estimate === "none" || estimate === "lit" ? estimate : "lit",
-    color: typeof color2 === "string" ? color2 : tileflowDefaultStreetLightsDesign.color,
+    color: typeof color2 === "string" || isColorProgramMarker(color2) ? color2 : tileflowDefaultStreetLightsDesign.color,
     intensity: typeof intensity === "number" ? intensity : 1
   };
 }
@@ -17908,7 +18348,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     "theme",
     () => resolveThemeValues(themeableConfig, selected.theme, `map.${input.id}`)
   );
-  const config = runCompilationPhase(
+  let config = runCompilationPhase(
     "config-validation",
     () => parseResolvedTileflowMap({
       ...resolvedThemeConfig,
@@ -17916,6 +18356,11 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       themes: input.themes
     })
   );
+  if (options.runtimeColors)
+    config = {
+      ...config,
+      modules: preserveThemeColorPrograms(input.modules, config.modules, selected.theme)
+    };
   const apiBaseUrl = normalizeBaseUrl(options.apiBaseUrl);
   const data = runCompilationPhase("data", () => resolveTileflowData(config.data, { apiBaseUrl }));
   const marine = runCompilationPhase("data", () => resolveMarine(config.marine, apiBaseUrl));
@@ -18008,7 +18453,8 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     "theme",
     () => resolveThemeColors(
       selected.theme,
-      onReport ? (decision) => colorDecisions.push(decision) : void 0
+      onReport ? (decision) => colorDecisions.push(decision) : void 0,
+      options.runtimeColors
     )
   );
   const images = runCompilationPhase("theme", () => resolveThemeImages(selected.theme));
@@ -18310,7 +18756,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
     marine?.nautical?.sourceId,
     tileflowNauticalV1Schema.layers.lights
   );
-  const style = {
+  let style = {
     ...sky ? { sky: compileTileflowStreetSky(sky, Boolean(atmosphere)) } : atmosphere ? { sky: compileTileflowSky(atmosphere) } : {},
     version: 8,
     name: config.name ?? "Streets",
@@ -18366,16 +18812,73 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       [tileflowOverlayPlacementManifestMetadataKey]: overlayPlacementManifest,
       "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord11(module) || module.enabled !== false).map(([name]) => name).sort(),
       ...config.view ? { "tileflow:view": config.view } : {},
-      ...config.camera?.adaptivePerspective !== void 0 ? {
+      ...config.camera?.adaptivePerspective !== void 0 || config.camera?.pitchLimit !== void 0 ? {
         [tileflowCameraMetadataKey]: {
           version: 1,
-          adaptivePerspective: config.camera.adaptivePerspective
+          ...config.camera
         }
       } : {},
       ...notices.length > 0 ? { [tileflowNoticesMetadataKey]: notices } : {},
       ...nauticalLights ? { [tileflowNauticalLightsMetadataKey]: nauticalLights } : {}
     }
   };
+  if (options.runtimeColors) {
+    const theme = selected.theme;
+    if (style.light)
+      style.light = preserveThemeColorPrograms(
+        { color: theme.lighting.sun?.color ?? theme.lighting.color },
+        style.light,
+        theme,
+        true
+      );
+    const authoredSky = typeof input.sky === "object" ? input.sky : void 0;
+    if (style.sky && authoredSky)
+      style.sky = preserveThemeColorPrograms(
+        {
+          "sky-color": authoredSky.color,
+          "horizon-color": authoredSky.horizonColor,
+          "fog-color": authoredSky.horizonColor
+        },
+        style.sky,
+        theme,
+        true
+      );
+    if (style.metadata) {
+      style.metadata["tileflow:sun"] = preserveThemeColorPrograms(
+        { color: theme.lighting.sun?.color, ambient: { color: theme.lighting.ambient?.color } },
+        style.metadata["tileflow:sun"],
+        theme,
+        true
+      );
+      if (authoredSky)
+        style.metadata["tileflow:sky"] = preserveThemeColorPrograms(
+          {
+            glowColor: authoredSky.glowColor,
+            timesOfDay: Object.fromEntries(
+              ["day", "night", "dawn", "dusk"].map((moment) => [moment, authoredSky])
+            )
+          },
+          style.metadata["tileflow:sky"],
+          theme,
+          true
+        );
+      const route = Object.fromEntries(
+        ["line", "casing", "core", "glow", "alternative"].filter((key) => Object.hasOwn(theme.tokens.color, `route.${key}`)).map((key) => [key, { kind: "theme-token", category: "color", token: `route.${key}` }])
+      );
+      style.metadata["tileflow:route"] = preserveThemeColorPrograms(
+        route,
+        style.metadata["tileflow:route"],
+        theme,
+        true
+      );
+      for (const key of Object.keys(style.metadata))
+        if (style.metadata[key] === void 0) delete style.metadata[key];
+    }
+    style = extractTileflowColorPrograms(style, {
+      color: theme.tokens.color,
+      number: theme.tokens.number
+    });
+  }
   const report = {
     ...partialReport,
     ...onReport ? {
@@ -18657,8 +19160,8 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record5 = isRecord11(error) ? error : {};
-  if (typeof record5.phase === "string") return error;
+  const record7 = isRecord11(error) ? error : {};
+  if (typeof record7.phase === "string") return error;
   if (error instanceof Error && Object.isExtensible(error)) {
     Object.defineProperty(error, "phase", { configurable: true, enumerable: true, value: phase });
     return error;
@@ -18674,7 +19177,7 @@ function withCompilationPhase(error, phase) {
     "severity",
     "target"
   ]) {
-    if (record5[key] !== void 0) Object.assign(wrapped, { [key]: record5[key] });
+    if (record7[key] !== void 0) Object.assign(wrapped, { [key]: record7[key] });
   }
   Object.assign(wrapped, { phase });
   return wrapped;
@@ -18781,6 +19284,7 @@ function createTileflowRuntimeManifestSchema(primitives, operations, identities
       apiUrl: operations.optional(apiOriginSchema),
       defaultTheme: tileflowThemeNameSchema2,
       environment: operations.optional(operations.maxLength(safeTextSchema, 128)),
+      familyUrl: operations.optional(publicResourceUrlSchema),
       mapId: operations.optional(operations.maxLength(safeTextSchema, 128)),
       systemThemes: operations.optional(
         operations.object({
@@ -18862,11 +19366,20 @@ function createTileflowRuntimeManifestSchema(primitives, operations, identities
       maps: operations.record(tileflowPortableIdSchema2, manifestMapSchema),
       version: operations.union(
         operations.literal(tileflowRuntimeManifestVersion),
-        operations.literal(2)
+        operations.union(operations.literal(2), operations.literal(3))
       )
     }),
     (manifest, context) => {
       const mapCount = Object.keys(manifest.maps).length;
+      if (manifest.version !== 3)
+        for (const [name, map] of Object.entries(manifest.maps)) {
+          if (map.familyUrl !== void 0)
+            context.addIssue({
+              code: "custom",
+              message: "familyUrl requires manifest version 3",
+              path: ["maps", name, "familyUrl"]
+            });
+        }
       if (manifest.version === 1) {
         for (const [name, map] of Object.entries(manifest.maps)) {
           if (map.timeOfDay !== void 0)
@@ -19706,6 +20219,473 @@ function isPlainRecord5(value) {
   return prototype === Object.prototype || prototype === null;
 }
 
+// src/style-family.ts
+var tileflowStyleFamilyLimits = Object.freeze({
+  themes: 64,
+  documentBytes: 16 * 1024 * 1024,
+  expandedStyleBytes: 8 * 1024 * 1024,
+  expandedFamilyBytes: 32 * 1024 * 1024,
+  layers: 4096,
+  nodes: 5e5,
+  depth: 96
+});
+function createTileflowStyleFamily(styles) {
+  const themes = Object.keys(styles).sort();
+  if (!themes.length || themes.length > tileflowStyleFamilyLimits.themes || themes.some((name) => !isTileflowThemeName(name)))
+    fail("Invalid theme names.");
+  const parameters = [];
+  const columns = /* @__PURE__ */ new Map();
+  const add2 = (values) => {
+    const key = serializeCanonicalJson(values);
+    let index = columns.get(key);
+    if (index === void 0) {
+      index = parameters.length;
+      columns.set(key, index);
+      parameters.push(values);
+    }
+    return { $variant: index };
+  };
+  const factor = (values) => {
+    const first = values[0];
+    if (values.some((value) => isReference(value) || isConstantReference(value)))
+      return add2(values);
+    if (Array.isArray(first) && values.every((v) => Array.isArray(v) && v.length === first.length))
+      return first.map((_, index) => factor(values.map((v) => v[index])));
+    if (record5(first) && values.every((v) => record5(v) && same(Object.keys(v).sort(), Object.keys(first).sort())))
+      return Object.fromEntries(
+        Object.keys(first).sort().map((key) => [key, factor(values.map((v) => v[key]))])
+      );
+    if (values.every((v) => same(v, first))) return first;
+    return add2(values);
+  };
+  const documents = themes.map((name) => JSON.parse(serializeCanonicalJson(styles[name])));
+  for (const document of documents) assertStyle(document);
+  const template = factor(documents);
+  const packed = shareConstants(template);
+  const family = {
+    kind: "tileflow-style-family",
+    version: 1,
+    themes,
+    template: packed.template,
+    constants: packed.constants,
+    parameters,
+    updates: planUpdates(template)
+  };
+  return parseTileflowStyleFamily(family);
+}
+function parseTileflowStyleFamily(input) {
+  assertJsonBudget(input);
+  if (!record5(input) || !same(Object.keys(input).sort(), [
+    "constants",
+    "kind",
+    "parameters",
+    "template",
+    "themes",
+    "updates",
+    "version"
+  ]) || input.kind !== "tileflow-style-family" || input.version !== 1 || !Array.isArray(input.themes) || !input.themes.length || input.themes.length > tileflowStyleFamilyLimits.themes || input.themes.some((name) => typeof name !== "string" || !isTileflowThemeName(name)) || new Set(input.themes).size !== input.themes.length || !Array.isArray(input.parameters) || !Array.isArray(input.constants))
+    fail("Invalid family document.");
+  const family = input;
+  if (bytes(input) > tileflowStyleFamilyLimits.documentBytes) fail("Family document is too large.");
+  for (const values of family.parameters)
+    if (!Array.isArray(values) || values.length !== family.themes.length)
+      fail("Invalid parameter column.");
+  walk(family.template, (value) => {
+    if (isReference(value) && (!Number.isSafeInteger(value.$variant) || value.$variant < 0 || value.$variant >= family.parameters.length))
+      fail("Invalid parameter reference.");
+    if (isConstantReference(value) && (!Number.isSafeInteger(value.$constant) || value.$constant < 0 || value.$constant >= family.constants.length))
+      fail("Invalid constant reference.");
+  });
+  let total = 0;
+  const sizes = family.parameters.map((column) => column.map(bytes));
+  const constants = family.constants.map(bytes);
+  for (let index = 0; index < family.themes.length; index += 1) {
+    const size = expandedBytes(family.template, sizes, constants, index);
+    total += size;
+    if (size > tileflowStyleFamilyLimits.expandedStyleBytes || total > tileflowStyleFamilyLimits.expandedFamilyBytes)
+      fail("Expanded family is too large.");
+    const style = materialize(family.template, family, index);
+    assertJsonBudget(style);
+    assertStyle(style);
+  }
+  if (!same(family.updates, planUpdates(expandTileflowFamilyTemplate(family))))
+    fail("Invalid update plan.");
+  return family;
+}
+function materializeTileflowStyleFamily(family, theme) {
+  const index = family.themes.indexOf(theme);
+  if (index < 0) fail(`Unknown family theme: ${theme}.`);
+  return materialize(family.template, family, index);
+}
+function expandTileflowStyleFamily(input) {
+  const family = parseTileflowStyleFamily(input);
+  return Object.fromEntries(
+    family.themes.map((name) => [name, materializeTileflowStyleFamily(family, name)])
+  );
+}
+function materialize(node2, family, index) {
+  if (isReference(node2)) return structuredClone(family.parameters[node2.$variant][index]);
+  if (isConstantReference(node2)) return structuredClone(family.constants[node2.$constant]);
+  if (Array.isArray(node2)) return node2.map((value) => materialize(value, family, index));
+  if (record5(node2))
+    return Object.fromEntries(
+      Object.entries(node2).map(([key, value]) => [key, materialize(value, family, index)])
+    );
+  return node2;
+}
+function planUpdates(template) {
+  let appearanceOnly = true;
+  const paint = /* @__PURE__ */ new Map();
+  const roots = /* @__PURE__ */ new Set();
+  walk(template, (node2, path) => {
+    if (!isReference(node2)) return;
+    if (path[0] === "name") return;
+    if (path[0] === "metadata") {
+      const key = path[1];
+      if ([
+        "tileflow:colors",
+        "tileflow:family-image-theme",
+        "tileflow:theme",
+        "tileflow:colorScheme",
+        "tileflow:sun",
+        "tileflow:route",
+        "tileflow:sky",
+        "tileflow:sourceRequirements",
+        "tileflow:dataRequirements"
+      ].includes(String(key)))
+        return;
+      if (key === "tileflow:buildings" && ["color", "modelColors", "modelLighting", "floodLight"].includes(String(path[2])))
+        return;
+      if (key === "tileflow:vegetation" && path[2] === "colors") return;
+      appearanceOnly = false;
+      return;
+    }
+    if (path[0] === "layers" && path[2] === "layout" && path[3] === "icon-image") return;
+    if (path[0] === "sky" || path[0] === "light") {
+      roots.add(path[0]);
+      return;
+    }
+    if (path[0] === "layers" && typeof path[1] === "number" && path[2] === "paint" && typeof path[3] === "string") {
+      paint.set(`${path[1]}/${path[3]}`, [path[1], path[3]]);
+    } else appearanceOnly = false;
+  });
+  if (record5(template) && record5(template.metadata) && template.metadata["tileflow:colors"] && Array.isArray(template.layers))
+    template.layers.forEach((layer, index) => {
+      if (record5(layer) && record5(layer.paint)) {
+        for (const property of Object.keys(layer.paint))
+          if (property.endsWith("color")) paint.set(`${index}/${property}`, [index, property]);
+      }
+    });
+  return { appearanceOnly, paint: [...paint.values()], roots: [...roots].sort() };
+}
+function expandedBytes(node2, sizes, constants, index) {
+  if (isReference(node2)) return sizes[node2.$variant][index];
+  if (isConstantReference(node2)) return constants[node2.$constant];
+  if (Array.isArray(node2))
+    return 2 + Math.max(0, node2.length - 1) + node2.reduce((n, v) => n + expandedBytes(v, sizes, constants, index), 0);
+  if (record5(node2))
+    return 2 + Math.max(0, Object.keys(node2).length - 1) + Object.entries(node2).reduce(
+      (n, [key, v]) => n + bytes(key) + 1 + expandedBytes(v, sizes, constants, index),
+      0
+    );
+  return bytes(node2);
+}
+function assertStyle(style) {
+  if (!record5(style) || style.version !== 8 || !record5(style.sources) || !Array.isArray(style.layers) || style.layers.length > tileflowStyleFamilyLimits.layers)
+    fail("Invalid expanded MapLibre style.");
+  const ids = /* @__PURE__ */ new Set();
+  for (const layer of style.layers) {
+    if (!record5(layer) || typeof layer.id !== "string" || ids.has(layer.id) || typeof layer.type !== "string")
+      fail("Invalid or duplicate layer.");
+    ids.add(layer.id);
+  }
+}
+function assertJsonBudget(input) {
+  let nodes = 0;
+  const stack = /* @__PURE__ */ new Set();
+  const visit2 = (value, depth) => {
+    if (++nodes > tileflowStyleFamilyLimits.nodes || depth > tileflowStyleFamilyLimits.depth)
+      fail("Family complexity limit exceeded.");
+    if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
+      return;
+    if (typeof value !== "object" || !value || stack.has(value)) fail("Expected acyclic JSON.");
+    stack.add(value);
+    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+      fail("Expected JSON objects.");
+    for (const [key, item] of Object.entries(value)) {
+      if (["__proto__", "constructor", "prototype"].includes(key)) fail("Unsafe object key.");
+      visit2(item, depth + 1);
+    }
+    stack.delete(value);
+  };
+  visit2(input, 0);
+}
+function walk(node2, visit2, path = []) {
+  visit2(node2, path);
+  if (isReference(node2) || isConstantReference(node2)) return;
+  if (Array.isArray(node2)) node2.forEach((value, i) => walk(value, visit2, [...path, i]));
+  else if (record5(node2))
+    Object.entries(node2).forEach(([key, value]) => walk(value, visit2, [...path, key]));
+}
+function isReference(node2) {
+  return record5(node2) && Object.keys(node2).length === 1 && Object.hasOwn(node2, "$variant");
+}
+function isConstantReference(node2) {
+  return record5(node2) && Object.keys(node2).length === 1 && Object.hasOwn(node2, "$constant");
+}
+function expandTileflowFamilyTemplate(family) {
+  const visit2 = (node2) => {
+    if (isConstantReference(node2)) return structuredClone(family.constants[node2.$constant]);
+    if (isReference(node2)) return node2;
+    if (Array.isArray(node2)) return node2.map(visit2);
+    if (record5(node2))
+      return Object.fromEntries(
+        Object.entries(node2).map(([key, value]) => [key, visit2(value)])
+      );
+    return node2;
+  };
+  return visit2(family.template);
+}
+function withTileflowFamilyTemplate(family, template) {
+  assertJsonBudget(template);
+  const packed = shareConstants(template);
+  return parseTileflowStyleFamily({
+    ...family,
+    template: packed.template,
+    constants: packed.constants
+  });
+}
+function shareConstants(template) {
+  const counts = /* @__PURE__ */ new Map();
+  const keys = /* @__PURE__ */ new WeakMap();
+  const inspect = (node2) => {
+    if (isReference(node2) || isConstantReference(node2)) return false;
+    if (!node2 || typeof node2 !== "object") return true;
+    const children = Array.isArray(node2) ? node2 : Object.values(node2);
+    const constant = children.map(inspect).every(Boolean);
+    if (constant) {
+      const key = JSON.stringify(node2);
+      if (key.length >= 96) {
+        keys.set(node2, key);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+      }
+    }
+    return constant;
+  };
+  inspect(template);
+  const constants = [];
+  const ids = /* @__PURE__ */ new Map();
+  const pack = (node2) => {
+    if (!node2 || typeof node2 !== "object" || isReference(node2)) return node2;
+    const key = keys.get(node2);
+    if (key && counts.get(key) > 1) {
+      let index = ids.get(key);
+      if (index === void 0) {
+        index = constants.length;
+        ids.set(key, index);
+        constants.push(node2);
+      }
+      return { $constant: index };
+    }
+    if (Array.isArray(node2)) return node2.map(pack);
+    return Object.fromEntries(
+      Object.entries(node2).map(([key2, value]) => [key2, pack(value)])
+    );
+  };
+  return { template: pack(template), constants };
+}
+function record5(node2) {
+  return !!node2 && typeof node2 === "object" && !Array.isArray(node2);
+}
+function same(a, b) {
+  return serializeCanonicalJson(a) === serializeCanonicalJson(b);
+}
+function serializeCanonicalJson(value) {
+  const sort = (node2) => Array.isArray(node2) ? node2.map(sort) : record5(node2) ? Object.fromEntries(
+    Object.keys(node2).sort().map((key) => [key, sort(node2[key])])
+  ) : node2;
+  return JSON.stringify(sort(value));
+}
+function bytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+function fail(message) {
+  throw new TypeError(`Tileflow style family: ${message}`);
+}
+
+// src/family-deployment.ts
+function compactTileflowDeploymentArtifact(input) {
+  const artifact = object(input);
+  if (artifact.kind !== "tileflow-map-deployment") throw new TypeError("Invalid deployment kind.");
+  if (artifact.schemaVersion === 1) {
+    const { styles, ...rest } = artifact;
+    return {
+      ...rest,
+      ...compactRequirements(rest.buildManifest),
+      schemaVersion: 3,
+      family: createTileflowStyleFamily(object(styles))
+    };
+  }
+  if (artifact.schemaVersion === 2) {
+    const renderers = object(artifact.renderers);
+    const { styles, ...web } = object(renderers.web);
+    return {
+      ...artifact,
+      schemaVersion: 4,
+      renderers: {
+        ...renderers,
+        web: {
+          ...web,
+          ...compactRequirements(web.buildManifest),
+          family: createTileflowStyleFamily(object(styles))
+        }
+      }
+    };
+  }
+  throw new TypeError("Expected deployment schema version 1 or 2.");
+}
+function expandTileflowDeploymentArtifact(input) {
+  const artifact = object(input);
+  if (artifact.schemaVersion === 3) {
+    if (Object.hasOwn(artifact, "styles"))
+      throw new TypeError("A compact deployment cannot include flat styles.");
+    const { family, sharedRequirements, ...rest } = artifact;
+    return {
+      ...rest,
+      buildManifest: expandRequirements(rest.buildManifest, sharedRequirements),
+      schemaVersion: 1,
+      styles: expandTileflowStyleFamily(family)
+    };
+  }
+  if (artifact.schemaVersion === 4) {
+    const renderers = object(artifact.renderers);
+    const web = object(renderers.web);
+    if (Object.hasOwn(web, "styles"))
+      throw new TypeError("A compact deployment cannot include flat web styles.");
+    const { family, sharedRequirements, ...rest } = web;
+    return {
+      ...artifact,
+      schemaVersion: 2,
+      renderers: {
+        ...renderers,
+        web: {
+          ...rest,
+          buildManifest: expandRequirements(rest.buildManifest, sharedRequirements),
+          styles: expandTileflowStyleFamily(family)
+        }
+      }
+    };
+  }
+  return input;
+}
+var requirementKeys = ["dataRequirements", "sourceRequirements"];
+function compactRequirements(input) {
+  const manifest = object(input);
+  const sharedRequirements = {};
+  const maps = Object.fromEntries(
+    Object.entries(object(manifest.maps)).map(([name, raw]) => {
+      const map = object(raw);
+      const themes = Object.entries(object(map.themes));
+      const common = {};
+      for (const key of requirementKeys) {
+        const frequencies = /* @__PURE__ */ new Map();
+        for (const [, rawTheme] of themes) {
+          const value = object(rawTheme)[key];
+          if (value === void 0) continue;
+          const serialized = JSON.stringify(value);
+          const entry = frequencies.get(serialized) ?? { value, count: 0 };
+          entry.count += 1;
+          frequencies.set(serialized, entry);
+        }
+        const frequent = [...frequencies.values()].sort((a, b) => b.count - a.count)[0];
+        if (frequent && frequent.count > 1 && themes.every(([, theme]) => Object.hasOwn(object(theme), key)))
+          common[key] = frequent.value;
+      }
+      if (!Object.keys(common).length) return [name, map];
+      sharedRequirements[name] = common;
+      return [
+        name,
+        {
+          ...map,
+          themes: Object.fromEntries(
+            themes.map(([theme, value]) => [
+              theme,
+              Object.fromEntries(
+                Object.entries(object(value)).filter(
+                  ([key, field2]) => !Object.hasOwn(common, key) || JSON.stringify(field2) !== JSON.stringify(common[key])
+                )
+              )
+            ])
+          )
+        }
+      ];
+    })
+  );
+  return {
+    buildManifest: { ...manifest, maps },
+    ...Object.keys(sharedRequirements).length ? { sharedRequirements } : {}
+  };
+}
+function expandRequirements(input, shared) {
+  if (shared === void 0) return input;
+  const manifest = object(input);
+  const maps = { ...object(manifest.maps) };
+  let expandedBytes2 = 0;
+  for (const [name, raw] of Object.entries(object(shared))) {
+    if (!Object.hasOwn(maps, name))
+      throw new TypeError("Shared requirements refer to an unknown map.");
+    const map = object(maps[name]);
+    const common = object(raw);
+    if (!Object.keys(common).length || Object.keys(common).some(
+      (key) => !requirementKeys.includes(key)
+    ))
+      throw new TypeError("Invalid shared requirements.");
+    const themes = Object.entries(object(map.themes));
+    if (!themes.length || themes.length > 64)
+      throw new TypeError("Invalid requirement theme count.");
+    expandedBytes2 += new TextEncoder().encode(JSON.stringify(common)).length * themes.length;
+    if (expandedBytes2 > 8 * 1024 * 1024)
+      throw new TypeError("Expanded requirements are too large.");
+    maps[name] = {
+      ...map,
+      themes: Object.fromEntries(
+        themes.map(([theme, rawTheme]) => {
+          const value = object(rawTheme);
+          return [theme, { ...common, ...value }];
+        })
+      )
+    };
+  }
+  return { ...manifest, maps };
+}
+function tileflowDeploymentWebBytes(input) {
+  const { iconComposition: _receipt, ...body } = object(input);
+  const source = object(body.artifact);
+  const artifact = source.schemaVersion === 2 || source.schemaVersion === 4 ? {
+    kind: source.kind,
+    schemaVersion: source.schemaVersion === 4 ? 3 : 1,
+    mapId: source.mapId,
+    teamSources: source.teamSources,
+    ...object(object(source.renderers).web)
+  } : { ...source };
+  const buildManifest = object(artifact.buildManifest);
+  const maps = Object.fromEntries(
+    Object.entries(object(buildManifest.maps)).map(([name, raw]) => {
+      const map = object(raw);
+      const { iconComposition: _embedded, ...sourceAssets } = object(map.sourceAssets);
+      return [name, { ...map, sourceAssets }];
+    })
+  );
+  return new TextEncoder().encode(
+    JSON.stringify({ ...body, artifact: { ...artifact, buildManifest: { ...buildManifest, maps } } })
+  ).length;
+}
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError("Expected a deployment object.");
+  return value;
+}
+
 // src/icon-composition.ts
 import { z as z11 } from "zod";
 
@@ -19838,13 +20818,13 @@ function compareCodeUnits8(left, right) {
   }
   return 0;
 }
-function serializeCanonicalJson(value) {
+function serializeCanonicalJson2(value) {
   return JSON.stringify(sortJsonValue(value));
 }
 async function sha256Hex(input) {
-  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
-  const digestInput = new Uint8Array(bytes.byteLength);
-  digestInput.set(bytes);
+  const bytes2 = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const digestInput = new Uint8Array(bytes2.byteLength);
+  digestInput.set(bytes2);
   const digest = await crypto.subtle.digest("SHA-256", digestInput.buffer);
   return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
@@ -19999,7 +20979,7 @@ var tileflowIconCompositionSchema = z11.object({
       message: "Winners must exactly cover the sorted last-wins export closure"
     });
   }
-  if (new TextEncoder().encode(serializeCanonicalJson(receipt)).byteLength > tileflowIconCompositionMaximumBytes) {
+  if (new TextEncoder().encode(serializeCanonicalJson2(receipt)).byteLength > tileflowIconCompositionMaximumBytes) {
     context.addIssue({ code: "custom", message: "Composition receipt exceeds its byte limit" });
   }
 });
@@ -20091,7 +21071,7 @@ async function normalizeCompiledThemes(map, styles) {
           colorScheme: theme.colorScheme,
           dataRequirements: inferTileflowDataRequirements(style),
           sourceRequirements: inferTileflowSourceRequirements(style),
-          styleSha256: await sha256Hex(serializeCanonicalJson(style)),
+          styleSha256: await sha256Hex(serializeCanonicalJson2(style)),
           themeId: theme.id,
           themeVersion: theme.version
         }
@@ -20147,7 +21127,7 @@ async function hashTileflowMapRevision(input, sourceAssets) {
     sourceAssets: normalizedSources
   };
   const domain = normalizedSources.iconComposition ? "tileflow-map-revision-v2\0" : tileflowMapRevisionDomain;
-  return sha256Hex(`${domain}${serializeCanonicalJson(revisionDocument)}`);
+  return sha256Hex(`${domain}${serializeCanonicalJson2(revisionDocument)}`);
 }
 function normalizeRevisionCartography(input) {
   if (!input.sources) return input;
@@ -20194,7 +21174,7 @@ async function hashTileflowAssetSetIdentities(input) {
       sha256: asset.sha256
     };
   });
-  return sha256Hex(`${tileflowAssetSetDomain}${serializeCanonicalJson({ files, schemaVersion: 1 })}`);
+  return sha256Hex(`${tileflowAssetSetDomain}${serializeCanonicalJson2({ files, schemaVersion: 1 })}`);
 }
 function normalizeLineage(input, map) {
   if (input.length === 0 || input[0]?.id !== map.id || input[0].mapVersion !== map.version) {
@@ -20280,7 +21260,7 @@ function assertIconCompositionMatchesMap(map, sources) {
     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 || serializeCanonicalJson(identity.appearance ?? null) !== serializeCanonicalJson(winner.appearance ?? null) || serializeCanonicalJson(identity.layout ?? null) !== serializeCanonicalJson(winner.layout ?? null))
+      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 || serializeCanonicalJson2(identity.appearance ?? null) !== serializeCanonicalJson2(winner.appearance ?? null) || serializeCanonicalJson2(identity.layout ?? null) !== serializeCanonicalJson2(winner.layout ?? null))
         throw new Error("Shared icon identity must match verified pixels, appearance and layout");
     } else if (identity.kind === "rendered-icon")
       throw new Error("Local originals must retain their existing source identity");
@@ -20413,7 +21393,7 @@ function isBoundedNativeJson(input, stage = "input") {
   let stringBytes = 0;
   const ancestors = /* @__PURE__ */ new Set();
   const encoder = new TextEncoder();
-  const visit = (value, depth) => {
+  const visit2 = (value, depth) => {
     if (++nodes > limits.maximumNodes || depth > limits.maximumDepth) {
       return false;
     }
@@ -20436,7 +21416,7 @@ function isBoundedNativeJson(input, stage = "input") {
     for (const key of keys) {
       if (Array.isArray(value) && key === "length") continue;
       const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      if (!descriptor || !descriptor.enumerable || !("value" in descriptor) || !visit(key, depth + 1) || !visit(descriptor.value, depth + 1)) {
+      if (!descriptor || !descriptor.enumerable || !("value" in descriptor) || !visit2(key, depth + 1) || !visit2(descriptor.value, depth + 1)) {
         return false;
       }
     }
@@ -20444,7 +21424,7 @@ function isBoundedNativeJson(input, stage = "input") {
     return true;
   };
   try {
-    return visit(input, 0) && encoder.encode(JSON.stringify(input)).byteLength <= limits.maximumStyleBytes;
+    return visit2(input, 0) && encoder.encode(JSON.stringify(input)).byteLength <= limits.maximumStyleBytes;
   } catch {
     return false;
   }
@@ -20526,9 +21506,9 @@ var tileflowNativeBuildRecordSchema = strictNativeObject({
   engines: strictNativeObject({ android: z13.literal("13.2.0"), ios: z13.literal("6.26.0") }),
   buildManifestSha256: hashSchema,
   transformations: z13.array(tileflowNativeStyleTransformationSchema).max(4096)
-}).superRefine((record5, context) => {
+}).superRefine((record7, context) => {
   let previous = "";
-  for (const [index, item] of record5.transformations.entries()) {
+  for (const [index, item] of record7.transformations.entries()) {
     const name = `${item.map}/${item.theme}`;
     if (name <= previous)
       context.addIssue({
@@ -20541,7 +21521,7 @@ var tileflowNativeBuildRecordSchema = strictNativeObject({
 });
 
 // src/native-profile.ts
-import { isExpression, validateStyleMin as validateStyleMin2 } from "@maplibre/maplibre-gl-style-spec";
+import { isExpression as isExpression2, validateStyleMin as validateStyleMin2 } from "@maplibre/maplibre-gl-style-spec";
 
 // ../../node_modules/.pnpm/@maplibre+maplibre-gl-style-spec@24.8.5/node_modules/@maplibre/maplibre-gl-style-spec/dist/latest.json
 var latest_default = {
@@ -29231,13 +30211,13 @@ function validateNativeStyle(input, options, stage) {
       issues.push(createTileflowNativeDiagnostic(code, path));
     }
   };
-  if (!record4(options) || !plainOptions(options)) {
+  if (!record6(options) || !plainOptions(options)) {
     return [createTileflowNativeDiagnostic("NATIVE_RENDERER_UNSUPPORTED", "/profile")];
   }
   if (options.profile !== void 0 && options.profile !== "native-v1" || !expressionDefinitions) {
     return [createTileflowNativeDiagnostic("NATIVE_RENDERER_UNSUPPORTED", "/profile")];
   }
-  if (!isBoundedNativeJson(input, stage) || !record4(input)) {
+  if (!isBoundedNativeJson(input, stage) || !record6(input)) {
     return [createTileflowNativeDiagnostic("NATIVE_UNSUPPORTED_STYLE")];
   }
   const style = input;
@@ -29251,11 +30231,11 @@ function validateNativeStyle(input, options, stage) {
   }
   if (style.projection !== void 0) {
     const projection = style.projection;
-    if (!record4(projection) || projection.type !== "mercator" || Object.keys(projection).length !== 1) {
+    if (!record6(projection) || projection.type !== "mercator" || Object.keys(projection).length !== 1) {
       add2("NATIVE_UNSUPPORTED_STYLE", "/projection");
     }
   }
-  if (record4(style.metadata)) {
+  if (record6(style.metadata)) {
     for (const key of Object.keys(style.metadata).sort()) {
       if (/^tileflow:(?:contour|pmtiles)/iu.test(key)) {
         add2("NATIVE_UNSUPPORTED_SOURCE", nativePointer("/metadata", key));
@@ -29298,14 +30278,14 @@ function validateNativeStyle(input, options, stage) {
       add2("NATIVE_FONT_UNAVAILABLE", "/glyphs");
     } else checkUrl(style.glyphs, "/glyphs", "glyphs");
   }
-  const sources = record4(style.sources) ? style.sources : {};
+  const sources = record6(style.sources) ? style.sources : {};
   if (Object.keys(sources).length > tileflowNativeProfileLimits.maximumSources) {
     add2("NATIVE_UNSUPPORTED_SOURCE", "/sources");
   }
   for (const id2 of Object.keys(sources).sort().slice(0, tileflowNativeProfileLimits.maximumSources)) {
     const source = sources[id2];
     const path = nativePointer("/sources", id2);
-    if (!record4(source) || typeof source.type !== "string" || !sourceKinds.has(source.type)) {
+    if (!record6(source) || typeof source.type !== "string" || !sourceKinds.has(source.type)) {
       add2("NATIVE_UNSUPPORTED_SOURCE", path);
       continue;
     }
@@ -29317,7 +30297,7 @@ function validateNativeStyle(input, options, stage) {
       "NATIVE_UNSUPPORTED_SOURCE"
     );
     if (source.clusterProperties !== void 0) {
-      if (record4(source.clusterProperties)) {
+      if (record6(source.clusterProperties)) {
         for (const key of Object.keys(source.clusterProperties).sort()) {
           const values = source.clusterProperties[key];
           if (Array.isArray(values))
@@ -29343,7 +30323,7 @@ function validateNativeStyle(input, options, stage) {
   if (faces !== void 0) {
     const support = spec.$root?.["font-faces"]?.["sdk-support"]?.["basic functionality"];
     if (!support || !supportsBoth(support)) add2("NATIVE_FONT_UNAVAILABLE", "/font-faces");
-    if (!record4(faces) || Object.keys(faces).length > tileflowNativeProfileLimits.maximumFontFaces) {
+    if (!record6(faces) || Object.keys(faces).length > tileflowNativeProfileLimits.maximumFontFaces) {
       add2("NATIVE_FONT_UNAVAILABLE", "/font-faces");
     } else {
       for (const name of Object.keys(faces).sort()) {
@@ -29360,14 +30340,14 @@ function validateNativeStyle(input, options, stage) {
     add2("NATIVE_UNSUPPORTED_STYLE", "/layers");
   layers2.slice(0, tileflowNativeProfileLimits.maximumLayers).forEach((layer, i) => {
     const path = `/layers/${i}`;
-    if (!record4(layer) || typeof layer.type !== "string" || !layerKinds.has(layer.type) || layer.ref !== void 0) {
+    if (!record6(layer) || typeof layer.type !== "string" || !layerKinds.has(layer.type) || layer.ref !== void 0) {
       add2("NATIVE_UNSUPPORTED_STYLE", path);
       return;
     }
     properties(layer, spec.layer, path, add2);
     for (const group of ["layout", "paint"]) {
       const values = layer[group];
-      if (!record4(values)) continue;
+      if (!record6(values)) continue;
       properties(
         values,
         spec[`${group}_${layer.type}`],
@@ -29381,7 +30361,7 @@ function validateNativeStyle(input, options, stage) {
       }
     }
     expressions(layer.filter, `${path}/filter`, add2);
-    if (!options.deferFontClosure && record4(layer.layout) && layer.layout["text-field"] !== void 0) {
+    if (!options.deferFontClosure && record6(layer.layout) && layer.layout["text-field"] !== void 0) {
       const fonts = layer.layout["text-font"];
       if (style.glyphs === void 0) {
         if (!fontStackAvailable(fonts, faces))
@@ -29391,7 +30371,7 @@ function validateNativeStyle(input, options, stage) {
     }
   });
   for (const key of ["light", "transition"]) {
-    if (record4(style[key])) {
+    if (record6(style[key])) {
       properties(style[key], spec[key], `/${key}`, add2);
       for (const [property, value] of Object.entries(style[key]))
         expressions(value, nativePointer(`/${key}`, property), add2);
@@ -29424,13 +30404,13 @@ function properties(values, definitions, path, add2, code = "NATIVE_UNSUPPORTED_
     const basic = definition["sdk-support"]?.["basic functionality"];
     if (basic && !supportsBoth(basic)) add2(code, nativePointer(path, key));
     const value = values[key];
-    if (checkFeatureSupport && record4(value) && Object.hasOwn(value, "stops"))
+    if (checkFeatureSupport && record6(value) && Object.hasOwn(value, "stops"))
       add2(code, nativePointer(path, key));
     if (typeof value === "string") {
       const enumSupport = definition.values?.[value]?.["sdk-support"]?.["basic functionality"];
       if (enumSupport && !supportsBoth(enumSupport)) add2(code, nativePointer(path, key));
     }
-    if (isExpression(value)) {
+    if (isExpression2(value)) {
       const support = definition["sdk-support"]?.["data-driven styling"];
       if (checkFeatureSupport && usesFeatureInput(value) && (!support || !supportsBoth(support)))
         add2(code, nativePointer(path, key));
@@ -29441,7 +30421,7 @@ function supportsBoth(support) {
   return supportsNativeVersions(support, tileflowNativeProfile);
 }
 function expressions(value, path, add2) {
-  if (!Array.isArray(value) || !isExpression(value)) return;
+  if (!Array.isArray(value) || !isExpression2(value)) return;
   const operator = value[0];
   const support = expressionDefinitions?.[operator]?.["sdk-support"]?.["basic functionality"];
   if (!support || !supportsBoth(support)) add2("NATIVE_UNSUPPORTED_STYLE", `${path}/0`);
@@ -29450,7 +30430,7 @@ function expressions(value, path, add2) {
     if (index === 0) return;
     if (operator === "match" && index >= 2 && index < value.length - 1 && index % 2 === 0) return;
     if (operator.startsWith("interpolate") && index === 1) return;
-    if (record4(child)) {
+    if (record6(child)) {
       for (const key of Object.keys(child).sort())
         expressions(child[key], nativePointer(`${path}/${index}`, key), add2);
     } else expressions(child, `${path}/${index}`, add2);
@@ -29458,14 +30438,14 @@ function expressions(value, path, add2) {
 }
 function fontStackAvailable(value, faces) {
   const stack = Array.isArray(value) && value.length === 2 && value[0] === "literal" ? value[1] : value;
-  return Array.isArray(stack) && stack.length > 0 && record4(faces) && stack.every((name) => typeof name === "string" && Object.hasOwn(faces, name));
+  return Array.isArray(stack) && stack.length > 0 && record6(faces) && stack.every((name) => typeof name === "string" && Object.hasOwn(faces, name));
 }
 function inlineFontStacks(value, path, faces, add2) {
-  if (!Array.isArray(value) || !isExpression(value) || value[0] === "literal") return;
+  if (!Array.isArray(value) || !isExpression2(value) || value[0] === "literal") return;
   value.forEach((child, index) => {
     if (index === 0 || value[0] === "match" && index >= 2 && index < value.length - 1 && index % 2 === 0)
       return;
-    if (value[0] === "format" && record4(child) && child["text-font"] !== void 0 && !fontStackAvailable(child["text-font"], faces)) {
+    if (value[0] === "format" && record6(child) && child["text-font"] !== void 0 && !fontStackAvailable(child["text-font"], faces)) {
       add2("NATIVE_FONT_UNAVAILABLE", `${path}/${index}/text-font`);
     }
     inlineFontStacks(child, `${path}/${index}`, faces, add2);
@@ -29482,7 +30462,7 @@ function parserIssuePointer(key, style) {
       path = nativePointer(path, match3[1]);
       value = value[Number(match3[1])];
       rest = rest.slice(match3[0].length).replace(/^\./u, "");
-    } else if (record4(value)) {
+    } else if (record6(value)) {
       const matches = Object.keys(value).filter(
         (name2) => rest === name2 || rest.startsWith(`${name2}.`) || rest.startsWith(`${name2}[`)
       );
@@ -29496,7 +30476,7 @@ function parserIssuePointer(key, style) {
   return path;
 }
 function usesFeatureInput(value) {
-  if (!Array.isArray(value) || !isExpression(value) || value[0] === "literal") return false;
+  if (!Array.isArray(value) || !isExpression2(value) || value[0] === "literal") return false;
   return ["get", "has", "id", "properties", "geometry-type", "feature-state"].includes(
     String(value[0])
   ) || value.slice(1).some(usesFeatureInput);
@@ -29513,7 +30493,7 @@ function plainOptions(value) {
     return false;
   }
 }
-function record4(value) {
+function record6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function normalizeNativeDiagnostics(input) {
@@ -29626,7 +30606,7 @@ var tileflowRendererDeploymentArtifactSchema = z15.object({
     native: z15.object({ ...familyShape, buildRecord: tileflowNativeBuildRecordSchema }).strict()
   }).strict()
 }).strict().superRefine((artifact, context) => {
-  const fail = () => context.addIssue({
+  const fail2 = () => context.addIssue({
     code: "custom",
     message: "Renderer families must share one complete authored Map identity"
   });
@@ -29634,22 +30614,22 @@ var tileflowRendererDeploymentArtifactSchema = z15.object({
     const names = Object.keys(family.buildManifest.maps);
     const map = family.buildManifest.maps[artifact.mapId];
     if (names.length !== 1 || names[0] !== artifact.mapId || !map) {
-      fail();
+      fail2();
       continue;
     }
     const themes = Object.keys(map.themes).sort();
-    if (!themes.length || themes.length > tileflowRendererDeploymentLimits.maximumThemes || !equal(themes, Object.keys(family.styles).sort()) || !themes.includes(map.defaultTheme) || map.lineage[0]?.id !== artifact.mapId || map.lineage[0]?.mapVersion !== map.mapVersion || Boolean(map.sourceAssets.iconComposition) !== (map.mapRevisionSchemaVersion === 2))
-      fail();
+    if (!themes.length || themes.length > tileflowRendererDeploymentLimits.maximumThemes || !equal2(themes, Object.keys(family.styles).sort()) || !themes.includes(map.defaultTheme) || map.lineage[0]?.id !== artifact.mapId || map.lineage[0]?.mapVersion !== map.mapVersion || Boolean(map.sourceAssets.iconComposition) !== (map.mapRevisionSchemaVersion === 2))
+      fail2();
     if (map.timeOfDay && validateTileflowTimeOfDayVariants(map.timeOfDay, map.themes).length)
-      fail();
+      fail2();
     for (const scheme of ["light", "dark"]) {
       if (map.systemThemes && map.themes[map.systemThemes[scheme]]?.colorScheme !== scheme)
-        fail();
+        fail2();
     }
   }
   const web = artifact.renderers.web.buildManifest;
   const native = artifact.renderers.native.buildManifest;
-  if (!equal(authoredIdentity(web), authoredIdentity(native))) fail();
+  if (!equal2(authoredIdentity(web), authoredIdentity(native))) fail2();
 });
 var TileflowRendererDeploymentError = class extends Error {
   code = "RENDERER_DEPLOYMENT_INVALID";
@@ -29660,17 +30640,17 @@ var TileflowRendererDeploymentError = class extends Error {
 };
 async function parseTileflowRendererDeploymentArtifact(input) {
   try {
-    const inputText = serializeCanonicalJson(input);
+    const inputText = serializeCanonicalJson2(input);
     if (new TextEncoder().encode(inputText).byteLength > tileflowRendererDeploymentLimits.maximumBytes || /tf_(?:public|native|live)_/u.test(inputText))
       throw new Error();
     const artifact = tileflowRendererDeploymentArtifactSchema.parse(input);
     const { web, native } = artifact.renderers;
-    if (new TextEncoder().encode(serializeCanonicalJson(native)).byteLength > tileflowRendererDeploymentLimits.maximumNativeFamilyBytes)
+    if (new TextEncoder().encode(serializeCanonicalJson2(native)).byteLength > tileflowRendererDeploymentLimits.maximumNativeFamilyBytes)
       throw new Error();
-    if (await sha256Hex(serializeCanonicalJson(native.buildManifest)) !== native.buildRecord.buildManifestSha256)
+    if (await sha256Hex(serializeCanonicalJson2(native.buildManifest)) !== native.buildRecord.buildManifestSha256)
       throw new Error();
     const names = Object.keys(web.styles).sort();
-    if (!equal(
+    if (!equal2(
       native.buildRecord.transformations.map((value) => `${value.map}/${value.theme}`),
       names.map((name) => `${artifact.mapId}/${name}`)
     ))
@@ -29683,8 +30663,8 @@ async function parseTileflowRendererDeploymentArtifact(input) {
       const transformation = native.buildRecord.transformations.find(
         (value) => value.theme === name
       );
-      const webHash = await sha256Hex(serializeCanonicalJson(webStyle));
-      const nativeHash = await sha256Hex(serializeCanonicalJson(nativeStyle));
+      const webHash = await sha256Hex(serializeCanonicalJson2(webStyle));
+      const nativeHash = await sha256Hex(serializeCanonicalJson2(nativeStyle));
       if (webHash !== webTheme.styleSha256 || nativeHash !== nativeTheme.styleSha256 || transformation.inputStyleSha256 !== webHash || !Array.isArray(webStyle.layers) || !Array.isArray(nativeStyle.layers) || transformation.inputLayers !== webStyle.layers.length || transformation.outputLayers !== nativeStyle.layers.length)
         throw new Error();
       if (validateTileflowNativePreparedStyle(
@@ -29695,10 +30675,10 @@ async function parseTileflowRendererDeploymentArtifact(input) {
       ).length)
         throw new Error();
       for (const field2 of ["sources", "sprite", "glyphs"]) {
-        if (!equal(webStyle[field2], nativeStyle[field2])) throw new Error();
+        if (!equal2(webStyle[field2], nativeStyle[field2])) throw new Error();
       }
       for (const style of [webStyle, nativeStyle]) {
-        const metadata = object(style.metadata);
+        const metadata = object2(style.metadata);
         if (!metadata || metadata["tileflow:map"] !== artifact.mapId || metadata["tileflow:theme"] !== name || metadata["tileflow:mapVersion"] !== web.buildManifest.maps[artifact.mapId].mapVersion || metadata["tileflow:colorScheme"] !== webTheme.colorScheme || [
           "tileflow:deploymentId",
           "tileflow:deploymentVersion",
@@ -29707,7 +30687,7 @@ async function parseTileflowRendererDeploymentArtifact(input) {
         ].some((key) => metadata[key] !== void 0))
           throw new Error();
       }
-      if (!equal(semanticIdentity(webStyle), semanticIdentity(nativeStyle))) throw new Error();
+      if (!equal2(semanticIdentity(webStyle), semanticIdentity(nativeStyle))) throw new Error();
     }
     return artifact;
   } catch {
@@ -29715,10 +30695,10 @@ async function parseTileflowRendererDeploymentArtifact(input) {
   }
 }
 function nativeValidationStyle(style, bindings) {
-  const copy = JSON.parse(serializeCanonicalJson(style));
-  const sources = object(copy.sources);
+  const copy = JSON.parse(serializeCanonicalJson2(style));
+  const sources = object2(copy.sources);
   for (const [id2, binding] of Object.entries(bindings)) {
-    const source = object(sources?.[id2]);
+    const source = object2(sources?.[id2]);
     if (!source || source.type !== binding.type || source.url !== `tileflow://hosted-sources/${id2}` || source.tiles !== void 0)
       throw new Error();
     source.url = `https://artifacts.invalid/tiles/${id2}/tiles.json`;
@@ -29744,11 +30724,11 @@ function authoredIdentity(manifest) {
     )
   };
 }
-function object(value) {
+function object2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-function equal(left, right) {
-  return left === void 0 || right === void 0 ? left === right : serializeCanonicalJson(left) === serializeCanonicalJson(right);
+function equal2(left, right) {
+  return left === void 0 || right === void 0 ? left === right : serializeCanonicalJson2(left) === serializeCanonicalJson2(right);
 }
 var artifactName = z15.string().min(1).max(256).refine(
   (value) => [...value].every((char) => {
@@ -29800,11 +30780,11 @@ var semanticSchema = z15.object({
   }).strict()
 }).strict();
 function semanticIdentity(style) {
-  const candidate = object(style.metadata)?.["tileflow:interaction-manifest"];
+  const candidate = object2(style.metadata)?.["tileflow:interaction-manifest"];
   if (candidate === void 0) return void 0;
   const manifest = semanticSchema.parse(candidate);
   const layers2 = style.layers.map((value) => {
-    const layer = object(value);
+    const layer = object2(value);
     if (!layer) throw new Error();
     return layer;
   });
@@ -29837,7 +30817,10 @@ var tileflowRendererDeploymentResponseSchema = z15.object({
   version: positive,
   worldConversionId: z15.string().min(1).max(128).optional(),
   renderers: z15.object({
-    web: z15.object({ themes: z15.record(tileflowThemeNameSchema, webResponseTheme) }).strict(),
+    web: z15.object({
+      themes: z15.record(tileflowThemeNameSchema, webResponseTheme),
+      familyUrl: publicUrlSchema.optional()
+    }).strict(),
     native: z15.object({
       profile: z15.literal("native-v1"),
       manifestUrl: publicUrlSchema,
@@ -29849,7 +30832,7 @@ var tileflowRendererDeploymentResponseSchema = z15.object({
     const names = Object.keys(value.renderers.web.themes).sort();
     const native = value.renderers.native;
     const url = new URL(native.manifestUrl);
-    if (!names.length || names.length > 64 || !equal(names, Object.keys(native.themes).sort()) || url.pathname !== `/maps/${value.mapId}/native/manifest.json` || names.some(
+    if (!names.length || names.length > 64 || !equal2(names, Object.keys(native.themes).sort()) || url.pathname !== `/maps/${value.mapId}/native/manifest.json` || value.renderers.web.familyUrl !== void 0 && value.renderers.web.familyUrl !== `${url.origin}/maps/${value.mapId}/family/v${value.version}.json` || names.some(
       (name) => native.themes[name].styleUrl !== `${url.origin}/maps/${value.mapId}/native/v${value.version}/${name}.json`
     ))
       throw new Error();
@@ -29958,6 +30941,7 @@ function createManifest(catalog, options = {}) {
         mapName,
         {
           defaultTheme: resolved.defaultTheme,
+          ...options.families ? { familyUrl: `${styleBaseUrl}/families/${mapName}.json` } : {},
           ...resolved.systemThemes ? { systemThemes: resolved.systemThemes } : {},
           themes,
           ...options.manifestVersion !== 1 && resolved.timeOfDay && Object.keys(resolved.timeOfDay).length ? { timeOfDay: resolved.timeOfDay } : {},
@@ -29968,7 +30952,7 @@ function createManifest(catalog, options = {}) {
   );
   const manifest = {
     maps,
-    version: options.manifestVersion ?? (Object.values(maps).some((map) => map.timeOfDay) ? 2 : tileflowRuntimeManifestVersion)
+    version: options.manifestVersion ?? (options.families ? 3 : Object.values(maps).some((map) => map.timeOfDay) ? 2 : tileflowRuntimeManifestVersion)
   };
   return parseTileflowRuntimeManifest(manifest);
 }
@@ -29990,6 +30974,7 @@ export {
   TileflowRendererDeploymentError,
   collectMapLineage,
   collectTileflowMapBuildLineage,
+  compactTileflowDeploymentArtifact,
   createManifest,
   createStyleFromCatalog,
   createStyleFromCatalogWithInspection,
@@ -29997,13 +30982,20 @@ export {
   createStylesFromCatalog,
   createStylesFromCatalogWithInspection,
   createTileflowMapBuildManifest,
+  createTileflowStyleFamily,
+  expandTileflowDeploymentArtifact,
+  expandTileflowFamilyTemplate,
+  expandTileflowStyleFamily,
   hashTileflowAssetSet,
   hashTileflowAssetSetIdentities,
   hashTileflowMapRevision,
   inferTileflowDataRequirements,
   inferTileflowSourceRequirements,
+  materializeTileflowStyleFamily,
   parseTileflowRendererDeploymentArtifact,
+  parseTileflowStyleFamily,
   prepareTileflowNativePathGround,
+  tileflowDeploymentWebBytes,
   tileflowMapBuildManifestFileName,
   tileflowMapBuildManifestSchemaVersion,
   tileflowMapRevisionCanonicalization,
@@ -30012,6 +31004,8 @@ export {
   tileflowRendererDeploymentLimits,
   tileflowRendererDeploymentResponseSchema,
   tileflowSharedIconMapRevisionSchemaVersion,
+  tileflowStyleFamilyLimits,
   tileflowStyleInspectionSchemaVersion,
-  validateTileflowDataCompatibility
+  validateTileflowDataCompatibility,
+  withTileflowFamilyTemplate
 };