@tileflow/dev 0.1.0-alpha.25 → 0.1.0-alpha.27

package/dist/{chunk-W3X2JXYS.js → chunk-QAMFAM3S.js}

@@ -2,6 +2,7 @@ import {
   inspectTileflowPmtilesForLocalUse
 } from "./chunk-ONYQNLNA.js";
 import {
+  TileflowFontCompilationError,
   getTileflowFontWatchPaths,
   joinTileflowPublicUrl,
   prepareTileflowStyleFonts,
@@ -10,7 +11,7 @@ import {
 import {
   getTileflowIconWatchPaths,
   prepareTileflowCatalogIcons
-} from "./chunk-D2QWYYIF.js";
+} from "./chunk-EJPVUSX4.js";
 import {
   TileflowStyleValidationError,
   normalizeTileflowStyleValidationIssues,
@@ -27,7 +28,7 @@ import {
 } from "./chunk-D4OE4ITL.js";
 
 // src/artifacts.ts
-import { createHash } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { realpathSync as realpathSync2 } from "fs";
 import {
   copyFile as copyFile2,
@@ -45,8 +46,8 @@ import { createRequire } from "module";
 import { dirname as dirname2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
 import {
   compareCodeUnits as compareCodeUnits2,
-  getTileflowStyleFontFaces,
-  serializeCanonicalJson,
+  getTileflowStyleFontFaces as getTileflowStyleFontFaces2,
+  serializeCanonicalJson as serializeCanonicalJson4,
   tileflowMapIdSchema,
   tileflowThemeNameSchema
 } from "@tileflow/core";
@@ -59,6 +60,13 @@ import {
   tileflowMapBuildManifestFileName
 } from "@tileflow/core/build";
 import { parseTileflowRuntimeManifest } from "@tileflow/core/manifest";
+import {
+  createTileflowNativeBuildRecord as createTileflowNativeBuildRecord2,
+  createTileflowNativeDiagnostic as createTileflowNativeDiagnostic4,
+  resolveTileflowRenderer,
+  tileflowNativeBuildRecordFileName,
+  TileflowNativeCompatibilityError as TileflowNativeCompatibilityError5
+} from "@tileflow/core/native-profile";
 
 // src/local-tilesets.ts
 import { randomUUID } from "crypto";
@@ -375,14 +383,802 @@ function hasErrorCode(error, code) {
   return Boolean(error && typeof error === "object" && error.code === code);
 }
 
+// src/native-artifacts.ts
+import { createHash } from "crypto";
+import {
+  convertFilter,
+  validateStyleMin
+} from "@maplibre/maplibre-gl-style-spec";
+import {
+  getTileflowStyleFontFaces,
+  serializeCanonicalJson,
+  tileflowStyleFontFacesMetadataKey,
+  tileflowIconIdPattern,
+  tileflowIconPackageLimits
+} from "@tileflow/core";
+import {
+  createTileflowNativeDiagnostic,
+  TileflowNativeCompatibilityError,
+  tileflowNativeProfileLimits,
+  validateTileflowNativeStyle,
+  validateTileflowNativePreparedStyle
+} from "@tileflow/core/native-profile";
+
+// src/native-lowering.ts
+var nativeLoweringLimits = Object.freeze({
+  maximumDecisionDepth: 16,
+  maximumDecisionNodes: 512,
+  maximumPropertyBranches: 16,
+  maximumPathsPerProperty: 64,
+  maximumLayerVariants: 32,
+  maximumZoomIntervals: 32,
+  maximumLayers: 4096,
+  maximumDashLength: 64
+});
+var NativeLoweringError = class extends Error {
+  constructor(path, reason = "shape") {
+    super(
+      reason === "budget" ? "Native decision lowering exceeds its finite budget." : "This native decision cannot be lowered without changing its meaning."
+    );
+    this.path = path;
+    this.reason = reason;
+    this.name = "NativeLoweringError";
+  }
+  path;
+  reason;
+};
+function fail(path, reason = "shape") {
+  throw new NativeLoweringError(path, reason);
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function operation(value, name, length) {
+  return Array.isArray(value) && value[0] === name && (length === void 0 || value.length === length);
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function key(value) {
+  return JSON.stringify(value);
+}
+function negate(value) {
+  return typeof value === "boolean" ? !value : operation(value, "!", 2) ? value[1] : ["!", value];
+}
+function combine(operator, values) {
+  const identity = operator === "all";
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values.flatMap(
+    (item) => operation(item, operator) ? item.slice(1) : [item]
+  )) {
+    if (value === identity) continue;
+    if (value === !identity || seen.has(key(negate(value)))) return !identity;
+    const serialized = key(value);
+    if (!seen.has(serialized)) {
+      seen.add(serialized);
+      result.push(value);
+    }
+  }
+  return result.length === 0 ? identity : result.length === 1 ? result[0] : [operator, ...result];
+}
+function choose(when, yes, no) {
+  if (when === true) return yes;
+  if (when === false) return no;
+  if (key(yes) === key(no)) return yes;
+  if (yes === true) return combine("any", [when, no]);
+  if (yes === false) return combine("all", [negate(when), no]);
+  if (no === true) return combine("any", [negate(when), yes]);
+  if (no === false) return combine("all", [when, yes]);
+  return ["case", when, yes, no];
+}
+function decision(arms, fallback) {
+  const active = [];
+  for (const arm of arms) {
+    if (arm.when === false) continue;
+    if (arm.when === true) {
+      fallback = arm.value;
+      break;
+    }
+    const previous = active.at(-1);
+    if (previous && key(previous.value) === key(arm.value)) {
+      previous.when = combine("any", [previous.when, arm.when]);
+    } else active.push({ ...arm });
+  }
+  while (active.length && key(active.at(-1).value) === key(fallback)) active.pop();
+  if (!active.length) return fallback;
+  if (active.length === 1) return choose(active[0].when, active[0].value, fallback);
+  return ["case", ...active.flatMap(({ when, value }) => [when, value]), fallback];
+}
+var Decisions = class {
+  constructor(path, vector) {
+    this.path = path;
+    this.vector = vector;
+  }
+  path;
+  vector;
+  visited = 0;
+  cuts = /* @__PURE__ */ new Set();
+  tick(depth) {
+    if (++this.visited > nativeLoweringLimits.maximumDecisionNodes || depth > nativeLoweringLimits.maximumDecisionDepth) {
+      fail(this.path, "budget");
+    }
+  }
+  tree(value, property, depth = 0) {
+    this.tick(depth);
+    const leaf = operation(value, "literal", 2) ? value[1] : value;
+    if (property === "line-cap" && typeof leaf === "string" && ["butt", "round", "square"].includes(leaf)) {
+      return { kind: "leaf", value: leaf };
+    }
+    if (property === "line-dasharray" && Array.isArray(leaf) && leaf.length > 0 && leaf.length <= nativeLoweringLimits.maximumDashLength && leaf.every((item) => finite(item) && item >= 0)) {
+      return { kind: "leaf", value: [...leaf] };
+    }
+    if (operation(value, "case") && value.length >= 4 && value.length % 2 === 0) {
+      const arms = [];
+      for (let index = 1; index < value.length - 1; index += 2) {
+        const when = this.predicate(value[index], depth + 1);
+        arms.push({ when, value: this.tree(value[index + 1], property, depth + 1) });
+      }
+      return { kind: "case", arms, fallback: this.tree(value.at(-1), property, depth + 1) };
+    }
+    if (operation(value, "match") && value.length >= 5 && value.length % 2 === 1) {
+      this.scalar(value[1], depth + 1);
+      const labels = this.matchLabels(value, depth + 1);
+      return {
+        kind: "case",
+        arms: labels.map((when, index) => ({
+          when,
+          value: this.tree(value[index * 2 + 3], property, depth + 1)
+        })),
+        fallback: this.tree(value.at(-1), property, depth + 1)
+      };
+    }
+    if (operation(value, "step") && value.length >= 5 && value.length % 2 === 1) {
+      if (this.scalar(value[1], depth + 1) !== "number") fail(this.path);
+      const stops = [];
+      let previous = -Infinity;
+      for (let index = 3; index < value.length; index += 2) {
+        const at = value[index];
+        if (!finite(at) || at <= previous) fail(this.path);
+        previous = at;
+        if (operation(value[1], "zoom", 1)) this.cuts.add(Math.ceil(at));
+        stops.push({ at, value: this.tree(value[index + 1], property, depth + 1) });
+      }
+      return {
+        kind: "step",
+        input: value[1],
+        fallback: this.tree(value[2], property, depth + 1),
+        stops
+      };
+    }
+    return fail(this.path);
+  }
+  scalar(value, depth) {
+    this.tick(depth);
+    if (finite(value)) return "number";
+    if (value === null || typeof value === "boolean" || typeof value === "string") return "scalar";
+    if (operation(value, "zoom", 1)) return "number";
+    if (operation(value, "get", 2) && typeof value[1] === "string" && this.vector) return "scalar";
+    if (operation(value, "geometry-type", 1) || operation(value, "id", 1) && this.vector)
+      return "scalar";
+    if (operation(value, "to-string", 2)) {
+      if (operation(value[1], "zoom", 1)) fail(this.path);
+      this.scalar(value[1], depth + 1);
+      return "scalar";
+    }
+    if (operation(value, "coalesce") && value.length >= 3) {
+      for (const child of value.slice(1)) {
+        if (operation(child, "zoom", 1)) fail(this.path);
+        this.scalar(child, depth + 1);
+      }
+      return "scalar";
+    }
+    if (operation(value, "to-number", 3) && finite(value[2])) {
+      if (operation(value[1], "zoom", 1)) fail(this.path);
+      this.scalar(value[1], depth + 1);
+      return "number";
+    }
+    return fail(this.path);
+  }
+  matchLabels(value, depth) {
+    const seen = /* @__PURE__ */ new Set();
+    let labelType;
+    const predicates = [];
+    for (let index = 2; index < value.length - 1; index += 2) {
+      const labels = Array.isArray(value[index]) ? value[index] : [value[index]];
+      if (!labels.length) fail(this.path);
+      const terms = [];
+      for (const label of labels) {
+        this.tick(depth);
+        if (!(typeof label === "string" || finite(label) && Number.isInteger(label)))
+          fail(this.path);
+        if (labelType !== void 0 && labelType !== typeof label) fail(this.path);
+        labelType = typeof label;
+        const encoded = key(label);
+        if (seen.has(encoded)) fail(this.path);
+        seen.add(encoded);
+        if (operation(value[1], "zoom", 1)) {
+          if (!finite(label)) fail(this.path);
+          this.cuts.add(label);
+          this.cuts.add(label + 1);
+        }
+        terms.push(["==", value[1], label]);
+      }
+      predicates.push(combine("any", terms));
+    }
+    return predicates;
+  }
+  predicate(value, depth) {
+    this.tick(depth);
+    if (typeof value === "boolean") return value;
+    if (operation(value, "literal", 2) && typeof value[1] === "boolean") return value[1];
+    if (operation(value, "all") || operation(value, "any")) {
+      return combine(
+        value[0],
+        value.slice(1).map((child) => this.predicate(child, depth + 1))
+      );
+    }
+    if (operation(value, "!", 2)) return negate(this.predicate(value[1], depth + 1));
+    if (operation(value, "has", 2) && typeof value[1] === "string") return value;
+    if (operation(value, "match") && value.length >= 5 && value.length % 2 === 1) {
+      this.scalar(value[1], depth + 1);
+      const conditions = this.matchLabels(value, depth + 1);
+      let remaining = true;
+      const terms = [];
+      for (const [index, condition] of conditions.entries()) {
+        terms.push(combine("all", [condition, this.predicate(value[index * 2 + 3], depth + 1)]));
+        remaining = combine("all", [remaining, negate(condition)]);
+      }
+      terms.push(combine("all", [remaining, this.predicate(value.at(-1), depth + 1)]));
+      return combine("any", terms);
+    }
+    if (operation(value, "case") && value.length >= 4 && value.length % 2 === 0) {
+      let remaining = true;
+      const terms = [];
+      for (let index = 1; index < value.length - 1; index += 2) {
+        const condition = this.predicate(value[index], depth + 1);
+        terms.push(
+          combine("all", [remaining, condition, this.predicate(value[index + 1], depth + 1)])
+        );
+        remaining = combine("all", [remaining, negate(condition)]);
+      }
+      terms.push(combine("all", [remaining, this.predicate(value.at(-1), depth + 1)]));
+      return combine("any", terms);
+    }
+    if (operation(value, "step") && value.length >= 5 && value.length % 2 === 1) {
+      if (this.scalar(value[1], depth + 1) !== "number") fail(this.path);
+      let previous = -Infinity;
+      let remaining = true;
+      let output = this.predicate(value[2], depth + 1);
+      const terms = [];
+      for (let index = 3; index < value.length; index += 2) {
+        const at = value[index];
+        if (!finite(at) || at <= previous) fail(this.path);
+        previous = at;
+        if (operation(value[1], "zoom", 1)) this.cuts.add(Math.ceil(at));
+        const below = ["<", value[1], at];
+        terms.push(combine("all", [remaining, below, output]));
+        remaining = combine("all", [remaining, negate(below)]);
+        output = this.predicate(value[index + 1], depth + 1);
+      }
+      terms.push(combine("all", [remaining, output]));
+      return combine("any", terms);
+    }
+    if (operation(value, "in", 3) && operation(value[2], "literal", 2) && Array.isArray(value[2][1])) {
+      this.scalar(value[1], depth + 1);
+      if (operation(value[1], "zoom", 1)) fail(this.path);
+      for (const item of value[2][1]) {
+        this.tick(depth + 1);
+        if (!(item === null || typeof item === "boolean" || typeof item === "string" || finite(item)))
+          fail(this.path);
+      }
+      return value;
+    }
+    if (Array.isArray(value) && value.length === 3 && ["==", "!=", "<", "<=", ">", ">="].includes(String(value[0]))) {
+      const left = this.scalar(value[1], depth + 1);
+      const right = this.scalar(value[2], depth + 1);
+      if (!["==", "!="].includes(String(value[0])) && (left !== "number" || right !== "number"))
+        fail(this.path);
+      if (operation(value[1], "zoom", 1) || operation(value[2], "zoom", 1)) {
+        const constant = operation(value[1], "zoom", 1) ? value[2] : value[1];
+        if (!finite(constant)) fail(this.path);
+        this.cuts.add(Math.ceil(constant));
+        this.cuts.add(Math.floor(constant) + 1);
+      }
+      return value;
+    }
+    return fail(this.path);
+  }
+  atZoom(value, zoom) {
+    if (typeof value === "boolean") return value;
+    const expr = value;
+    if (expr[0] === "all" || expr[0] === "any")
+      return combine(
+        expr[0],
+        expr.slice(1).map((child) => this.atZoom(child, zoom))
+      );
+    if (expr[0] === "!") return negate(this.atZoom(expr[1], zoom));
+    if (operation(expr[1], "zoom", 1) || operation(expr[2], "zoom", 1)) {
+      const left = operation(expr[1], "zoom", 1) ? zoom : expr[1];
+      const right = operation(expr[2], "zoom", 1) ? zoom : expr[2];
+      switch (expr[0]) {
+        case "==":
+          return left === right;
+        case "!=":
+          return left !== right;
+        case "<":
+          return left < right;
+        case "<=":
+          return left <= right;
+        case ">":
+          return left > right;
+        case ">=":
+          return left >= right;
+      }
+    }
+    return expr;
+  }
+  outcomes(tree, zoom) {
+    const leaves = [];
+    const walk = (node, guard) => {
+      if (guard === false) return;
+      if (node.kind === "leaf") {
+        leaves.push({ when: guard, value: node.value });
+        if (leaves.length > nativeLoweringLimits.maximumPathsPerProperty) fail(this.path, "budget");
+      } else if (node.kind === "case") {
+        let remaining = guard;
+        for (const arm of node.arms) {
+          const condition = this.atZoom(arm.when, zoom);
+          walk(arm.value, combine("all", [remaining, condition]));
+          remaining = combine("all", [remaining, negate(condition)]);
+        }
+        walk(node.fallback, remaining);
+      } else if (operation(node.input, "zoom", 1)) {
+        let selected = node.fallback;
+        for (const stop of node.stops) {
+          if (zoom < stop.at) break;
+          selected = stop.value;
+        }
+        walk(selected, guard);
+      } else {
+        let previous = node.fallback;
+        let remaining = guard;
+        for (const stop of node.stops) {
+          const below = ["<", node.input, stop.at];
+          walk(previous, combine("all", [remaining, below]));
+          remaining = combine("all", [remaining, negate(below)]);
+          previous = stop.value;
+        }
+        walk(previous, remaining);
+      }
+    };
+    walk(tree, true);
+    const grouped = /* @__PURE__ */ new Map();
+    for (const outcome of leaves) {
+      const id = key(outcome.value);
+      if (!grouped.has(id)) grouped.set(id, { when: true, value: outcome.value });
+    }
+    if (grouped.size > nativeLoweringLimits.maximumPropertyBranches) fail(this.path, "budget");
+    return [...grouped.entries()].map(([id, outcome]) => ({
+      value: outcome.value,
+      when: this.accepts(tree, id, zoom)
+    }));
+  }
+  accepts(tree, outcome, zoom) {
+    if (tree.kind === "leaf") return key(tree.value) === outcome;
+    if (tree.kind === "case") {
+      return decision(
+        tree.arms.map((arm) => ({
+          when: this.atZoom(arm.when, zoom),
+          value: this.accepts(arm.value, outcome, zoom)
+        })),
+        this.accepts(tree.fallback, outcome, zoom)
+      );
+    }
+    if (operation(tree.input, "zoom", 1)) {
+      let selected = tree.fallback;
+      for (const stop of tree.stops) {
+        if (zoom < stop.at) break;
+        selected = stop.value;
+      }
+      return this.accepts(selected, outcome, zoom);
+    }
+    return decision(
+      tree.stops.map((stop, index) => ({
+        when: ["<", tree.input, stop.at],
+        value: this.accepts(
+          index === 0 ? tree.fallback : tree.stops[index - 1].value,
+          outcome,
+          zoom
+        )
+      })),
+      this.accepts(tree.stops.at(-1).value, outcome, zoom)
+    );
+  }
+};
+function isConstant(value, property) {
+  return value === void 0 || (property === "line-cap" ? typeof value === "string" : Array.isArray(value) && value.every((item) => typeof item === "number"));
+}
+function lowerLayer(layer, index, vector) {
+  if (layer.type !== "line") return;
+  const properties = [];
+  let cap;
+  let dash;
+  for (const [group, property] of [
+    ["layout", "line-cap"],
+    ["paint", "line-dasharray"]
+  ]) {
+    const value = layer[group]?.[property];
+    if (isConstant(value, property)) continue;
+    const decisions = new Decisions(`/layers/${index}/${group}/${property}`, vector);
+    const tree = decisions.tree(value, property);
+    properties.push(property);
+    if (property === "line-cap") cap = { decisions, tree };
+    else dash = { decisions, tree };
+  }
+  if (!properties.length) return;
+  const minimum = layer.minzoom ?? 0;
+  const maximum = layer.maxzoom ?? 24;
+  if (!finite(minimum) || !finite(maximum) || minimum < 0 || maximum > 24 || minimum >= maximum) {
+    fail(`/layers/${index}/minzoom`);
+  }
+  const cuts = [
+    .../* @__PURE__ */ new Set([
+      minimum,
+      maximum,
+      ...[...cap?.decisions.cuts ?? [], ...dash?.decisions.cuts ?? []].filter(
+        (cut) => cut > minimum && cut < maximum
+      )
+    ])
+  ].sort((a, b) => a - b);
+  if (cuts.length - 1 > nativeLoweringLimits.maximumZoomIntervals)
+    fail(`/layers/${index}`, "budget");
+  const variants = [];
+  const tails = /* @__PURE__ */ new Map();
+  for (let part = 0; part < cuts.length - 1; part++) {
+    const low = cuts[part];
+    const high = cuts[part + 1];
+    const caps = cap ? cap.decisions.outcomes(cap.tree, Math.floor(low)) : [{ when: true, value: void 0 }];
+    const dashes = dash ? dash.decisions.outcomes(dash.tree, Math.floor(low)) : [{ when: true, value: void 0 }];
+    for (const c of caps)
+      for (const d of dashes) {
+        const when = combine("all", [c.when, d.when]);
+        if (when === false) continue;
+        const signature = key([when, c.value, d.value]);
+        const tail = tails.get(signature);
+        if (tail && tail.maximum === low) {
+          tail.maximum = high;
+          continue;
+        }
+        const variant = {
+          minimum: low,
+          maximum: high,
+          when,
+          ...cap ? { cap: c.value } : {},
+          ...dash ? { dash: d.value } : {}
+        };
+        variants.push(variant);
+        tails.set(signature, variant);
+        if (variants.length > nativeLoweringLimits.maximumLayerVariants)
+          fail(`/layers/${index}`, "budget");
+      }
+  }
+  return { variants, properties };
+}
+function lowerNativeStyleRepresentation(input, normalizeFilter = (filter) => filter) {
+  if (!Array.isArray(input.layers) || input.layers.length > nativeLoweringLimits.maximumLayers)
+    fail("/layers", "budget");
+  const originalLayers = input.layers;
+  const reserved = /* @__PURE__ */ new Set();
+  for (const [index, layer] of originalLayers.entries()) {
+    if (!object(layer) || typeof layer.id !== "string" || reserved.has(layer.id))
+      fail(`/layers/${index}/id`);
+    reserved.add(layer.id);
+  }
+  let projection = "none";
+  if (input.projection !== void 0) {
+    if (!object(input.projection) || Object.keys(input.projection).length !== 1 || typeof input.projection.type !== "string" || !["globe", "mercator"].includes(input.projection.type))
+      fail("/projection");
+    projection = input.projection.type === "globe" ? "globe-to-mercator" : "mercator-to-implicit";
+  }
+  const layers = [];
+  const transformations = [];
+  for (const [index, layer] of originalLayers.entries()) {
+    const source = object(input.sources) && typeof layer.source === "string" ? input.sources[layer.source] : void 0;
+    const lowered = lowerLayer(layer, index, object(source) && source.type === "vector");
+    if (!lowered) {
+      layers.push(layer);
+      continue;
+    }
+    if (layers.length + lowered.variants.length + originalLayers.length - index - 1 > nativeLoweringLimits.maximumLayers) {
+      fail(`/layers/${index}`, "budget");
+    }
+    const originalFilter = layer.filter === void 0 ? void 0 : normalizeFilter(layer.filter);
+    const outputStart = layers.length;
+    for (const [branch, variant] of lowered.variants.entries()) {
+      const stem = `${layer.id}--native-v1-${branch}`;
+      let id = stem;
+      let collision = 0;
+      while (reserved.has(id)) id = `${stem}-${++collision}`;
+      reserved.add(id);
+      const next = { ...layer, id };
+      if (variant.minimum !== (layer.minzoom ?? 0)) next.minzoom = variant.minimum;
+      if (variant.maximum !== (layer.maxzoom ?? 24)) next.maxzoom = variant.maximum;
+      if (variant.when !== true)
+        next.filter = originalFilter === void 0 ? variant.when : ["all", originalFilter, variant.when];
+      if (variant.cap !== void 0) next.layout = { ...layer.layout, "line-cap": variant.cap };
+      if (variant.dash !== void 0) next.paint = { ...layer.paint, "line-dasharray": variant.dash };
+      layers.push(next);
+    }
+    transformations.push({
+      inputLayer: index,
+      outputStart,
+      outputCount: lowered.variants.length,
+      properties: lowered.properties
+    });
+  }
+  const changed = projection !== "none" || transformations.length > 0;
+  const output = changed ? { ...input, layers } : input;
+  if (changed && projection !== "none") delete output.projection;
+  return {
+    style: output,
+    projection,
+    layers: transformations,
+    inputLayers: originalLayers.length,
+    outputLayers: layers.length
+  };
+}
+
+// src/native-artifacts.ts
+function documentUrl(map, theme) {
+  return `https://artifacts.invalid/native/styles/${map}/${theme}.json`;
+}
+function withContext(issue, map, theme) {
+  const prefix = `/maps/${map}/themes/${theme}/style`;
+  return { ...issue, path: prefix.length + issue.path.length <= 300 ? prefix + issue.path : prefix };
+}
+function lowerTileflowNativeCompiledStyles(input) {
+  const styles = {};
+  const transformations = [];
+  for (const map of Object.keys(input).sort()) {
+    styles[map] = {};
+    for (const theme of Object.keys(input[map]).sort()) {
+      const original = input[map][theme];
+      try {
+        const options = { documentUrl: documentUrl(map, theme), deferFontClosure: true };
+        const pending = validateTileflowNativeStyle(original, options);
+        const blockers = pending.filter(
+          (issue) => issue.code !== "NATIVE_UNSUPPORTED_STYLE" || !(issue.path === "/projection" || /^\/layers\/\d+\/(?:layout\/line-cap|paint\/line-dasharray)(?:\/|$)/u.test(issue.path))
+        );
+        if (blockers.length)
+          throw new TileflowNativeCompatibilityError(
+            blockers.map((issue) => withContext(issue, map, theme))
+          );
+        const syntax = validateStyleMin(JSON.parse(serializeCanonicalJson(original)));
+        if (syntax.length)
+          throw new TileflowNativeCompatibilityError(
+            syntax.map((issue) => {
+              const match = /^layers\[(\d+)\]\.(layout\.line-cap|paint\.line-dasharray)(?=[:.[]|$)/u.exec(
+                issue.message
+              );
+              const path = match ? `/layers/${match[1]}/${match[2].replace(".", "/")}` : issue.message.startsWith("projection") ? "/projection" : "";
+              return withContext(
+                createTileflowNativeDiagnostic("NATIVE_UNSUPPORTED_STYLE", path),
+                map,
+                theme
+              );
+            })
+          );
+        const lowered = lowerNativeStyleRepresentation(
+          original,
+          (filter) => convertFilter(structuredClone(filter))
+        );
+        const issues = validateTileflowNativePreparedStyle(lowered.style, options);
+        if (issues.length)
+          throw new TileflowNativeCompatibilityError(
+            issues.map((issue) => withContext(issue, map, theme))
+          );
+        styles[map][theme] = lowered.style;
+        transformations.push({
+          map,
+          theme,
+          inputStyleSha256: createHash("sha256").update(serializeCanonicalJson(original)).digest("hex"),
+          loweredStyleSha256: createHash("sha256").update(serializeCanonicalJson(lowered.style)).digest("hex"),
+          inputLayers: lowered.inputLayers,
+          outputLayers: lowered.outputLayers,
+          projection: lowered.projection,
+          layers: lowered.layers
+        });
+      } catch (error) {
+        if (!(error instanceof NativeLoweringError)) throw error;
+        throw new TileflowNativeCompatibilityError([
+          withContext(
+            {
+              ...createTileflowNativeDiagnostic("NATIVE_UNSUPPORTED_STYLE", error.path),
+              message: error.message,
+              suggestion: error.reason === "budget" ? "Reduce the decision expansion or style size; native lowering never raises its resource limits automatically." : error.path === "/projection" ? "Use a fixed globe or Mercator projection for native-v1; adaptive projections are not supported." : "Use finite case/match/step decisions with constant leaves and supported scalar predicates, or select web."
+            },
+            map,
+            theme
+          )
+        ]);
+      }
+    }
+  }
+  return { styles, transformations };
+}
+function assertTileflowNativeCompiledStyles(project, styles) {
+  const issues = [];
+  for (const mapName of Object.keys(project.maps).sort()) {
+    for (const theme of Object.keys(styles[mapName] ?? {}).sort()) {
+      issues.push(
+        ...validateTileflowNativePreparedStyle(styles[mapName][theme], {
+          documentUrl: documentUrl(mapName, theme),
+          deferFontClosure: true
+        }).map((issue) => withContext(issue, mapName, theme))
+      );
+    }
+  }
+  if (issues.length) throw new TileflowNativeCompatibilityError(issues);
+}
+function prepareTileflowNativeStyles(input, assets) {
+  const issues = [];
+  const result = {};
+  for (const map of Object.keys(input).sort()) {
+    result[map] = {};
+    if (!validNativeSprites(map, assets)) {
+      issues.push({
+        ...createTileflowNativeDiagnostic("NATIVE_UNSUPPORTED_STYLE", `/maps/${map}/icons`),
+        suggestion: "Rebuild the icon sources into a complete, bounded 1x/2x sprite pair."
+      });
+    }
+    for (const theme of Object.keys(input[map]).sort()) {
+      const original = input[map][theme];
+      const preflight = validateTileflowNativePreparedStyle(original, {
+        documentUrl: documentUrl(map, theme),
+        deferFontClosure: true
+      });
+      if (preflight.length) {
+        issues.push(...preflight.map((issue) => withContext(issue, map, theme)));
+        continue;
+      }
+      const metadata = { ...original.metadata };
+      const faces = getTileflowStyleFontFaces(original);
+      const nativeFaces = {};
+      for (const face of faces) {
+        const asset = assets.find(
+          (item) => item.fileName.startsWith("fonts/") && (face.source === item.fileName || face.source.endsWith(`/${item.fileName}`))
+        );
+        if (!asset || !isNativeFontAsset(asset)) {
+          issues.push(
+            withContext(
+              createTileflowNativeDiagnostic("NATIVE_FONT_UNAVAILABLE", "/font-faces"),
+              map,
+              theme
+            )
+          );
+          continue;
+        }
+        if (Object.hasOwn(nativeFaces, face.family)) {
+          issues.push(
+            withContext(
+              createTileflowNativeDiagnostic("NATIVE_FONT_UNAVAILABLE", "/font-faces"),
+              map,
+              theme
+            )
+          );
+          continue;
+        }
+        Object.defineProperty(nativeFaces, face.family, { value: face.source, enumerable: true });
+      }
+      delete metadata[tileflowStyleFontFacesMetadataKey];
+      const { projection: _projection, ...rest } = original;
+      const style = {
+        ...rest,
+        metadata,
+        ...faces.length ? { "font-faces": nativeFaces } : {}
+      };
+      issues.push(
+        ...validateTileflowNativePreparedStyle(style, {
+          documentUrl: documentUrl(map, theme)
+        }).map((issue) => withContext(issue, map, theme))
+      );
+      result[map][theme] = style;
+    }
+  }
+  if (issues.length) throw new TileflowNativeCompatibilityError(issues);
+  return result;
+}
+function isNativeFontAsset(asset) {
+  const bytes = typeof asset.source === "string" ? Buffer.from(asset.source) : asset.source;
+  if (bytes.byteLength < 12 || bytes.byteLength > tileflowNativeProfileLimits.maximumFontBytes)
+    return false;
+  const signature = Buffer.from(bytes.subarray(0, 4)).toString("hex");
+  if (!/\.(?:ttf|otf)$/u.test(asset.fileName) || !["00010000", "4f54544f"].includes(signature))
+    return false;
+  const expectedHash = /-([a-f0-9]{64})\.(?:ttf|otf)$/u.exec(asset.fileName)?.[1];
+  return expectedHash === createHash("sha256").update(bytes).digest("hex");
+}
+function assertTileflowNativeGeneratedStyle(style, map, theme) {
+  const issues = validateTileflowNativePreparedStyle(style, { documentUrl: documentUrl(map, theme) });
+  if (issues.length) {
+    throw new TileflowNativeCompatibilityError(
+      issues.map((issue) => withContext(issue, map, theme))
+    );
+  }
+}
+function replaceTileflowNativeFontSources(style, replace) {
+  const faces = style["font-faces"];
+  if (!faces) return style;
+  return {
+    ...style,
+    "font-faces": Object.fromEntries(
+      Object.entries(faces).map(([name, source]) => [name, replace(source)])
+    )
+  };
+}
+function validNativeSprites(map, assets) {
+  const prefix = `icons/${map}/`;
+  const files = assets.filter((asset) => asset.fileName.startsWith(prefix));
+  if (!files.length) return true;
+  try {
+    if (files.length !== 4) return false;
+    let totalBytes = 0;
+    const indexes = [];
+    for (const ratio of [1, 2]) {
+      const suffix = ratio === 1 ? "" : "@2x";
+      const image = files.find((asset) => asset.fileName === `${prefix}sprite${suffix}.png`);
+      const index = files.find((asset) => asset.fileName === `${prefix}sprite${suffix}.json`);
+      if (!image || !index) return false;
+      const imageBytes = Buffer.from(
+        typeof image.source === "string" ? new TextEncoder().encode(image.source) : image.source
+      );
+      const indexBytes = Buffer.from(
+        typeof index.source === "string" ? new TextEncoder().encode(index.source) : index.source
+      );
+      for (const bytes of [imageBytes, indexBytes]) {
+        if (bytes.length > tileflowIconPackageLimits.maxGeneratedFileBytes) return false;
+        totalBytes += bytes.length;
+      }
+      if (imageBytes.length < 33 || imageBytes.subarray(0, 8).toString("hex") !== "89504e470d0a1a0a" || imageBytes.toString("ascii", 12, 16) !== "IHDR")
+        return false;
+      const width = imageBytes.readUInt32BE(16);
+      const height = imageBytes.readUInt32BE(20);
+      if (!width || !height || width > tileflowIconPackageLimits.maxAtlasDimension || height > tileflowIconPackageLimits.maxAtlasDimension)
+        return false;
+      const data = JSON.parse(indexBytes.toString("utf8"));
+      if (!data || typeof data !== "object" || Array.isArray(data)) return false;
+      const names = Object.keys(data).sort();
+      if (!names.length || names.length > tileflowIconPackageLimits.maxIconCount) return false;
+      indexes.push(names);
+      for (const name of names) {
+        if (!tileflowIconIdPattern.test(name)) return false;
+        const entry = data[name];
+        if (!entry || entry.pixelRatio !== ratio) return false;
+        const { x, y, width: w, height: h } = entry;
+        if (![x, y, w, h].every((value) => typeof value === "number" && Number.isSafeInteger(value)))
+          return false;
+        if (x < 0 || y < 0 || w <= 0 || h <= 0 || x + w > width || y + h > height)
+          return false;
+      }
+    }
+    return totalBytes <= tileflowIconPackageLimits.maxGeneratedPackageBytes && JSON.stringify(indexes[0]) === JSON.stringify(indexes[1]);
+  } catch {
+    return false;
+  }
+}
+
 // src/session.ts
 import { watch } from "chokidar";
-import { realpathSync } from "fs";
-import { dirname, extname, isAbsolute, relative, resolve as resolve2, sep, win32 } from "path";
+import { realpathSync, statSync } from "fs";
+import { basename as basename2, dirname, extname, isAbsolute, relative, resolve as resolve2, sep, win32 } from "path";
+import { tileflowIconMetadataFileName } from "@tileflow/core";
+import { TileflowNativeCompatibilityError as TileflowNativeCompatibilityError2 } from "@tileflow/core/native-profile";
 var tileflowArtifactSessionSchemaVersion = 1;
 var configExtensions = /* @__PURE__ */ new Set([".cjs", ".cts", ".js", ".json", ".mjs", ".mts", ".ts", ".tsx"]);
 var iconExtensions = /* @__PURE__ */ new Set([".jpeg", ".jpg", ".png", ".svg", ".webp"]);
 var fontExtensions = /* @__PURE__ */ new Set([".otf", ".ttf", ".woff2"]);
+var writeStabilityMs = 50;
 var excludedDirectories = /* @__PURE__ */ new Set([
   ".cache",
   ".git",
@@ -416,6 +1212,7 @@ var TileflowArtifactSessionImpl = class {
   #closed = false;
   #closing;
   #debounceTimer;
+  #startupCheckTimer;
   #generation = 0;
   #current;
   #artifactGenerations = /* @__PURE__ */ new Set();
@@ -424,13 +1221,17 @@ var TileflowArtifactSessionImpl = class {
   #refreshToken = 0;
   #state = { generation: 0, status: "building" };
   #watcher;
+  #watchedArtifactDirectories = /* @__PURE__ */ new Map();
   #watchedArtifactPaths = /* @__PURE__ */ new Set();
   constructor(options, buildArtifacts, discoverWatchPaths) {
     this.#cwd = resolve2(options.cwd ?? process.cwd());
-    this.#configPath = resolve2(this.#cwd, options.config ?? "tileflow.config.ts");
+    const configPath = resolve2(this.#cwd, options.config ?? "tileflow.config.ts");
+    this.#configPath = resolve2(canonicalWatchPath(dirname(configPath)), basename2(configPath));
     this.#debounceMs = Math.max(0, Math.min(options.debounceMs ?? 75, 1e3));
     this.#watchEnabled = options.watch ?? false;
-    this.#ignoredPaths = (options.ignoredPaths ?? []).map((path) => resolve2(this.#cwd, path));
+    this.#ignoredPaths = (options.ignoredPaths ?? []).map(
+      (path) => canonicalWatchPath(resolve2(this.#cwd, path))
+    );
     this.#buildArtifacts = buildArtifacts;
     this.#discoverWatchPaths = discoverWatchPaths;
     this.#buildOptions = {
@@ -441,6 +1242,7 @@ var TileflowArtifactSessionImpl = class {
       // Trusted shared Icon Set resolution settings, supplied once by the owning command.
       ...options.icons ? { icons: options.icons } : {},
       inspection: options.inspection,
+      ...options.renderer === void 0 ? {} : { renderer: options.renderer },
       styleBaseUrl: options.styleBaseUrl,
       target: options.target
     };
@@ -448,7 +1250,7 @@ var TileflowArtifactSessionImpl = class {
   async start() {
     if (this.#watchEnabled) {
       this.#watcher = watch(dirname(this.#configPath), {
-        awaitWriteFinish: { pollInterval: 20, stabilityThreshold: 50 },
+        awaitWriteFinish: { pollInterval: 20, stabilityThreshold: writeStabilityMs },
         followSymlinks: false,
         ignoreInitial: true,
         ignored: (path, stats) => this.#ignoreWatchPath(path, stats?.isDirectory()),
@@ -476,6 +1278,22 @@ var TileflowArtifactSessionImpl = class {
         if (!this.#shouldRefreshForWatchEvent(path)) return;
         this.#scheduleRefresh(path);
       });
+      this.#watcher.on("raw", (event, path, details) => {
+        if (event !== "rename" && event !== "change") return;
+        const resolvedPath = resolveRawWatchPath(path, details);
+        if (!resolvedPath || this.#ignoreWatchPath(resolvedPath, void 0)) return;
+        const directoryChanged = this.#watchedArtifactDirectories.has(resolvedPath);
+        const metadataChanged = event === "rename" && basename2(resolvedPath) === tileflowIconMetadataFileName && [...this.#watchedArtifactDirectories.keys()].some(
+          (directory) => isSameOrInside(directory, resolvedPath)
+        );
+        if (!directoryChanged && !metadataChanged) return;
+        if (directoryChanged && event === "change") {
+          const modified = directoryModificationTime(resolvedPath);
+          if (modified === this.#watchedArtifactDirectories.get(resolvedPath)) return;
+          this.#watchedArtifactDirectories.set(resolvedPath, modified);
+        }
+        this.#scheduleRefresh(resolvedPath);
+      });
       this.#watcher.on("error", (error) => {
         if (this.#closed) return;
         this.#refreshToken += 1;
@@ -484,6 +1302,19 @@ var TileflowArtifactSessionImpl = class {
       await watcherReady;
     }
     await this.refresh("initial");
+    if (this.#watcher && !this.#closed) {
+      this.#startupCheckTimer = setTimeout(() => {
+        this.#startupCheckTimer = void 0;
+        if (this.#closed) return;
+        for (const [path, observed] of this.#watchedArtifactDirectories) {
+          if (this.#ignoreWatchPath(path, true)) continue;
+          const modified = directoryModificationTime(path);
+          if (modified === observed) continue;
+          this.#watchedArtifactDirectories.set(path, modified);
+          this.#scheduleRefresh(path);
+        }
+      }, writeStabilityMs);
+    }
   }
   getState() {
     return this.#state;
@@ -577,6 +1408,7 @@ var TileflowArtifactSessionImpl = class {
     this.#closed = true;
     this.#refreshToken += 1;
     if (this.#debounceTimer) clearTimeout(this.#debounceTimer);
+    if (this.#startupCheckTimer) clearTimeout(this.#startupCheckTimer);
     this.#listeners.clear();
     await this.#watcher?.close();
     const retained = [...this.#artifactGenerations];
@@ -589,7 +1421,7 @@ var TileflowArtifactSessionImpl = class {
     await Promise.all(retained.map((generation) => generation.completion));
   }
   #ignoreWatchPath(path, isDirectory) {
-    const resolvedPath = resolve2(path);
+    const resolvedPath = canonicalWatchPath(path);
     const relativePath = relative(dirname(this.#configPath), resolvedPath);
     const segments = relativePath.split(sep).filter(Boolean);
     if (this.#ignoredPaths.some((path2) => isSameOrInside(path2, resolvedPath))) return true;
@@ -603,7 +1435,7 @@ var TileflowArtifactSessionImpl = class {
     return true;
   }
   #shouldRefreshForWatchEvent(path) {
-    const resolvedPath = resolve2(path);
+    const resolvedPath = canonicalWatchPath(path);
     const extension = extname(resolvedPath).toLowerCase();
     if (!iconExtensions.has(extension) && !fontExtensions.has(extension)) return true;
     return [...this.#watchedArtifactPaths].some((path2) => isSameOrInside(path2, resolvedPath));
@@ -631,9 +1463,20 @@ var TileflowArtifactSessionImpl = class {
   }
   #updateArtifactWatchPaths(paths) {
     if (!this.#watcher) return;
-    const next = new Set(paths.map((path) => resolve2(this.#cwd, path)));
+    const next = new Set(paths.map((path) => canonicalWatchPath(resolve2(this.#cwd, path))));
     const previous = this.#watchedArtifactPaths;
     this.#watchedArtifactPaths = next;
+    const previousDirectories = this.#watchedArtifactDirectories;
+    this.#watchedArtifactDirectories = /* @__PURE__ */ new Map();
+    for (const path of next) {
+      const modified = directoryModificationTime(path);
+      if (modified !== void 0) {
+        this.#watchedArtifactDirectories.set(
+          path,
+          previousDirectories.has(path) ? previousDirectories.get(path) : modified
+        );
+      }
+    }
     for (const path of previous) {
       if (!next.has(path) && !isSameOrInside(dirname(this.#configPath), path)) {
         void this.#watcher.unwatch(path);
@@ -688,7 +1531,41 @@ function isSameOrInside(root, candidate) {
   const path = relative(resolve2(root), resolve2(candidate));
   return path === "" || !isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`);
 }
+function directoryModificationTime(path) {
+  try {
+    const stats = statSync(path);
+    return stats.isDirectory() ? stats.mtimeMs : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveRawWatchPath(path, details) {
+  if (typeof path !== "string" || !path) return void 0;
+  if (isAbsolute(path)) return canonicalWatchPath(path);
+  if (!details || typeof details !== "object") return void 0;
+  const watchedPath = details.watchedPath;
+  if (typeof watchedPath !== "string" || !isAbsolute(watchedPath)) return void 0;
+  return canonicalWatchPath(
+    basename2(watchedPath) === path ? watchedPath : resolve2(watchedPath, path)
+  );
+}
+function canonicalWatchPath(path) {
+  const resolved = resolve2(path);
+  let ancestor = resolved;
+  while (true) {
+    try {
+      return resolve2(realpathSync.native(ancestor), relative(ancestor, resolved));
+    } catch {
+      const parent = dirname(ancestor);
+      if (parent === ancestor) return resolved;
+      ancestor = parent;
+    }
+  }
+}
 function createTileflowArtifactDiagnostics(error, cwd) {
+  if (error instanceof TileflowNativeCompatibilityError2) {
+    return error.issues.map((issue) => ({ ...issue }));
+  }
   const inheritedCode = optionalDiagnosticField(error, "code");
   const inheritedPath = optionalDiagnosticPath(error);
   const inheritedPhase = optionalDiagnosticField(error, "phase") ?? optionalNestedDiagnosticField(error, "phase");
@@ -719,8 +1596,8 @@ function createTileflowArtifactDiagnostics(error, cwd) {
 function getIssueList(error) {
   if (!error || typeof error !== "object") return [];
   const containers = [];
-  for (const key of ["messages", "issues"]) {
-    const value = error[key];
+  for (const key2 of ["messages", "issues"]) {
+    const value = error[key2];
     if (Array.isArray(value)) containers.push(value);
   }
   const details = error.details;
@@ -811,14 +1688,14 @@ function normalizeDiagnostics(diagnostics) {
     (diagnostic, index) => index === 0 || JSON.stringify(diagnostic) !== JSON.stringify(bounded[index - 1])
   ).slice(0, 32);
 }
-function optionalDiagnosticField(value, key) {
+function optionalDiagnosticField(value, key2) {
   if (!value || typeof value !== "object") return void 0;
-  const field = value[key];
+  const field = value[key2];
   return typeof field === "string" && field.trim() ? boundDiagnosticField(field) : void 0;
 }
-function optionalNestedDiagnosticField(value, key) {
+function optionalNestedDiagnosticField(value, key2) {
   if (!value || typeof value !== "object") return void 0;
-  return optionalDiagnosticField(value.details, key);
+  return optionalDiagnosticField(value.details, key2);
 }
 function boundDiagnosticField(value) {
   return boundDiagnosticText(value.replace(/[^A-Za-z0-9_-]/g, ""), 64);
@@ -827,6 +1704,213 @@ function boundDiagnosticText(value, limit) {
   return value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
 }
 
+// src/hosted-native-artifacts.ts
+import { createHash as createHash2 } from "crypto";
+import { serializeCanonicalJson as serializeCanonicalJson3 } from "@tileflow/core";
+import {
+  inferTileflowDataRequirements,
+  inferTileflowSourceRequirements,
+  parseTileflowRendererDeploymentArtifact
+} from "@tileflow/core/build";
+import {
+  createTileflowNativeBuildRecord,
+  TileflowNativeCompatibilityError as TileflowNativeCompatibilityError4,
+  createTileflowNativeDiagnostic as createTileflowNativeDiagnostic3
+} from "@tileflow/core/native-profile";
+
+// src/native-hosted-provenance.ts
+import { serializeCanonicalJson as serializeCanonicalJson2 } from "@tileflow/core";
+import {
+  createTileflowNativeDiagnostic as createTileflowNativeDiagnostic2,
+  TileflowNativeCompatibilityError as TileflowNativeCompatibilityError3
+} from "@tileflow/core/native-profile";
+var overlayKeys = [
+  "above-water",
+  "below-roads",
+  "above-roads",
+  "above-buildings",
+  "below-labels",
+  "above-labels"
+];
+function object2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error();
+  return value;
+}
+function identifier(layer) {
+  if (typeof layer.id !== "string" || !layer.id.length) throw new Error();
+  return layer.id;
+}
+function finalizeNativeHostedProvenance(input, lowered, changes) {
+  try {
+    const result = JSON.parse(serializeCanonicalJson2(lowered));
+    const originalIndexes = /* @__PURE__ */ new Map();
+    const finalIndexes = /* @__PURE__ */ new Map();
+    const starts = /* @__PURE__ */ new Map();
+    const transformed = /* @__PURE__ */ new Map();
+    let previous = -1;
+    for (const change of changes) {
+      if (!Number.isSafeInteger(change.inputLayer) || change.inputLayer <= previous || change.inputLayer >= input.layers.length || !Number.isSafeInteger(change.outputStart) || !Number.isSafeInteger(change.outputCount) || change.outputCount < 1 || change.outputCount > 32 || !Array.isArray(change.properties) || !["line-cap", "line-dasharray", "line-cap,line-dasharray"].includes(
+        change.properties.join(",")
+      ))
+        throw new Error();
+      previous = change.inputLayer;
+      transformed.set(change.inputLayer, change);
+    }
+    for (const [index, layer] of result.layers.entries()) {
+      const id = identifier(layer);
+      if (finalIndexes.has(id)) throw new Error();
+      finalIndexes.set(id, index);
+    }
+    let offset = 0;
+    for (const [index, layer] of input.layers.entries()) {
+      const id = identifier(layer);
+      if (originalIndexes.has(id)) throw new Error();
+      originalIndexes.set(id, index);
+      starts.set(id, offset);
+      const change = transformed.get(index);
+      if (change && (change.outputStart !== offset || layer.type !== "line")) throw new Error();
+      const count = change?.outputCount ?? 1;
+      if (offset + count > result.layers.length) throw new Error();
+      for (let branch = 0; branch < count; branch++) {
+        const candidate = result.layers[offset + branch];
+        if (!change && identifier(candidate) !== id) throw new Error();
+        if (candidate.type !== layer.type || candidate.source !== layer.source || candidate["source-layer"] !== layer["source-layer"])
+          throw new Error();
+      }
+      offset += count;
+    }
+    if (offset !== result.layers.length) throw new Error();
+    const metadata = result.metadata === void 0 ? void 0 : object2(result.metadata);
+    const originalMetadata = input.metadata === void 0 ? void 0 : object2(input.metadata);
+    if (originalMetadata?.["tileflow:overlay-placement-manifest"] !== void 0) {
+      if (!metadata) throw new Error();
+      const overlay = object2(originalMetadata["tileflow:overlay-placement-manifest"]);
+      const anchors = object2(overlay.anchors);
+      if (overlay.schemaVersion !== 1 || Object.keys(anchors).length !== overlayKeys.length || overlayKeys.some((key2) => !Object.hasOwn(anchors, key2)))
+        throw new Error();
+      const updated = {};
+      for (const key2 of overlayKeys) {
+        const anchor = anchors[key2];
+        if (anchor === null) {
+          updated[key2] = null;
+          continue;
+        }
+        if (typeof anchor !== "string" || !starts.has(anchor)) throw new Error();
+        updated[key2] = identifier(result.layers[starts.get(anchor)]);
+      }
+      metadata["tileflow:overlay-placement-manifest"] = { ...overlay, anchors: updated };
+    }
+    if (originalMetadata?.["tileflow:interaction-manifest"] !== void 0) {
+      if (!metadata) throw new Error();
+      const manifest = object2(
+        JSON.parse(serializeCanonicalJson2(originalMetadata["tileflow:interaction-manifest"]))
+      );
+      if (manifest.version !== 2) throw new Error();
+      const domains = object2(manifest.domains);
+      if (domains.poi !== void 0) {
+        const poi = object2(domains.poi);
+        if (!Array.isArray(poi.layers) || poi.layers.length > 256) throw new Error();
+        const seen = /* @__PURE__ */ new Set();
+        poi.layers = poi.layers.map((value) => {
+          const entry = object2(value);
+          if (typeof entry.layerId !== "string" || seen.has(entry.layerId)) throw new Error();
+          const index = originalIndexes.get(entry.layerId);
+          if (index === void 0 || index !== entry.priority || transformed.has(index) || !finalIndexes.has(entry.layerId))
+            throw new Error();
+          const original = input.layers[index];
+          if (original.source !== entry.source || original["source-layer"] !== entry.sourceLayer)
+            throw new Error();
+          seen.add(entry.layerId);
+          return { ...entry, priority: finalIndexes.get(entry.layerId) };
+        });
+      }
+      metadata["tileflow:interaction-manifest"] = manifest;
+    }
+    return result;
+  } catch {
+    throw new TileflowNativeCompatibilityError3([
+      createTileflowNativeDiagnostic2("NATIVE_UNSUPPORTED_STYLE", "/metadata")
+    ]);
+  }
+}
+
+// src/hosted-native-artifacts.ts
+var digest = (value) => createHash2("sha256").update(serializeCanonicalJson3(value)).digest("hex");
+var invalidSource = () => new TileflowNativeCompatibilityError4([
+  createTileflowNativeDiagnostic3("NATIVE_UNSUPPORTED_SOURCE", "/sources")
+]);
+async function prepareTileflowHostedNativeDeployment(input) {
+  const webStyles = JSON.parse(serializeCanonicalJson3(input.styles));
+  const validationStyles = JSON.parse(
+    serializeCanonicalJson3(webStyles)
+  );
+  for (const style of Object.values(validationStyles)) {
+    for (const [sourceId, binding] of Object.entries(input.teamSources)) {
+      const source = style.sources[sourceId];
+      if (!source || source.type !== binding.type || source.url !== `tileflow://hosted-sources/${sourceId}` || source.tiles !== void 0)
+        throw invalidSource();
+      source.url = `https://artifacts.invalid/tiles/${sourceId}/tiles.json`;
+    }
+  }
+  const lowered = lowerTileflowNativeCompiledStyles({ [input.mapId]: validationStyles });
+  for (const transformation of lowered.transformations) {
+    const name = transformation.theme;
+    lowered.styles[input.mapId][name] = finalizeNativeHostedProvenance(
+      validationStyles[name],
+      lowered.styles[input.mapId][name],
+      transformation.layers
+    );
+  }
+  const projected = prepareTileflowNativeStyles(lowered.styles, input.assets)[input.mapId];
+  for (const [name, style] of Object.entries(projected)) {
+    for (const sourceId of Object.keys(input.teamSources)) {
+      const source = style.sources[sourceId];
+      if (!source) throw invalidSource();
+      source.url = `tileflow://hosted-sources/${sourceId}`;
+    }
+    if (serializeCanonicalJson3(style.sources) !== serializeCanonicalJson3(webStyles[name].sources))
+      throw invalidSource();
+  }
+  const nativeBuild = JSON.parse(
+    serializeCanonicalJson3(input.buildManifest)
+  );
+  const mapBuild = nativeBuild.maps[input.mapId];
+  if (!mapBuild) throw invalidSource();
+  for (const [name, style] of Object.entries(projected)) {
+    const theme = mapBuild.themes[name];
+    if (!theme) throw invalidSource();
+    mapBuild.themes[name] = {
+      ...theme,
+      styleSha256: digest(style),
+      dataRequirements: inferTileflowDataRequirements(style),
+      sourceRequirements: inferTileflowSourceRequirements(style)
+    };
+  }
+  const transformations = lowered.transformations.map((item) => ({
+    ...item,
+    inputStyleSha256: digest(webStyles[item.theme]),
+    loweredStyleSha256: digest({
+      ...lowered.styles[input.mapId][item.theme],
+      sources: webStyles[item.theme].sources
+    })
+  }));
+  return parseTileflowRendererDeploymentArtifact({
+    kind: "tileflow-map-deployment",
+    schemaVersion: 2,
+    mapId: input.mapId,
+    teamSources: input.teamSources,
+    ...input.view ? { view: input.view } : {},
+    renderers: {
+      web: { buildManifest: input.buildManifest, styles: webStyles },
+      native: {
+        buildManifest: nativeBuild,
+        buildRecord: createTileflowNativeBuildRecord(digest(nativeBuild), transformations),
+        styles: projected
+      }
+    }
+  });
+}
+
 // src/artifacts.ts
 var tileflowArtifactPlanSchemaVersion = 1;
 var tileflowArtifactInventoryFileName = ".tileflow-artifacts.json";
@@ -905,31 +1989,50 @@ function assertValidTileflowStyles(project, styles) {
   }
 }
 async function createTileflowArtifactPlan(prepared, options = {}) {
-  if (options.target === "production" && hasLocalTilesetSources(prepared.project)) {
+  const renderer = resolveTileflowRenderer(options.renderer);
+  if (renderer === "native" && options.inspection) {
+    throw new TileflowNativeCompatibilityError5([
+      createTileflowNativeDiagnostic4("NATIVE_RENDERER_UNSUPPORTED", "/inspection")
+    ]);
+  }
+  if (renderer === "native") {
+    assertTileflowNativeCompiledStyles(prepared.project, {});
+  } else if (options.target === "production" && hasLocalTilesetSources(prepared.project)) {
     throw new TileflowLocalTilesetProductionError();
   }
   const inspected = options.inspection ? createTileflowStylesWithInspection(prepared.project, {
     apiBaseUrl: options.apiBaseUrl,
     mapAssets: prepared.mapAssets
   }) : void 0;
-  const compiledStyles = inspected?.styles ?? createTileflowStyles(prepared.project, {
+  const compileStyles = renderer === "native" ? createStylesFromCatalog : createTileflowStyles;
+  const compiledStyles = inspected?.styles ?? compileStyles(prepared.project, {
     apiBaseUrl: options.apiBaseUrl,
     mapAssets: prepared.mapAssets
   });
-  const localTilesets = await prepareTileflowLocalTilesets(prepared.project, compiledStyles, {
-    assetBaseUrl: resolveAssetBaseUrl(options),
+  const nativeLowering = renderer === "native" ? lowerTileflowNativeCompiledStyles(compiledStyles) : void 0;
+  const rendererStyles = nativeLowering?.styles ?? compiledStyles;
+  if (renderer === "native") assertTileflowNativeCompiledStyles(prepared.project, rendererStyles);
+  const localTilesets = await prepareTileflowLocalTilesets(prepared.project, rendererStyles, {
+    assetBaseUrl: resolveRendererAssetBaseUrl(options),
     baseDirectory: prepared.baseDirectory,
     cwd: prepared.cwd
   });
   try {
     const preparedFonts = await prepareTileflowStyleFonts(prepared.project, localTilesets.styles, {
-      assetBaseUrl: resolveAssetBaseUrl(options),
+      assetBaseUrl: resolveRendererAssetBaseUrl(options),
       baseDirectory: prepared.baseDirectory,
       cwd: prepared.cwd,
       target: "local"
+    }).catch((error) => {
+      if (renderer === "native" && error instanceof TileflowFontCompilationError) {
+        throw new TileflowNativeCompatibilityError5([
+          createTileflowNativeDiagnostic4("NATIVE_FONT_UNAVAILABLE", "/fonts")
+        ]);
+      }
+      throw error;
     });
-    const styles = preparedFonts.styles;
     const assets = [...prepared.assets, ...preparedFonts.assets];
+    const styles = renderer === "native" ? prepareTileflowNativeStyles(preparedFonts.styles, assets) : preparedFonts.styles;
     const provenance = await createTileflowBuildProvenance(prepared.cwd);
     const buildManifest = await createTileflowMapBuildManifest(
       Object.fromEntries(
@@ -960,7 +2063,9 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
       ),
       { provenance }
     );
-    const stableManifest = createFontAwareManifest(
+    const stableManifest = renderer === "native" ? createManifest(prepared.project, {
+      styleBaseUrl: nativePublicBase(options.styleBaseUrl ?? ".")
+    }) : createFontAwareManifest(
       createManifest(prepared.project, { styleBaseUrl: options.styleBaseUrl }),
       styles
     );
@@ -977,6 +2082,12 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
     const partial = {
       assets,
       buildManifest,
+      ...renderer === "native" ? {
+        nativeBuild: createTileflowNativeBuildRecord2(
+          hashBytes(serializeCanonicalJson4(buildManifest)),
+          nativeLowering.transformations
+        )
+      } : {},
       dispose: localTilesets.dispose,
       manifest: stableManifest,
       project: prepared.project,
@@ -986,7 +2097,8 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
       watchPaths: uniqueStrings([...inputs.files, ...inputs.directories])
     };
     const generation = hashArtifactGeneration(getStableTileflowArtifactFiles(partial));
-    const manifest = createGenerationManifest(stableManifest, generation, assets);
+    const generatedManifest = createGenerationManifest(stableManifest, generation, assets);
+    const manifest = renderer === "native" ? parseTileflowRuntimeManifest(generatedManifest) : generatedManifest;
     const generationArtifacts = { ...partial, manifest };
     return {
       ...generationArtifacts,
@@ -1002,6 +2114,7 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
   }
 }
 async function createTileflowBuildArtifacts(options = {}) {
+  resolveTileflowRenderer(options.renderer);
   const loaded = await loadValidTileflowConfigWithInputs(
     options.config ?? defaultTileflowConfigPath,
     {
@@ -1010,7 +2123,7 @@ async function createTileflowBuildArtifacts(options = {}) {
     }
   );
   const prepared = await prepareTileflowCatalogIcons(loaded.project, {
-    assetBaseUrl: resolveAssetBaseUrl(options),
+    assetBaseUrl: resolveRendererAssetBaseUrl(options),
     baseDirectory: dirname2(loaded.configFile),
     cwd: options.cwd ?? process.cwd(),
     ...options.icons ? { icons: options.icons } : {}
@@ -1028,7 +2141,7 @@ function getStableTileflowArtifactFiles(artifacts) {
     {
       contentType: "application/json; charset=utf-8",
       fileName: tileflowMapBuildManifestFileName,
-      source: `${serializeCanonicalJson(artifacts.buildManifest)}
+      source: `${serializeCanonicalJson4(artifacts.buildManifest)}
 `
     },
     {
@@ -1045,7 +2158,15 @@ function getStableTileflowArtifactFiles(artifacts) {
 `
       }))
     ),
-    ...artifacts.assets
+    ...artifacts.assets,
+    ...artifacts.nativeBuild ? [
+      {
+        contentType: "application/json; charset=utf-8",
+        fileName: tileflowNativeBuildRecordFileName,
+        source: `${serializeCanonicalJson4(artifacts.nativeBuild)}
+`
+      }
+    ] : []
   ];
   return validateArtifactFiles(files);
 }
@@ -1109,10 +2230,13 @@ function createGenerationArtifactFiles(artifacts, generation) {
         // Every theme in one logical map shares the same immutable sprite closure.
         sprite: isRelativePublicUrl(sprite) ? sprite : insertGenerationInPublicUrl(sprite, `icons/${mapName}/sprite`, generation)
       } : style;
-      const generationStyle = replaceTileflowStyleFontSources(
+      const replaceFontSources = artifacts.nativeBuild ? replaceTileflowNativeFontSources : replaceTileflowStyleFontSources;
+      const generationStyle = replaceFontSources(
         generationStyleWithSprite,
         (source) => retargetLocalFontAssetUrl(source, artifacts.assets, generation)
       );
+      if (artifacts.nativeBuild)
+        assertTileflowNativeGeneratedStyle(generationStyle, mapName, themeName);
       return {
         contentType: "application/json; charset=utf-8",
         fileName: `${prefix}/styles/${mapName}/${themeName}.json`,
@@ -1138,7 +2262,7 @@ function createFontAwareManifest(manifest, styles) {
             if (!style) {
               throw new Error(`Missing compiled Tileflow style for ${mapName}/${themeName}.`);
             }
-            const definitions = getTileflowStyleFontFaces(style);
+            const definitions = getTileflowStyleFontFaces2(style);
             return [themeName, { ...theme, fontFaces: definitions }];
           })
         )
@@ -1168,7 +2292,7 @@ function getMapBuildAssets(mapName, assets, fontAssets) {
   );
 }
 function hashBytes(source) {
-  return createHash("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
+  return createHash3("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
 }
 async function createTileflowBuildProvenance(cwd) {
   const projectDirectory = resolve3(cwd);
@@ -1303,7 +2427,8 @@ async function disposeTileflowBuildArtifacts(artifacts) {
 async function writeTileflowArtifactPlan(artifacts, options) {
   assertNoLocalTilesetsForProduction(artifacts);
   const cwd = options.cwd ?? process.cwd();
-  const output = await prepareTileflowOutputDirectory(cwd, options.outDir);
+  const outDir = artifacts.nativeBuild ? `${options.outDir.replace(/[\\/]$/u, "")}/native` : options.outDir;
+  const output = await prepareTileflowOutputDirectory(cwd, outDir);
   const files = getTileflowArtifactFiles(artifacts);
   await assertTileflowSelfHostedManifestTarget(resolve3(output.outDir, "manifest.json"), options);
   await commitTileflowArtifactFiles(output, files);
@@ -1590,7 +2715,7 @@ function assertTileflowArtifactFileName(fileName) {
   const logicalName = fileName.replace(/^generations\/[a-f0-9]{64}\//, "");
   const styleMatch = /^styles\/([^/]+)\/([^/]+)\.json$/u.exec(logicalName);
   const iconMatch = /^icons\/([^/]+)\/sprite(?:@2x)?\.(?:json|png)$/u.exec(logicalName);
-  if (fileName === "manifest.json" || fileName === tileflowMapBuildManifestFileName || styleMatch && tileflowMapIdSchema.safeParse(styleMatch[1]).success && tileflowThemeNameSchema.safeParse(styleMatch[2]).success || iconMatch && tileflowMapIdSchema.safeParse(iconMatch[1]).success || /^tilesets\/[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.pmtiles$/u.test(logicalName) || /^fonts\/[a-z0-9]+(?:-[a-z0-9]+)*-[a-f0-9]{64}\.(?:otf|ttf|woff2)$/.test(logicalName) || /^fonts\/licenses\/license-[a-f0-9]{64}\.txt$/.test(logicalName)) {
+  if (fileName === "manifest.json" || fileName === tileflowMapBuildManifestFileName || fileName === tileflowNativeBuildRecordFileName || styleMatch && tileflowMapIdSchema.safeParse(styleMatch[1]).success && tileflowThemeNameSchema.safeParse(styleMatch[2]).success || iconMatch && tileflowMapIdSchema.safeParse(iconMatch[1]).success || /^tilesets\/[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.pmtiles$/u.test(logicalName) || /^fonts\/[a-z0-9]+(?:-[a-z0-9]+)*-[a-f0-9]{64}\.(?:otf|ttf|woff2)$/.test(logicalName) || /^fonts\/licenses\/license-[a-f0-9]{64}\.txt$/.test(logicalName)) {
     return;
   }
   throw new Error(`Unexpected Tileflow managed artifact file name: ${fileName}`);
@@ -1630,7 +2755,7 @@ async function removeManagedFile(path) {
   }
 }
 function hashArtifactGeneration(files) {
-  const hash = createHash("sha256");
+  const hash = createHash3("sha256");
   for (const file of files) {
     const source = typeof file.source === "string" ? Buffer.from(file.source, "utf8") : Buffer.from(file.source);
     hash.update(`${file.fileName}\0${file.contentType}\0${source.byteLength}\0`, "utf8");
@@ -1638,6 +2763,13 @@ function hashArtifactGeneration(files) {
   }
   return hash.digest("hex");
 }
+function resolveRendererAssetBaseUrl(options) {
+  const base = resolveAssetBaseUrl(options);
+  return options.renderer === "native" ? nativePublicBase(base) : base;
+}
+function nativePublicBase(base) {
+  return isRelativePublicUrl(base) ? base : `${base.replace(/\/+$/u, "")}/native`;
+}
 function resolveAssetBaseUrl(options) {
   if (options.assetBaseUrl !== void 0) return options.assetBaseUrl;
   if (options.styleBaseUrl && !isRelativePublicUrl(options.styleBaseUrl)) {
@@ -1671,6 +2803,7 @@ export {
   prepareTileflowLocalTilesets,
   tileflowArtifactSessionSchemaVersion,
   createTileflowArtifactDiagnostics,
+  prepareTileflowHostedNativeDeployment,
   tileflowArtifactPlanSchemaVersion,
   tileflowArtifactInventoryFileName,
   TileflowHostedManifestOverwriteError,