@tileflow/dev 0.1.0-alpha.4 → 0.1.0-alpha.40

package/dist/chunk-AVJMTXW5.js

@@ -0,0 +1,3147 @@
+import {
+  TileflowFontCompilationError,
+  getTileflowFontWatchPaths,
+  joinTileflowPublicUrl,
+  prepareTileflowStyleFonts,
+  replaceTileflowStyleFontSources
+} from "./chunk-FOMTSCOP.js";
+import {
+  getTileflowIconWatchPaths,
+  prepareTileflowCatalogIcons
+} from "./chunk-C4VPHZ3F.js";
+import {
+  TileflowStyleValidationError,
+  normalizeTileflowStyleValidationIssues,
+  sanitizeDiagnosticSecrets,
+  validateTileflowStyle
+} from "./chunk-KDFTE4Q5.js";
+import {
+  defaultTileflowConfigPath,
+  getTileflowMapNames,
+  loadValidTileflowConfigWithInputs
+} from "./chunk-AQUGMUZW.js";
+import {
+  isPathWithin
+} from "./chunk-D4OE4ITL.js";
+import {
+  inspectTileflowPmtilesForLocalUse
+} from "./chunk-ONYQNLNA.js";
+
+// src/artifacts.ts
+import { createHash as createHash5 } from "crypto";
+import { realpathSync as realpathSync2 } from "fs";
+import {
+  copyFile as copyFile2,
+  lstat as lstat3,
+  mkdir as mkdir3,
+  mkdtemp,
+  open as open2,
+  readFile as readFile2,
+  realpath as realpath2,
+  rename as rename2,
+  rm as rm3,
+  unlink
+} from "fs/promises";
+import { createRequire } from "module";
+import { dirname as dirname2, relative as relative2, resolve as resolve4, sep as sep2 } from "path";
+import {
+  compareCodeUnits as compareCodeUnits2,
+  getTileflowStyleFontFaces as getTileflowStyleFontFaces2,
+  serializeCanonicalJson as serializeCanonicalJson3,
+  tileflowMapIdSchema,
+  tileflowThemeNameSchema
+} from "@tileflow/core";
+import {
+  createManifest,
+  createStyleFromCatalog,
+  createStylesFromCatalog,
+  createStylesFromCatalogWithInspection,
+  createTileflowMapBuildManifest,
+  tileflowMapBuildManifestFileName
+} from "@tileflow/core/build";
+import { parseTileflowRuntimeManifest } from "@tileflow/core/manifest";
+import {
+  createTileflowNativeBuildRecord as createTileflowNativeBuildRecord2,
+  createTileflowNativeDiagnostic as createTileflowNativeDiagnostic3,
+  resolveTileflowRenderer,
+  tileflowNativeBuildRecordFileName,
+  TileflowNativeCompatibilityError as TileflowNativeCompatibilityError4
+} from "@tileflow/core/native-profile";
+
+// src/image-source-assets.ts
+import { createHash } from "crypto";
+function prepareEmbeddedImageSources(input) {
+  const styles = structuredClone(input);
+  const assets = /* @__PURE__ */ new Map();
+  for (const [map, themes] of Object.entries(styles)) {
+    for (const style of Object.values(themes)) {
+      for (const source of Object.values(style.sources)) {
+        if (source.type !== "image" || typeof source.url !== "string") continue;
+        const match = /^data:image\/png;base64,([A-Za-z0-9+/]+={0,2})$/u.exec(source.url);
+        if (!match || match[1].length > 14 * 1024 * 1024) continue;
+        const bytes = Buffer.from(match[1], "base64");
+        if (bytes.length < 24 || !bytes.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex")))
+          continue;
+        const hash = createHash("sha256").update(bytes).digest("hex");
+        const fileName = `images/${map}/${hash}.png`;
+        assets.set(fileName, { contentType: "image/png", fileName, source: bytes });
+        source.url = `../../${fileName}`;
+      }
+    }
+  }
+  return { styles, assets: [...assets.values()] };
+}
+
+// src/line-background-glyphs.ts
+import { createHash as createHash2, 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 createHash2("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 as randomUUID2 } from "crypto";
+import { constants } from "fs";
+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;
+async function prepareTileflowLocalTilesets(project, styles, options) {
+  const hasSources = Object.values(project.maps).some(
+    (map) => Object.keys(map.sources ?? {}).length > 0
+  );
+  if (!hasSources) {
+    return { dispose: async () => void 0, files: [], styles, watchPaths: [] };
+  }
+  const logicalProjectRoot = resolve2(options.cwd);
+  const projectRoot = await realpath(logicalProjectRoot).catch(() => logicalProjectRoot);
+  const snapshotStore = resolve2(logicalProjectRoot, ".tileflow/cache/pmtiles-snapshots/v1");
+  await assertSafeSnapshotStore(logicalProjectRoot, snapshotStore);
+  await collectAbandonedSnapshotGenerations(snapshotStore);
+  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();
+  const output = Object.fromEntries(
+    Object.entries(styles).map(([mapName, family]) => [
+      mapName,
+      Object.fromEntries(
+        Object.entries(family).map(([themeName, style]) => [themeName, cloneStyle(style)])
+      )
+    ])
+  );
+  let disposed = false;
+  const dispose = async () => {
+    if (disposed) return;
+    disposed = true;
+    if (!isPathWithin(snapshotStore, generationDirectory)) {
+      throw new Error("Local PMTiles snapshot generation escaped its store.");
+    }
+    await rm2(generationDirectory, { force: true, recursive: true });
+  };
+  try {
+    for (const mapName of Object.keys(project.maps).sort(compareCodeUnits)) {
+      const map = project.maps[mapName];
+      for (const [sourceId, source] of Object.entries(map.sources ?? {}).sort(
+        ([left], [right]) => compareCodeUnits(left, right)
+      )) {
+        const requestedPath = resolve2(options.baseDirectory, source.local);
+        const sourcePath = await realpath(requestedPath).catch(() => requestedPath);
+        if (!isPathWithin(projectRoot, sourcePath)) {
+          throw localTilesetError(
+            "TF_LOCAL_TILESET_OUTSIDE_ROOT",
+            `maps.${mapName}.sources.${sourceId}.local`,
+            "Local hosted tileset must stay inside the project root."
+          );
+        }
+        const sourceStat = await lstat2(sourcePath).catch(() => null);
+        if (!sourceStat?.isFile() || sourceStat.isSymbolicLink()) {
+          throw localTilesetError(
+            "TF_LOCAL_TILESET_NOT_FOUND",
+            `maps.${mapName}.sources.${sourceId}.local`,
+            `Local hosted tileset "${sourceId}" was not found.`
+          );
+        }
+        let snapshot = snapshots.get(sourcePath);
+        if (!snapshot) {
+          snapshot = await createLocalTilesetSnapshot(
+            sourcePath,
+            generationDirectory,
+            snapshots.size
+          );
+          snapshots.set(sourcePath, snapshot);
+        }
+        const file = {
+          byteLength: snapshot.byteLength,
+          etag: snapshot.etag,
+          fileName: `tilesets/${source.tileset}.pmtiles`,
+          logicalId: source.tileset,
+          sourcePath: snapshot.sourcePath
+        };
+        const existing = bindings.get(source.tileset);
+        if (existing && existing.originalSourcePath !== sourcePath) {
+          throw localTilesetError(
+            "TF_LOCAL_TILESET_BINDING_CONFLICT",
+            `maps.${mapName}.sources.${sourceId}.local`,
+            `Logical tileset "${source.tileset}" resolves to different local archives in one generation.`
+          );
+        }
+        bindings.set(source.tileset, { file, originalSourcePath: sourcePath });
+        files.set(file.fileName, files.get(file.fileName) ?? file);
+        validateSourceContract(
+          mapName,
+          sourceId,
+          source.type,
+          output[mapName] ?? {},
+          snapshot.inspection
+        );
+        const publicUrl = joinTileflowPublicUrl(options.assetBaseUrl, file.fileName);
+        for (const style of Object.values(output[mapName] ?? {})) {
+          const definition = style.sources[sourceId];
+          if (!definition) {
+            throw localTilesetError(
+              "TF_LOCAL_TILESET_SOURCE_MISSING",
+              `maps.${mapName}.sources.${sourceId}`,
+              `Compiled style is missing hosted source "${sourceId}".`
+            );
+          }
+          definition.url = `tileflow-pmtiles://${publicUrl}`;
+          delete definition.tiles;
+        }
+      }
+    }
+    return {
+      dispose,
+      files: [...files.values()].sort(
+        (left, right) => compareCodeUnits(left.fileName, right.fileName)
+      ),
+      styles: output,
+      watchPaths: [...snapshots.keys()].sort(compareCodeUnits)
+    };
+  } catch (error) {
+    await dispose().catch(() => void 0);
+    throw error;
+  }
+}
+async function createLocalTilesetSnapshot(sourcePath, generationDirectory, index) {
+  const sourceHandle = await open(sourcePath, "r");
+  const snapshotPath = resolve2(generationDirectory, `${index}.pmtiles`);
+  try {
+    const before = sourceIdentity(await sourceHandle.stat({ bigint: true }));
+    if (before.size < minimumLocalPmtilesBytes || before.size > maximumLocalPmtilesBytes) {
+      throw localTilesetError(
+        "TF_TILESET_ARCHIVE_INVALID",
+        "archive",
+        "Expected one bounded PMTiles file."
+      );
+    }
+    await copyFile(sourcePath, snapshotPath, constants.COPYFILE_FICLONE);
+    await syncFile(snapshotPath);
+    const [afterHandle, afterPath, snapshotStat] = await Promise.all([
+      sourceHandle.stat({ bigint: true }).then(sourceIdentity),
+      stat(sourcePath, { bigint: true }).then(sourceIdentity),
+      stat(snapshotPath, { bigint: true })
+    ]);
+    assertSourceIdentity(before, afterHandle);
+    assertSourceIdentity(before, afterPath);
+    if (!snapshotStat.isFile() || snapshotStat.size !== before.size) {
+      throw localTilesetError(
+        "TF_LOCAL_TILESET_CHANGED",
+        "local",
+        "Local hosted tileset changed while its immutable snapshot was prepared."
+      );
+    }
+    const inspection = await inspectTileflowPmtilesForLocalUse(snapshotPath);
+    await chmod(snapshotPath, 292);
+    return Object.freeze({
+      byteLength: Number(before.size),
+      etag: `"${generationIdFromDirectory(generationDirectory)}-${index}"`,
+      inspection,
+      sourcePath: snapshotPath
+    });
+  } finally {
+    await sourceHandle.close();
+  }
+}
+function generationIdFromDirectory(path) {
+  const generationId = basename(path);
+  if (!/^snapshot-\d+-[a-f0-9]{32}$/u.test(generationId)) {
+    throw new Error("Local PMTiles snapshot generation is invalid.");
+  }
+  return generationId;
+}
+function sourceIdentity(value) {
+  if (!value.isFile()) throw new Error("Local PMTiles source is not a file.");
+  return Object.freeze({
+    device: BigInt(value.dev),
+    inode: BigInt(value.ino),
+    mtimeNanoseconds: "mtimeNs" in value ? BigInt(value.mtimeNs) : BigInt(Math.round(value.mtimeMs * 1e6)),
+    size: BigInt(value.size)
+  });
+}
+function assertSourceIdentity(before, after) {
+  if (before.device !== after.device || before.inode !== after.inode || before.mtimeNanoseconds !== after.mtimeNanoseconds || before.size !== after.size) {
+    throw localTilesetError(
+      "TF_LOCAL_TILESET_CHANGED",
+      "local",
+      "Local hosted tileset changed while its immutable snapshot was prepared."
+    );
+  }
+}
+function validateSourceContract(mapName, sourceId, sourceType, styles, inspection) {
+  const isVectorArchive = inspection.contract.tileType === "mlt" || inspection.contract.tileType === "mvt";
+  if (sourceType === "vector" !== isVectorArchive) {
+    throw localTilesetError(
+      "TF_SOURCE_TILE_TYPE_MISMATCH",
+      `maps.${mapName}.sources.${sourceId}.type`,
+      `Source "${sourceId}" declares ${sourceType} but the PMTiles archive contains ${inspection.contract.tileType}.`
+    );
+  }
+  if (!isVectorArchive || !inspection.contract.sourceLayersDeclared) return;
+  const availableLayers = new Map(
+    inspection.contract.sourceLayers.map((layer) => [layer.id, layer])
+  );
+  for (const style of Object.values(styles)) {
+    const requirements = asRecord(style.metadata?.["tileflow:sourceRequirements"]);
+    const sources = asRecord(requirements?.sources);
+    const source = asRecord(sources?.[sourceId]);
+    const sourceLayers = Array.isArray(source?.sourceLayers) ? source.sourceLayers : [];
+    for (const candidate of sourceLayers) {
+      const required = asRecord(candidate);
+      const layerId = required?.id;
+      if (typeof layerId !== "string") continue;
+      const available = availableLayers.get(layerId);
+      if (!available) {
+        const candidates = [...availableLayers.keys()].sort(compareCodeUnits);
+        throw localTilesetError(
+          "TF_SOURCE_LAYER_NOT_FOUND",
+          `maps.${mapName}.sources.${sourceId}.sourceLayers.${layerId}`,
+          `Source "${sourceId}" has no source-layer "${layerId}". Available: ${candidates.join(", ") || "(none)"}.`
+        );
+      }
+      if (!available.fieldsDeclared) continue;
+      const availableFields = new Map(available.fields.map((field) => [field.name, field.type]));
+      const requiredFields = Array.isArray(required?.fields) ? required.fields : [];
+      for (const fieldCandidate of requiredFields) {
+        const field = asRecord(fieldCandidate);
+        const fieldName = field?.name;
+        if (typeof fieldName !== "string") continue;
+        if (!availableFields.has(fieldName)) {
+          const candidates = [...availableFields.keys()].sort(compareCodeUnits);
+          throw localTilesetError(
+            "TF_SOURCE_FIELD_NOT_FOUND",
+            `maps.${mapName}.sources.${sourceId}.sourceLayers.${layerId}.fields.${fieldName}`,
+            `Source-layer "${layerId}" has no field "${fieldName}". Available: ${candidates.join(", ") || "(none)"}.`
+          );
+        }
+        const requiredType = field?.type;
+        const actualType = availableFields.get(fieldName);
+        if (typeof requiredType === "string" && actualType !== void 0 && requiredType !== actualType) {
+          throw localTilesetError(
+            "TF_SOURCE_FIELD_TYPE_MISMATCH",
+            `maps.${mapName}.sources.${sourceId}.sourceLayers.${layerId}.fields.${fieldName}`,
+            `Field "${layerId}.${fieldName}" is ${actualType}; ${requiredType} is required.`
+          );
+        }
+      }
+    }
+  }
+}
+async function collectAbandonedSnapshotGenerations(store) {
+  const entries = await readdir(store, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    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 = 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 = resolve2(current, segment);
+    try {
+      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 mkdir2(current).catch((mkdirError) => {
+        if (!hasErrorCode(mkdirError, "EEXIST")) throw mkdirError;
+      });
+      const created = await lstat2(current);
+      if (!created.isDirectory() || created.isSymbolicLink()) {
+        throw new Error(`Local PMTiles snapshot path is unsafe: ${current}`);
+      }
+    }
+  }
+  if (resolve2(current) !== resolve2(store)) {
+    throw new Error("Local PMTiles snapshot path escaped its project root.");
+  }
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !hasErrorCode(error, "ESRCH");
+  }
+}
+async function syncFile(path) {
+  const handle = await open(path, "r");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+function cloneStyle(style) {
+  return JSON.parse(JSON.stringify(style));
+}
+function localTilesetError(code, path, message) {
+  return Object.assign(new Error(message), { code, path, phase: "local-tileset-resolution" });
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function hasErrorCode(error, code) {
+  return Boolean(error && typeof error === "object" && error.code === code);
+}
+
+// src/native-artifacts.ts
+import {
+  convertFilter,
+  validateStyleMin
+} from "@maplibre/maplibre-gl-style-spec";
+import { createHash as createHash3 } from "crypto";
+import {
+  getTileflowStyleFontFaces,
+  serializeCanonicalJson,
+  steadyTileflowNauticalLights,
+  tileflowIconIdPattern,
+  tileflowIconPackageLimits,
+  tileflowStyleFontFacesMetadataKey
+} from "@tileflow/core";
+import {
+  prepareTileflowNativePathGround
+} from "@tileflow/core/build";
+import {
+  createTileflowNativeDiagnostic,
+  TileflowNativeCompatibilityError,
+  tileflowNativeProfileLimits,
+  validateTileflowNativePreparedStyle,
+  validateTileflowNativeStyle
+} 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 !== 3) 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,
+  maximumDecisionNodes: 512,
+  maximumPropertyBranches: 16,
+  maximumPathsPerProperty: 64,
+  maximumLayerVariants: 32,
+  maximumZoomIntervals: 32,
+  maximumLayers: 4096,
+  maximumDashLength: 64
+});
+var overlapProperties = ["icon-overlap", "text-overlap"];
+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 object2(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 replaceSymbolOverlap(layer, index) {
+  if (layer.type !== "symbol" || !object2(layer.layout)) return;
+  const properties = overlapProperties.filter((property) => layer.layout[property] !== void 0);
+  if (!properties.length) return;
+  const layout = { ...layer.layout };
+  for (const property of properties) {
+    const mode = layout[property];
+    if (mode !== "never" && mode !== "always" && mode !== "cooperative") {
+      fail(`/layers/${index}/layout/${property}`);
+    }
+    delete layout[property];
+    layout[property === "icon-overlap" ? "icon-allow-overlap" : "text-allow-overlap"] = mode !== "never";
+  }
+  return { layer: { ...layer, layout }, 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 (!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 (!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 = [];
+  const symbolOverlap = [];
+  for (const [index, layer] of originalLayers.entries()) {
+    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) {
+      const replaced = replaceSymbolOverlap(layer, index);
+      if (replaced) symbolOverlap.push({ inputLayer: index, properties: replaced.properties });
+      layers.push(replaced?.layer ?? 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
+    });
+  }
+  if (input.sky !== void 0 && !object2(input.sky)) fail("/sky");
+  const sky = input.sky !== void 0;
+  const changed = projection !== "none" || sky || transformations.length > 0 || symbolOverlap.length > 0;
+  const output = changed ? { ...input, layers } : input;
+  if (changed && projection !== "none") delete output.projection;
+  if (sky) delete output.sky;
+  return {
+    style: output,
+    projection,
+    ...sky ? { sky: "removed" } : {},
+    layers: transformations,
+    symbolOverlap,
+    inputLayers: originalLayers.length,
+    outputLayers: layers.length
+  };
+}
+
+// src/native-artifacts.ts
+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, policy = {}) {
+  const styles = {};
+  const transformations = [];
+  for (const map of Object.keys(input).sort()) {
+    styles[map] = {};
+    for (const theme of Object.keys(input[map]).sort()) {
+      const web = input[map][theme];
+      const steady = steadyTileflowNauticalLights(web);
+      const original = prepareTileflowNativePathGround(steady);
+      const pathGroundFallback = original !== steady;
+      try {
+        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" || issue.path === "/sky" || /^\/layers\/\d+\/(?:layout\/line-cap|paint\/line-dasharray)(?:\/|$)/u.test(
+            issue.path
+          ) || /^\/layers\/\d+\/layout\/(?:icon|text)-overlap$/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 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] = style;
+        transformations.push({
+          map,
+          theme,
+          inputStyleSha256: createHash3("sha256").update(serializeCanonicalJson(web)).digest("hex"),
+          loweredStyleSha256: createHash3("sha256").update(serializeCanonicalJson(style)).digest("hex"),
+          inputLayers: lowered.inputLayers,
+          outputLayers: lowered.outputLayers,
+          projection: lowered.projection,
+          ...lowered.sky ? { sky: lowered.sky } : {},
+          ...pathGroundFallback ? { pathGround: "ground-fallback" } : {},
+          layers: lowered.layers,
+          symbolOverlap: lowered.symbolOverlap
+        });
+      } 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, 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], {
+          ...urlOptions(mapName, theme, policy),
+          deferFontClosure: true
+        }).map((issue) => withContext(issue, mapName, theme))
+      );
+    }
+  }
+  if (issues.length) throw new TileflowNativeCompatibilityError(issues);
+}
+function prepareTileflowNativeStyles(input, assets, policy = {}) {
+  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, {
+        ...urlOptions(map, theme, policy),
+        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, urlOptions(map, theme, policy)).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 === createHash3("sha256").update(bytes).digest("hex");
+}
+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))
+    );
+  }
+}
+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, statSync } from "fs";
+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;
+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",
+  ".hg",
+  ".next",
+  ".nuxt",
+  ".svn",
+  ".svelte-kit",
+  ".tileflow",
+  ".turbo",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+async function createTileflowArtifactSessionWithBuilder(options, buildArtifacts, discoverWatchPaths) {
+  const session = new TileflowArtifactSessionImpl(options, buildArtifacts, discoverWatchPaths);
+  await session.start();
+  return session;
+}
+var TileflowArtifactSessionImpl = class {
+  #buildArtifacts;
+  #buildOptions;
+  #configPath;
+  #cwd;
+  #debounceMs;
+  #discoverWatchPaths;
+  #listeners = /* @__PURE__ */ new Set();
+  #ignoredPaths;
+  #watchEnabled;
+  #closed = false;
+  #closing;
+  #debounceTimer;
+  #startupCheckTimer;
+  #generation = 0;
+  #current;
+  #artifactGenerations = /* @__PURE__ */ new Set();
+  #lastGoodGeneration;
+  #refreshes = /* @__PURE__ */ new Set();
+  #refreshToken = 0;
+  #state = { generation: 0, status: "building" };
+  #watcher;
+  #watchedArtifactDirectories = /* @__PURE__ */ new Map();
+  #watchedArtifactPaths = /* @__PURE__ */ new Set();
+  constructor(options, buildArtifacts, discoverWatchPaths) {
+    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(resolve3(this.#cwd, path))
+    );
+    this.#buildArtifacts = buildArtifacts;
+    this.#discoverWatchPaths = discoverWatchPaths;
+    this.#buildOptions = {
+      apiBaseUrl: options.apiBaseUrl,
+      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,
+      ...options.renderer === void 0 ? {} : { renderer: options.renderer },
+      styleBaseUrl: options.styleBaseUrl,
+      target: options.target
+    };
+  }
+  async start() {
+    if (this.#watchEnabled) {
+      this.#watcher = watch(dirname(this.#configPath), {
+        awaitWriteFinish: { pollInterval: 20, stabilityThreshold: writeStabilityMs },
+        followSymlinks: false,
+        ignoreInitial: true,
+        ignored: (path, stats) => this.#ignoreWatchPath(path, stats?.isDirectory()),
+        usePolling: process.platform === "win32"
+      });
+      const watcherReady = new Promise((resolveReady, rejectReady) => {
+        const watcher = this.#watcher;
+        const cleanup = () => {
+          watcher.off("ready", onReady);
+          watcher.off("error", onError);
+        };
+        const onReady = () => {
+          cleanup();
+          resolveReady();
+        };
+        const onError = (error) => {
+          cleanup();
+          rejectReady(error);
+        };
+        watcher.once("ready", onReady);
+        watcher.once("error", onError);
+      });
+      this.#watcher.on("all", (event, path) => {
+        if (event === "addDir" || event === "unlinkDir") return;
+        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;
+        this.#publishInvalid(this.#generation + 1, error);
+      });
+      await watcherReady;
+    }
+    await this.refresh("initial");
+    while (!this.#current && this.#state.status === "building" && !this.#closed) {
+      await Promise.all([...this.#refreshes]);
+    }
+    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;
+  }
+  getLastGoodArtifacts() {
+    return this.#current?.artifacts;
+  }
+  acquireArtifacts(generation) {
+    const current = this.#current;
+    if (this.#closed || !current?.accepting || generation !== void 0 && generation !== current.generation) {
+      return void 0;
+    }
+    current.references += 1;
+    let released = false;
+    return Object.freeze({
+      artifacts: current.artifacts,
+      generation: current.generation,
+      release: async () => {
+        if (released) return;
+        released = true;
+        current.references -= 1;
+        if (!current.accepting && current.references === 0) {
+          await this.#disposeGeneration(current);
+        }
+      }
+    });
+  }
+  subscribe(listener) {
+    if (this.#closed) return () => void 0;
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  async refresh(_reason = "manual") {
+    const refresh = this.#refresh();
+    this.#refreshes.add(refresh);
+    try {
+      await refresh;
+    } finally {
+      this.#refreshes.delete(refresh);
+    }
+  }
+  async #refresh() {
+    if (this.#closed) return;
+    const generation = ++this.#generation;
+    const token = ++this.#refreshToken;
+    this.#publish({
+      generation,
+      status: "building",
+      ...this.#lastGoodGeneration === void 0 ? {} : { lastGoodGeneration: this.#lastGoodGeneration }
+    });
+    try {
+      const artifacts = await this.#buildArtifacts(this.#buildOptions);
+      if (this.#closed || token !== this.#refreshToken) {
+        await disposeArtifacts(artifacts);
+        return;
+      }
+      const previous = this.#current;
+      const current = createArtifactGeneration(generation, artifacts);
+      this.#artifactGenerations.add(current);
+      this.#current = current;
+      this.#lastGoodGeneration = generation;
+      this.#updateArtifactWatchPaths(artifacts.watchPaths);
+      if (previous) {
+        previous.accepting = false;
+        if (previous.references === 0) await this.#disposeGeneration(previous);
+      }
+      this.#publish({
+        artifacts,
+        generation,
+        lastGoodGeneration: generation,
+        status: "ready"
+      });
+    } catch (error) {
+      if (this.#closed || token !== this.#refreshToken) return;
+      if (this.#watcher && this.#discoverWatchPaths) {
+        try {
+          const watchPaths = await this.#discoverWatchPaths();
+          if (this.#closed || token !== this.#refreshToken) return;
+          this.#updateArtifactWatchPaths(watchPaths);
+        } catch {
+        }
+      }
+      this.#publishInvalid(generation, error);
+    }
+  }
+  close() {
+    this.#closing ??= this.#close();
+    return this.#closing;
+  }
+  async #close() {
+    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];
+    this.#current = void 0;
+    for (const generation of retained) {
+      generation.accepting = false;
+      if (generation.references === 0) void this.#disposeGeneration(generation);
+    }
+    await Promise.allSettled([...this.#refreshes]);
+    await Promise.all(retained.map((generation) => generation.completion));
+  }
+  #ignoreWatchPath(path, isDirectory) {
+    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;
+    if (segments.some((segment) => excludedDirectories.has(segment))) return true;
+    if (isDirectory !== false) return false;
+    if (resolvedPath === this.#configPath || this.#watchedArtifactPaths.has(resolvedPath))
+      return false;
+    const extension = extname(resolvedPath).toLowerCase();
+    if (configExtensions.has(extension)) return false;
+    if (iconExtensions.has(extension) || fontExtensions.has(extension)) return false;
+    return true;
+  }
+  #shouldRefreshForWatchEvent(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));
+  }
+  #publish(state) {
+    this.#state = state;
+    for (const listener of this.#listeners) listener(state);
+  }
+  #publishInvalid(generation, error) {
+    this.#generation = Math.max(this.#generation, generation);
+    this.#publish({
+      diagnostics: createTileflowArtifactDiagnostics(error, this.#cwd),
+      generation,
+      status: "invalid",
+      ...this.#lastGoodGeneration === void 0 ? {} : { lastGoodGeneration: this.#lastGoodGeneration }
+    });
+  }
+  #scheduleRefresh(_path) {
+    if (this.#closed) return;
+    if (this.#debounceTimer) clearTimeout(this.#debounceTimer);
+    this.#debounceTimer = setTimeout(() => {
+      this.#debounceTimer = void 0;
+      void this.refresh("filesystem");
+    }, this.#debounceMs);
+  }
+  #updateArtifactWatchPaths(paths) {
+    if (!this.#watcher) return;
+    const next = new Set(paths.map((path) => canonicalWatchPath(resolve3(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);
+      }
+    }
+    for (const path of next) {
+      if (!previous.has(path) && !isSameOrInside(dirname(this.#configPath), path)) {
+        this.#watcher.add(path);
+      }
+    }
+  }
+  #disposeGeneration(generation) {
+    if (generation.disposeStarted) return generation.completion;
+    generation.disposeStarted = true;
+    void disposeArtifacts(generation.artifacts).then(
+      () => {
+        this.#artifactGenerations.delete(generation);
+        generation.resolveCompletion();
+      },
+      (error) => {
+        this.#artifactGenerations.delete(generation);
+        generation.rejectCompletion(error);
+      }
+    );
+    return generation.completion;
+  }
+};
+function createArtifactGeneration(generation, artifacts) {
+  let rejectCompletion;
+  let resolveCompletion;
+  const completion = new Promise((resolvePromise, rejectPromise) => {
+    rejectCompletion = rejectPromise;
+    resolveCompletion = resolvePromise;
+  });
+  return {
+    accepting: true,
+    artifacts,
+    completion,
+    disposeStarted: false,
+    generation,
+    references: 0,
+    rejectCompletion,
+    resolveCompletion
+  };
+}
+async function disposeArtifacts(artifacts) {
+  const dispose = artifacts.dispose;
+  artifacts.dispose = void 0;
+  await dispose?.();
+}
+function isSameOrInside(root, candidate) {
+  const path = relative(resolve3(root), resolve3(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 : resolve3(watchedPath, path)
+  );
+}
+function canonicalWatchPath(path) {
+  const resolved = resolve3(path);
+  let ancestor = resolved;
+  while (true) {
+    try {
+      return resolve3(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");
+  const semanticResolutionPath = isTileflowMapResolutionDiagnostic(error, inheritedPath) ? sanitizeDiagnosticSecrets(inheritedPath) : void 0;
+  const issueList = getIssueList(error);
+  if (issueList.length > 0) {
+    return normalizeDiagnostics(
+      issueList.map((issue) => ({
+        ...issue.code ?? inheritedCode ? { code: issue.code ?? inheritedCode } : {},
+        message: sanitizeMessage(issue.message, cwd),
+        path: sanitizePath(issue.path, cwd),
+        ...issue.phase ?? inheritedPhase ? { phase: issue.phase ?? inheritedPhase } : {}
+      }))
+    );
+  }
+  return normalizeDiagnostics([
+    {
+      ...inheritedCode ? { code: inheritedCode } : {},
+      message: sanitizeMessage(
+        error instanceof Error ? removeSemanticResolutionPath(error.message, semanticResolutionPath) : "Unknown build error",
+        cwd
+      ),
+      path: semanticResolutionPath ?? sanitizePath(inheritedPath ?? "", cwd),
+      ...inheritedPhase ? { phase: inheritedPhase } : {}
+    }
+  ]);
+}
+function getIssueList(error) {
+  if (!error || typeof error !== "object") return [];
+  const containers = [];
+  for (const key2 of ["messages", "issues"]) {
+    const value = error[key2];
+    if (Array.isArray(value)) containers.push(value);
+  }
+  const details = error.details;
+  if (details && typeof details === "object") {
+    const diagnostics = details.diagnostics;
+    if (Array.isArray(diagnostics)) containers.push(diagnostics);
+  }
+  return containers.flatMap(
+    (value) => value.flatMap((entry) => {
+      if (!entry || typeof entry !== "object") return [];
+      const message = entry.message;
+      const path = entry.path;
+      const code = optionalDiagnosticField(entry, "code");
+      const phase = optionalDiagnosticField(entry, "phase");
+      return typeof message === "string" ? [
+        {
+          ...code ? { code } : {},
+          message,
+          path: typeof path === "string" ? path : "",
+          ...phase ? { phase } : {}
+        }
+      ] : [];
+    })
+  );
+}
+function sanitizeMessage(value, cwd) {
+  let sanitized = value;
+  for (const root of localPathAliases(cwd)) sanitized = sanitized.replaceAll(root, ".");
+  sanitized = sanitized.replace(/[\r\n]+/g, " ").trim();
+  sanitized = sanitized.replace(/https?:\/\/[^\s'")<>]+/gi, (url) => {
+    try {
+      return new URL(url.replace(/[),.;]+$/, "")).origin;
+    } catch {
+      return "(resource URL)";
+    }
+  });
+  sanitized = sanitized.replace(/(^|[\s'"(])[A-Za-z]:[\\/][^\s'")]+/g, "$1(external path)");
+  sanitized = sanitized.replace(/(^|[\s'"(])(?:\\\\|\/\/)[^\s'")]+/g, "$1(external path)");
+  sanitized = sanitized.replace(/(^|[\s'"(])\/[^\s'")]+/g, "$1(external path)");
+  return sanitizeDiagnosticSecrets(sanitized);
+}
+function sanitizePath(value, cwd) {
+  if (!value) return "";
+  if (win32.isAbsolute(value) && !isAbsolute(value)) return "(external)";
+  if (!isAbsolute(value)) return sanitizeDiagnosticSecrets(value.replaceAll("\\", "/"));
+  const local = relative(canonicalPath(cwd), canonicalPath(value)).replaceAll(sep, "/");
+  return local.startsWith("../") || local === ".." ? "(external)" : sanitizeDiagnosticSecrets(local || ".");
+}
+function optionalDiagnosticPath(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const path = value.path;
+  return typeof path === "string" && path ? path : void 0;
+}
+function isTileflowMapResolutionDiagnostic(value, path) {
+  if (!value || typeof value !== "object" || !path) return false;
+  const record = value;
+  return record.name === "TileflowMapResolutionError" && typeof record.code === "string" && typeof record.mapId === "string" && path.startsWith("/modules/") && !/[\p{Cc}]/u.test(path) && !/~(?:[^01]|$)/u.test(path);
+}
+function removeSemanticResolutionPath(message, path) {
+  if (!path) return message;
+  return message.replace(` at ${path}:`, ":");
+}
+function localPathAliases(path) {
+  return [.../* @__PURE__ */ new Set([resolve3(path), canonicalPath(path)])].sort(
+    (left, right) => right.length - left.length
+  );
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync.native(resolve3(path));
+  } catch {
+    return resolve3(path);
+  }
+}
+function normalizeDiagnostics(diagnostics) {
+  const bounded = diagnostics.map((diagnostic) => ({
+    ...diagnostic.code ? { code: boundDiagnosticField(diagnostic.code) } : {},
+    message: boundDiagnosticText(diagnostic.message, 300),
+    path: boundDiagnosticText(diagnostic.path, 300),
+    ...diagnostic.phase ? { phase: boundDiagnosticField(diagnostic.phase) } : {}
+  }));
+  bounded.sort((left, right) => {
+    const leftKey = `${left.path}\0${left.message}\0${left.code ?? ""}\0${left.phase ?? ""}`;
+    const rightKey = `${right.path}\0${right.message}\0${right.code ?? ""}\0${right.phase ?? ""}`;
+    return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+  });
+  return bounded.filter(
+    (diagnostic, index) => index === 0 || JSON.stringify(diagnostic) !== JSON.stringify(bounded[index - 1])
+  ).slice(0, 32);
+}
+function optionalDiagnosticField(value, key2) {
+  if (!value || typeof value !== "object") return void 0;
+  const field = value[key2];
+  return typeof field === "string" && field.trim() ? boundDiagnosticField(field) : void 0;
+}
+function optionalNestedDiagnosticField(value, key2) {
+  if (!value || typeof value !== "object") return void 0;
+  return optionalDiagnosticField(value.details, key2);
+}
+function boundDiagnosticField(value) {
+  return boundDiagnosticText(value.replace(/[^A-Za-z0-9_-]/g, ""), 64);
+}
+function boundDiagnosticText(value, limit) {
+  return value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
+}
+
+// src/hosted-native-artifacts.ts
+import { createHash as createHash4 } from "crypto";
+import { serializeCanonicalJson as serializeCanonicalJson2 } from "@tileflow/core";
+import {
+  inferTileflowDataRequirements,
+  inferTileflowSourceRequirements,
+  parseTileflowRendererDeploymentArtifact
+} from "@tileflow/core/build";
+import {
+  createTileflowNativeBuildRecord,
+  TileflowNativeCompatibilityError as TileflowNativeCompatibilityError3,
+  createTileflowNativeDiagnostic as createTileflowNativeDiagnostic2
+} from "@tileflow/core/native-profile";
+var digest2 = (value) => createHash4("sha256").update(serializeCanonicalJson2(value)).digest("hex");
+var invalidSource = () => new TileflowNativeCompatibilityError3([
+  createTileflowNativeDiagnostic2("NATIVE_UNSUPPORTED_SOURCE", "/sources")
+]);
+async function prepareTileflowHostedNativeDeployment(input) {
+  const webStyles = JSON.parse(serializeCanonicalJson2(input.styles));
+  const validationStyles = JSON.parse(
+    serializeCanonicalJson2(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 });
+  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 (serializeCanonicalJson2(style.sources) !== serializeCanonicalJson2(webStyles[name].sources))
+      throw invalidSource();
+  }
+  const nativeBuild = JSON.parse(
+    serializeCanonicalJson2(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: digest2(style),
+      dataRequirements: inferTileflowDataRequirements(style),
+      sourceRequirements: inferTileflowSourceRequirements(style)
+    };
+  }
+  const transformations = lowered.transformations.map((item) => ({
+    ...item,
+    inputStyleSha256: digest2(webStyles[item.theme]),
+    loweredStyleSha256: digest2({
+      ...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(digest2(nativeBuild), transformations),
+        styles: projected
+      }
+    }
+  });
+}
+
+// src/artifacts.ts
+import {
+  readTileflowLandmarkTileFootprints,
+  tileflowLandmarkRegionOf,
+  tileflowLandmarkRegionZoom,
+  tileflowLandmarkTileOf,
+  tileflowLandmarkTileZoom
+} from "@tileflow/core";
+var tileflowArtifactPlanSchemaVersion = 1;
+var tileflowArtifactInventoryFileName = ".tileflow-artifacts.json";
+var TileflowHostedManifestOverwriteError = class extends Error {
+  code = "HOSTED_MANIFEST_OVERWRITE_REFUSED";
+  constructor(path) {
+    super(
+      `Refusing to overwrite Hosted manifest at ${path}. Remove it, choose another output directory, or explicitly set overwriteHostedManifest: true.`
+    );
+    this.name = "TileflowHostedManifestOverwriteError";
+  }
+};
+var TileflowLocalTilesetProductionError = class extends Error {
+  code = "TF_LOCAL_TILESET_PRODUCTION_UNRESOLVED";
+  constructor() {
+    super(
+      "Production builds cannot publish local PMTiles sources. Publish the tileset explicitly or provide an application-owned production source."
+    );
+    this.name = "TileflowLocalTilesetProductionError";
+  }
+};
+function createTileflowManifest(project, options = {}) {
+  return createManifest(project, options);
+}
+function createTileflowStyle(project, mapName, options = {}) {
+  const style = createStyleFromCatalog(project, mapName, options);
+  assertValidTileflowStyle(style, mapName);
+  return style;
+}
+function createTileflowStyles(project, options = {}) {
+  const { mapAssets, ...styleOptions } = options;
+  const styles = createStylesFromCatalog(project, {
+    ...styleOptions,
+    mapAssets
+  });
+  assertValidTileflowStyles(project, styles);
+  return styles;
+}
+function createTileflowStylesWithInspection(project, options = {}) {
+  const { mapAssets, ...styleOptions } = options;
+  const inspected = createStylesFromCatalogWithInspection(project, {
+    ...styleOptions,
+    mapAssets
+  });
+  const styles = Object.fromEntries(
+    Object.entries(inspected).map(([mapName, family]) => [
+      mapName,
+      Object.fromEntries(
+        Object.entries(family).map(([themeName, result]) => [themeName, result.style])
+      )
+    ])
+  );
+  const inspections = Object.fromEntries(
+    Object.entries(inspected).map(([mapName, family]) => [
+      mapName,
+      Object.fromEntries(
+        Object.entries(family).map(([themeName, result]) => [themeName, result.inspection])
+      )
+    ])
+  );
+  assertValidTileflowStyles(project, styles);
+  return { inspections, styles };
+}
+function assertValidTileflowStyles(project, styles) {
+  const issues = [];
+  for (const mapName of getTileflowMapNames(project).sort(compareCodeUnits2)) {
+    const family = styles[mapName];
+    if (!family) continue;
+    for (const themeName of Object.keys(family).sort(compareCodeUnits2)) {
+      const style = family[themeName];
+      issues.push(...validateTileflowStyle(style, `${mapName}/${themeName}`));
+    }
+  }
+  if (issues.length > 0) {
+    throw new TileflowStyleValidationError(normalizeTileflowStyleValidationIssues(issues));
+  }
+}
+async function createTileflowArtifactPlan(prepared, options = {}) {
+  const renderer = resolveTileflowRenderer(options.renderer);
+  if (renderer === "native" && options.inspection) {
+    throw new TileflowNativeCompatibilityError4([
+      createTileflowNativeDiagnostic3("NATIVE_RENDERER_UNSUPPORTED", "/inspection")
+    ]);
+  }
+  assertNativeDevelopmentOrigin(options);
+  const nativeUrls = {
+    developmentOrigin: options.developmentOrigin
+  };
+  if (renderer === "native") {
+    assertTileflowNativeCompiledStyles(prepared.project, {}, nativeUrls);
+  } 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 compileStyles = renderer === "native" ? createStylesFromCatalog : createTileflowStyles;
+  const compiledStyles = inspected?.styles ?? compileStyles(prepared.project, {
+    apiBaseUrl: options.apiBaseUrl,
+    mapAssets: prepared.mapAssets
+  });
+  const embeddedImages = renderer === "native" ? prepareEmbeddedImageSources(compiledStyles) : { styles: compiledStyles, assets: [] };
+  const nativeLowering = renderer === "native" ? lowerTileflowNativeCompiledStyles(embeddedImages.styles, nativeUrls) : void 0;
+  const rendererStyles = nativeLowering?.styles ?? compiledStyles;
+  if (renderer === "native")
+    assertTileflowNativeCompiledStyles(prepared.project, rendererStyles, nativeUrls);
+  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: resolveRendererAssetBaseUrl(options),
+      baseDirectory: prepared.baseDirectory,
+      cwd: prepared.cwd,
+      target: "local"
+    }).catch((error) => {
+      if (renderer === "native" && error instanceof TileflowFontCompilationError) {
+        throw new TileflowNativeCompatibilityError4([
+          createTileflowNativeDiagnostic3("NATIVE_FONT_UNAVAILABLE", "/fonts")
+        ]);
+      }
+      throw error;
+    });
+    const assets = [...prepared.assets, ...preparedFonts.assets, ...embeddedImages.assets];
+    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(
+        Object.keys(prepared.project.maps).sort(compareCodeUnits2).map((mapName) => {
+          const map = prepared.project.maps[mapName];
+          const style = styles[mapName];
+          return [
+            mapName,
+            {
+              assets: getMapBuildAssets(
+                mapName,
+                assets,
+                preparedFonts.bundles[mapName]?.files ?? []
+              ),
+              lineage: prepared.project.mapMetadata?.[mapName]?.lineage ?? [
+                { id: map.id, mapVersion: map.version }
+              ],
+              map,
+              sourceAssets: {
+                fonts: preparedFonts.sourceIdentities[mapName] ?? [],
+                icons: prepared.mapIconSources[mapName] ?? [],
+                ...prepared.mapIconCompositions[mapName] ? { iconComposition: prepared.mapIconCompositions[mapName] } : {},
+                ...prepared.mapModelSources?.[mapName]?.length ? { models: prepared.mapModelSources[mapName] } : {}
+              },
+              styles: style
+            }
+          ];
+        })
+      ),
+      { provenance }
+    );
+    const stableManifest = renderer === "native" ? createManifest(prepared.project, {
+      styleBaseUrl: nativePublicBase(options.styleBaseUrl ?? ".")
+    }) : createFontAwareManifest(
+      createManifest(prepared.project, { styleBaseUrl: options.styleBaseUrl }),
+      styles
+    );
+    const inputs = {
+      directories: uniqueStrings(
+        [...prepared.watchPaths, ...preparedFonts.watchPaths].map(canonicalInputPath)
+      ),
+      files: uniqueStrings(
+        [...options.inputFiles ?? [], ...prepared.watchFiles, ...localTilesets.watchPaths].map(
+          canonicalInputPath
+        )
+      )
+    };
+    const partial = {
+      mapAssets: prepared.mapAssets,
+      assets,
+      buildManifest,
+      ...renderer === "native" ? {
+        nativeBuild: createTileflowNativeBuildRecord2(
+          hashBytes(serializeCanonicalJson3(buildManifest)),
+          nativeLowering.transformations
+        )
+      } : {},
+      dispose: localTilesets.dispose,
+      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])
+    };
+    const generation = hashArtifactGeneration(getStableTileflowArtifactFiles(partial));
+    const generatedManifest = createGenerationManifest(stableManifest, generation, assets);
+    const manifest = renderer === "native" ? parseTileflowRuntimeManifest(generatedManifest) : generatedManifest;
+    const generationArtifacts = { ...partial, manifest };
+    return {
+      ...generationArtifacts,
+      files: createGenerationArtifactFiles(generationArtifacts, generation, nativeUrls),
+      inputs,
+      project: prepared.project,
+      schemaVersion: tileflowArtifactPlanSchemaVersion,
+      sourceProject: prepared.sourceProject
+    };
+  } catch (error) {
+    await localTilesets.dispose().catch(() => void 0);
+    throw error;
+  }
+}
+async function createTileflowBuildArtifacts(options = {}) {
+  resolveTileflowRenderer(options.renderer);
+  assertNativeDevelopmentOrigin(options);
+  const loaded = await loadValidTileflowConfigWithInputs(
+    options.config ?? defaultTileflowConfigPath,
+    {
+      cwd: options.cwd,
+      fresh: true
+    }
+  );
+  const prepared = await prepareTileflowCatalogIcons(loaded.project, {
+    assetBaseUrl: resolveRendererAssetBaseUrl(options),
+    baseDirectory: dirname2(loaded.configFile),
+    cwd: options.cwd ?? process.cwd(),
+    ...options.icons ? { icons: options.icons } : {}
+  });
+  return await createTileflowArtifactPlan(prepared, { ...options, inputFiles: loaded.inputFiles });
+}
+function getTileflowArtifactFiles(artifacts) {
+  if ("files" in artifacts && Array.isArray(artifacts.files)) {
+    return validateArtifactFiles(artifacts.files);
+  }
+  return getStableTileflowArtifactFiles(artifacts);
+}
+function getStableTileflowArtifactFiles(artifacts) {
+  const files = [
+    {
+      contentType: "application/json; charset=utf-8",
+      fileName: tileflowMapBuildManifestFileName,
+      source: `${serializeCanonicalJson3(artifacts.buildManifest)}
+`
+    },
+    {
+      contentType: "application/json; charset=utf-8",
+      fileName: "manifest.json",
+      source: `${JSON.stringify(artifacts.manifest, null, 2)}
+`
+    },
+    ...Object.entries(artifacts.styles).flatMap(
+      ([mapName, themes]) => Object.entries(themes).map(([themeName, style]) => ({
+        contentType: "application/json; charset=utf-8",
+        fileName: `styles/${mapName}/${themeName}.json`,
+        source: `${JSON.stringify(style, null, 2)}
+`
+      }))
+    ),
+    ...artifacts.assets,
+    ...artifacts.nativeBuild ? [
+      {
+        contentType: "application/json; charset=utf-8",
+        fileName: tileflowNativeBuildRecordFileName,
+        source: `${serializeCanonicalJson3(artifacts.nativeBuild)}
+`
+      }
+    ] : []
+  ];
+  return validateArtifactFiles(files);
+}
+function validateArtifactFiles(files) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    assertTileflowArtifactFileName(file.fileName);
+    if (file.fileName === tileflowArtifactInventoryFileName) {
+      throw new Error(`${file.fileName} is reserved for the Tileflow artifact inventory.`);
+    }
+    if (seen.has(file.fileName)) {
+      throw new Error(`Duplicate Tileflow artifact file: ${file.fileName}`);
+    }
+    seen.add(file.fileName);
+  }
+  return [...files].sort((left, right) => compareCodeUnits2(left.fileName, right.fileName));
+}
+function createGenerationManifest(manifest, generation, assets) {
+  return {
+    ...manifest,
+    maps: Object.fromEntries(
+      Object.entries(manifest.maps).map(([mapName, map]) => [
+        mapName,
+        {
+          ...map,
+          themes: Object.fromEntries(
+            Object.entries(map.themes).map(([themeName, theme]) => [
+              themeName,
+              {
+                ...theme,
+                styleUrl: insertGenerationInPublicUrl(
+                  theme.styleUrl,
+                  `styles/${mapName}/${themeName}.json`,
+                  generation
+                ),
+                ...theme.fontFaces ? {
+                  fontFaces: theme.fontFaces.map((fontFace) => ({
+                    ...fontFace,
+                    source: retargetLocalFontAssetUrl(fontFace.source, assets, generation)
+                  }))
+                } : {}
+              }
+            ])
+          )
+        }
+      ])
+    )
+  };
+}
+function createGenerationArtifactFiles(artifacts, generation, nativeUrls) {
+  const prefix = `generations/${generation}`;
+  const stableFiles = getStableTileflowArtifactFiles(artifacts);
+  const immutableStyles = Object.entries(artifacts.styles).flatMap(
+    ([mapName, themes]) => Object.entries(themes).map(([themeName, style]) => {
+      const hasLocalSprite = artifacts.assets.some(
+        (asset) => asset.fileName.startsWith(`icons/${mapName}/`)
+      );
+      const sprite = style.sprite;
+      const generationStyleWithSprite = hasLocalSprite && typeof sprite === "string" ? {
+        ...style,
+        // Every theme in one logical map shares the same immutable sprite closure.
+        sprite: isRelativePublicUrl(sprite) ? sprite : insertGenerationInPublicUrl(sprite, `icons/${mapName}/sprite`, generation)
+      } : style;
+      const replaceFontSources = artifacts.nativeBuild ? replaceTileflowNativeFontSources : replaceTileflowStyleFontSources;
+      const generationStyle = replaceFontSources(
+        withGenerationBuildingModels(
+          generationStyleWithSprite,
+          mapName,
+          generation,
+          artifacts.assets
+        ),
+        (source) => retargetLocalFontAssetUrl(source, artifacts.assets, generation)
+      );
+      if (artifacts.nativeBuild)
+        assertTileflowNativeGeneratedStyle(generationStyle, mapName, themeName, nativeUrls);
+      return {
+        contentType: "application/json; charset=utf-8",
+        fileName: `${prefix}/styles/${mapName}/${themeName}.json`,
+        source: `${JSON.stringify(generationStyle, null, 2)}
+`
+      };
+    })
+  );
+  const immutableAssets = artifacts.assets.map((asset) => ({
+    ...asset,
+    fileName: `${prefix}/${asset.fileName}`
+  }));
+  return validateArtifactFiles([...stableFiles, ...immutableStyles, ...immutableAssets]);
+}
+function createFontAwareManifest(manifest, styles) {
+  const maps = Object.fromEntries(
+    Object.entries(manifest.maps).map(([mapName, map]) => [
+      mapName,
+      {
+        ...map,
+        themes: Object.fromEntries(
+          Object.entries(map.themes).map(([themeName, theme]) => {
+            const style = styles[mapName]?.[themeName];
+            if (!style) {
+              throw new Error(`Missing compiled Tileflow style for ${mapName}/${themeName}.`);
+            }
+            const definitions = getTileflowStyleFontFaces2(style);
+            return [themeName, { ...theme, fontFaces: definitions }];
+          })
+        )
+      }
+    ])
+  );
+  return parseTileflowRuntimeManifest({ ...manifest, maps });
+}
+function retargetLocalFontAssetUrl(source, assets, generation) {
+  if (isRelativePublicUrl(source)) return source;
+  const asset = assets.find(
+    (candidate) => candidate.fileName.startsWith("fonts/") && (source === candidate.fileName || source.endsWith(`/${candidate.fileName}`))
+  );
+  if (!asset) throw new Error(`Unable to resolve Tileflow font artifact URL: ${source}`);
+  return insertGenerationInPublicUrl(source, asset.fileName, generation);
+}
+function getMapBuildAssets(mapName, assets, fontAssets) {
+  const selected = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    if (asset.fileName.startsWith(`icons/${mapName}/`) || asset.fileName.startsWith(`models/${mapName}/`) || asset.fileName.startsWith(`images/${mapName}/`))
+      selected.set(asset.fileName, asset);
+  }
+  for (const asset of fontAssets) {
+    selected.set(asset.fileName, asset);
+  }
+  return [...selected.values()].sort(
+    (left, right) => compareCodeUnits2(left.fileName, right.fileName)
+  );
+}
+function hashBytes(source) {
+  return createHash5("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
+}
+async function createTileflowBuildProvenance(cwd) {
+  const projectDirectory = resolve4(cwd);
+  const projectRequire = createRequire(
+    resolve4(projectDirectory, "__tileflow_build_provenance__.cjs")
+  );
+  const toolRequire = createRequire(import.meta.url);
+  const packages = {};
+  packages["@tileflow/core"] = await readPackageVersion(
+    "@tileflow/core",
+    resolvePackageJson(projectRequire, "@tileflow/core") ?? resolvePackageJson(toolRequire, "@tileflow/core")
+  );
+  packages["@tileflow/dev"] = await readPackageVersion(
+    "@tileflow/dev",
+    new URL("../package.json", import.meta.url)
+  );
+  const mapsPackage = resolvePackageJson(projectRequire, "@tileflow/maps");
+  if (mapsPackage) {
+    packages["@tileflow/maps"] = await readPackageVersion("@tileflow/maps", mapsPackage);
+  }
+  const lockfile = await findNearestLockfile(projectDirectory);
+  return {
+    ...lockfile ? { lockfile: { format: lockfile.format, sha256: hashBytes(lockfile.source) } } : {},
+    packages,
+    schemaVersion: 1
+  };
+}
+function resolvePackageJson(require2, packageName) {
+  try {
+    return require2.resolve(`${packageName}/package.json`);
+  } catch {
+    return void 0;
+  }
+}
+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 readFile2(path, "utf8"));
+  } catch {
+    throw new Error(`Unable to read build package provenance for ${expectedName}.`);
+  }
+  if (!parsed || typeof parsed !== "object" || parsed.name !== expectedName || typeof parsed.version !== "string") {
+    throw new Error(`Invalid build package provenance for ${expectedName}.`);
+  }
+  return parsed.version;
+}
+async function findNearestLockfile(cwd) {
+  const candidates = [
+    { fileName: "pnpm-lock.yaml", format: "pnpm" },
+    { fileName: "package-lock.json", format: "npm" },
+    { fileName: "yarn.lock", format: "yarn" },
+    { fileName: "bun.lock", format: "bun" },
+    { fileName: "bun.lockb", format: "bun" }
+  ];
+  let directory = cwd;
+  while (true) {
+    for (const candidate of candidates) {
+      try {
+        return {
+          format: candidate.format,
+          source: await readFile2(resolve4(directory, candidate.fileName))
+        };
+      } catch (error) {
+        if (!hasErrorCode2(error, "ENOENT")) throw error;
+      }
+    }
+    const parent = dirname2(directory);
+    if (parent === directory) return void 0;
+    directory = parent;
+  }
+}
+function withGenerationBuildingModels(style, mapName, generation, assets) {
+  const metadata = style.metadata;
+  const buildings = metadata?.["tileflow:buildings"];
+  if (!buildings || !Array.isArray(buildings.models)) return style;
+  const models = buildings.models.map((entry) => {
+    const url = entry.url;
+    if (typeof url !== "string" || isRelativePublicUrl(url)) return entry;
+    const file = url.slice(url.lastIndexOf("/") + 1);
+    const logical = `models/${mapName}/${file}`;
+    if (!url.endsWith(`/${logical}`) || !assets.some((asset) => asset.fileName === logical))
+      return entry;
+    return {
+      ...entry,
+      url: insertGenerationInPublicUrl(url, logical, generation)
+    };
+  });
+  return {
+    ...style,
+    metadata: { ...metadata, "tileflow:buildings": { ...buildings, models } }
+  };
+}
+function insertGenerationInPublicUrl(url, logicalPath, generation) {
+  const marker = `/${logicalPath}`;
+  const index = url.lastIndexOf(marker);
+  if (index >= 0 && index + marker.length === url.length) {
+    return `${url.slice(0, index)}/generations/${generation}${marker}`;
+  }
+  if (url === logicalPath) return `generations/${generation}/${logicalPath}`;
+  throw new Error(`Unable to content-address Tileflow artifact URL: ${url}`);
+}
+function createTileflowArtifactSession(options = {}) {
+  return createTileflowArtifactSessionWithBuilder(
+    options,
+    createTileflowBuildArtifacts,
+    () => getTileflowWatchPaths(options)
+  );
+}
+async function getTileflowWatchPaths(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const loaded = await loadValidTileflowConfigWithInputs(
+    options.config ?? defaultTileflowConfigPath,
+    { cwd, fresh: true }
+  );
+  const [iconPaths, fontPaths] = await Promise.all([
+    getTileflowIconWatchPaths(loaded.project, cwd, dirname2(loaded.configFile)),
+    getTileflowFontWatchPaths(loaded.project, cwd, dirname2(loaded.configFile))
+  ]);
+  return uniqueStrings([...loaded.inputFiles, ...iconPaths, ...fontPaths]);
+}
+function isTileflowArtifactInputPath(inputs, path) {
+  const candidate = canonicalInputPath(path);
+  return inputs.files.some((input) => canonicalInputPath(input) === candidate) || inputs.directories.some((input) => isPathWithin(canonicalInputPath(input), candidate));
+}
+async function refreshTileflowArtifactSession(session, options) {
+  const inputs = getArtifactInputGraph(session.getLastGoodArtifacts());
+  if (options.inputPath && inputs && !isTileflowArtifactInputPath(inputs, options.inputPath)) {
+    return false;
+  }
+  await session.refresh(options.reason);
+  return true;
+}
+function getArtifactInputGraph(artifacts) {
+  if (!artifacts || !("inputs" in artifacts)) return void 0;
+  const inputs = artifacts.inputs;
+  return inputs && Array.isArray(inputs.files) && Array.isArray(inputs.directories) ? inputs : void 0;
+}
+async function writeTileflowBuildArtifacts(options) {
+  const artifacts = await createTileflowBuildArtifacts({ ...options, target: "production" });
+  try {
+    await writeTileflowArtifactPlan(artifacts, options);
+    return { ...artifacts, dispose: void 0, localTilesets: void 0 };
+  } finally {
+    await disposeTileflowBuildArtifacts(artifacts);
+  }
+}
+async function disposeTileflowBuildArtifacts(artifacts) {
+  const dispose = artifacts.dispose;
+  artifacts.dispose = void 0;
+  await dispose?.();
+}
+async function writeTileflowArtifactPlan(artifacts, options) {
+  assertNoLocalTilesetsForProduction(artifacts);
+  const cwd = options.cwd ?? process.cwd();
+  const outDir = artifacts.nativeBuild ? `${options.outDir.replace(/[\\/]$/u, "")}/native` : options.outDir;
+  const output = await prepareTileflowOutputDirectory(cwd, outDir);
+  const files = getTileflowArtifactFiles(artifacts);
+  await assertTileflowSelfHostedManifestTarget(resolve4(output.outDir, "manifest.json"), options);
+  await commitTileflowArtifactFiles(output, files);
+}
+function assertNoLocalTilesetsForProduction(artifacts) {
+  if (artifacts.localTilesets?.length) throw new TileflowLocalTilesetProductionError();
+}
+function hasLocalTilesetSources(project) {
+  return Object.values(project.maps).some((map) => Object.keys(map.sources ?? {}).length > 0);
+}
+async function assertTileflowSelfHostedManifestTarget(manifestPath, options = {}) {
+  if (options.overwriteHostedManifest) return;
+  let source;
+  try {
+    source = await readFile2(resolve4(manifestPath), "utf8");
+  } catch (error) {
+    if (hasErrorCode2(error, "ENOENT")) return;
+    throw error;
+  }
+  try {
+    const manifest = parseTileflowRuntimeManifest(JSON.parse(source));
+    if (isHostedRuntimeManifest(manifest)) {
+      throw new TileflowHostedManifestOverwriteError(resolve4(manifestPath));
+    }
+  } catch (error) {
+    if (error instanceof TileflowHostedManifestOverwriteError) throw error;
+  }
+}
+function isHostedRuntimeManifest(manifest) {
+  return Boolean(
+    manifest.apiUrl || Object.values(manifest.maps).some(
+      (map) => map.apiUrl || map.environment || map.mapId || map.usageMode || map.worldGeneration || Object.values(map.themes).some((theme) => theme.styleId)
+    )
+  );
+}
+function assertValidTileflowStyle(style, mapName) {
+  const issues = validateTileflowStyle(style, mapName);
+  if (issues.length > 0) {
+    throw new TileflowStyleValidationError(normalizeTileflowStyleValidationIssues(issues));
+  }
+}
+async function commitTileflowArtifactFiles(output, files) {
+  await assertTileflowOutputDirectoryIsSafe(output);
+  const { outDir } = output;
+  const previous = await readTileflowArtifactInventory(outDir);
+  const desiredNames = files.map((file) => file.fileName);
+  const generation = getArtifactGeneration(files);
+  const retainedGenerations = previous ? generation === previous.generation ? getManagedGenerations(previous.files) : [previous.generation] : [];
+  const retainedPrefixes = retainedGenerations.map((item) => `generations/${item}/`);
+  const retainedGenerationNames = previous ? previous.files.filter((name) => retainedPrefixes.some((prefix) => name.startsWith(prefix))) : [];
+  const retainedNames = uniqueStrings(retainedGenerationNames);
+  const inventoryNames = uniqueStrings([...desiredNames, ...retainedNames]);
+  const inventory = {
+    files: inventoryNames,
+    generation,
+    schemaVersion: 1
+  };
+  const inventoryFile = {
+    contentType: "application/json; charset=utf-8",
+    fileName: tileflowArtifactInventoryFileName,
+    source: `${JSON.stringify(inventory, null, 2)}
+`
+  };
+  const stagedFiles = [...files, inventoryFile];
+  const staleNames = (previous?.files ?? []).filter((name) => !inventoryNames.includes(name));
+  const affectedNames = uniqueStrings([
+    ...desiredNames,
+    ...staleNames,
+    tileflowArtifactInventoryFileName
+  ]);
+  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 mkdir3(dirname2(stagePath), { recursive: true });
+      await writeFileDurably(stagePath, file.source);
+    }
+    for (const name of affectedNames) {
+      await assertManagedTargetIsSafe(outDir, name);
+      const targetPath = managedPath(outDir, name);
+      if (!await isFile(targetPath)) continue;
+      const backupPath = managedPath(backupDir, name);
+      await mkdir3(dirname2(backupPath), { recursive: true });
+      await copyFile2(targetPath, backupPath);
+      backedUp.add(name);
+    }
+    const commitOrder = stagedFiles.map((file) => file.fileName).sort((left, right) => {
+      const leftRank = commitRank(left);
+      const rightRank = commitRank(right);
+      return leftRank - rightRank || compareCodeUnits2(left, right);
+    });
+    for (const name of commitOrder.filter(
+      (candidate) => candidate !== tileflowArtifactInventoryFileName
+    )) {
+      const sourcePath = managedPath(newDir, name);
+      const targetPath = managedPath(outDir, name);
+      await mkdir3(dirname2(targetPath), { recursive: true });
+      await rename2(sourcePath, targetPath);
+      installed.add(name);
+    }
+    for (const name of staleNames) {
+      await removeManagedFile(managedPath(outDir, name));
+    }
+    const stagedInventoryPath = managedPath(newDir, tileflowArtifactInventoryFileName);
+    const inventoryPath = managedPath(outDir, tileflowArtifactInventoryFileName);
+    await rename2(stagedInventoryPath, inventoryPath);
+    installed.add(tileflowArtifactInventoryFileName);
+  } catch (error) {
+    await rollbackManagedFiles(outDir, backupDir, affectedNames, backedUp, installed);
+    throw error;
+  } finally {
+    await rm3(stageDir, { force: true, recursive: true });
+  }
+}
+function getArtifactGeneration(files) {
+  const generations = getManagedGenerations(files.map((file) => file.fileName));
+  if (generations.length !== 1) {
+    throw new Error("A Tileflow artifact plan must contain exactly one content generation.");
+  }
+  return generations[0];
+}
+function getManagedGenerations(fileNames) {
+  return uniqueStrings(
+    fileNames.flatMap((fileName) => {
+      const match = /^generations\/([a-f0-9]{64})\//.exec(fileName);
+      return match?.[1] ? [match[1]] : [];
+    })
+  );
+}
+function commitRank(fileName) {
+  if (fileName === tileflowArtifactInventoryFileName) return 2;
+  if (fileName === "manifest.json") return 1;
+  return 0;
+}
+async function rollbackManagedFiles(outDir, backupDir, affectedNames, backedUp, installed) {
+  const rollbackErrors = [];
+  for (const name of [...affectedNames].reverse()) {
+    try {
+      const targetPath = managedPath(outDir, name);
+      if (installed.has(name) && !backedUp.has(name)) {
+        await removeManagedFile(targetPath);
+      }
+      if (backedUp.has(name)) {
+        await mkdir3(dirname2(targetPath), { recursive: true });
+        await copyFile2(managedPath(backupDir, name), targetPath);
+      }
+    } catch (error) {
+      rollbackErrors.push(error);
+    }
+  }
+  if (rollbackErrors.length > 0) {
+    throw new AggregateError(rollbackErrors, "Unable to restore the previous Tileflow generation.");
+  }
+}
+async function readTileflowArtifactInventory(outDir) {
+  const inventoryPath = managedPath(outDir, tileflowArtifactInventoryFileName);
+  let source;
+  try {
+    source = await readFile2(inventoryPath, "utf8");
+  } catch (error) {
+    if (hasErrorCode2(error, "ENOENT")) return void 0;
+    throw error;
+  }
+  let candidate;
+  try {
+    candidate = JSON.parse(source);
+  } catch {
+    throw new Error(`Invalid Tileflow artifact inventory: ${inventoryPath}`);
+  }
+  if (!candidate || typeof candidate !== "object" || candidate.schemaVersion !== 1 || typeof candidate.generation !== "string" || !/^[a-f0-9]{64}$/.test(candidate.generation) || !Array.isArray(candidate.files) || candidate.files.length > 1e4) {
+    throw new Error(`Invalid Tileflow artifact inventory: ${inventoryPath}`);
+  }
+  const files = candidate.files;
+  if (!files.every((name) => typeof name === "string")) {
+    throw new Error(`Invalid Tileflow artifact inventory: ${inventoryPath}`);
+  }
+  try {
+    for (const name of files) assertTileflowArtifactFileName(name);
+  } catch {
+    throw new Error(`Invalid Tileflow artifact inventory: ${inventoryPath}`);
+  }
+  if (new Set(files).size !== files.length || files.includes(tileflowArtifactInventoryFileName)) {
+    throw new Error(`Invalid Tileflow artifact inventory: ${inventoryPath}`);
+  }
+  return {
+    files: [...files],
+    generation: candidate.generation,
+    schemaVersion: 1
+  };
+}
+async function assertManagedTargetIsSafe(outDir, fileName) {
+  assertSafeManagedFileName(fileName);
+  const rootStats = await lstat3(outDir);
+  if (rootStats.isSymbolicLink()) {
+    throw new Error(`Tileflow refuses to write through a symbolic link: ${outDir}`);
+  }
+  if (!rootStats.isDirectory()) {
+    throw new Error(`Tileflow artifact output is not a directory: ${outDir}`);
+  }
+  const segments = fileName.split("/");
+  let current = outDir;
+  for (let index = 0; index < segments.length; index += 1) {
+    current = resolve4(current, segments[index]);
+    try {
+      const stats = await lstat3(current);
+      if (stats.isSymbolicLink()) {
+        throw new Error(`Tileflow refuses to write through a symbolic link: ${fileName}`);
+      }
+      if (index < segments.length - 1 && !stats.isDirectory()) {
+        throw new Error(`Tileflow artifact parent is not a directory: ${fileName}`);
+      }
+      if (index === segments.length - 1 && !stats.isFile()) {
+        throw new Error(`Tileflow artifact target is not a file: ${fileName}`);
+      }
+    } catch (error) {
+      if (hasErrorCode2(error, "ENOENT")) return;
+      throw error;
+    }
+  }
+}
+async function prepareTileflowOutputDirectory(cwd, 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 lstat3(logicalRoot);
+  if (!rootStats.isDirectory()) {
+    throw new Error(`Tileflow artifact working directory is not a directory: ${logicalRoot}`);
+  }
+  const rootDir = await realpath2(logicalRoot);
+  const relativeOutDir = relative2(logicalRoot, logicalOutDir);
+  const segments = relativeOutDir ? relativeOutDir.split(sep2) : [];
+  let current = rootDir;
+  for (const segment of segments) {
+    current = resolve4(current, segment);
+    let stats;
+    try {
+      stats = await lstat3(current);
+    } catch (error) {
+      if (!hasErrorCode2(error, "ENOENT")) throw error;
+      await mkdir3(current);
+      stats = await lstat3(current);
+    }
+    if (stats.isSymbolicLink()) {
+      throw new Error(`Tileflow refuses to write through a symbolic link: ${current}`);
+    }
+    if (!stats.isDirectory()) {
+      throw new Error(`Tileflow artifact output ancestor is not a directory: ${current}`);
+    }
+  }
+  const outDir = await realpath2(current);
+  const output = { outDir, rootDir };
+  await assertTileflowOutputDirectoryIsSafe(output);
+  return output;
+}
+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 lstat3(output.outDir);
+  if (stats.isSymbolicLink()) {
+    throw new Error(`Tileflow refuses to write through a symbolic link: ${output.outDir}`);
+  }
+  if (!stats.isDirectory()) {
+    throw new Error(`Tileflow artifact output is not a directory: ${output.outDir}`);
+  }
+  const canonicalOutDir = await realpath2(output.outDir);
+  if (canonicalOutDir !== output.outDir || !isPathWithin(output.rootDir, canonicalOutDir)) {
+    throw new Error(`Tileflow artifact output escapes its working directory: ${output.outDir}`);
+  }
+}
+function assertSafeManagedFileName(fileName) {
+  if (!fileName || fileName.includes("\\") || fileName.includes("\0") || fileName.startsWith("/") || fileName.endsWith("/") || fileName.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new Error(`Unsafe Tileflow artifact file name: ${fileName}`);
+  }
+}
+function assertTileflowArtifactFileName(fileName) {
+  assertSafeManagedFileName(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);
+  const imageMatch = /^images\/([^/]+)\/[a-f0-9]{64}\.png$/u.exec(logicalName);
+  const modelMatch = /^models\/([^/]+)\/[a-z0-9]+(?:-[a-z0-9]+)*-[a-f0-9]{16}\.glb$/u.exec(
+    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 || imageMatch && tileflowMapIdSchema.safeParse(imageMatch[1]).success || modelMatch && tileflowMapIdSchema.safeParse(modelMatch[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}`);
+}
+function managedPath(root, fileName) {
+  assertSafeManagedFileName(fileName);
+  const path = resolve4(root, ...fileName.split("/"));
+  if (!isPathWithin(root, path)) {
+    throw new Error(`Unsafe Tileflow artifact file name: ${fileName}`);
+  }
+  return path;
+}
+async function writeFileDurably(path, source) {
+  const handle = await open2(path, "wx");
+  try {
+    await handle.writeFile(source);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function isFile(path) {
+  try {
+    return (await lstat3(path)).isFile();
+  } catch (error) {
+    if (hasErrorCode2(error, "ENOENT")) return false;
+    throw error;
+  }
+}
+async function removeManagedFile(path) {
+  try {
+    const stats = await lstat3(path);
+    if (!stats.isFile()) throw new Error(`Refusing to remove non-file artifact target: ${path}`);
+    await unlink(path);
+  } catch (error) {
+    if (!hasErrorCode2(error, "ENOENT")) throw error;
+  }
+}
+function hashArtifactGeneration(files) {
+  const hash = createHash5("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");
+    hash.update(source);
+  }
+  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;
+}
+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)) {
+    return options.styleBaseUrl;
+  }
+  return "../..";
+}
+function isRelativePublicUrl(value) {
+  return !(value.startsWith("http://") || value.startsWith("https://") || value.startsWith("/") || value.startsWith("data:"));
+}
+function uniqueStrings(values) {
+  return [...new Set(values)].sort(compareCodeUnits2);
+}
+function hasErrorCode2(error, code) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
+}
+function canonicalInputPath(path) {
+  const resolved = resolve4(path);
+  try {
+    return realpathSync2.native(resolved);
+  } catch {
+    try {
+      return resolve4(realpathSync2.native(dirname2(resolved)), resolved.split(/[\\/]/).at(-1));
+    } catch {
+      return resolved;
+    }
+  }
+}
+
+export {
+  tileflowLineBackgroundGlyphRoute,
+  usesTileflowLineBackgroundGlyphs,
+  parseTileflowLineBackgroundGlyphPath,
+  createTileflowLineBackgroundGlyphResponder,
+  prepareTileflowLocalTilesets,
+  tileflowArtifactSessionSchemaVersion,
+  createTileflowArtifactDiagnostics,
+  prepareTileflowHostedNativeDeployment,
+  tileflowArtifactPlanSchemaVersion,
+  tileflowArtifactInventoryFileName,
+  TileflowHostedManifestOverwriteError,
+  TileflowLocalTilesetProductionError,
+  createTileflowManifest,
+  createTileflowStyle,
+  createTileflowStyles,
+  createTileflowArtifactPlan,
+  createTileflowBuildArtifacts,
+  getTileflowArtifactFiles,
+  createTileflowBuildProvenance,
+  createTileflowArtifactSession,
+  getTileflowWatchPaths,
+  isTileflowArtifactInputPath,
+  refreshTileflowArtifactSession,
+  writeTileflowBuildArtifacts,
+  disposeTileflowBuildArtifacts,
+  writeTileflowArtifactPlan,
+  assertNoLocalTilesetsForProduction,
+  assertTileflowSelfHostedManifestTarget,
+  readTileflowLandmarkTileFootprints,
+  tileflowLandmarkRegionOf,
+  tileflowLandmarkRegionZoom,
+  tileflowLandmarkTileOf,
+  tileflowLandmarkTileZoom
+};