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

package/dist/index.js

@@ -13,241 +13,6 @@ var __export = (target, all2) => {
     __defProp(target, name, { get: all2[name], enumerable: true });
 };
 
-// src/theme-blend.ts
-function mixTileflowColours(from, to, t) {
-  const a = oklab(from);
-  const b = oklab(to);
-  if (!a || !b) return void 0;
-  return colourFromOklab(a.map((value, channel) => value + (b[channel] - value) * t));
-}
-function oklab(colour) {
-  const cached = oklabCache.get(colour);
-  if (cached !== void 0) return cached;
-  const rgba = parseColour(colour);
-  let result = null;
-  if (rgba) {
-    const [r, g, b] = rgba.slice(0, 3).map((channel) => {
-      const value = channel / 255;
-      return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
-    });
-    const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
-    const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
-    const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
-    result = [
-      0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
-      1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
-      0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
-      rgba[3]
-    ];
-  }
-  if (oklabCache.size > 4096) oklabCache.clear();
-  oklabCache.set(colour, result);
-  return result;
-}
-function colourFromOklab([lightness, a, b, alpha2]) {
-  const l = (lightness + 0.3963377774 * a + 0.2158037573 * b) ** 3;
-  const m = (lightness - 0.1055613458 * a - 0.0638541728 * b) ** 3;
-  const s = (lightness - 0.0894841775 * a - 1.291485548 * b) ** 3;
-  const [red, green, blue] = [
-    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
-    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
-    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
-  ].map((value) => {
-    const clamped = Math.min(1, Math.max(0, value));
-    const encoded = clamped <= 31308e-7 ? clamped * 12.92 : 1.055 * clamped ** (1 / 2.4) - 0.055;
-    return Math.round(encoded * 255);
-  });
-  return `rgba(${red}, ${green}, ${blue}, ${Number(alpha2.toFixed(3))})`;
-}
-function tileflowColourChannels(colour) {
-  const rgba = parseColour(colour);
-  if (!rgba) return null;
-  return [
-    Math.min(1, Math.max(0, rgba[0] / 255)),
-    Math.min(1, Math.max(0, rgba[1] / 255)),
-    Math.min(1, Math.max(0, rgba[2] / 255)),
-    Math.min(1, Math.max(0, rgba[3]))
-  ];
-}
-function parseColour(colour) {
-  const text = colour.trim().toLowerCase();
-  const hex = /^#([\da-f]{3,8})$/u.exec(text)?.[1];
-  if (hex && [3, 4, 6, 8].includes(hex.length)) {
-    const full = hex.length <= 4 ? [...hex].map((digit) => digit + digit).join("") : hex;
-    const channels = full.match(/../gu).map((pair) => Number.parseInt(pair, 16));
-    return [channels[0], channels[1], channels[2], channels.length > 3 ? channels[3] / 255 : 1];
-  }
-  const functional = /^(rgba?|hsla?)\(([^)]+)\)$/u.exec(text);
-  if (!functional) return null;
-  const parts = functional[2].split(/[\s,/]+/u).filter(Boolean);
-  if (parts.length < 3 || parts.length > 4) return null;
-  const alpha2 = parts[3] === void 0 ? 1 : parseUnit(parts[3], 1);
-  if (functional[1].startsWith("rgb")) {
-    const [r, g, b] = parts.slice(0, 3).map((part) => parseUnit(part, 255));
-    if ([r, g, b, alpha2].some((value) => value === null)) return null;
-    return [r, g, b, alpha2];
-  }
-  const hue = Number.parseFloat(parts[0]);
-  const saturation = parseUnit(parts[1], 1);
-  const light = parseUnit(parts[2], 1);
-  if (!Number.isFinite(hue) || saturation === null || light === null || alpha2 === null) return null;
-  const chroma = (1 - Math.abs(2 * light - 1)) * saturation;
-  const sector = (hue % 360 + 360) % 360 / 60;
-  const x = chroma * (1 - Math.abs(sector % 2 - 1));
-  const [r1, g1, b1] = sector < 1 ? [chroma, x, 0] : sector < 2 ? [x, chroma, 0] : sector < 3 ? [0, chroma, x] : sector < 4 ? [0, x, chroma] : sector < 5 ? [x, 0, chroma] : [chroma, 0, x];
-  const offset = light - chroma / 2;
-  return [(r1 + offset) * 255, (g1 + offset) * 255, (b1 + offset) * 255, alpha2];
-}
-function parseUnit(part, scale) {
-  const percentage = part.endsWith("%");
-  const value = Number.parseFloat(part);
-  if (!Number.isFinite(value)) return null;
-  return percentage ? value / 100 * scale : value;
-}
-var oklabCache;
-var init_theme_blend = __esm({
-  "src/theme-blend.ts"() {
-    "use strict";
-    oklabCache = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/camera-limits.ts
-var tileflowMaxPitch;
-var init_camera_limits = __esm({
-  "src/camera-limits.ts"() {
-    "use strict";
-    tileflowMaxPitch = 85;
-  }
-});
-
-// src/native-zod-object.ts
-import { z } from "zod";
-function strictNativeObject(shape) {
-  const object = new z.core.$ZodObject({
-    type: "object",
-    shape,
-    catchall: z.never()
-  });
-  return z.lazy(() => object);
-}
-var init_native_zod_object = __esm({
-  "src/native-zod-object.ts"() {
-    "use strict";
-  }
-});
-
-// src/manifest-schema-classic.ts
-import { z as z2 } from "zod";
-function classic(schema) {
-  return schema;
-}
-var classicManifestStringOperations, classicManifestSchemaOperations;
-var init_manifest_schema_classic = __esm({
-  "src/manifest-schema-classic.ts"() {
-    "use strict";
-    init_native_zod_object();
-    classicManifestStringOperations = {
-      string: () => z2.string(),
-      minLength(schema, minimum2) {
-        return schema.min(
-          minimum2
-        );
-      },
-      maxLength(schema, maximum2) {
-        return schema.max(
-          maximum2
-        );
-      },
-      regex: (schema, pattern, message) => schema.regex(pattern, { message }),
-      refine: (schema, check, message) => classic(schema).refine(check, message)
-    };
-    classicManifestSchemaOperations = {
-      ...classicManifestStringOperations,
-      number: (minimum2, maximum2) => z2.number().finite().min(minimum2).max(maximum2),
-      unknown: () => z2.unknown(),
-      optional: (schema) => classic(schema).optional(),
-      array: (schema) => z2.array(classic(schema)),
-      enum(values) {
-        return z2.enum(values);
-      },
-      literal: (value) => z2.literal(value),
-      union: (left, right) => z2.union([classic(left), classic(right)]),
-      tuplePair(left, right) {
-        return z2.tuple([classic(left), classic(right)]);
-      },
-      object(shape) {
-        return strictNativeObject(shape);
-      },
-      record(key, value) {
-        return z2.record(classic(key), classic(value));
-      },
-      superRefine: (schema, check) => classic(schema).superRefine(check),
-      pipe: (input, output) => classic(input).pipe(classic(output))
-    };
-  }
-});
-
-// src/portable-identity-rules.ts
-function isTileflowPortableId(value) {
-  return typeof value === "string" && value.length <= tileflowPortableIdMaximumLength && tileflowPortableIdPattern.test(value) && !["constructor", "prototype"].includes(value) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(value);
-}
-function isTileflowThemeName(value) {
-  return isTileflowPortableId(value) && value !== "system";
-}
-var tileflowPortableIdMaximumLength, tileflowPortableIdPattern;
-var init_portable_identity_rules = __esm({
-  "src/portable-identity-rules.ts"() {
-    "use strict";
-    tileflowPortableIdMaximumLength = 64;
-    tileflowPortableIdPattern = /^[a-z][a-z0-9-]{0,63}$/u;
-  }
-});
-
-// src/portable-identity-schema.ts
-function createPortableIdentitySchemas(operations2) {
-  const bounded2 = operations2.maxLength(
-    operations2.minLength(operations2.string(), 1),
-    tileflowPortableIdMaximumLength
-  );
-  const pattern = operations2.regex(
-    bounded2,
-    tileflowPortableIdPattern,
-    "Expected lowercase kebab-case beginning with a letter"
-  );
-  const tileflowPortableIdSchema2 = operations2.refine(
-    pattern,
-    (name) => !["constructor", "prototype"].includes(name) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
-    "Expected a portable identifier that is not a reserved filename or prototype key"
-  );
-  const tileflowThemeNameSchema2 = operations2.refine(
-    tileflowPortableIdSchema2,
-    isTileflowThemeName,
-    "Expected a concrete theme name; system is browser-only"
-  );
-  return { tileflowPortableIdSchema: tileflowPortableIdSchema2, tileflowThemeNameSchema: tileflowThemeNameSchema2 };
-}
-var init_portable_identity_schema = __esm({
-  "src/portable-identity-schema.ts"() {
-    "use strict";
-    init_portable_identity_rules();
-  }
-});
-
-// src/portable-identity.ts
-var schemas, tileflowPortableIdSchema, tileflowThemeNameSchema;
-var init_portable_identity = __esm({
-  "src/portable-identity.ts"() {
-    "use strict";
-    init_manifest_schema_classic();
-    init_portable_identity_schema();
-    init_portable_identity_rules();
-    schemas = createPortableIdentitySchemas(classicManifestStringOperations);
-    tileflowPortableIdSchema = schemas.tileflowPortableIdSchema;
-    tileflowThemeNameSchema = schemas.tileflowThemeNameSchema;
-  }
-});
-
 // src/cartography/expression-operators.ts
 function isMapLibreExpressionOperator(value) {
   return typeof value === "string" && mapLibreExpressionOperators.has(value);
@@ -370,16 +135,16 @@ var init_expression_operators = __esm({
 function fixed(value, options) {
   const reason = options.reason.trim();
   if (!reason) throw new Error("Tileflow fixed values require a non-empty reason.");
-  cloneJson2(value);
+  cloneJson(value);
   return { kind: "theme-fixed", reason, value };
 }
 function expression(value) {
   validateExpressionArray(value, "expression");
-  return { kind: "expression", value: cloneJson2(value) };
+  return { kind: "expression", value: cloneJson(value) };
 }
 function toMapLibreStyleValue(value) {
   if (isTileflowExpression(value)) {
-    return cloneJson2(value.value);
+    return cloneJson(value.value);
   }
   if (isTileflowZoomValue(value)) {
     if (value.interpolation === "step") {
@@ -387,8 +152,8 @@ function toMapLibreStyleValue(value) {
       return [
         "step",
         ["zoom"],
-        cloneJson2(firstValue),
-        ...rest.flatMap(([stop, stopValue]) => [stop, cloneJson2(stopValue)])
+        cloneJson(firstValue),
+        ...rest.flatMap(([stop, stopValue]) => [stop, cloneJson(stopValue)])
       ];
     }
     const interpolation = value.interpolation === "exponential" ? ["exponential", value.base] : [value.interpolation];
@@ -396,13 +161,13 @@ function toMapLibreStyleValue(value) {
       "interpolate",
       interpolation,
       ["zoom"],
-      ...value.stops.flatMap(([stop, stopValue]) => [stop, cloneJson2(stopValue)])
+      ...value.stops.flatMap(([stop, stopValue]) => [stop, cloneJson(stopValue)])
     ];
   }
   if (isTileflowThemeValueNode(value)) {
     throw new Error("Tileflow theme values must be resolved before MapLibre style compilation.");
   }
-  return cloneJson2(value);
+  return cloneJson(value);
 }
 function isTileflowExpression(value) {
   return isRecord(value) && value.kind === "expression" && Array.isArray(value.value);
@@ -439,7 +204,7 @@ function createZoomValue(interpolation, stops, base) {
       throw new Error("Tileflow zoom stops must be strictly increasing.");
     }
     previous = stop;
-    return [stop, cloneJson2(value)];
+    return [stop, cloneJson(value)];
   });
   return {
     kind: "zoom",
@@ -468,9 +233,9 @@ function validateExpressionArray(value, name) {
   if (!isMapLibreExpressionOperator(value[0])) {
     throw new Error(`Unknown MapLibre expression operator: ${value[0]}`);
   }
-  cloneJson2(value);
+  cloneJson(value);
 }
-function cloneJson2(value) {
+function cloneJson(value) {
   const serialized = JSON.stringify(value);
   if (serialized === void 0) {
     throw new Error("Tileflow style values must be JSON-serializable.");
@@ -512,9 +277,9 @@ var init_values = __esm({
     color = {
       alpha(value, opacity) {
         return {
-          color: cloneJson2(value),
+          color: cloneJson(value),
           kind: "theme-color",
-          opacity: cloneJson2(opacity),
+          opacity: cloneJson(opacity),
           operation: "alpha"
         };
       },
@@ -523,12 +288,12 @@ var init_values = __esm({
           throw new Error("Tileflow color mixing supports only the deterministic OKLCH color space.");
         }
         return {
-          amount: cloneJson2(options.amount),
-          from: cloneJson2(from),
+          amount: cloneJson(options.amount),
+          from: cloneJson(from),
           kind: "theme-color",
           operation: "mix",
           space: "oklch",
-          to: cloneJson2(to)
+          to: cloneJson(to)
         };
       }
     };
@@ -591,6 +356,22 @@ var init_operations = __esm({
   }
 });
 
+// src/portable-identity-rules.ts
+function isTileflowPortableId(value) {
+  return typeof value === "string" && value.length <= tileflowPortableIdMaximumLength && tileflowPortableIdPattern.test(value) && !["constructor", "prototype"].includes(value) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(value);
+}
+function isTileflowThemeName(value) {
+  return isTileflowPortableId(value) && value !== "system";
+}
+var tileflowPortableIdMaximumLength, tileflowPortableIdPattern;
+var init_portable_identity_rules = __esm({
+  "src/portable-identity-rules.ts"() {
+    "use strict";
+    tileflowPortableIdMaximumLength = 64;
+    tileflowPortableIdPattern = /^[a-z][a-z0-9-]{0,63}$/u;
+  }
+});
+
 // src/sun.ts
 function normalizeTileflowAzimuth(azimuth) {
   const turned = azimuth % 360;
@@ -661,7 +442,7 @@ function tileflowSunDirection(azimuth, altitude) {
 function resolveTileflowSun(preset, direction = preset, source = "theme") {
   const azimuth = normalizeTileflowAzimuth(direction.azimuth);
   const altitude = Math.min(90, Math.max(-90, direction.altitude));
-  const horizon = smoothstep2(-0.5, 3, altitude);
+  const horizon = smoothstep(-0.5, 3, altitude);
   const intensity = clamp01(preset.intensity) * horizon;
   const rgb = rgbOf(preset.color);
   const ambientRgb = rgbOf(preset.ambient.color);
@@ -714,9 +495,9 @@ function tileflowSunMetadata(preset) {
   return Object.freeze({ version: 1, ...preset });
 }
 function readTileflowSunPreset(metadata) {
-  if (!isRecord4(metadata)) return void 0;
+  if (!isRecord2(metadata)) return void 0;
   const value = metadata[tileflowSunMetadataKey];
-  if (!isRecord4(value) || value.version !== 1 || !isRecord4(value.ambient)) return void 0;
+  if (!isRecord2(value) || value.version !== 1 || !isRecord2(value.ambient)) return void 0;
   const { azimuth, altitude, color: color3, intensity, shadowIntensity } = value;
   const ambient = value.ambient;
   if (!isFiniteNumber(azimuth) || !isFiniteNumber(altitude) || !isUnit(intensity) || !isUnit(shadowIntensity) || !isUnit(ambient.intensity) || !isColour(color3) || !isColour(ambient.color))
@@ -733,7 +514,7 @@ function readTileflowSunPreset(metadata) {
 function tileflowStyleSunPreset(style) {
   const published = readTileflowSunPreset(style?.metadata);
   if (published) return published;
-  const light = isRecord4(style?.light) ? style.light : void 0;
+  const light = isRecord2(style?.light) ? style.light : void 0;
   const position = light?.position;
   if (!position) return tileflowDefaultSunPreset;
   return Object.freeze({
@@ -764,14 +545,14 @@ function luminance([r, g, b]) {
   const linear = (value) => value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
   return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
 }
-function smoothstep2(from, to, value) {
+function smoothstep(from, to, value) {
   const t = clamp01((value - from) / (to - from));
   return t * t * (3 - 2 * t);
 }
 function clamp01(value) {
   return Math.min(1, Math.max(0, Number.isFinite(value) ? value : 0));
 }
-function isRecord4(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isFiniteNumber(value) {
@@ -1034,7 +815,7 @@ function defineTheme(baseOrDefinition, maybeDefinition) {
     version: definition.version
   };
   resolveTileflowTheme(theme);
-  return cloneJson14(theme);
+  return cloneJson2(theme);
 }
 function resolveTileflowTheme(theme) {
   assertThemeDocument(theme);
@@ -1096,7 +877,7 @@ function auditTileflowThemeValues(value, path = "value", context = inferAuditCon
   return diagnostics.sort(compareAuditDiagnostics);
 }
 function auditTileflowMapThemeValues(map) {
-  const modules = isRecord5(map.modules) ? map.modules : void 0;
+  const modules = isRecord3(map.modules) ? map.modules : void 0;
   const moduleDiagnostics = modules ? Object.keys(modules).sort(compareCodeUnits).flatMap(
     (owner) => auditTileflowThemeValues(modules[owner], `modules.${owner}`, {
       owner,
@@ -1203,7 +984,7 @@ function isThemePrimitiveForCategory(value, category) {
   return category === "number" ? typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every((entry) => typeof entry === "number" && Number.isFinite(entry)) : typeof value === "string" && value.length > 0;
 }
 function isThemeValueCandidate(value) {
-  return isRecord5(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
+  return isRecord3(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
 }
 function visitAuditableValue(value, path, category, state, intentRequired = false) {
   if (isThemeStructuralPath(path)) category = void 0;
@@ -1219,7 +1000,7 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     visitAuditableArray(value, path, category, state, false, intentRequired);
     return;
   }
-  if (!isRecord5(value)) return;
+  if (!isRecord3(value)) return;
   if (value.kind === "expression" && Array.isArray(value.value)) {
     visitAuditableArray(value.value, `${path}.value`, category, state, true, intentRequired);
     return;
@@ -1254,8 +1035,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 isExpression = forceExpression || isMapLibreExpressionOperator(operator);
-  if (!isExpression) {
+  const isExpression2 = forceExpression || isMapLibreExpressionOperator(operator);
+  if (!isExpression2) {
     for (const [index, entry] of value.entries()) {
       visitAuditableValue(entry, `${path}[${index}]`, category, state, intentRequired);
     }
@@ -1492,30 +1273,30 @@ function assertThemeIdentity(theme) {
   }
 }
 function assertThemeDefinition(definition) {
-  const record4 = assertPlainThemeRecord(definition, "theme");
-  assertExactThemeKeys(record4, "theme", themeDocumentKeys);
-  assertRequiredThemeKeys(record4, "theme", themeDefinitionRequiredKeys);
+  const record5 = assertPlainThemeRecord(definition, "theme");
+  assertExactThemeKeys(record5, "theme", themeDocumentKeys);
+  assertRequiredThemeKeys(record5, "theme", themeDefinitionRequiredKeys);
   assertThemeIdentity(definition);
-  if (Object.hasOwn(record4, "tokens")) {
-    assertThemeTokens(record4.tokens, "theme.tokens", false);
+  if (Object.hasOwn(record5, "tokens")) {
+    assertThemeTokens(record5.tokens, "theme.tokens", false);
   }
-  if (Object.hasOwn(record4, "typography")) {
-    assertThemeTypography(record4.typography, "theme.typography");
+  if (Object.hasOwn(record5, "typography")) {
+    assertThemeTypography(record5.typography, "theme.typography");
   }
-  if (Object.hasOwn(record4, "lighting")) {
-    assertThemeLighting(record4.lighting, "theme.lighting", true);
+  if (Object.hasOwn(record5, "lighting")) {
+    assertThemeLighting(record5.lighting, "theme.lighting", true);
   }
-  cloneJson14(definition);
+  cloneJson2(definition);
 }
 function assertThemeDocument(theme) {
-  const record4 = assertPlainThemeRecord(theme, "theme");
-  assertExactThemeKeys(record4, "theme", themeDocumentKeys);
-  assertRequiredThemeKeys(record4, "theme", themeDocumentKeys);
+  const record5 = assertPlainThemeRecord(theme, "theme");
+  assertExactThemeKeys(record5, "theme", themeDocumentKeys);
+  assertRequiredThemeKeys(record5, "theme", themeDocumentKeys);
   assertThemeIdentity(theme);
-  assertThemeTokens(record4.tokens, "theme.tokens", true);
-  assertThemeTypography(record4.typography, "theme.typography");
-  assertThemeLighting(record4.lighting, "theme.lighting");
-  cloneJson14(theme);
+  assertThemeTokens(record5.tokens, "theme.tokens", true);
+  assertThemeTypography(record5.typography, "theme.typography");
+  assertThemeLighting(record5.lighting, "theme.lighting");
+  cloneJson2(theme);
 }
 function assertThemeTokens(value, path, complete) {
   const tokens = assertPlainThemeRecord(value, path);
@@ -1608,7 +1389,7 @@ function assertThemeLighting(value, path, allowReset = false) {
   }
 }
 function assertThemeCategoryValue(value, expectedCategory, path) {
-  if (!isRecord5(value)) {
+  if (!isRecord3(value)) {
     assertTokenPrimitive(expectedCategory, value, path);
     return;
   }
@@ -1785,8 +1566,8 @@ function isThemeName(value) {
 }
 function mergeTypography(base, overlay) {
   return {
-    ...cloneJson14(base),
-    ...cloneJson14(overlay ?? {}),
+    ...cloneJson2(base),
+    ...cloneJson2(overlay ?? {}),
     ...mergeOptionalStyle("places", base, overlay),
     ...mergeOptionalStyle("poi", base, overlay),
     ...mergeOptionalStyle("roads", base, overlay),
@@ -1799,13 +1580,13 @@ function mergeOptionalStyle(key, base, overlay) {
 }
 function mergeLighting(base, overlay) {
   if (isTileflowReset(overlay)) return {};
-  const merged = cloneJson14(base);
+  const merged = cloneJson2(base);
   for (const key of themeLightingKeys) {
     const value = overlay[key];
     if (isTileflowReset(value)) {
       delete merged[key];
     } else if (value !== void 0) {
-      merged[key] = (key === "sun" || key === "ambient") && base[key] !== void 0 ? mergeRecord(base[key], value) : cloneJson14(value);
+      merged[key] = (key === "sun" || key === "ambient") && base[key] !== void 0 ? mergeRecord(base[key], value) : cloneJson2(value);
     }
   }
   return merged;
@@ -1814,7 +1595,7 @@ function mergeRecord(base, overlay) {
   if (!isPlainRecord2(base) || !isPlainRecord2(overlay)) {
     throw new Error("Tileflow theme composition accepts only plain JSON objects.");
   }
-  return { ...cloneJson14(base), ...cloneJson14(overlay) };
+  return { ...cloneJson2(base), ...cloneJson2(overlay) };
 }
 function mixOklch(from, to, amount) {
   const a = rgbaToOklch(parseColor(from));
@@ -1968,16 +1749,16 @@ function round(value, digits) {
   const power = 10 ** digits;
   return Math.round(value * power) / power;
 }
-function cloneJson14(value) {
+function cloneJson2(value) {
   const serialized = JSON.stringify(value);
   if (serialized === void 0) throw new Error("Tileflow themes must be JSON-serializable.");
   return JSON.parse(serialized);
 }
-function isRecord5(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRecord2(value) {
-  if (!isRecord5(value)) return false;
+  if (!isRecord3(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -2092,7 +1873,7 @@ var init_model = __esm({
         if (Array.isArray(value)) {
           return value.map((entry, index) => this.resolveTree(entry, `${path}[${index}]`, category));
         }
-        if (!isRecord5(value)) return value;
+        if (!isRecord3(value)) return value;
         if (value.kind === "expression" && Array.isArray(value.value)) {
           return {
             ...value,
@@ -2292,26 +2073,379 @@ var init_model = __esm({
         return mixOklch(from, to, amount);
       }
     };
-    themeStructuralPathSegments = /* @__PURE__ */ new Set([
-      "after",
-      "before",
-      "filter",
-      "id",
-      "maxZoom",
-      "maxzoom",
-      "metadata",
-      "minZoom",
-      "minzoom",
-      "owner",
-      "placement",
-      "requires",
-      "source",
-      "source-layer",
-      "sourceLayer",
-      "target",
-      "type",
-      "visibility"
-    ]);
+    themeStructuralPathSegments = /* @__PURE__ */ new Set([
+      "after",
+      "before",
+      "filter",
+      "id",
+      "maxZoom",
+      "maxzoom",
+      "metadata",
+      "minZoom",
+      "minzoom",
+      "owner",
+      "placement",
+      "requires",
+      "source",
+      "source-layer",
+      "sourceLayer",
+      "target",
+      "type",
+      "visibility"
+    ]);
+  }
+});
+
+// src/color-program.ts
+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;
+}
+var tileflowColorMetadataKey, marker;
+var init_color_program = __esm({
+  "src/color-program.ts"() {
+    "use strict";
+    init_values();
+    init_model();
+    tileflowColorMetadataKey = "tileflow:colors";
+    marker = "__tileflow_color_program";
+  }
+});
+
+// src/theme-blend.ts
+function mixTileflowColours(from, to, t) {
+  const a = oklab(from);
+  const b = oklab(to);
+  if (!a || !b) return void 0;
+  return colourFromOklab(a.map((value, channel) => value + (b[channel] - value) * t));
+}
+function oklab(colour) {
+  const cached = oklabCache.get(colour);
+  if (cached !== void 0) return cached;
+  const rgba = parseColour(colour);
+  let result = null;
+  if (rgba) {
+    const [r, g, b] = rgba.slice(0, 3).map((channel) => {
+      const value = channel / 255;
+      return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+    });
+    const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+    const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+    const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+    result = [
+      0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+      1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+      0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+      rgba[3]
+    ];
+  }
+  if (oklabCache.size > 4096) oklabCache.clear();
+  oklabCache.set(colour, result);
+  return result;
+}
+function colourFromOklab([lightness, a, b, alpha2]) {
+  const l = (lightness + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (lightness - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (lightness - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  const [red, green, blue] = [
+    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  ].map((value) => {
+    const clamped = Math.min(1, Math.max(0, value));
+    const encoded = clamped <= 31308e-7 ? clamped * 12.92 : 1.055 * clamped ** (1 / 2.4) - 0.055;
+    return Math.round(encoded * 255);
+  });
+  return `rgba(${red}, ${green}, ${blue}, ${Number(alpha2.toFixed(3))})`;
+}
+function tileflowColourChannels(colour) {
+  const rgba = parseColour(colour);
+  if (!rgba) return null;
+  return [
+    Math.min(1, Math.max(0, rgba[0] / 255)),
+    Math.min(1, Math.max(0, rgba[1] / 255)),
+    Math.min(1, Math.max(0, rgba[2] / 255)),
+    Math.min(1, Math.max(0, rgba[3]))
+  ];
+}
+function parseColour(colour) {
+  const text = colour.trim().toLowerCase();
+  const hex = /^#([\da-f]{3,8})$/u.exec(text)?.[1];
+  if (hex && [3, 4, 6, 8].includes(hex.length)) {
+    const full = hex.length <= 4 ? [...hex].map((digit) => digit + digit).join("") : hex;
+    const channels = full.match(/../gu).map((pair) => Number.parseInt(pair, 16));
+    return [channels[0], channels[1], channels[2], channels.length > 3 ? channels[3] / 255 : 1];
+  }
+  const functional = /^(rgba?|hsla?)\(([^)]+)\)$/u.exec(text);
+  if (!functional) return null;
+  const parts = functional[2].split(/[\s,/]+/u).filter(Boolean);
+  if (parts.length < 3 || parts.length > 4) return null;
+  const alpha2 = parts[3] === void 0 ? 1 : parseUnit(parts[3], 1);
+  if (functional[1].startsWith("rgb")) {
+    const [r, g, b] = parts.slice(0, 3).map((part) => parseUnit(part, 255));
+    if ([r, g, b, alpha2].some((value) => value === null)) return null;
+    return [r, g, b, alpha2];
+  }
+  const hue = Number.parseFloat(parts[0]);
+  const saturation = parseUnit(parts[1], 1);
+  const light = parseUnit(parts[2], 1);
+  if (!Number.isFinite(hue) || saturation === null || light === null || alpha2 === null) return null;
+  const chroma = (1 - Math.abs(2 * light - 1)) * saturation;
+  const sector = (hue % 360 + 360) % 360 / 60;
+  const x = chroma * (1 - Math.abs(sector % 2 - 1));
+  const [r1, g1, b1] = sector < 1 ? [chroma, x, 0] : sector < 2 ? [x, chroma, 0] : sector < 3 ? [0, chroma, x] : sector < 4 ? [0, x, chroma] : sector < 5 ? [x, 0, chroma] : [chroma, 0, x];
+  const offset = light - chroma / 2;
+  return [(r1 + offset) * 255, (g1 + offset) * 255, (b1 + offset) * 255, alpha2];
+}
+function parseUnit(part, scale) {
+  const percentage = part.endsWith("%");
+  const value = Number.parseFloat(part);
+  if (!Number.isFinite(value)) return null;
+  return percentage ? value / 100 * scale : value;
+}
+var oklabCache;
+var init_theme_blend = __esm({
+  "src/theme-blend.ts"() {
+    "use strict";
+    oklabCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/camera-limits.ts
+var tileflowMaxPitch;
+var init_camera_limits = __esm({
+  "src/camera-limits.ts"() {
+    "use strict";
+    tileflowMaxPitch = 85;
+  }
+});
+
+// src/native-zod-object.ts
+import { z } from "zod";
+function strictNativeObject(shape) {
+  const object = new z.core.$ZodObject({
+    type: "object",
+    shape,
+    catchall: z.never()
+  });
+  return z.lazy(() => object);
+}
+var init_native_zod_object = __esm({
+  "src/native-zod-object.ts"() {
+    "use strict";
+  }
+});
+
+// src/manifest-schema-classic.ts
+import { z as z2 } from "zod";
+function classic(schema) {
+  return schema;
+}
+var classicManifestStringOperations, classicManifestSchemaOperations;
+var init_manifest_schema_classic = __esm({
+  "src/manifest-schema-classic.ts"() {
+    "use strict";
+    init_native_zod_object();
+    classicManifestStringOperations = {
+      string: () => z2.string(),
+      minLength(schema, minimum2) {
+        return schema.min(
+          minimum2
+        );
+      },
+      maxLength(schema, maximum2) {
+        return schema.max(
+          maximum2
+        );
+      },
+      regex: (schema, pattern, message) => schema.regex(pattern, { message }),
+      refine: (schema, check, message) => classic(schema).refine(check, message)
+    };
+    classicManifestSchemaOperations = {
+      ...classicManifestStringOperations,
+      number: (minimum2, maximum2) => z2.number().finite().min(minimum2).max(maximum2),
+      unknown: () => z2.unknown(),
+      optional: (schema) => classic(schema).optional(),
+      array: (schema) => z2.array(classic(schema)),
+      enum(values) {
+        return z2.enum(values);
+      },
+      literal: (value) => z2.literal(value),
+      union: (left, right) => z2.union([classic(left), classic(right)]),
+      tuplePair(left, right) {
+        return z2.tuple([classic(left), classic(right)]);
+      },
+      object(shape) {
+        return strictNativeObject(shape);
+      },
+      record(key, value) {
+        return z2.record(classic(key), classic(value));
+      },
+      superRefine: (schema, check) => classic(schema).superRefine(check),
+      pipe: (input, output) => classic(input).pipe(classic(output))
+    };
+  }
+});
+
+// src/portable-identity-schema.ts
+function createPortableIdentitySchemas(operations2) {
+  const bounded2 = operations2.maxLength(
+    operations2.minLength(operations2.string(), 1),
+    tileflowPortableIdMaximumLength
+  );
+  const pattern = operations2.regex(
+    bounded2,
+    tileflowPortableIdPattern,
+    "Expected lowercase kebab-case beginning with a letter"
+  );
+  const tileflowPortableIdSchema2 = operations2.refine(
+    pattern,
+    (name) => !["constructor", "prototype"].includes(name) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
+    "Expected a portable identifier that is not a reserved filename or prototype key"
+  );
+  const tileflowThemeNameSchema2 = operations2.refine(
+    tileflowPortableIdSchema2,
+    isTileflowThemeName,
+    "Expected a concrete theme name; system is browser-only"
+  );
+  return { tileflowPortableIdSchema: tileflowPortableIdSchema2, tileflowThemeNameSchema: tileflowThemeNameSchema2 };
+}
+var init_portable_identity_schema = __esm({
+  "src/portable-identity-schema.ts"() {
+    "use strict";
+    init_portable_identity_rules();
+  }
+});
+
+// src/portable-identity.ts
+var schemas, tileflowPortableIdSchema, tileflowThemeNameSchema;
+var init_portable_identity = __esm({
+  "src/portable-identity.ts"() {
+    "use strict";
+    init_manifest_schema_classic();
+    init_portable_identity_schema();
+    init_portable_identity_rules();
+    schemas = createPortableIdentitySchemas(classicManifestStringOperations);
+    tileflowPortableIdSchema = schemas.tileflowPortableIdSchema;
+    tileflowThemeNameSchema = schemas.tileflowThemeNameSchema;
   }
 });
 
@@ -2334,12 +2468,13 @@ var init_time_of_day_schema = __esm({
 });
 
 // src/manifest-types.ts
-var tileflowRuntimeManifestVersion, tileflowTimeOfDayManifestVersion, tileflowRuntimeManifestLimits;
+var tileflowRuntimeManifestVersion, tileflowTimeOfDayManifestVersion, tileflowFamilyManifestVersion, tileflowRuntimeManifestLimits;
 var init_manifest_types = __esm({
   "src/manifest-types.ts"() {
     "use strict";
     tileflowRuntimeManifestVersion = 1;
     tileflowTimeOfDayManifestVersion = 2;
+    tileflowFamilyManifestVersion = 3;
     tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
   }
 });
@@ -2409,6 +2544,7 @@ function createTileflowRuntimeManifestSchema(primitives, operations2, identities
       apiUrl: operations2.optional(apiOriginSchema),
       defaultTheme: tileflowThemeNameSchema2,
       environment: operations2.optional(operations2.maxLength(safeTextSchema, 128)),
+      familyUrl: operations2.optional(publicResourceUrlSchema),
       mapId: operations2.optional(operations2.maxLength(safeTextSchema, 128)),
       systemThemes: operations2.optional(
         operations2.object({
@@ -2490,11 +2626,20 @@ function createTileflowRuntimeManifestSchema(primitives, operations2, identities
       maps: operations2.record(tileflowPortableIdSchema2, manifestMapSchema),
       version: operations2.union(
         operations2.literal(tileflowRuntimeManifestVersion),
-        operations2.literal(2)
+        operations2.union(operations2.literal(2), operations2.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)
@@ -2627,6 +2772,7 @@ var manifest_exports = {};
 __export(manifest_exports, {
   parseTileflowRuntimeManifest: () => parseTileflowRuntimeManifest,
   safeParseTileflowRuntimeManifest: () => safeParseTileflowRuntimeManifest,
+  tileflowFamilyManifestVersion: () => tileflowFamilyManifestVersion,
   tileflowRuntimeManifestLimits: () => tileflowRuntimeManifestLimits,
   tileflowRuntimeManifestSchema: () => tileflowRuntimeManifestSchema,
   tileflowRuntimeManifestVersion: () => tileflowRuntimeManifestVersion,
@@ -2935,20 +3081,20 @@ var hexColour = /^#[0-9a-f]{6}$/iu;
 var unit = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
 function readColours(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const record4 = value;
-  if (Object.keys(record4).length !== 4) return void 0;
-  const { color: color3, horizonColor, horizonBlend, glowColor } = record4;
+  const record5 = value;
+  if (Object.keys(record5).length !== 4) return void 0;
+  const { color: color3, horizonColor, horizonBlend, glowColor } = record5;
   if (typeof color3 !== "string" || !hexColour.test(color3) || typeof horizonColor !== "string" || !hexColour.test(horizonColor) || typeof glowColor !== "string" || !hexColour.test(glowColor) || !unit(horizonBlend))
     return void 0;
   return { color: color3, horizonColor, horizonBlend, glowColor };
 }
 function readTileflowSky(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const record4 = value;
-  const keys = Object.keys(record4);
-  if (record4.version !== 1 || keys.length !== (record4.timesOfDay === void 0 ? 3 : 4))
+  const record5 = value;
+  const keys = Object.keys(record5);
+  if (record5.version !== 1 || keys.length !== (record5.timesOfDay === void 0 ? 3 : 4))
     return void 0;
-  const { starIntensity, glowColor, timesOfDay } = record4;
+  const { starIntensity, glowColor, timesOfDay } = record5;
   if (!unit(starIntensity) || typeof glowColor !== "string" || !hexColour.test(glowColor))
     return void 0;
   if (timesOfDay === void 0) return { version: 1, starIntensity, glowColor };
@@ -3178,7 +3324,7 @@ function tileflowShotStateAt(shot, at) {
   const from = keyframes[segment];
   const to = keyframes[segment + 1];
   const linear = Math.min(1, Math.max(0, (time - from.at) / (to.at - from.at)));
-  const t = shot.easing === "linear" ? linear : smoothstep(linear);
+  const t = shot.easing === "linear" ? linear : smoothstep2(linear);
   return {
     at: time,
     camera: interpolateCamera(cameraOf(from), cameraOf(to), t),
@@ -3240,7 +3386,7 @@ function wrapDegrees(value) {
   if (value >= -180 && value <= 180) return value;
   return ((value + 180) % 360 + 360) % 360 - 180;
 }
-function smoothstep(t) {
+function smoothstep2(t) {
   return t * t * (3 - 2 * t);
 }
 
@@ -3415,31 +3561,31 @@ function createTileflowCompilationFailure(input) {
   };
 }
 function diagnosticsFromError(error, fallbackPhase) {
-  const record4 = asRecord(error);
-  const inheritedPhase = isTileflowCompilationPhase(record4.phase) ? record4.phase : fallbackPhase;
-  const nested = Array.isArray(record4.diagnostics) ? record4.diagnostics : void 0;
+  const record5 = asRecord(error);
+  const inheritedPhase = isTileflowCompilationPhase(record5.phase) ? record5.phase : fallbackPhase;
+  const nested = Array.isArray(record5.diagnostics) ? record5.diagnostics : void 0;
   if (nested?.length) {
     return nested.map(
-      (item) => diagnosticFromRecord(asRecord(item), error, inheritedPhase, record4)
+      (item) => diagnosticFromRecord(asRecord(item), error, inheritedPhase, record5)
     );
   }
-  const messages = Array.isArray(record4.messages) ? record4.messages : void 0;
+  const messages = Array.isArray(record5.messages) ? record5.messages : void 0;
   if (messages?.length) {
     return messages.map(
-      (item) => diagnosticFromRecord(asRecord(item), error, inheritedPhase, record4)
+      (item) => diagnosticFromRecord(asRecord(item), error, inheritedPhase, record5)
     );
   }
-  return [diagnosticFromRecord(record4, error, inheritedPhase)];
-}
-function diagnosticFromRecord(record4, fallback, fallbackPhase, inherited = {}) {
-  const code = inheritedString(record4, inherited, "code");
-  const domain = inheritedString(record4, inherited, "domain") ?? inheritedString(record4, inherited, "owner");
-  const message = inheritedString(record4, inherited, "message");
-  const path = inheritedString(record4, inherited, "path");
-  const phase = record4.phase ?? inherited.phase;
-  const severity = record4.severity ?? record4.level ?? inherited.severity ?? inherited.level;
-  const suggestion = inheritedString(record4, inherited, "suggestion");
-  const target = inheritedString(record4, inherited, "target");
+  return [diagnosticFromRecord(record5, error, inheritedPhase)];
+}
+function diagnosticFromRecord(record5, fallback, fallbackPhase, inherited = {}) {
+  const code = inheritedString(record5, inherited, "code");
+  const domain = inheritedString(record5, inherited, "domain") ?? inheritedString(record5, inherited, "owner");
+  const message = inheritedString(record5, inherited, "message");
+  const path = inheritedString(record5, inherited, "path");
+  const phase = record5.phase ?? inherited.phase;
+  const severity = record5.severity ?? record5.level ?? inherited.severity ?? inherited.level;
+  const suggestion = inheritedString(record5, inherited, "suggestion");
+  const target = inheritedString(record5, inherited, "target");
   return {
     code: code ?? "TILEFLOW_COMPILATION_FAILED",
     ...domain ? { domain } : {},
@@ -3451,8 +3597,8 @@ function diagnosticFromRecord(record4, fallback, fallbackPhase, inherited = {})
     ...target ? { target } : {}
   };
 }
-function inheritedString(record4, inherited, key) {
-  const value = record4[key] ?? inherited[key];
+function inheritedString(record5, inherited, key) {
+  const value = record5[key] ?? inherited[key];
   return typeof value === "string" ? value : void 0;
 }
 function isTileflowCompilationPhase(value) {
@@ -3632,9 +3778,9 @@ var tileflowCompilerMetadataKeys = Object.freeze({
 
 // src/modules/addresses/index.ts
 function addresses(options = {}) {
-  return { type: "addresses", ...cloneJson(options) };
+  return { type: "addresses", ...cloneJson3(options) };
 }
-function cloneJson(value) {
+function cloneJson3(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -4301,34 +4447,34 @@ function asRecord2(value) {
 // src/cartography/merge.ts
 init_values();
 function mergeTileflowDesign(base, ...overlays) {
-  let resolved = cloneJson3(base);
+  let resolved = cloneJson4(base);
   for (const overlay of overlays) {
     resolved = mergeValue(resolved, overlay);
   }
   return resolved;
 }
 function mergeValue(base, overlay) {
-  if (overlay === void 0) return cloneJson3(base);
-  if (Array.isArray(overlay) || isTileflowExpression(overlay) || isTileflowThemeValueNode(overlay) || isTileflowZoomValue(overlay) || !isRecord2(overlay)) {
-    return cloneJson3(overlay);
+  if (overlay === void 0) return cloneJson4(base);
+  if (Array.isArray(overlay) || isTileflowExpression(overlay) || isTileflowThemeValueNode(overlay) || isTileflowZoomValue(overlay) || !isRecord4(overlay)) {
+    return cloneJson4(overlay);
   }
-  const baseRecord = isRecord2(base) ? base : {};
+  const baseRecord = isRecord4(base) ? base : {};
   const result = {};
   for (const key of /* @__PURE__ */ new Set([...Object.keys(baseRecord), ...Object.keys(overlay)])) {
     const overlayValue = overlay[key];
     if (overlayValue === void 0) {
-      if (key in baseRecord) result[key] = cloneJson3(baseRecord[key]);
+      if (key in baseRecord) result[key] = cloneJson4(baseRecord[key]);
       continue;
     }
     result[key] = mergeValue(baseRecord[key], overlayValue);
   }
   return result;
 }
-function cloneJson3(value) {
+function cloneJson4(value) {
   if (value === void 0) return value;
   return JSON.parse(JSON.stringify(value));
 }
-function isRecord2(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -4385,9 +4531,9 @@ function compileAddresses(request, context) {
 
 // src/modules/aeroways/index.ts
 function aeroways(options = {}) {
-  return { type: "aeroways", ...cloneJson4(options) };
+  return { type: "aeroways", ...cloneJson5(options) };
 }
-function cloneJson4(value) {
+function cloneJson5(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -4546,9 +4692,9 @@ function compileAeroways(request, context) {
 
 // src/modules/boundaries/index.ts
 function boundaries(options = {}) {
-  return { type: "boundaries", ...cloneJson5(options) };
+  return { type: "boundaries", ...cloneJson6(options) };
 }
-function cloneJson5(value) {
+function cloneJson6(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -4663,12 +4809,15 @@ function compileBoundaries(request, context) {
 
 // src/modules/buildings/index.ts
 function buildings(options = {}) {
-  return { type: "buildings", ...cloneJson6(options) };
+  return { type: "buildings", ...cloneJson7(options) };
 }
-function cloneJson6(value) {
+function cloneJson7(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
+// src/building-layer-ids.ts
+var tileflowNativeBuildingsLayerId = "tileflow-buildings-native-extrusion";
+
 // src/modules/buildings/compiler.ts
 init_values();
 function compileBuildings(request, context) {
@@ -4749,7 +4898,7 @@ function compileBuildings(request, context) {
       kind: "layer",
       layer: applyExtrusionStyle(
         {
-          id: "tileflow-buildings-3d",
+          id: tileflowNativeBuildingsLayerId,
           type: "fill-extrusion",
           source,
           "source-layer": sourceLayer,
@@ -4998,7 +5147,7 @@ function visibleRoadClasses(options) {
   ].filter((roadClass) => !disabled.has(roadClass));
 }
 function roads(options = {}) {
-  return { type: "roads", ...cloneJson7(options) };
+  return { type: "roads", ...cloneJson8(options) };
 }
 function resolveRoads(request) {
   return {
@@ -5047,7 +5196,7 @@ function roadStyleMetrics(options) {
     weightScale: { thin: 0.78, regular: 1, bold: 1.24 }[options.weight]
   };
 }
-function cloneJson7(value) {
+function cloneJson8(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -5066,7 +5215,7 @@ var defaults3 = {
   water: "major"
 };
 function labels(options = {}) {
-  return { type: "labels", ...cloneJson8(options) };
+  return { type: "labels", ...cloneJson9(options) };
 }
 function resolveLabels(request) {
   return {
@@ -5090,7 +5239,7 @@ function visibleRoadLabelClasses(detail, roads2, explicitClasses) {
   const eligible = explicit ? tileflowRoadClasses.filter((roadClass) => explicit.has(roadClass)) : roadClassesWithPaths(detail, detail === "all" && roads2.extras.paths);
   return eligible.filter((roadClass) => visibleGeometry.has(roadClass));
 }
-function cloneJson8(value) {
+function cloneJson9(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -5858,9 +6007,9 @@ function symbolContribution(target, localOrder, layer, slot = "symbols", family)
 
 // src/modules/land/index.ts
 function land(options = {}) {
-  return { type: "land", ...cloneJson9(options) };
+  return { type: "land", ...cloneJson10(options) };
 }
-function cloneJson9(value) {
+function cloneJson10(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -6221,9 +6370,9 @@ var tileflowLandformClasses = [
   "arete"
 ];
 function landforms(options = {}) {
-  return { type: "landforms", ...cloneJson10(options) };
+  return { type: "landforms", ...cloneJson11(options) };
 }
-function cloneJson10(value) {
+function cloneJson11(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -6405,9 +6554,9 @@ var tileflowNauticalNotice = Object.freeze({
   text: "Not for navigation"
 });
 function nautical(options = {}) {
-  return { type: "nautical", ...cloneJson11(options) };
+  return { type: "nautical", ...cloneJson12(options) };
 }
-function cloneJson11(value) {
+function cloneJson12(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -7290,7 +7439,7 @@ var tileflowNauticalV1Schema = Object.freeze({
 });
 var tileflowBathymetryNameLayerLimits = Object.freeze({ maxZoomRanges: 128 });
 function bathymetry(options = {}) {
-  return { type: "bathymetry", ...cloneJson12(options) };
+  return { type: "bathymetry", ...cloneJson13(options) };
 }
 function resolveMarine(marine, apiBaseUrl = "https://api.tileflow.dev") {
   if (marine === void 0) return void 0;
@@ -7331,7 +7480,7 @@ function resolveBathymetry(input, apiBaseUrl) {
     ...advanced?.contours === void 0 ? {} : { contours: advanced.contours },
     display,
     ...advanced?.labels === void 0 ? {} : { labels: advanced.labels },
-    ...advanced?.vectorLayers === void 0 ? {} : { vectorLayers: cloneJson12(advanced.vectorLayers) },
+    ...advanced?.vectorLayers === void 0 ? {} : { vectorLayers: cloneJson13(advanced.vectorLayers) },
     ...reliefVisible ? { relief: resolveBathymetryRelief(reliefConfig ?? {}, apiBaseUrl) } : {},
     ...usesVector ? {
       vector: resolveMarineSource({
@@ -7370,7 +7519,7 @@ function resolveBathymetryRelief(style, apiBaseUrl) {
       url
     },
     sourceId,
-    style: cloneJson12(style)
+    style: cloneJson13(style)
   };
 }
 var tileflowNauticalPromoteId = Object.freeze({
@@ -7443,7 +7592,7 @@ function normalizeApiBaseUrl2(value) {
   }
   return url.toString();
 }
-function cloneJson12(value) {
+function cloneJson13(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -7460,9 +7609,9 @@ var tileflowNauticalLightsLimits = Object.freeze({ maxLayers: 16 });
 var identifierPattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u;
 var layerIdPattern = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/u;
 function readTileflowNauticalLights(metadata) {
-  if (!isRecord3(metadata)) return void 0;
+  if (!isRecord5(metadata)) return void 0;
   const value = metadata[tileflowNauticalLightsMetadataKey];
-  if (!isRecord3(value) || value.version !== 1) return void 0;
+  if (!isRecord5(value) || value.version !== 1) return void 0;
   const { layers: layers2, source, sourceLayer } = value;
   if (typeof source !== "string" || !identifierPattern.test(source)) return void 0;
   if (typeof sourceLayer !== "string" || !identifierPattern.test(sourceLayer)) return void 0;
@@ -7485,13 +7634,13 @@ function declareTileflowNauticalLights(layers2, sourceId, sourceLayer) {
   return { layers: ids, source: sourceId, sourceLayer, version: 1 };
 }
 function steadyTileflowNauticalLights(style) {
-  const declaration = isRecord3(style.metadata) ? readTileflowNauticalLights(style.metadata) : void 0;
-  const hasKey = isRecord3(style.metadata) && tileflowNauticalLightsMetadataKey in style.metadata;
+  const declaration = isRecord5(style.metadata) ? readTileflowNauticalLights(style.metadata) : void 0;
+  const hasKey = isRecord5(style.metadata) && tileflowNauticalLightsMetadataKey in style.metadata;
   if (!declaration && !hasKey) return style;
   const metadata = { ...style.metadata };
   delete metadata[tileflowNauticalLightsMetadataKey];
   const layers2 = Array.isArray(style.layers) ? style.layers.map(
-    (layer) => isRecord3(layer) && isRecord3(layer.paint) && readsLightState(layer.paint) ? { ...layer, paint: steady(layer.paint) } : layer
+    (layer) => isRecord5(layer) && isRecord5(layer.paint) && readsLightState(layer.paint) ? { ...layer, paint: steady(layer.paint) } : layer
   ) : style.layers;
   return { ...style, layers: layers2, metadata };
 }
@@ -7501,7 +7650,7 @@ function tileflowNauticalLightStateRead(state, steadyValue) {
 var stateKeys = new Set(Object.values(tileflowNauticalLightStates));
 function readsLightState(value) {
   if (!Array.isArray(value)) {
-    return isRecord3(value) ? Object.values(value).some(readsLightState) : false;
+    return isRecord5(value) ? Object.values(value).some(readsLightState) : false;
   }
   if (value[0] === "literal") return false;
   if (value[0] === "feature-state" && typeof value[1] === "string" && stateKeys.has(value[1])) {
@@ -7517,12 +7666,12 @@ function steady(value) {
     }
     return value.map(steady);
   }
-  if (isRecord3(value)) {
+  if (isRecord5(value)) {
     return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, steady(entry)]));
   }
   return value;
 }
-function isRecord3(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -8692,7 +8841,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",
@@ -8710,7 +8859,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"
       )
     );
@@ -9032,7 +9181,7 @@ var tileflowPoiIconOnlyTypes = Object.freeze([
   "public_restroom"
 ]);
 function poi(options = {}) {
-  return { type: "poi", ...cloneJson13(options) };
+  return { type: "poi", ...cloneJson14(options) };
 }
 function resolvePoi(request) {
   return {
@@ -9055,7 +9204,7 @@ function resolvePoi(request) {
     }
   };
 }
-function cloneJson13(value) {
+function cloneJson14(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
@@ -9160,12 +9309,12 @@ function mergePoiCategoryLayers(entries, options) {
   };
   for (const part of ["layout", "paint"]) {
     const records = entries.map(({ layer }) => asRecord3(layer[part]));
-    const properties = [...new Set(records.flatMap((record4) => Object.keys(record4)))].sort();
+    const properties = [...new Set(records.flatMap((record5) => Object.keys(record5)))].sort();
     const merged = {};
     for (const property of properties) {
       const fallback = Object.hasOwn(varying, property) ? varying[property] : tileflowPoiLayerPropertyDefaults[property];
       const values = records.map(
-        (record4) => Object.hasOwn(record4, property) ? record4[property] : fallback
+        (record5) => Object.hasOwn(record5, property) ? record5[property] : fallback
       );
       if (values.every((value) => sameJson(value, values[0]))) {
         if (values[0] !== void 0) merged[property] = values[0];
@@ -9687,6 +9836,7 @@ function withoutVisibility(value) {
 init_values();
 
 // src/themes/index.ts
+init_color_program();
 init_model();
 init_model();
 init_visual_semantics();
@@ -9895,8 +10045,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) {
@@ -10134,10 +10294,22 @@ function relativeLuminance(color3) {
   return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
 }
 function alpha(color3, opacity) {
+  if (isColorProgramMarker(color3))
+    return colorProgramMarker(alpha(colorProgramValue(color3), opacity), {
+      kind: "theme-color",
+      operation: "alpha",
+      color: colorProgramOf(color3),
+      opacity
+    });
   const { a, b, g, r } = hexToRgba(color3);
   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);
@@ -10150,6 +10322,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*\)$/
   );
@@ -10171,6 +10344,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;
@@ -10349,10 +10527,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);
@@ -10360,7 +10538,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) {
@@ -11216,8 +11394,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 equal = among([label]);
-      return equal === void 0 ? void 0 : operator === "==" ? equal : !equal;
+      const equal2 = among([label]);
+      return equal2 === void 0 ? void 0 : operator === "==" ? equal2 : !equal2;
     }
     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]];
@@ -11715,6 +11893,7 @@ function cloneJson16(value) {
 }
 
 // src/modules/vegetation/compiler.ts
+init_color_program();
 init_values();
 
 // src/trees-3d.ts
@@ -11980,7 +12159,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;
@@ -12007,7 +12189,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),
@@ -12049,7 +12234,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 ?? [],
@@ -12893,8 +13078,8 @@ function assertProvidedServices(domain, services) {
   }
 }
 function checkedModuleRecord(entries) {
-  const record4 = Object.fromEntries(entries);
-  const actual = Object.keys(record4).sort(compareCodeUnits2);
+  const record5 = Object.fromEntries(entries);
+  const actual = Object.keys(record5).sort(compareCodeUnits2);
   if (actual.length !== tileflowSemanticDomainRegistry.length || actual.some(
     (name, index) => name !== [...tileflowSemanticDomainRegistry.map(({ name: name2 }) => name2)].sort(compareCodeUnits2)[index]
   )) {
@@ -12902,7 +13087,7 @@ function checkedModuleRecord(entries) {
       "Tileflow semantic domain registry did not produce one value for every module."
     );
   }
-  return record4;
+  return record5;
 }
 function assertRegistryIsValid() {
   const names = /* @__PURE__ */ new Set();
@@ -13759,7 +13944,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 {
@@ -13773,11 +13958,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),
@@ -13800,7 +13985,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],
@@ -13816,16 +14001,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);
@@ -13839,7 +14024,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",
@@ -13848,14 +14033,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);
 }
 
@@ -13927,8 +14112,9 @@ function readTileflowBuildings3D(metadata) {
   };
 }
 function readTileflowBuildingsEntrance(value) {
+  if (value === false) return { entrance: false };
   if (!isRecord7(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 } : {} } } : {};
@@ -13981,6 +14167,9 @@ function isRecord7(value) {
 // src/camera.ts
 var tileflowCameraMetadataKey = "tileflow:camera";
 
+// src/cartography/streets.ts
+init_color_program();
+
 // src/data/requirements.ts
 import { convertFilter } from "@maplibre/maplibre-gl-style-spec";
 function inferTileflowDataRequirements(style, options = {}) {
@@ -14120,11 +14309,11 @@ function collectFieldAccesses(value, fields2, dynamicAccesses, path) {
     return;
   }
   if (!value || typeof value !== "object") return;
-  const record4 = value;
-  if (typeof record4.property === "string" && Array.isArray(record4.stops)) {
-    fields2.set(record4.property, fields2.get(record4.property));
+  const record5 = value;
+  if (typeof record5.property === "string" && Array.isArray(record5.stops)) {
+    fields2.set(record5.property, fields2.get(record5.property));
   }
-  for (const [key, child] of Object.entries(record4)) {
+  for (const [key, child] of Object.entries(record5)) {
     collectFieldAccesses(child, fields2, dynamicAccesses, `${path}.${key}`);
   }
 }
@@ -14530,7 +14719,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(
@@ -14592,18 +14781,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":
@@ -14612,7 +14801,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 "-":
@@ -14625,8 +14814,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 "+":
@@ -14644,7 +14833,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":
@@ -14658,7 +14847,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": {
@@ -14678,7 +14867,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": {
@@ -14698,10 +14887,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": {
@@ -14717,10 +14906,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": {
@@ -14737,9 +14926,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:
@@ -14874,6 +15063,262 @@ var expr = Object.freeze({
   zoom: zoom2
 });
 
+// src/cartography/expression-compaction.ts
+init_expression_operators();
+init_color_program();
+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 properties = layer[group];
+    if (properties && typeof properties === "object" && !Array.isArray(properties))
+      Object.assign(result, {
+        [group]: Object.fromEntries(
+          Object.entries(properties).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(
@@ -15076,7 +15521,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();
@@ -15126,6 +15571,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
   );
@@ -15224,7 +15670,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",
@@ -17476,7 +17922,7 @@ function boundedThemeNumberSchema(min, max) {
     }).strict()
   ]);
 }
-var entranceBandSchema = z7.tuple([z7.number().finite().min(0).max(24), z7.number().finite().min(0).max(24)]).refine(([from, to]) => from < to, "A band starts at a lower zoom than it ends.");
+var entranceBandSchema = z7.tuple([z7.number().finite().min(0).max(24), z7.number().finite().min(0).max(24)]).refine(([from, to]) => from <= to, "A band cannot end before it starts.");
 var modelRoleLightingSchema = z7.object({
   emissiveStrength: boundedThemeNumberSchema(0, 5).optional(),
   emissiveVariation: boundedThemeNumberSchema(0, 1).optional(),
@@ -17536,7 +17982,7 @@ var buildingsModuleSchema = z7.object({
       lamp: modelRoleLightingSchema.optional(),
       logo: modelRoleLightingSchema.optional()
     }).strict().optional(),
-    entrance: z7.object({ buildings: entranceBandSchema.optional(), models: entranceBandSchema.optional() }).strict().optional(),
+    entrance: z7.object({ buildings: entranceBandSchema.optional(), models: entranceBandSchema.optional() }).strict().or(z7.literal(false)).optional(),
     flatFootprints: z7.boolean().optional(),
     occlusion: z7.boolean().optional(),
     groundOcclusion: boundedThemeNumberSchema(0, 1).optional(),
@@ -18575,7 +19021,13 @@ var systemThemesSchema = z7.object({ dark: tileflowThemeNameSchema, light: tilef
 var resolvedTileflowMapSchema = z7.object({
   atmosphere: atmosphereSchema.optional(),
   boundaryAreas: boundaryAreasSchema.optional(),
-  camera: z7.object({ adaptivePerspective: z7.boolean().optional() }).strict().optional(),
+  camera: z7.object({
+    adaptivePerspective: z7.boolean().optional(),
+    pitchLimit: z7.object({
+      maxZoom: z7.number().finite().min(0).max(24),
+      maxPitch: z7.number().finite().min(0).max(tileflowMaxPitch)
+    }).strict().optional()
+  }).strict().optional(),
   data: dataSchema.optional(),
   defaultTheme: tileflowThemeNameSchema,
   fonts: fontDirectoriesSchema.optional(),
@@ -18750,8 +19202,8 @@ function isSafeGlyphUrl(value) {
 function validateZoomRanges(value, context, path = []) {
   if (!value || typeof value !== "object") return;
   if (!Array.isArray(value)) {
-    const record4 = value;
-    if (typeof record4.minZoom === "number" && typeof record4.maxZoom === "number" && record4.minZoom > record4.maxZoom) {
+    const record5 = value;
+    if (typeof record5.minZoom === "number" && typeof record5.maxZoom === "number" && record5.minZoom > record5.maxZoom) {
       context.addIssue({
         code: "custom",
         path: [...path, "maxZoom"],
@@ -19451,8 +19903,8 @@ function validateTileflowCompiledIconCapabilities(style, icons) {
   const checked = structuredClone(style);
   applyTileflowIconCapabilities(checked, icons);
   for (const [index, layer] of checked.layers.entries()) {
-    const originalPaint = record3(style.layers[index]?.paint);
-    const checkedPaint = record3(layer.paint);
+    const originalPaint = record4(style.layers[index]?.paint);
+    const checkedPaint = record4(layer.paint);
     for (const property of ["icon-color", "icon-halo-color", "icon-halo-width", "icon-halo-blur"]) {
       if (originalPaint[property] === void 0 && checkedPaint[property] !== void 0) {
         throw Object.assign(
@@ -19483,7 +19935,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",
@@ -19492,7 +19944,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.`), {
@@ -19514,7 +19966,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]
@@ -19544,7 +19996,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) {
@@ -20402,6 +20854,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
   );
@@ -20567,7 +21028,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
   );
@@ -20705,10 +21167,10 @@ function stableSerialize(value) {
 }
 
 // src/cartography/scene-3d-metadata.ts
+init_color_program();
 init_values();
 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) {
@@ -20731,7 +21193,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 = isRecord13(style.surfaces) ? readTileflowBuildingSurfaces(
+  const surfaces = isRecord13(style.surfaces) ? mapColorProgramsThrough(
     Object.fromEntries(
       Object.entries(style.surfaces).map(([key, entry]) => [
         key,
@@ -20742,7 +21204,8 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
           ])
         ) : entry
       ])
-    )
+    ),
+    readTileflowBuildingSurfaces
   ) : void 0;
   return {
     source: context.data.sourceId,
@@ -20756,18 +21219,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),
     ...isRecord13(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
+      )
     } : {},
     ...isRecord13(style.modelLighting) ? {
-      modelLighting: readModelRoleLighting(
+      modelLighting: mapColorProgramsThrough(
         Object.fromEntries(
           Object.entries(style.modelLighting).filter(([, entry]) => isRecord13(entry)).map(([role, entry]) => {
             const own = entry;
@@ -20798,7 +21264,8 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
               }
             ];
           })
-        )
+        ),
+        readModelRoleLighting
       )
     } : {},
     windows: style.windows === true,
@@ -20852,7 +21319,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 } : {};
 }
@@ -20873,7 +21341,7 @@ function tileflowStreetLightsDesignOf(module, context) {
       ...layers2.sidewalk ? { sidewalk: layers2.sidewalk } : {}
     },
     estimate: estimate === "streets" || estimate === "none" || estimate === "lit" ? estimate : "lit",
-    color: typeof color3 === "string" ? color3 : tileflowDefaultStreetLightsDesign.color,
+    color: typeof color3 === "string" || isColorProgramMarker(color3) ? color3 : tileflowDefaultStreetLightsDesign.color,
     intensity: typeof intensity === "number" ? intensity : 1
   };
 }
@@ -20940,7 +21408,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,
@@ -20948,6 +21416,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));
@@ -21040,7 +21513,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));
@@ -21342,7 +21816,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",
@@ -21398,16 +21872,73 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       [tileflowOverlayPlacementManifestMetadataKey]: overlayPlacementManifest,
       "tileflow:modules": Object.entries(modules).filter(([, module]) => !isRecord14(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 ? {
@@ -21689,8 +22220,8 @@ function runCompilationPhase(phase, operation) {
   }
 }
 function withCompilationPhase(error, phase) {
-  const record4 = isRecord14(error) ? error : {};
-  if (typeof record4.phase === "string") return error;
+  const record5 = isRecord14(error) ? error : {};
+  if (typeof record5.phase === "string") return error;
   if (error instanceof Error && Object.isExtensible(error)) {
     Object.defineProperty(error, "phase", { configurable: true, enumerable: true, value: phase });
     return error;
@@ -21706,7 +22237,7 @@ function withCompilationPhase(error, phase) {
     "severity",
     "target"
   ]) {
-    if (record4[key] !== void 0) Object.assign(wrapped, { [key]: record4[key] });
+    if (record5[key] !== void 0) Object.assign(wrapped, { [key]: record5[key] });
   }
   Object.assign(wrapped, { phase });
   return wrapped;
@@ -23183,16 +23714,16 @@ function parseBoundaryLookupCsv(text) {
     throw new Error("Boundaries lookup CSV must start with a header that has id and class.");
   }
   const rows = [];
-  records.forEach((record4, index) => {
-    if (record4.length === 1 && record4[0] === "") return;
-    if (record4.length !== header.length) {
+  records.forEach((record5, index) => {
+    if (record5.length === 1 && record5[0] === "") return;
+    if (record5.length !== header.length) {
       throw new Error(
-        `Boundaries lookup CSV row ${index + 2} has ${record4.length} fields; expected ${header.length}.`
+        `Boundaries lookup CSV row ${index + 2} has ${record5.length} fields; expected ${header.length}.`
       );
     }
     const row = {};
     header.forEach((column2, position) => {
-      const cell = record4[position];
+      const cell = record5[position];
       if (cell === "" || !lookupColumns.has(column2)) return;
       if (numericLookupColumns.has(column2)) {
         const number = Number(cell);
@@ -23213,7 +23744,7 @@ function parseBoundaryLookupCsv(text) {
 }
 function parseCsv(text) {
   const records = [];
-  let record4 = [];
+  let record5 = [];
   let field2 = "";
   let quoted = false;
   for (let index = 0; index < text.length; index += 1) {
@@ -23232,22 +23763,22 @@ function parseCsv(text) {
     } else if (char === '"' && field2 === "") {
       quoted = true;
     } else if (char === ",") {
-      record4.push(field2);
+      record5.push(field2);
       field2 = "";
     } else if (char === "\n" || char === "\r") {
       if (char === "\r" && text[index + 1] === "\n") index += 1;
-      record4.push(field2);
-      records.push(record4);
-      record4 = [];
+      record5.push(field2);
+      records.push(record5);
+      record5 = [];
       field2 = "";
     } else {
       field2 += char;
     }
   }
   if (quoted) throw new Error("Boundaries lookup CSV ends inside a quoted field.");
-  if (field2 !== "" || record4.length > 0) {
-    record4.push(field2);
-    records.push(record4);
+  if (field2 !== "" || record5.length > 0) {
+    record5.push(field2);
+    records.push(record5);
   }
   return records;
 }
@@ -24151,6 +24682,7 @@ function resolveTileflowRuntimeStyle(options) {
         styleId: theme.styleId
       },
       colorScheme: theme.colorScheme,
+      ...options.manifestMap.familyUrl ? { familyUrl: options.manifestMap.familyUrl } : {},
       ...theme.fontFaces === void 0 ? {} : { fontFaces: [...theme.fontFaces] },
       revision: theme.revision,
       style: theme.styleUrl,
@@ -24341,7 +24873,8 @@ function createTileflowSessionController(input) {
 async function requestSessionGrant(input) {
   return runWithinSessionGrantTimeout(input.timeoutMs, async (signal) => {
     const apiUrl = getTileflowAnalyticsApiUrl(input.analytics);
-    const response = await input.fetchGrant(`${apiUrl}/v1/sessions/start`, {
+    const fetchGrant = input.fetchGrant;
+    const response = await fetchGrant(`${apiUrl}/v1/sessions/start`, {
       body: JSON.stringify({
         mapId: input.analytics.mapId,
         sdkVersion: input.analytics.sdkVersion,
@@ -24667,6 +25200,7 @@ function resolveLoadedTileflowManifestUrls(manifest, manifestUrl) {
         mapName,
         {
           ...entry,
+          ...entry.familyUrl ? { familyUrl: resolveTileflowLoadedResourceUrl(entry.familyUrl, manifestUrl) } : {},
           themes: Object.fromEntries(
             Object.entries(entry.themes).map(([themeName, theme]) => {
               const styleUrl = resolveTileflowLoadedResourceUrl(theme.styleUrl, manifestUrl);
@@ -24716,6 +25250,7 @@ function resolveTileflowManifestMap(manifest, mapName) {
     mapId: entry.mapId ?? analytics?.mapId,
     name: mapName,
     defaultTheme: entry.defaultTheme,
+    ...entry.familyUrl ? { familyUrl: entry.familyUrl } : {},
     ...entry.environment ? { environment: entry.environment } : {},
     ...entry.systemThemes ? { systemThemes: { ...entry.systemThemes } } : {},
     ...entry.timeOfDay ? { timeOfDay: entry.timeOfDay } : {},
@@ -25539,14 +26074,14 @@ function tileflowModelImageSize(bytes, mimeType) {
   for (let at = 2; at + 4 <= bytes.length; ) {
     if (bytes[at++] !== 255) return void 0;
     while (bytes[at] === 255) at++;
-    const marker = bytes[at++];
-    if (marker === 217 || marker === 218) return void 0;
-    if (marker === 1 || marker >= 208 && marker <= 215) continue;
+    const marker2 = bytes[at++];
+    if (marker2 === 217 || marker2 === 218) return void 0;
+    if (marker2 === 1 || marker2 >= 208 && marker2 <= 215) continue;
     if (at + 2 > bytes.length) return void 0;
     const length = view.getUint16(at);
     if (length < 2 || at + length > bytes.length) return void 0;
     if ([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207].includes(
-      marker
+      marker2
     )) {
       if (length < 8) return void 0;
       const height = view.getUint16(at + 3), width = view.getUint16(at + 5);