@tileflow/core 0.1.0-alpha.32 → 0.1.0-alpha.34

package/dist/native.js

@@ -3493,2046 +3493,2055 @@ 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/theme-blend.ts
+function planTileflowThemeBlend(styles, options = {}) {
+  if (styles.length < 2)
+    throw new TileflowThemeBlendError("A theme blend needs two or more themes.");
+  const [base2] = styles;
+  assertSameStructure(styles, base2);
+  const mixedImages = new Set(imageProperties);
+  if (options.iconImages === "switch") mixedImages.delete("icon-image");
+  const paints = [];
+  const switches = [];
+  const imageGroups = collectImageNames(styles, base2, 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 base2.layers.entries()) {
+    const variants = styles.map((style) => style.layers[index]);
+    layers.push(...planLayer(variants, String(layer.type)));
   }
-});
-
-// src/manifest-schema.ts
-function createTileflowRuntimeManifestSchema(primitives, operations, identities = createPortableIdentitySchemas(operations)) {
-  const { tileflowPortableIdSchema, tileflowThemeNameSchema } = identities;
-  const safeTextSchema = operations.refine(
-    operations.refine(
-      operations.maxLength(operations.minLength(operations.string(), 1), 2048),
-      (value) => value === value.trim(),
-      "Expected text without surrounding whitespace"
-    ),
-    (value) => !/[\p{Cc}\\]/u.test(value),
-    "Expected safe text"
-  );
-  const publicResourceUrlSchema = operations.refine(
-    safeTextSchema,
-    isPublicResourceUrl,
-    "Expected an HTTP(S), root-relative, or path-relative public URL"
-  );
-  const apiOriginSchema = operations.refine(
-    safeTextSchema,
-    isApiOrigin,
-    "Expected an absolute HTTP(S) origin without path, credentials, query, or fragment"
-  );
-  const viewSchema2 = createTileflowRuntimeViewSchema(operations);
-  const fontFaceSchema = operations.object({
-    family: operations.maxLength(safeTextSchema, 100),
-    source: publicResourceUrlSchema,
-    style: operations.optional(operations.enum(["italic", "normal", "oblique"])),
-    weight: operations.optional(
-      operations.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
-    )
-  });
-  const fontFacesSchema = operations.superRefine(
-    operations.maxLength(operations.array(fontFaceSchema), 16),
-    validateUniqueFontFaces
-  );
-  const manifestThemeSchema = operations.object({
-    colorScheme: operations.enum(["dark", "light"]),
-    fontFaces: operations.optional(fontFacesSchema),
-    revision: operations.optional(operations.maxLength(safeTextSchema, 128)),
-    styleId: operations.optional(operations.maxLength(safeTextSchema, 128)),
-    styleUrl: publicResourceUrlSchema
-  });
-  const manifestMapSchema = operations.superRefine(
-    operations.object({
-      apiUrl: operations.optional(apiOriginSchema),
-      defaultTheme: tileflowThemeNameSchema,
-      environment: operations.optional(operations.maxLength(safeTextSchema, 128)),
-      mapId: operations.optional(operations.maxLength(safeTextSchema, 128)),
-      systemThemes: operations.optional(
-        operations.object({
-          dark: tileflowThemeNameSchema,
-          light: tileflowThemeNameSchema
-        })
-      ),
-      themes: operations.record(tileflowThemeNameSchema, manifestThemeSchema),
-      usageMode: operations.optional(operations.literal("session")),
-      view: operations.optional(viewSchema2),
-      worldGeneration: operations.optional(operations.literal("v1"))
-    }),
-    (entry, context) => {
-      const names = Object.keys(entry.themes);
-      if (names.length === 0) {
-        context.addIssue({
-          code: "custom",
-          message: "Expected at least one theme",
-          path: ["themes"]
-        });
-      }
-      if (names.length > tileflowThemeLimits.maxThemes) {
-        context.addIssue({
-          code: "too_big",
-          maximum: tileflowThemeLimits.maxThemes,
-          origin: "object",
-          path: ["themes"]
-        });
-      }
-      if (!Object.hasOwn(entry.themes, entry.defaultTheme)) {
-        context.addIssue({
-          code: "custom",
-          message: "defaultTheme must name a declared theme",
-          path: ["defaultTheme"]
-        });
-      }
-      if (entry.systemThemes) {
-        for (const colorScheme of ["light", "dark"]) {
-          const name = entry.systemThemes[colorScheme];
-          const theme = entry.themes[name];
-          if (!theme) {
-            context.addIssue({
-              code: "custom",
-              message: `systemThemes.${colorScheme} must name a declared theme`,
-              path: ["systemThemes", colorScheme]
-            });
-          } else if (theme.colorScheme !== colorScheme) {
-            context.addIssue({
-              code: "custom",
-              message: `systemThemes.${colorScheme} must reference a ${colorScheme} theme`,
-              path: ["systemThemes", colorScheme]
-            });
+  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(base2.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 = {
+        ...base2,
+        ...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) => same(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;
       }
-      if (entry.usageMode === void 0 !== (entry.worldGeneration === void 0)) {
-        context.addIssue({
-          code: "custom",
-          message: "usageMode and worldGeneration must be declared together"
+    }
+    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 });
     }
-  );
-  const canonicalManifestSchema = operations.superRefine(
-    operations.object({
-      apiUrl: operations.optional(apiOriginSchema),
-      maps: operations.record(tileflowPortableIdSchema, manifestMapSchema),
-      version: operations.literal(tileflowRuntimeManifestVersion)
-    }),
-    (manifest, context) => {
-      const mapCount = Object.keys(manifest.maps).length;
-      if (mapCount === 0) {
-        context.addIssue({ code: "custom", message: "Expected at least one map", path: ["maps"] });
-      }
-      if (mapCount > 1e3) {
-        context.addIssue({ code: "too_big", maximum: 1e3, origin: "object", path: ["maps"] });
-      }
-      if (primitives.utf8ByteLength(JSON.stringify(manifest)) > tileflowRuntimeManifestLimits.maximumBytes) {
-        context.addIssue({
-          code: "too_big",
-          maximum: tileflowRuntimeManifestLimits.maximumBytes,
-          origin: "string",
-          message: "Manifest JSON exceeds the 1 MiB limit"
-        });
-      }
-    }
-  );
-  const safeManifestInputSchema = operations.superRefine(operations.unknown(), (input, context) => {
-    const unsafe = findUnsafeManifestStructure(input);
-    if (unsafe) {
-      context.addIssue({
-        code: "custom",
-        message: unsafe.reason === "prototype" ? "Expected plain manifest objects" : "Expected no prototype-mutating keys",
-        path: unsafe.path
+    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 validateUniqueFontFaces(fontFaces, context) {
-    const seen = /* @__PURE__ */ new Map();
-    for (const [index, fontFace] of fontFaces.entries()) {
-      const identity = `${fontFace.family}\0${fontFace.style ?? "normal"}\0${fontFace.weight ?? "400"}`;
-      const first = seen.get(identity);
-      if (first !== void 0) {
-        context.addIssue({
-          code: "custom",
-          message: `Duplicate font face identity; first declared at index ${first}`,
-          path: [index]
-        });
-        continue;
+    function splitLayer() {
+      if (isLegacyFilter(layer.filter)) return void 0;
+      const branches = splitBranches(
+        Object.fromEntries(
+          driven.map((property) => [
+            property,
+            variants.map((variant) => paintOf(variant)[property])
+          ])
+        )
+      );
+      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, values] of Object.entries(branch.valuesByProperty)) {
+            const template = tryMixTemplate(values);
+            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]
+        );
       }
-      seen.set(identity, index);
-    }
-  }
-  function isPublicResourceUrl(value) {
-    if (value.startsWith("//")) return false;
-    if (!value.startsWith("/") && !value.startsWith("./") && !value.startsWith("../") && !isAbsolutePublicUrl(value)) {
-      return false;
+      splitLayers += groups.size;
+      return [...groups.values()].map((group, number3) => {
+        const chosen = group.conditions.length === 1 ? group.conditions[0] : ["any", ...group.conditions];
+        return {
+          layer: {
+            ...planned,
+            id: `${id}::branch-${number3}`,
+            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 }))
+        };
+      });
     }
-    return isSafeResolvedPublicUrl(value);
-  }
-  function isAbsolutePublicUrl(value) {
-    try {
-      const url = primitives.parseUrl(value);
-      return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
-    } catch {
-      return false;
+    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 isSafeResolvedPublicUrl(value) {
-    try {
-      const url = primitives.parseUrl(value, "https://manifest.invalid/owner/manifest.json");
-      return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
-    } catch {
-      return false;
+}
+function fillTileflowThemeBlendTemplate(template, position) {
+  return fillTemplate(template, position);
+}
+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];
   }
-  function hasEncodedPathSeparator(value) {
-    return /%(?:2f|5c)/iu.test(value);
+  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)])
+    );
   }
-  function isApiOrigin(value) {
-    try {
-      const url = primitives.parseUrl(value);
-      return isAbsolutePublicUrl(value) && url.pathname === "/" && !url.search && value.replace(/\/$/u, "") === url.origin;
-    } catch {
-      return false;
+  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, base2) {
+  const ids = (style) => style.layers.map((layer) => layer.id);
+  for (const style of styles) {
+    if (!same(ids(style), ids(base2)))
+      throw new TileflowThemeBlendError(
+        "Blended themes must have the same layers in the same order."
+      );
+    if (!same(style.sources, base2.sources))
+      throw new TileflowThemeBlendError("Blended themes must use the same sources.");
+    if (!same(style.sprite, base2.sprite) || !same(style.glyphs, base2.glyphs))
+      throw new TileflowThemeBlendError("Blended themes must use the same sprite and glyphs.");
+    for (const [index, layer] of style.layers.entries()) {
+      const other = base2.layers[index];
+      for (const key of ["type", "source", "source-layer", "filter", "minzoom", "maxzoom"])
+        if (!same(layer[key], other[key]))
+          throw new TileflowThemeBlendError(
+            `Blended themes differ in ${key} of layer ${JSON.stringify(layer.id)}.`
+          );
     }
   }
-  function findUnsafeManifestStructure(input) {
-    if (!input || typeof input !== "object") return void 0;
-    const pending = [
-      { path: [], value: input }
-    ];
-    const visited = /* @__PURE__ */ new WeakSet();
-    while (pending.length > 0) {
-      const current = pending.pop();
-      if (visited.has(current.value)) continue;
-      visited.add(current.value);
-      if (!Array.isArray(current.value)) {
-        const prototype = Object.getPrototypeOf(current.value);
-        if (prototype !== Object.prototype && prototype !== null) {
-          return { path: current.path, reason: "prototype" };
+}
+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) => same(value, values[0]))) return void 0;
+  return tryMixTemplate(values);
+}
+function collectImageNames(styles, base2, properties) {
+  const uses = /* @__PURE__ */ new Map();
+  for (const [index] of base2.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);
         }
       }
-      for (const key of Object.keys(current.value)) {
-        const path = [...current.path, Array.isArray(current.value) ? Number(key) : key];
-        if (key === "__proto__") return { path, reason: "key" };
-        const descriptor = Object.getOwnPropertyDescriptor(current.value, key);
-        if (descriptor && "value" in descriptor && descriptor.value && typeof descriptor.value === "object") {
-          pending.push({ path, value: descriptor.value });
+    }
+  }
+  return uses;
+}
+function alignInteractionManifest(metadata, layers) {
+  if (!isRecord(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 = isRecord(interactions) ? interactions.domains : void 0;
+  if (isRecord(interactions) && isRecord(domains) && isRecord(domains.poi)) {
+    const poi = domains.poi;
+    if (Array.isArray(poi.layers)) {
+      const poiLayers = poi.layers.flatMap((entry) => {
+        if (!isRecord(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 } }
         }
-      }
+      };
     }
-    return void 0;
   }
-  return operations.pipe(safeManifestInputSchema, canonicalManifestSchema);
+  const overlays = metadata["tileflow:overlay-placement-manifest"];
+  if (isRecord(overlays) && isRecord(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;
 }
-var init_manifest_schema = __esm({
-  "src/manifest-schema.ts"() {
-    "use strict";
-    init_manifest_types();
-    init_portable_identity_schema();
-    init_runtime_view_schema();
-    init_model();
+function imageTuples(values, out = []) {
+  const [first] = values;
+  if (values.every((value) => typeof value === "string")) {
+    out.push(values);
+    return out;
   }
-});
-
-// src/native-url-policy.ts
-var tileflowNativeUrlLimits = Object.freeze({ maximumLength: 2048 });
-var errorMessages = {
-  NATIVE_URL_INVALID: "Expected a bounded HTTP(S) URL without credentials, fragments or backslashes.",
-  NATIVE_URL_ABSOLUTE_REQUIRED: "An explicit absolute HTTP(S) document URL is required.",
-  NATIVE_URL_HTTPS_REQUIRED: "HTTP is allowed only at the explicitly configured development origin.",
-  NATIVE_URL_DEVELOPMENT_ORIGIN_INVALID: "Expected one HTTP origin without a path, credentials, query or fragment.",
-  NATIVE_URL_TEMPLATE_INVALID: "Expected supported URL placeholders in the resource path or query only."
-};
-var TileflowNativeUrlError = class extends TypeError {
-  constructor(code, field) {
-    super(errorMessages[code]);
-    __publicField(this, "code");
-    __publicField(this, "field");
-    this.name = "TileflowNativeUrlError";
-    this.code = code;
-    this.field = field;
+  if (!Array.isArray(first) || typeof first[0] !== "string") {
+    return values.every((value) => same(value, first)) ? out : void 0;
   }
-};
-function createNativeUrlPolicy(parse2) {
-  const tilePlaceholders = /* @__PURE__ */ new Set(["z", "x", "y", "ratio", "quadkey", "bbox-epsg-3857", "prefix"]);
-  const glyphPlaceholders = /* @__PURE__ */ new Set(["fontstack", "range"]);
-  const absoluteHttpPattern = /^https?:\/\/[^/?#]+/iu;
-  const schemePattern = /^[a-z][a-z\d+.-]*:/iu;
-  function resolveTileflowNativeManifestUrl2(value, options = {}) {
-    assertOptionsObject(options, "developmentOrigin");
-    const developmentOrigin = resolveDevelopmentOrigin(options.developmentOrigin);
-    return resolveDocumentUrl(value, "manifestUrl", developmentOrigin).href;
+  const operator = first[0];
+  if (!values.every(
+    (value) => Array.isArray(value) && value[0] === operator && value.length === first.length
+  )) {
+    return void 0;
   }
-  function resolveTileflowNativeResourceUrl2(value, options) {
-    assertOptionsObject(options, "documentUrl");
-    const developmentOrigin = resolveDevelopmentOrigin(options.developmentOrigin);
-    const document2 = resolveDocumentUrl(options.documentUrl, "documentUrl", developmentOrigin);
-    assertUrlText(value, "resourceUrl");
-    if (options.template !== void 0 && options.template !== "tile" && options.template !== "glyphs") {
-      throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", "resourceUrl");
-    }
-    assertReferenceSyntax(value, "resourceUrl", false);
-    const authority = absoluteHttpPattern.exec(value)?.[0];
-    if (authority && /[{}]/u.test(authority)) {
-      throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", "resourceUrl");
+  const at = (index) => values.map((value) => value[index]);
+  const sameAt = (index) => at(index).every((value) => same(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);
     }
-    let prefix = "__tileflow_native_template_";
-    let attempt = 0;
-    while (value.includes(prefix) || document2.href.includes(prefix)) {
-      prefix = `__tileflow_native_template_${attempt++}_`;
+    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);
     }
-    const placeholders = [];
-    const allowed = options.template === "tile" ? tilePlaceholders : glyphPlaceholders;
-    const protectedValue = value.replace(/\{([^{}]*)\}/gu, (placeholder, name) => {
-      if (!options.template || !allowed.has(name)) {
-        throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", "resourceUrl");
-      }
-      placeholders.push(placeholder);
-      return `${prefix}${placeholders.length - 1}__`;
-    });
-    if (/[{}]/u.test(protectedValue)) {
-      throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", "resourceUrl");
+    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);
     }
-    const resolved = parseUrl(protectedValue, "resourceUrl", document2.href);
-    assertTransport(resolved, "resourceUrl", developmentOrigin);
-    const resourcePath = resolved.href.slice(resolved.origin.length);
-    const suffix = resourcePath.replace(
-      new RegExp(`${prefix}(\\d+)__`, "gu"),
-      (match, index) => placeholders[Number(index)] ?? match
-    );
-    const result = resolved.origin + suffix;
-    assertUrlText(result, "resourceUrl");
-    return result;
+  } else {
+    return values.every((value) => same(value, first)) ? out : void 0;
   }
-  function assertOptionsObject(value, field) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-      throw new TileflowNativeUrlError(
-        field === "documentUrl" ? "NATIVE_URL_INVALID" : "NATIVE_URL_DEVELOPMENT_ORIGIN_INVALID",
-        field
-      );
+  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) => same(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;
   }
-  function resolveDevelopmentOrigin(value) {
-    if (value === void 0) return void 0;
-    try {
-      assertUrlText(value, "developmentOrigin");
-      const match = /^(http:\/\/[^/?#]+)\/?$/iu.exec(value);
-      if (!match || /[{}@*]/u.test(value)) throw new Error();
-      const url = parseUrl(value, "developmentOrigin");
-      if (url.protocol !== "http:" || url.pathname !== "/" || url.search || url.hash || url.hostname.includes("*")) {
-        throw new Error();
-      }
-      return url.origin;
-    } catch {
-      throw new TileflowNativeUrlError(
-        "NATIVE_URL_DEVELOPMENT_ORIGIN_INVALID",
-        "developmentOrigin"
-      );
+  if (first && typeof first === "object" && !Array.isArray(first)) {
+    const keys = Object.keys(first);
+    if (!values.every((value) => value && typeof value === "object" && same(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;
   }
-  function resolveDocumentUrl(value, field, developmentOrigin) {
-    assertUrlText(value, field);
-    assertReferenceSyntax(value, field, true);
-    if (/[{}]/u.test(value)) throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", field);
-    const url = parseUrl(value, field);
-    assertTransport(url, field, developmentOrigin);
-    assertUrlText(url.href, field);
-    return url;
-  }
-  function assertUrlText(value, field) {
-    if (typeof value !== "string" || value.length === 0 || value.length > tileflowNativeUrlLimits.maximumLength || value !== value.trim() || /[\p{Cc}\\#]/u.test(value) || /%(?![\da-f]{2})/iu.test(value)) {
-      throw new TileflowNativeUrlError("NATIVE_URL_INVALID", field);
+  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
+    };
   }
-  function assertReferenceSyntax(value, field, absolute) {
-    if (value.startsWith("//")) {
-      throw new TileflowNativeUrlError(
-        absolute ? "NATIVE_URL_ABSOLUTE_REQUIRED" : "NATIVE_URL_INVALID",
-        field
-      );
+  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]);
     }
-    const authority = absoluteHttpPattern.exec(value)?.[0];
-    if (schemePattern.test(value) && !authority) {
-      throw new TileflowNativeUrlError("NATIVE_URL_INVALID", field);
-    }
-    if (absolute && !authority) {
-      throw new TileflowNativeUrlError("NATIVE_URL_ABSOLUTE_REQUIRED", field);
-    }
-    if (authority?.includes("@")) throw new TileflowNativeUrlError("NATIVE_URL_INVALID", field);
+    outputs.push(node.at(-1));
+    if (!conditions.some(isDataDriven)) return void 0;
+    return {
+      index: [
+        "case",
+        ...conditions.flatMap((condition, index) => [condition, index]),
+        conditions.length
+      ],
+      outputs
+    };
   }
-  function parseUrl(value, field, base2) {
-    let url;
-    try {
-      url = parse2(value, base2);
-      if (!url.hostname || url.username || url.password || url.hash) throw new Error();
-    } catch {
-      throw new TileflowNativeUrlError("NATIVE_URL_INVALID", field);
-    }
-    if (/[{}]/u.test(url.hostname)) {
-      throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", field);
+  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 url;
-  }
-  function assertTransport(url, field, developmentOrigin) {
-    if (url.protocol === "https:") return;
-    if (url.protocol === "http:" && url.origin === developmentOrigin) return;
-    throw new TileflowNativeUrlError("NATIVE_URL_HTTPS_REQUIRED", field);
+    return {
+      index: ["step", node[1], 0, ...stops.flatMap((stop, index) => [stop, index + 1])],
+      outputs
+    };
   }
-  return { resolveTileflowNativeManifestUrl: resolveTileflowNativeManifestUrl2, resolveTileflowNativeResourceUrl: resolveTileflowNativeResourceUrl2 };
-}
-
-// src/native-url-provider.ts
-var import_url_state_machine = __toESM(require_url_state_machine(), 1);
-function parseNativeUrl(value, base2) {
-  const baseURL = base2 === void 0 ? void 0 : (0, import_url_state_machine.basicURLParse)(base2);
-  if (baseURL === null) throw new TypeError("Invalid native URL.");
-  const parsed = (0, import_url_state_machine.basicURLParse)(value, baseURL === void 0 ? void 0 : { baseURL });
-  if (parsed === null) throw new TypeError("Invalid native URL.");
-  return {
-    href: (0, import_url_state_machine.serializeURL)(parsed),
-    origin: (0, import_url_state_machine.serializeURLOrigin)(parsed),
-    protocol: `${parsed.scheme}:`,
-    hostname: parsed.host === null ? "" : (0, import_url_state_machine.serializeHost)(parsed.host),
-    pathname: (0, import_url_state_machine.serializePath)(parsed),
-    search: parsed.query ? `?${parsed.query}` : "",
-    hash: parsed.fragment ? `#${parsed.fragment}` : "",
-    username: parsed.username,
-    password: parsed.password
-  };
-}
-
-// src/native-urls.ts
-var policy = createNativeUrlPolicy(parseNativeUrl);
-function resolveTileflowNativeManifestUrl(value, options = {}) {
-  return policy.resolveTileflowNativeManifestUrl(value, options);
+  return void 0;
 }
-function resolveTileflowNativeResourceUrl(value, options) {
-  return policy.resolveTileflowNativeResourceUrl(value, options);
+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;
 }
-
-// src/native-manifest.ts
-init_manifest_types();
-
-// ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/mini/parse.js
-init_core2();
-
-// ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/mini/schemas.js
-init_core2();
-init_util();
-var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
-  if (!inst._zod)
-    throw new Error("Uninitialized schema in ZodMiniType.");
-  $ZodType.init(inst, def);
-  inst.def = def;
-  inst.type = def.type;
-  inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
-  inst.safeParse = (data, params) => safeParse(inst, data, params);
-  inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
-  inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
-  inst.check = (...checks) => {
-    return inst.clone({
-      ...def,
-      checks: [
-        ...def.checks ?? [],
-        ...checks.map((ch) => typeof ch === "function" ? {
-          _zod: { check: ch, def: { check: "custom" }, onattach: [] }
-        } : ch)
-      ]
-    }, { parent: true });
-  };
-  inst.with = inst.check;
-  inst.clone = (_def, params) => clone(inst, _def, params);
-  inst.brand = () => inst;
-  inst.register = ((reg, meta2) => {
-    reg.add(inst, meta2);
-    return inst;
-  });
-  inst.apply = (fn) => fn(inst);
-});
-var ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
-  $ZodString.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-// @__NO_SIDE_EFFECTS__
-function string2(params) {
-  return _string(ZodMiniString, params);
+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));
 }
-var ZodMiniNumber = /* @__PURE__ */ $constructor("ZodMiniNumber", (inst, def) => {
-  $ZodNumber.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-// @__NO_SIDE_EFFECTS__
-function number2(params) {
-  return _number(ZodMiniNumber, params);
+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;
 }
-var ZodMiniUnknown = /* @__PURE__ */ $constructor("ZodMiniUnknown", (inst, def) => {
-  $ZodUnknown.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-// @__NO_SIDE_EFFECTS__
-function unknown() {
-  return _unknown(ZodMiniUnknown);
+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];
 }
-var ZodMiniNever = /* @__PURE__ */ $constructor("ZodMiniNever", (inst, def) => {
-  $ZodNever.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-// @__NO_SIDE_EFFECTS__
-function never(params) {
-  return _never(ZodMiniNever, params);
+function same(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
 }
-var ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
-  $ZodArray.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-// @__NO_SIDE_EFFECTS__
-function array(element, params) {
-  return new ZodMiniArray({
-    type: "array",
-    element,
-    ...normalizeParams(params)
-  });
+function oklab(colour) {
+  const cached2 = oklabCache.get(colour);
+  if (cached2 !== void 0) return cached2;
+  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;
 }
-var ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
-  $ZodObject.init(inst, def);
-  ZodMiniType.init(inst, def);
-  defineLazy(inst, "shape", () => def.shape);
-});
-// @__NO_SIDE_EFFECTS__
-function strictObject(shape, params) {
-  return new ZodMiniObject({
-    type: "object",
-    shape,
-    catchall: /* @__PURE__ */ never(),
-    ...normalizeParams(params)
+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))})`;
 }
-var ZodMiniTuple = /* @__PURE__ */ $constructor("ZodMiniTuple", (inst, def) => {
-  $ZodTuple.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-// @__NO_SIDE_EFFECTS__
-function tuple(items, _paramsOrRest, _params) {
-  const hasRest = _paramsOrRest instanceof $ZodType;
-  const params = hasRest ? _params : _paramsOrRest;
-  const rest = hasRest ? _paramsOrRest : null;
-  return new ZodMiniTuple({
-    type: "tuple",
-    items,
-    rest,
-    ...normalizeParams(params)
-  });
-}
-var ZodMiniRecord = /* @__PURE__ */ $constructor("ZodMiniRecord", (inst, def) => {
-  $ZodRecord.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-// @__NO_SIDE_EFFECTS__
-function record(keyType, valueType, params) {
-  if (!valueType || !valueType._zod) {
-    return new ZodMiniRecord({
-      type: "record",
-      keyType: /* @__PURE__ */ string2(),
-      valueType: keyType,
-      ...normalizeParams(valueType)
-    });
+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];
   }
-  return new ZodMiniRecord({
-    type: "record",
-    keyType,
-    valueType,
-    ...normalizeParams(params)
-  });
-}
-var ZodMiniEnum = /* @__PURE__ */ $constructor("ZodMiniEnum", (inst, def) => {
-  $ZodEnum.init(inst, def);
-  ZodMiniType.init(inst, def);
-  inst.options = Object.values(def.entries);
-});
-// @__NO_SIDE_EFFECTS__
-function _enum(values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
-  return new ZodMiniEnum({
-    type: "enum",
-    entries,
-    ...normalizeParams(params)
-  });
-}
-var ZodMiniLiteral = /* @__PURE__ */ $constructor("ZodMiniLiteral", (inst, def) => {
-  $ZodLiteral.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-// @__NO_SIDE_EFFECTS__
-function literal(value, params) {
-  return new ZodMiniLiteral({
-    type: "literal",
-    values: Array.isArray(value) ? value : [value],
-    ...normalizeParams(params)
-  });
-}
-var ZodMiniOptional = /* @__PURE__ */ $constructor("ZodMiniOptional", (inst, def) => {
-  $ZodOptional.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-// @__NO_SIDE_EFFECTS__
-function optional(innerType) {
-  return new ZodMiniOptional({
-    type: "optional",
-    innerType
-  });
+  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];
 }
-var ZodMiniPipe = /* @__PURE__ */ $constructor("ZodMiniPipe", (inst, def) => {
-  $ZodPipe.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-// @__NO_SIDE_EFFECTS__
-function pipe(in_, out) {
-  return new ZodMiniPipe({
-    type: "pipe",
-    in: in_,
-    out
-  });
+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 ZodMiniCustom = /* @__PURE__ */ $constructor("ZodMiniCustom", (inst, def) => {
-  $ZodCustom.init(inst, def);
-  ZodMiniType.init(inst, def);
+var TileflowThemeBlendError, BlendLeaf, imageProperties, opacityProperties, featureOperators, maximumBranches, isRecord, reads, isLegacyFilter, oklabCache;
+var init_theme_blend = __esm({
+  "src/theme-blend.ts"() {
+    "use strict";
+    TileflowThemeBlendError = class extends Error {
+      constructor() {
+        super(...arguments);
+        __publicField(this, "name", "TileflowThemeBlendError");
+      }
+    };
+    BlendLeaf = class {
+      constructor(values) {
+        __publicField(this, "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;
+    isRecord = (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();
+  }
 });
-// @__NO_SIDE_EFFECTS__
-function refine(fn, _params = {}) {
-  return _refine(ZodMiniCustom, fn, _params);
-}
-// @__NO_SIDE_EFFECTS__
-function superRefine(fn, params) {
-  return _superRefine(fn, params);
-}
-
-// ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/mini/checks.js
-init_core2();
-
-// src/native-manifest-schema.ts
-init_manifest_schema();
-
-// src/manifest-schema-mini.ts
-function mini(schema2) {
-  return schema2;
-}
-var miniManifestSchemaOperations = {
-  string: () => string2(),
-  minLength: (schema2, minimum) => mini(schema2).check(_minLength(minimum)),
-  maxLength: (schema2, maximum) => mini(schema2).check(_maxLength(maximum)),
-  regex: (schema2, pattern, message) => mini(schema2).check(_regex(pattern, { message })),
-  refine: (schema2, check, message) => mini(schema2).check(refine(check, message)),
-  // Zod 4's number parser rejects NaN and infinities; Classic finite() is a no-op.
-  number: (minimum, maximum) => number2().check(_gte(minimum), _lte(maximum)),
-  unknown: () => unknown(),
-  optional: (schema2) => optional(schema2),
-  array: (schema2) => array(schema2),
-  enum(values) {
-    return _enum(values);
-  },
-  literal: (value) => literal(value),
-  tuplePair(left, right) {
-    return tuple([left, right]);
-  },
-  // ZodMiniObject uses the interpreted $ZodObject, not the Classic object JIT constructor.
-  object(shape) {
-    return strictObject(shape);
-  },
-  record(key, value) {
-    return record(key, value);
-  },
-  superRefine: (schema2, check) => mini(schema2).check(superRefine(check)),
-  pipe: (input, output) => pipe(input, output)
-};
 
-// src/native-manifest-utf8.ts
-init_native_url_utf8();
-function nativeManifestUtf8ByteLength(input) {
-  let bytes = 0;
-  for (let index = 0; index < input.length; index++) {
-    const value = input.charCodeAt(index);
-    if (value <= 127) bytes++;
-    else if (value <= 2047) bytes += 2;
-    else if (value >= 55296 && value <= 56319 && input.charCodeAt(index + 1) >= 56320 && input.charCodeAt(index + 1) <= 57343) {
-      bytes += 4;
-      index++;
-    } else bytes += 3;
-  }
-  return bytes;
-}
-function decodeNativeManifestUtf8(input) {
-  let remaining = 0;
-  let lower = 128;
-  let upper = 191;
-  for (const byte of input) {
-    if (remaining === 0) {
-      if (byte <= 127) continue;
-      if (byte >= 194 && byte <= 223) remaining = 1;
-      else if (byte >= 224 && byte <= 239) {
-        remaining = 2;
-        if (byte === 224) lower = 160;
-        if (byte === 237) upper = 159;
-      } else if (byte >= 240 && byte <= 244) {
-        remaining = 3;
-        if (byte === 240) lower = 144;
-        if (byte === 244) upper = 143;
-      } else throw new TypeError("Invalid manifest UTF-8.");
-    } else {
-      if (byte < lower || byte > upper) throw new TypeError("Invalid manifest UTF-8.");
-      remaining--;
-      lower = 128;
-      upper = 191;
-    }
-  }
-  if (remaining) throw new TypeError("Invalid manifest UTF-8.");
-  const parts = [];
-  let offset = 0;
-  while (offset < input.byteLength) {
-    let end = Math.min(offset + nativeUrlCodecMaximumLength, input.byteLength);
-    while (end < input.byteLength && (input[end] & 192) === 128) end--;
-    parts.push(utf8DecodeWithoutBOM(input.subarray(offset, end)));
-    offset = end;
-  }
-  const text = parts.join("");
-  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
-}
-function hasBoundedNativeManifestDepth(text, maximumDepth) {
-  let depth = 0;
-  let quoted = false;
-  let escaped = false;
-  for (let index = 0; index < text.length; index++) {
-    const character = text[index];
-    if (quoted) {
-      if (escaped) escaped = false;
-      else if (character === "\\") escaped = true;
-      else if (character === '"') quoted = false;
-    } else if (character === '"') quoted = true;
-    else if (character === "[" || character === "{") {
-      if (++depth > maximumDepth) return false;
-    } else if (character === "]" || character === "}") depth--;
+// 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"
+    ];
   }
-  return true;
-}
+});
 
-// src/native-manifest-schema.ts
-var schema = createTileflowRuntimeManifestSchema(
-  {
-    parseUrl: parseNativeUrl,
-    utf8ByteLength: nativeManifestUtf8ByteLength
-  },
-  miniManifestSchemaOperations
-);
-function parseTileflowRuntimeManifest(input) {
-  return parse(schema, input);
-}
-
-// src/native-source-types.ts
-var messages = {
-  NATIVE_SOURCE_INVALID: "Expected a valid native source or renderer-neutral view.",
-  NATIVE_SOURCE_ABORTED: "The source operation was cancelled.",
-  NATIVE_SOURCE_DISPOSED: "The source controller has been disposed.",
-  NATIVE_MANIFEST_URL_INVALID: "Expected a safe absolute manifest URL and an exact development origin.",
-  NATIVE_MANIFEST_REQUEST_FAILED: "Manifest acquisition failed.",
-  NATIVE_MANIFEST_RESPONSE_INVALID: "Expected a bounded byte reader and an explicit final response URL.",
-  NATIVE_MANIFEST_ACCESS_DENIED: "Manifest access was denied.",
-  NATIVE_MANIFEST_NOT_FOUND: "The manifest was not found.",
-  NATIVE_MANIFEST_TOO_LARGE: "The manifest exceeds the 1 MiB limit.",
-  NATIVE_MANIFEST_UTF8_INVALID: "The manifest body is not valid UTF-8.",
-  NATIVE_MANIFEST_JSON_INVALID: "The manifest body is not valid JSON.",
-  NATIVE_MANIFEST_INVALID: "The manifest does not satisfy the version-1 runtime contract.",
-  NATIVE_MANIFEST_RESOURCE_INVALID: "A manifest resource URL is outside the native URL policy.",
-  NATIVE_MAP_NOT_FOUND: "The requested map is not declared by the manifest.",
-  NATIVE_THEME_INVALID: "Expected a declared concrete theme or an explicitly supplied system color scheme."
-};
-var TileflowNativeSourceError = class extends Error {
-  constructor(code, field) {
-    super(messages[code]);
-    __publicField(this, "code");
-    __publicField(this, "field");
-    __publicField(this, "kind");
-    this.name = "TileflowNativeSourceError";
-    this.code = code;
-    this.field = field;
-    this.kind = code === "NATIVE_SOURCE_ABORTED" || code === "NATIVE_SOURCE_DISPOSED" ? "cancelled" : "terminal";
-  }
-};
-function normalizeNativeSourceError(error2) {
-  try {
-    if (error2 instanceof TileflowNativeSourceError) {
-      const code = Object.getOwnPropertyDescriptor(error2, "code")?.value;
-      const field = Object.getOwnPropertyDescriptor(error2, "field")?.value;
-      if (typeof code === "string" && Object.hasOwn(messages, code) && ["source", "signal", "manifestUrl", "response", "body", "map", "theme", "view"].includes(
-        field
-      )) {
-        return new TileflowNativeSourceError(code, field);
+// src/manifest-schema.ts
+function createTileflowRuntimeManifestSchema(primitives, operations, identities = createPortableIdentitySchemas(operations)) {
+  const { tileflowPortableIdSchema, tileflowThemeNameSchema } = identities;
+  const safeTextSchema = operations.refine(
+    operations.refine(
+      operations.maxLength(operations.minLength(operations.string(), 1), 2048),
+      (value) => value === value.trim(),
+      "Expected text without surrounding whitespace"
+    ),
+    (value) => !/[\p{Cc}\\]/u.test(value),
+    "Expected safe text"
+  );
+  const publicResourceUrlSchema = operations.refine(
+    safeTextSchema,
+    isPublicResourceUrl,
+    "Expected an HTTP(S), root-relative, or path-relative public URL"
+  );
+  const apiOriginSchema = operations.refine(
+    safeTextSchema,
+    isApiOrigin,
+    "Expected an absolute HTTP(S) origin without path, credentials, query, or fragment"
+  );
+  const viewSchema2 = createTileflowRuntimeViewSchema(operations);
+  const fontFaceSchema = operations.object({
+    family: operations.maxLength(safeTextSchema, 100),
+    source: publicResourceUrlSchema,
+    style: operations.optional(operations.enum(["italic", "normal", "oblique"])),
+    weight: operations.optional(
+      operations.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
+    )
+  });
+  const fontFacesSchema = operations.superRefine(
+    operations.maxLength(operations.array(fontFaceSchema), 16),
+    validateUniqueFontFaces
+  );
+  const manifestThemeSchema = operations.object({
+    colorScheme: operations.enum(["dark", "light"]),
+    fontFaces: operations.optional(fontFacesSchema),
+    revision: operations.optional(operations.maxLength(safeTextSchema, 128)),
+    styleId: operations.optional(operations.maxLength(safeTextSchema, 128)),
+    styleUrl: publicResourceUrlSchema
+  });
+  const manifestMapSchema = operations.superRefine(
+    operations.object({
+      apiUrl: operations.optional(apiOriginSchema),
+      defaultTheme: tileflowThemeNameSchema,
+      environment: operations.optional(operations.maxLength(safeTextSchema, 128)),
+      mapId: operations.optional(operations.maxLength(safeTextSchema, 128)),
+      systemThemes: operations.optional(
+        operations.object({
+          dark: tileflowThemeNameSchema,
+          light: tileflowThemeNameSchema
+        })
+      ),
+      themes: operations.record(tileflowThemeNameSchema, manifestThemeSchema),
+      usageMode: operations.optional(operations.literal("session")),
+      view: operations.optional(viewSchema2),
+      worldGeneration: operations.optional(operations.literal("v1"))
+    }),
+    (entry, context) => {
+      const names = Object.keys(entry.themes);
+      if (names.length === 0) {
+        context.addIssue({
+          code: "custom",
+          message: "Expected at least one theme",
+          path: ["themes"]
+        });
+      }
+      if (names.length > tileflowThemeLimits.maxThemes) {
+        context.addIssue({
+          code: "too_big",
+          maximum: tileflowThemeLimits.maxThemes,
+          origin: "object",
+          path: ["themes"]
+        });
+      }
+      if (!Object.hasOwn(entry.themes, entry.defaultTheme)) {
+        context.addIssue({
+          code: "custom",
+          message: "defaultTheme must name a declared theme",
+          path: ["defaultTheme"]
+        });
+      }
+      if (entry.systemThemes) {
+        for (const colorScheme of ["light", "dark"]) {
+          const name = entry.systemThemes[colorScheme];
+          const theme = entry.themes[name];
+          if (!theme) {
+            context.addIssue({
+              code: "custom",
+              message: `systemThemes.${colorScheme} must name a declared theme`,
+              path: ["systemThemes", colorScheme]
+            });
+          } else if (theme.colorScheme !== colorScheme) {
+            context.addIssue({
+              code: "custom",
+              message: `systemThemes.${colorScheme} must reference a ${colorScheme} theme`,
+              path: ["systemThemes", colorScheme]
+            });
+          }
+        }
+      }
+      if (entry.usageMode === void 0 !== (entry.worldGeneration === void 0)) {
+        context.addIssue({
+          code: "custom",
+          message: "usageMode and worldGeneration must be declared together"
+        });
       }
     }
-  } catch {
-  }
-  return new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
-}
-
-// src/native-source-cancellation.ts
-var NativeSourceCancellation = class {
-  constructor() {
-    __publicField(this, "cancelled", false);
-    __publicField(this, "listeners", /* @__PURE__ */ new Set());
-  }
-  get aborted() {
-    return this.cancelled;
-  }
-  cancel() {
-    if (this.cancelled) return;
-    this.cancelled = true;
-    const listeners = [...this.listeners];
-    this.listeners.clear();
-    for (const listener of listeners) {
-      try {
-        listener();
-      } catch {
+  );
+  const canonicalManifestSchema = operations.superRefine(
+    operations.object({
+      apiUrl: operations.optional(apiOriginSchema),
+      maps: operations.record(tileflowPortableIdSchema, manifestMapSchema),
+      version: operations.literal(tileflowRuntimeManifestVersion)
+    }),
+    (manifest, context) => {
+      const mapCount = Object.keys(manifest.maps).length;
+      if (mapCount === 0) {
+        context.addIssue({ code: "custom", message: "Expected at least one map", path: ["maps"] });
+      }
+      if (mapCount > 1e3) {
+        context.addIssue({ code: "too_big", maximum: 1e3, origin: "object", path: ["maps"] });
+      }
+      if (primitives.utf8ByteLength(JSON.stringify(manifest)) > tileflowRuntimeManifestLimits.maximumBytes) {
+        context.addIssue({
+          code: "too_big",
+          maximum: tileflowRuntimeManifestLimits.maximumBytes,
+          origin: "string",
+          message: "Manifest JSON exceeds the 1 MiB limit"
+        });
+      }
+    }
+  );
+  const safeManifestInputSchema = operations.superRefine(operations.unknown(), (input, context) => {
+    const unsafe = findUnsafeManifestStructure(input);
+    if (unsafe) {
+      context.addIssue({
+        code: "custom",
+        message: unsafe.reason === "prototype" ? "Expected plain manifest objects" : "Expected no prototype-mutating keys",
+        path: unsafe.path
+      });
+    }
+  });
+  function validateUniqueFontFaces(fontFaces, context) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const [index, fontFace] of fontFaces.entries()) {
+      const identity = `${fontFace.family}\0${fontFace.style ?? "normal"}\0${fontFace.weight ?? "400"}`;
+      const first = seen.get(identity);
+      if (first !== void 0) {
+        context.addIssue({
+          code: "custom",
+          message: `Duplicate font face identity; first declared at index ${first}`,
+          path: [index]
+        });
+        continue;
       }
+      seen.set(identity, index);
     }
   }
-  check() {
-    if (this.cancelled) throw new TileflowNativeSourceError("NATIVE_SOURCE_ABORTED", "signal");
+  function isPublicResourceUrl(value) {
+    if (value.startsWith("//")) return false;
+    if (!value.startsWith("/") && !value.startsWith("./") && !value.startsWith("../") && !isAbsolutePublicUrl(value)) {
+      return false;
+    }
+    return isSafeResolvedPublicUrl(value);
   }
-  onCancel(listener) {
-    if (this.cancelled) {
-      listener();
-      return () => void 0;
+  function isAbsolutePublicUrl(value) {
+    try {
+      const url = primitives.parseUrl(value);
+      return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
+    } catch {
+      return false;
     }
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
   }
-  race(promise) {
-    return new Promise((resolve, reject) => {
-      const off = this.onCancel(
-        () => reject(new TileflowNativeSourceError("NATIVE_SOURCE_ABORTED", "signal"))
-      );
-      promise.then(
-        (value) => {
-          off();
-          resolve(value);
-        },
-        (error2) => {
-          off();
-          reject(error2);
-        }
-      );
-    });
+  function isSafeResolvedPublicUrl(value) {
+    try {
+      const url = primitives.parseUrl(value, "https://manifest.invalid/owner/manifest.json");
+      return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
+    } catch {
+      return false;
+    }
   }
-  link(signal) {
-    if (signal === void 0) return () => void 0;
-    let onAbort;
+  function hasEncodedPathSeparator(value) {
+    return /%(?:2f|5c)/iu.test(value);
+  }
+  function isApiOrigin(value) {
     try {
-      if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function" || typeof signal.removeEventListener !== "function")
-        throw new Error();
-      onAbort = () => this.cancel();
-      if (signal.aborted) {
-        this.cancel();
-        return () => void 0;
-      }
-      signal.addEventListener("abort", onAbort, { once: true });
-      if (signal.aborted) this.cancel();
+      const url = primitives.parseUrl(value);
+      return isAbsolutePublicUrl(value) && url.pathname === "/" && !url.search && value.replace(/\/$/u, "") === url.origin;
     } catch {
-      if (onAbort) {
-        try {
-          signal.removeEventListener("abort", onAbort);
-        } catch {
+      return false;
+    }
+  }
+  function findUnsafeManifestStructure(input) {
+    if (!input || typeof input !== "object") return void 0;
+    const pending = [
+      { path: [], value: input }
+    ];
+    const visited = /* @__PURE__ */ new WeakSet();
+    while (pending.length > 0) {
+      const current = pending.pop();
+      if (visited.has(current.value)) continue;
+      visited.add(current.value);
+      if (!Array.isArray(current.value)) {
+        const prototype = Object.getPrototypeOf(current.value);
+        if (prototype !== Object.prototype && prototype !== null) {
+          return { path: current.path, reason: "prototype" };
         }
       }
-      throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "signal");
-    }
-    return () => {
-      try {
-        signal.removeEventListener("abort", onAbort);
-      } catch {
+      for (const key of Object.keys(current.value)) {
+        const path = [...current.path, Array.isArray(current.value) ? Number(key) : key];
+        if (key === "__proto__") return { path, reason: "key" };
+        const descriptor = Object.getOwnPropertyDescriptor(current.value, key);
+        if (descriptor && "value" in descriptor && descriptor.value && typeof descriptor.value === "object") {
+          pending.push({ path, value: descriptor.value });
+        }
       }
-    };
-  }
-};
-function cancelNativeOperation(cancel) {
-  try {
-    void Promise.resolve(cancel()).catch(() => void 0);
-  } catch {
-  }
-}
-
-// src/native-source-utils.ts
-function nativeOwnRecord(value) {
-  try {
-    if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== null && prototype !== Object.prototype) return void 0;
-    const result = /* @__PURE__ */ Object.create(null);
-    for (const key of Object.keys(value)) {
-      const property = Object.getOwnPropertyDescriptor(value, key);
-      if (!property || !("value" in property)) return void 0;
-      result[key] = property.value;
     }
-    return result;
-  } catch {
     return void 0;
   }
+  return operations.pipe(safeManifestInputSchema, canonicalManifestSchema);
 }
-function freezeNativeSnapshot(value) {
-  if (value && typeof value === "object" && !Object.isFrozen(value)) {
-    for (const child of Object.values(value)) freezeNativeSnapshot(child);
-    Object.freeze(value);
+var init_manifest_schema = __esm({
+  "src/manifest-schema.ts"() {
+    "use strict";
+    init_manifest_types();
+    init_portable_identity_schema();
+    init_runtime_view_schema();
+    init_model();
   }
-  return value;
-}
-
-// src/native-manifest.ts
-var tileflowNativeManifestLimits = Object.freeze({
-  maximumBytes: tileflowRuntimeManifestLimits.maximumBytes,
-  maximumChunkBytes: 64 * 1024,
-  maximumDepth: 64
 });
-async function loadTileflowNativeManifest(manifestUrl, options) {
-  const input = nativeOwnRecord(options);
-  if (!input || typeof input.acquire !== "function")
-    throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "source");
-  const cancellation = new NativeSourceCancellation();
-  const detach = cancellation.link(input.signal);
-  try {
-    return await loadNativeManifest(
-      manifestUrl,
-      input.acquire,
-      {
-        developmentOrigin: input.developmentOrigin
-      },
-      cancellation
-    );
-  } finally {
-    detach();
+
+// src/native-url-policy.ts
+var tileflowNativeUrlLimits = Object.freeze({ maximumLength: 2048 });
+var errorMessages = {
+  NATIVE_URL_INVALID: "Expected a bounded HTTP(S) URL without credentials, fragments or backslashes.",
+  NATIVE_URL_ABSOLUTE_REQUIRED: "An explicit absolute HTTP(S) document URL is required.",
+  NATIVE_URL_HTTPS_REQUIRED: "HTTP is allowed only at the explicitly configured development origin.",
+  NATIVE_URL_DEVELOPMENT_ORIGIN_INVALID: "Expected one HTTP origin without a path, credentials, query or fragment.",
+  NATIVE_URL_TEMPLATE_INVALID: "Expected supported URL placeholders in the resource path or query only."
+};
+var TileflowNativeUrlError = class extends TypeError {
+  constructor(code, field) {
+    super(errorMessages[code]);
+    __publicField(this, "code");
+    __publicField(this, "field");
+    this.name = "TileflowNativeUrlError";
+    this.code = code;
+    this.field = field;
   }
-}
-async function loadNativeManifest(manifestUrl, acquire, network, cancellation) {
-  cancellation.check();
-  let requestUrl;
-  try {
-    requestUrl = resolveTileflowNativeManifestUrl(manifestUrl, network);
-  } catch {
-    throw new TileflowNativeSourceError("NATIVE_MANIFEST_URL_INVALID", "manifestUrl");
+};
+function createNativeUrlPolicy(parse2) {
+  const tilePlaceholders = /* @__PURE__ */ new Set(["z", "x", "y", "ratio", "quadkey", "bbox-epsg-3857", "prefix"]);
+  const glyphPlaceholders = /* @__PURE__ */ new Set(["fontstack", "range"]);
+  const absoluteHttpPattern = /^https?:\/\/[^/?#]+/iu;
+  const schemePattern = /^[a-z][a-z\d+.-]*:/iu;
+  function resolveTileflowNativeManifestUrl2(value, options = {}) {
+    assertOptionsObject(options, "developmentOrigin");
+    const developmentOrigin = resolveDevelopmentOrigin(options.developmentOrigin);
+    return resolveDocumentUrl(value, "manifestUrl", developmentOrigin).href;
   }
-  let operation;
-  try {
-    operation = acquire(
-      requestUrl,
-      Object.freeze({ maximumBytes: tileflowNativeManifestLimits.maximumBytes })
-    );
-    if (!operation || typeof operation.cancel !== "function" || !operation.response || typeof operation.response.then !== "function") {
-      throw new Error();
+  function resolveTileflowNativeResourceUrl2(value, options) {
+    assertOptionsObject(options, "documentUrl");
+    const developmentOrigin = resolveDevelopmentOrigin(options.developmentOrigin);
+    const document2 = resolveDocumentUrl(options.documentUrl, "documentUrl", developmentOrigin);
+    assertUrlText(value, "resourceUrl");
+    if (options.template !== void 0 && options.template !== "tile" && options.template !== "glyphs") {
+      throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", "resourceUrl");
     }
-  } catch {
-    if (operation) cancelNativeOperation(() => operation.cancel());
-    throw new TileflowNativeSourceError("NATIVE_MANIFEST_REQUEST_FAILED", "response");
-  }
-  let reader;
-  let readerCancelled = false;
-  let operationCancelled = false;
-  const cancelReader = () => {
-    if (!reader || readerCancelled) return;
-    readerCancelled = true;
-    cancelNativeOperation(() => reader.cancel());
-  };
-  const cleanup = () => {
-    if (!operationCancelled) {
-      operationCancelled = true;
-      cancelNativeOperation(() => operation.cancel());
+    assertReferenceSyntax(value, "resourceUrl", false);
+    const authority = absoluteHttpPattern.exec(value)?.[0];
+    if (authority && /[{}]/u.test(authority)) {
+      throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", "resourceUrl");
     }
-    cancelReader();
-  };
-  const unlisten = cancellation.onCancel(cleanup);
-  try {
-    const headers = Promise.resolve(operation.response).then(
-      (response2) => {
-        try {
-          if (!response2 || !response2.reader || typeof response2.reader.read !== "function" || typeof response2.reader.cancel !== "function") {
-            throw new Error();
-          }
-          reader = response2.reader;
-        } catch {
-          throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
-        }
-        if (cancellation.aborted) cancelReader();
-        cancellation.check();
-        return response2;
-      },
-      () => {
-        throw new TileflowNativeSourceError("NATIVE_MANIFEST_REQUEST_FAILED", "response");
-      }
-    );
-    const response = await cancellation.race(headers);
-    cancellation.check();
-    let finalUrl;
-    try {
-      finalUrl = resolveTileflowNativeManifestUrl(response.url, network);
-    } catch {
-      throw new TileflowNativeSourceError("NATIVE_MANIFEST_URL_INVALID", "manifestUrl");
+    let prefix = "__tileflow_native_template_";
+    let attempt = 0;
+    while (value.includes(prefix) || document2.href.includes(prefix)) {
+      prefix = `__tileflow_native_template_${attempt++}_`;
     }
-    if (!Number.isInteger(response.status) || response.status < 100 || response.status > 599) {
-      throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
+    const placeholders = [];
+    const allowed = options.template === "tile" ? tilePlaceholders : glyphPlaceholders;
+    const protectedValue = value.replace(/\{([^{}]*)\}/gu, (placeholder, name) => {
+      if (!options.template || !allowed.has(name)) {
+        throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", "resourceUrl");
+      }
+      placeholders.push(placeholder);
+      return `${prefix}${placeholders.length - 1}__`;
+    });
+    if (/[{}]/u.test(protectedValue)) {
+      throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", "resourceUrl");
     }
-    if (response.status === 401 || response.status === 403)
-      throw new TileflowNativeSourceError("NATIVE_MANIFEST_ACCESS_DENIED", "response");
-    if (response.status === 404)
-      throw new TileflowNativeSourceError("NATIVE_MANIFEST_NOT_FOUND", "response");
-    if (response.status < 200 || response.status >= 300)
-      throw new TileflowNativeSourceError("NATIVE_MANIFEST_REQUEST_FAILED", "response");
-    const buffer = new Uint8Array(tileflowNativeManifestLimits.maximumBytes);
-    let length = 0;
-    while (true) {
-      cancellation.check();
-      const allowance = Math.min(
-        tileflowNativeManifestLimits.maximumChunkBytes,
-        buffer.byteLength - length + 1
+    const resolved = parseUrl(protectedValue, "resourceUrl", document2.href);
+    assertTransport(resolved, "resourceUrl", developmentOrigin);
+    const resourcePath = resolved.href.slice(resolved.origin.length);
+    const suffix = resourcePath.replace(
+      new RegExp(`${prefix}(\\d+)__`, "gu"),
+      (match, index) => placeholders[Number(index)] ?? match
+    );
+    const result = resolved.origin + suffix;
+    assertUrlText(result, "resourceUrl");
+    return result;
+  }
+  function assertOptionsObject(value, field) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      throw new TileflowNativeUrlError(
+        field === "documentUrl" ? "NATIVE_URL_INVALID" : "NATIVE_URL_DEVELOPMENT_ORIGIN_INVALID",
+        field
       );
-      let next;
-      try {
-        const pending = Promise.resolve(reader.read(allowance)).catch(() => {
-          throw new TileflowNativeSourceError("NATIVE_MANIFEST_REQUEST_FAILED", "response");
-        });
-        next = await cancellation.race(pending);
-      } catch {
-        cancellation.check();
-        throw new TileflowNativeSourceError("NATIVE_MANIFEST_REQUEST_FAILED", "response");
-      }
-      cancellation.check();
-      if (!next || typeof next.done !== "boolean")
-        throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
-      if (next.done) {
-        if (next.value !== void 0)
-          throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
-        break;
-      }
-      if (!(next.value instanceof Uint8Array) || next.value.byteLength === 0)
-        throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
-      if (next.value.byteLength > buffer.byteLength - length)
-        throw new TileflowNativeSourceError("NATIVE_MANIFEST_TOO_LARGE", "body");
-      if (next.value.byteLength > allowance)
-        throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
-      buffer.set(next.value, length);
-      length += next.value.byteLength;
     }
-    let text;
+  }
+  function resolveDevelopmentOrigin(value) {
+    if (value === void 0) return void 0;
     try {
-      text = decodeNativeManifestUtf8(buffer.subarray(0, length));
+      assertUrlText(value, "developmentOrigin");
+      const match = /^(http:\/\/[^/?#]+)\/?$/iu.exec(value);
+      if (!match || /[{}@*]/u.test(value)) throw new Error();
+      const url = parseUrl(value, "developmentOrigin");
+      if (url.protocol !== "http:" || url.pathname !== "/" || url.search || url.hash || url.hostname.includes("*")) {
+        throw new Error();
+      }
+      return url.origin;
     } catch {
-      throw new TileflowNativeSourceError("NATIVE_MANIFEST_UTF8_INVALID", "body");
+      throw new TileflowNativeUrlError(
+        "NATIVE_URL_DEVELOPMENT_ORIGIN_INVALID",
+        "developmentOrigin"
+      );
     }
-    if (!hasBoundedNativeManifestDepth(text, tileflowNativeManifestLimits.maximumDepth)) {
-      throw new TileflowNativeSourceError("NATIVE_MANIFEST_INVALID", "body");
+  }
+  function resolveDocumentUrl(value, field, developmentOrigin) {
+    assertUrlText(value, field);
+    assertReferenceSyntax(value, field, true);
+    if (/[{}]/u.test(value)) throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", field);
+    const url = parseUrl(value, field);
+    assertTransport(url, field, developmentOrigin);
+    assertUrlText(url.href, field);
+    return url;
+  }
+  function assertUrlText(value, field) {
+    if (typeof value !== "string" || value.length === 0 || value.length > tileflowNativeUrlLimits.maximumLength || value !== value.trim() || /[\p{Cc}\\#]/u.test(value) || /%(?![\da-f]{2})/iu.test(value)) {
+      throw new TileflowNativeUrlError("NATIVE_URL_INVALID", field);
     }
-    let json;
-    try {
-      json = JSON.parse(text);
-    } catch {
-      throw new TileflowNativeSourceError("NATIVE_MANIFEST_JSON_INVALID", "body");
+  }
+  function assertReferenceSyntax(value, field, absolute) {
+    if (value.startsWith("//")) {
+      throw new TileflowNativeUrlError(
+        absolute ? "NATIVE_URL_ABSOLUTE_REQUIRED" : "NATIVE_URL_INVALID",
+        field
+      );
     }
-    let manifest;
-    try {
-      manifest = parseTileflowRuntimeManifest(json);
-    } catch {
-      throw new TileflowNativeSourceError("NATIVE_MANIFEST_INVALID", "body");
+    const authority = absoluteHttpPattern.exec(value)?.[0];
+    if (schemePattern.test(value) && !authority) {
+      throw new TileflowNativeUrlError("NATIVE_URL_INVALID", field);
     }
-    let resolvedBytes = nativeManifestUtf8ByteLength(JSON.stringify(manifest));
-    const resolveResource = (value, owner) => {
-      const resolved = resolveTileflowNativeResourceUrl(value, { documentUrl: owner, ...network });
-      resolvedBytes += nativeManifestUtf8ByteLength(JSON.stringify(resolved)) - nativeManifestUtf8ByteLength(JSON.stringify(value));
-      if (resolvedBytes > tileflowNativeManifestLimits.maximumBytes) {
-        throw new TileflowNativeSourceError("NATIVE_MANIFEST_TOO_LARGE", "body");
-      }
-      return resolved;
-    };
-    try {
-      for (const name of Object.keys(manifest.maps).sort()) {
-        const map2 = manifest.maps[name];
-        for (const themeName of Object.keys(map2.themes).sort()) {
-          const theme = map2.themes[themeName];
-          theme.styleUrl = resolveResource(theme.styleUrl, finalUrl);
-          for (const face of theme.fontFaces ?? []) {
-            face.source = resolveResource(face.source, theme.styleUrl);
-          }
-        }
-      }
-    } catch (error2) {
-      if (error2 instanceof TileflowNativeSourceError) throw normalizeNativeSourceError(error2);
-      throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESOURCE_INVALID", "body");
+    if (absolute && !authority) {
+      throw new TileflowNativeUrlError("NATIVE_URL_ABSOLUTE_REQUIRED", field);
     }
-    cancellation.check();
-    return freezeNativeSnapshot({ manifestUrl: finalUrl, manifest });
-  } catch (error2) {
-    cleanup();
-    cancellation.check();
-    throw normalizeNativeSourceError(error2);
-  } finally {
-    unlisten();
+    if (authority?.includes("@")) throw new TileflowNativeUrlError("NATIVE_URL_INVALID", field);
   }
-}
-
-// src/native-source-controller.ts
-init_portable_identity_rules();
-
-// src/runtime.ts
-init_portable_identity_rules();
-var defaultTileflowRuntimeView = Object.freeze({
-  bearing: 0,
-  center: [0, 20],
-  pitch: 0,
-  zoom: 2
-});
-var tileflowStyleFontFaceLimits = Object.freeze({
-  maximumCount: 16,
-  maximumSourceLength: 2048
-});
-var maxStaticImagePixels = 1280 * 1280;
-var maximumManifestBytes = 1024 * 1024;
-var maximumSessionGrantBytes = 64 * 1024;
-var manifestCache = new globalThis.Map();
-function validateTileflowThemeSelection(value) {
-  return value === "system" || isTileflowThemeName(value);
-}
-var tileflowThemeBlendLimits = Object.freeze({ maximumThemes: 8, minimumThemes: 2 });
-function validateTileflowThemeBlendSelection(value) {
-  if (!value || typeof value !== "object") return false;
-  const { position, themes } = value;
-  return Array.isArray(themes) && themes.length >= tileflowThemeBlendLimits.minimumThemes && themes.length <= tileflowThemeBlendLimits.maximumThemes && themes.every((theme) => isTileflowThemeName(theme)) && typeof position === "number" && Number.isFinite(position) && position >= 0 && position <= themes.length - 1;
-}
-function nearestTileflowBlendTheme(blend) {
-  const index = Math.min(blend.themes.length - 1, Math.max(0, Math.round(blend.position)));
-  return blend.themes[index];
-}
-function resolveTileflowRuntimeTheme(map2, selection, colorScheme) {
-  let name;
-  if (selection === void 0) {
-    name = map2.defaultTheme;
-  } else if (selection === "system") {
-    if (!map2.systemThemes) {
-      throw new Error(
-        `Tileflow map "${map2.name}" does not declare systemThemes; select a concrete theme.`
-      );
+  function parseUrl(value, field, base2) {
+    let url;
+    try {
+      url = parse2(value, base2);
+      if (!url.hostname || url.username || url.password || url.hash) throw new Error();
+    } catch {
+      throw new TileflowNativeUrlError("NATIVE_URL_INVALID", field);
     }
-    if (!colorScheme) {
-      throw new Error('Resolving theme="system" requires an explicit browser color scheme.');
+    if (/[{}]/u.test(url.hostname)) {
+      throw new TileflowNativeUrlError("NATIVE_URL_TEMPLATE_INVALID", field);
     }
-    name = map2.systemThemes[colorScheme];
-  } else {
-    name = selection;
-  }
-  if (!isTileflowThemeName(name)) {
-    throw new Error(
-      `Tileflow resolved invalid theme ${JSON.stringify(name)} for map "${map2.name}"; expected a concrete portable theme name.`
-    );
+    return url;
   }
-  const theme = Object.hasOwn(map2.themes, name) ? map2.themes[name] : void 0;
-  if (!theme) {
-    const available = Object.keys(map2.themes).sort().join(", ");
-    throw new Error(
-      `Unknown Tileflow theme "${name}" for map "${map2.name}". Available themes: ${available}.`
-    );
+  function assertTransport(url, field, developmentOrigin) {
+    if (url.protocol === "https:") return;
+    if (url.protocol === "http:" && url.origin === developmentOrigin) return;
+    throw new TileflowNativeUrlError("NATIVE_URL_HTTPS_REQUIRED", field);
   }
-  return { ...theme, name };
+  return { resolveTileflowNativeManifestUrl: resolveTileflowNativeManifestUrl2, resolveTileflowNativeResourceUrl: resolveTileflowNativeResourceUrl2 };
 }
-function resolveTileflowRuntimeView(options) {
-  const manifestView = options.manifestMap?.view;
+
+// src/native-url-provider.ts
+var import_url_state_machine = __toESM(require_url_state_machine(), 1);
+function parseNativeUrl(value, base2) {
+  const baseURL = base2 === void 0 ? void 0 : (0, import_url_state_machine.basicURLParse)(base2);
+  if (baseURL === null) throw new TypeError("Invalid native URL.");
+  const parsed = (0, import_url_state_machine.basicURLParse)(value, baseURL === void 0 ? void 0 : { baseURL });
+  if (parsed === null) throw new TypeError("Invalid native URL.");
   return {
-    ...options.fallback ?? defaultTileflowRuntimeView,
-    ...manifestView ?? {},
-    ...options.bearing !== void 0 ? { bearing: options.bearing } : {},
-    ...options.center !== void 0 ? { center: options.center } : {},
-    ...options.pitch !== void 0 ? { pitch: options.pitch } : {},
-    ...options.zoom !== void 0 ? { zoom: options.zoom } : {}
+    href: (0, import_url_state_machine.serializeURL)(parsed),
+    origin: (0, import_url_state_machine.serializeURLOrigin)(parsed),
+    protocol: `${parsed.scheme}:`,
+    hostname: parsed.host === null ? "" : (0, import_url_state_machine.serializeHost)(parsed.host),
+    pathname: (0, import_url_state_machine.serializePath)(parsed),
+    search: parsed.query ? `?${parsed.query}` : "",
+    hash: parsed.fragment ? `#${parsed.fragment}` : "",
+    username: parsed.username,
+    password: parsed.password
   };
 }
 
-// src/native-source-controller.ts
-function createTileflowNativeSourceController(options) {
-  const input = nativeOwnRecord(options);
-  if (!input || typeof input.acquire !== "function")
-    throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "source");
-  const acquire = input.acquire;
-  const listeners = /* @__PURE__ */ new Set();
-  let state;
-  let generation = 0;
-  let disposed = false;
-  let active;
-  const notify = (listener, value) => {
-    try {
-      void Promise.resolve(listener(value)).catch(() => void 0);
-    } catch {
-    }
-  };
-  const publish = (next) => {
-    if (disposed || next.generation !== generation) return;
-    state = freezeNativeSnapshot(next);
-    for (const listener of [...listeners]) {
-      if (disposed || state !== next || generation !== next.generation) break;
-      if (listeners.has(listener)) notify(listener, next);
-    }
-  };
-  return {
-    get state() {
-      return state;
-    },
-    subscribe(listener) {
-      if (typeof listener !== "function")
-        throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "source");
-      if (disposed) return () => void 0;
-      listeners.add(listener);
-      if (state) notify(listener, state);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    async replace(source, options2 = {}) {
-      if (disposed) throw new TileflowNativeSourceError("NATIVE_SOURCE_DISPOSED", "source");
-      if (generation >= Number.MAX_SAFE_INTEGER)
-        throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "source");
-      const own = { generation: ++generation, cancellation: new NativeSourceCancellation() };
-      const previous = active;
-      active = own;
-      const current = () => !disposed && generation === own.generation;
-      let sourceInput;
-      let selection;
-      let snapshotError;
-      try {
-        sourceInput = nativeOwnRecord(source);
-        selection = nativeOwnRecord(options2);
-      } catch (error2) {
-        snapshotError = normalizeNativeSourceError(error2);
-      }
-      previous?.cancellation.cancel();
-      let detach = () => void 0;
-      try {
-        if (!current()) return;
-        publish({ status: "loading", generation: own.generation });
-        if (!current()) return;
-        if (snapshotError) throw snapshotError;
-        if (!sourceInput || !selection || Object.hasOwn(sourceInput, "kind") || Object.hasOwn(sourceInput, "style") || !isTileflowPortableId(sourceInput.map))
-          throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "source");
-        if (selection.theme !== void 0 && !validateTileflowThemeSelection(selection.theme) || selection.colorScheme !== void 0 && selection.colorScheme !== "light" && selection.colorScheme !== "dark") {
-          throw new TileflowNativeSourceError("NATIVE_THEME_INVALID", "theme");
-        }
-        const selectedSource = {
-          map: sourceInput.map,
-          manifestUrl: sourceInput.manifestUrl
-        };
-        if (sourceInput.developmentOrigin !== void 0) {
-          try {
-            const developmentOrigin = sourceInput.developmentOrigin;
-            selectedSource.developmentOrigin = resolveTileflowNativeManifestUrl(developmentOrigin, {
-              developmentOrigin
-            }).slice(0, -1);
-          } catch {
-            throw new TileflowNativeSourceError("NATIVE_MANIFEST_URL_INVALID", "manifestUrl");
-          }
-        }
-        detach = own.cancellation.link(selection.signal);
-        const result = await loadNativeManifest(
-          selectedSource.manifestUrl,
-          acquire,
-          {
-            developmentOrigin: selectedSource.developmentOrigin
-          },
-          own.cancellation
-        );
-        if (!current()) return;
-        if (!Object.hasOwn(result.manifest.maps, selectedSource.map)) {
-          throw new TileflowNativeSourceError("NATIVE_MAP_NOT_FOUND", "map");
-        }
-        const entry = result.manifest.maps[selectedSource.map];
-        const apiUrl = entry.apiUrl ?? result.manifest.apiUrl;
-        const map2 = {
-          ...entry,
-          name: selectedSource.map,
-          ...apiUrl === void 0 ? {} : { apiUrl }
-        };
-        let theme;
-        try {
-          theme = resolveTileflowRuntimeTheme(
-            map2,
-            selection.theme,
-            selection.colorScheme
-          );
-        } catch {
-          throw new TileflowNativeSourceError("NATIVE_THEME_INVALID", "theme");
-        }
-        publish({
-          status: "ready",
-          generation: own.generation,
-          source: selectedSource,
-          ...result,
-          map: map2,
-          theme
-        });
-      } catch (error2) {
-        if (current())
-          publish({
-            status: "error",
-            generation: own.generation,
-            error: normalizeNativeSourceError(error2)
-          });
-      } finally {
-        detach();
-        if (active === own) active = void 0;
-      }
-    },
-    dispose() {
-      if (disposed) return;
-      disposed = true;
-      listeners.clear();
-      const previous = active;
-      active = void 0;
-      previous?.cancellation.cancel();
-    }
-  };
+// src/native-urls.ts
+var policy = createNativeUrlPolicy(parseNativeUrl);
+function resolveTileflowNativeManifestUrl(value, options = {}) {
+  return policy.resolveTileflowNativeManifestUrl(value, options);
+}
+function resolveTileflowNativeResourceUrl(value, options) {
+  return policy.resolveTileflowNativeResourceUrl(value, options);
 }
 
-// src/native-initial-view.ts
-init_runtime_view_schema();
-var viewSchema = createTileflowRuntimeViewSchema(miniManifestSchemaOperations);
-var viewKeys = ["bearing", "center", "pitch", "zoom"];
-var inputKeys = ["view", "mapOptionsView", "manifestView"];
-var invalid = () => {
-  throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "view");
-};
-function resolveTileflowNativeInitialView(options = {}) {
-  try {
-    const input = snapshotRecord(options, inputKeys);
-    const manifestView = snapshotView(input.manifestView);
-    const mapOptionsView = snapshotView(input.mapOptionsView);
-    const view = snapshotView(input.view);
-    const resolved = resolveTileflowRuntimeView({
-      ...view,
-      fallback: { ...defaultTileflowRuntimeView, ...manifestView, ...mapOptionsView }
-    });
-    return freezeNativeSnapshot({
-      center: [resolved.center[0], resolved.center[1]],
-      zoom: resolved.zoom,
-      bearing: resolved.bearing,
-      pitch: resolved.pitch
+// src/native-manifest.ts
+init_manifest_types();
+
+// ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/mini/parse.js
+init_core2();
+
+// ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/mini/schemas.js
+init_core2();
+init_util();
+var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+  if (!inst._zod)
+    throw new Error("Uninitialized schema in ZodMiniType.");
+  $ZodType.init(inst, def);
+  inst.def = def;
+  inst.type = def.type;
+  inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
+  inst.safeParse = (data, params) => safeParse(inst, data, params);
+  inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+  inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+  inst.check = (...checks) => {
+    return inst.clone({
+      ...def,
+      checks: [
+        ...def.checks ?? [],
+        ...checks.map((ch) => typeof ch === "function" ? {
+          _zod: { check: ch, def: { check: "custom" }, onattach: [] }
+        } : ch)
+      ]
+    }, { parent: true });
+  };
+  inst.with = inst.check;
+  inst.clone = (_def, params) => clone(inst, _def, params);
+  inst.brand = () => inst;
+  inst.register = ((reg, meta2) => {
+    reg.add(inst, meta2);
+    return inst;
+  });
+  inst.apply = (fn) => fn(inst);
+});
+var ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
+  $ZodString.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function string2(params) {
+  return _string(ZodMiniString, params);
+}
+var ZodMiniNumber = /* @__PURE__ */ $constructor("ZodMiniNumber", (inst, def) => {
+  $ZodNumber.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function number2(params) {
+  return _number(ZodMiniNumber, params);
+}
+var ZodMiniUnknown = /* @__PURE__ */ $constructor("ZodMiniUnknown", (inst, def) => {
+  $ZodUnknown.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function unknown() {
+  return _unknown(ZodMiniUnknown);
+}
+var ZodMiniNever = /* @__PURE__ */ $constructor("ZodMiniNever", (inst, def) => {
+  $ZodNever.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function never(params) {
+  return _never(ZodMiniNever, params);
+}
+var ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
+  $ZodArray.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function array(element, params) {
+  return new ZodMiniArray({
+    type: "array",
+    element,
+    ...normalizeParams(params)
+  });
+}
+var ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
+  $ZodObject.init(inst, def);
+  ZodMiniType.init(inst, def);
+  defineLazy(inst, "shape", () => def.shape);
+});
+// @__NO_SIDE_EFFECTS__
+function strictObject(shape, params) {
+  return new ZodMiniObject({
+    type: "object",
+    shape,
+    catchall: /* @__PURE__ */ never(),
+    ...normalizeParams(params)
+  });
+}
+var ZodMiniTuple = /* @__PURE__ */ $constructor("ZodMiniTuple", (inst, def) => {
+  $ZodTuple.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function tuple(items, _paramsOrRest, _params) {
+  const hasRest = _paramsOrRest instanceof $ZodType;
+  const params = hasRest ? _params : _paramsOrRest;
+  const rest = hasRest ? _paramsOrRest : null;
+  return new ZodMiniTuple({
+    type: "tuple",
+    items,
+    rest,
+    ...normalizeParams(params)
+  });
+}
+var ZodMiniRecord = /* @__PURE__ */ $constructor("ZodMiniRecord", (inst, def) => {
+  $ZodRecord.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function record(keyType, valueType, params) {
+  if (!valueType || !valueType._zod) {
+    return new ZodMiniRecord({
+      type: "record",
+      keyType: /* @__PURE__ */ string2(),
+      valueType: keyType,
+      ...normalizeParams(valueType)
     });
-  } catch {
-    return invalid();
   }
+  return new ZodMiniRecord({
+    type: "record",
+    keyType,
+    valueType,
+    ...normalizeParams(params)
+  });
+}
+var ZodMiniEnum = /* @__PURE__ */ $constructor("ZodMiniEnum", (inst, def) => {
+  $ZodEnum.init(inst, def);
+  ZodMiniType.init(inst, def);
+  inst.options = Object.values(def.entries);
+});
+// @__NO_SIDE_EFFECTS__
+function _enum(values, params) {
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  return new ZodMiniEnum({
+    type: "enum",
+    entries,
+    ...normalizeParams(params)
+  });
+}
+var ZodMiniLiteral = /* @__PURE__ */ $constructor("ZodMiniLiteral", (inst, def) => {
+  $ZodLiteral.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function literal(value, params) {
+  return new ZodMiniLiteral({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...normalizeParams(params)
+  });
+}
+var ZodMiniOptional = /* @__PURE__ */ $constructor("ZodMiniOptional", (inst, def) => {
+  $ZodOptional.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function optional(innerType) {
+  return new ZodMiniOptional({
+    type: "optional",
+    innerType
+  });
+}
+var ZodMiniPipe = /* @__PURE__ */ $constructor("ZodMiniPipe", (inst, def) => {
+  $ZodPipe.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function pipe(in_, out) {
+  return new ZodMiniPipe({
+    type: "pipe",
+    in: in_,
+    out
+  });
+}
+var ZodMiniCustom = /* @__PURE__ */ $constructor("ZodMiniCustom", (inst, def) => {
+  $ZodCustom.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function refine(fn, _params = {}) {
+  return _refine(ZodMiniCustom, fn, _params);
+}
+// @__NO_SIDE_EFFECTS__
+function superRefine(fn, params) {
+  return _superRefine(fn, params);
+}
+
+// ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/mini/checks.js
+init_core2();
+
+// src/native-manifest-schema.ts
+init_manifest_schema();
+
+// src/manifest-schema-mini.ts
+function mini(schema2) {
+  return schema2;
+}
+var miniManifestSchemaOperations = {
+  string: () => string2(),
+  minLength: (schema2, minimum) => mini(schema2).check(_minLength(minimum)),
+  maxLength: (schema2, maximum) => mini(schema2).check(_maxLength(maximum)),
+  regex: (schema2, pattern, message) => mini(schema2).check(_regex(pattern, { message })),
+  refine: (schema2, check, message) => mini(schema2).check(refine(check, message)),
+  // Zod 4's number parser rejects NaN and infinities; Classic finite() is a no-op.
+  number: (minimum, maximum) => number2().check(_gte(minimum), _lte(maximum)),
+  unknown: () => unknown(),
+  optional: (schema2) => optional(schema2),
+  array: (schema2) => array(schema2),
+  enum(values) {
+    return _enum(values);
+  },
+  literal: (value) => literal(value),
+  tuplePair(left, right) {
+    return tuple([left, right]);
+  },
+  // ZodMiniObject uses the interpreted $ZodObject, not the Classic object JIT constructor.
+  object(shape) {
+    return strictObject(shape);
+  },
+  record(key, value) {
+    return record(key, value);
+  },
+  superRefine: (schema2, check) => mini(schema2).check(superRefine(check)),
+  pipe: (input, output) => pipe(input, output)
+};
+
+// src/native-manifest-utf8.ts
+init_native_url_utf8();
+function nativeManifestUtf8ByteLength(input) {
+  let bytes = 0;
+  for (let index = 0; index < input.length; index++) {
+    const value = input.charCodeAt(index);
+    if (value <= 127) bytes++;
+    else if (value <= 2047) bytes += 2;
+    else if (value >= 55296 && value <= 56319 && input.charCodeAt(index + 1) >= 56320 && input.charCodeAt(index + 1) <= 57343) {
+      bytes += 4;
+      index++;
+    } else bytes += 3;
+  }
+  return bytes;
 }
-function snapshotRecord(input, keys) {
-  const snapshot = nativeOwnRecord(input);
-  if (!snapshot) return invalid();
-  const ownKeys = Reflect.ownKeys(input);
-  if (ownKeys.length !== Object.keys(snapshot).length || ownKeys.some((key) => typeof key !== "string" || !keys.includes(key)))
-    return invalid();
-  return snapshot;
+function decodeNativeManifestUtf8(input) {
+  let remaining = 0;
+  let lower = 128;
+  let upper = 191;
+  for (const byte of input) {
+    if (remaining === 0) {
+      if (byte <= 127) continue;
+      if (byte >= 194 && byte <= 223) remaining = 1;
+      else if (byte >= 224 && byte <= 239) {
+        remaining = 2;
+        if (byte === 224) lower = 160;
+        if (byte === 237) upper = 159;
+      } else if (byte >= 240 && byte <= 244) {
+        remaining = 3;
+        if (byte === 240) lower = 144;
+        if (byte === 244) upper = 143;
+      } else throw new TypeError("Invalid manifest UTF-8.");
+    } else {
+      if (byte < lower || byte > upper) throw new TypeError("Invalid manifest UTF-8.");
+      remaining--;
+      lower = 128;
+      upper = 191;
+    }
+  }
+  if (remaining) throw new TypeError("Invalid manifest UTF-8.");
+  const parts = [];
+  let offset = 0;
+  while (offset < input.byteLength) {
+    let end = Math.min(offset + nativeUrlCodecMaximumLength, input.byteLength);
+    while (end < input.byteLength && (input[end] & 192) === 128) end--;
+    parts.push(utf8DecodeWithoutBOM(input.subarray(offset, end)));
+    offset = end;
+  }
+  const text = parts.join("");
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
 }
-function snapshotView(input) {
-  if (input === void 0) return {};
-  const snapshot = snapshotRecord(input, viewKeys);
-  if (snapshot.center !== void 0) {
-    const center = snapshot.center;
-    if (!Array.isArray(center) || Object.getPrototypeOf(center) !== Array.prototype || Reflect.ownKeys(center).length !== 3 || Object.getOwnPropertyDescriptor(center, "length")?.value !== 2)
-      return invalid();
-    const longitude = Object.getOwnPropertyDescriptor(center, "0");
-    const latitude = Object.getOwnPropertyDescriptor(center, "1");
-    if (!longitude?.enumerable || !latitude?.enumerable || !("value" in longitude) || !("value" in latitude))
-      return invalid();
-    snapshot.center = [longitude.value, latitude.value];
+function hasBoundedNativeManifestDepth(text, maximumDepth) {
+  let depth = 0;
+  let quoted = false;
+  let escaped = false;
+  for (let index = 0; index < text.length; index++) {
+    const character = text[index];
+    if (quoted) {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') quoted = false;
+    } else if (character === '"') quoted = true;
+    else if (character === "[" || character === "{") {
+      if (++depth > maximumDepth) return false;
+    } else if (character === "]" || character === "}") depth--;
   }
-  const parsed = parse(viewSchema, snapshot);
-  return {
-    ...parsed.bearing === void 0 ? {} : { bearing: parsed.bearing },
-    ...parsed.center === void 0 ? {} : { center: parsed.center },
-    ...parsed.pitch === void 0 ? {} : { pitch: parsed.pitch },
-    ...parsed.zoom === void 0 ? {} : { zoom: parsed.zoom }
-  };
+  return true;
 }
 
-// src/theme-blend.ts
-var TileflowThemeBlendError = class extends Error {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "name", "TileflowThemeBlendError");
-  }
+// src/native-manifest-schema.ts
+var schema = createTileflowRuntimeManifestSchema(
+  {
+    parseUrl: parseNativeUrl,
+    utf8ByteLength: nativeManifestUtf8ByteLength
+  },
+  miniManifestSchemaOperations
+);
+function parseTileflowRuntimeManifest(input) {
+  return parse(schema, input);
+}
+
+// src/native-source-types.ts
+var messages = {
+  NATIVE_SOURCE_INVALID: "Expected a valid native source or renderer-neutral view.",
+  NATIVE_SOURCE_ABORTED: "The source operation was cancelled.",
+  NATIVE_SOURCE_DISPOSED: "The source controller has been disposed.",
+  NATIVE_MANIFEST_URL_INVALID: "Expected a safe absolute manifest URL and an exact development origin.",
+  NATIVE_MANIFEST_REQUEST_FAILED: "Manifest acquisition failed.",
+  NATIVE_MANIFEST_RESPONSE_INVALID: "Expected a bounded byte reader and an explicit final response URL.",
+  NATIVE_MANIFEST_ACCESS_DENIED: "Manifest access was denied.",
+  NATIVE_MANIFEST_NOT_FOUND: "The manifest was not found.",
+  NATIVE_MANIFEST_TOO_LARGE: "The manifest exceeds the 1 MiB limit.",
+  NATIVE_MANIFEST_UTF8_INVALID: "The manifest body is not valid UTF-8.",
+  NATIVE_MANIFEST_JSON_INVALID: "The manifest body is not valid JSON.",
+  NATIVE_MANIFEST_INVALID: "The manifest does not satisfy the version-1 runtime contract.",
+  NATIVE_MANIFEST_RESOURCE_INVALID: "A manifest resource URL is outside the native URL policy.",
+  NATIVE_MAP_NOT_FOUND: "The requested map is not declared by the manifest.",
+  NATIVE_THEME_INVALID: "Expected a declared concrete theme or an explicitly supplied system color scheme."
 };
-var BlendLeaf = class {
-  constructor(values) {
-    __publicField(this, "values", values);
+var TileflowNativeSourceError = class extends Error {
+  constructor(code, field) {
+    super(messages[code]);
+    __publicField(this, "code");
+    __publicField(this, "field");
+    __publicField(this, "kind");
+    this.name = "TileflowNativeSourceError";
+    this.code = code;
+    this.field = field;
+    this.kind = code === "NATIVE_SOURCE_ABORTED" || code === "NATIVE_SOURCE_DISPOSED" ? "cancelled" : "terminal";
   }
 };
-var imageProperties = /* @__PURE__ */ new Set([
-  "icon-image",
-  "fill-pattern",
-  "line-pattern",
-  "background-pattern",
-  "fill-extrusion-pattern"
-]);
-var opacityProperties = {
-  background: "background-opacity",
-  circle: "circle-opacity",
-  fill: "fill-opacity",
-  "fill-extrusion": "fill-extrusion-opacity",
-  heatmap: "heatmap-opacity",
-  line: "line-opacity",
-  raster: "raster-opacity"
-};
-var featureOperators = /* @__PURE__ */ new Set([
-  "feature-state",
-  "geometry-type",
-  "get",
-  "has",
-  "id",
-  "in",
-  "properties"
-]);
-var maximumBranches = 24;
-function planTileflowThemeBlend(styles, options = {}) {
-  if (styles.length < 2)
-    throw new TileflowThemeBlendError("A theme blend needs two or more themes.");
-  const [base2] = styles;
-  assertSameStructure(styles, base2);
-  const mixedImages = new Set(imageProperties);
-  if (options.iconImages === "switch") mixedImages.delete("icon-image");
-  const paints = [];
-  const switches = [];
-  const imageGroups = collectImageNames(styles, base2, 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 base2.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(base2.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 = {
-        ...base2,
-        ...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 normalizeNativeSourceError(error2) {
+  try {
+    if (error2 instanceof TileflowNativeSourceError) {
+      const code = Object.getOwnPropertyDescriptor(error2, "code")?.value;
+      const field = Object.getOwnPropertyDescriptor(error2, "field")?.value;
+      if (typeof code === "string" && Object.hasOwn(messages, code) && ["source", "signal", "manifestUrl", "response", "body", "map", "theme", "view"].includes(
+        field
+      )) {
+        return new TileflowNativeSourceError(code, field);
+      }
     }
-  };
-  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) => same(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;
+  } catch {
+  }
+  return new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
+}
+
+// src/native-source-cancellation.ts
+var NativeSourceCancellation = class {
+  constructor() {
+    __publicField(this, "cancelled", false);
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+  }
+  get aborted() {
+    return this.cancelled;
+  }
+  cancel() {
+    if (this.cancelled) return;
+    this.cancelled = true;
+    const listeners = [...this.listeners];
+    this.listeners.clear();
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch {
       }
     }
-    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 });
+  }
+  check() {
+    if (this.cancelled) throw new TileflowNativeSourceError("NATIVE_SOURCE_ABORTED", "signal");
+  }
+  onCancel(listener) {
+    if (this.cancelled) {
+      listener();
+      return () => void 0;
     }
-    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;
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  race(promise) {
+    return new Promise((resolve, reject) => {
+      const off = this.onCancel(
+        () => reject(new TileflowNativeSourceError("NATIVE_SOURCE_ABORTED", "signal"))
+      );
+      promise.then(
+        (value) => {
+          off();
+          resolve(value);
+        },
+        (error2) => {
+          off();
+          reject(error2);
         }
-        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 branches = splitBranches(
-        Object.fromEntries(
-          driven.map((property) => [
-            property,
-            variants.map((variant) => paintOf(variant)[property])
-          ])
-        )
       );
-      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, values] of Object.entries(branch.valuesByProperty)) {
-            const template = tryMixTemplate(values);
-            if (template === void 0) return void 0;
-            templates[property] = template;
-          }
-          group = { templates, conditions: [] };
-          groups.set(key, group);
+    });
+  }
+  link(signal) {
+    if (signal === void 0) return () => void 0;
+    let onAbort;
+    try {
+      if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function" || typeof signal.removeEventListener !== "function")
+        throw new Error();
+      onAbort = () => this.cancel();
+      if (signal.aborted) {
+        this.cancel();
+        return () => void 0;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted) this.cancel();
+    } catch {
+      if (onAbort) {
+        try {
+          signal.removeEventListener("abort", onAbort);
+        } catch {
         }
-        group.conditions.push(
-          branch.conditions.length === 1 ? branch.conditions[0] : ["all", ...branch.conditions]
-        );
       }
-      splitLayers += groups.size;
-      return [...groups.values()].map((group, number3) => {
-        const chosen = group.conditions.length === 1 ? group.conditions[0] : ["any", ...group.conditions];
-        return {
-          layer: {
-            ...planned,
-            id: `${id}::branch-${number3}`,
-            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 fillTileflowThemeBlendTemplate(template, position) {
-  return fillTemplate(template, position);
-}
-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;
+      throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "signal");
     }
-    if (Object.keys(out).length > 0) filled[group] = out;
-    else delete filled[group];
+    return () => {
+      try {
+        signal.removeEventListener("abort", onAbort);
+      } catch {
+      }
+    };
   }
-  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)])
-    );
+};
+function cancelNativeOperation(cancel) {
+  try {
+    void Promise.resolve(cancel()).catch(() => void 0);
+  } catch {
   }
-  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, base2) {
-  const ids = (style) => style.layers.map((layer) => layer.id);
-  for (const style of styles) {
-    if (!same(ids(style), ids(base2)))
-      throw new TileflowThemeBlendError(
-        "Blended themes must have the same layers in the same order."
-      );
-    if (!same(style.sources, base2.sources))
-      throw new TileflowThemeBlendError("Blended themes must use the same sources.");
-    if (!same(style.sprite, base2.sprite) || !same(style.glyphs, base2.glyphs))
-      throw new TileflowThemeBlendError("Blended themes must use the same sprite and glyphs.");
-    for (const [index, layer] of style.layers.entries()) {
-      const other = base2.layers[index];
-      for (const key of ["type", "source", "source-layer", "filter", "minzoom", "maxzoom"])
-        if (!same(layer[key], other[key]))
-          throw new TileflowThemeBlendError(
-            `Blended themes differ in ${key} of layer ${JSON.stringify(layer.id)}.`
-          );
+
+// src/native-source-utils.ts
+function nativeOwnRecord(value) {
+  try {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== null && prototype !== Object.prototype) return void 0;
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value)) {
+      const property = Object.getOwnPropertyDescriptor(value, key);
+      if (!property || !("value" in property)) return void 0;
+      result[key] = property.value;
     }
+    return result;
+  } catch {
+    return void 0;
   }
 }
-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) => same(value, values[0]))) return void 0;
-  return tryMixTemplate(values);
+function freezeNativeSnapshot(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) freezeNativeSnapshot(child);
+    Object.freeze(value);
+  }
+  return value;
 }
-function collectImageNames(styles, base2, properties) {
-  const uses = /* @__PURE__ */ new Map();
-  for (const [index] of base2.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);
-        }
-      }
-    }
+
+// src/native-manifest.ts
+var tileflowNativeManifestLimits = Object.freeze({
+  maximumBytes: tileflowRuntimeManifestLimits.maximumBytes,
+  maximumChunkBytes: 64 * 1024,
+  maximumDepth: 64
+});
+async function loadTileflowNativeManifest(manifestUrl, options) {
+  const input = nativeOwnRecord(options);
+  if (!input || typeof input.acquire !== "function")
+    throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "source");
+  const cancellation = new NativeSourceCancellation();
+  const detach = cancellation.link(input.signal);
+  try {
+    return await loadNativeManifest(
+      manifestUrl,
+      input.acquire,
+      {
+        developmentOrigin: input.developmentOrigin
+      },
+      cancellation
+    );
+  } finally {
+    detach();
   }
-  return uses;
 }
-function alignInteractionManifest(metadata, layers) {
-  if (!isRecord(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 }]);
+async function loadNativeManifest(manifestUrl, acquire, network, cancellation) {
+  cancellation.check();
+  let requestUrl;
+  try {
+    requestUrl = resolveTileflowNativeManifestUrl(manifestUrl, network);
+  } catch {
+    throw new TileflowNativeSourceError("NATIVE_MANIFEST_URL_INVALID", "manifestUrl");
   }
-  let aligned;
-  const interactions = metadata["tileflow:interaction-manifest"];
-  const domains = isRecord(interactions) ? interactions.domains : void 0;
-  if (isRecord(interactions) && isRecord(domains) && isRecord(domains.poi)) {
-    const poi = domains.poi;
-    if (Array.isArray(poi.layers)) {
-      const poiLayers = poi.layers.flatMap((entry) => {
-        if (!isRecord(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 } }
-        }
-      };
+  let operation;
+  try {
+    operation = acquire(
+      requestUrl,
+      Object.freeze({ maximumBytes: tileflowNativeManifestLimits.maximumBytes })
+    );
+    if (!operation || typeof operation.cancel !== "function" || !operation.response || typeof operation.response.then !== "function") {
+      throw new Error();
     }
+  } catch {
+    if (operation) cancelNativeOperation(() => operation.cancel());
+    throw new TileflowNativeSourceError("NATIVE_MANIFEST_REQUEST_FAILED", "response");
   }
-  const overlays = metadata["tileflow:overlay-placement-manifest"];
-  if (isRecord(overlays) && isRecord(overlays.anchors)) {
-    const anchors = Object.fromEntries(
-      Object.entries(overlays.anchors).map(([placement, anchor]) => [
-        placement,
-        typeof anchor === "string" ? planned.get(anchor)?.[0]?.id ?? anchor : anchor
-      ])
+  let reader;
+  let readerCancelled = false;
+  let operationCancelled = false;
+  const cancelReader = () => {
+    if (!reader || readerCancelled) return;
+    readerCancelled = true;
+    cancelNativeOperation(() => reader.cancel());
+  };
+  const cleanup = () => {
+    if (!operationCancelled) {
+      operationCancelled = true;
+      cancelNativeOperation(() => operation.cancel());
+    }
+    cancelReader();
+  };
+  const unlisten = cancellation.onCancel(cleanup);
+  try {
+    const headers = Promise.resolve(operation.response).then(
+      (response2) => {
+        try {
+          if (!response2 || !response2.reader || typeof response2.reader.read !== "function" || typeof response2.reader.cancel !== "function") {
+            throw new Error();
+          }
+          reader = response2.reader;
+        } catch {
+          throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
+        }
+        if (cancellation.aborted) cancelReader();
+        cancellation.check();
+        return response2;
+      },
+      () => {
+        throw new TileflowNativeSourceError("NATIVE_MANIFEST_REQUEST_FAILED", "response");
+      }
     );
-    aligned = {
-      ...aligned ?? metadata,
-      "tileflow:overlay-placement-manifest": { ...overlays, anchors }
+    const response = await cancellation.race(headers);
+    cancellation.check();
+    let finalUrl;
+    try {
+      finalUrl = resolveTileflowNativeManifestUrl(response.url, network);
+    } catch {
+      throw new TileflowNativeSourceError("NATIVE_MANIFEST_URL_INVALID", "manifestUrl");
+    }
+    if (!Number.isInteger(response.status) || response.status < 100 || response.status > 599) {
+      throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
+    }
+    if (response.status === 401 || response.status === 403)
+      throw new TileflowNativeSourceError("NATIVE_MANIFEST_ACCESS_DENIED", "response");
+    if (response.status === 404)
+      throw new TileflowNativeSourceError("NATIVE_MANIFEST_NOT_FOUND", "response");
+    if (response.status < 200 || response.status >= 300)
+      throw new TileflowNativeSourceError("NATIVE_MANIFEST_REQUEST_FAILED", "response");
+    const buffer = new Uint8Array(tileflowNativeManifestLimits.maximumBytes);
+    let length = 0;
+    while (true) {
+      cancellation.check();
+      const allowance = Math.min(
+        tileflowNativeManifestLimits.maximumChunkBytes,
+        buffer.byteLength - length + 1
+      );
+      let next;
+      try {
+        const pending = Promise.resolve(reader.read(allowance)).catch(() => {
+          throw new TileflowNativeSourceError("NATIVE_MANIFEST_REQUEST_FAILED", "response");
+        });
+        next = await cancellation.race(pending);
+      } catch {
+        cancellation.check();
+        throw new TileflowNativeSourceError("NATIVE_MANIFEST_REQUEST_FAILED", "response");
+      }
+      cancellation.check();
+      if (!next || typeof next.done !== "boolean")
+        throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
+      if (next.done) {
+        if (next.value !== void 0)
+          throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
+        break;
+      }
+      if (!(next.value instanceof Uint8Array) || next.value.byteLength === 0)
+        throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
+      if (next.value.byteLength > buffer.byteLength - length)
+        throw new TileflowNativeSourceError("NATIVE_MANIFEST_TOO_LARGE", "body");
+      if (next.value.byteLength > allowance)
+        throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESPONSE_INVALID", "response");
+      buffer.set(next.value, length);
+      length += next.value.byteLength;
+    }
+    let text;
+    try {
+      text = decodeNativeManifestUtf8(buffer.subarray(0, length));
+    } catch {
+      throw new TileflowNativeSourceError("NATIVE_MANIFEST_UTF8_INVALID", "body");
+    }
+    if (!hasBoundedNativeManifestDepth(text, tileflowNativeManifestLimits.maximumDepth)) {
+      throw new TileflowNativeSourceError("NATIVE_MANIFEST_INVALID", "body");
+    }
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      throw new TileflowNativeSourceError("NATIVE_MANIFEST_JSON_INVALID", "body");
+    }
+    let manifest;
+    try {
+      manifest = parseTileflowRuntimeManifest(json);
+    } catch {
+      throw new TileflowNativeSourceError("NATIVE_MANIFEST_INVALID", "body");
+    }
+    let resolvedBytes = nativeManifestUtf8ByteLength(JSON.stringify(manifest));
+    const resolveResource = (value, owner) => {
+      const resolved = resolveTileflowNativeResourceUrl(value, { documentUrl: owner, ...network });
+      resolvedBytes += nativeManifestUtf8ByteLength(JSON.stringify(resolved)) - nativeManifestUtf8ByteLength(JSON.stringify(value));
+      if (resolvedBytes > tileflowNativeManifestLimits.maximumBytes) {
+        throw new TileflowNativeSourceError("NATIVE_MANIFEST_TOO_LARGE", "body");
+      }
+      return resolved;
     };
+    try {
+      for (const name of Object.keys(manifest.maps).sort()) {
+        const map2 = manifest.maps[name];
+        for (const themeName of Object.keys(map2.themes).sort()) {
+          const theme = map2.themes[themeName];
+          theme.styleUrl = resolveResource(theme.styleUrl, finalUrl);
+          for (const face of theme.fontFaces ?? []) {
+            face.source = resolveResource(face.source, theme.styleUrl);
+          }
+        }
+      }
+    } catch (error2) {
+      if (error2 instanceof TileflowNativeSourceError) throw normalizeNativeSourceError(error2);
+      throw new TileflowNativeSourceError("NATIVE_MANIFEST_RESOURCE_INVALID", "body");
+    }
+    cancellation.check();
+    return freezeNativeSnapshot({ manifestUrl: finalUrl, manifest });
+  } catch (error2) {
+    cleanup();
+    cancellation.check();
+    throw normalizeNativeSourceError(error2);
+  } finally {
+    unlisten();
   }
-  return aligned;
 }
-var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-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) => same(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) => same(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);
+
+// src/native-source-controller.ts
+init_portable_identity_rules();
+
+// src/runtime.ts
+init_portable_identity_rules();
+var defaultTileflowRuntimeView = Object.freeze({
+  bearing: 0,
+  center: [0, 20],
+  pitch: 0,
+  zoom: 2
+});
+var tileflowStyleFontFaceLimits = Object.freeze({
+  maximumCount: 16,
+  maximumSourceLength: 2048
+});
+var maxStaticImagePixels = 1280 * 1280;
+var maximumManifestBytes = 1024 * 1024;
+var maximumSessionGrantBytes = 64 * 1024;
+var manifestCache = new globalThis.Map();
+function validateTileflowThemeSelection(value) {
+  return value === "system" || isTileflowThemeName(value);
+}
+var tileflowThemeBlendLimits = Object.freeze({ maximumThemes: 8, minimumThemes: 2 });
+function validateTileflowThemeBlendSelection(value) {
+  if (!value || typeof value !== "object") return false;
+  const { position, themes } = value;
+  return Array.isArray(themes) && themes.length >= tileflowThemeBlendLimits.minimumThemes && themes.length <= tileflowThemeBlendLimits.maximumThemes && themes.every((theme) => isTileflowThemeName(theme)) && typeof position === "number" && Number.isFinite(position) && position >= 0 && position <= themes.length - 1;
+}
+function nearestTileflowBlendTheme(blend) {
+  const index = Math.min(blend.themes.length - 1, Math.max(0, Math.round(blend.position)));
+  return blend.themes[index];
+}
+function resolveTileflowRuntimeTheme(map2, selection, colorScheme) {
+  let name;
+  if (selection === void 0) {
+    name = map2.defaultTheme;
+  } else if (selection === "system") {
+    if (!map2.systemThemes) {
+      throw new Error(
+        `Tileflow map "${map2.name}" does not declare systemThemes; select a concrete theme.`
+      );
     }
-    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);
+    if (!colorScheme) {
+      throw new Error('Resolving theme="system" requires an explicit browser color scheme.');
     }
+    name = map2.systemThemes[colorScheme];
   } else {
-    return values.every((value) => same(value, first)) ? out : void 0;
+    name = selection;
   }
-  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) => same(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 (!isTileflowThemeName(name)) {
+    throw new Error(
+      `Tileflow resolved invalid theme ${JSON.stringify(name)} for map "${map2.name}"; expected a concrete portable theme name.`
+    );
   }
-  if (first && typeof first === "object" && !Array.isArray(first)) {
-    const keys = Object.keys(first);
-    if (!values.every((value) => value && typeof value === "object" && same(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;
+  const theme = Object.hasOwn(map2.themes, name) ? map2.themes[name] : void 0;
+  if (!theme) {
+    const available = Object.keys(map2.themes).sort().join(", ");
+    throw new Error(
+      `Unknown Tileflow theme "${name}" for map "${map2.name}". Available themes: ${available}.`
+    );
   }
-  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;
+  return { ...theme, name };
 }
-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 resolveTileflowRuntimeView(options) {
+  const manifestView = options.manifestMap?.view;
+  return {
+    ...options.fallback ?? defaultTileflowRuntimeView,
+    ...manifestView ?? {},
+    ...options.bearing !== void 0 ? { bearing: options.bearing } : {},
+    ...options.center !== void 0 ? { center: options.center } : {},
+    ...options.pitch !== void 0 ? { pitch: options.pitch } : {},
+    ...options.zoom !== void 0 ? { zoom: options.zoom } : {}
+  };
 }
-var reads = (value, operator) => Array.isArray(value) && (value[0] === operator || value.some((item) => reads(item, operator)));
-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]);
+
+// src/native-source-controller.ts
+function createTileflowNativeSourceController(options) {
+  const input = nativeOwnRecord(options);
+  if (!input || typeof input.acquire !== "function")
+    throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "source");
+  const acquire = input.acquire;
+  const listeners = /* @__PURE__ */ new Set();
+  let state;
+  let generation = 0;
+  let disposed = false;
+  let active;
+  const notify = (listener, value) => {
+    try {
+      void Promise.resolve(listener(value)).catch(() => void 0);
+    } catch {
     }
-    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]);
+  };
+  const publish = (next) => {
+    if (disposed || next.generation !== generation) return;
+    state = freezeNativeSnapshot(next);
+    for (const listener of [...listeners]) {
+      if (disposed || state !== next || generation !== next.generation) break;
+      if (listeners.has(listener)) notify(listener, next);
     }
-    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 {
+    get state() {
+      return state;
+    },
+    subscribe(listener) {
+      if (typeof listener !== "function")
+        throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "source");
+      if (disposed) return () => void 0;
+      listeners.add(listener);
+      if (state) notify(listener, state);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    async replace(source, options2 = {}) {
+      if (disposed) throw new TileflowNativeSourceError("NATIVE_SOURCE_DISPOSED", "source");
+      if (generation >= Number.MAX_SAFE_INTEGER)
+        throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "source");
+      const own = { generation: ++generation, cancellation: new NativeSourceCancellation() };
+      const previous = active;
+      active = own;
+      const current = () => !disposed && generation === own.generation;
+      let sourceInput;
+      let selection;
+      let snapshotError;
+      try {
+        sourceInput = nativeOwnRecord(source);
+        selection = nativeOwnRecord(options2);
+      } catch (error2) {
+        snapshotError = normalizeNativeSourceError(error2);
+      }
+      previous?.cancellation.cancel();
+      let detach = () => void 0;
+      try {
+        if (!current()) return;
+        publish({ status: "loading", generation: own.generation });
+        if (!current()) return;
+        if (snapshotError) throw snapshotError;
+        if (!sourceInput || !selection || Object.hasOwn(sourceInput, "kind") || Object.hasOwn(sourceInput, "style") || !isTileflowPortableId(sourceInput.map))
+          throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "source");
+        if (selection.theme !== void 0 && !validateTileflowThemeSelection(selection.theme) || selection.colorScheme !== void 0 && selection.colorScheme !== "light" && selection.colorScheme !== "dark") {
+          throw new TileflowNativeSourceError("NATIVE_THEME_INVALID", "theme");
+        }
+        const selectedSource = {
+          map: sourceInput.map,
+          manifestUrl: sourceInput.manifestUrl
+        };
+        if (sourceInput.developmentOrigin !== void 0) {
+          try {
+            const developmentOrigin = sourceInput.developmentOrigin;
+            selectedSource.developmentOrigin = resolveTileflowNativeManifestUrl(developmentOrigin, {
+              developmentOrigin
+            }).slice(0, -1);
+          } catch {
+            throw new TileflowNativeSourceError("NATIVE_MANIFEST_URL_INVALID", "manifestUrl");
+          }
+        }
+        detach = own.cancellation.link(selection.signal);
+        const result = await loadNativeManifest(
+          selectedSource.manifestUrl,
+          acquire,
+          {
+            developmentOrigin: selectedSource.developmentOrigin
+          },
+          own.cancellation
+        );
+        if (!current()) return;
+        if (!Object.hasOwn(result.manifest.maps, selectedSource.map)) {
+          throw new TileflowNativeSourceError("NATIVE_MAP_NOT_FOUND", "map");
+        }
+        const entry = result.manifest.maps[selectedSource.map];
+        const apiUrl = entry.apiUrl ?? result.manifest.apiUrl;
+        const map2 = {
+          ...entry,
+          name: selectedSource.map,
+          ...apiUrl === void 0 ? {} : { apiUrl }
+        };
+        let theme;
+        try {
+          theme = resolveTileflowRuntimeTheme(
+            map2,
+            selection.theme,
+            selection.colorScheme
+          );
+        } catch {
+          throw new TileflowNativeSourceError("NATIVE_THEME_INVALID", "theme");
+        }
+        publish({
+          status: "ready",
+          generation: own.generation,
+          source: selectedSource,
+          ...result,
+          map: map2,
+          theme
+        });
+      } catch (error2) {
+        if (current())
+          publish({
+            status: "error",
+            generation: own.generation,
+            error: normalizeNativeSourceError(error2)
+          });
+      } finally {
+        detach();
+        if (active === own) active = void 0;
+      }
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      listeners.clear();
+      const previous = active;
+      active = void 0;
+      previous?.cancellation.cancel();
     }
-    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;
-}
-var isLegacyFilter = (filter) => Array.isArray(filter) && typeof filter[1] === "string" && !Array.isArray(filter[1]);
-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 same(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
+  };
 }
-var oklabCache = /* @__PURE__ */ new Map();
-function oklab(colour) {
-  const cached2 = oklabCache.get(colour);
-  if (cached2 !== void 0) return cached2;
-  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;
+
+// src/native-initial-view.ts
+init_runtime_view_schema();
+var viewSchema = createTileflowRuntimeViewSchema(miniManifestSchemaOperations);
+var viewKeys = ["bearing", "center", "pitch", "zoom"];
+var inputKeys = ["view", "mapOptionsView", "manifestView"];
+var invalid = () => {
+  throw new TileflowNativeSourceError("NATIVE_SOURCE_INVALID", "view");
+};
+function resolveTileflowNativeInitialView(options = {}) {
+  try {
+    const input = snapshotRecord(options, inputKeys);
+    const manifestView = snapshotView(input.manifestView);
+    const mapOptionsView = snapshotView(input.mapOptionsView);
+    const view = snapshotView(input.view);
+    const resolved = resolveTileflowRuntimeView({
+      ...view,
+      fallback: { ...defaultTileflowRuntimeView, ...manifestView, ...mapOptionsView }
     });
-    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]
-    ];
+    return freezeNativeSnapshot({
+      center: [resolved.center[0], resolved.center[1]],
+      zoom: resolved.zoom,
+      bearing: resolved.bearing,
+      pitch: resolved.pitch
+    });
+  } catch {
+    return invalid();
   }
-  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 snapshotRecord(input, keys) {
+  const snapshot = nativeOwnRecord(input);
+  if (!snapshot) return invalid();
+  const ownKeys = Reflect.ownKeys(input);
+  if (ownKeys.length !== Object.keys(snapshot).length || ownKeys.some((key) => typeof key !== "string" || !keys.includes(key)))
+    return invalid();
+  return snapshot;
 }
-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];
+function snapshotView(input) {
+  if (input === void 0) return {};
+  const snapshot = snapshotRecord(input, viewKeys);
+  if (snapshot.center !== void 0) {
+    const center = snapshot.center;
+    if (!Array.isArray(center) || Object.getPrototypeOf(center) !== Array.prototype || Reflect.ownKeys(center).length !== 3 || Object.getOwnPropertyDescriptor(center, "length")?.value !== 2)
+      return invalid();
+    const longitude = Object.getOwnPropertyDescriptor(center, "0");
+    const latitude = Object.getOwnPropertyDescriptor(center, "1");
+    if (!longitude?.enumerable || !latitude?.enumerable || !("value" in longitude) || !("value" in latitude))
+      return invalid();
+    snapshot.center = [longitude.value, latitude.value];
   }
-  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;
+  const parsed = parse(viewSchema, snapshot);
+  return {
+    ...parsed.bearing === void 0 ? {} : { bearing: parsed.bearing },
+    ...parsed.center === void 0 ? {} : { center: parsed.center },
+    ...parsed.pitch === void 0 ? {} : { pitch: parsed.pitch },
+    ...parsed.zoom === void 0 ? {} : { zoom: parsed.zoom }
+  };
 }
+
+// src/native.ts
+init_theme_blend();
 export {
   TileflowNativeSourceError,
   TileflowNativeUrlError,