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

package/dist/runtime.js

@@ -86,13 +86,2398 @@ var init_time_of_day = __esm({
   }
 });
 
+// src/cartography/expression-operators.ts
+function isMapLibreExpressionOperator(value) {
+  return typeof value === "string" && mapLibreExpressionOperators.has(value);
+}
+var mapLibreExpressionOperators;
+var init_expression_operators = __esm({
+  "src/cartography/expression-operators.ts"() {
+    "use strict";
+    mapLibreExpressionOperators = /* @__PURE__ */ new Set([
+      "!",
+      "!=",
+      "%",
+      "*",
+      "+",
+      "-",
+      "/",
+      "<",
+      "<=",
+      "==",
+      ">",
+      ">=",
+      "^",
+      "abs",
+      "accumulated",
+      "acos",
+      "all",
+      "any",
+      "array",
+      "asin",
+      "at",
+      "atan",
+      "boolean",
+      "case",
+      "ceil",
+      "coalesce",
+      "collator",
+      "concat",
+      "cos",
+      "distance",
+      "downcase",
+      "e",
+      "elevation",
+      "error",
+      "feature-state",
+      "filter-<",
+      "filter-<=",
+      "filter-==",
+      "filter->",
+      "filter->=",
+      "filter-has",
+      "filter-has-id",
+      "filter-id-<",
+      "filter-id-<=",
+      "filter-id-==",
+      "filter-id->",
+      "filter-id->=",
+      "filter-id-in",
+      "filter-in-large",
+      "filter-in-small",
+      "filter-type-==",
+      "filter-type-in",
+      "floor",
+      "format",
+      "geometry-type",
+      "get",
+      "global-state",
+      "has",
+      "heatmap-density",
+      "id",
+      "image",
+      "in",
+      "index-of",
+      "interpolate",
+      "interpolate-hcl",
+      "interpolate-lab",
+      "is-supported-script",
+      "join",
+      "length",
+      "let",
+      "line-progress",
+      "literal",
+      "ln",
+      "ln2",
+      "log10",
+      "log2",
+      "match",
+      "max",
+      "min",
+      "number",
+      "number-format",
+      "object",
+      "pi",
+      "properties",
+      "resolved-locale",
+      "rgb",
+      "rgba",
+      "round",
+      "sin",
+      "slice",
+      "split",
+      "sqrt",
+      "step",
+      "string",
+      "tan",
+      "to-boolean",
+      "to-color",
+      "to-number",
+      "to-rgba",
+      "to-string",
+      "typeof",
+      "upcase",
+      "var",
+      "within",
+      "zoom"
+    ]);
+  }
+});
+
+// src/cartography/values.ts
+function isTileflowThemeTokenReference(value) {
+  return isRecord(value) && hasExactOwnKeys(value, ["category", "kind", "token"]) && value.kind === "theme-token" && typeof value.token === "string" && /^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)*$/.test(value.token) && tileflowThemeTokenCategories.includes(value.category);
+}
+function isTileflowFixedValue(value) {
+  return isRecord(value) && hasExactOwnKeys(value, ["kind", "reason", "value"]) && value.kind === "theme-fixed" && typeof value.reason === "string" && Boolean(value.reason.trim()) && Object.hasOwn(value, "value");
+}
+function isTileflowThemeColorOperation(value) {
+  if (!isRecord(value) || value.kind !== "theme-color") return false;
+  if (value.operation === "alpha") {
+    return hasExactOwnKeys(value, ["color", "kind", "opacity", "operation"]) && Object.hasOwn(value, "color") && Object.hasOwn(value, "opacity");
+  }
+  return value.operation === "mix" && hasExactOwnKeys(value, ["amount", "from", "kind", "operation", "space", "to"]) && value.space === "oklch" && Object.hasOwn(value, "amount") && Object.hasOwn(value, "from") && Object.hasOwn(value, "to");
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function hasExactOwnKeys(value, expectedKeys) {
+  const ownKeys = Reflect.ownKeys(value);
+  return ownKeys.length === expectedKeys.length && ownKeys.every((key) => typeof key === "string" && expectedKeys.includes(key));
+}
+var tileflowThemeTokenCategories;
+var init_values = __esm({
+  "src/cartography/values.ts"() {
+    "use strict";
+    tileflowThemeTokenCategories = Object.freeze([
+      "color",
+      "font",
+      "image",
+      "number"
+    ]);
+  }
+});
+
+// src/maps/operations.ts
+function isTileflowReset(value) {
+  if (!isPlainRecord(value)) return false;
+  return value.$tileflow === "reset" && Object.keys(value).length === 1;
+}
+function deepFreeze(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const child of Object.values(value)) deepFreeze(child);
+  return value;
+}
+function isPlainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+var resetValue, disableValue;
+var init_operations = __esm({
+  "src/maps/operations.ts"() {
+    "use strict";
+    resetValue = deepFreeze({ $tileflow: "reset" });
+    disableValue = deepFreeze({ op: "disable" });
+  }
+});
+
+// src/theme-blend.ts
+function planTileflowThemeBlend(styles, options = {}) {
+  if (styles.length < 2)
+    throw new TileflowThemeBlendError("A theme blend needs two or more themes.");
+  const [base] = styles;
+  assertSameStructure(styles, base);
+  const mixedImages = new Set(imageProperties);
+  if (options.iconImages === "switch") mixedImages.delete("icon-image");
+  const paints = [];
+  const switches = [];
+  const imageGroups = collectImageNames(styles, base, mixedImages);
+  const symbolLayers = /* @__PURE__ */ new Set();
+  const images = /* @__PURE__ */ new Map();
+  let splitLayers = 0;
+  let copiedLayers = 0;
+  let switchedLayers = 0;
+  const layers = [];
+  for (const [index, layer] of base.layers.entries()) {
+    const variants = styles.map((style) => style.layers[index]);
+    layers.push(...planLayer(variants, String(layer.type)));
+  }
+  const switchesByLayer = /* @__PURE__ */ new Map();
+  for (const entry of switches) {
+    const list = switchesByLayer.get(entry.layer) ?? [];
+    list.push(entry);
+    switchesByLayer.set(entry.layer, list);
+  }
+  const sky = differingRoot(styles, "sky");
+  const light = differingRoot(styles, "light");
+  const metadata = alignInteractionManifest(base.metadata, layers);
+  return {
+    themes: styles.length,
+    paints,
+    images: [...images.values()],
+    switches,
+    ...sky === void 0 ? {} : { sky },
+    ...light === void 0 ? {} : { light },
+    summary: { splitLayers, copiedLayers, switchedLayers, switchedValues: switches.length },
+    styleAt(position) {
+      const at = clampPosition(position, styles.length);
+      const dominant = Math.round(at);
+      const style = {
+        ...base,
+        ...metadata === void 0 ? {} : { metadata },
+        // Symbols show the nearest theme, as the label cross-fade leaves them between changes.
+        layers: layers.map(
+          (layer) => fillLayer(
+            layer,
+            symbolLayers.has(String(layer.id)) ? dominant : at,
+            dominant,
+            switchesByLayer.get(String(layer.id))
+          )
+        )
+      };
+      if (sky !== void 0) style.sky = fillTemplate(sky, at);
+      if (light !== void 0) style.light = fillTemplate(light, at);
+      return style;
+    }
+  };
+  function planLayer(variants, type) {
+    const [layer] = variants;
+    const id = String(layer.id);
+    const paint = { ...layer.paint };
+    const layout = { ...layer.layout };
+    const follows = type === "symbol" ? "dominant" : "position";
+    const ownPaints = [];
+    const ownSwitches = [];
+    const driven = [];
+    const paintOf = (variant) => variant.paint ?? {};
+    for (const group of ["layout", "paint"]) {
+      const target = group === "paint" ? paint : layout;
+      for (const property of propertyNames(variants, group)) {
+        const values = variants.map(
+          (variant) => variant[group]?.[property]
+        );
+        if (values.every((value) => same2(value, values[0]))) continue;
+        if (mixedImages.has(property)) {
+          const tuples = imageTuples(values);
+          if (tuples && tuples.every((names) => imageGroups.get(names[0])?.size === 1)) {
+            for (const names of tuples) {
+              if (names.every((name) => name === names[0])) continue;
+              images.set(JSON.stringify(names), {
+                names,
+                follows: property === "icon-image" ? "dominant" : "position"
+              });
+            }
+            continue;
+          }
+        }
+        if (group === "layout" || values.includes(void 0) || imageProperties.has(property)) {
+          ownSwitches.push({ group, property, values });
+          continue;
+        }
+        if (values.some(isDataDriven)) {
+          driven.push(property);
+          continue;
+        }
+        const template = tryMixTemplate(values);
+        if (template === void 0) {
+          ownSwitches.push({ group, property, values });
+          continue;
+        }
+        ownPaints.push({ property, template });
+        target[property] = template;
+      }
+    }
+    const planned = { ...layer, paint, layout };
+    let results = [{ layer: planned, extra: [] }];
+    if (driven.length > 0) {
+      const split = type === "symbol" ? void 0 : splitLayer();
+      const copies = split ?? (type === "symbol" ? void 0 : copyLayer());
+      if (copies) results = copies;
+      else
+        for (const property of driven)
+          ownSwitches.push({
+            group: "paint",
+            property,
+            values: variants.map((variant) => paintOf(variant)[property])
+          });
+    }
+    if (options.featureSwitches === "layers" && results.length === 1 && ownSwitches.some((entry) => entry.values.some(isDataDriven)))
+      results = switchLayer();
+    for (const result of results) {
+      const resultId = String(result.layer.id);
+      if (type === "symbol") symbolLayers.add(resultId);
+      const overridden = new Set(result.extra.map((entry) => entry.property));
+      for (const entry of [
+        ...ownPaints.filter((own) => !overridden.has(own.property)),
+        ...result.extra
+      ])
+        paints.push({ layer: resultId, property: entry.property, template: entry.template, follows });
+      if (result.visibility)
+        switches.push({
+          layer: resultId,
+          group: "layout",
+          property: "visibility",
+          values: result.visibility
+        });
+      else for (const entry of ownSwitches) switches.push({ layer: resultId, ...entry });
+    }
+    return results.map((result) => result.layer);
+    function switchLayer() {
+      switchedLayers += variants.length;
+      return variants.map((_, theme) => {
+        const copyPaint = { ...paint };
+        const copyLayout = { ...layout };
+        for (const entry of ownSwitches) {
+          const target = entry.group === "paint" ? copyPaint : copyLayout;
+          const value = entry.values[theme];
+          if (value === void 0) delete target[entry.property];
+          else target[entry.property] = value;
+        }
+        const shown = copyLayout.visibility === "none" ? "none" : "visible";
+        return {
+          layer: { ...planned, id: `${id}::theme-${theme}`, paint: copyPaint, layout: copyLayout },
+          extra: [],
+          visibility: variants.map((__, nearest) => nearest === theme ? shown : "none")
+        };
+      });
+    }
+    function splitLayer() {
+      if (isLegacyFilter(layer.filter)) return void 0;
+      const values = driven.map(
+        (property) => [
+          property,
+          variants.map((variant) => inlineBranchBindings(paintOf(variant)[property]))
+        ]
+      );
+      if (values.some(([, entries]) => entries.some((entry) => !entry))) return void 0;
+      const branches = splitBranches(
+        Object.fromEntries(
+          values.map(([property, entries]) => [property, entries.map((entry) => entry.value)])
+        )
+      );
+      if (!branches) return void 0;
+      const groups = /* @__PURE__ */ new Map();
+      for (const branch of branches) {
+        const key = JSON.stringify(branch.valuesByProperty);
+        let group = groups.get(key);
+        if (!group) {
+          const templates = {};
+          for (const [property, values2] of Object.entries(branch.valuesByProperty)) {
+            const template = tryMixTemplate(values2);
+            if (template === void 0) return void 0;
+            templates[property] = template;
+          }
+          group = { templates, conditions: [] };
+          groups.set(key, group);
+        }
+        group.conditions.push(
+          branch.conditions.length === 1 ? branch.conditions[0] : ["all", ...branch.conditions]
+        );
+      }
+      splitLayers += groups.size;
+      return [...groups.values()].map((group, number) => {
+        const chosen = group.conditions.length === 1 ? group.conditions[0] : ["any", ...group.conditions];
+        return {
+          layer: {
+            ...planned,
+            id: `${id}::branch-${number}`,
+            filter: layer.filter === void 0 ? chosen : ["all", layer.filter, chosen],
+            paint: { ...paint, ...group.templates }
+          },
+          extra: Object.entries(group.templates).filter(([, template]) => containsLeaf(template)).map(([property, template]) => ({ property, template }))
+        };
+      });
+    }
+    function copyLayer() {
+      const opacity = opacityProperties[type];
+      if (!opacity || variants.some((variant) => isDataDriven(paintOf(variant)[opacity])))
+        return void 0;
+      copiedLayers += variants.length;
+      return variants.map((variant, theme) => {
+        const weight = new BlendLeaf(variants.map((_, other) => other === theme ? 1 : 0));
+        const template = scaleByWeight(paint[opacity] ?? 1, weight);
+        const copyPaint = { ...paint, [opacity]: template };
+        for (const property of driven) copyPaint[property] = paintOf(variant)[property];
+        return {
+          layer: { ...planned, id: `${id}::theme-${theme}`, paint: copyPaint },
+          extra: [{ property: opacity, template }]
+        };
+      });
+    }
+  }
+}
+function fillLayer(layer, position, dominant, layerSwitches) {
+  const filled = { ...layer };
+  for (const group of ["layout", "paint"]) {
+    const values = layer[group];
+    if (!values) continue;
+    const out = {};
+    for (const [key, value] of Object.entries(values)) out[key] = fillTemplate(value, position);
+    for (const entry of layerSwitches ?? []) {
+      if (entry.group !== group) continue;
+      const value = entry.values[dominant];
+      if (value === void 0) delete out[entry.property];
+      else out[entry.property] = value;
+    }
+    if (Object.keys(out).length > 0) filled[group] = out;
+    else delete filled[group];
+  }
+  return filled;
+}
+function fillTemplate(node, position) {
+  if (node instanceof BlendLeaf) return mixLeaf(node.values, position);
+  if (Array.isArray(node)) return node.map((item) => fillTemplate(item, position));
+  if (node && typeof node === "object" && containsLeaf(node)) {
+    return Object.fromEntries(
+      Object.entries(node).map(([key, value]) => [key, fillTemplate(value, position)])
+    );
+  }
+  return node;
+}
+function containsLeaf(node) {
+  if (node instanceof BlendLeaf) return true;
+  if (Array.isArray(node)) return node.some(containsLeaf);
+  if (node && typeof node === "object") return Object.values(node).some(containsLeaf);
+  return false;
+}
+function mixLeaf(values, position) {
+  const at = clampPosition(position, values.length);
+  const index = Math.min(values.length - 2, Math.floor(at));
+  const t = at - index;
+  const from = values[index];
+  const to = values[index + 1];
+  if (t <= 0 || from === to) return from;
+  if (t >= 1) return to;
+  if (typeof from === "number" && typeof to === "number") return from + (to - from) * t;
+  const a = oklab(String(from));
+  const b = oklab(String(to));
+  if (!a || !b) return t < 0.5 ? from : to;
+  return colourFromOklab(a.map((value, channel) => value + (b[channel] - value) * t));
+}
+function clampPosition(position, themes) {
+  if (!Number.isFinite(position)) return 0;
+  return Math.min(themes - 1, Math.max(0, position));
+}
+function assertSameStructure(styles, base) {
+  const ids = (style) => style.layers.map((layer) => layer.id);
+  for (const style of styles) {
+    if (!same2(ids(style), ids(base)))
+      throw new TileflowThemeBlendError(
+        "Blended themes must have the same layers in the same order."
+      );
+    if (!same2(style.sources, base.sources))
+      throw new TileflowThemeBlendError("Blended themes must use the same sources.");
+    if (!same2(style.sprite, base.sprite) || !same2(style.glyphs, base.glyphs))
+      throw new TileflowThemeBlendError("Blended themes must use the same sprite and glyphs.");
+    for (const key of ["projection", "terrain"])
+      if (!same2(style[key], base[key]))
+        throw new TileflowThemeBlendError(`Blended themes must use the same ${key}.`);
+    for (const [index, layer] of style.layers.entries()) {
+      const other = base.layers[index];
+      for (const key of ["type", "source", "source-layer", "filter", "minzoom", "maxzoom"])
+        if (!same2(layer[key], other[key]))
+          throw new TileflowThemeBlendError(
+            `Blended themes differ in ${key} of layer ${JSON.stringify(layer.id)}.`
+          );
+    }
+  }
+}
+function propertyNames(variants, group) {
+  const names = /* @__PURE__ */ new Set();
+  for (const variant of variants)
+    for (const name of Object.keys(variant[group] ?? {})) names.add(name);
+  return [...names];
+}
+function differingRoot(styles, key) {
+  const values = styles.map((style) => style[key]);
+  if (values.every((value) => same2(value, values[0]))) return void 0;
+  return tryMixTemplate(values);
+}
+function collectImageNames(styles, base, properties) {
+  const uses = /* @__PURE__ */ new Map();
+  for (const [index] of base.layers.entries()) {
+    for (const group of ["layout", "paint"]) {
+      for (const property of properties) {
+        const values = styles.map(
+          (style) => style.layers[index]?.[group]?.[property]
+        );
+        if (values[0] === void 0) continue;
+        for (const names of imageTuples(values) ?? []) {
+          const set = uses.get(names[0]) ?? /* @__PURE__ */ new Set();
+          set.add(JSON.stringify(names));
+          uses.set(names[0], set);
+        }
+      }
+    }
+  }
+  return uses;
+}
+function alignInteractionManifest(metadata, layers) {
+  if (!isRecord2(metadata)) return void 0;
+  const planned = /* @__PURE__ */ new Map();
+  for (const [index, layer] of layers.entries()) {
+    const id = String(layer.id);
+    const original = /^(.+)::(?:branch|theme)-\d+$/u.exec(id)?.[1] ?? id;
+    planned.set(original, [...planned.get(original) ?? [], { id, index }]);
+  }
+  let aligned;
+  const interactions = metadata["tileflow:interaction-manifest"];
+  const domains = isRecord2(interactions) ? interactions.domains : void 0;
+  if (isRecord2(interactions) && isRecord2(domains) && isRecord2(domains.poi)) {
+    const poi = domains.poi;
+    if (Array.isArray(poi.layers)) {
+      const poiLayers = poi.layers.flatMap((entry) => {
+        if (!isRecord2(entry) || typeof entry.layerId !== "string") return [entry];
+        const copies = planned.get(entry.layerId);
+        if (!copies) return [entry];
+        return copies.map(({ id, index }) => ({ ...entry, layerId: id, priority: index }));
+      });
+      aligned = {
+        ...metadata,
+        "tileflow:interaction-manifest": {
+          ...interactions,
+          domains: { ...domains, poi: { ...poi, layers: poiLayers } }
+        }
+      };
+    }
+  }
+  const overlays = metadata["tileflow:overlay-placement-manifest"];
+  if (isRecord2(overlays) && isRecord2(overlays.anchors)) {
+    const anchors = Object.fromEntries(
+      Object.entries(overlays.anchors).map(([placement, anchor]) => [
+        placement,
+        typeof anchor === "string" ? planned.get(anchor)?.[0]?.id ?? anchor : anchor
+      ])
+    );
+    aligned = {
+      ...aligned ?? metadata,
+      "tileflow:overlay-placement-manifest": { ...overlays, anchors }
+    };
+  }
+  return aligned;
+}
+function imageTuples(values, out = []) {
+  const [first] = values;
+  if (values.every((value) => typeof value === "string")) {
+    out.push(values);
+    return out;
+  }
+  if (!Array.isArray(first) || typeof first[0] !== "string") {
+    return values.every((value) => same2(value, first)) ? out : void 0;
+  }
+  const operator = first[0];
+  if (!values.every(
+    (value) => Array.isArray(value) && value[0] === operator && value.length === first.length
+  )) {
+    return void 0;
+  }
+  const at = (index) => values.map((value) => value[index]);
+  const sameAt = (index) => at(index).every((value) => same2(value, first[index]));
+  const outputs = [];
+  if (operator === "literal" || operator === "image") outputs.push(1);
+  else if (operator === "coalesce")
+    for (let index = 1; index < first.length; index += 1) outputs.push(index);
+  else if (operator === "match") {
+    if (!sameAt(1)) return void 0;
+    for (let index = 2; index < first.length - 1; index += 2) {
+      if (!sameAt(index)) return void 0;
+      outputs.push(index + 1);
+    }
+    outputs.push(first.length - 1);
+  } else if (operator === "case") {
+    for (let index = 1; index < first.length - 1; index += 2) {
+      if (!sameAt(index)) return void 0;
+      outputs.push(index + 1);
+    }
+    outputs.push(first.length - 1);
+  } else if (operator === "step") {
+    if (!sameAt(1)) return void 0;
+    outputs.push(2);
+    for (let index = 3; index < first.length; index += 2) {
+      if (!sameAt(index)) return void 0;
+      outputs.push(index + 1);
+    }
+  } else {
+    return values.every((value) => same2(value, first)) ? out : void 0;
+  }
+  for (const index of outputs) if (!imageTuples(at(index), out)) return void 0;
+  return out;
+}
+function tryMixTemplate(values) {
+  const [first] = values;
+  if (values.every((value) => same2(value, first))) return first;
+  if (Array.isArray(first) && first[0] !== "literal" && values.every((value) => Array.isArray(value) && value.length === first.length)) {
+    const items = [];
+    for (let index = 0; index < first.length; index += 1) {
+      const item = tryMixTemplate(values.map((value) => value[index]));
+      if (item === void 0 && first[index] !== void 0) return void 0;
+      items.push(item);
+    }
+    return items;
+  }
+  if (first && typeof first === "object" && !Array.isArray(first)) {
+    const keys = Object.keys(first);
+    if (!values.every((value) => value && typeof value === "object" && same2(Object.keys(value), keys)))
+      return void 0;
+    const out = {};
+    for (const key of keys) {
+      const item = tryMixTemplate(values.map((value) => value[key]));
+      if (item === void 0) return void 0;
+      out[key] = item;
+    }
+    return out;
+  }
+  if (values.every((value) => typeof value === "number")) return new BlendLeaf(values);
+  if (values.every((value) => typeof value === "string" && oklab(value)))
+    return new BlendLeaf(values);
+  return void 0;
+}
+function isDataDriven(value) {
+  if (!Array.isArray(value)) return false;
+  if (typeof value[0] === "string" && featureOperators.has(value[0])) return true;
+  return value.some(isDataDriven);
+}
+function decisionOf(node) {
+  if (!Array.isArray(node) || typeof node[0] !== "string") return void 0;
+  const [operator] = node;
+  if (operator === "match" && isDataDriven(node[1])) {
+    const labels = [];
+    const outputs = [];
+    for (let index = 2; index < node.length - 1; index += 2) {
+      labels.push(node[index]);
+      outputs.push(node[index + 1]);
+    }
+    outputs.push(node.at(-1));
+    return {
+      index: ["match", node[1], ...labels.flatMap((label, index) => [label, index]), labels.length],
+      outputs
+    };
+  }
+  if (operator === "case") {
+    const conditions = [];
+    const outputs = [];
+    for (let index = 1; index < node.length - 1; index += 2) {
+      conditions.push(node[index]);
+      outputs.push(node[index + 1]);
+    }
+    outputs.push(node.at(-1));
+    if (!conditions.some(isDataDriven)) return void 0;
+    return {
+      index: [
+        "case",
+        ...conditions.flatMap((condition, index) => [condition, index]),
+        conditions.length
+      ],
+      outputs
+    };
+  }
+  if (operator === "step" && isDataDriven(node[1])) {
+    const outputs = [node[2]];
+    const stops = [];
+    for (let index = 3; index < node.length; index += 2) {
+      stops.push(node[index]);
+      outputs.push(node[index + 1]);
+    }
+    return {
+      index: ["step", node[1], 0, ...stops.flatMap((stop, index) => [stop, index + 1])],
+      outputs
+    };
+  }
+  return void 0;
+}
+function firstDecision(value) {
+  const decision = decisionOf(value);
+  if (decision) return decision;
+  if (!Array.isArray(value) || value[0] === "literal") return void 0;
+  for (const item of value) {
+    const found = firstDecision(item);
+    if (found) return found;
+  }
+  return void 0;
+}
+function choose(value, key, branch) {
+  const decision = decisionOf(value);
+  if (decision && JSON.stringify(decision.index) === key)
+    return choose(decision.outputs[branch], key, branch);
+  if (!Array.isArray(value) || value[0] === "literal") return value;
+  return value.map((item) => choose(item, key, branch));
+}
+function splitBranches(valuesByProperty, conditions = []) {
+  let decision;
+  for (const values of Object.values(valuesByProperty)) {
+    decision = firstDecision(values[0]);
+    if (decision) break;
+  }
+  if (!decision) {
+    const residual = Object.values(valuesByProperty).some((values) => values.some(isDataDriven));
+    return residual ? void 0 : [{ conditions, valuesByProperty }];
+  }
+  if (reads(decision.index, "zoom") || reads(decision.index, "feature-state")) return void 0;
+  const key = JSON.stringify(decision.index);
+  const branches = [];
+  for (let branch = 0; branch < decision.outputs.length; branch += 1) {
+    const chosen = Object.fromEntries(
+      Object.entries(valuesByProperty).map(([property, values]) => [
+        property,
+        values.map((value) => choose(value, key, branch))
+      ])
+    );
+    const nested = splitBranches(chosen, [...conditions, ["==", decision.index, branch]]);
+    if (!nested) return void 0;
+    branches.push(...nested);
+    if (branches.length > maximumBranches) return void 0;
+  }
+  return branches;
+}
+function inlineBranchBindings(input) {
+  const limit = 2e4;
+  const visit = (node, scope, depth) => {
+    if (depth > 96) throw new RangeError("Expression nesting limit");
+    if (!Array.isArray(node) || node[0] === "literal" || isColorProgramMarker(node))
+      return { value: node, size: 1 };
+    if (node[0] === "var") {
+      const bound = scope.get(String(node[1]));
+      if (!bound) throw new TypeError("Unbound branch variable");
+      return bound;
+    }
+    if (node[0] === "let") {
+      const inner = new Map(scope);
+      for (let index = 1; index < node.length - 1; index += 2)
+        inner.set(String(node[index]), visit(node[index + 1], scope, depth + 1));
+      return visit(node.at(-1), inner, depth + 1);
+    }
+    let size = 1;
+    const value = node.map((child) => {
+      const result = visit(child, scope, depth + 1);
+      size += result.size;
+      if (size > limit) throw new RangeError("Expanded branch limit");
+      return result.value;
+    });
+    return { value, size };
+  };
+  try {
+    return { value: visit(input, /* @__PURE__ */ new Map(), 0).value };
+  } catch {
+    return void 0;
+  }
+}
+function scaleByWeight(opacity, weight) {
+  const input = Array.isArray(opacity) ? opacity[0] === "interpolate" ? opacity[2] : opacity[1] : void 0;
+  if (Array.isArray(opacity) && (opacity[0] === "interpolate" || opacity[0] === "step") && reads(input, "zoom")) {
+    const head = opacity[0] === "interpolate" ? 3 : 2;
+    return opacity.map(
+      (item, index) => index >= head && (index - head) % 2 === (opacity[0] === "interpolate" ? 1 : 0) ? scaleByWeight(item, weight) : item
+    );
+  }
+  if (typeof opacity === "number")
+    return new BlendLeaf(weight.values.map((value) => opacity * Number(value)));
+  return ["*", opacity, weight];
+}
+function same2(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+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, alpha]) {
+  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(alpha.toFixed(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 alpha = 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, alpha].some((value) => value === null)) return null;
+    return [r, g, b, alpha];
+  }
+  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 || alpha === 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, alpha];
+}
+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 TileflowThemeBlendError, BlendLeaf, imageProperties, opacityProperties, featureOperators, maximumBranches, isRecord2, reads, isLegacyFilter, oklabCache;
+var init_theme_blend = __esm({
+  "src/theme-blend.ts"() {
+    "use strict";
+    init_color_program();
+    TileflowThemeBlendError = class extends Error {
+      name = "TileflowThemeBlendError";
+    };
+    BlendLeaf = class {
+      constructor(values) {
+        this.values = values;
+      }
+      values;
+    };
+    imageProperties = /* @__PURE__ */ new Set([
+      "icon-image",
+      "fill-pattern",
+      "line-pattern",
+      "background-pattern",
+      "fill-extrusion-pattern"
+    ]);
+    opacityProperties = {
+      background: "background-opacity",
+      circle: "circle-opacity",
+      fill: "fill-opacity",
+      "fill-extrusion": "fill-extrusion-opacity",
+      heatmap: "heatmap-opacity",
+      line: "line-opacity",
+      raster: "raster-opacity"
+    };
+    featureOperators = /* @__PURE__ */ new Set([
+      "feature-state",
+      "geometry-type",
+      "get",
+      "has",
+      "id",
+      "in",
+      "properties"
+    ]);
+    maximumBranches = 24;
+    isRecord2 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+    reads = (value, operator) => Array.isArray(value) && (value[0] === operator || value.some((item) => reads(item, operator)));
+    isLegacyFilter = (filter) => Array.isArray(filter) && typeof filter[1] === "string" && !Array.isArray(filter[1]);
+    oklabCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/sun.ts
+function normalizeTileflowAzimuth(azimuth) {
+  const turned = azimuth % 360;
+  return turned < 0 ? turned + 360 : turned === 0 ? 0 : turned;
+}
+function tileflowSunLight(direction, base) {
+  const radial = base?.position?.[0] ?? 1.15;
+  return {
+    ...base ?? {},
+    anchor: "map",
+    position: [
+      radial,
+      Number(normalizeTileflowAzimuth(direction.azimuth).toFixed(3)),
+      // MapLibre lights the extrusions from above the horizon only.
+      Number(Math.min(90, Math.max(0, 90 - direction.altitude)).toFixed(3))
+    ]
+  };
+}
+var tileflowDefaultSunPreset, degrees;
+var init_sun = __esm({
+  "src/sun.ts"() {
+    "use strict";
+    tileflowDefaultSunPreset = Object.freeze({
+      azimuth: 210,
+      altitude: 60,
+      color: "#ffffff",
+      intensity: 0.2,
+      shadowIntensity: 1,
+      ambient: Object.freeze({ color: "#ffffff", intensity: 0.8 })
+    });
+    degrees = Math.PI / 180;
+  }
+});
+
+// src/themes/visual-semantics.ts
+function isTileflowVisualColorCollection(property) {
+  return property === "colors" || property.endsWith("Colors") || property.endsWith("-colors");
+}
+function classifyTileflowVisualProperty(property, _value) {
+  if (property === "color" || property.endsWith("Color") || property.endsWith("-color") || isTileflowVisualColorCollection(property)) {
+    return "color";
+  }
+  if (property === "font" || property === "fallbacks" || property.endsWith("-font")) return "font";
+  if (property === "image" || property === "pattern" || property.endsWith("-image") || property.endsWith("-pattern")) {
+    return "image";
+  }
+  return visualNumberProperties.has(property) ? "number" : void 0;
+}
+var visualNumberProperties;
+var init_visual_semantics = __esm({
+  "src/themes/visual-semantics.ts"() {
+    "use strict";
+    visualNumberProperties = /* @__PURE__ */ new Set([
+      "angle",
+      "base",
+      "blur",
+      "brightnessScale",
+      "crownScale",
+      "crownAnchor",
+      "sizeAnchor",
+      "sizeCompression",
+      "contrast",
+      "dash",
+      "exaggeration",
+      "emissiveStrength",
+      "emissiveVariation",
+      "emissiveHeight",
+      "colorMix",
+      "colorScale",
+      "metallic",
+      "roughness",
+      "horizonBlend",
+      "hue",
+      "saturation",
+      "lightness",
+      "fadeDuration",
+      "gapWidth",
+      "groundOcclusion",
+      "groundOcclusionRadius",
+      "haloBlur",
+      "haloWidth",
+      "height",
+      "heightScale",
+      "illuminationDirection",
+      "intensity",
+      "letterSpacing",
+      "lineHeight",
+      "maxAngle",
+      "maxWidth",
+      "miterLimit",
+      "modelOcclusion",
+      "offset",
+      "opacity",
+      "padding",
+      "patternWidths",
+      "radius",
+      "radialOffset",
+      "rotate",
+      "roundLimit",
+      "size",
+      "spacing",
+      "starIntensity",
+      "strokeOpacity",
+      "strokeWidth",
+      "textFitPadding",
+      "translate",
+      "width",
+      "widthScale",
+      "background-emissive-strength",
+      "background-opacity",
+      "circle-blur",
+      "circle-emissive-strength",
+      "circle-opacity",
+      "circle-radius",
+      "circle-stroke-opacity",
+      "circle-stroke-width",
+      "circle-translate",
+      "color-relief-opacity",
+      "fill-emissive-strength",
+      "fill-extrusion-ambient-occlusion-ground-attenuation",
+      "fill-extrusion-ambient-occlusion-ground-radius",
+      "fill-extrusion-ambient-occlusion-intensity",
+      "fill-extrusion-ambient-occlusion-radius",
+      "fill-extrusion-base",
+      "fill-extrusion-emissive-strength",
+      "fill-extrusion-flood-light-ground-attenuation",
+      "fill-extrusion-flood-light-ground-radius",
+      "fill-extrusion-flood-light-intensity",
+      "fill-extrusion-flood-light-wall-radius",
+      "fill-extrusion-height",
+      "fill-extrusion-opacity",
+      "fill-extrusion-translate",
+      "fill-extrusion-vertical-scale",
+      "fill-opacity",
+      "fill-translate",
+      "heatmap-intensity",
+      "heatmap-opacity",
+      "heatmap-radius",
+      "heatmap-weight",
+      "hillshade-exaggeration",
+      "hillshade-emissive-strength",
+      "hillshade-illumination-direction",
+      "icon-emissive-strength",
+      "icon-halo-blur",
+      "icon-halo-width",
+      "icon-opacity",
+      "icon-occlusion-opacity",
+      "icon-offset",
+      "icon-padding",
+      "icon-size",
+      "icon-text-fit-padding",
+      "icon-translate",
+      "line-blur",
+      "line-dasharray",
+      "line-emissive-strength",
+      "line-gap-width",
+      "line-miter-limit",
+      "line-opacity",
+      "line-offset",
+      "line-round-limit",
+      "line-translate",
+      "line-width",
+      "raster-brightness-max",
+      "raster-brightness-min",
+      "raster-contrast",
+      "raster-emissive-strength",
+      "raster-fade-duration",
+      "raster-hue-rotate",
+      "raster-opacity",
+      "raster-saturation",
+      "text-emissive-strength",
+      "text-halo-blur",
+      "text-halo-width",
+      "text-letter-spacing",
+      "text-line-height",
+      "text-max-angle",
+      "text-max-width",
+      "text-offset",
+      "text-occlusion-opacity",
+      "text-opacity",
+      "text-padding",
+      "text-radial-offset",
+      "text-rotate",
+      "text-size",
+      "text-translate",
+      "symbol-spacing"
+    ]);
+  }
+});
+
+// src/themes/model.ts
+function resolveTileflowTheme(theme) {
+  assertThemeDocument(theme);
+  const resolver = new ThemeValueResolver(theme);
+  const tokens = {
+    color: resolver.resolveCategory("color"),
+    font: resolver.resolveCategory("font"),
+    image: resolver.resolveCategory("image"),
+    number: resolver.resolveCategory("number")
+  };
+  const typography = resolver.resolveTypography(theme.typography);
+  const { light: lighting, sun } = resolver.resolveLighting(theme.lighting);
+  return {
+    colorScheme: theme.colorScheme,
+    id: theme.id,
+    lighting,
+    ...sun ? { sun } : {},
+    tokens,
+    typography,
+    version: theme.version
+  };
+}
+function resolveThemeValues(value, theme, path = "value") {
+  const resolver = new ThemeValueResolver(theme);
+  resolver.resolveAllTokens();
+  const resolved = resolver.resolveTree(value, path);
+  const errors = auditTileflowThemeValues(value, path).filter(({ severity }) => severity === "error");
+  if (errors.length > 0) throw new TileflowThemeAuditError(errors);
+  return resolved;
+}
+function auditTileflowThemeValues(value, path = "value", context = inferAuditContext(path)) {
+  const diagnostics = [];
+  visitAuditableValue(value, path, void 0, {
+    context,
+    diagnostics,
+    resolvingVariables: /* @__PURE__ */ new Set(),
+    variables: /* @__PURE__ */ new Map()
+  });
+  return diagnostics.sort(compareAuditDiagnostics);
+}
+function visitThemeIntentNode(value, path, expectedCategory, state) {
+  const tokenReference = isTileflowThemeTokenReference(value) ? value : void 0;
+  const fixedValue = isTileflowFixedValue(value) ? value : void 0;
+  const colorOperation = isTileflowThemeColorOperation(value) ? value : void 0;
+  if (!tokenReference && !fixedValue && !colorOperation) {
+    addThemeNodeDiagnostic(
+      expectedCategory ?? inferThemeNodeCategory(value),
+      path,
+      state,
+      themeNodeDisplayValue(value),
+      `Malformed Tileflow ${String(value.kind)} node cannot establish explicit theme intent.`,
+      "Use token.*, fixed(value, {reason}), or color.* constructors without extra fields."
+    );
+    return;
+  }
+  const actualCategory = tokenReference?.category ?? (colorOperation ? "color" : void 0);
+  if (!expectedCategory) {
+    addThemeNodeDiagnostic(
+      actualCategory ?? inferThemeNodeCategory(value),
+      path,
+      state,
+      themeNodeDisplayValue(value),
+      "Tileflow theme values may only be consumed by a categorized visual property.",
+      "Move the value to a color, font, image, or visual-number field; keep structure literal."
+    );
+    return;
+  }
+  if (actualCategory && actualCategory !== expectedCategory) {
+    addThemeNodeDiagnostic(
+      expectedCategory,
+      path,
+      state,
+      themeNodeDisplayValue(value),
+      `Tileflow theme value category mismatch: expected ${expectedCategory}, received ${actualCategory}.`,
+      `Use token.${expectedCategory}(...) or an explicit fixed ${expectedCategory} value.`
+    );
+    return;
+  }
+  if (fixedValue) {
+    if (!isThemePrimitiveForCategory(fixedValue.value, expectedCategory)) {
+      addThemeNodeDiagnostic(
+        expectedCategory,
+        path,
+        state,
+        themeNodeDisplayValue(value),
+        `Tileflow fixed value category mismatch: expected ${expectedCategory}.`,
+        `Use a primitive ${expectedCategory} value inside fixed(value, {reason}).`
+      );
+    }
+    return;
+  }
+  if (!colorOperation) return;
+  if (colorOperation.operation === "alpha") {
+    visitAuditableValue(colorOperation.color, `${path}.color`, "color", state, true);
+    visitAuditableValue(colorOperation.opacity, `${path}.opacity`, "number", state, true);
+    return;
+  }
+  visitAuditableValue(colorOperation.from, `${path}.from`, "color", state, true);
+  visitAuditableValue(colorOperation.to, `${path}.to`, "color", state, true);
+  visitAuditableValue(colorOperation.amount, `${path}.amount`, "number", state, true);
+}
+function addThemeNodeDiagnostic(category, path, state, value, message, suggestion) {
+  state.diagnostics.push({
+    category,
+    code: "THEME_IMPLICIT_FIXED",
+    message,
+    ...state.context.owner ? { owner: state.context.owner } : {},
+    path,
+    phase: "theme-audit",
+    scope: state.context.scope,
+    severity: "error",
+    suggestion,
+    ...state.context.target ? { target: state.context.target } : {},
+    value
+  });
+}
+function inferThemeNodeCategory(value) {
+  if (isThemeTokenCategory(value.category)) return value.category;
+  if (value.kind === "theme-color") return "color";
+  return typeof value.value === "number" ? "number" : "color";
+}
+function themeNodeDisplayValue(value) {
+  if (typeof value.token === "string") return value.token;
+  if (typeof value.value === "string" || typeof value.value === "number") return value.value;
+  if (typeof value.operation === "string") return value.operation;
+  return String(value.kind);
+}
+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 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;
+  if (isThemeValueCandidate(value)) {
+    visitThemeIntentNode(value, path, category, state);
+    return;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    addAuditDiagnostic(value, path, category, state, intentRequired);
+    return;
+  }
+  if (Array.isArray(value)) {
+    visitAuditableArray(value, path, category, state, false, intentRequired);
+    return;
+  }
+  if (!isRecord3(value)) return;
+  if (value.kind === "expression" && Array.isArray(value.value)) {
+    visitAuditableArray(value.value, `${path}.value`, category, state, true, intentRequired);
+    return;
+  }
+  if (value.kind === "zoom" && Array.isArray(value.stops)) {
+    for (const [index, stop] of value.stops.entries()) {
+      if (Array.isArray(stop)) {
+        visitAuditableValue(stop[0], `${path}.stops[${index}][0]`, void 0, state);
+        visitAuditableValue(
+          stop[1],
+          `${path}.stops[${index}][1]`,
+          category,
+          state,
+          category !== void 0 && category !== "number"
+        );
+      }
+    }
+    return;
+  }
+  const collectionCategory = isTileflowVisualColorCollection(lastPathKey(path)) ? category : void 0;
+  for (const key of Object.keys(value).sort(compareCodeUnits)) {
+    visitAuditableValue(
+      value[key],
+      `${path}.${key}`,
+      classifyTileflowVisualProperty(key, value[key]) ?? collectionCategory,
+      state
+    );
+  }
+}
+function lastPathKey(path) {
+  return path.endsWith("]") ? "" : path.slice(path.lastIndexOf(".") + 1);
+}
+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) {
+    for (const [index, entry] of value.entries()) {
+      visitAuditableValue(entry, `${path}[${index}]`, category, state, intentRequired);
+    }
+    return;
+  }
+  visitExpressionOutputs(value, path, category, state, intentRequired);
+}
+function visitExpressionOutputs(value, path, category, state, intentRequired) {
+  const operator = typeof value[0] === "string" ? value[0] : void 0;
+  if (!operator) return;
+  if (operator === "let") {
+    const variables = new Map(state.variables);
+    for (let index = 1; index < value.length - 1; index += 2) {
+      const name = value[index];
+      if (typeof name === "string") {
+        variables.set(name, { path: `${path}[${index + 1}]`, value: value[index + 1] });
+      }
+    }
+    if (value.length > 1) {
+      visitAuditableValue(
+        value.at(-1),
+        `${path}[${value.length - 1}]`,
+        category,
+        { ...state, variables },
+        intentRequired || category !== void 0 && category !== "number"
+      );
+    }
+    return;
+  }
+  if (operator === "var") {
+    const name = value[1];
+    if (typeof name !== "string" || state.resolvingVariables.has(name)) {
+      addDynamicExpressionDiagnostic(
+        operator,
+        path,
+        category,
+        state,
+        intentRequired || category !== void 0 && category !== "number"
+      );
+      return;
+    }
+    const variable = state.variables.get(name);
+    if (!variable) {
+      addDynamicExpressionDiagnostic(
+        operator,
+        path,
+        category,
+        state,
+        intentRequired || category !== void 0 && category !== "number"
+      );
+      return;
+    }
+    visitAuditableValue(
+      variable.value,
+      variable.path,
+      category,
+      { ...state, resolvingVariables: /* @__PURE__ */ new Set([...state.resolvingVariables, name]) },
+      intentRequired
+    );
+    return;
+  }
+  if (operator === "literal") {
+    if (value.length > 1) {
+      visitLiteralOutput(value[1], `${path}[1]`, category, state, intentRequired);
+    }
+    return;
+  }
+  if (expressionDataOperators.has(operator)) {
+    for (let index = 1; index < value.length; index += 1) {
+      visitAuditableValue(value[index], `${path}[${index}]`, void 0, state);
+    }
+    addDynamicExpressionDiagnostic(
+      operator,
+      path,
+      category,
+      state,
+      intentRequired || category !== void 0 && category !== "number"
+    );
+    return;
+  }
+  if (operator === "rgb" || operator === "rgba") {
+    for (let index = 1; index < value.length; index += 1) {
+      visitAuditableValue(value[index], `${path}[${index}]`, void 0, state);
+    }
+    addDynamicExpressionDiagnostic(operator, path, category, state, true);
+    return;
+  }
+  const outputIndices = new Set(expressionOutputIndices(operator, value.length));
+  for (let index = 1; index < value.length; index += 1) {
+    const isOutput = outputIndices.has(index);
+    visitAuditableValue(
+      value[index],
+      `${path}[${index}]`,
+      isOutput ? category : void 0,
+      state,
+      isOutput && (intentRequired || category !== void 0 && category !== "number")
+    );
+  }
+}
+function visitLiteralOutput(value, path, category, state, intentRequired) {
+  if (Array.isArray(value)) {
+    for (const [index, entry] of value.entries()) {
+      visitLiteralOutput(entry, `${path}[${index}]`, category, state, intentRequired);
+    }
+    return;
+  }
+  visitAuditableValue(value, path, category, state, intentRequired);
+}
+function addAuditDiagnostic(value, path, category, state, blocking = false) {
+  if (!category) return;
+  if (category === "number") {
+    if (typeof value !== "number" || !Number.isFinite(value)) return;
+  } else {
+    if (typeof value !== "string") return;
+  }
+  state.diagnostics.push({
+    category,
+    code: "THEME_IMPLICIT_FIXED",
+    message: `Visual ${category} literal is implicitly fixed; use token.${category}(...) or fixed(value, {reason}).`,
+    ...state.context.owner ? { owner: state.context.owner } : {},
+    path,
+    phase: "theme-audit",
+    scope: state.context.scope,
+    severity: category === "number" && !blocking ? "warning" : "error",
+    suggestion: `Replace the literal with token.${category}(...) or document the invariant with fixed(value, {reason}).`,
+    ...state.context.target ? { target: state.context.target } : {},
+    value
+  });
+}
+function addDynamicExpressionDiagnostic(operator, path, category, state, intentRequired) {
+  if (!category || category === "number" || !intentRequired) return;
+  state.diagnostics.push({
+    category,
+    code: "THEME_IMPLICIT_FIXED",
+    message: `Visual ${category} expression has a dynamic output from ${operator}; every possible output must be token.${category}(...), fixed(value, {reason}), or a valid theme color operation.`,
+    ...state.context.owner ? { owner: state.context.owner } : {},
+    path,
+    phase: "theme-audit",
+    scope: state.context.scope,
+    severity: "error",
+    suggestion: `Make every ${category} output branch carry explicit theme intent.`,
+    ...state.context.target ? { target: state.context.target } : {},
+    value: operator
+  });
+}
+function expressionOutputIndices(operator, length) {
+  switch (operator) {
+    case "case":
+      return uniqueIndices([...range(2, length - 1, 2), length - 1]);
+    case "match":
+      return uniqueIndices([...range(3, length - 1, 2), length - 1]);
+    case "step":
+      return range(2, length, 2);
+    case "interpolate":
+    case "interpolate-hcl":
+    case "interpolate-lab":
+      return range(4, length, 2);
+    case "format":
+      return range(1, length, 2);
+    case "at":
+      return length > 2 ? [2] : [];
+    case "array":
+      return length > 1 ? [length - 1] : [];
+    case "image":
+      return length > 1 ? [1] : [];
+    case "coalesce":
+    case "concat":
+    case "join":
+    case "boolean":
+    case "number":
+    case "object":
+    case "string":
+    case "to-boolean":
+    case "to-color":
+    case "to-number":
+    case "to-string":
+      return range(1, length, 1);
+    default:
+      return range(1, length, 1);
+  }
+}
+function uniqueIndices(indices) {
+  return [...new Set(indices)];
+}
+function inferAuditContext(path) {
+  if (path === "terrain" || path.startsWith("terrain.")) return { scope: "terrain" };
+  if (path === "modules" || path.startsWith("modules.")) {
+    const owner = path.match(/^modules\.([^.[]+)/u)?.[1];
+    return { scope: "module", ...owner ? { owner } : {} };
+  }
+  return { scope: "value" };
+}
+function compareAuditDiagnostics(left, right) {
+  const leftKey = [
+    left.scope,
+    left.owner ?? "",
+    left.target ?? "",
+    left.path,
+    left.category,
+    typeof left.value,
+    String(left.value)
+  ];
+  const rightKey = [
+    right.scope,
+    right.owner ?? "",
+    right.target ?? "",
+    right.path,
+    right.category,
+    typeof right.value,
+    String(right.value)
+  ];
+  for (let index = 0; index < leftKey.length; index += 1) {
+    const compared = compareCodeUnits(leftKey[index], rightKey[index]);
+    if (compared !== 0) return compared;
+  }
+  return 0;
+}
+function range(start, end, step) {
+  const values = [];
+  for (let index = start; index < end; index += step) values.push(index);
+  return values;
+}
+function assertThemeIdentity(theme) {
+  if (!isThemeName(theme.id)) {
+    throw new Error(
+      `Invalid Tileflow theme id ${JSON.stringify(theme.id)}; expected a portable identifier.`
+    );
+  }
+  if (!Number.isSafeInteger(theme.version) || theme.version < 1) {
+    throw new Error(`Tileflow theme "${theme.id}" version must be a positive integer.`);
+  }
+  if (theme.colorScheme !== "light" && theme.colorScheme !== "dark") {
+    throw new Error(`Tileflow theme "${theme.id}" colorScheme must be light or dark.`);
+  }
+}
+function assertThemeDocument(theme) {
+  const record3 = assertPlainThemeRecord(theme, "theme");
+  assertExactThemeKeys(record3, "theme", themeDocumentKeys);
+  assertRequiredThemeKeys(record3, "theme", themeDocumentKeys);
+  assertThemeIdentity(theme);
+  assertThemeTokens(record3.tokens, "theme.tokens", true);
+  assertThemeTypography(record3.typography, "theme.typography");
+  assertThemeLighting(record3.lighting, "theme.lighting");
+  cloneJson(theme);
+}
+function assertThemeTokens(value, path, complete) {
+  const tokens = assertPlainThemeRecord(value, path);
+  assertExactThemeKeys(tokens, path, tileflowThemeTokenCategories);
+  if (complete) assertRequiredThemeKeys(tokens, path, tileflowThemeTokenCategories);
+  for (const category of tileflowThemeTokenCategories) {
+    if (!Object.hasOwn(tokens, category)) continue;
+    const values = assertPlainThemeRecord(tokens[category], `${path}.${category}`);
+    for (const name of Reflect.ownKeys(values)) {
+      if (typeof name !== "string") {
+        throw new Error(
+          `Invalid Tileflow ${category} token key ${String(name)} at ${path}.${category}.`
+        );
+      }
+      assertTokenName(name, category);
+      assertThemeCategoryValue(values[name], category, `${path}.${category}.${name}`);
+    }
+  }
+}
+function assertThemeTypography(value, path) {
+  const typography = assertPlainThemeRecord(value, path);
+  assertExactThemeKeys(typography, path, themeTypographyKeys);
+  assertThemeTypographyStyleFields(typography, path);
+  for (const domain of themeTypographyDomains) {
+    if (!Object.hasOwn(typography, domain)) continue;
+    const stylePath = `${path}.${domain}`;
+    const style = assertPlainThemeRecord(typography[domain], stylePath);
+    assertExactThemeKeys(style, stylePath, themeTypographyStyleKeys);
+    assertThemeTypographyStyleFields(style, stylePath);
+  }
+}
+function assertThemeTypographyStyleFields(style, path) {
+  if (Object.hasOwn(style, "font")) {
+    assertThemeCategoryValue(style.font, "font", `${path}.font`);
+  }
+  if (Object.hasOwn(style, "fallbacks")) {
+    if (!Array.isArray(style.fallbacks)) {
+      throw themeTypeError(`${path}.fallbacks`, "font array", style.fallbacks);
+    }
+    for (const [index, fallback] of style.fallbacks.entries()) {
+      assertThemeCategoryValue(fallback, "font", `${path}.fallbacks[${index}]`);
+    }
+  }
+  if (Object.hasOwn(style, "letterSpacing")) {
+    assertThemeCategoryValue(style.letterSpacing, "number", `${path}.letterSpacing`);
+  }
+  if (Object.hasOwn(style, "transform") && !["lowercase", "none", "uppercase"].includes(String(style.transform))) {
+    throw themeTypeError(`${path}.transform`, "text transform", style.transform);
+  }
+}
+function assertThemeLighting(value, path, allowReset = false) {
+  if (allowReset && isTileflowReset(value)) return;
+  const authored = assertPlainThemeRecord(value, path);
+  assertExactThemeKeys(authored, path, themeLightingKeys);
+  const lighting = allowReset ? Object.fromEntries(Object.entries(authored).filter(([, entry]) => !isTileflowReset(entry))) : authored;
+  if (Object.hasOwn(lighting, "sun")) {
+    const sun = assertPlainThemeRecord(lighting.sun, `${path}.sun`);
+    assertExactThemeKeys(sun, `${path}.sun`, themeSunKeys);
+    for (const key of ["altitude", "azimuth", "intensity", "shadowIntensity"]) {
+      if (Object.hasOwn(sun, key))
+        assertThemeCategoryValue(sun[key], "number", `${path}.sun.${key}`);
+    }
+    if (Object.hasOwn(sun, "color"))
+      assertThemeCategoryValue(sun.color, "color", `${path}.sun.color`);
+  }
+  if (Object.hasOwn(lighting, "ambient")) {
+    const ambient = assertPlainThemeRecord(lighting.ambient, `${path}.ambient`);
+    assertExactThemeKeys(ambient, `${path}.ambient`, themeAmbientKeys);
+    if (Object.hasOwn(ambient, "intensity"))
+      assertThemeCategoryValue(ambient.intensity, "number", `${path}.ambient.intensity`);
+    if (Object.hasOwn(ambient, "color"))
+      assertThemeCategoryValue(ambient.color, "color", `${path}.ambient.color`);
+  }
+  if (Object.hasOwn(lighting, "anchor") && lighting.anchor !== "map" && lighting.anchor !== "viewport") {
+    throw themeTypeError(`${path}.anchor`, "map or viewport", lighting.anchor);
+  }
+  if (Object.hasOwn(lighting, "color")) {
+    assertThemeCategoryValue(lighting.color, "color", `${path}.color`);
+  }
+  if (Object.hasOwn(lighting, "intensity")) {
+    assertThemeCategoryValue(lighting.intensity, "number", `${path}.intensity`);
+  }
+  if (Object.hasOwn(lighting, "position")) {
+    if (!Array.isArray(lighting.position) || lighting.position.length !== 3) {
+      throw themeTypeError(`${path}.position`, "three number values", lighting.position);
+    }
+    for (const [index, position] of lighting.position.entries()) {
+      assertThemeCategoryValue(position, "number", `${path}.position[${index}]`);
+    }
+  }
+}
+function assertThemeCategoryValue(value, expectedCategory, path) {
+  if (!isRecord3(value)) {
+    assertTokenPrimitive(expectedCategory, value, path);
+    return;
+  }
+  if (value.kind === "theme-token") {
+    assertThemeTokenReferenceNode(value, expectedCategory, path);
+    return;
+  }
+  if (value.kind === "theme-fixed") {
+    assertThemeFixedNode(value, expectedCategory, path);
+    return;
+  }
+  if (value.kind === "theme-color") {
+    if (expectedCategory !== "color") {
+      throw themeTypeError(path, `${expectedCategory} value`, value);
+    }
+    assertThemeColorOperationNode(value, path);
+    return;
+  }
+  throw themeTypeError(path, `${expectedCategory} value`, value);
+}
+function assertThemeTokenReferenceNode(reference, expectedCategory, path) {
+  assertExactThemeKeys(reference, path, ["category", "kind", "token"]);
+  assertRequiredThemeKeys(reference, path, ["category", "kind", "token"]);
+  if (!isThemeTokenCategory(reference.category)) {
+    throw themeTypeError(`${path}.category`, "color, font, image, or number", reference.category);
+  }
+  if (typeof reference.token !== "string") {
+    throw themeTypeError(`${path}.token`, "token name", reference.token);
+  }
+  assertTokenName(reference.token, reference.category);
+  if (reference.category !== expectedCategory) {
+    throw new Error(
+      `Tileflow theme token type mismatch at ${path}; expected ${expectedCategory}, received ${reference.category} token "${reference.token}".`
+    );
+  }
+}
+function assertThemeFixedNode(fixedValue, expectedCategory, path) {
+  assertExactThemeKeys(fixedValue, path, ["kind", "reason", "value"]);
+  assertRequiredThemeKeys(fixedValue, path, ["kind", "reason", "value"]);
+  if (typeof fixedValue.reason !== "string" || !fixedValue.reason.trim()) {
+    throw new Error(`Tileflow fixed value at ${path} requires a non-empty reason.`);
+  }
+  assertTokenPrimitive(expectedCategory, fixedValue.value, `${path}.value`);
+}
+function assertThemeColorOperationNode(operation, path) {
+  if (operation.operation === "alpha") {
+    assertExactThemeKeys(operation, path, ["color", "kind", "opacity", "operation"]);
+    assertRequiredThemeKeys(operation, path, ["color", "kind", "opacity", "operation"]);
+    assertThemeCategoryValue(operation.color, "color", `${path}.color`);
+    assertThemeCategoryValue(operation.opacity, "number", `${path}.opacity`);
+    return;
+  }
+  if (operation.operation === "mix") {
+    assertExactThemeKeys(operation, path, ["amount", "from", "kind", "operation", "space", "to"]);
+    assertRequiredThemeKeys(operation, path, [
+      "amount",
+      "from",
+      "kind",
+      "operation",
+      "space",
+      "to"
+    ]);
+    if (operation.space !== "oklch") {
+      throw new Error(`Tileflow theme color mix at ${path} must use the oklch color space.`);
+    }
+    assertThemeCategoryValue(operation.from, "color", `${path}.from`);
+    assertThemeCategoryValue(operation.to, "color", `${path}.to`);
+    assertThemeCategoryValue(operation.amount, "number", `${path}.amount`);
+    return;
+  }
+  throw themeTypeError(`${path}.operation`, "alpha or mix", operation.operation);
+}
+function assertPlainThemeRecord(value, path) {
+  if (!isPlainRecord2(value)) throw themeTypeError(path, "plain object", value);
+  return value;
+}
+function assertExactThemeKeys(value, path, allowedKeys) {
+  const allowed = new Set(allowedKeys);
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string" || !allowed.has(key)) {
+      throw new Error(`Unknown Tileflow theme field ${JSON.stringify(String(key))} at ${path}.`);
+    }
+  }
+}
+function assertRequiredThemeKeys(value, path, requiredKeys) {
+  for (const key of requiredKeys) {
+    if (!Object.hasOwn(value, key)) {
+      throw new Error(`Missing Tileflow theme field ${JSON.stringify(key)} at ${path}.`);
+    }
+  }
+}
+function isThemeTokenCategory(value) {
+  return tileflowThemeTokenCategories.includes(value);
+}
+function assertTokenPrimitive(category, value, path) {
+  if (category === "number") {
+    assertFiniteNumber(value, path);
+    return;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    throw themeTypeError(path, category, value);
+  }
+  if (category === "color") assertColor(value, path);
+  if (category === "font") assertFontName(value, path);
+  if (category === "image") assertImageName(value, path);
+}
+function assertThemeNodeResolutionContext(value, expectedCategory, path) {
+  if (value.kind === "theme-token") {
+    if (!isThemeTokenCategory(value.category)) {
+      assertExactThemeKeys(value, path, ["category", "kind", "token"]);
+      assertRequiredThemeKeys(value, path, ["category", "kind", "token"]);
+      throw themeTypeError(`${path}.category`, "color, font, image, or number", value.category);
+    }
+    assertThemeTokenReferenceNode(value, expectedCategory ?? value.category, path);
+    if (!expectedCategory) throwThemeValueOutsideVisualField(path);
+    return;
+  }
+  if (value.kind === "theme-fixed") {
+    assertExactThemeKeys(value, path, ["kind", "reason", "value"]);
+    assertRequiredThemeKeys(value, path, ["kind", "reason", "value"]);
+    if (typeof value.reason !== "string" || !value.reason.trim()) {
+      throw new Error(`Tileflow fixed value at ${path} requires a non-empty reason.`);
+    }
+    if (!expectedCategory) throwThemeValueOutsideVisualField(path);
+    if (!isThemePrimitiveForCategory(value.value, expectedCategory)) {
+      throw themeTypeError(path, `${expectedCategory} value`, value.value);
+    }
+    return;
+  }
+  if (value.kind === "theme-color") {
+    assertThemeColorOperationNode(value, path);
+    if (!expectedCategory) throwThemeValueOutsideVisualField(path);
+    if (expectedCategory !== "color") {
+      throw themeTypeError(path, `${expectedCategory} value`, value);
+    }
+  }
+}
+function throwThemeValueOutsideVisualField(path) {
+  throw new Error(
+    `Tileflow theme value at ${path} is outside a categorized visual property; theme values cannot control filters, zoom bounds, visibility, metadata, or structure.`
+  );
+}
+function inferThemeCategoryFromPath(path) {
+  const tokenCategory = path.match(/^theme\.tokens\.(color|font|image|number)(?:\.|$)/u)?.[1];
+  if (isThemeTokenCategory(tokenCategory)) return tokenCategory;
+  if (/^theme\.lighting\.position(?:\[\d+\])?$/u.test(path)) return "number";
+  if (/^theme\.lighting\.sun\.(?:altitude|azimuth|shadowIntensity)$/u.test(path)) return "number";
+  const segments = path.replace(/\[\d+\]/g, "").split(".");
+  return [...segments].reverse().map((segment) => classifyTileflowVisualProperty(segment)).find((category) => category !== void 0);
+}
+function isThemeStructuralPath(path) {
+  const segments = path.replace(/\[\d+\]/g, "").split(".");
+  const modulesIndex = segments.indexOf("modules");
+  const dataIndex = segments.indexOf("data");
+  if (dataIndex >= 0 && segments[dataIndex + 1] === "schema" && ["fields", "layers"].includes(segments[dataIndex + 2] ?? "")) {
+    return true;
+  }
+  if (modulesIndex >= 0 && segments[modulesIndex + 1] === "poi" && segments.length === modulesIndex + 3 && segments[modulesIndex + 2] === "color") {
+    return true;
+  }
+  const terrainIndex = segments.indexOf("terrain");
+  const firstPropertyIndex = modulesIndex >= 0 ? modulesIndex + 2 : terrainIndex >= 0 ? terrainIndex + 1 : segments[0] === "map" ? 2 : 0;
+  return segments.slice(firstPropertyIndex).some((segment) => themeStructuralPathSegments.has(segment));
+}
+function assertTokenName(name, category) {
+  if (!/^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)*$/.test(name)) {
+    throw new Error(
+      `Invalid Tileflow ${category} token ${JSON.stringify(name)}; expected a portable dot-separated semantic name.`
+    );
+  }
+}
+function isThemeName(value) {
+  return isTileflowThemeName(value);
+}
+function mixOklch(from, to, amount) {
+  const a = rgbaToOklch(parseColor(from));
+  const b = rgbaToOklch(parseColor(to));
+  let hueDelta = b.h - a.h;
+  if (hueDelta > 180) hueDelta -= 360;
+  if (hueDelta < -180) hueDelta += 360;
+  const rgba = oklchToRgba({
+    c: interpolate(a.c, b.c, amount),
+    h: (a.h + hueDelta * amount + 360) % 360,
+    l: interpolate(a.l, b.l, amount)
+  });
+  const alpha = interpolate(parseColor(from).a, parseColor(to).a, amount);
+  return formatColor({ ...rgba, a: alpha });
+}
+function applyAlpha(value, opacity) {
+  const rgba = parseColor(value);
+  return formatSrgbColor({ ...rgba, a: rgba.a * opacity });
+}
+function parseColor(value) {
+  const hex = value.match(/^#([0-9a-f]{3,8})$/i)?.[1];
+  if (hex) {
+    const expanded = hex.length === 3 || hex.length === 4 ? [...hex].map((entry) => entry + entry).join("") : hex;
+    if (expanded.length === 6 || expanded.length === 8) {
+      return {
+        a: expanded.length === 8 ? Number.parseInt(expanded.slice(6), 16) / 255 : 1,
+        b: Number.parseInt(expanded.slice(4, 6), 16) / 255,
+        g: Number.parseInt(expanded.slice(2, 4), 16) / 255,
+        r: Number.parseInt(expanded.slice(0, 2), 16) / 255
+      };
+    }
+  }
+  const rgb = value.match(
+    /^rgba?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)(?:\s*,\s*(\d+(?:\.\d+)?))?\s*\)$/i
+  );
+  if (rgb) {
+    const result = {
+      a: Number(rgb[4] ?? 1),
+      b: Number(rgb[3]) / 255,
+      g: Number(rgb[2]) / 255,
+      r: Number(rgb[1]) / 255
+    };
+    if (Object.values(result).every((entry) => Number.isFinite(entry) && entry >= 0 && entry <= 1)) {
+      return result;
+    }
+  }
+  throw new Error(`Invalid Tileflow theme color ${JSON.stringify(value)}.`);
+}
+function rgbaToOklch({ b, g, r }) {
+  const linear = [r, g, b].map(srgbToLinear);
+  const l = 0.4122214708 * linear[0] + 0.5363325363 * linear[1] + 0.0514459929 * linear[2];
+  const m = 0.2119034982 * linear[0] + 0.6806995451 * linear[1] + 0.1073969566 * linear[2];
+  const s = 0.0883024619 * linear[0] + 0.2817188376 * linear[1] + 0.6299787005 * linear[2];
+  const lRoot = Math.cbrt(l);
+  const mRoot = Math.cbrt(m);
+  const sRoot = Math.cbrt(s);
+  const labA = 1.9779984951 * lRoot - 2.428592205 * mRoot + 0.4505937099 * sRoot;
+  const labB = 0.0259040371 * lRoot + 0.7827717662 * mRoot - 0.808675766 * sRoot;
+  return {
+    c: Math.hypot(labA, labB),
+    h: Math.atan2(labB, labA) * 180 / Math.PI + 360,
+    l: 0.2104542553 * lRoot + 0.793617785 * mRoot - 0.0040720468 * sRoot
+  };
+}
+function oklchToRgba({ c, h, l }) {
+  const radians = h * Math.PI / 180;
+  const labA = c * Math.cos(radians);
+  const labB = c * Math.sin(radians);
+  const lRoot = l + 0.3963377774 * labA + 0.2158037573 * labB;
+  const mRoot = l - 0.1055613458 * labA - 0.0638541728 * labB;
+  const sRoot = l - 0.0894841775 * labA - 1.291485548 * labB;
+  const lLinear = lRoot ** 3;
+  const mLinear = mRoot ** 3;
+  const sLinear = sRoot ** 3;
+  return {
+    a: 1,
+    b: clamp01(-0.0041960863 * lLinear - 0.7034186147 * mLinear + 1.707614701 * sLinear),
+    g: clamp01(-1.2684380046 * lLinear + 2.6097574011 * mLinear - 0.3413193965 * sLinear),
+    r: clamp01(4.0767416621 * lLinear - 3.3077115913 * mLinear + 0.2309699292 * sLinear)
+  };
+}
+function formatColor({ a, b, g, r }) {
+  const channels = [r, g, b].map((entry) => Math.round(linearToSrgb(entry) * 255));
+  if (a >= 0.9995) {
+    return `#${channels.map((entry) => entry.toString(16).padStart(2, "0")).join("")}`;
+  }
+  return `rgba(${channels[0]}, ${channels[1]}, ${channels[2]}, ${round(a, 4)})`;
+}
+function formatSrgbColor({ a, b, g, r }) {
+  const channels = [r, g, b].map((entry) => Math.round(clamp01(entry) * 255));
+  if (a >= 0.9995) {
+    return `#${channels.map((entry) => entry.toString(16).padStart(2, "0")).join("")}`;
+  }
+  return `rgba(${channels[0]}, ${channels[1]}, ${channels[2]}, ${round(a, 4)})`;
+}
+function srgbToLinear(value) {
+  return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb(value) {
+  const clamped = clamp01(value);
+  return clamped <= 31308e-7 ? clamped * 12.92 : 1.055 * clamped ** (1 / 2.4) - 0.055;
+}
+function assertColor(value, path) {
+  if (typeof value !== "string") throw themeTypeError(path, "color", value);
+  try {
+    parseColor(value);
+  } catch {
+    throw new Error(`Invalid Tileflow theme color ${JSON.stringify(value)} at ${path}.`);
+  }
+}
+function assertFiniteNumber(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw themeTypeError(path, "finite number", value);
+  }
+}
+function assertFontName(value, path) {
+  if (value.length > 100 || value !== value.trim() || value !== value.normalize("NFC") || /[\p{Cc}\\]/u.test(value)) {
+    throw new Error(
+      `Invalid Tileflow font ${JSON.stringify(value)} at ${path}; expected an exact NFC face name without whitespace, controls, or backslashes.`
+    );
+  }
+}
+function assertImageName(value, path) {
+  if (value.length > 128 || value !== value.trim() || value !== value.normalize("NFC") || /[\p{Cc}\\]/u.test(value)) {
+    throw new Error(`Invalid Tileflow image token value ${JSON.stringify(value)} at ${path}.`);
+  }
+}
+function assertUnitInterval(value, path) {
+  assertFiniteNumber(value, path);
+  if (value < 0 || value > 1) {
+    throw new Error(`Tileflow theme value at ${path} must be between 0 and 1.`);
+  }
+}
+function themeTypeError(path, expected, value) {
+  return new Error(
+    `Invalid Tileflow theme value at ${path}; expected ${expected}, received ${describe(value)}.`
+  );
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function interpolate(from, to, amount) {
+  return from + (to - from) * amount;
+}
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function round(value, digits) {
+  const power = 10 ** digits;
+  return Math.round(value * power) / power;
+}
+function cloneJson(value) {
+  const serialized = JSON.stringify(value);
+  if (serialized === void 0) throw new Error("Tileflow themes must be JSON-serializable.");
+  return JSON.parse(serialized);
+}
+function isRecord3(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isPlainRecord2(value) {
+  if (!isRecord3(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+var tileflowThemeLimits, TileflowThemeAuditError, themeDocumentKeys, themeTypographyStyleKeys, themeTypographyKeys, themeTypographyDomains, themeLightingKeys, themeSunKeys, themeAmbientKeys, expressionDataOperators, ThemeValueResolver, themeStructuralPathSegments;
+var init_model = __esm({
+  "src/themes/model.ts"() {
+    "use strict";
+    init_expression_operators();
+    init_values();
+    init_operations();
+    init_portable_identity_rules();
+    init_sun();
+    init_visual_semantics();
+    tileflowThemeLimits = Object.freeze({ maxThemes: 64 });
+    TileflowThemeAuditError = class extends Error {
+      diagnostics;
+      constructor(diagnostics) {
+        const errors = diagnostics.filter(({ severity }) => severity === "error").sort(compareAuditDiagnostics).map((diagnostic) => ({ ...diagnostic }));
+        const first = errors[0];
+        super(
+          `Tileflow theme audit failed with ${errors.length} blocking diagnostic${errors.length === 1 ? "" : "s"}${first ? `; first error at ${first.path}` : ""}.`
+        );
+        this.name = "TileflowThemeAuditError";
+        this.diagnostics = errors;
+      }
+    };
+    themeDocumentKeys = [
+      "colorScheme",
+      "id",
+      "lighting",
+      "tokens",
+      "typography",
+      "version"
+    ];
+    themeTypographyStyleKeys = ["fallbacks", "font", "letterSpacing", "transform"];
+    themeTypographyKeys = [
+      ...themeTypographyStyleKeys,
+      "places",
+      "poi",
+      "roads",
+      "water"
+    ];
+    themeTypographyDomains = ["places", "poi", "roads", "water"];
+    themeLightingKeys = ["ambient", "anchor", "color", "intensity", "position", "sun"];
+    themeSunKeys = ["altitude", "azimuth", "color", "intensity", "shadowIntensity"];
+    themeAmbientKeys = ["color", "intensity"];
+    expressionDataOperators = /* @__PURE__ */ new Set([
+      "accumulated",
+      "collator",
+      "distance",
+      "elevation",
+      "error",
+      "feature-state",
+      "geometry-type",
+      "get",
+      "global-state",
+      "has",
+      "heatmap-density",
+      "id",
+      "in",
+      "index-of",
+      "is-supported-script",
+      "length",
+      "line-progress",
+      "properties",
+      "resolved-locale",
+      "typeof",
+      "within",
+      "zoom"
+    ]);
+    ThemeValueResolver = class {
+      #cache = /* @__PURE__ */ new Map();
+      #stack = [];
+      #theme;
+      constructor(theme) {
+        assertThemeDocument(theme);
+        this.#theme = theme;
+      }
+      resolveAllTokens() {
+        for (const category of tileflowThemeTokenCategories) {
+          this.resolveCategory(category);
+        }
+      }
+      resolveCategory(category) {
+        return Object.fromEntries(
+          Object.keys(this.#theme.tokens[category]).sort(compareCodeUnits).map((name) => [
+            name,
+            this.#resolveToken(category, name, `theme.tokens.${category}.${name}`)
+          ])
+        );
+      }
+      resolveTree(value, path, expectedCategory) {
+        const category = isThemeStructuralPath(path) ? void 0 : expectedCategory ?? inferThemeCategoryFromPath(path);
+        if (isThemeValueCandidate(value)) {
+          assertThemeNodeResolutionContext(value, category, path);
+        }
+        if (isTileflowThemeTokenReference(value)) {
+          return this.#resolveReference(value, path);
+        }
+        if (isTileflowFixedValue(value)) {
+          return this.resolveTree(value.value, `${path}.value`, category);
+        }
+        if (isTileflowThemeColorOperation(value)) return this.#resolveColorOperation(value, path);
+        if (Array.isArray(value)) {
+          return value.map((entry, index) => this.resolveTree(entry, `${path}[${index}]`, category));
+        }
+        if (!isRecord3(value)) return value;
+        if (value.kind === "expression" && Array.isArray(value.value)) {
+          return {
+            ...value,
+            value: this.resolveTree(value.value, `${path}.value`, category)
+          };
+        }
+        if (value.kind === "zoom" && Array.isArray(value.stops)) {
+          return {
+            ...value,
+            stops: value.stops.map(
+              (stop, index) => Array.isArray(stop) ? [
+                this.resolveTree(stop[0], `${path}.stops[${index}][0]`),
+                this.resolveTree(stop[1], `${path}.stops[${index}][1]`, category)
+              ] : this.resolveTree(stop, `${path}.stops[${index}]`)
+            )
+          };
+        }
+        const result = {};
+        for (const key of Reflect.ownKeys(value)) {
+          const nextPath = typeof key === "symbol" ? `${path}.[${String(key)}]` : `${path}.${String(key)}`;
+          const nextValue = value[key];
+          const nextCategory = typeof key === "string" ? classifyTileflowVisualProperty(key, nextValue) : void 0;
+          result[key] = this.resolveTree(nextValue, nextPath, nextCategory);
+        }
+        return result;
+      }
+      resolveTypography(typography) {
+        const global = this.#resolveTypographyStyle(typography, "theme.typography", {
+          font: "Noto Sans Regular"
+        });
+        return {
+          ...global,
+          places: this.#resolveTypographyStyle(typography.places, "theme.typography.places", global),
+          poi: this.#resolveTypographyStyle(typography.poi, "theme.typography.poi", global),
+          roads: this.#resolveTypographyStyle(typography.roads, "theme.typography.roads", global),
+          water: this.#resolveTypographyStyle(typography.water, "theme.typography.water", global)
+        };
+      }
+      resolveLighting(lighting) {
+        const { ambient, sun, ...flat } = lighting;
+        const light = this.#resolveFlatLight(flat);
+        if (sun === void 0 && ambient === void 0) return { light };
+        const resolvedSun = this.resolveTree(sun ?? {}, "theme.lighting.sun");
+        const resolvedAmbient = this.resolveTree(ambient ?? {}, "theme.lighting.ambient");
+        const defaults = tileflowDefaultSunPreset;
+        const number = (value, path, fallback, range2) => {
+          if (value === void 0) return fallback;
+          assertFiniteNumber(value, path);
+          if (range2 && (value < range2[0] || value > range2[1])) {
+            throw new Error(`Tileflow ${path} must be between ${range2[0]} and ${range2[1]}.`);
+          }
+          return value;
+        };
+        const colour = (value, path, fallback) => {
+          if (value === void 0) return fallback;
+          assertColor(value, path);
+          return value;
+        };
+        const preset = {
+          azimuth: normalizeTileflowAzimuth(
+            number(resolvedSun.azimuth, "theme.lighting.sun.azimuth", defaults.azimuth)
+          ),
+          altitude: number(
+            resolvedSun.altitude,
+            "theme.lighting.sun.altitude",
+            defaults.altitude,
+            [-90, 90]
+          ),
+          color: colour(resolvedSun.color, "theme.lighting.sun.color", defaults.color),
+          intensity: number(
+            resolvedSun.intensity,
+            "theme.lighting.sun.intensity",
+            defaults.intensity,
+            [0, 1]
+          ),
+          shadowIntensity: number(
+            resolvedSun.shadowIntensity,
+            "theme.lighting.sun.shadowIntensity",
+            defaults.shadowIntensity,
+            [0, 1]
+          ),
+          ambient: {
+            color: colour(
+              resolvedAmbient.color,
+              "theme.lighting.ambient.color",
+              defaults.ambient.color
+            ),
+            intensity: number(
+              resolvedAmbient.intensity,
+              "theme.lighting.ambient.intensity",
+              defaults.ambient.intensity,
+              [0, 1]
+            )
+          }
+        };
+        return { light: sun === void 0 ? light : tileflowSunLight(preset, light), sun: preset };
+      }
+      #resolveFlatLight(lighting) {
+        const result = this.resolveTree(lighting, "theme.lighting");
+        if (result.anchor !== void 0 && result.anchor !== "map" && result.anchor !== "viewport") {
+          throw themeTypeError("theme.lighting.anchor", "map or viewport", result.anchor);
+        }
+        if (result.color !== void 0) assertColor(result.color, "theme.lighting.color");
+        if (result.intensity !== void 0) {
+          assertFiniteNumber(result.intensity, "theme.lighting.intensity");
+          if (result.intensity < 0 || result.intensity > 1) {
+            throw new Error("Tileflow theme.lighting.intensity must be between 0 and 1.");
+          }
+        }
+        if (result.position !== void 0) {
+          if (!Array.isArray(result.position) || result.position.length !== 3 || result.position.some((entry) => typeof entry !== "number" || !Number.isFinite(entry))) {
+            throw themeTypeError("theme.lighting.position", "three finite numbers", result.position);
+          }
+        }
+        return result;
+      }
+      #resolveTypographyStyle(style, path, defaults) {
+        const resolved = this.resolveTree(style ?? {}, path);
+        const font = resolved.font ?? defaults.font;
+        if (typeof font !== "string" || !font) throw themeTypeError(`${path}.font`, "font", font);
+        assertFontName(font, `${path}.font`);
+        const fallbacks = resolved.fallbacks ?? defaults.fallbacks;
+        if (fallbacks !== void 0 && (!Array.isArray(fallbacks) || fallbacks.some((entry) => typeof entry !== "string" || !entry))) {
+          throw themeTypeError(`${path}.fallbacks`, "font array", fallbacks);
+        }
+        if (Array.isArray(fallbacks)) {
+          const seen = /* @__PURE__ */ new Set();
+          for (const [index, fallback] of fallbacks.entries()) {
+            assertFontName(fallback, `${path}.fallbacks[${index}]`);
+            if (seen.has(fallback)) {
+              throw new Error(
+                `Duplicate Tileflow font fallback ${JSON.stringify(fallback)} at ${path}.fallbacks[${index}].`
+              );
+            }
+            seen.add(fallback);
+          }
+        }
+        const letterSpacing = resolved.letterSpacing ?? defaults.letterSpacing;
+        if (letterSpacing !== void 0) assertFiniteNumber(letterSpacing, `${path}.letterSpacing`);
+        const transform = resolved.transform ?? defaults.transform;
+        if (transform !== void 0 && !["lowercase", "none", "uppercase"].includes(String(transform))) {
+          throw themeTypeError(`${path}.transform`, "text transform", transform);
+        }
+        return {
+          font,
+          ...fallbacks === void 0 ? {} : { fallbacks: [...fallbacks] },
+          ...letterSpacing === void 0 ? {} : { letterSpacing },
+          ...transform === void 0 ? {} : { transform }
+        };
+      }
+      #resolveReference(reference, path) {
+        return this.#resolveToken(reference.category, reference.token, path);
+      }
+      #resolveToken(category, name, consumedAt) {
+        const cacheKey = `${category}:${name}`;
+        const cached = this.#cache.get(cacheKey);
+        if (cached !== void 0) return cached;
+        const tokens = this.#theme.tokens[category];
+        if (!Object.hasOwn(tokens, name)) {
+          throw new Error(
+            `Unknown Tileflow ${category} token "${name}" at ${consumedAt} in theme "${this.#theme.id}".`
+          );
+        }
+        const cycleStart = this.#stack.indexOf(cacheKey);
+        if (cycleStart >= 0) {
+          const cycle = [...this.#stack.slice(cycleStart), cacheKey].map((key) => key.replace(":", ".")).join(" -> ");
+          throw new Error(`Circular Tileflow theme token reference: ${cycle}.`);
+        }
+        this.#stack.push(cacheKey);
+        try {
+          const path = `theme.tokens.${category}.${name}`;
+          const value = this.resolveTree(tokens[name], path, category);
+          assertTokenPrimitive(category, value, path);
+          this.#cache.set(cacheKey, value);
+          return value;
+        } finally {
+          this.#stack.pop();
+        }
+      }
+      #resolveColorOperation(operation, path) {
+        if (operation.operation === "alpha") {
+          const source = this.resolveTree(operation.color, `${path}.color`, "color");
+          const opacity = this.resolveTree(operation.opacity, `${path}.opacity`, "number");
+          assertColor(source, `${path}.color`);
+          assertUnitInterval(opacity, `${path}.opacity`);
+          return applyAlpha(source, opacity);
+        }
+        const from = this.resolveTree(operation.from, `${path}.from`, "color");
+        const to = this.resolveTree(operation.to, `${path}.to`, "color");
+        const amount = this.resolveTree(operation.amount, `${path}.amount`, "number");
+        assertColor(from, `${path}.from`);
+        assertColor(to, `${path}.to`);
+        assertUnitInterval(amount, `${path}.amount`);
+        if (operation.space !== "oklch") {
+          throw new Error(`Tileflow theme color mix at ${path} must use the oklch color space.`);
+        }
+        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"
+    ]);
+  }
+});
+
+// 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 extractTileflowColorPrograms(style, tokens) {
+  const programs = [];
+  const ids = /* @__PURE__ */ new Map();
+  const bindings = [];
+  const visit = (node, path) => {
+    if (record2(node) && node.kind === "expression" && isColorProgramMarker(node.value))
+      return visit(node.value, path);
+    if (isColorProgramMarker(node)) {
+      const program = colorProgramOf(node);
+      const key = JSON.stringify(program);
+      let id = ids.get(key);
+      if (id === void 0) {
+        id = programs.length;
+        ids.set(key, id);
+        programs.push(program);
+      }
+      bindings.push([
+        path[0] === "layers" && path[2] === "paint" ? [path[1], ...path.slice(3)] : path,
+        id
+      ]);
+      return colorProgramValue(node);
+    }
+    if (Array.isArray(node)) return node.map((v, i) => visit(v, [...path, i]));
+    if (record2(node))
+      return Object.fromEntries(
+        Object.entries(node).filter(([key]) => key !== tileflowColorMetadataKey).map(([key, v]) => [key, visit(v, [...path, key])])
+      );
+    return node;
+  };
+  const result = visit(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 restoreTileflowColorPrograms(style) {
+  const result = structuredClone(style);
+  const metadata = result.metadata?.[tileflowColorMetadataKey];
+  if (!metadata) return result;
+  validateBindings(metadata);
+  for (const [path, id] of metadata.bindings)
+    updatePath(result, path, (value) => colorProgramMarker(value, metadata.programs[id]));
+  return result;
+}
+function updatePath(root, inputPath, change) {
+  const path = typeof inputPath[0] === "number" ? ["layers", inputPath[0], "paint", ...inputPath.slice(1)] : inputPath;
+  if (!path.length || path.length > 96 || path.some((key) => ["__proto__", "constructor", "prototype"].includes(String(key))))
+    throw new TypeError("Invalid colour binding path.");
+  let node = root;
+  for (const key of path.slice(0, -1)) {
+    if (!node || typeof node !== "object" || !Object.hasOwn(node, key))
+      throw new TypeError("Missing colour binding path.");
+    node = node[key];
+  }
+  const last = path.at(-1);
+  if (!node || !Object.hasOwn(node, last)) throw new TypeError("Missing colour binding value.");
+  node[last] = change(node[last]);
+}
+function validateBindings(value) {
+  if (value.version !== 1 || !Array.isArray(value.programs) || value.programs.length > 4096 || !Array.isArray(value.bindings) || value.bindings.length > 16384 || !record2(value.tokens?.color) || !record2(value.tokens?.number))
+    throw new TypeError("Invalid colour program catalog.");
+  for (const [path, id] of value.bindings) {
+    if (!Array.isArray(path) || !path.length || path.some((key) => typeof key !== "string" && !Number.isSafeInteger(key)) || !Number.isSafeInteger(id) || id < 0 || id >= value.programs.length || !(typeof path[0] === "number" || ["metadata", "light", "sky"].includes(String(path[0]))))
+      throw new TypeError("Invalid colour program binding.");
+    if (typeof path[0] === "number" && (path[0] < 0 || !String(path[1]).endsWith("color")))
+      throw new TypeError("Colour programs can only change paint colours.");
+    if (path[0] === "metadata" && (path[1] === tileflowColorMetadataKey || ![
+      "tileflow:buildings",
+      "tileflow:vegetation",
+      "tileflow:sun",
+      "tileflow:sky",
+      "tileflow:route"
+    ].includes(String(path[1]))))
+      throw new TypeError("Invalid colour metadata binding.");
+  }
+}
+function record2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+var tileflowColorMetadataKey, marker;
+var init_color_program = __esm({
+  "src/color-program.ts"() {
+    "use strict";
+    tileflowColorMetadataKey = "tileflow:colors";
+    marker = "__tileflow_color_program";
+  }
+});
+
 // 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 });
   }
 });
