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

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

@@ -28,26 +28,26 @@ import {
 } from "./chunk-D4OE4ITL.js";
 
 // src/artifacts.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { realpathSync as realpathSync2 } from "fs";
 import {
   copyFile as copyFile2,
-  lstat as lstat2,
-  mkdir as mkdir2,
+  lstat as lstat3,
+  mkdir as mkdir3,
   mkdtemp,
   open as open2,
-  readFile,
+  readFile as readFile2,
   realpath as realpath2,
-  rename,
-  rm as rm2,
+  rename as rename2,
+  rm as rm3,
   unlink
 } from "fs/promises";
 import { createRequire } from "module";
-import { dirname as dirname2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+import { dirname as dirname2, relative as relative2, resolve as resolve4, sep as sep2 } from "path";
 import {
   compareCodeUnits as compareCodeUnits2,
   getTileflowStyleFontFaces as getTileflowStyleFontFaces2,
-  serializeCanonicalJson as serializeCanonicalJson4,
+  serializeCanonicalJson as serializeCanonicalJson3,
   tileflowMapIdSchema,
   tileflowThemeNameSchema
 } from "@tileflow/core";
@@ -62,17 +62,200 @@ import {
 import { parseTileflowRuntimeManifest } from "@tileflow/core/manifest";
 import {
   createTileflowNativeBuildRecord as createTileflowNativeBuildRecord2,
-  createTileflowNativeDiagnostic as createTileflowNativeDiagnostic4,
+  createTileflowNativeDiagnostic as createTileflowNativeDiagnostic3,
   resolveTileflowRenderer,
   tileflowNativeBuildRecordFileName,
-  TileflowNativeCompatibilityError as TileflowNativeCompatibilityError5
+  TileflowNativeCompatibilityError as TileflowNativeCompatibilityError4
 } from "@tileflow/core/native-profile";
 
+// src/line-background-glyphs.ts
+import { createHash, randomUUID } from "crypto";
+import { lstat, mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { resolve } from "path";
+import {
+  deriveTileflowLineBackgroundGlyphs,
+  parseTileflowLineBackgroundFontStack
+} from "@tileflow/core";
+var tileflowLineBackgroundGlyphRoute = "__glyphs";
+var RANGE = /^\d{1,6}-\d{1,6}$/u;
+var FONT_STACK = /^[\p{L}\p{N} _.,-]{1,256}$/u;
+var MAP_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+var MAX_RANGE_BYTES = 8 * 1024 * 1024;
+var MAX_DERIVED_ENTRIES = 512;
+var CACHE_SEGMENTS = [".tileflow", "cache", "glyphs", "v1"];
+function usesTileflowLineBackgroundGlyphs(style) {
+  return style.layers.some((layer) => {
+    const layout = layer.layout;
+    const font = layout?.["text-font"];
+    return Array.isArray(font) && font.length === 1 && typeof font[0] === "string" && parseTileflowLineBackgroundFontStack(font[0]) !== void 0;
+  });
+}
+function prepareTileflowLineBackgroundGlyphs(styles, options) {
+  const base = absoluteHttpUrl(options.assetBaseUrl);
+  if (!base) return { providers: {}, styles };
+  const providers = {};
+  const output = {};
+  for (const [mapName, themes] of Object.entries(styles)) {
+    const family = Object.values(themes);
+    const upstream = family.find((style) => typeof style.glyphs === "string")?.glyphs;
+    if (!MAP_NAME.test(mapName) || !upstream || !absoluteHttpUrl(upstream) || !family.some(usesTileflowLineBackgroundGlyphs) || family.some((style) => style.glyphs !== upstream)) {
+      output[mapName] = themes;
+      continue;
+    }
+    providers[mapName] = upstream;
+    const glyphs = `${base.replace(/\/+$/u, "")}/${tileflowLineBackgroundGlyphRoute}/${mapName}/{fontstack}/{range}.pbf`;
+    output[mapName] = Object.fromEntries(
+      Object.entries(themes).map(([themeName, style]) => [themeName, { ...style, glyphs }])
+    );
+  }
+  return { providers, styles: output };
+}
+function parseTileflowLineBackgroundGlyphPath(path) {
+  const match = /^\/__glyphs\/([^/]+)\/([^/]+)\/([^/]+)\.pbf$/u.exec(path);
+  if (!match) return void 0;
+  let fontStack;
+  try {
+    fontStack = decodeURIComponent(match[2]);
+  } catch {
+    return void 0;
+  }
+  if (!MAP_NAME.test(match[1]) || !FONT_STACK.test(fontStack) || !RANGE.test(match[3])) {
+    return void 0;
+  }
+  return { fontStack, mapName: match[1], range: match[3] };
+}
+function createTileflowLineBackgroundGlyphResponder(options) {
+  const fetchRange = options.fetch ?? globalThis.fetch;
+  const derived = /* @__PURE__ */ new Map();
+  const upstreamRanges = /* @__PURE__ */ new Map();
+  const readUpstream = (upstream, fontStack, range) => {
+    const key2 = `${upstream}
+${fontStack}
+${range}`;
+    let pending = upstreamRanges.get(key2);
+    if (!pending) {
+      pending = loadUpstreamRange(options.cwd, fetchRange, upstream, fontStack, range).finally(
+        () => upstreamRanges.delete(key2)
+      );
+      upstreamRanges.set(key2, pending);
+    }
+    return pending;
+  };
+  return async (upstream, fontStack, range) => {
+    if (!absoluteHttpUrl(upstream) || !FONT_STACK.test(fontStack) || !RANGE.test(range)) {
+      return notFound();
+    }
+    const backed = parseTileflowLineBackgroundFontStack(fontStack);
+    if (!backed) {
+      if (fontStack.split(",").some((stack) => parseTileflowLineBackgroundFontStack(stack))) {
+        return notFound();
+      }
+      return glyphResponse(await readUpstream(upstream, fontStack, range));
+    }
+    const key2 = `${upstream}
+${fontStack}
+${range}`;
+    let pending = derived.get(key2);
+    if (!pending) {
+      pending = readUpstream(upstream, backed.source, range).then(
+        (source) => source ? deriveTileflowLineBackgroundGlyphs(source, backed.metrics) : void 0
+      );
+      pending.catch(() => derived.delete(key2));
+      derived.set(key2, pending);
+      if (derived.size > MAX_DERIVED_ENTRIES) derived.delete(derived.keys().next().value);
+    }
+    return glyphResponse(await pending);
+  };
+}
+async function loadUpstreamRange(cwd, fetchRange, upstream, fontStack, range) {
+  const directory = await cacheDirectory(cwd, upstream);
+  const file = resolve(directory, `${digest(fontStack)}-${range}.pbf`);
+  const cached = await readFile(file).catch((error) => {
+    if (hasCode(error, "ENOENT")) return void 0;
+    throw error;
+  });
+  if (cached) return new Uint8Array(cached);
+  const url = upstream.replace("{fontstack}", encodeURIComponent(fontStack)).replace("{range}", range);
+  const response = await fetchRange(url, {
+    credentials: "omit",
+    headers: { Accept: "application/x-protobuf" },
+    redirect: "error",
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (response.status === 404) return void 0;
+  if (response.status !== 200) {
+    throw new Error(`Glyph provider responded ${response.status} for ${fontStack} ${range}.`);
+  }
+  const length = Number(response.headers.get("content-length") ?? 0);
+  if (length > MAX_RANGE_BYTES) throw new Error(`Glyph range ${range} exceeds the size limit.`);
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  if (bytes.byteLength > MAX_RANGE_BYTES)
+    throw new Error(`Glyph range ${range} exceeds the size limit.`);
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, bytes, { flag: "wx" });
+    await rename(temporary, file);
+  } catch {
+    await rm(temporary, { force: true }).catch(() => void 0);
+  }
+  return bytes;
+}
+async function cacheDirectory(cwd, upstream) {
+  let current = resolve(cwd);
+  for (const segment of [...CACHE_SEGMENTS, digest(upstream)]) {
+    current = resolve(current, segment);
+    try {
+      const stats = await lstat(current);
+      if (!stats.isDirectory() || stats.isSymbolicLink()) {
+        throw new Error(`Glyph cache path is unsafe: ${current}`);
+      }
+    } catch (error) {
+      if (!hasCode(error, "ENOENT")) throw error;
+      await mkdir(current).catch((mkdirError) => {
+        if (!hasCode(mkdirError, "EEXIST")) throw mkdirError;
+      });
+    }
+  }
+  return current;
+}
+function glyphResponse(bytes) {
+  if (!bytes) return notFound();
+  return new Response(new Uint8Array(bytes), {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "no-cache",
+      "Content-Type": "application/x-protobuf"
+    },
+    status: 200
+  });
+}
+function notFound() {
+  return new Response(JSON.stringify({ error: "Unknown glyph range." }), {
+    headers: { "Content-Type": "application/json; charset=utf-8" },
+    status: 404
+  });
+}
+function absoluteHttpUrl(value) {
+  if (!value) return void 0;
+  try {
+    const url = new URL(value.replace("{fontstack}", "stack").replace("{range}", "0-255"));
+    return url.protocol === "http:" || url.protocol === "https:" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function digest(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+function hasCode(error, code) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
+}
+
 // src/local-tilesets.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { constants } from "fs";
-import { chmod, copyFile, lstat, mkdir, open, readdir, realpath, rm, stat } from "fs/promises";
-import { basename, resolve } from "path";
+import { chmod, copyFile, lstat as lstat2, mkdir as mkdir2, open, readdir, realpath, rm as rm2, stat } from "fs/promises";
+import { basename, resolve as resolve2 } from "path";
 import { compareCodeUnits } from "@tileflow/core";
 var minimumLocalPmtilesBytes = 127n;
 var maximumLocalPmtilesBytes = 8000000000n;
@@ -83,14 +266,14 @@ async function prepareTileflowLocalTilesets(project, styles, options) {
   if (!hasSources) {
     return { dispose: async () => void 0, files: [], styles, watchPaths: [] };
   }
-  const logicalProjectRoot = resolve(options.cwd);
+  const logicalProjectRoot = resolve2(options.cwd);
   const projectRoot = await realpath(logicalProjectRoot).catch(() => logicalProjectRoot);
-  const snapshotStore = resolve(logicalProjectRoot, ".tileflow/cache/pmtiles-snapshots/v1");
+  const snapshotStore = resolve2(logicalProjectRoot, ".tileflow/cache/pmtiles-snapshots/v1");
   await assertSafeSnapshotStore(logicalProjectRoot, snapshotStore);
   await collectAbandonedSnapshotGenerations(snapshotStore);
-  const generationId = `snapshot-${process.pid}-${randomUUID().replaceAll("-", "")}`;
-  const generationDirectory = resolve(snapshotStore, generationId);
-  await mkdir(generationDirectory);
+  const generationId = `snapshot-${process.pid}-${randomUUID2().replaceAll("-", "")}`;
+  const generationDirectory = resolve2(snapshotStore, generationId);
+  await mkdir2(generationDirectory);
   const bindings = /* @__PURE__ */ new Map();
   const files = /* @__PURE__ */ new Map();
   const snapshots = /* @__PURE__ */ new Map();
@@ -109,7 +292,7 @@ async function prepareTileflowLocalTilesets(project, styles, options) {
     if (!isPathWithin(snapshotStore, generationDirectory)) {
       throw new Error("Local PMTiles snapshot generation escaped its store.");
     }
-    await rm(generationDirectory, { force: true, recursive: true });
+    await rm2(generationDirectory, { force: true, recursive: true });
   };
   try {
     for (const mapName of Object.keys(project.maps).sort(compareCodeUnits)) {
@@ -117,7 +300,7 @@ async function prepareTileflowLocalTilesets(project, styles, options) {
       for (const [sourceId, source] of Object.entries(map.sources ?? {}).sort(
         ([left], [right]) => compareCodeUnits(left, right)
       )) {
-        const requestedPath = resolve(options.baseDirectory, source.local);
+        const requestedPath = resolve2(options.baseDirectory, source.local);
         const sourcePath = await realpath(requestedPath).catch(() => requestedPath);
         if (!isPathWithin(projectRoot, sourcePath)) {
           throw localTilesetError(
@@ -126,7 +309,7 @@ async function prepareTileflowLocalTilesets(project, styles, options) {
             "Local hosted tileset must stay inside the project root."
           );
         }
-        const sourceStat = await lstat(sourcePath).catch(() => null);
+        const sourceStat = await lstat2(sourcePath).catch(() => null);
         if (!sourceStat?.isFile() || sourceStat.isSymbolicLink()) {
           throw localTilesetError(
             "TF_LOCAL_TILESET_NOT_FOUND",
@@ -197,7 +380,7 @@ async function prepareTileflowLocalTilesets(project, styles, options) {
 }
 async function createLocalTilesetSnapshot(sourcePath, generationDirectory, index) {
   const sourceHandle = await open(sourcePath, "r");
-  const snapshotPath = resolve(generationDirectory, `${index}.pmtiles`);
+  const snapshotPath = resolve2(generationDirectory, `${index}.pmtiles`);
   try {
     const before = sourceIdentity(await sourceHandle.stat({ bigint: true }));
     if (before.size < minimumLocalPmtilesBytes || before.size > maximumLocalPmtilesBytes) {
@@ -325,32 +508,32 @@ async function collectAbandonedSnapshotGenerations(store) {
     if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
     const match = /^snapshot-(\d+)-[a-f0-9]{32}$/u.exec(entry.name);
     if (!match?.[1] || processIsAlive(Number(match[1]))) continue;
-    const path = resolve(store, entry.name);
-    if (isPathWithin(store, path)) await rm(path, { force: true, recursive: true });
+    const path = resolve2(store, entry.name);
+    if (isPathWithin(store, path)) await rm2(path, { force: true, recursive: true });
   }
 }
 async function assertSafeSnapshotStore(projectRoot, store) {
   const segments = [".tileflow", "cache", "pmtiles-snapshots", "v1"];
   let current = projectRoot;
   for (const segment of segments) {
-    current = resolve(current, segment);
+    current = resolve2(current, segment);
     try {
-      const value = await lstat(current);
+      const value = await lstat2(current);
       if (!value.isDirectory() || value.isSymbolicLink()) {
         throw new Error(`Local PMTiles snapshot path is unsafe: ${current}`);
       }
     } catch (error) {
       if (!hasErrorCode(error, "ENOENT")) throw error;
-      await mkdir(current).catch((mkdirError) => {
+      await mkdir2(current).catch((mkdirError) => {
         if (!hasErrorCode(mkdirError, "EEXIST")) throw mkdirError;
       });
-      const created = await lstat(current);
+      const created = await lstat2(current);
       if (!created.isDirectory() || created.isSymbolicLink()) {
         throw new Error(`Local PMTiles snapshot path is unsafe: ${current}`);
       }
     }
   }
-  if (resolve(current) !== resolve(store)) {
+  if (resolve2(current) !== resolve2(store)) {
     throw new Error("Local PMTiles snapshot path escaped its project root.");
   }
 }
@@ -384,7 +567,7 @@ function hasErrorCode(error, code) {
 }
 
 // src/native-artifacts.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import {
   convertFilter,
   validateStyleMin
@@ -404,6 +587,114 @@ import {
   validateTileflowNativePreparedStyle
 } from "@tileflow/core/native-profile";
 
+// src/native-layer-references.ts
+var overlayKeys = [
+  "above-water",
+  "below-roads",
+  "above-roads",
+  "above-buildings",
+  "below-labels",
+  "above-labels"
+];
+function object(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 rebindNativeLayerReferences(input, lowered, changes) {
+  try {
+    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 lowered.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 > lowered.layers.length) throw new Error();
+      for (let branch = 0; branch < count; branch++) {
+        const candidate = lowered.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 !== lowered.layers.length) throw new Error();
+    const metadata = lowered.metadata === void 0 ? void 0 : { ...object(lowered.metadata) };
+    const originalMetadata = input.metadata === void 0 ? void 0 : object(input.metadata);
+    if (originalMetadata?.["tileflow:overlay-placement-manifest"] !== void 0) {
+      if (!metadata) throw new Error();
+      const overlay = object(originalMetadata["tileflow:overlay-placement-manifest"]);
+      const anchors = object(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(lowered.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 = object(originalMetadata["tileflow:interaction-manifest"]);
+      if (manifest.version !== 2) throw new Error();
+      const domains = object(manifest.domains);
+      let rebound = manifest;
+      if (domains.poi !== void 0) {
+        const poi = object(domains.poi);
+        if (!Array.isArray(poi.layers) || poi.layers.length > 256) throw new Error();
+        const seen = /* @__PURE__ */ new Set();
+        const layers = poi.layers.map((value) => {
+          const entry = object(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) };
+        });
+        rebound = { ...manifest, domains: { ...domains, poi: { ...poi, layers } } };
+      }
+      metadata["tileflow:interaction-manifest"] = rebound;
+    }
+    return metadata === void 0 ? { ...lowered } : { ...lowered, metadata };
+  } catch {
+    return void 0;
+  }
+}
+
 // src/native-lowering.ts
 var nativeLoweringLimits = Object.freeze({
   maximumDecisionDepth: 16,
@@ -430,7 +721,7 @@ var NativeLoweringError = class extends Error {
 function fail(path, reason = "shape") {
   throw new NativeLoweringError(path, reason);
 }
-function object(value) {
+function object2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function operation(value, name, length) {
@@ -871,21 +1162,21 @@ function lowerNativeStyleRepresentation(input, normalizeFilter = (filter) => fil
   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))
+    if (!object2(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))
+    if (!object2(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");
+    const source = object2(input.sources) && typeof layer.source === "string" ? input.sources[layer.source] : void 0;
+    const lowered = lowerLayer(layer, index, object2(source) && source.type === "vector");
     if (!lowered) {
       layers.push(layer);
       continue;
@@ -933,11 +1224,17 @@ function lowerNativeStyleRepresentation(input, normalizeFilter = (filter) => fil
 function documentUrl(map, theme) {
   return `https://artifacts.invalid/native/styles/${map}/${theme}.json`;
 }
+function urlOptions(map, theme, policy) {
+  return {
+    documentUrl: documentUrl(map, theme),
+    ...policy.developmentOrigin === void 0 ? {} : { developmentOrigin: policy.developmentOrigin }
+  };
+}
 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) {
+function lowerTileflowNativeCompiledStyles(input, policy = {}) {
   const styles = {};
   const transformations = [];
   for (const map of Object.keys(input).sort()) {
@@ -945,7 +1242,7 @@ function lowerTileflowNativeCompiledStyles(input) {
     for (const theme of Object.keys(input[map]).sort()) {
       const original = input[map][theme];
       try {
-        const options = { documentUrl: documentUrl(map, theme), deferFontClosure: true };
+        const options = { ...urlOptions(map, theme, policy), 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))
@@ -973,17 +1270,34 @@ function lowerTileflowNativeCompiledStyles(input) {
           original,
           (filter) => convertFilter(structuredClone(filter))
         );
-        const issues = validateTileflowNativePreparedStyle(lowered.style, options);
+        const style = rebindNativeLayerReferences(
+          original,
+          lowered.style,
+          lowered.layers
+        );
+        if (!style)
+          throw new TileflowNativeCompatibilityError([
+            withContext(
+              {
+                ...createTileflowNativeDiagnostic("NATIVE_UNSUPPORTED_STYLE", "/metadata"),
+                message: "Tileflow POI interaction or overlay placement metadata does not match the compiled layers.",
+                suggestion: "Rebuild with the Tileflow compiler; native lowering only rebinds POI priorities and overlay anchors that match the compiled layer order."
+              },
+              map,
+              theme
+            )
+          ]);
+        const issues = validateTileflowNativePreparedStyle(style, options);
         if (issues.length)
           throw new TileflowNativeCompatibilityError(
             issues.map((issue) => withContext(issue, map, theme))
           );
-        styles[map][theme] = lowered.style;
+        styles[map][theme] = style;
         transformations.push({
           map,
           theme,
-          inputStyleSha256: createHash("sha256").update(serializeCanonicalJson(original)).digest("hex"),
-          loweredStyleSha256: createHash("sha256").update(serializeCanonicalJson(lowered.style)).digest("hex"),
+          inputStyleSha256: createHash2("sha256").update(serializeCanonicalJson(original)).digest("hex"),
+          loweredStyleSha256: createHash2("sha256").update(serializeCanonicalJson(style)).digest("hex"),
           inputLayers: lowered.inputLayers,
           outputLayers: lowered.outputLayers,
           projection: lowered.projection,
@@ -1007,13 +1321,13 @@ function lowerTileflowNativeCompiledStyles(input) {
   }
   return { styles, transformations };
 }
-function assertTileflowNativeCompiledStyles(project, styles) {
+function assertTileflowNativeCompiledStyles(project, styles, policy = {}) {
   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),
+          ...urlOptions(mapName, theme, policy),
           deferFontClosure: true
         }).map((issue) => withContext(issue, mapName, theme))
       );
@@ -1021,7 +1335,7 @@ function assertTileflowNativeCompiledStyles(project, styles) {
   }
   if (issues.length) throw new TileflowNativeCompatibilityError(issues);
 }
-function prepareTileflowNativeStyles(input, assets) {
+function prepareTileflowNativeStyles(input, assets, policy = {}) {
   const issues = [];
   const result = {};
   for (const map of Object.keys(input).sort()) {
@@ -1035,7 +1349,7 @@ function prepareTileflowNativeStyles(input, assets) {
     for (const theme of Object.keys(input[map]).sort()) {
       const original = input[map][theme];
       const preflight = validateTileflowNativePreparedStyle(original, {
-        documentUrl: documentUrl(map, theme),
+        ...urlOptions(map, theme, policy),
         deferFontClosure: true
       });
       if (preflight.length) {
@@ -1079,9 +1393,9 @@ function prepareTileflowNativeStyles(input, assets) {
         ...faces.length ? { "font-faces": nativeFaces } : {}
       };
       issues.push(
-        ...validateTileflowNativePreparedStyle(style, {
-          documentUrl: documentUrl(map, theme)
-        }).map((issue) => withContext(issue, map, theme))
+        ...validateTileflowNativePreparedStyle(style, urlOptions(map, theme, policy)).map(
+          (issue) => withContext(issue, map, theme)
+        )
       );
       result[map][theme] = style;
     }
@@ -1097,10 +1411,10 @@ function isNativeFontAsset(asset) {
   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");
+  return expectedHash === createHash2("sha256").update(bytes).digest("hex");
 }
-function assertTileflowNativeGeneratedStyle(style, map, theme) {
-  const issues = validateTileflowNativePreparedStyle(style, { documentUrl: documentUrl(map, theme) });
+function assertTileflowNativeGeneratedStyle(style, map, theme, policy = {}) {
+  const issues = validateTileflowNativePreparedStyle(style, urlOptions(map, theme, policy));
   if (issues.length) {
     throw new TileflowNativeCompatibilityError(
       issues.map((issue) => withContext(issue, map, theme))
@@ -1171,7 +1485,7 @@ function validNativeSprites(map, assets) {
 // src/session.ts
 import { watch } from "chokidar";
 import { realpathSync, statSync } from "fs";
-import { basename as basename2, dirname, extname, isAbsolute, relative, resolve as resolve2, sep, win32 } from "path";
+import { basename as basename2, dirname, extname, isAbsolute, relative, resolve as resolve3, sep, win32 } from "path";
 import { tileflowIconMetadataFileName } from "@tileflow/core";
 import { TileflowNativeCompatibilityError as TileflowNativeCompatibilityError2 } from "@tileflow/core/native-profile";
 var tileflowArtifactSessionSchemaVersion = 1;
@@ -1224,13 +1538,13 @@ var TileflowArtifactSessionImpl = class {
   #watchedArtifactDirectories = /* @__PURE__ */ new Map();
   #watchedArtifactPaths = /* @__PURE__ */ new Set();
   constructor(options, buildArtifacts, discoverWatchPaths) {
-    this.#cwd = resolve2(options.cwd ?? process.cwd());
-    const configPath = resolve2(this.#cwd, options.config ?? "tileflow.config.ts");
-    this.#configPath = resolve2(canonicalWatchPath(dirname(configPath)), basename2(configPath));
+    this.#cwd = resolve3(options.cwd ?? process.cwd());
+    const configPath = resolve3(this.#cwd, options.config ?? "tileflow.config.ts");
+    this.#configPath = resolve3(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) => canonicalWatchPath(resolve2(this.#cwd, path))
+      (path) => canonicalWatchPath(resolve3(this.#cwd, path))
     );
     this.#buildArtifacts = buildArtifacts;
     this.#discoverWatchPaths = discoverWatchPaths;
@@ -1239,6 +1553,7 @@ var TileflowArtifactSessionImpl = class {
       assetBaseUrl: options.assetBaseUrl,
       config: options.config,
       cwd: this.#cwd,
+      ...options.developmentOrigin === void 0 ? {} : { developmentOrigin: options.developmentOrigin },
       // Trusted shared Icon Set resolution settings, supplied once by the owning command.
       ...options.icons ? { icons: options.icons } : {},
       inspection: options.inspection,
@@ -1463,7 +1778,7 @@ var TileflowArtifactSessionImpl = class {
   }
   #updateArtifactWatchPaths(paths) {
     if (!this.#watcher) return;
-    const next = new Set(paths.map((path) => canonicalWatchPath(resolve2(this.#cwd, path))));
+    const next = new Set(paths.map((path) => canonicalWatchPath(resolve3(this.#cwd, path))));
     const previous = this.#watchedArtifactPaths;
     this.#watchedArtifactPaths = next;
     const previousDirectories = this.#watchedArtifactDirectories;
@@ -1528,7 +1843,7 @@ async function disposeArtifacts(artifacts) {
   await dispose?.();
 }
 function isSameOrInside(root, candidate) {
-  const path = relative(resolve2(root), resolve2(candidate));
+  const path = relative(resolve3(root), resolve3(candidate));
   return path === "" || !isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`);
 }
 function directoryModificationTime(path) {
@@ -1546,15 +1861,15 @@ function resolveRawWatchPath(path, details) {
   const watchedPath = details.watchedPath;
   if (typeof watchedPath !== "string" || !isAbsolute(watchedPath)) return void 0;
   return canonicalWatchPath(
-    basename2(watchedPath) === path ? watchedPath : resolve2(watchedPath, path)
+    basename2(watchedPath) === path ? watchedPath : resolve3(watchedPath, path)
   );
 }
 function canonicalWatchPath(path) {
-  const resolved = resolve2(path);
+  const resolved = resolve3(path);
   let ancestor = resolved;
   while (true) {
     try {
-      return resolve2(realpathSync.native(ancestor), relative(ancestor, resolved));
+      return resolve3(realpathSync.native(ancestor), relative(ancestor, resolved));
     } catch {
       const parent = dirname(ancestor);
       if (parent === ancestor) return resolved;
@@ -1661,15 +1976,15 @@ function removeSemanticResolutionPath(message, path) {
   return message.replace(` at ${path}:`, ":");
 }
 function localPathAliases(path) {
-  return [.../* @__PURE__ */ new Set([resolve2(path), canonicalPath(path)])].sort(
+  return [.../* @__PURE__ */ new Set([resolve3(path), canonicalPath(path)])].sort(
     (left, right) => right.length - left.length
   );
 }
 function canonicalPath(path) {
   try {
-    return realpathSync.native(resolve2(path));
+    return realpathSync.native(resolve3(path));
   } catch {
-    return resolve2(path);
+    return resolve3(path);
   }
 }
 function normalizeDiagnostics(diagnostics) {
@@ -1705,8 +2020,8 @@ function boundDiagnosticText(value, limit) {
 }
 
 // src/hosted-native-artifacts.ts
-import { createHash as createHash2 } from "crypto";
-import { serializeCanonicalJson as serializeCanonicalJson3 } from "@tileflow/core";
+import { createHash as createHash3 } from "crypto";
+import { serializeCanonicalJson as serializeCanonicalJson2 } from "@tileflow/core";
 import {
   inferTileflowDataRequirements,
   inferTileflowSourceRequirements,
@@ -1714,135 +2029,17 @@ import {
 } 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
+  TileflowNativeCompatibilityError as TileflowNativeCompatibilityError3,
+  createTileflowNativeDiagnostic as createTileflowNativeDiagnostic2
 } 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")
+var digest2 = (value) => createHash3("sha256").update(serializeCanonicalJson2(value)).digest("hex");
+var invalidSource = () => new TileflowNativeCompatibilityError3([
+  createTileflowNativeDiagnostic2("NATIVE_UNSUPPORTED_SOURCE", "/sources")
 ]);
 async function prepareTileflowHostedNativeDeployment(input) {
-  const webStyles = JSON.parse(serializeCanonicalJson3(input.styles));
+  const webStyles = JSON.parse(serializeCanonicalJson2(input.styles));
   const validationStyles = JSON.parse(
-    serializeCanonicalJson3(webStyles)
+    serializeCanonicalJson2(webStyles)
   );
   for (const style of Object.values(validationStyles)) {
     for (const [sourceId, binding] of Object.entries(input.teamSources)) {
@@ -1853,14 +2050,6 @@ async function prepareTileflowHostedNativeDeployment(input) {
     }
   }
   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)) {
@@ -1868,11 +2057,11 @@ async function prepareTileflowHostedNativeDeployment(input) {
       if (!source) throw invalidSource();
       source.url = `tileflow://hosted-sources/${sourceId}`;
     }
-    if (serializeCanonicalJson3(style.sources) !== serializeCanonicalJson3(webStyles[name].sources))
+    if (serializeCanonicalJson2(style.sources) !== serializeCanonicalJson2(webStyles[name].sources))
       throw invalidSource();
   }
   const nativeBuild = JSON.parse(
-    serializeCanonicalJson3(input.buildManifest)
+    serializeCanonicalJson2(input.buildManifest)
   );
   const mapBuild = nativeBuild.maps[input.mapId];
   if (!mapBuild) throw invalidSource();
@@ -1881,15 +2070,15 @@ async function prepareTileflowHostedNativeDeployment(input) {
     if (!theme) throw invalidSource();
     mapBuild.themes[name] = {
       ...theme,
-      styleSha256: digest(style),
+      styleSha256: digest2(style),
       dataRequirements: inferTileflowDataRequirements(style),
       sourceRequirements: inferTileflowSourceRequirements(style)
     };
   }
   const transformations = lowered.transformations.map((item) => ({
     ...item,
-    inputStyleSha256: digest(webStyles[item.theme]),
-    loweredStyleSha256: digest({
+    inputStyleSha256: digest2(webStyles[item.theme]),
+    loweredStyleSha256: digest2({
       ...lowered.styles[input.mapId][item.theme],
       sources: webStyles[item.theme].sources
     })
@@ -1904,7 +2093,7 @@ async function prepareTileflowHostedNativeDeployment(input) {
       web: { buildManifest: input.buildManifest, styles: webStyles },
       native: {
         buildManifest: nativeBuild,
-        buildRecord: createTileflowNativeBuildRecord(digest(nativeBuild), transformations),
+        buildRecord: createTileflowNativeBuildRecord(digest2(nativeBuild), transformations),
         styles: projected
       }
     }
@@ -1991,12 +2180,16 @@ function assertValidTileflowStyles(project, styles) {
 async function createTileflowArtifactPlan(prepared, options = {}) {
   const renderer = resolveTileflowRenderer(options.renderer);
   if (renderer === "native" && options.inspection) {
-    throw new TileflowNativeCompatibilityError5([
-      createTileflowNativeDiagnostic4("NATIVE_RENDERER_UNSUPPORTED", "/inspection")
+    throw new TileflowNativeCompatibilityError4([
+      createTileflowNativeDiagnostic3("NATIVE_RENDERER_UNSUPPORTED", "/inspection")
     ]);
   }
+  assertNativeDevelopmentOrigin(options);
+  const nativeUrls = {
+    developmentOrigin: options.developmentOrigin
+  };
   if (renderer === "native") {
-    assertTileflowNativeCompiledStyles(prepared.project, {});
+    assertTileflowNativeCompiledStyles(prepared.project, {}, nativeUrls);
   } else if (options.target === "production" && hasLocalTilesetSources(prepared.project)) {
     throw new TileflowLocalTilesetProductionError();
   }
@@ -2009,9 +2202,10 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
     apiBaseUrl: options.apiBaseUrl,
     mapAssets: prepared.mapAssets
   });
-  const nativeLowering = renderer === "native" ? lowerTileflowNativeCompiledStyles(compiledStyles) : void 0;
+  const nativeLowering = renderer === "native" ? lowerTileflowNativeCompiledStyles(compiledStyles, nativeUrls) : void 0;
   const rendererStyles = nativeLowering?.styles ?? compiledStyles;
-  if (renderer === "native") assertTileflowNativeCompiledStyles(prepared.project, rendererStyles);
+  if (renderer === "native")
+    assertTileflowNativeCompiledStyles(prepared.project, rendererStyles, nativeUrls);
   const localTilesets = await prepareTileflowLocalTilesets(prepared.project, rendererStyles, {
     assetBaseUrl: resolveRendererAssetBaseUrl(options),
     baseDirectory: prepared.baseDirectory,
@@ -2025,14 +2219,17 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
       target: "local"
     }).catch((error) => {
       if (renderer === "native" && error instanceof TileflowFontCompilationError) {
-        throw new TileflowNativeCompatibilityError5([
-          createTileflowNativeDiagnostic4("NATIVE_FONT_UNAVAILABLE", "/fonts")
+        throw new TileflowNativeCompatibilityError4([
+          createTileflowNativeDiagnostic3("NATIVE_FONT_UNAVAILABLE", "/fonts")
         ]);
       }
       throw error;
     });
     const assets = [...prepared.assets, ...preparedFonts.assets];
-    const styles = renderer === "native" ? prepareTileflowNativeStyles(preparedFonts.styles, assets) : preparedFonts.styles;
+    const lineBackgroundGlyphs = renderer === "native" || options.target === "production" ? { providers: {}, styles: preparedFonts.styles } : prepareTileflowLineBackgroundGlyphs(preparedFonts.styles, {
+      assetBaseUrl: resolveRendererAssetBaseUrl(options)
+    });
+    const styles = renderer === "native" ? prepareTileflowNativeStyles(preparedFonts.styles, assets, nativeUrls) : lineBackgroundGlyphs.styles;
     const provenance = await createTileflowBuildProvenance(prepared.cwd);
     const buildManifest = await createTileflowMapBuildManifest(
       Object.fromEntries(
@@ -2084,7 +2281,7 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
       buildManifest,
       ...renderer === "native" ? {
         nativeBuild: createTileflowNativeBuildRecord2(
-          hashBytes(serializeCanonicalJson4(buildManifest)),
+          hashBytes(serializeCanonicalJson3(buildManifest)),
           nativeLowering.transformations
         )
       } : {},
@@ -2092,6 +2289,7 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
       manifest: stableManifest,
       project: prepared.project,
       ...localTilesets.files.length > 0 ? { localTilesets: localTilesets.files } : {},
+      ...Object.keys(lineBackgroundGlyphs.providers).length > 0 ? { lineBackgroundGlyphs: lineBackgroundGlyphs.providers } : {},
       ...inspected ? { styleInspections: inspected.inspections } : {},
       styles,
       watchPaths: uniqueStrings([...inputs.files, ...inputs.directories])
@@ -2102,7 +2300,7 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
     const generationArtifacts = { ...partial, manifest };
     return {
       ...generationArtifacts,
-      files: createGenerationArtifactFiles(generationArtifacts, generation),
+      files: createGenerationArtifactFiles(generationArtifacts, generation, nativeUrls),
       inputs,
       project: prepared.project,
       schemaVersion: tileflowArtifactPlanSchemaVersion,
@@ -2115,6 +2313,7 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
 }
 async function createTileflowBuildArtifacts(options = {}) {
   resolveTileflowRenderer(options.renderer);
+  assertNativeDevelopmentOrigin(options);
   const loaded = await loadValidTileflowConfigWithInputs(
     options.config ?? defaultTileflowConfigPath,
     {
@@ -2141,7 +2340,7 @@ function getStableTileflowArtifactFiles(artifacts) {
     {
       contentType: "application/json; charset=utf-8",
       fileName: tileflowMapBuildManifestFileName,
-      source: `${serializeCanonicalJson4(artifacts.buildManifest)}
+      source: `${serializeCanonicalJson3(artifacts.buildManifest)}
 `
     },
     {
@@ -2163,7 +2362,7 @@ function getStableTileflowArtifactFiles(artifacts) {
       {
         contentType: "application/json; charset=utf-8",
         fileName: tileflowNativeBuildRecordFileName,
-        source: `${serializeCanonicalJson4(artifacts.nativeBuild)}
+        source: `${serializeCanonicalJson3(artifacts.nativeBuild)}
 `
       }
     ] : []
@@ -2216,7 +2415,7 @@ function createGenerationManifest(manifest, generation, assets) {
     )
   };
 }
-function createGenerationArtifactFiles(artifacts, generation) {
+function createGenerationArtifactFiles(artifacts, generation, nativeUrls) {
   const prefix = `generations/${generation}`;
   const stableFiles = getStableTileflowArtifactFiles(artifacts);
   const immutableStyles = Object.entries(artifacts.styles).flatMap(
@@ -2236,7 +2435,7 @@ function createGenerationArtifactFiles(artifacts, generation) {
         (source) => retargetLocalFontAssetUrl(source, artifacts.assets, generation)
       );
       if (artifacts.nativeBuild)
-        assertTileflowNativeGeneratedStyle(generationStyle, mapName, themeName);
+        assertTileflowNativeGeneratedStyle(generationStyle, mapName, themeName, nativeUrls);
       return {
         contentType: "application/json; charset=utf-8",
         fileName: `${prefix}/styles/${mapName}/${themeName}.json`,
@@ -2292,12 +2491,12 @@ function getMapBuildAssets(mapName, assets, fontAssets) {
   );
 }
 function hashBytes(source) {
-  return createHash3("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
+  return createHash4("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
 }
 async function createTileflowBuildProvenance(cwd) {
-  const projectDirectory = resolve3(cwd);
+  const projectDirectory = resolve4(cwd);
   const projectRequire = createRequire(
-    resolve3(projectDirectory, "__tileflow_build_provenance__.cjs")
+    resolve4(projectDirectory, "__tileflow_build_provenance__.cjs")
   );
   const toolRequire = createRequire(import.meta.url);
   const packages = {};
@@ -2331,7 +2530,7 @@ async function readPackageVersion(expectedName, path) {
   if (!path) throw new Error(`Unable to resolve build package provenance for ${expectedName}.`);
   let parsed;
   try {
-    parsed = JSON.parse(await readFile(path, "utf8"));
+    parsed = JSON.parse(await readFile2(path, "utf8"));
   } catch {
     throw new Error(`Unable to read build package provenance for ${expectedName}.`);
   }
@@ -2354,7 +2553,7 @@ async function findNearestLockfile(cwd) {
       try {
         return {
           format: candidate.format,
-          source: await readFile(resolve3(directory, candidate.fileName))
+          source: await readFile2(resolve4(directory, candidate.fileName))
         };
       } catch (error) {
         if (!hasErrorCode2(error, "ENOENT")) throw error;
@@ -2430,7 +2629,7 @@ async function writeTileflowArtifactPlan(artifacts, options) {
   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 assertTileflowSelfHostedManifestTarget(resolve4(output.outDir, "manifest.json"), options);
   await commitTileflowArtifactFiles(output, files);
 }
 function assertNoLocalTilesetsForProduction(artifacts) {
@@ -2443,7 +2642,7 @@ async function assertTileflowSelfHostedManifestTarget(manifestPath, options = {}
   if (options.overwriteHostedManifest) return;
   let source;
   try {
-    source = await readFile(resolve3(manifestPath), "utf8");
+    source = await readFile2(resolve4(manifestPath), "utf8");
   } catch (error) {
     if (hasErrorCode2(error, "ENOENT")) return;
     throw error;
@@ -2451,7 +2650,7 @@ async function assertTileflowSelfHostedManifestTarget(manifestPath, options = {}
   try {
     const manifest = parseTileflowRuntimeManifest(JSON.parse(source));
     if (isHostedRuntimeManifest(manifest)) {
-      throw new TileflowHostedManifestOverwriteError(resolve3(manifestPath));
+      throw new TileflowHostedManifestOverwriteError(resolve4(manifestPath));
     }
   } catch (error) {
     if (error instanceof TileflowHostedManifestOverwriteError) throw error;
@@ -2499,15 +2698,15 @@ async function commitTileflowArtifactFiles(output, files) {
     ...staleNames,
     tileflowArtifactInventoryFileName
   ]);
-  const stageDir = await mkdtemp(resolve3(outDir, ".tileflow-stage-"));
-  const newDir = resolve3(stageDir, "new");
-  const backupDir = resolve3(stageDir, "backup");
+  const stageDir = await mkdtemp(resolve4(outDir, ".tileflow-stage-"));
+  const newDir = resolve4(stageDir, "new");
+  const backupDir = resolve4(stageDir, "backup");
   const backedUp = /* @__PURE__ */ new Set();
   const installed = /* @__PURE__ */ new Set();
   try {
     for (const file of stagedFiles) {
       const stagePath = managedPath(newDir, file.fileName);
-      await mkdir2(dirname2(stagePath), { recursive: true });
+      await mkdir3(dirname2(stagePath), { recursive: true });
       await writeFileDurably(stagePath, file.source);
     }
     for (const name of affectedNames) {
@@ -2515,7 +2714,7 @@ async function commitTileflowArtifactFiles(output, files) {
       const targetPath = managedPath(outDir, name);
       if (!await isFile(targetPath)) continue;
       const backupPath = managedPath(backupDir, name);
-      await mkdir2(dirname2(backupPath), { recursive: true });
+      await mkdir3(dirname2(backupPath), { recursive: true });
       await copyFile2(targetPath, backupPath);
       backedUp.add(name);
     }
@@ -2529,8 +2728,8 @@ async function commitTileflowArtifactFiles(output, files) {
     )) {
       const sourcePath = managedPath(newDir, name);
       const targetPath = managedPath(outDir, name);
-      await mkdir2(dirname2(targetPath), { recursive: true });
-      await rename(sourcePath, targetPath);
+      await mkdir3(dirname2(targetPath), { recursive: true });
+      await rename2(sourcePath, targetPath);
       installed.add(name);
     }
     for (const name of staleNames) {
@@ -2538,13 +2737,13 @@ async function commitTileflowArtifactFiles(output, files) {
     }
     const stagedInventoryPath = managedPath(newDir, tileflowArtifactInventoryFileName);
     const inventoryPath = managedPath(outDir, tileflowArtifactInventoryFileName);
-    await rename(stagedInventoryPath, inventoryPath);
+    await rename2(stagedInventoryPath, inventoryPath);
     installed.add(tileflowArtifactInventoryFileName);
   } catch (error) {
     await rollbackManagedFiles(outDir, backupDir, affectedNames, backedUp, installed);
     throw error;
   } finally {
-    await rm2(stageDir, { force: true, recursive: true });
+    await rm3(stageDir, { force: true, recursive: true });
   }
 }
 function getArtifactGeneration(files) {
@@ -2576,7 +2775,7 @@ async function rollbackManagedFiles(outDir, backupDir, affectedNames, backedUp,
         await removeManagedFile(targetPath);
       }
       if (backedUp.has(name)) {
-        await mkdir2(dirname2(targetPath), { recursive: true });
+        await mkdir3(dirname2(targetPath), { recursive: true });
         await copyFile2(managedPath(backupDir, name), targetPath);
       }
     } catch (error) {
@@ -2591,7 +2790,7 @@ async function readTileflowArtifactInventory(outDir) {
   const inventoryPath = managedPath(outDir, tileflowArtifactInventoryFileName);
   let source;
   try {
-    source = await readFile(inventoryPath, "utf8");
+    source = await readFile2(inventoryPath, "utf8");
   } catch (error) {
     if (hasErrorCode2(error, "ENOENT")) return void 0;
     throw error;
@@ -2625,7 +2824,7 @@ async function readTileflowArtifactInventory(outDir) {
 }
 async function assertManagedTargetIsSafe(outDir, fileName) {
   assertSafeManagedFileName(fileName);
-  const rootStats = await lstat2(outDir);
+  const rootStats = await lstat3(outDir);
   if (rootStats.isSymbolicLink()) {
     throw new Error(`Tileflow refuses to write through a symbolic link: ${outDir}`);
   }
@@ -2635,9 +2834,9 @@ async function assertManagedTargetIsSafe(outDir, fileName) {
   const segments = fileName.split("/");
   let current = outDir;
   for (let index = 0; index < segments.length; index += 1) {
-    current = resolve3(current, segments[index]);
+    current = resolve4(current, segments[index]);
     try {
-      const stats = await lstat2(current);
+      const stats = await lstat3(current);
       if (stats.isSymbolicLink()) {
         throw new Error(`Tileflow refuses to write through a symbolic link: ${fileName}`);
       }
@@ -2654,12 +2853,12 @@ async function assertManagedTargetIsSafe(outDir, fileName) {
   }
 }
 async function prepareTileflowOutputDirectory(cwd, requestedOutDir) {
-  const logicalRoot = resolve3(cwd);
-  const logicalOutDir = resolve3(logicalRoot, requestedOutDir);
+  const logicalRoot = resolve4(cwd);
+  const logicalOutDir = resolve4(logicalRoot, requestedOutDir);
   if (!isPathWithin(logicalRoot, logicalOutDir)) {
     throw new Error(`Tileflow artifact output escapes its working directory: ${logicalOutDir}`);
   }
-  const rootStats = await lstat2(logicalRoot);
+  const rootStats = await lstat3(logicalRoot);
   if (!rootStats.isDirectory()) {
     throw new Error(`Tileflow artifact working directory is not a directory: ${logicalRoot}`);
   }
@@ -2668,14 +2867,14 @@ async function prepareTileflowOutputDirectory(cwd, requestedOutDir) {
   const segments = relativeOutDir ? relativeOutDir.split(sep2) : [];
   let current = rootDir;
   for (const segment of segments) {
-    current = resolve3(current, segment);
+    current = resolve4(current, segment);
     let stats;
     try {
-      stats = await lstat2(current);
+      stats = await lstat3(current);
     } catch (error) {
       if (!hasErrorCode2(error, "ENOENT")) throw error;
-      await mkdir2(current);
-      stats = await lstat2(current);
+      await mkdir3(current);
+      stats = await lstat3(current);
     }
     if (stats.isSymbolicLink()) {
       throw new Error(`Tileflow refuses to write through a symbolic link: ${current}`);
@@ -2693,7 +2892,7 @@ async function assertTileflowOutputDirectoryIsSafe(output) {
   if (!isPathWithin(output.rootDir, output.outDir)) {
     throw new Error(`Tileflow artifact output escapes its working directory: ${output.outDir}`);
   }
-  const stats = await lstat2(output.outDir);
+  const stats = await lstat3(output.outDir);
   if (stats.isSymbolicLink()) {
     throw new Error(`Tileflow refuses to write through a symbolic link: ${output.outDir}`);
   }
@@ -2722,7 +2921,7 @@ function assertTileflowArtifactFileName(fileName) {
 }
 function managedPath(root, fileName) {
   assertSafeManagedFileName(fileName);
-  const path = resolve3(root, ...fileName.split("/"));
+  const path = resolve4(root, ...fileName.split("/"));
   if (!isPathWithin(root, path)) {
     throw new Error(`Unsafe Tileflow artifact file name: ${fileName}`);
   }
@@ -2739,7 +2938,7 @@ async function writeFileDurably(path, source) {
 }
 async function isFile(path) {
   try {
-    return (await lstat2(path)).isFile();
+    return (await lstat3(path)).isFile();
   } catch (error) {
     if (hasErrorCode2(error, "ENOENT")) return false;
     throw error;
@@ -2747,7 +2946,7 @@ async function isFile(path) {
 }
 async function removeManagedFile(path) {
   try {
-    const stats = await lstat2(path);
+    const stats = await lstat3(path);
     if (!stats.isFile()) throw new Error(`Refusing to remove non-file artifact target: ${path}`);
     await unlink(path);
   } catch (error) {
@@ -2755,7 +2954,7 @@ async function removeManagedFile(path) {
   }
 }
 function hashArtifactGeneration(files) {
-  const hash = createHash3("sha256");
+  const hash = createHash4("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");
@@ -2763,6 +2962,13 @@ function hashArtifactGeneration(files) {
   }
   return hash.digest("hex");
 }
+function assertNativeDevelopmentOrigin(options) {
+  if (options.developmentOrigin !== void 0 && (resolveTileflowRenderer(options.renderer) !== "native" || options.target === "production")) {
+    throw new TileflowNativeCompatibilityError4([
+      createTileflowNativeDiagnostic3("NATIVE_RENDERER_UNSUPPORTED", "/developmentOrigin")
+    ]);
+  }
+}
 function resolveRendererAssetBaseUrl(options) {
   const base = resolveAssetBaseUrl(options);
   return options.renderer === "native" ? nativePublicBase(base) : base;
@@ -2787,12 +2993,12 @@ function hasErrorCode2(error, code) {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
 }
 function canonicalInputPath(path) {
-  const resolved = resolve3(path);
+  const resolved = resolve4(path);
   try {
     return realpathSync2.native(resolved);
   } catch {
     try {
-      return resolve3(realpathSync2.native(dirname2(resolved)), resolved.split(/[\\/]/).at(-1));
+      return resolve4(realpathSync2.native(dirname2(resolved)), resolved.split(/[\\/]/).at(-1));
     } catch {
       return resolved;
     }
@@ -2800,6 +3006,10 @@ function canonicalInputPath(path) {
 }
 
 export {
+  tileflowLineBackgroundGlyphRoute,
+  usesTileflowLineBackgroundGlyphs,
+  parseTileflowLineBackgroundGlyphPath,
+  createTileflowLineBackgroundGlyphResponder,
   prepareTileflowLocalTilesets,
   tileflowArtifactSessionSchemaVersion,
   createTileflowArtifactDiagnostics,