@tileflow/dev 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/{chunk-O7PE6FB2.js → chunk-XTRHREXO.js}

@@ -1,12 +1,16 @@
+import {
+  inspectTileflowPmtilesForLocalUse
+} from "./chunk-ONYQNLNA.js";
 import {
   getTileflowFontWatchPaths,
+  joinTileflowPublicUrl,
   prepareTileflowStyleFonts,
   replaceTileflowStyleFontSources
-} from "./chunk-VEB43KDS.js";
+} from "./chunk-RSBV4L2Y.js";
 import {
   getTileflowIconWatchPaths,
   prepareTileflowCatalogIcons
-} from "./chunk-BALG4DSG.js";
+} from "./chunk-CENQR5Q2.js";
 import {
   TileflowStyleValidationError,
   normalizeTileflowStyleValidationIssues,
@@ -17,7 +21,7 @@ import {
   defaultTileflowConfigPath,
   getTileflowMapNames,
   loadValidTileflowConfigWithInputs
-} from "./chunk-BKHIZ7H2.js";
+} from "./chunk-6MGFMKG3.js";
 import {
   isPathWithin
 } from "./chunk-D4OE4ITL.js";
@@ -26,28 +30,27 @@ import {
 import { createHash } from "crypto";
 import { realpathSync as realpathSync2 } from "fs";
 import {
-  copyFile,
-  lstat,
-  mkdir,
+  copyFile as copyFile2,
+  lstat as lstat2,
+  mkdir as mkdir2,
   mkdtemp,
-  open,
+  open as open2,
   readFile,
-  realpath,
+  realpath as realpath2,
   rename,
-  rm,
+  rm as rm2,
   unlink
 } from "fs/promises";
 import { createRequire } from "module";
-import { dirname as dirname2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+import { dirname as dirname2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
 import {
-  compareCodeUnits,
+  compareCodeUnits as compareCodeUnits2,
   getTileflowStyleFontFaces,
   serializeCanonicalJson,
   tileflowMapIdSchema,
   tileflowThemeNameSchema
 } from "@tileflow/core";
 import {
-  collectTileflowMapBuildLineage,
   createManifest,
   createStyleFromCatalog,
   createStylesFromCatalog,
@@ -57,10 +60,325 @@ import {
 } from "@tileflow/core/build";
 import { parseTileflowRuntimeManifest } from "@tileflow/core/manifest";
 
+// src/local-tilesets.ts
+import { randomUUID } from "crypto";
+import { constants } from "fs";
+import { chmod, copyFile, lstat, mkdir, open, readdir, realpath, rm, stat } from "fs/promises";
+import { basename, resolve } from "path";
+import { 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 = resolve(options.cwd);
+  const projectRoot = await realpath(logicalProjectRoot).catch(() => logicalProjectRoot);
+  const snapshotStore = resolve(logicalProjectRoot, ".tileflow/cache/pmtiles-snapshots/v1");
+  await assertSafeSnapshotStore(logicalProjectRoot, snapshotStore);
+  await collectAbandonedSnapshotGenerations(snapshotStore);
+  const generationId = `snapshot-${process.pid}-${randomUUID().replaceAll("-", "")}`;
+  const generationDirectory = resolve(snapshotStore, generationId);
+  await mkdir(generationDirectory);
+  const 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 rm(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 = resolve(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 lstat(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 = resolve(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 = resolve(store, entry.name);
+    if (isPathWithin(store, path)) await rm(path, { force: true, recursive: true });
+  }
+}
+async function assertSafeSnapshotStore(projectRoot, store) {
+  const segments = [".tileflow", "cache", "pmtiles-snapshots", "v1"];
+  let current = projectRoot;
+  for (const segment of segments) {
+    current = resolve(current, segment);
+    try {
+      const value = await lstat(current);
+      if (!value.isDirectory() || value.isSymbolicLink()) {
+        throw new Error(`Local PMTiles snapshot path is unsafe: ${current}`);
+      }
+    } catch (error) {
+      if (!hasErrorCode(error, "ENOENT")) throw error;
+      await mkdir(current).catch((mkdirError) => {
+        if (!hasErrorCode(mkdirError, "EEXIST")) throw mkdirError;
+      });
+      const created = await lstat(current);
+      if (!created.isDirectory() || created.isSymbolicLink()) {
+        throw new Error(`Local PMTiles snapshot path is unsafe: ${current}`);
+      }
+    }
+  }
+  if (resolve(current) !== resolve(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/session.ts
 import { watch } from "chokidar";
 import { realpathSync } from "fs";
-import { dirname, extname, isAbsolute, relative, resolve, sep, win32 } from "path";
+import { dirname, extname, isAbsolute, relative, resolve as resolve2, sep, win32 } from "path";
 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"]);
@@ -96,20 +414,23 @@ var TileflowArtifactSessionImpl = class {
   #ignoredPaths;
   #watchEnabled;
   #closed = false;
+  #closing;
   #debounceTimer;
   #generation = 0;
-  #lastGoodArtifacts;
+  #current;
+  #artifactGenerations = /* @__PURE__ */ new Set();
   #lastGoodGeneration;
+  #refreshes = /* @__PURE__ */ new Set();
   #refreshToken = 0;
   #state = { generation: 0, status: "building" };
   #watcher;
   #watchedArtifactPaths = /* @__PURE__ */ new Set();
   constructor(options, buildArtifacts, discoverWatchPaths) {
-    this.#cwd = resolve(options.cwd ?? process.cwd());
-    this.#configPath = resolve(this.#cwd, options.config ?? "tileflow.config.ts");
+    this.#cwd = resolve2(options.cwd ?? process.cwd());
+    this.#configPath = resolve2(this.#cwd, options.config ?? "tileflow.config.ts");
     this.#debounceMs = Math.max(0, Math.min(options.debounceMs ?? 75, 1e3));
     this.#watchEnabled = options.watch ?? false;
-    this.#ignoredPaths = (options.ignoredPaths ?? []).map((path) => resolve(this.#cwd, path));
+    this.#ignoredPaths = (options.ignoredPaths ?? []).map((path) => resolve2(this.#cwd, path));
     this.#buildArtifacts = buildArtifacts;
     this.#discoverWatchPaths = discoverWatchPaths;
     this.#buildOptions = {
@@ -118,7 +439,8 @@ var TileflowArtifactSessionImpl = class {
       config: options.config,
       cwd: this.#cwd,
       inspection: options.inspection,
-      styleBaseUrl: options.styleBaseUrl
+      styleBaseUrl: options.styleBaseUrl,
+      target: options.target
     };
   }
   async start() {
@@ -165,7 +487,27 @@ var TileflowArtifactSessionImpl = class {
     return this.#state;
   }
   getLastGoodArtifacts() {
-    return this.#lastGoodArtifacts;
+    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;
@@ -173,6 +515,15 @@ var TileflowArtifactSessionImpl = class {
     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;
@@ -183,10 +534,20 @@ var TileflowArtifactSessionImpl = class {
     });
     try {
       const artifacts = await this.#buildArtifacts(this.#buildOptions);
-      if (this.#closed || token !== this.#refreshToken) return;
-      this.#lastGoodArtifacts = artifacts;
+      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,
@@ -206,16 +567,27 @@ var TileflowArtifactSessionImpl = class {
       this.#publishInvalid(generation, error);
     }
   }
-  async close() {
-    if (this.#closed) return;
+  close() {
+    this.#closing ??= this.#close();
+    return this.#closing;
+  }
+  async #close() {
     this.#closed = true;
     this.#refreshToken += 1;
     if (this.#debounceTimer) clearTimeout(this.#debounceTimer);
     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 = resolve(path);
+    const resolvedPath = resolve2(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;
@@ -229,7 +601,7 @@ var TileflowArtifactSessionImpl = class {
     return true;
   }
   #shouldRefreshForWatchEvent(path) {
-    const resolvedPath = resolve(path);
+    const resolvedPath = resolve2(path);
     const extension = extname(resolvedPath).toLowerCase();
     if (!iconExtensions.has(extension) && !fontExtensions.has(extension)) return true;
     return [...this.#watchedArtifactPaths].some((path2) => isSameOrInside(path2, resolvedPath));
@@ -257,7 +629,7 @@ var TileflowArtifactSessionImpl = class {
   }
   #updateArtifactWatchPaths(paths) {
     if (!this.#watcher) return;
-    const next = new Set(paths.map((path) => resolve(this.#cwd, path)));
+    const next = new Set(paths.map((path) => resolve2(this.#cwd, path)));
     const previous = this.#watchedArtifactPaths;
     this.#watchedArtifactPaths = next;
     for (const path of previous) {
@@ -271,14 +643,54 @@ var TileflowArtifactSessionImpl = class {
       }
     }
   }
+  #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(resolve(root), resolve(candidate));
+  const path = relative(resolve2(root), resolve2(candidate));
   return path === "" || !isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`);
 }
 function createTileflowArtifactDiagnostics(error, cwd) {
   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(
@@ -293,8 +705,11 @@ function createTileflowArtifactDiagnostics(error, cwd) {
   return normalizeDiagnostics([
     {
       ...inheritedCode ? { code: inheritedCode } : {},
-      message: sanitizeMessage(error instanceof Error ? error.message : "Unknown build error", cwd),
-      path: "",
+      message: sanitizeMessage(
+        error instanceof Error ? removeSemanticResolutionPath(error.message, semanticResolutionPath) : "Unknown build error",
+        cwd
+      ),
+      path: semanticResolutionPath ?? sanitizePath(inheritedPath ?? "", cwd),
       ...inheritedPhase ? { phase: inheritedPhase } : {}
     }
   ]);
@@ -348,20 +763,34 @@ function sanitizeMessage(value, cwd) {
 function sanitizePath(value, cwd) {
   if (!value) return "";
   if (win32.isAbsolute(value) && !isAbsolute(value)) return "(external)";
-  if (!isAbsolute(value)) return value.replaceAll("\\", "/");
+  if (!isAbsolute(value)) return sanitizeDiagnosticSecrets(value.replaceAll("\\", "/"));
   const local = relative(canonicalPath(cwd), canonicalPath(value)).replaceAll(sep, "/");
-  return local.startsWith("../") || local === ".." ? "(external)" : local || ".";
+  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([resolve(path), canonicalPath(path)])].sort(
+  return [.../* @__PURE__ */ new Set([resolve2(path), canonicalPath(path)])].sort(
     (left, right) => right.length - left.length
   );
 }
 function canonicalPath(path) {
   try {
-    return realpathSync.native(resolve(path));
+    return realpathSync.native(resolve2(path));
   } catch {
-    return resolve(path);
+    return resolve2(path);
   }
 }
 function normalizeDiagnostics(diagnostics) {
@@ -408,6 +837,15 @@ var TileflowHostedManifestOverwriteError = class extends Error {
     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);
 }
@@ -452,10 +890,10 @@ function createTileflowStylesWithInspection(project, options = {}) {
 }
 function assertValidTileflowStyles(project, styles) {
   const issues = [];
-  for (const mapName of getTileflowMapNames(project).sort(compareCodeUnits)) {
+  for (const mapName of getTileflowMapNames(project).sort(compareCodeUnits2)) {
     const family = styles[mapName];
     if (!family) continue;
-    for (const themeName of Object.keys(family).sort(compareCodeUnits)) {
+    for (const themeName of Object.keys(family).sort(compareCodeUnits2)) {
       const style = family[themeName];
       issues.push(...validateTileflowStyle(style, `${mapName}/${themeName}`));
     }
@@ -465,6 +903,9 @@ function assertValidTileflowStyles(project, styles) {
   }
 }
 async function createTileflowArtifactPlan(prepared, options = {}) {
+  if (options.target === "production" && hasLocalTilesetSources(prepared.project)) {
+    throw new TileflowLocalTilesetProductionError();
+  }
   const inspected = options.inspection ? createTileflowStylesWithInspection(prepared.project, {
     apiBaseUrl: options.apiBaseUrl,
     mapAssets: prepared.mapAssets
@@ -473,71 +914,87 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
     apiBaseUrl: options.apiBaseUrl,
     mapAssets: prepared.mapAssets
   });
-  const preparedFonts = await prepareTileflowStyleFonts(prepared.project, compiledStyles, {
+  const localTilesets = await prepareTileflowLocalTilesets(prepared.project, compiledStyles, {
     assetBaseUrl: resolveAssetBaseUrl(options),
     baseDirectory: prepared.baseDirectory,
-    cwd: prepared.cwd,
-    target: "local"
+    cwd: prepared.cwd
   });
-  const styles = preparedFonts.styles;
-  const assets = [...prepared.assets, ...preparedFonts.assets];
-  const provenance = await createTileflowBuildProvenance(prepared.cwd);
-  const buildManifest = await createTileflowMapBuildManifest(
-    Object.fromEntries(
-      Object.keys(prepared.project.maps).sort(compareCodeUnits).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 ?? collectTileflowMapBuildLineage(map),
-            map,
-            sourceAssets: {
-              fonts: preparedFonts.sourceIdentities[mapName] ?? [],
-              icons: prepared.mapIconSources[mapName] ?? []
-            },
-            styles: style
-          }
-        ];
-      })
-    ),
-    { provenance }
-  );
-  const stableManifest = createFontAwareManifest(
-    createManifest(prepared.project, { styleBaseUrl: options.styleBaseUrl }),
-    styles
-  );
-  const inputs = {
-    directories: uniqueStrings(
-      [...prepared.watchPaths, ...preparedFonts.watchPaths].map(canonicalInputPath)
-    ),
-    files: uniqueStrings((options.inputFiles ?? []).map(canonicalInputPath))
-  };
-  const partial = {
-    assets,
-    buildManifest,
-    manifest: stableManifest,
-    project: prepared.project,
-    ...inspected ? { styleInspections: inspected.inspections } : {},
-    styles,
-    watchPaths: uniqueStrings([...inputs.files, ...inputs.directories])
-  };
-  const generation = hashArtifactGeneration(getStableTileflowArtifactFiles(partial));
-  const manifest = createGenerationManifest(stableManifest, generation, assets);
-  const generationArtifacts = { ...partial, manifest };
-  return {
-    ...generationArtifacts,
-    files: createGenerationArtifactFiles(generationArtifacts, generation),
-    inputs,
-    project: prepared.project,
-    schemaVersion: tileflowArtifactPlanSchemaVersion,
-    sourceProject: prepared.sourceProject
-  };
+  try {
+    const preparedFonts = await prepareTileflowStyleFonts(prepared.project, localTilesets.styles, {
+      assetBaseUrl: resolveAssetBaseUrl(options),
+      baseDirectory: prepared.baseDirectory,
+      cwd: prepared.cwd,
+      target: "local"
+    });
+    const styles = preparedFonts.styles;
+    const assets = [...prepared.assets, ...preparedFonts.assets];
+    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] ?? []
+              },
+              styles: style
+            }
+          ];
+        })
+      ),
+      { provenance }
+    );
+    const stableManifest = createFontAwareManifest(
+      createManifest(prepared.project, { styleBaseUrl: options.styleBaseUrl }),
+      styles
+    );
+    const inputs = {
+      directories: uniqueStrings(
+        [...prepared.watchPaths, ...preparedFonts.watchPaths].map(canonicalInputPath)
+      ),
+      files: uniqueStrings(
+        [...options.inputFiles ?? [], ...localTilesets.watchPaths].map(canonicalInputPath)
+      )
+    };
+    const partial = {
+      assets,
+      buildManifest,
+      dispose: localTilesets.dispose,
+      manifest: stableManifest,
+      project: prepared.project,
+      ...localTilesets.files.length > 0 ? { localTilesets: localTilesets.files } : {},
+      ...inspected ? { styleInspections: inspected.inspections } : {},
+      styles,
+      watchPaths: uniqueStrings([...inputs.files, ...inputs.directories])
+    };
+    const generation = hashArtifactGeneration(getStableTileflowArtifactFiles(partial));
+    const manifest = createGenerationManifest(stableManifest, generation, assets);
+    const generationArtifacts = { ...partial, manifest };
+    return {
+      ...generationArtifacts,
+      files: createGenerationArtifactFiles(generationArtifacts, generation),
+      inputs,
+      project: prepared.project,
+      schemaVersion: tileflowArtifactPlanSchemaVersion,
+      sourceProject: prepared.sourceProject
+    };
+  } catch (error) {
+    await localTilesets.dispose().catch(() => void 0);
+    throw error;
+  }
 }
 async function createTileflowBuildArtifacts(options = {}) {
   const loaded = await loadValidTileflowConfigWithInputs(
@@ -598,7 +1055,7 @@ function validateArtifactFiles(files) {
     }
     seen.add(file.fileName);
   }
-  return [...files].sort((left, right) => compareCodeUnits(left.fileName, right.fileName));
+  return [...files].sort((left, right) => compareCodeUnits2(left.fileName, right.fileName));
 }
 function createGenerationManifest(manifest, generation, assets) {
   return {
@@ -701,16 +1158,16 @@ function getMapBuildAssets(mapName, assets, fontAssets) {
     selected.set(asset.fileName, asset);
   }
   return [...selected.values()].sort(
-    (left, right) => compareCodeUnits(left.fileName, right.fileName)
+    (left, right) => compareCodeUnits2(left.fileName, right.fileName)
   );
 }
 function hashBytes(source) {
   return createHash("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
 }
 async function createTileflowBuildProvenance(cwd) {
-  const projectDirectory = resolve2(cwd);
+  const projectDirectory = resolve3(cwd);
   const projectRequire = createRequire(
-    resolve2(projectDirectory, "__tileflow_build_provenance__.cjs")
+    resolve3(projectDirectory, "__tileflow_build_provenance__.cjs")
   );
   const toolRequire = createRequire(import.meta.url);
   const packages = {};
@@ -767,10 +1224,10 @@ async function findNearestLockfile(cwd) {
       try {
         return {
           format: candidate.format,
-          source: await readFile(resolve2(directory, candidate.fileName))
+          source: await readFile(resolve3(directory, candidate.fileName))
         };
       } catch (error) {
-        if (!hasErrorCode(error, "ENOENT")) throw error;
+        if (!hasErrorCode2(error, "ENOENT")) throw error;
       }
     }
     const parent = dirname2(directory);
@@ -824,30 +1281,46 @@ function getArtifactInputGraph(artifacts) {
   return inputs && Array.isArray(inputs.files) && Array.isArray(inputs.directories) ? inputs : void 0;
 }
 async function writeTileflowBuildArtifacts(options) {
-  const artifacts = await createTileflowBuildArtifacts(options);
-  await writeTileflowArtifactPlan(artifacts, options);
-  return artifacts;
+  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 output = await prepareTileflowOutputDirectory(cwd, options.outDir);
   const files = getTileflowArtifactFiles(artifacts);
-  await assertTileflowSelfHostedManifestTarget(resolve2(output.outDir, "manifest.json"), options);
+  await assertTileflowSelfHostedManifestTarget(resolve3(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 readFile(resolve2(manifestPath), "utf8");
+    source = await readFile(resolve3(manifestPath), "utf8");
   } catch (error) {
-    if (hasErrorCode(error, "ENOENT")) return;
+    if (hasErrorCode2(error, "ENOENT")) return;
     throw error;
   }
   try {
     const manifest = parseTileflowRuntimeManifest(JSON.parse(source));
     if (isHostedRuntimeManifest(manifest)) {
-      throw new TileflowHostedManifestOverwriteError(resolve2(manifestPath));
+      throw new TileflowHostedManifestOverwriteError(resolve3(manifestPath));
     }
   } catch (error) {
     if (error instanceof TileflowHostedManifestOverwriteError) throw error;
@@ -874,7 +1347,8 @@ async function commitTileflowArtifactFiles(output, files) {
   const generation = getArtifactGeneration(files);
   const retainedGenerations = previous ? generation === previous.generation ? getManagedGenerations(previous.files) : [previous.generation] : [];
   const retainedPrefixes = retainedGenerations.map((item) => `generations/${item}/`);
-  const retainedNames = previous ? previous.files.filter((name) => retainedPrefixes.some((prefix) => name.startsWith(prefix))) : [];
+  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,
@@ -894,15 +1368,15 @@ async function commitTileflowArtifactFiles(output, files) {
     ...staleNames,
     tileflowArtifactInventoryFileName
   ]);
-  const stageDir = await mkdtemp(resolve2(outDir, ".tileflow-stage-"));
-  const newDir = resolve2(stageDir, "new");
-  const backupDir = resolve2(stageDir, "backup");
+  const stageDir = await mkdtemp(resolve3(outDir, ".tileflow-stage-"));
+  const newDir = resolve3(stageDir, "new");
+  const backupDir = resolve3(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 mkdir(dirname2(stagePath), { recursive: true });
+      await mkdir2(dirname2(stagePath), { recursive: true });
       await writeFileDurably(stagePath, file.source);
     }
     for (const name of affectedNames) {
@@ -910,21 +1384,21 @@ async function commitTileflowArtifactFiles(output, files) {
       const targetPath = managedPath(outDir, name);
       if (!await isFile(targetPath)) continue;
       const backupPath = managedPath(backupDir, name);
-      await mkdir(dirname2(backupPath), { recursive: true });
-      await copyFile(targetPath, backupPath);
+      await mkdir2(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 || compareCodeUnits(left, 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 mkdir(dirname2(targetPath), { recursive: true });
+      await mkdir2(dirname2(targetPath), { recursive: true });
       await rename(sourcePath, targetPath);
       installed.add(name);
     }
@@ -939,7 +1413,7 @@ async function commitTileflowArtifactFiles(output, files) {
     await rollbackManagedFiles(outDir, backupDir, affectedNames, backedUp, installed);
     throw error;
   } finally {
-    await rm(stageDir, { force: true, recursive: true });
+    await rm2(stageDir, { force: true, recursive: true });
   }
 }
 function getArtifactGeneration(files) {
@@ -971,8 +1445,8 @@ async function rollbackManagedFiles(outDir, backupDir, affectedNames, backedUp,
         await removeManagedFile(targetPath);
       }
       if (backedUp.has(name)) {
-        await mkdir(dirname2(targetPath), { recursive: true });
-        await copyFile(managedPath(backupDir, name), targetPath);
+        await mkdir2(dirname2(targetPath), { recursive: true });
+        await copyFile2(managedPath(backupDir, name), targetPath);
       }
     } catch (error) {
       rollbackErrors.push(error);
@@ -988,7 +1462,7 @@ async function readTileflowArtifactInventory(outDir) {
   try {
     source = await readFile(inventoryPath, "utf8");
   } catch (error) {
-    if (hasErrorCode(error, "ENOENT")) return void 0;
+    if (hasErrorCode2(error, "ENOENT")) return void 0;
     throw error;
   }
   let candidate;
@@ -1020,7 +1494,7 @@ async function readTileflowArtifactInventory(outDir) {
 }
 async function assertManagedTargetIsSafe(outDir, fileName) {
   assertSafeManagedFileName(fileName);
-  const rootStats = await lstat(outDir);
+  const rootStats = await lstat2(outDir);
   if (rootStats.isSymbolicLink()) {
     throw new Error(`Tileflow refuses to write through a symbolic link: ${outDir}`);
   }
@@ -1030,9 +1504,9 @@ async function assertManagedTargetIsSafe(outDir, fileName) {
   const segments = fileName.split("/");
   let current = outDir;
   for (let index = 0; index < segments.length; index += 1) {
-    current = resolve2(current, segments[index]);
+    current = resolve3(current, segments[index]);
     try {
-      const stats = await lstat(current);
+      const stats = await lstat2(current);
       if (stats.isSymbolicLink()) {
         throw new Error(`Tileflow refuses to write through a symbolic link: ${fileName}`);
       }
@@ -1043,34 +1517,34 @@ async function assertManagedTargetIsSafe(outDir, fileName) {
         throw new Error(`Tileflow artifact target is not a file: ${fileName}`);
       }
     } catch (error) {
-      if (hasErrorCode(error, "ENOENT")) return;
+      if (hasErrorCode2(error, "ENOENT")) return;
       throw error;
     }
   }
 }
 async function prepareTileflowOutputDirectory(cwd, requestedOutDir) {
-  const logicalRoot = resolve2(cwd);
-  const logicalOutDir = resolve2(logicalRoot, requestedOutDir);
+  const logicalRoot = resolve3(cwd);
+  const logicalOutDir = resolve3(logicalRoot, requestedOutDir);
   if (!isPathWithin(logicalRoot, logicalOutDir)) {
     throw new Error(`Tileflow artifact output escapes its working directory: ${logicalOutDir}`);
   }
-  const rootStats = await lstat(logicalRoot);
+  const rootStats = await lstat2(logicalRoot);
   if (!rootStats.isDirectory()) {
     throw new Error(`Tileflow artifact working directory is not a directory: ${logicalRoot}`);
   }
-  const rootDir = await realpath(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 = resolve2(current, segment);
+    current = resolve3(current, segment);
     let stats;
     try {
-      stats = await lstat(current);
+      stats = await lstat2(current);
     } catch (error) {
-      if (!hasErrorCode(error, "ENOENT")) throw error;
-      await mkdir(current);
-      stats = await lstat(current);
+      if (!hasErrorCode2(error, "ENOENT")) throw error;
+      await mkdir2(current);
+      stats = await lstat2(current);
     }
     if (stats.isSymbolicLink()) {
       throw new Error(`Tileflow refuses to write through a symbolic link: ${current}`);
@@ -1079,7 +1553,7 @@ async function prepareTileflowOutputDirectory(cwd, requestedOutDir) {
       throw new Error(`Tileflow artifact output ancestor is not a directory: ${current}`);
     }
   }
-  const outDir = await realpath(current);
+  const outDir = await realpath2(current);
   const output = { outDir, rootDir };
   await assertTileflowOutputDirectoryIsSafe(output);
   return output;
@@ -1088,14 +1562,14 @@ 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 lstat(output.outDir);
+  const stats = await lstat2(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 realpath(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}`);
   }
@@ -1110,21 +1584,21 @@ function assertTileflowArtifactFileName(fileName) {
   const logicalName = fileName.replace(/^generations\/[a-f0-9]{64}\//, "");
   const styleMatch = /^styles\/([^/]+)\/([^/]+)\.json$/u.exec(logicalName);
   const iconMatch = /^icons\/([^/]+)\/sprite(?:@2x)?\.(?:json|png)$/u.exec(logicalName);
-  if (fileName === "manifest.json" || fileName === tileflowMapBuildManifestFileName || styleMatch && tileflowMapIdSchema.safeParse(styleMatch[1]).success && tileflowThemeNameSchema.safeParse(styleMatch[2]).success || iconMatch && tileflowMapIdSchema.safeParse(iconMatch[1]).success || /^fonts\/[a-z0-9]+(?:-[a-z0-9]+)*-[a-f0-9]{64}\.(?:otf|ttf|woff2)$/.test(logicalName) || /^fonts\/licenses\/license-[a-f0-9]{64}\.txt$/.test(logicalName)) {
+  if (fileName === "manifest.json" || fileName === tileflowMapBuildManifestFileName || styleMatch && tileflowMapIdSchema.safeParse(styleMatch[1]).success && tileflowThemeNameSchema.safeParse(styleMatch[2]).success || iconMatch && tileflowMapIdSchema.safeParse(iconMatch[1]).success || /^tilesets\/[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.pmtiles$/u.test(logicalName) || /^fonts\/[a-z0-9]+(?:-[a-z0-9]+)*-[a-f0-9]{64}\.(?:otf|ttf|woff2)$/.test(logicalName) || /^fonts\/licenses\/license-[a-f0-9]{64}\.txt$/.test(logicalName)) {
     return;
   }
   throw new Error(`Unexpected Tileflow managed artifact file name: ${fileName}`);
 }
 function managedPath(root, fileName) {
   assertSafeManagedFileName(fileName);
-  const path = resolve2(root, ...fileName.split("/"));
+  const path = resolve3(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 open(path, "wx");
+  const handle = await open2(path, "wx");
   try {
     await handle.writeFile(source);
     await handle.sync();
@@ -1134,19 +1608,19 @@ async function writeFileDurably(path, source) {
 }
 async function isFile(path) {
   try {
-    return (await lstat(path)).isFile();
+    return (await lstat2(path)).isFile();
   } catch (error) {
-    if (hasErrorCode(error, "ENOENT")) return false;
+    if (hasErrorCode2(error, "ENOENT")) return false;
     throw error;
   }
 }
 async function removeManagedFile(path) {
   try {
-    const stats = await lstat(path);
+    const stats = await lstat2(path);
     if (!stats.isFile()) throw new Error(`Refusing to remove non-file artifact target: ${path}`);
     await unlink(path);
   } catch (error) {
-    if (!hasErrorCode(error, "ENOENT")) throw error;
+    if (!hasErrorCode2(error, "ENOENT")) throw error;
   }
 }
 function hashArtifactGeneration(files) {
@@ -1169,18 +1643,18 @@ function isRelativePublicUrl(value) {
   return !(value.startsWith("http://") || value.startsWith("https://") || value.startsWith("/") || value.startsWith("data:"));
 }
 function uniqueStrings(values) {
-  return [...new Set(values)].sort(compareCodeUnits);
+  return [...new Set(values)].sort(compareCodeUnits2);
 }
-function hasErrorCode(error, code) {
+function hasErrorCode2(error, code) {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
 }
 function canonicalInputPath(path) {
-  const resolved = resolve2(path);
+  const resolved = resolve3(path);
   try {
     return realpathSync2.native(resolved);
   } catch {
     try {
-      return resolve2(realpathSync2.native(dirname2(resolved)), resolved.split(/[\\/]/).at(-1));
+      return resolve3(realpathSync2.native(dirname2(resolved)), resolved.split(/[\\/]/).at(-1));
     } catch {
       return resolved;
     }
@@ -1188,11 +1662,13 @@ function canonicalInputPath(path) {
 }
 
 export {
+  prepareTileflowLocalTilesets,
   tileflowArtifactSessionSchemaVersion,
   createTileflowArtifactDiagnostics,
   tileflowArtifactPlanSchemaVersion,
   tileflowArtifactInventoryFileName,
   TileflowHostedManifestOverwriteError,
+  TileflowLocalTilesetProductionError,
   createTileflowManifest,
   createTileflowStyle,
   createTileflowStyles,
@@ -1205,6 +1681,8 @@ export {
   isTileflowArtifactInputPath,
   refreshTileflowArtifactSession,
   writeTileflowBuildArtifacts,
+  disposeTileflowBuildArtifacts,
   writeTileflowArtifactPlan,
+  assertNoLocalTilesetsForProduction,
   assertTileflowSelfHostedManifestTarget
 };