@@ -154,23 +2539,6 @@ var init_runtime_view_schema = __esm({
   }
 });
 
-// src/themes/model.ts
-var tileflowThemeLimits, themeTypographyStyleKeys, themeTypographyKeys;
-var init_model = __esm({
-  "src/themes/model.ts"() {
-    "use strict";
-    tileflowThemeLimits = Object.freeze({ maxThemes: 64 });
-    themeTypographyStyleKeys = ["fallbacks", "font", "letterSpacing", "transform"];
-    themeTypographyKeys = [
-      ...themeTypographyStyleKeys,
-      "places",
-      "poi",
-      "roads",
-      "water"
-    ];
-  }
-});
-
 // src/time-of-day-schema.ts
 function createTileflowTimeOfDaySchema(operations, themeName) {
   return operations.record(
@@ -236,6 +2604,7 @@ function createTileflowRuntimeManifestSchema(primitives, operations, identities
       apiUrl: operations.optional(apiOriginSchema),
       defaultTheme: tileflowThemeNameSchema2,
       environment: operations.optional(operations.maxLength(safeTextSchema, 128)),
+      familyUrl: operations.optional(publicResourceUrlSchema),
       mapId: operations.optional(operations.maxLength(safeTextSchema, 128)),
       systemThemes: operations.optional(
         operations.object({
@@ -317,11 +2686,20 @@ function createTileflowRuntimeManifestSchema(primitives, operations, identities
       maps: operations.record(tileflowPortableIdSchema2, manifestMapSchema),
       version: operations.union(
         operations.literal(tileflowRuntimeManifestVersion),
-        operations.literal(2)
+        operations.union(operations.literal(2), operations.literal(3))
       )
     }),
     (manifest, context) => {
       const mapCount = Object.keys(manifest.maps).length;
+      if (manifest.version !== 3)
+        for (const [name, map] of Object.entries(manifest.maps)) {
+          if (map.familyUrl !== void 0)
+            context.addIssue({
+              code: "custom",
+              message: "familyUrl requires manifest version 3",
+              path: ["maps", name, "familyUrl"]
+            });
+        }
       if (manifest.version === 1) {
         for (const [name, map] of Object.entries(manifest.maps)) {
           if (map.timeOfDay !== void 0)
@@ -534,6 +2912,7 @@ var manifest_exports = {};
 __export(manifest_exports, {
   parseTileflowRuntimeManifest: () => parseTileflowRuntimeManifest,
   safeParseTileflowRuntimeManifest: () => safeParseTileflowRuntimeManifest,
+  tileflowFamilyManifestVersion: () => tileflowFamilyManifestVersion,
   tileflowRuntimeManifestLimits: () => tileflowRuntimeManifestLimits,
   tileflowRuntimeManifestSchema: () => tileflowRuntimeManifestSchema,
   tileflowRuntimeManifestVersion: () => tileflowRuntimeManifestVersion,
@@ -567,6 +2946,664 @@ var init_manifest = __esm({
 // src/runtime.ts
 init_portable_identity_rules();
 init_time_of_day();
+
+// src/style-family.ts
+init_portable_identity_rules();
+var tileflowStyleFamilyLimits = Object.freeze({
+  themes: 64,
+  documentBytes: 16 * 1024 * 1024,
+  expandedStyleBytes: 8 * 1024 * 1024,
+  expandedFamilyBytes: 32 * 1024 * 1024,
+  layers: 4096,
+  nodes: 5e5,
+  depth: 96
+});
+function createTileflowStyleFamily(styles) {
+  const themes = Object.keys(styles).sort();
+  if (!themes.length || themes.length > tileflowStyleFamilyLimits.themes || themes.some((name) => !isTileflowThemeName(name)))
+    fail("Invalid theme names.");
+  const parameters = [];
+  const columns = /* @__PURE__ */ new Map();
+  const add = (values) => {
+    const key = serializeCanonicalJson(values);
+    let index = columns.get(key);
+    if (index === void 0) {
+      index = parameters.length;
+      columns.set(key, index);
+      parameters.push(values);
+    }
+    return { $variant: index };
+  };
+  const factor = (values) => {
+    const first = values[0];
+    if (values.some((value) => isReference(value) || isConstantReference(value)))
+      return add(values);
+    if (Array.isArray(first) && values.every((v) => Array.isArray(v) && v.length === first.length))
+      return first.map((_, index) => factor(values.map((v) => v[index])));
+    if (record(first) && values.every((v) => record(v) && same(Object.keys(v).sort(), Object.keys(first).sort())))
+      return Object.fromEntries(
+        Object.keys(first).sort().map((key) => [key, factor(values.map((v) => v[key]))])
+      );
+    if (values.every((v) => same(v, first))) return first;
+    return add(values);
+  };
+  const documents = themes.map((name) => JSON.parse(serializeCanonicalJson(styles[name])));
+  for (const document2 of documents) assertStyle(document2);
+  const template = factor(documents);
+  const packed = shareConstants(template);
+  const family = {
+    kind: "tileflow-style-family",
+    version: 1,
+    themes,
+    template: packed.template,
+    constants: packed.constants,
+    parameters,
+    updates: planUpdates(template)
+  };
+  return parseTileflowStyleFamily(family);
+}
+function parseTileflowStyleFamily(input) {
+  assertJsonBudget(input);
+  if (!record(input) || !same(Object.keys(input).sort(), [
+    "constants",
+    "kind",
+    "parameters",
+    "template",
+    "themes",
+    "updates",
+    "version"
+  ]) || input.kind !== "tileflow-style-family" || input.version !== 1 || !Array.isArray(input.themes) || !input.themes.length || input.themes.length > tileflowStyleFamilyLimits.themes || input.themes.some((name) => typeof name !== "string" || !isTileflowThemeName(name)) || new Set(input.themes).size !== input.themes.length || !Array.isArray(input.parameters) || !Array.isArray(input.constants))
+    fail("Invalid family document.");
+  const family = input;
+  if (bytes(input) > tileflowStyleFamilyLimits.documentBytes) fail("Family document is too large.");
+  for (const values of family.parameters)
+    if (!Array.isArray(values) || values.length !== family.themes.length)
+      fail("Invalid parameter column.");
+  walk(family.template, (value) => {
+    if (isReference(value) && (!Number.isSafeInteger(value.$variant) || value.$variant < 0 || value.$variant >= family.parameters.length))
+      fail("Invalid parameter reference.");
+    if (isConstantReference(value) && (!Number.isSafeInteger(value.$constant) || value.$constant < 0 || value.$constant >= family.constants.length))
+      fail("Invalid constant reference.");
+  });
+  let total = 0;
+  const sizes = family.parameters.map((column) => column.map(bytes));
+  const constants = family.constants.map(bytes);
+  for (let index = 0; index < family.themes.length; index += 1) {
+    const size = expandedBytes(family.template, sizes, constants, index);
+    total += size;
+    if (size > tileflowStyleFamilyLimits.expandedStyleBytes || total > tileflowStyleFamilyLimits.expandedFamilyBytes)
+      fail("Expanded family is too large.");
+    const style = materialize(family.template, family, index);
+    assertJsonBudget(style);
+    assertStyle(style);
+  }
+  if (!same(family.updates, planUpdates(expandTileflowFamilyTemplate(family))))
+    fail("Invalid update plan.");
+  return family;
+}
+function materializeTileflowStyleFamily(family, theme) {
+  const index = family.themes.indexOf(theme);
+  if (index < 0) fail(`Unknown family theme: ${theme}.`);
+  return materialize(family.template, family, index);
+}
+function expandTileflowStyleFamily(input) {
+  const family = parseTileflowStyleFamily(input);
+  return Object.fromEntries(
+    family.themes.map((name) => [name, materializeTileflowStyleFamily(family, name)])
+  );
+}
+function readTileflowFamilyValue(family, path, theme) {
+  const index = family.themes.indexOf(theme);
+  if (index < 0) fail(`Unknown family theme: ${theme}.`);
+  let node = family.template;
+  for (const key of path) {
+    if (isReference(node)) node = family.parameters[node.$variant][index];
+    else if (isConstantReference(node)) node = family.constants[node.$constant];
+    node = node && typeof node === "object" ? node[key] : void 0;
+  }
+  return node === void 0 ? void 0 : materialize(node, family, index);
+}
+function materialize(node, family, index) {
+  if (isReference(node)) return structuredClone(family.parameters[node.$variant][index]);
+  if (isConstantReference(node)) return structuredClone(family.constants[node.$constant]);
+  if (Array.isArray(node)) return node.map((value) => materialize(value, family, index));
+  if (record(node))
+    return Object.fromEntries(
+      Object.entries(node).map(([key, value]) => [key, materialize(value, family, index)])
+    );
+  return node;
+}
+function planUpdates(template) {
+  let appearanceOnly = true;
+  const paint = /* @__PURE__ */ new Map();
+  const roots = /* @__PURE__ */ new Set();
+  walk(template, (node, path) => {
+    if (!isReference(node)) return;
+    if (path[0] === "name") return;
+    if (path[0] === "metadata") {
+      const key = path[1];
+      if ([
+        "tileflow:colors",
+        "tileflow:family-image-theme",
+        "tileflow:theme",
+        "tileflow:colorScheme",
+        "tileflow:sun",
+        "tileflow:route",
+        "tileflow:sky",
+        "tileflow:sourceRequirements",
+        "tileflow:dataRequirements"
+      ].includes(String(key)))
+        return;
+      if (key === "tileflow:buildings" && ["color", "modelColors", "modelLighting", "floodLight"].includes(String(path[2])))
+        return;
+      if (key === "tileflow:vegetation" && path[2] === "colors") return;
+      appearanceOnly = false;
+      return;
+    }
+    if (path[0] === "layers" && path[2] === "layout" && path[3] === "icon-image") return;
+    if (path[0] === "sky" || path[0] === "light") {
+      roots.add(path[0]);
+      return;
+    }
+    if (path[0] === "layers" && typeof path[1] === "number" && path[2] === "paint" && typeof path[3] === "string") {
+      paint.set(`${path[1]}/${path[3]}`, [path[1], path[3]]);
+    } else appearanceOnly = false;
+  });
+  if (record(template) && record(template.metadata) && template.metadata["tileflow:colors"] && Array.isArray(template.layers))
+    template.layers.forEach((layer, index) => {
+      if (record(layer) && record(layer.paint)) {
+        for (const property of Object.keys(layer.paint))
+          if (property.endsWith("color")) paint.set(`${index}/${property}`, [index, property]);
+      }
+    });
+  return { appearanceOnly, paint: [...paint.values()], roots: [...roots].sort() };
+}
+function expandedBytes(node, sizes, constants, index) {
+  if (isReference(node)) return sizes[node.$variant][index];
+  if (isConstantReference(node)) return constants[node.$constant];
+  if (Array.isArray(node))
+    return 2 + Math.max(0, node.length - 1) + node.reduce((n, v) => n + expandedBytes(v, sizes, constants, index), 0);
+  if (record(node))
+    return 2 + Math.max(0, Object.keys(node).length - 1) + Object.entries(node).reduce(
+      (n, [key, v]) => n + bytes(key) + 1 + expandedBytes(v, sizes, constants, index),
+      0
+    );
+  return bytes(node);
+}
+function assertStyle(style) {
+  if (!record(style) || style.version !== 8 || !record(style.sources) || !Array.isArray(style.layers) || style.layers.length > tileflowStyleFamilyLimits.layers)
+    fail("Invalid expanded MapLibre style.");
+  const ids = /* @__PURE__ */ new Set();
+  for (const layer of style.layers) {
+    if (!record(layer) || typeof layer.id !== "string" || ids.has(layer.id) || typeof layer.type !== "string")
+      fail("Invalid or duplicate layer.");
+    ids.add(layer.id);
+  }
+}
+function assertJsonBudget(input) {
+  let nodes = 0;
+  const stack = /* @__PURE__ */ new Set();
+  const visit = (value, depth) => {
+    if (++nodes > tileflowStyleFamilyLimits.nodes || depth > tileflowStyleFamilyLimits.depth)
+      fail("Family complexity limit exceeded.");
+    if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
+      return;
+    if (typeof value !== "object" || !value || stack.has(value)) fail("Expected acyclic JSON.");
+    stack.add(value);
+    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+      fail("Expected JSON objects.");
+    for (const [key, item] of Object.entries(value)) {
+      if (["__proto__", "constructor", "prototype"].includes(key)) fail("Unsafe object key.");
+      visit(item, depth + 1);
+    }
+    stack.delete(value);
+  };
+  visit(input, 0);
+}
+function walk(node, visit, path = []) {
+  visit(node, path);
+  if (isReference(node) || isConstantReference(node)) return;
+  if (Array.isArray(node)) node.forEach((value, i) => walk(value, visit, [...path, i]));
+  else if (record(node))
+    Object.entries(node).forEach(([key, value]) => walk(value, visit, [...path, key]));
+}
+function isReference(node) {
+  return record(node) && Object.keys(node).length === 1 && Object.hasOwn(node, "$variant");
+}
+function isConstantReference(node) {
+  return record(node) && Object.keys(node).length === 1 && Object.hasOwn(node, "$constant");
+}
+function expandTileflowFamilyTemplate(family) {
+  const visit = (node) => {
+    if (isConstantReference(node)) return structuredClone(family.constants[node.$constant]);
+    if (isReference(node)) return node;
+    if (Array.isArray(node)) return node.map(visit);
+    if (record(node))
+      return Object.fromEntries(
+        Object.entries(node).map(([key, value]) => [key, visit(value)])
+      );
+    return node;
+  };
+  return visit(family.template);
+}
+function withTileflowFamilyTemplate(family, template) {
+  assertJsonBudget(template);
+  const packed = shareConstants(template);
+  return parseTileflowStyleFamily({
+    ...family,
+    template: packed.template,
+    constants: packed.constants
+  });
+}
+function shareConstants(template) {
+  const counts = /* @__PURE__ */ new Map();
+  const keys = /* @__PURE__ */ new WeakMap();
+  const inspect = (node) => {
+    if (isReference(node) || isConstantReference(node)) return false;
+    if (!node || typeof node !== "object") return true;
+    const children = Array.isArray(node) ? node : Object.values(node);
+    const constant = children.map(inspect).every(Boolean);
+    if (constant) {
+      const key = JSON.stringify(node);
+      if (key.length >= 96) {
+        keys.set(node, key);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+      }
+    }
+    return constant;
+  };
+  inspect(template);
+  const constants = [];
+  const ids = /* @__PURE__ */ new Map();
+  const pack = (node) => {
+    if (!node || typeof node !== "object" || isReference(node)) return node;
+    const key = keys.get(node);
+    if (key && counts.get(key) > 1) {
+      let index = ids.get(key);
+      if (index === void 0) {
+        index = constants.length;
+        ids.set(key, index);
+        constants.push(node);
+      }
+      return { $constant: index };
+    }
+    if (Array.isArray(node)) return node.map(pack);
+    return Object.fromEntries(
+      Object.entries(node).map(([key2, value]) => [key2, pack(value)])
+    );
+  };
+  return { template: pack(template), constants };
+}
+function record(node) {
+  return !!node && typeof node === "object" && !Array.isArray(node);
+}
+function same(a, b) {
+  return serializeCanonicalJson(a) === serializeCanonicalJson(b);
+}
+function serializeCanonicalJson(value) {
+  const sort = (node) => Array.isArray(node) ? node.map(sort) : record(node) ? Object.fromEntries(
+    Object.keys(node).sort().map((key) => [key, sort(node[key])])
+  ) : node;
+  return JSON.stringify(sort(value));
+}
+function bytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+function fail(message) {
+  throw new TypeError(`Tileflow style family: ${message}`);
+}
+
+// src/style-family-loader.ts
+async function loadTileflowStyleFamily(url, options = {}) {
+  const request = options.fetch ?? globalThis.fetch.bind(globalThis);
+  const response = await request(url, { credentials: "same-origin", signal: options.signal });
+  if (!response.ok) throw new Error(`Tileflow style family request failed: ${response.status}`);
+  const maximum = tileflowStyleFamilyLimits.documentBytes;
+  const length = response.headers.get("content-length");
+  if (length && Number(length) > maximum) {
+    await response.body?.cancel();
+    throw new TypeError("Tileflow style family is too large.");
+  }
+  const reader = response.body?.getReader();
+  if (!reader) throw new TypeError("Tileflow style family response has no body.");
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maximum) {
+        await reader.cancel();
+        throw new TypeError("Tileflow style family is too large.");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes2 = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes2.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return parseTileflowStyleFamily(
+    JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes2))
+  );
+}
+
+// src/color-program-runtime.ts
+init_color_program();
+
+// src/themes/index.ts
+init_color_program();
+init_model();
+init_visual_semantics();
+var baseThemeColorRoles = {
+  background: "surface.background",
+  boundary: "boundaries.default",
+  building: "surface.building",
+  land: "surface.land",
+  park: "surface.park",
+  road: "roads.default",
+  roadCasing: "roads.casing",
+  roadMajor: "roads.major",
+  text: "labels.primary",
+  textHalo: "labels.halo",
+  textMuted: "labels.muted",
+  water: "surface.water"
+};
+var tileflowRequiredThemeColorRoles = Object.freeze(Object.values(baseThemeColorRoles));
+var baseThemeColorRoleSet = new Set(tileflowRequiredThemeColorRoles);
+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);
+  const g = Math.round(a.g + (b.g - a.g) * amount);
+  const bValue = Math.round(a.b + (b.b - a.b) * amount);
+  return rgbToHex(r, g, bValue);
+}
+function hexToRgb(hex) {
+  const { b, g, r } = hexToRgba(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*\)$/
+  );
+  if (rgbMatch) {
+    return {
+      a: roundAlpha(Number(rgbMatch[4] ?? 1)),
+      r: Math.round(Number(rgbMatch[1])),
+      g: Math.round(Number(rgbMatch[2])),
+      b: Math.round(Number(rgbMatch[3]))
+    };
+  }
+  const value = hex.replace("#", "");
+  const normalized = value.length === 3 || value.length === 4 ? value.split("").map((character) => character + character).join("") : value;
+  return {
+    a: normalized.length === 8 ? roundAlpha(Number.parseInt(normalized.slice(6, 8), 16) / 255) : 1,
+    r: Number.parseInt(normalized.slice(0, 2), 16),
+    g: Number.parseInt(normalized.slice(2, 4), 16),
+    b: Number.parseInt(normalized.slice(4, 6), 16)
+  };
+}
+function roundAlpha(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function rgbToHex(r, g, b) {
+  return `#${[r, g, b].map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
+
+// src/color-program-runtime.ts
+init_model();
+function applyTileflowColorOverrides(style, overrides) {
+  const keys = Object.keys(overrides);
+  if (!keys.length) return style;
+  const catalog = style.metadata?.[tileflowColorMetadataKey];
+  if (!catalog)
+    throw new TypeError(
+      "This style has no runtime colour bindings. Rebuild with runtimeColors enabled."
+    );
+  validateBindings(catalog);
+  if (keys.length > 1024 || keys.some(
+    (key) => !Object.hasOwn(catalog.tokens.color, key) || typeof overrides[key] !== "string" || overrides[key].length > 128
+  ))
+    throw new TypeError("Unknown colour token or invalid override.");
+  const theme = {
+    id: "runtime",
+    version: 1,
+    colorScheme: "light",
+    lighting: {},
+    typography: { font: "Noto Sans Regular" },
+    tokens: {
+      ...catalog.tokens,
+      color: { ...catalog.tokens.color, ...overrides },
+      font: {},
+      image: {}
+    }
+  };
+  const resolved = resolveTileflowTheme(theme);
+  const concrete = {
+    ...theme,
+    tokens: { ...theme.tokens, color: resolved.tokens.color, number: resolved.tokens.number }
+  };
+  const evaluate = (program) => {
+    if (typeof program === "string") return program;
+    if (Array.isArray(program) && program[0] === "srgb" && program.length === 4 && typeof program[3] === "number" && program[3] >= 0 && program[3] <= 1)
+      return mix(evaluate(program[1]), evaluate(program[2]), program[3]);
+    if (program && typeof program === "object" && !Array.isArray(program)) {
+      const node = program;
+      if (node.kind === "theme-color" && node.operation === "alpha")
+        program = { ...node, color: evaluate(node.color) };
+      else if (node.kind === "theme-color" && node.operation === "mix")
+        program = { ...node, from: evaluate(node.from), to: evaluate(node.to) };
+    }
+    return resolveThemeValues({ color: program }, concrete).color;
+  };
+  const affected = (node, seen = /* @__PURE__ */ new Set()) => {
+    if (!node || typeof node !== "object") return false;
+    const ref = node;
+    if (ref.kind === "theme-token" && ref.category === "color" && typeof ref.token === "string") {
+      if (Object.hasOwn(overrides, ref.token)) return true;
+      if (seen.has(ref.token)) return false;
+      return affected(catalog.tokens.color[ref.token], /* @__PURE__ */ new Set([...seen, ref.token]));
+    }
+    return Object.values(node).some((value) => affected(value, seen));
+  };
+  const values = catalog.programs.map(
+    (program) => affected(program) ? evaluate(program) : void 0
+  );
+  const result = structuredClone(style);
+  for (const [path, id] of catalog.bindings)
+    if (values[id] !== void 0) updatePath(result, path, () => colorProgramValue(values[id]));
+  return result;
+}
+
+// src/style-family-render.ts
+init_color_program();
+init_theme_blend();
+var preparedFamilies = /* @__PURE__ */ new WeakMap();
+function prepareTileflowStyleFamilyForRendering(family) {
+  const cached = preparedFamilies.get(family);
+  if (cached) return cached;
+  if (readTileflowFamilyValue(family, ["metadata", "tileflow:family-prepared"], family.themes[0]) === 1)
+    return family;
+  if (!family.updates.appearanceOnly || family.themes.length < 2) return family;
+  const styles = expandTileflowStyleFamily(family);
+  const plan = planTileflowThemeBlend(
+    family.themes.map((name) => restoreTileflowColorPrograms(styles[name])),
+    { iconImages: "mix" }
+  );
+  const first = plan.styleAt(0);
+  const descendants = (id) => first.layers.map((layer) => String(layer.id)).filter(
+    (name) => name === id || name.startsWith(`${id}::branch-`) || name.startsWith(`${id}::theme-`)
+  );
+  const prepared = createTileflowStyleFamily(
+    Object.fromEntries(
+      family.themes.map((name, index) => {
+        const style = plan.styleAt(index);
+        const metadata = {
+          ...styles[name].metadata,
+          "tileflow:family-prepared": 1,
+          ...plan.images.length ? { "tileflow:family-images": plan.images, "tileflow:family-image-theme": name } : {},
+          // A split physical layer must retain the planner's interaction mapping.
+          ...style.metadata?.["tileflow:interaction-manifest"] ? { "tileflow:interaction-manifest": style.metadata["tileflow:interaction-manifest"] } : {},
+          ...style.metadata?.["tileflow:overlay-placement-manifest"] ? {
+            "tileflow:overlay-placement-manifest": style.metadata["tileflow:overlay-placement-manifest"]
+          } : {}
+        };
+        const vegetation = metadata["tileflow:vegetation"];
+        if (Array.isArray(vegetation?.flatLayers))
+          metadata["tileflow:vegetation"] = {
+            ...vegetation,
+            flatLayers: vegetation.flatLayers.flatMap(descendants)
+          };
+        const display = metadata["tileflow:vegetation-display"];
+        if (Array.isArray(display?.flatLayers))
+          metadata["tileflow:vegetation-display"] = {
+            ...display,
+            flatLayers: display.flatLayers.flatMap(
+              (layer) => descendants(layer.id).map((id) => ({ ...layer, id }))
+            )
+          };
+        const colors = styles[name].metadata?.[tileflowColorMetadataKey];
+        const preparedStyle = { ...style, transition: { duration: 0, delay: 0 }, metadata };
+        if (colors) {
+          const restoredMetadata = restoreTileflowColorPrograms(styles[name]).metadata;
+          for (const key of Object.keys(restoredMetadata))
+            if (key !== "tileflow:interaction-manifest" && key !== "tileflow:overlay-placement-manifest" && key !== "tileflow:vegetation-display")
+              preparedStyle.metadata[key] = key === "tileflow:vegetation" ? {
+                ...restoredMetadata[key],
+                flatLayers: metadata[key].flatLayers
+              } : restoredMetadata[key];
+        }
+        return [
+          name,
+          colors ? extractTileflowColorPrograms(preparedStyle, colors.tokens) : preparedStyle
+        ];
+      })
+    )
+  );
+  if (!prepared.updates.appearanceOnly)
+    throw new TypeError("Family preparation changed its structural contract.");
+  preparedFamilies.set(family, prepared);
+  preparedFamilies.set(prepared, prepared);
+  return prepared;
+}
+
+// src/style-family-runtime.ts
+function resolveTileflowStyleResourceUrls(style, documentUrl) {
+  const result = structuredClone(style);
+  const absolute = (value) => (
+    // URL encodes path placeholders. Query values may contain a nested URL whose
+    // escaped placeholders must remain opaque to the outer tile substitution.
+    new URL(value, documentUrl).href.replace(
+      /^[^?#]+/u,
+      (path) => path.replaceAll(/%7B([^%]+)%7D/giu, "{$1}")
+    )
+  );
+  const property = (record3, key) => {
+    if (typeof record3[key] === "string") record3[key] = absolute(record3[key]);
+  };
+  property(result, "glyphs");
+  if (typeof result.sprite === "string") result.sprite = absolute(result.sprite);
+  else if (Array.isArray(result.sprite))
+    for (const sprite of result.sprite) property(sprite, "url");
+  for (const source of Object.values(result.sources)) {
+    property(source, "url");
+    if (source.type === "geojson") property(source, "data");
+    if (Array.isArray(source.tiles))
+      source.tiles = source.tiles.map(
+        (value) => typeof value === "string" ? absolute(value) : value
+      );
+    if (Array.isArray(source.urls))
+      source.urls = source.urls.map(
+        (value) => typeof value === "string" ? absolute(value) : value
+      );
+  }
+  const metadata = result.metadata;
+  const fonts = metadata?.["tileflow:fontFaces"];
+  if (Array.isArray(fonts)) {
+    for (const face of fonts) if (face && typeof face === "object") property(face, "source");
+  }
+  for (const key of ["tileflow:buildings", "tileflow:vegetation"]) {
+    const descriptor = metadata?.[key];
+    if (Array.isArray(descriptor?.models))
+      for (const model of descriptor.models) property(model, "url");
+  }
+  return result;
+}
+function resolveTileflowFamilyResourceUrls(family, documentUrl) {
+  if (family.updates.appearanceOnly)
+    return withTileflowFamilyTemplate(
+      family,
+      resolveTileflowStyleResourceUrls(
+        expandTileflowFamilyTemplate(family),
+        documentUrl
+      )
+    );
+  return createTileflowStyleFamily(
+    Object.fromEntries(
+      Object.entries(expandTileflowStyleFamily(family)).map(([name, style]) => [
+        name,
+        resolveTileflowStyleResourceUrls(style, documentUrl)
+      ])
+    )
+  );
+}
+async function loadTileflowRuntimeAppearance(style, options = {}) {
+  if (!style.familyUrl || !style.theme || style.family) return style;
+  const family = prepareTileflowStyleFamilyForRendering(
+    resolveTileflowFamilyResourceUrls(
+      await loadTileflowStyleFamily(style.familyUrl, options),
+      style.familyUrl
+    )
+  );
+  return { ...style, family, style: materializeTileflowStyleFamily(family, style.theme) };
+}
+
+// src/appearance.ts
+init_time_of_day();
+function resolveTileflowAppearance(map, selection, context) {
+  const theme = (moment) => {
+    if (moment !== void 0 && !isTileflowTimeOfDay(moment))
+      throw new TypeError("Invalid appearance moment.");
+    return resolveTileflowRuntimeTheme(map, selection.palette, context.colorScheme, moment).name;
+  };
+  if (selection.mode === "fixed") return { themes: [theme(selection.moment)], position: 0 };
+  if (selection.mode === "system")
+    return { themes: [theme(selection[context.colorScheme])], position: 0 };
+  if (selection.mode !== "clock")
+    throw new TypeError("Expected fixed, system, or clock appearance.");
+  const schedule = [...selection.schedule].sort((a, b) => a.hour - b.hour);
+  if (schedule.length < 2 || schedule.length > 24 || schedule.some(
+    (stop, index) => !Number.isFinite(stop.hour) || stop.hour < 0 || stop.hour >= 24 || !isTileflowTimeOfDay(stop.moment) || index > 0 && stop.hour === schedule[index - 1].hour
+  ))
+    throw new TypeError("A clock schedule needs 2\u201324 distinct hours from 0 to less than 24.");
+  if (!Number.isFinite(context.date.getTime())) throw new TypeError("Invalid appearance date.");
+  const hour = context.date.getHours() + context.date.getMinutes() / 60 + context.date.getSeconds() / 3600;
+  let lower = -1;
+  schedule.forEach((stop, index) => {
+    if (stop.hour <= hour) lower = index;
+  });
+  if (lower < 0) lower = schedule.length - 1;
+  const from = schedule[lower];
+  const to = schedule[(lower + 1) % schedule.length];
+  if (!selection.blend) return { themes: [theme(from.moment)], position: 0 };
+  const span = (to.hour - from.hour + 24) % 24;
+  const themes = [theme(from.moment), theme(to.moment)];
+  return themes[0] === themes[1] ? { themes: [themes[0]], position: 0 } : { themes, position: (hour - from.hour + 24) % 24 / span };
+}
+
+// src/runtime.ts
 init_time_of_day();
 var defaultTileflowManifestUrl = "/tileflow/manifest.json";
 var defaultTileflowRuntimeView = Object.freeze({
@@ -659,6 +3696,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,
@@ -876,7 +3914,7 @@ async function requestSessionGrant(input) {
       else throw error;
     }
     throwIfSessionGrantAborted(signal);
-    if (response.status === 409 && isRecord(body) && body.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && body.ok === false && body.retryWithNewSession === true && body.sessionId === input.sessionId) {
+    if (response.status === 409 && isRecord4(body) && body.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && body.ok === false && body.retryWithNewSession === true && body.sessionId === input.sessionId) {
       throw new TileflowSessionRestartError();
     }
     if (!response.ok) {
@@ -949,7 +3987,7 @@ function sessionGrantAbortReason(signal) {
   return error;
 }
 function parseSessionGrantResponse(value, expectedSessionId) {
-  if (!isRecord(value) || value.ok !== true || value.sessionId !== expectedSessionId) return null;
+  if (!isRecord4(value) || value.ok !== true || value.sessionId !== expectedSessionId) return null;
   if (value.usageMode !== void 0 && value.usageMode !== "session") return null;
   if (value.billingEnabled !== void 0 && value.billingEnabled !== false) return null;
   if (value.disposition !== void 0 && value.disposition !== "ordinary" && value.disposition !== "unbilled_fail_open") {
@@ -968,11 +4006,11 @@ function parseSessionGrantResponse(value, expectedSessionId) {
   }
   return value;
 }
-function isRecord(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPlainRuntimeRecord(value) {
-  if (!isRecord(value)) return false;
+  if (!isRecord4(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
@@ -1175,6 +4213,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);
@@ -1224,6 +4263,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 } : {},
@@ -1306,14 +4346,14 @@ async function readBoundedUtf8Response(response, maximumBytes, errors) {
     }
     chunks.push(next.value);
   }
-  const bytes = new Uint8Array(byteLength);
+  const bytes2 = new Uint8Array(byteLength);
   let offset = 0;
   for (const chunk of chunks) {
-    bytes.set(chunk, offset);
+    bytes2.set(chunk, offset);
     offset += chunk.byteLength;
   }
   try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes2);
   } catch {
     throw new Error(errors.invalidUtf8);
   }
@@ -1408,24 +4448,33 @@ function getTileflowLocationBaseUrl() {
   return `${getTileflowLocationOrigin().replace(/\/+$/u, "")}/`;
 }
 export {
+  applyTileflowColorOverrides,
   assertValidTileflowRuntimeSource,
   clearTileflowManifestCache,
   createTileflowSessionController,
   createTileflowSessionId,
   defaultTileflowManifestUrl,
   defaultTileflowRuntimeView,
+  expandTileflowFamilyTemplate,
   getTileflowAnalyticsApiUrl,
   getTileflowStyleFontFaces,
   inferTileflowAnalyticsFromStyleUrl,
   isTileflowTimeOfDay,
   loadTileflowManifest,
+  loadTileflowRuntimeAppearance,
+  loadTileflowStyleFamily,
+  materializeTileflowStyleFamily,
   mergeTileflowAnalytics,
   nearestTileflowBlendTheme,
   normalizeTileflowRuntimeCenter,
   normalizeTileflowStaticImageSize,
   normalizeTileflowSurfaceId,
   normalizeTileflowUrl,
+  parseTileflowStyleFamily,
+  prepareTileflowStyleFamilyForRendering,
   resolveTileflowAnalyticsRequestUrl,
+  resolveTileflowAppearance,
+  resolveTileflowFamilyResourceUrls,
   resolveTileflowManifestMap,
   resolveTileflowMapMode,
   resolveTileflowRuntimeStyle,
@@ -1433,13 +4482,16 @@ export {
   resolveTileflowRuntimeThemeBlend,
   resolveTileflowRuntimeView,
   resolveTileflowStaticImageUrl,
+  resolveTileflowStyleResourceUrls,
   shouldLoadTileflowManifest,
   startTileflowSession,
+  tileflowStyleFamilyLimits,
   tileflowStyleFontFaceLimits,
   tileflowStyleFontFacesMetadataKey,
   tileflowThemeBlendLimits,
   tileflowTimesOfDay,
   validateTileflowRuntimeSource,
   validateTileflowThemeBlendSelection,
-  validateTileflowThemeSelection
+  validateTileflowThemeSelection,
+  withTileflowFamilyTemplate
 };