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

package/dist/index.js

@@ -1,2608 +1,170 @@
-// src/index.ts
-import { createJiti } from "jiti";
-import { existsSync, readFileSync, realpathSync as realpathSync2 } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import { createRequire } from "module";
-import { dirname as dirname2, isAbsolute as isAbsolute3, join, relative as relative3, resolve as resolve3, sep as sep3 } from "path";
 import {
-  compareCodeUnits as compareCodeUnits3,
-  createManifest,
-  createStyleFromProject as createStyleFromProject2,
-  normalizeTileflowCaptureScene,
-  validateConfig
-} from "@tileflow/core";
-
-// src/icons.ts
-import { readdir, readFile, realpath, stat } from "fs/promises";
-import { basename, extname, isAbsolute, relative, resolve, sep } from "path";
-import { fileURLToPath } from "url";
-import { SaxesParser } from "saxes";
+  TileflowConfigInspectionError,
+  inspectLoadedTileflowConfig,
+  inspectTileflowConfig,
+  inspectTileflowFeatures
+} from "./chunk-ZOYFZ3MT.js";
 import {
-  compareCodeUnits,
-  hashTileflowIconPackageManifest,
-  hashTileflowRenderedIconPixels,
-  serializeCanonicalJson,
-  sha256Hex,
-  tileflowHostedIconIdPattern,
-  tileflowIconPackageLabelSchema,
-  tileflowIconPackageLimits,
-  tileflowIconPackageManifestSchema,
-  tileflowStreetsPoiIconMapping
-} from "@tileflow/core";
-var TileflowIconCompilationError = class extends Error {
-  code = "ICON_INVALID";
-  issues;
-  phase = "icon-compilation";
-  constructor(issues) {
-    super(
-      [
-        "Invalid Tileflow icon package",
-        ...issues.map((issue) => `- ${issue.path}: ${issue.message}`)
-      ].join("\n")
-    );
-    this.name = "TileflowIconCompilationError";
-    this.issues = issues;
-  }
-};
-var iconFileExtensions = /* @__PURE__ */ new Set([".svg", ".png", ".jpg", ".jpeg", ".webp"]);
-var iconSpriteSize = 24;
-var streetsPoiIconSourceDir = fileURLToPath(new URL("../assets/streets-poi", import.meta.url));
-async function compileTileflowIconPackages(project, options) {
-  const result = await compileIconSources(project, options);
-  const packagesByHash = /* @__PURE__ */ new Map();
-  for (const compiled of result.compiledBySource.values()) {
-    packagesByHash.set(compiled.package.contentHash, compiled.package);
-  }
-  const bindings = result.resolvedRequests.map((request) => {
-    const compiled = result.compiledBySource.get(request.realSourceDir);
-    if (!compiled) {
-      throw new Error(`Missing compiled icon package for map ${request.mapName}`);
-    }
-    return {
-      label: request.label,
-      mapName: request.mapName,
-      ...request.mapping ? { mapping: request.mapping } : {},
-      packageHash: compiled.package.contentHash
-    };
-  });
-  return {
-    bindings,
-    packages: [...packagesByHash.values()].sort(
-      (left, right) => compareCodeUnits(left.contentHash, right.contentHash)
-    ),
-    watchPaths: [
-      ...new Set(
-        result.resolvedRequests.filter((request) => !request.builtIn).map((request) => request.realSourceDir)
-      )
-    ].sort(compareCodeUnits)
-  };
-}
-async function inspectTileflowIconCatalogs(project, options) {
-  const result = await compileIconSources(project, {
-    cwd: options.cwd,
-    mapNames: options.mapNames,
-    target: "local"
-  });
-  const resolvedByMap = new Map(
-    result.resolvedRequests.map((request) => [request.mapName, request])
-  );
-  const mappedFromBySource = /* @__PURE__ */ new Map();
-  const maps = result.mapRequests.map((request) => {
-    if (request.kind !== "local") {
-      return {
-        name: request.mapName,
-        icons: {
-          inspectable: false,
-          kind: request.kind,
-          mappings: createCatalogMappings(request.mapping, "unknown")
-        }
-      };
-    }
-    const resolved = resolvedByMap.get(request.mapName);
-    if (!resolved || !result.realCwd) {
-      throw new Error(`Missing resolved icon source for map ${request.mapName}`);
-    }
-    const compiled = result.compiledBySource.get(resolved.realSourceDir);
-    if (!compiled) {
-      throw new Error(`Missing compiled icon catalog for map ${request.mapName}`);
-    }
-    const iconNames = new Set(compiled.package.manifest.iconNames);
-    const mappings = createCatalogMappings(
-      request.mapping,
-      (iconId) => iconNames.has(iconId) ? "present" : "missing"
-    );
-    const mappedFromByIcon = mappedFromBySource.get(resolved.realSourceDir) ?? /* @__PURE__ */ new Map();
-    for (const mapping of mappings) {
-      if (mapping.targetStatus !== "present") {
-        continue;
-      }
-      const mappedFrom = mappedFromByIcon.get(mapping.iconId) ?? [];
-      mappedFrom.push({ map: request.mapName, semantic: mapping.semantic });
-      mappedFromByIcon.set(mapping.iconId, mappedFrom);
-    }
-    mappedFromBySource.set(resolved.realSourceDir, mappedFromByIcon);
-    return {
-      name: request.mapName,
-      icons: {
-        catalogSourcePath: relativePortablePath(result.realCwd, resolved.realSourceDir),
-        kind: "local",
-        label: request.label,
-        mappings,
-        packageHash: compiled.package.contentHash
-      }
-    };
-  });
-  if (!result.realCwd) {
-    return { catalogs: [], maps };
-  }
-  const realCwd = result.realCwd;
-  const catalogs = [...result.compiledBySource.entries()].map(([realSourceDir, compiled]) => {
-    const sourcePath2 = relativePortablePath(realCwd, realSourceDir);
-    const mappedFromByIcon = mappedFromBySource.get(realSourceDir) ?? /* @__PURE__ */ new Map();
-    return {
-      compiledPackage: compiled.package,
-      icons: compiled.icons.map((icon, index) => {
-        const manifestIcon = compiled.package.manifest.renderedIcons[index];
-        const oneXAtlas = compiled.layoutOneX.index[icon.input.name];
-        const twoXAtlas = compiled.layoutTwoX.index[icon.input.name];
-        if (!manifestIcon || manifestIcon.name !== icon.input.name || !oneXAtlas || !twoXAtlas) {
-          throw new Error(`Missing compiled catalog metadata for icon ${icon.input.name}`);
-        }
-        return {
-          id: icon.input.name,
-          mappedFrom: [...mappedFromByIcon.get(icon.input.name) ?? []].sort(compareMappedFrom),
-          rendered: {
-            oneX: {
-              atlas: atlasRectangle(oneXAtlas),
-              height: icon.oneX.height,
-              pixelRatio: 1,
-              pixelSha256: manifestIcon.pixelSha256.oneX,
-              width: icon.oneX.width
-            },
-            twoX: {
-              atlas: atlasRectangle(twoXAtlas),
-              height: icon.twoX.height,
-              pixelRatio: 2,
-              pixelSha256: manifestIcon.pixelSha256.twoX,
-              width: icon.twoX.width
-            }
-          },
-          source: {
-            byteLength: icon.input.source.byteLength,
-            dimensions: { ...icon.dimensions },
-            format: icon.input.format,
-            path: relativePortablePath(realCwd, icon.input.path)
-          }
-        };
-      }),
-      insideWorkingTree: isPathInside(realCwd, realSourceDir),
-      sourcePath: sourcePath2
-    };
-  }).sort((left, right) => compareCodeUnits(left.sourcePath, right.sourcePath));
-  return { catalogs, maps };
-}
-async function compileIconSources(project, options) {
-  const mapRequests = getMapIconRequests(project, options.cwd, options.mapNames);
-  const requests = mapRequests.filter(
-    (request) => request.kind === "local"
-  );
-  if (requests.length === 0) {
-    return {
-      compiledBySource: /* @__PURE__ */ new Map(),
-      mapRequests,
-      realCwd: null,
-      resolvedRequests: []
-    };
-  }
-  const issues = [];
-  const realCwd = await resolveWorkingDirectory(options.cwd, issues);
-  const resolvedRequests = [];
-  for (const request of requests) {
-    try {
-      const realSourceDir = await realpath(request.sourceDir);
-      if (options.target === "hosted" && realCwd && !request.builtIn && !isPathInside(realCwd, realSourceDir)) {
-        issues.push({
-          message: "Hosted icon sources must remain inside the selected working tree",
-          path: sourcePath(request.mapName)
-        });
-        continue;
-      }
-      const sourceStat = await stat(realSourceDir);
-      if (!sourceStat.isDirectory()) {
-        issues.push({
-          message: "Icon source must be a directory",
-          path: sourcePath(request.mapName)
-        });
-        continue;
-      }
-      resolvedRequests.push({ ...request, realSourceDir });
-    } catch (error) {
-      issues.push({
-        message: describeFileSystemError(error, "Icon source was not found"),
-        path: sourcePath(request.mapName)
-      });
-    }
-  }
-  const inspectedBySource = /* @__PURE__ */ new Map();
-  const requestsBySource = groupRequestsBySource(resolvedRequests);
-  for (const [realSourceDir, sourceRequests] of requestsBySource) {
-    const representative = sourceRequests[0];
-    if (!representative) {
-      continue;
-    }
-    const inspected = await inspectIconSource(
-      representative,
-      realSourceDir,
-      realCwd,
-      options.target,
-      issues
-    );
-    if (inspected) {
-      inspectedBySource.set(realSourceDir, inspected);
-    }
-  }
-  if (issues.length > 0) {
-    throw new TileflowIconCompilationError(issues);
-  }
-  const compiledBySource = /* @__PURE__ */ new Map();
-  for (const [realSourceDir, inspected] of inspectedBySource) {
-    const representative = requestsBySource.get(realSourceDir)?.[0];
-    if (!representative) {
-      continue;
-    }
-    try {
-      compiledBySource.set(realSourceDir, await compileInspectedIconSource(inspected));
-    } catch (error) {
-      issues.push({
-        message: error instanceof Error ? error.message : "Icon compilation failed",
-        path: sourcePath(representative.mapName)
-      });
-    }
-  }
-  if (issues.length > 0) {
-    throw new TileflowIconCompilationError(issues);
-  }
-  return { compiledBySource, mapRequests, realCwd, resolvedRequests };
-}
-async function prepareTileflowProjectIcons(project, options) {
-  const nextProject = cloneProject(project);
-  const compiled = await compileTileflowIconPackages(project, {
-    cwd: options.cwd,
-    target: "local"
-  });
-  const packagesByHash = new Map(
-    compiled.packages.map((iconPackage) => [iconPackage.contentHash, iconPackage])
-  );
-  const assets = [];
-  for (const binding of compiled.bindings) {
-    const mapConfig = nextProject.maps[binding.mapName];
-    const iconPackage = packagesByHash.get(binding.packageHash);
-    if (!mapConfig || !iconPackage) {
-      continue;
-    }
-    const spriteUrl = joinUrl(options.assetBaseUrl, `icons/${binding.mapName}/sprite`);
-    mapConfig.icons = {
-      ...binding.mapping ? { mapping: binding.mapping } : {},
-      sprite: spriteUrl
-    };
-    for (const file of iconPackage.files) {
-      assets.push({
-        contentType: file.contentType === "application/json" ? "application/json; charset=utf-8" : file.contentType,
-        fileName: `icons/${binding.mapName}/${file.fileName}`,
-        source: file.contentType === "application/json" ? new TextDecoder().decode(file.source) : file.source
-      });
-    }
-  }
-  return {
-    assets,
-    project: nextProject,
-    watchPaths: compiled.watchPaths
-  };
-}
-function getTileflowIconWatchPaths(project, cwd) {
-  return uniqueStrings(
-    getLocalIconRequests(project, cwd).filter((request) => !request.builtIn).map((request) => request.sourceDir)
-  ).sort(compareCodeUnits);
-}
-function getLocalIconRequests(project, cwd) {
-  return getMapIconRequests(project, cwd).filter(
-    (request) => request.kind === "local"
-  );
-}
-function getMapIconRequests(project, cwd, mapNames) {
-  const selectedNames = (mapNames === void 0 ? Object.keys(project.maps) : [...new Set(mapNames)]).sort(compareCodeUnits);
-  return selectedNames.map((mapName) => {
-    const mapConfig = project.maps[mapName];
-    if (!mapConfig) {
-      throw new Error(`Unknown Tileflow map: ${mapName}`);
-    }
-    const iconSet = resolveIconSet(mapConfig.icons, project.icons);
-    if (!iconSet?.source && !iconSet?.sprite && usesBuiltInStreetsPoiIcons(mapConfig)) {
-      const mapping2 = sortMapping({ ...tileflowStreetsPoiIconMapping, ...iconSet?.mapping });
-      return {
-        builtIn: true,
-        kind: "local",
-        label: "tileflow-streets",
-        mapName,
-        ...mapping2 ? { mapping: mapping2 } : {},
-        source: "@tileflow/dev/assets/streets-poi",
-        sourceDir: streetsPoiIconSourceDir
-      };
-    }
-    const mapping = sortMapping(iconSet?.mapping);
-    if (iconSet?.source) {
-      return {
-        kind: "local",
-        label: resolvePackageLabel(mapConfig.icons, iconSet.source, project.icons, mapName),
-        mapName,
-        ...mapping ? { mapping } : {},
-        source: iconSet.source,
-        sourceDir: resolve(cwd, iconSet.source)
-      };
-    }
-    return {
-      kind: iconSet?.sprite ? "external" : "none",
-      mapName,
-      ...mapping ? { mapping } : {}
-    };
-  });
-}
-function usesBuiltInStreetsPoiIcons(mapConfig) {
-  const poi = mapConfig.modules?.poi;
-  return mapConfig.basemap?.type === "streets" && poi?.enabled !== false && poi?.preset !== "none" && poi?.icons !== false;
-}
-function resolveIconSet(icons, iconSets, path = []) {
-  if (!icons) {
-    return void 0;
-  }
-  if (typeof icons === "string") {
-    const referenced = iconSets?.[icons];
-    if (referenced) {
-      if (path.includes(icons)) {
-        throw new Error(`Circular Tileflow icon set extends: ${[...path, icons].join(" -> ")}`);
-      }
-      return resolveIconSet(referenced, iconSets, [...path, icons]);
-    }
-    return isRemoteSpriteReference(icons) ? { sprite: icons } : { source: icons };
-  }
-  const extended = icons.extends ? resolveIconSet(icons.extends, iconSets, path) : void 0;
-  return {
-    ...extended,
-    ...icons,
-    mapping: {
-      ...extended?.mapping,
-      ...icons.mapping
-    }
-  };
-}
-async function resolveWorkingDirectory(cwd, issues) {
-  try {
-    const resolved = await realpath(cwd);
-    if (!(await stat(resolved)).isDirectory()) {
-      throw new Error("Working tree is not a directory");
-    }
-    return resolved;
-  } catch (error) {
-    issues.push({
-      message: describeFileSystemError(error, "Selected working tree was not found"),
-      path: "cwd"
-    });
-    return null;
-  }
-}
-function groupRequestsBySource(requests) {
-  const result = /* @__PURE__ */ new Map();
-  for (const request of requests) {
-    const existing = result.get(request.realSourceDir) ?? [];
-    existing.push(request);
-    result.set(request.realSourceDir, existing);
-  }
-  return result;
-}
-async function inspectIconSource(request, realSourceDir, realCwd, target, issues) {
-  let entries;
-  try {
-    entries = await readdir(realSourceDir, { withFileTypes: true });
-  } catch (error) {
-    issues.push({
-      message: describeFileSystemError(error, "Icon source could not be read"),
-      path: sourcePath(request.mapName)
-    });
-    return null;
-  }
-  entries.sort((left, right) => compareCodeUnits(left.name, right.name));
-  const candidates = [];
-  const names = /* @__PURE__ */ new Set();
-  let aggregateBytes = 0;
-  for (const entry of entries) {
-    const entryPath = resolve(realSourceDir, entry.name);
-    const path = iconPath(request.mapName, entry.name);
-    if (entry.isDirectory()) {
-      if (target === "hosted") {
-        issues.push({ message: "Nested directories are not supported", path });
-      }
-      continue;
-    }
-    let entryStat;
-    let realEntryPath = entryPath;
-    try {
-      if (entry.isSymbolicLink()) {
-        if (target === "local") {
-          continue;
-        }
-        realEntryPath = await realpath(entryPath);
-        if (!realCwd || !isPathInside(realCwd, realEntryPath)) {
-          issues.push({ message: "Icon symlink escapes the selected working tree", path });
-          continue;
-        }
-      }
-      entryStat = await stat(realEntryPath);
-    } catch (error) {
-      if (target === "hosted") {
-        issues.push({
-          message: describeFileSystemError(error, "Icon entry could not be read"),
-          path
-        });
-      }
-      continue;
-    }
-    if (!entryStat.isFile()) {
-      if (target === "hosted") {
-        issues.push({ message: "Icon entries must be regular files", path });
-      }
-      continue;
-    }
-    const extension = extname(entry.name).toLowerCase();
-    if (!iconFileExtensions.has(extension)) {
-      continue;
-    }
-    const name = entry.name.slice(0, -extname(entry.name).length);
-    if (names.has(name)) {
-      issues.push({
-        message: `Duplicate icon basename "${name}"`,
-        path
-      });
-      continue;
-    }
-    names.add(name);
-    if (target === "hosted" && !tileflowHostedIconIdPattern.test(name)) {
-      issues.push({
-        message: "Hosted icon IDs must match ^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
-        path
-      });
-    }
-    if (entryStat.size > tileflowIconPackageLimits.maxSourceFileBytes) {
-      issues.push({
-        message: `Icon source exceeds ${tileflowIconPackageLimits.maxSourceFileBytes} bytes`,
-        path
-      });
-    }
-    aggregateBytes += entryStat.size;
-    candidates.push({
-      fileName: entry.name,
-      format: iconSourceFormat(extension),
-      name,
-      path: realEntryPath,
-      size: entryStat.size
-    });
-  }
-  candidates.sort((left, right) => compareCodeUnits(left.name, right.name));
-  if (candidates.length === 0) {
-    issues.push({
-      message: "No supported .svg, .png, .jpg, .jpeg, or .webp icon files were found",
-      path: sourcePath(request.mapName)
-    });
-  }
-  if (candidates.length > tileflowIconPackageLimits.maxIconCount) {
-    issues.push({
-      message: `Icon source contains more than ${tileflowIconPackageLimits.maxIconCount} icons`,
-      path: sourcePath(request.mapName)
-    });
-  }
-  if (aggregateBytes > tileflowIconPackageLimits.maxSourceBytes) {
-    issues.push({
-      message: `Icon source exceeds ${tileflowIconPackageLimits.maxSourceBytes} aggregate bytes`,
-      path: sourcePath(request.mapName)
-    });
-  }
-  if (issues.length > 0) {
-    return null;
-  }
-  const icons = [];
-  for (const candidate of candidates) {
-    const displayPath = iconPath(request.mapName, candidate.fileName);
-    try {
-      const source = await readFile(candidate.path);
-      if (source.byteLength !== candidate.size || source.byteLength > tileflowIconPackageLimits.maxSourceFileBytes) {
-        throw new Error("Icon changed while it was being validated");
-      }
-      if (target === "hosted" && extname(candidate.fileName).toLowerCase() === ".svg") {
-        validateHostedSvg(source, displayPath);
-      }
-      icons.push({
-        fileName: candidate.fileName,
-        format: candidate.format,
-        name: candidate.name,
-        path: candidate.path,
-        source
-      });
-    } catch (error) {
-      issues.push({
-        message: error instanceof Error ? error.message : "Icon could not be read",
-        path: displayPath
-      });
-    }
-  }
-  if (issues.length > 0) {
-    return null;
-  }
-  return { icons, realSourceDir };
-}
-async function compileInspectedIconSource(inspected) {
-  const layoutOneX = createSpriteLayout(inspected.icons, 1);
-  const layoutTwoX = createSpriteLayout(inspected.icons, 2);
-  const rendered = await mapWithConcurrency(
-    inspected.icons,
-    tileflowIconPackageLimits.decodeConcurrency,
-    async (icon) => {
-      const dimensions = await validateDecodedDimensions(icon);
-      const oneX = await renderIcon(icon, 1);
-      const twoX = await renderIcon(icon, 2);
-      return {
-        dimensions,
-        input: icon,
-        oneX,
-        pixelSha256: {
-          oneX: await hashTileflowRenderedIconPixels({
-            height: oneX.height,
-            pixelRatio: 1,
-            rgba: oneX.rgba,
-            width: oneX.width
-          }),
-          twoX: await hashTileflowRenderedIconPixels({
-            height: twoX.height,
-            pixelRatio: 2,
-            rgba: twoX.rgba,
-            width: twoX.width
-          })
-        },
-        twoX
-      };
-    }
-  );
-  const [oneXImage, twoXImage] = await Promise.all([
-    createSpriteImage(
-      rendered.map((item) => item.oneX),
-      layoutOneX
-    ),
-    createSpriteImage(
-      rendered.map((item) => item.twoX),
-      layoutTwoX
-    )
-  ]);
-  const oneXJson = new TextEncoder().encode(`${serializeCanonicalJson(layoutOneX.index)}
-`);
-  const twoXJson = new TextEncoder().encode(`${serializeCanonicalJson(layoutTwoX.index)}
-`);
-  const files = [
-    { contentType: "application/json", fileName: "sprite.json", source: oneXJson },
-    { contentType: "image/png", fileName: "sprite.png", source: oneXImage },
-    { contentType: "application/json", fileName: "sprite@2x.json", source: twoXJson },
-    { contentType: "image/png", fileName: "sprite@2x.png", source: twoXImage }
-  ];
-  assertGeneratedFileLimits(files);
-  const fileDigests = await Promise.all(files.map((file) => sha256Hex(file.source)));
-  const manifest = tileflowIconPackageManifestSchema.parse({
-    files: files.map((file, index) => ({
-      byteLength: file.source.byteLength,
-      contentType: file.contentType,
-      name: file.fileName,
-      sha256: fileDigests[index]
-    })),
-    format: "tileflow-icon-package-v1",
-    iconNames: inspected.icons.map((icon) => icon.name),
-    renderedIcons: inspected.icons.map((icon, index) => {
-      const pixels = rendered[index];
-      if (!pixels) {
-        throw new Error(`Missing rendered pixels for ${icon.name}`);
-      }
-      return { name: icon.name, pixelSha256: pixels.pixelSha256 };
-    }),
-    sprites: {
-      oneX: { height: layoutOneX.height, pixelRatio: 1, width: layoutOneX.width },
-      twoX: { height: layoutTwoX.height, pixelRatio: 2, width: layoutTwoX.width }
-    }
-  });
-  return {
-    icons: rendered,
-    layoutOneX,
-    layoutTwoX,
-    package: {
-      contentHash: await hashTileflowIconPackageManifest(manifest),
-      files,
-      manifest
-    }
-  };
-}
-function createSpriteLayout(icons, pixelRatio) {
-  const cellSize = iconSpriteSize * pixelRatio;
-  const columns = Math.ceil(Math.sqrt(icons.length));
-  const rows = Math.ceil(icons.length / columns);
-  const width = columns * cellSize;
-  const height = rows * cellSize;
-  if (width > tileflowIconPackageLimits.maxAtlasDimension || height > tileflowIconPackageLimits.maxAtlasDimension) {
-    throw new Error(
-      `Generated sprite exceeds ${tileflowIconPackageLimits.maxAtlasDimension} pixels per dimension`
-    );
-  }
-  const index = Object.fromEntries(
-    icons.map((icon, indexNumber) => {
-      const column = indexNumber % columns;
-      const row = Math.floor(indexNumber / columns);
-      return [
-        icon.name,
-        {
-          height: cellSize,
-          pixelRatio,
-          width: cellSize,
-          x: column * cellSize,
-          y: row * cellSize
-        }
-      ];
-    })
-  );
-  return { cellSize, columns, height, index, width };
-}
-async function validateDecodedDimensions(icon) {
-  const sharp = await loadSharp();
-  const metadata = await sharp(icon.source, {
-    density: 72,
-    failOn: "error",
-    limitInputPixels: tileflowIconPackageLimits.maxDecodedPixelsPerIcon
-  }).metadata();
-  const width = metadata.width ?? 0;
-  const height = metadata.height ?? 0;
-  if (width <= 0 || height <= 0) {
-    throw new Error(`Unable to determine decoded dimensions for ${icon.fileName}`);
-  }
-  if (width * height > tileflowIconPackageLimits.maxDecodedPixelsPerIcon) {
-    throw new Error(
-      `${icon.fileName} exceeds ${tileflowIconPackageLimits.maxDecodedPixelsPerIcon} decoded pixels`
-    );
-  }
-  return { height, width };
-}
-async function renderIcon(icon, pixelRatio) {
-  const sharp = await loadSharp();
-  const cellSize = iconSpriteSize * pixelRatio;
-  const { data, info } = await sharp(icon.source, {
-    density: 72 * pixelRatio,
-    failOn: "error",
-    limitInputPixels: tileflowIconPackageLimits.maxDecodedPixelsPerIcon
-  }).resize(cellSize, cellSize, {
-    background: { alpha: 0, b: 0, g: 0, r: 0 },
-    fit: "contain"
-  }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-  if (info.channels !== 4 || info.width !== cellSize || info.height !== cellSize) {
-    throw new Error(`Rendered icon ${icon.fileName} did not produce canonical RGBA pixels`);
-  }
-  const rgba = new Uint8Array(data);
-  const png = await sharp(data, {
-    raw: { channels: 4, height: info.height, width: info.width }
-  }).png({ adaptiveFiltering: false, compressionLevel: 9, palette: false }).toBuffer();
-  return { height: info.height, png, rgba, width: info.width };
-}
-async function createSpriteImage(icons, layout) {
-  const sharp = await loadSharp();
-  const atlas = new Uint8Array(layout.width * layout.height * 4);
-  for (const [indexNumber, icon] of icons.entries()) {
-    if (icon.width !== layout.cellSize || icon.height !== layout.cellSize) {
-      throw new Error("Rendered icon dimensions do not match the sprite layout");
-    }
-    const left = indexNumber % layout.columns * layout.cellSize;
-    const top = Math.floor(indexNumber / layout.columns) * layout.cellSize;
-    const rowBytes = icon.width * 4;
-    for (let row = 0; row < icon.height; row += 1) {
-      const sourceStart = row * rowBytes;
-      const targetStart = ((top + row) * layout.width + left) * 4;
-      atlas.set(icon.rgba.subarray(sourceStart, sourceStart + rowBytes), targetStart);
-    }
-  }
-  return sharp(atlas, {
-    raw: {
-      channels: 4,
-      height: layout.height,
-      width: layout.width
-    }
-  }).png({ adaptiveFiltering: false, compressionLevel: 9, palette: false }).toBuffer();
-}
-function assertGeneratedFileLimits(files) {
-  let totalBytes = 0;
-  for (const file of files) {
-    if (file.source.byteLength > tileflowIconPackageLimits.maxGeneratedFileBytes) {
-      throw new Error(
-        `${file.fileName} exceeds ${tileflowIconPackageLimits.maxGeneratedFileBytes} generated bytes`
-      );
-    }
-    totalBytes += file.source.byteLength;
-  }
-  if (totalBytes > tileflowIconPackageLimits.maxGeneratedPackageBytes) {
-    throw new Error(
-      `Generated package exceeds ${tileflowIconPackageLimits.maxGeneratedPackageBytes} bytes`
-    );
-  }
-}
-function validateHostedSvg(source, displayPath) {
-  const parser = new SaxesParser({ fileName: displayPath, xmlns: true });
-  const decoder = new TextDecoder("utf-8", { fatal: true });
-  let styleDepth = 0;
-  let styleText = "";
-  parser.on("doctype", () => {
-    throw new Error("Hosted SVGs cannot contain a document type or entity declarations");
-  });
-  parser.on("processinginstruction", (instruction) => {
-    if (instruction.target.toLowerCase() === "xml-stylesheet") {
-      throw new Error("Hosted SVGs cannot load external stylesheets");
-    }
-  });
-  parser.on("opentag", (tag) => {
-    const localName = tag.local.toLowerCase();
-    if (localName === "script") {
-      throw new Error("Hosted SVGs cannot contain scripts");
-    }
-    if (localName === "style") {
-      styleDepth += 1;
-    }
-    for (const attribute of Object.values(tag.attributes)) {
-      const attributeName = attribute.local.toLowerCase();
-      const value = attribute.value.trim();
-      if (attributeName.startsWith("on")) {
-        throw new Error("Hosted SVGs cannot contain script event handlers");
-      }
-      if (attributeName === "href" && value.length > 0 && !value.startsWith("#")) {
-        throw new Error("Hosted SVG resource references must use local fragments");
-      }
-      if (containsExternalCssUrl(value)) {
-        throw new Error("Hosted SVG resource references must use local fragments");
-      }
-    }
-  });
-  parser.on("text", (text) => {
-    if (styleDepth > 0) {
-      styleText += text;
-    }
-  });
-  parser.on("cdata", (text) => {
-    if (styleDepth > 0) {
-      styleText += text;
-    }
-  });
-  parser.on("closetag", (tag) => {
-    if (tag.local.toLowerCase() !== "style") {
-      return;
-    }
-    styleDepth -= 1;
-    if (styleDepth === 0) {
-      if (styleText.toLowerCase().includes("@import") || containsExternalCssUrl(styleText)) {
-        throw new Error("Hosted SVGs cannot load external stylesheets or resources");
-      }
-      styleText = "";
-    }
-  });
-  parser.on("error", (error) => {
-    throw error;
-  });
-  const chunkBytes = 64 * 1024;
-  for (let offset = 0; offset < source.byteLength; offset += chunkBytes) {
-    parser.write(decoder.decode(source.subarray(offset, offset + chunkBytes), { stream: true }));
-  }
-  parser.write(decoder.decode());
-  parser.close();
-}
-function containsExternalCssUrl(value) {
-  const lowerValue = value.toLowerCase();
-  let cursor = 0;
-  while (cursor < value.length) {
-    const start = lowerValue.indexOf("url(", cursor);
-    if (start === -1) {
-      return false;
-    }
-    const end = value.indexOf(")", start + 4);
-    if (end === -1) {
-      return true;
-    }
-    const rawTarget = value.slice(start + 4, end).trim();
-    const target = stripMatchingQuotes(rawTarget);
-    if (!target.startsWith("#")) {
-      return true;
-    }
-    cursor = end + 1;
-  }
-  return false;
-}
-function stripMatchingQuotes(value) {
-  if (value.length < 2) {
-    return value;
-  }
-  const first = value[0];
-  const last = value[value.length - 1];
-  return first === '"' && last === '"' || first === "'" && last === "'" ? value.slice(1, -1).trim() : value;
-}
-async function mapWithConcurrency(values, concurrency, map) {
-  const results = new Array(values.length);
-  let nextIndex = 0;
-  async function worker() {
-    while (nextIndex < values.length) {
-      const index = nextIndex;
-      nextIndex += 1;
-      const value = values[index];
-      if (value !== void 0) {
-        results[index] = await map(value, index);
-      }
-    }
-  }
-  await Promise.all(
-    Array.from({ length: Math.min(concurrency, values.length) }, async () => worker())
-  );
-  return results;
-}
-async function loadSharp() {
-  try {
-    return (await import("sharp")).default;
-  } catch (error) {
-    throw new Error(
-      'Local icon sprites require the optional "sharp" package. Install sharp or disable local icons.',
-      { cause: error }
-    );
-  }
-}
-function resolvePackageLabel(icons, source, iconSets, mapName) {
-  let candidate;
-  if (typeof icons === "string" && iconSets?.[icons]) {
-    candidate = icons;
-  } else if (icons && typeof icons === "object" && icons.extends && iconSets?.[icons.extends]) {
-    candidate = icons.extends;
-  }
-  candidate ??= basename(source.replace(/[\\/]+$/u, "")) || mapName || "Icons";
-  const printable = Array.from(candidate.normalize("NFC")).map((character) => {
-    const codePoint = character.codePointAt(0) ?? 0;
-    return codePoint < 32 || codePoint >= 127 && codePoint <= 159 ? "" : character;
-  }).join("").trim();
-  const bounded = Array.from(printable || "Icons").slice(0, 64).join("");
-  return tileflowIconPackageLabelSchema.parse(bounded);
-}
-function sortMapping(mapping) {
-  if (!mapping) {
-    return void 0;
-  }
-  return Object.fromEntries(
-    Object.entries(mapping).sort(([left], [right]) => compareCodeUnits(left, right))
-  );
-}
-function createCatalogMappings(mapping, targetStatus) {
-  return Object.entries(mapping ?? {}).sort(([left], [right]) => compareCodeUnits(left, right)).map(([semantic, iconId]) => ({
-    iconId,
-    semantic,
-    targetStatus: typeof targetStatus === "function" ? targetStatus(iconId) : targetStatus
-  }));
-}
-function compareMappedFrom(left, right) {
-  return compareCodeUnits(left.map, right.map) || compareCodeUnits(left.semantic, right.semantic);
-}
-function atlasRectangle(entry) {
-  return { height: entry.height, width: entry.width, x: entry.x, y: entry.y };
-}
-function relativePortablePath(root, candidate) {
-  const pathFromRoot = relative(root, candidate);
-  if (pathFromRoot === "") {
-    return ".";
-  }
-  if (isAbsolute(pathFromRoot)) {
-    throw new Error("Icon catalog path cannot be represented relative to the working tree");
-  }
-  return pathFromRoot.split(sep).join("/");
-}
-function iconSourceFormat(extension) {
-  switch (extension) {
-    case ".svg":
-      return "svg";
-    case ".png":
-      return "png";
-    case ".jpg":
-    case ".jpeg":
-      return "jpeg";
-    case ".webp":
-      return "webp";
-    default:
-      throw new Error(`Unsupported icon source format: ${extension}`);
-  }
-}
-function sourcePath(mapName) {
-  return `maps.${mapName}.icons.source`;
-}
-function iconPath(mapName, fileName) {
-  return `${sourcePath(mapName)}/${fileName}`;
-}
-function isPathInside(root, candidate) {
-  const pathFromRoot = relative(root, candidate);
-  return pathFromRoot === "" || !isAbsolute(pathFromRoot) && pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep}`);
-}
-function describeFileSystemError(error, fallback) {
-  if (error && typeof error === "object" && "code" in error) {
-    const code = String(error.code ?? "");
-    if (code === "ENOENT") {
-      return fallback;
-    }
-    if (code === "EACCES" || code === "EPERM") {
-      return "Icon source is not readable";
-    }
-  }
-  return error instanceof Error && error.message ? error.message : fallback;
-}
-function cloneProject(project) {
-  return JSON.parse(JSON.stringify(project));
-}
-function isRemoteSpriteReference(value) {
-  return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("/") || value.startsWith("data:");
-}
-function joinUrl(base, path) {
-  const trimmedBase = base.replace(/\/+$/g, "");
-  const trimmedPath = path.replace(/^\/+/g, "");
-  return trimmedBase ? `${trimmedBase}/${trimmedPath}` : trimmedPath;
-}
-function uniqueStrings(values) {
-  return [...new Set(values)];
-}
-
-// src/session.ts
-import { watch } from "chokidar";
-import { realpathSync } from "fs";
-import { dirname, extname as extname2, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2, win32 } from "path";
-
-// src/diagnostic-sanitization.ts
-function sanitizeDiagnosticSecrets(value) {
-  return value.replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/gi, "$1[redacted]@").replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [redacted]").replace(/\btf_(?:live|cli|test)_[A-Za-z0-9_-]{8,}\b/gi, "tf_[redacted]").replace(/\b(?:sk_(?:live|test)|rk_(?:live|test)|whsec)_[A-Za-z0-9_-]+\b/g, "[redacted]").replace(
-    /([?&](?:access_token|api_key|key|password|secret|signature|token)=)[^&#\s]+/gi,
-    "$1[redacted]"
-  );
-}
-
-// src/session.ts
-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 excludedDirectories = /* @__PURE__ */ new Set([
-  ".cache",
-  ".git",
-  ".hg",
-  ".next",
-  ".nuxt",
-  ".svn",
-  ".svelte-kit",
-  ".tileflow",
-  ".turbo",
-  "build",
-  "coverage",
-  "dist",
-  "node_modules"
-]);
-async function createTileflowArtifactSessionWithBuilder(options, buildArtifacts) {
-  const session = new TileflowArtifactSessionImpl(options, buildArtifacts);
-  await session.start();
-  return session;
-}
-var TileflowArtifactSessionImpl = class {
-  #buildArtifacts;
-  #buildOptions;
-  #configPath;
-  #cwd;
-  #debounceMs;
-  #listeners = /* @__PURE__ */ new Set();
-  #ignoredPaths;
-  #watchEnabled;
-  #closed = false;
-  #debounceTimer;
-  #generation = 0;
-  #lastGoodArtifacts;
-  #lastGoodGeneration;
-  #refreshToken = 0;
-  #state = { generation: 0, status: "building" };
-  #watcher;
-  #watchedArtifactPaths = /* @__PURE__ */ new Set();
-  constructor(options, buildArtifacts) {
-    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) => resolve2(this.#cwd, path));
-    this.#buildArtifacts = buildArtifacts;
-    this.#buildOptions = {
-      apiBaseUrl: options.apiBaseUrl,
-      assetBaseUrl: options.assetBaseUrl,
-      config: options.config,
-      cwd: this.#cwd,
-      styleBaseUrl: options.styleBaseUrl
-    };
-  }
-  async start() {
-    if (this.#watchEnabled) {
-      this.#watcher = watch(dirname(this.#configPath), {
-        awaitWriteFinish: { pollInterval: 20, stabilityThreshold: 50 },
-        followSymlinks: false,
-        ignoreInitial: true,
-        ignored: (path, stats) => this.#ignoreWatchPath(path, stats?.isDirectory())
-      });
-      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("error", (error) => {
-        if (this.#closed) return;
-        this.#refreshToken += 1;
-        this.#publishInvalid(this.#generation + 1, error);
-      });
-      await watcherReady;
-    }
-    await this.refresh("initial");
-  }
-  getState() {
-    return this.#state;
-  }
-  getLastGoodArtifacts() {
-    return this.#lastGoodArtifacts;
-  }
-  subscribe(listener) {
-    if (this.#closed) return () => void 0;
-    this.#listeners.add(listener);
-    return () => this.#listeners.delete(listener);
-  }
-  async refresh(_reason = "manual") {
-    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) return;
-      this.#lastGoodArtifacts = artifacts;
-      this.#lastGoodGeneration = generation;
-      this.#updateArtifactWatchPaths(artifacts.watchPaths);
-      this.#publish({
-        artifacts,
-        generation,
-        lastGoodGeneration: generation,
-        status: "ready"
-      });
-    } catch (error) {
-      if (this.#closed || token !== this.#refreshToken) return;
-      this.#publishInvalid(generation, error);
-    }
-  }
-  async close() {
-    if (this.#closed) return;
-    this.#closed = true;
-    this.#refreshToken += 1;
-    if (this.#debounceTimer) clearTimeout(this.#debounceTimer);
-    this.#listeners.clear();
-    await this.#watcher?.close();
-  }
-  #ignoreWatchPath(path, isDirectory) {
-    const resolvedPath = resolve2(path);
-    const relativePath = relative2(dirname(this.#configPath), resolvedPath);
-    const segments = relativePath.split(sep2).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 = extname2(resolvedPath).toLowerCase();
-    if (configExtensions.has(extension)) return false;
-    if (iconExtensions.has(extension)) return false;
-    return true;
-  }
-  #shouldRefreshForWatchEvent(path) {
-    const resolvedPath = resolve2(path);
-    if (!iconExtensions.has(extname2(resolvedPath).toLowerCase())) 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) => resolve2(this.#cwd, path)));
-    const previous = this.#watchedArtifactPaths;
-    this.#watchedArtifactPaths = next;
-    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);
-      }
-    }
-  }
-};
-function isSameOrInside(root, candidate) {
-  const path = relative2(resolve2(root), resolve2(candidate));
-  return path === "" || !isAbsolute2(path) && path !== ".." && !path.startsWith(`..${sep2}`);
-}
-function createTileflowArtifactDiagnostics(error, cwd) {
-  const inheritedCode = optionalDiagnosticField(error, "code");
-  const inheritedPhase = optionalDiagnosticField(error, "phase") ?? optionalNestedDiagnosticField(error, "phase");
-  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 ? error.message : "Unknown build error", cwd),
-      path: "",
-      ...inheritedPhase ? { phase: inheritedPhase } : {}
-    }
-  ]);
-}
-function getIssueList(error) {
-  if (!error || typeof error !== "object") return [];
-  const containers = [];
-  for (const key of ["messages", "issues"]) {
-    const value = error[key];
-    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) && !isAbsolute2(value)) return "(external)";
-  if (!isAbsolute2(value)) return value.replaceAll("\\", "/");
-  const local = relative2(canonicalPath(cwd), canonicalPath(value)).replaceAll(sep2, "/");
-  return local.startsWith("../") || local === ".." ? "(external)" : local || ".";
-}
-function localPathAliases(path) {
-  return [.../* @__PURE__ */ new Set([resolve2(path), canonicalPath(path)])].sort(
-    (left, right) => right.length - left.length
-  );
-}
-function canonicalPath(path) {
-  try {
-    return realpathSync.native(resolve2(path));
-  } catch {
-    return resolve2(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, key) {
-  if (!value || typeof value !== "object") return void 0;
-  const field = value[key];
-  return typeof field === "string" && field.trim() ? boundDiagnosticField(field) : void 0;
-}
-function optionalNestedDiagnosticField(value, key) {
-  if (!value || typeof value !== "object") return void 0;
-  return optionalDiagnosticField(value.details, key);
-}
-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/style-validation.ts
-import { validateStyleMin } from "@maplibre/maplibre-gl-style-spec";
-var TileflowStyleValidationError = class extends Error {
-  code = "STYLE_INVALID";
-  issues;
-  phase = "style-validation";
-  constructor(issues) {
-    super("Compiled Tileflow styles are not valid MapLibre styles.");
-    this.name = "TileflowStyleValidationError";
-    this.issues = normalizeIssues(issues);
-  }
-};
-var maxIssues = 32;
-var maxMessageLength = 300;
-var maxPathLength = 300;
-function assertValidTileflowStyle(style, map) {
-  const issues = validateTileflowStyle(style, map);
-  if (issues.length > 0) throw new TileflowStyleValidationError(issues);
-}
-function validateTileflowStyle(style, map) {
-  const jsonIssues = [];
-  collectJsonIssues(
-    style,
-    `maps.${sanitizePathSegment(map)}.style`,
-    map,
-    jsonIssues,
-    /* @__PURE__ */ new Set()
-  );
-  if (jsonIssues.length > 0) return normalizeIssues(jsonIssues);
-  const semanticIssues = validateStyleMin(style).map(
-    (issue) => createSemanticIssue(style, map, issue.message)
-  );
-  return normalizeIssues(semanticIssues);
-}
-function normalizeTileflowStyleValidationIssues(issues) {
-  return normalizeIssues(issues);
-}
-function createSemanticIssue(style, map, rawMessage) {
-  const normalized = rawMessage.replace(/[\r\n]+/g, " ").trim();
-  const separator = normalized.indexOf(":");
-  const rawPath = separator >= 0 ? normalized.slice(0, separator).trim() : "";
-  const detail = separator >= 0 ? normalized.slice(separator + 1).trim() : normalized;
-  return {
-    map,
-    message: boundText(sanitizeDiagnosticSecrets(sanitizeUrls(detail)), maxMessageLength),
-    path: boundText(stableStylePath(style, map, rawPath), maxPathLength)
-  };
-}
-function stableStylePath(style, map, rawPath) {
-  const fallback = `maps.${sanitizePathSegment(map)}.style`;
-  if (!rawPath) return fallback;
-  const path = rawPath.replace(/layers\[(\d+)]/g, (_match, index) => {
-    const layer = style.layers[Number(index)];
-    const id = typeof layer?.id === "string" && layer.id ? layer.id : index;
-    return `layers.${sanitizePathSegment(id)}`;
-  });
-  return `${fallback}.${path}`;
-}
-function sanitizePathSegment(value) {
-  let sanitized = "";
-  let replacing = false;
-  for (const character of value) {
-    const codePoint = character.codePointAt(0) ?? 0;
-    const isAsciiLetter = codePoint >= 65 && codePoint <= 90 || codePoint >= 97 && codePoint <= 122;
-    const isDigit = codePoint >= 48 && codePoint <= 57;
-    const shouldReplace = !isAsciiLetter && !isDigit && character !== "-" && character !== "_";
-    if (shouldReplace) {
-      if (!replacing) sanitized += "-";
-      replacing = true;
-    } else {
-      sanitized += character;
-      replacing = false;
-    }
-  }
-  return sanitized.slice(0, 128) || "(unknown)";
-}
-function collectJsonIssues(value, path, map, issues, ancestors) {
-  if (issues.length >= maxIssues) return;
-  if (value === null || typeof value === "string" || typeof value === "boolean") return;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) addJsonIssue(map, path, "non-finite number", issues);
-    return;
-  }
-  if (typeof value !== "object") {
-    addJsonIssue(map, path, typeof value, issues);
-    return;
-  }
-  if (ancestors.has(value)) {
-    addJsonIssue(map, path, "cyclic object", issues);
-    return;
-  }
-  ancestors.add(value);
-  if (Array.isArray(value)) {
-    value.forEach((item, index) => {
-      const layerId = path.endsWith(".layers") && item && typeof item === "object" && !Array.isArray(item) ? item.id : void 0;
-      const childPath = typeof layerId === "string" && layerId ? `${path}.${sanitizePathSegment(layerId)}` : `${path}[${index}]`;
-      collectJsonIssues(item, childPath, map, issues, ancestors);
-    });
-  } else {
-    for (const [key, item] of Object.entries(value)) {
-      collectJsonIssues(item, `${path}.${sanitizePathSegment(key)}`, map, issues, ancestors);
-    }
-  }
-  ancestors.delete(value);
-}
-function addJsonIssue(map, path, type, issues) {
-  issues.push({
-    map,
-    message: `Expected a recursive JSON value; found ${type}.`,
-    path: boundText(path, maxPathLength)
-  });
-}
-function normalizeIssues(issues) {
-  const normalized = issues.map((issue) => ({
-    map: boundText(sanitizePathSegment(issue.map), 128),
-    message: boundText(
-      sanitizeDiagnosticSecrets(issue.message.replace(/[\r\n]+/g, " ").trim()),
-      maxMessageLength
-    ),
-    path: boundText(issue.path.replaceAll("\\", "/"), maxPathLength)
-  }));
-  normalized.sort(
-    (left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : left.message < right.message ? -1 : left.message > right.message ? 1 : 0
-  );
-  return normalized.filter(
-    (issue, index) => index === 0 || issue.path !== normalized[index - 1]?.path || issue.message !== normalized[index - 1]?.message
-  ).slice(0, maxIssues);
-}
-function sanitizeUrls(message) {
-  return message.replace(/https?:\/\/[^\s'"<>]+/gi, (value) => {
-    try {
-      return new URL(value.replace(/[),.;]+$/, "")).origin;
-    } catch {
-      return "(resource URL)";
-    }
-  });
-}
-function boundText(value, limit) {
-  return value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
-}
-
-// src/feature-inspection.ts
-import { VectorTile } from "@mapbox/vector-tile";
-import Pbf from "pbf";
+  createTileflowCommandFailureDocument,
+  createTileflowCommandSummary,
+  createTileflowStructuredDiagnostics,
+  serializeTileflowCommandDocument,
+  tileflowCommandDocumentSchemaVersion
+} from "./chunk-ZRI6PNFL.js";
 import {
-  compareCodeUnits as compareCodeUnits2,
-  createStyleFromProject
-} from "@tileflow/core";
-var mercatorLatitudeLimit = 85.0511287798066;
-var maxTileJsonBytes = 1024 * 1024;
-var maxTileBytes = 6 * 1024 * 1024;
-var maxTotalTileBytes = 24 * 1024 * 1024;
-var maxTiles = 32;
-var maxScannedFeatures = 2e4;
-var maxStringLength = 256;
-async function inspectTileflowFeatures(project, mapName, input) {
-  const options = validateInspectionOptions(input);
-  if (!Object.hasOwn(project.maps, mapName)) {
-    const available = Object.keys(project.maps).sort(compareCodeUnits2);
-    throw new Error(
-      `Unknown map "${mapName}". Available maps: ${available.join(", ") || "(none)"}`
-    );
-  }
-  const style = createStyleFromProject(project, mapName, { apiBaseUrl: options.apiBaseUrl });
-  assertValidTileflowStyle(style, mapName);
-  const source = resolveVectorSource(style, options.sourceLayers);
-  const fetchImplementation = options.fetch ?? globalThis.fetch;
-  const remoteOrigins = /* @__PURE__ */ new Set();
-  const tileSource = await resolveTileSource(
-    source.definition,
-    fetchImplementation,
-    options,
-    remoteOrigins
-  );
-  const bounds = viewportBounds(options.center, options.zoom, options.width, options.height);
-  const tileZoom = resolveTileZoom(options.zoom, tileSource.minzoom, tileSource.maxzoom);
-  const tileCoordinates = tileCover(bounds, tileZoom);
-  if (tileCoordinates.length > maxTiles) {
-    throw new Error(
-      `Feature inspection would read ${tileCoordinates.length} tiles; narrow the viewport or increase zoom (maximum ${maxTiles}).`
-    );
-  }
-  const features = [];
-  let scannedFeatures = 0;
-  let totalTileBytes = 0;
-  let scanTruncated = false;
-  for (const coordinate of tileCoordinates) {
-    const tileUrl = resolveTileUrl(tileSource.template, coordinate, tileSource.scheme);
-    const bytes = await fetchBytes(tileUrl, {
-      fetchImplementation,
-      label: "vector tile",
-      limit: maxTileBytes,
-      signal: options.signal,
-      timeoutMs: options.timeoutMs
-    });
-    remoteOrigins.add(safeOrigin(bytes.finalUrl));
-    totalTileBytes += bytes.body.byteLength;
-    if (totalTileBytes > maxTotalTileBytes) {
-      throw new Error(
-        `Feature inspection exceeded the ${maxTotalTileBytes}-byte total vector-tile limit.`
-      );
-    }
-    const tile = new VectorTile(new Pbf(bytes.body));
-    for (const sourceLayer of options.sourceLayers) {
-      const layer = tile.layers[sourceLayer];
-      if (!layer) continue;
-      for (let index = 0; index < layer.length; index += 1) {
-        scannedFeatures += 1;
-        if (scannedFeatures > maxScannedFeatures) {
-          scanTruncated = true;
-          break;
-        }
-        const vectorFeature = layer.feature(index);
-        const geoJsonFeature = vectorFeature.toGeoJSON(coordinate.x, coordinate.y, coordinate.z);
-        const geometry = summarizeGeometry(geoJsonFeature.geometry);
-        if (!geometry || !boundsIntersect(bounds, geometry.bounds)) continue;
-        features.push({
-          sourceLayer,
-          id: typeof vectorFeature.id === "number" && Number.isSafeInteger(vectorFeature.id) ? vectorFeature.id : null,
-          geometry,
-          properties: projectProperties(vectorFeature.properties, options.properties)
-        });
-      }
-      if (scanTruncated) break;
-    }
-    if (scanTruncated) break;
-  }
-  const uniqueFeatures = deduplicateFeatures(features).sort(compareInspectedFeatures);
-  const limitedFeatures = uniqueFeatures.slice(0, options.limit);
-  const dataIdentity = style.metadata?.["tileflow:data"];
-  const metadataVersion = dataIdentity && typeof dataIdentity === "object" && "revision" in dataIdentity ? dataIdentity.revision : void 0;
-  return {
-    schemaVersion: 1,
-    map: mapName,
-    camera: {
-      center: [...options.center],
-      zoom: options.zoom,
-      viewport: { width: options.width, height: options.height }
-    },
-    source: {
-      id: source.id,
-      origin: tileSource.origin,
-      tileJsonPath: tileSource.tileJsonPath,
-      tileOrigins: [...remoteOrigins].sort(compareCodeUnits2),
-      version: typeof metadataVersion === "string" ? metadataVersion : null
-    },
-    sourceLayers: options.sourceLayers,
-    properties: options.properties,
-    tileZoom,
-    tilesRead: tileCoordinates.length,
-    scannedFeatures: Math.min(scannedFeatures, maxScannedFeatures),
-    truncated: scanTruncated || uniqueFeatures.length > options.limit,
-    features: limitedFeatures
-  };
-}
-function validateInspectionOptions(input) {
-  const center = input.center;
-  if (!Array.isArray(center) || center.length !== 2 || !Number.isFinite(center[0]) || !Number.isFinite(center[1]) || center[0] < -180 || center[0] > 180 || center[1] < -mercatorLatitudeLimit || center[1] > mercatorLatitudeLimit) {
-    throw new Error(
-      `Feature inspection center must be [longitude, latitude] inside Web Mercator bounds.`
-    );
-  }
-  if (!Number.isFinite(input.zoom) || input.zoom < 0 || input.zoom > 24) {
-    throw new Error("Feature inspection zoom must be between 0 and 24.");
-  }
-  const width = boundedInteger(input.width ?? 512, 64, 2048, "width");
-  const height = boundedInteger(input.height ?? 512, 64, 2048, "height");
-  const limit = boundedInteger(input.limit ?? 200, 1, 500, "limit");
-  const timeoutMs = boundedInteger(input.timeoutMs ?? 1e4, 100, 6e4, "timeout");
-  const sourceLayers = normalizeNames(input.sourceLayers, 1, 12, "source layer");
-  const properties = normalizeNames(input.properties ?? [], 0, 16, "property");
-  return {
-    ...input,
-    center: [center[0], center[1]],
-    height,
-    limit,
-    properties,
-    sourceLayers,
-    timeoutMs,
-    width
-  };
-}
-function boundedInteger(value, minimum, maximum, label) {
-  if (!Number.isInteger(value) || value < minimum || value > maximum) {
-    throw new Error(
-      `Feature inspection ${label} must be an integer from ${minimum} to ${maximum}.`
-    );
-  }
-  return value;
-}
-function normalizeNames(values, minimum, maximum, label) {
-  if (!Array.isArray(values) || values.length < minimum || values.length > maximum) {
-    throw new Error(
-      `Feature inspection requires ${minimum}-${maximum} ${label}${maximum === 1 ? "" : "s"}.`
-    );
-  }
-  const normalized = [...new Set(values)].sort(compareCodeUnits2);
-  for (const value of normalized) {
-    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/.test(value)) {
-      throw new Error(`Invalid feature inspection ${label} "${value}".`);
-    }
-  }
-  return normalized;
-}
-function resolveVectorSource(style, sourceLayers) {
-  const requested = new Set(sourceLayers);
-  const referencedSourceIds = new Set(
-    style.layers.filter((layer) => requested.has(String(layer["source-layer"] ?? ""))).map((layer) => layer.source).filter((sourceId) => typeof sourceId === "string")
-  );
-  const vectorSources = Object.entries(style.sources).filter(
-    ([, definition2]) => definition2.type === "vector"
-  );
-  const candidates = referencedSourceIds.size > 0 ? vectorSources.filter(([sourceId]) => referencedSourceIds.has(sourceId)) : vectorSources;
-  if (candidates.length !== 1) {
-    throw new Error(
-      `Feature inspection requires exactly one vector source for the selected layers; found ${candidates.length}.`
-    );
-  }
-  const [id, definition] = candidates[0];
-  return { id, definition };
-}
-async function resolveTileSource(definition, fetchImplementation, options, origins) {
-  if (Array.isArray(definition.tiles) && typeof definition.tiles[0] === "string") {
-    const template2 = safeHttpUrl(definition.tiles[0], "vector tile template");
-    origins.add(template2.origin);
-    return {
-      maxzoom: finiteZoom(definition.maxzoom, 22),
-      minzoom: finiteZoom(definition.minzoom, 0),
-      origin: template2.origin,
-      scheme: definition.scheme === "tms" ? "tms" : "xyz",
-      template: template2,
-      tileJsonPath: null
-    };
-  }
-  if (typeof definition.url !== "string") {
-    throw new Error("Feature inspection vector source must define an HTTP(S) TileJSON URL.");
-  }
-  const tileJsonUrl = safeHttpUrl(definition.url, "TileJSON URL");
-  const response = await fetchBytes(tileJsonUrl, {
-    fetchImplementation,
-    label: "TileJSON",
-    limit: maxTileJsonBytes,
-    signal: options.signal,
-    timeoutMs: options.timeoutMs
-  });
-  const finalTileJsonUrl = safeHttpUrl(response.finalUrl, "TileJSON response URL");
-  origins.add(finalTileJsonUrl.origin);
-  let parsed;
-  try {
-    parsed = JSON.parse(new TextDecoder().decode(response.body));
-  } catch {
-    throw new Error("Feature inspection received invalid TileJSON JSON.");
-  }
-  const tileJson = parseTileJson(parsed);
-  const template = safeHttpUrl(
-    new URL(tileJson.tiles[0], finalTileJsonUrl).toString(),
-    "vector tile template"
-  );
-  origins.add(template.origin);
-  return {
-    maxzoom: finiteZoom(tileJson.maxzoom, 22),
-    minzoom: finiteZoom(tileJson.minzoom, 0),
-    origin: finalTileJsonUrl.origin,
-    scheme: tileJson.scheme === "tms" ? "tms" : "xyz",
-    template,
-    tileJsonPath: finalTileJsonUrl.pathname
-  };
-}
-function parseTileJson(value) {
-  if (!isRecord(value) || !Array.isArray(value.tiles) || value.tiles.length === 0) {
-    throw new Error("Feature inspection TileJSON must contain a non-empty tiles array.");
-  }
-  const tiles = value.tiles.filter((entry) => typeof entry === "string");
-  if (tiles.length !== value.tiles.length || tiles.length > 8) {
-    throw new Error("Feature inspection TileJSON tiles must contain 1-8 URL templates.");
-  }
-  return {
-    tiles,
-    ...typeof value.maxzoom === "number" ? { maxzoom: value.maxzoom } : {},
-    ...typeof value.minzoom === "number" ? { minzoom: value.minzoom } : {},
-    ...typeof value.scheme === "string" ? { scheme: value.scheme } : {}
-  };
-}
-function finiteZoom(value, fallback) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 24 ? value : fallback;
-}
-function resolveTileZoom(zoom, minzoom, maxzoom) {
-  if (minzoom > maxzoom) throw new Error("Feature inspection source minzoom exceeds maxzoom.");
-  return Math.max(minzoom, Math.min(maxzoom, Math.floor(zoom)));
-}
-function viewportBounds(center, zoom, width, height) {
-  const centerX = longitudeToWorldX(center[0]);
-  const centerY = latitudeToWorldY(center[1]);
-  const scale = 512 * 2 ** zoom;
-  const westX = centerX - width / 2 / scale;
-  const eastX = centerX + width / 2 / scale;
-  if (westX < 0 || eastX > 1) {
-    throw new Error("Feature inspection viewports that cross the antimeridian are not supported.");
-  }
-  const northY = Math.max(0, centerY - height / 2 / scale);
-  const southY = Math.min(1, centerY + height / 2 / scale);
-  return [
-    worldXToLongitude(westX),
-    worldYToLatitude(southY),
-    worldXToLongitude(eastX),
-    worldYToLatitude(northY)
-  ];
-}
-function tileCover(bounds, zoom) {
-  const count = 2 ** zoom;
-  const minimumX = clampTile(Math.floor(longitudeToWorldX(bounds[0]) * count), count);
-  const maximumX = clampTile(Math.floor(longitudeToWorldX(bounds[2]) * count), count);
-  const minimumY = clampTile(Math.floor(latitudeToWorldY(bounds[3]) * count), count);
-  const maximumY = clampTile(Math.floor(latitudeToWorldY(bounds[1]) * count), count);
-  const coordinates = [];
-  for (let y = minimumY; y <= maximumY; y += 1) {
-    for (let x = minimumX; x <= maximumX; x += 1) coordinates.push({ x, y, z: zoom });
-  }
-  return coordinates;
-}
-function clampTile(value, count) {
-  return Math.max(0, Math.min(count - 1, value));
-}
-function resolveTileUrl(template, coordinate, scheme) {
-  const y = scheme === "tms" ? 2 ** coordinate.z - 1 - coordinate.y : coordinate.y;
-  const replacements = {
-    z: coordinate.z,
-    x: coordinate.x,
-    y,
-    "-y": 2 ** coordinate.z - 1 - coordinate.y
-  };
-  let value = template.toString();
-  for (const [token, replacement] of Object.entries(replacements)) {
-    value = value.replace(
-      new RegExp(`(?:\\{${token}\\}|%7B${token}%7D)`, "giu"),
-      String(replacement)
-    );
-  }
-  if (/(?:\{(?:z|x|-?y)\}|%7B(?:z|x|-?y)%7D)/iu.test(value)) {
-    throw new Error("Feature inspection tile template contains unresolved coordinates.");
-  }
-  return new URL(value);
-}
-async function fetchBytes(url, options) {
-  const timeout = AbortSignal.timeout(options.timeoutMs);
-  const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
-  const response = await options.fetchImplementation(url, { signal });
-  if (!response.ok) {
-    throw new Error(`${options.label} request failed with HTTP ${response.status}.`);
-  }
-  const declaredLength = Number(response.headers.get("content-length"));
-  if (Number.isFinite(declaredLength) && declaredLength > options.limit) {
-    throw new Error(`${options.label} exceeds the ${options.limit}-byte limit.`);
-  }
-  if (!response.body) throw new Error(`${options.label} response had no body.`);
-  const chunks = [];
-  let length = 0;
-  const reader = response.body.getReader();
-  while (true) {
-    const result = await reader.read();
-    if (result.done) break;
-    length += result.value.byteLength;
-    if (length > options.limit) {
-      await reader.cancel();
-      throw new Error(`${options.label} exceeds the ${options.limit}-byte limit.`);
-    }
-    chunks.push(result.value);
-  }
-  const body = new Uint8Array(length);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return { body, finalUrl: response.url || url.toString() };
-}
-function summarizeGeometry(value) {
-  if (!isRecord(value) || typeof value.type !== "string" || !("coordinates" in value)) return;
-  const points = [];
-  collectCoordinates(value.coordinates, points);
-  if (points.length === 0) return;
-  let west = Infinity;
-  let south = Infinity;
-  let east = -Infinity;
-  let north = -Infinity;
-  for (const [longitude, latitude] of points) {
-    west = Math.min(west, longitude);
-    south = Math.min(south, latitude);
-    east = Math.max(east, longitude);
-    north = Math.max(north, latitude);
-  }
-  return {
-    type: value.type,
-    center: [roundCoordinate((west + east) / 2), roundCoordinate((south + north) / 2)],
-    bounds: [
-      roundCoordinate(west),
-      roundCoordinate(south),
-      roundCoordinate(east),
-      roundCoordinate(north)
-    ]
-  };
-}
-function collectCoordinates(value, points) {
-  if (!Array.isArray(value)) return;
-  if (value.length >= 2 && typeof value[0] === "number" && Number.isFinite(value[0]) && typeof value[1] === "number" && Number.isFinite(value[1])) {
-    points.push([value[0], value[1]]);
-    return;
-  }
-  for (const child of value) collectCoordinates(child, points);
-}
-function boundsIntersect(left, right) {
-  return left[0] <= right[2] && left[2] >= right[0] && left[1] <= right[3] && left[3] >= right[1];
-}
-function projectProperties(source, properties) {
-  const projected = {};
-  for (const property of properties) {
-    const value = source[property];
-    if (typeof value === "string") projected[property] = value.slice(0, maxStringLength);
-    else if (typeof value === "boolean") projected[property] = value;
-    else if (typeof value === "number" && Number.isFinite(value)) projected[property] = value;
-  }
-  return projected;
-}
-function deduplicateFeatures(features) {
-  const unique = /* @__PURE__ */ new Map();
-  for (const feature of features) {
-    const key = feature.id === null ? `${feature.sourceLayer}|${JSON.stringify(feature.geometry)}|${JSON.stringify(feature.properties)}` : `${feature.sourceLayer}|id:${feature.id}`;
-    if (!unique.has(key)) unique.set(key, feature);
-  }
-  return [...unique.values()];
-}
-function compareInspectedFeatures(left, right) {
-  const leftName = typeof left.properties.name === "string" ? left.properties.name : "";
-  const rightName = typeof right.properties.name === "string" ? right.properties.name : "";
-  return compareCodeUnits2(left.sourceLayer, right.sourceLayer) || Number(rightName.length > 0) - Number(leftName.length > 0) || compareCodeUnits2(leftName, rightName) || (left.id ?? Number.MAX_SAFE_INTEGER) - (right.id ?? Number.MAX_SAFE_INTEGER) || compareCodeUnits2(JSON.stringify(left), JSON.stringify(right));
-}
-function safeHttpUrl(value, label) {
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new Error(`Feature inspection ${label} is not a valid URL.`);
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(`Feature inspection ${label} must use HTTP or HTTPS.`);
-  }
-  return parsed;
-}
-function safeOrigin(value) {
-  return safeHttpUrl(value, "response URL").origin;
-}
-function longitudeToWorldX(longitude) {
-  return (longitude + 180) / 360;
-}
-function worldXToLongitude(x) {
-  return x * 360 - 180;
-}
-function latitudeToWorldY(latitude) {
-  const radians = latitude * Math.PI / 180;
-  return (1 - Math.log(Math.tan(radians) + 1 / Math.cos(radians)) / Math.PI) / 2;
-}
-function worldYToLatitude(y) {
-  return Math.atan(Math.sinh(Math.PI * (1 - 2 * y))) * 180 / Math.PI;
-}
-function roundCoordinate(value) {
-  return Math.round(value * 1e7) / 1e7;
-}
-function isRecord(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
-// src/index.ts
-var defaultTileflowApiUrl = "https://api.tileflow.dev";
-var defaultTileflowConfigPath = "tileflow.config.ts";
-var defaultTileflowManifestPath = "public/tileflow/manifest.json";
-var TileflowPreviewSelectionError = class extends Error {
-  code = "PREVIEW_SELECTION_INVALID";
-  constructor(message) {
-    super(message);
-    this.name = "TileflowPreviewSelectionError";
-  }
-};
-var TileflowValidationError = class extends Error {
-  code = "CONFIG_INVALID";
-  messages;
-  phase = "config-validation";
-  constructor(messages) {
-    super("Invalid Tileflow config");
-    this.name = "TileflowValidationError";
-    this.messages = messages;
-  }
-};
-async function loadTileflowConfig(configPath = defaultTileflowConfigPath, options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const resolvedPath = resolve3(cwd, configPath);
-  if (!existsSync(resolvedPath)) {
-    throw new Error(`Config not found: ${configPath}`);
-  }
-  if (options.fresh) {
-    clearTileflowLocalModuleCache(resolvedPath, cwd);
-  }
-  const jiti = createJiti(import.meta.url, {
-    fsCache: false,
-    moduleCache: !options.fresh
-  });
-  const imported = await jiti.import(resolvedPath, { default: true });
-  return asTileflowProjectConfig(imported);
-}
-async function loadValidTileflowConfig(configPath = defaultTileflowConfigPath, options = {}) {
-  const project = await loadTileflowConfig(configPath, options);
-  assertValidTileflowConfig(project);
-  return project;
-}
-function assertValidTileflowConfig(project) {
-  const result = validateConfig(project);
-  if (!result.valid) {
-    throw new TileflowValidationError(result.messages);
-  }
-}
-function asTileflowProjectConfig(input) {
-  if (input && typeof input === "object" && "maps" in input && typeof input.maps === "object") {
-    return input;
-  }
-  return { maps: { main: input } };
-}
-function getTileflowMapNames(project) {
-  return Object.keys(project.maps);
-}
-function getFirstTileflowMapName(project) {
-  const [mapName] = getTileflowMapNames(project);
-  if (!mapName) {
-    throw new Error("Tileflow config must define at least one map.");
-  }
-  return mapName;
-}
-function resolveTileflowPreview(project, selection = {}) {
-  if (selection.map !== void 0 && selection.scene !== void 0) {
-    throw new TileflowPreviewSelectionError(
-      "Choose either a Tileflow preview map or scene, not both."
-    );
-  }
-  if (selection.scene !== void 0) {
-    const scene = Object.hasOwn(project.scenes ?? {}, selection.scene) ? project.scenes?.[selection.scene] : void 0;
-    if (!scene) {
-      throw new TileflowPreviewSelectionError(`Unknown Tileflow scene: ${selection.scene}`);
-    }
-    const normalized = normalizeTileflowCaptureScene(scene);
-    if (normalized.target.kind === "application") {
-      throw new TileflowPreviewSelectionError(
-        `Tileflow scene "${selection.scene}" targets an application. Preview it through the application's development server.`
-      );
-    }
-    if (!Object.hasOwn(project.maps, normalized.map)) {
-      throw new TileflowPreviewSelectionError(
-        `Tileflow scene "${selection.scene}" references an unknown map: ${normalized.map}`
-      );
-    }
-    return {
-      camera: normalized.camera,
-      label: `${normalized.map} / ${selection.scene} \xB7 ${normalized.viewport.width}\xD7${normalized.viewport.height}`,
-      mapName: normalized.map,
-      viewport: normalized.viewport
-    };
-  }
-  const mapName = selection.map ?? getFirstTileflowMapName(project);
-  const map = Object.hasOwn(project.maps, mapName) ? project.maps[mapName] : void 0;
-  if (!map) {
-    throw new TileflowPreviewSelectionError(`Unknown Tileflow map: ${mapName}`);
-  }
-  return {
-    camera: {
-      type: "center",
-      center: map.view?.center ? [map.view.center[0], map.view.center[1]] : [0, 0],
-      zoom: map.view?.zoom ?? 0,
-      bearing: map.view?.bearing ?? 0,
-      pitch: map.view?.pitch ?? 0
-    },
-    label: mapName,
-    mapName
-  };
-}
-function getTileflowStyleMapName(path) {
-  const fileName = path.split("/").pop() ?? "";
-  return fileName.replace(/\.json$/, "");
-}
-function createTileflowManifest(project, options = {}) {
-  return createManifest(project, options);
-}
-function createTileflowStyle(project, mapName, options = {}) {
-  const style = createStyleFromProject2(project, mapName, options);
-  assertValidTileflowStyle(style, mapName);
-  return style;
-}
-function createTileflowStyles(project, options = {}) {
-  const styleEntries = [];
-  const issues = [];
-  for (const mapName of getTileflowMapNames(project).sort(compareCodeUnits3)) {
-    const style = createStyleFromProject2(project, mapName, options);
-    styleEntries.push([mapName, style]);
-    issues.push(...validateTileflowStyle(style, mapName));
-  }
-  if (issues.length > 0) {
-    throw new TileflowStyleValidationError(normalizeTileflowStyleValidationIssues(issues));
-  }
-  return Object.fromEntries(styleEntries);
-}
-async function createTileflowBuildArtifacts(options = {}) {
-  const project = await loadValidTileflowConfig(options.config ?? defaultTileflowConfigPath, {
-    cwd: options.cwd,
-    fresh: true
-  });
-  const prepared = await prepareTileflowProjectIcons(project, {
-    assetBaseUrl: resolveAssetBaseUrl(options),
-    cwd: options.cwd ?? process.cwd()
-  });
-  const styleOptions = { apiBaseUrl: options.apiBaseUrl };
-  const styles = createTileflowStyles(prepared.project, styleOptions);
-  return {
-    assets: prepared.assets,
-    manifest: createManifest(prepared.project, {
-      styleBaseUrl: options.styleBaseUrl
-    }),
-    project: prepared.project,
-    styles,
-    watchPaths: prepared.watchPaths
-  };
-}
-function createTileflowArtifactSession(options = {}) {
-  return createTileflowArtifactSessionWithBuilder(options, createTileflowBuildArtifacts);
-}
-async function getTileflowWatchPaths(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const project = await loadValidTileflowConfig(options.config ?? defaultTileflowConfigPath, {
-    cwd,
-    fresh: true
-  });
-  return getTileflowIconWatchPaths(project, cwd);
-}
-async function writeTileflowBuildArtifacts(options) {
-  const cwd = options.cwd ?? process.cwd();
-  const outDir = resolve3(cwd, options.outDir);
-  const stylesDir = resolve3(outDir, "styles");
-  const artifacts = await createTileflowBuildArtifacts(options);
-  await mkdir(stylesDir, { recursive: true });
-  for (const [mapName, style] of Object.entries(artifacts.styles)) {
-    await writeFile(
-      resolve3(stylesDir, `${mapName}.json`),
-      `${JSON.stringify(style, null, 2)}
-`,
-      "utf8"
-    );
-  }
-  for (const asset of artifacts.assets) {
-    const outputPath = resolve3(outDir, asset.fileName);
-    await mkdir(dirname2(outputPath), { recursive: true });
-    await writeFile(outputPath, asset.source);
-  }
-  await writeFile(
-    resolve3(outDir, "manifest.json"),
-    `${JSON.stringify(artifacts.manifest, null, 2)}
-`,
-    "utf8"
-  );
-  return artifacts;
-}
-function isTileflowRequestUrl(url, basePath) {
-  const pathname = (url ?? "/").split("?")[0] ?? "/";
-  if (!basePath) {
-    return pathname === "/manifest.json" || pathname === "/style.json" || pathname === "/" || pathname.startsWith("/icons/") || pathname.startsWith("/styles/");
-  }
-  return pathname === basePath || pathname.startsWith(`${basePath}/`);
-}
-function createTileflowNodeRequest(request) {
-  const protocol = getNodeHeader(request, "x-forwarded-proto") ?? "http";
-  const host = getNodeHeader(request, "host") ?? "localhost";
-  return new Request(`${protocol}://${host}${request.url ?? "/"}`, {
-    method: request.method
-  });
-}
-async function writeTileflowNodeResponse(response, tileflowResponse) {
-  response.statusCode = tileflowResponse.status;
-  tileflowResponse.headers.forEach((value, key) => {
-    response.setHeader(key, value);
-  });
-  if (!tileflowResponse.body) {
-    response.end();
-    return;
-  }
-  const reader = tileflowResponse.body.getReader();
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (response.destroyed) {
-        await reader.cancel();
-        return;
-      }
-      response.write(Buffer.from(value));
-    }
-    response.end();
-  } finally {
-    reader.releaseLock();
-  }
-}
-function joinTileflowPublicUrl(publicBase, basePath) {
-  const trimmedBase = publicBase.replace(/\/+$/g, "");
-  const trimmedPath = basePath.replace(/^\/+|\/+$/g, "");
-  if (!trimmedPath) {
-    return trimmedBase || "";
-  }
-  if (!trimmedBase || trimmedBase === ".") {
-    return `/${trimmedPath}`;
-  }
-  return `${trimmedBase}/${trimmedPath}`;
-}
-function getTileflowAssetBasePath(basePath) {
-  return basePath.replace(/^\/+|\/+$/g, "");
-}
-function getTileflowAssetFileName(basePath, fileName) {
-  return basePath ? `${basePath}/${fileName}` : fileName;
-}
-function createTileflowDevRequestHandler(options = {}) {
-  const basePath = normalizeTileflowBasePath(options.basePath);
-  const configPath = options.config ?? defaultTileflowConfigPath;
-  const cwd = options.cwd ?? process.cwd();
-  const apiBaseUrl = options.apiBaseUrl ?? defaultTileflowApiUrl;
-  return async function handleTileflowDevRequest(request) {
-    if (request.method !== "GET" && request.method !== "HEAD") {
-      return jsonResponse({ error: "Method not allowed" }, 405);
-    }
-    const url = new URL(request.url);
-    const path = stripTileflowBasePath(url.pathname, basePath);
-    if (path === null) {
-      return jsonResponse({ error: "Not found" }, 404);
-    }
-    try {
-      if (path === "/__events") {
-        return options.session ? eventStreamResponse(options.session) : jsonResponse({ error: "Live events require a development session." }, 404);
-      }
-      if (path === "/__runtime/maplibre-gl.js") {
-        return textAssetResponse(getLocalMapLibreAsset("js"), "text/javascript; charset=utf-8");
-      }
-      if (path === "/__runtime/maplibre-gl.css") {
-        return textAssetResponse(getLocalMapLibreAsset("css"), "text/css; charset=utf-8");
-      }
-      let artifacts;
-      let state;
-      if (options.session) {
-        artifacts = getSessionArtifacts(options.session);
-        state = options.session.getState();
-      } else {
-        artifacts = await createTileflowBuildArtifacts({
-          assetBaseUrl: `${url.origin}${basePath}`,
-          config: configPath,
-          cwd,
-          styleBaseUrl: options.styleBaseUrl ?? `${url.origin}${basePath}`,
-          apiBaseUrl
-        });
-        state = {
-          artifacts,
-          generation: 1,
-          lastGoodGeneration: 1,
-          status: "ready"
-        };
-      }
-      if (path === "/__status") {
-        return jsonResponse(createTileflowArtifactStatus(state));
-      }
-      if (path === "/" || path === "") {
-        const preview = artifacts ? resolveTileflowPreview(artifacts.project, { map: options.map, scene: options.scene }) : void 0;
-        return htmlResponse(previewHtml(preview, basePath, state));
-      }
-      if (!artifacts) return unavailableArtifactsResponse(state);
-      if (path === "/manifest.json") {
-        return jsonResponse(artifacts.manifest);
-      }
-      if (path === "/style.json") {
-        return jsonResponse(artifacts.styles[getFirstTileflowMapName(artifacts.project)]);
-      }
-      if (path.startsWith("/styles/")) {
-        const mapName = getTileflowStyleMapName(path);
-        if (!Object.hasOwn(artifacts.styles, mapName)) {
-          return jsonResponse({ error: `Unknown map: ${mapName}` }, 404);
-        }
-        return jsonResponse(artifacts.styles[mapName]);
-      }
-      if (path.startsWith("/icons/")) {
-        const assetName = path.replace(/^\/+/, "");
-        const asset = artifacts.assets.find((candidate) => candidate.fileName === assetName);
-        if (!asset) {
-          return jsonResponse({ error: `Unknown icon asset: ${assetName}` }, 404);
-        }
-        return assetResponse(asset);
-      }
-      return jsonResponse({ error: "Not found" }, 404);
-    } catch (error) {
-      options.onError?.(error);
-      return tileflowErrorResponse(error);
-    }
-  };
-}
-function createTileflowArtifactStatus(state) {
-  return {
-    schemaVersion: tileflowArtifactSessionSchemaVersion,
-    generation: state.generation,
-    status: state.status,
-    ..."lastGoodGeneration" in state && state.lastGoodGeneration !== void 0 ? { lastGoodGeneration: state.lastGoodGeneration } : {},
-    ...state.status === "invalid" ? { diagnostics: state.diagnostics } : {}
-  };
-}
-function getSessionArtifacts(session) {
-  const state = session.getState();
-  return state.status === "ready" ? state.artifacts : session.getLastGoodArtifacts();
-}
-function unavailableArtifactsResponse(state) {
-  return jsonResponse(
-    {
-      error: "No valid Tileflow artifact generation is available.",
-      ...createTileflowArtifactStatus(state)
-    },
-    409
-  );
-}
-function eventStreamResponse(session) {
-  const encoder = new TextEncoder();
-  let unsubscribe = () => {
-  };
-  const stream = new ReadableStream({
-    start(controller) {
-      const enqueue = (state) => {
-        const status = createTileflowArtifactStatus(state);
-        controller.enqueue(
-          encoder.encode(`event: ${status.status}
-data: ${JSON.stringify(status)}
-
-`)
-        );
-      };
-      enqueue(session.getState());
-      unsubscribe = session.subscribe(enqueue);
-    },
-    cancel() {
-      unsubscribe();
-    }
-  });
-  return new Response(stream, {
-    headers: {
-      "Access-Control-Allow-Origin": "*",
-      "Cache-Control": "no-cache, no-transform",
-      Connection: "keep-alive",
-      "Content-Type": "text/event-stream; charset=utf-8",
-      "X-Accel-Buffering": "no"
-    }
-  });
-}
-function getNodeHeader(request, name) {
-  const value = request.headers[name];
-  return Array.isArray(value) ? value[0] : value;
-}
-function normalizeTileflowBasePath(value = "") {
-  const trimmed = value.trim().replace(/^\/+|\/+$/g, "");
-  return trimmed ? `/${trimmed}` : "";
-}
-function stripTileflowBasePath(pathname, basePath) {
-  if (!basePath) {
-    return pathname;
-  }
-  if (pathname === basePath) {
-    return "/";
-  }
-  if (pathname.startsWith(`${basePath}/`)) {
-    return pathname.slice(basePath.length);
-  }
-  return null;
-}
-function tileflowErrorResponse(error) {
-  if (error instanceof TileflowPreviewSelectionError) {
-    return jsonResponse({ error: error.message }, 400);
-  }
-  if (error instanceof TileflowStyleValidationError) {
-    return jsonResponse(
-      {
-        error: error.message,
-        issues: error.issues
-      },
-      400
-    );
-  }
-  if (error instanceof TileflowValidationError) {
-    return jsonResponse(
-      {
-        error: error.message,
-        messages: error.messages
-      },
-      400
-    );
-  }
-  const message = error instanceof Error ? error.message : "Unknown error";
-  return jsonResponse({ error: message }, 500);
-}
-function jsonResponse(body, status = 200) {
-  return new Response(`${JSON.stringify(body, null, 2)}
-`, {
-    headers: {
-      "Access-Control-Allow-Origin": "*",
-      "Cache-Control": "no-store",
-      "Content-Type": "application/json; charset=utf-8"
-    },
-    status
-  });
-}
-function htmlResponse(body, status = 200) {
-  return new Response(body, {
-    headers: {
-      "Access-Control-Allow-Origin": "*",
-      "Cache-Control": "no-store",
-      "Content-Type": "text/html; charset=utf-8"
-    },
-    status
-  });
-}
-function assetResponse(asset) {
-  const body = typeof asset.source === "string" ? asset.source : Buffer.from(asset.source);
-  return new Response(body, {
-    headers: {
-      "Access-Control-Allow-Origin": "*",
-      "Cache-Control": "no-store",
-      "Content-Type": asset.contentType
-    }
-  });
-}
-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 previewHtml(preview, basePath, state) {
-  const styleUrl = preview ? `${basePath}/styles/${preview.mapName}.json` : void 0;
-  const initialStatus = createTileflowArtifactStatus(state);
-  const mapOptions = preview ? previewMapOptions(preview) : void 0;
-  const viewportCss = preview?.viewport ? `
-      html, body { min-height: 100%; margin: 0; }
-      body {
-        display: grid;
-        place-items: center;
-        overflow: auto;
-        background: #E8E5DE;
-      }
-      #map {
-        width: ${preview.viewport.width}px;
-        height: ${preview.viewport.height}px;
-        box-shadow: 0 24px 80px rgba(37, 34, 29, 0.18);
-      }` : "html, body, #map { height: 100%; margin: 0; }";
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Tileflow Preview</title>
-    <link rel="stylesheet" href="${basePath}/__runtime/maplibre-gl.css" />
-    <style>
-      ${viewportCss}
-      body { font-family: ui-sans-serif, system-ui, sans-serif; }
-      .badge {
-        position: fixed;
-        left: 16px;
-        top: 16px;
-        z-index: 1;
-        border-radius: 8px;
-        background: rgba(246, 247, 243, 0.92);
-        border: 1px solid rgba(60, 64, 67, 0.12);
-        color: #3C4043;
-        padding: 10px 12px;
-        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.12);
-      }
-      .status {
-        position: fixed;
-        left: 16px;
-        right: 16px;
-        bottom: 16px;
-        z-index: 2;
-        display: none;
-        max-width: 720px;
-        border: 1px solid rgba(160, 46, 46, 0.35);
-        border-radius: 8px;
-        background: rgba(255, 244, 244, 0.96);
-        color: #702020;
-        padding: 12px;
-        white-space: pre-wrap;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="badge" id="badge">Tileflow preview</div>
-    <div class="status" id="status" role="status"></div>
-    <div id="map"></div>
-    <script src="${basePath}/__runtime/maplibre-gl.js"></script>
-    <script>
-      const initialStatus = ${JSON.stringify(initialStatus)};
-      const initialGeneration = initialStatus.generation;
-      const badge = document.getElementById("badge");
-      const status = document.getElementById("status");
-      const previewLabel = ${JSON.stringify(preview?.label)};
-      const styleUrl = ${JSON.stringify(styleUrl)};
-      const previewMapOptions = ${JSON.stringify(mapOptions)};
-
-      const cameraRanges = {
-        bearing: [-180, 180],
-        lat: [-90, 90],
-        lng: [-180, 180],
-        pitch: [0, 85],
-        zoom: [0, 24]
-      };
-
-      function readCameraFromUrl() {
-        const params = new URL(location.href).searchParams;
-        const camera = {};
-
-        for (const [name, range] of Object.entries(cameraRanges)) {
-          const values = params.getAll(name);
-          if (values.length !== 1 || values[0].trim() === "") return undefined;
-          const value = Number(values[0]);
-          if (!Number.isFinite(value) || value < range[0] || value > range[1]) return undefined;
-          camera[name] = value;
-        }
-
-        return {
-          bearing: camera.bearing,
-          center: [camera.lng, camera.lat],
-          pitch: camera.pitch,
-          zoom: camera.zoom
-        };
-      }
-
-      function resolveInitialMapOptions(options) {
-        const camera = readCameraFromUrl();
-        if (!camera) return options;
-        const resolved = {...options};
-        delete resolved.bounds;
-        delete resolved.fitBoundsOptions;
-        return {...resolved, ...camera};
-      }
-
-      function formatCameraNumber(value) {
-        return String(Number(value.toFixed(6)));
-      }
-
-      function wrapLongitude(value) {
-        return ((value + 180) % 360 + 360) % 360 - 180;
-      }
-
-      function writeCameraToUrl(map) {
-        const center = map.getCenter();
-        const url = new URL(location.href);
-        const camera = {
-          bearing: map.getBearing(),
-          lat: center.lat,
-          lng: wrapLongitude(center.lng),
-          pitch: map.getPitch(),
-          zoom: map.getZoom()
-        };
-
-        for (const [name, value] of Object.entries(camera)) {
-          url.searchParams.set(name, formatCameraNumber(value));
-        }
-        history.replaceState(history.state, "", url.href);
-      }
-
-      if (styleUrl) {
-        const map = new maplibregl.Map({
-          container: "map",
-          style: styleUrl,
-          ...resolveInitialMapOptions(previewMapOptions)
-        });
-        map.addControl(new maplibregl.NavigationControl(), "top-right");
-        map.on("load", () => writeCameraToUrl(map));
-        map.on("moveend", () => writeCameraToUrl(map));
-      }
-
-      function applyStatus(next) {
-        badge.textContent = ["Tileflow preview", previewLabel, next.status].filter(Boolean).join(" \xB7 ");
-        if (next.status === "invalid") {
-          const diagnostics = next.diagnostics || [];
-          status.textContent = diagnostics.map((item) =>
-            (item.path ? item.path + ": " : "") + item.message
-          ).join("\\n") || "Tileflow config is invalid.";
-          status.style.display = "block";
-          return;
-        }
-        status.style.display = "none";
-        if (next.status === "ready" && next.generation > initialGeneration) {
-          location.reload();
-        }
-      }
-
-      applyStatus(initialStatus);
-      const events = new EventSource(${JSON.stringify(`${basePath}/__events`)});
-      for (const eventName of ["building", "ready", "invalid"]) {
-        events.addEventListener(eventName, (event) => applyStatus(JSON.parse(event.data)));
-      }
-    </script>
-  </body>
-</html>`;
-}
-function previewMapOptions(preview) {
-  if (preview.camera.type === "center") {
-    return {
-      bearing: preview.camera.bearing,
-      center: preview.camera.center,
-      pitch: preview.camera.pitch,
-      zoom: preview.camera.zoom
-    };
-  }
-  const [west, south, east, north] = preview.camera.bounds;
-  return {
-    bearing: preview.camera.bearing,
-    bounds: [
-      [west, south],
-      [east, north]
-    ],
-    fitBoundsOptions: { padding: preview.camera.padding },
-    pitch: preview.camera.pitch
-  };
-}
-var localRequire = createRequire(import.meta.url);
-var localMapLibreJavaScript;
-var localMapLibreStylesheet;
-function getLocalMapLibreAsset(kind) {
-  if (kind === "js" && localMapLibreJavaScript !== void 0) return localMapLibreJavaScript;
-  if (kind === "css" && localMapLibreStylesheet !== void 0) return localMapLibreStylesheet;
-  const packagePath = localRequire.resolve("maplibre-gl/package.json");
-  const source = readFileSync(
-    join(dirname2(packagePath), "dist", kind === "js" ? "maplibre-gl.js" : "maplibre-gl.css"),
-    "utf8"
-  );
-  if (kind === "js") localMapLibreJavaScript = source;
-  else localMapLibreStylesheet = source;
-  return source;
-}
-function textAssetResponse(body, contentType) {
-  return new Response(body, {
-    headers: {
-      "Access-Control-Allow-Origin": "*",
-      "Cache-Control": "no-store",
-      "Content-Type": contentType
-    }
-  });
-}
-function clearTileflowLocalModuleCache(configPath, cwd) {
-  const roots = [canonicalPath2(cwd), canonicalPath2(dirname2(resolve3(configPath)))];
-  for (const cachePath of Object.keys(localRequire.cache)) {
-    if (cachePath.split(sep3).includes("node_modules")) continue;
-    if (roots.some((root) => isPathWithin(root, canonicalPath2(cachePath)))) {
-      delete localRequire.cache[cachePath];
-    }
-  }
-}
-function canonicalPath2(path) {
-  try {
-    return realpathSync2.native(resolve3(path));
-  } catch {
-    return resolve3(path);
-  }
-}
-function isPathWithin(root, candidate) {
-  const path = relative3(resolve3(root), resolve3(candidate));
-  return path === "" || !isAbsolute3(path) && path !== ".." && !path.startsWith(`..${sep3}`);
-}
+  TileflowPreviewSelectionError,
+  normalizeTileflowLandmarkManifest,
+  readBoundedTileflowJsonResponse,
+  readBoundedTileflowResponse,
+  renderTileflowPreviewHtml,
+  resolveTileflowPreview
+} from "./chunk-GWUMIHL6.js";
+import {
+  createTileflowArtifactStatus,
+  createTileflowComparisonRequestHandler,
+  createTileflowDevRequestHandler,
+  createTileflowNodeRequest,
+  getTileflowRequestPath,
+  getTileflowStyleInspectionSelection,
+  getTileflowStyleSelection,
+  isTileflowRequestUrl,
+  tileflowComparisonSchemaVersion,
+  writeTileflowNodeResponse
+} from "./chunk-OEABXOJH.js";
+import {
+  TileflowHostedManifestOverwriteError,
+  assertTileflowSelfHostedManifestTarget,
+  createTileflowArtifactDiagnostics,
+  createTileflowArtifactPlan,
+  createTileflowArtifactSession,
+  createTileflowBuildArtifacts,
+  createTileflowBuildProvenance,
+  createTileflowManifest,
+  createTileflowStyle,
+  createTileflowStyles,
+  getTileflowArtifactFiles,
+  getTileflowWatchPaths,
+  isTileflowArtifactInputPath,
+  refreshTileflowArtifactSession,
+  tileflowArtifactInventoryFileName,
+  tileflowArtifactPlanSchemaVersion,
+  tileflowArtifactSessionSchemaVersion,
+  writeTileflowArtifactPlan,
+  writeTileflowBuildArtifacts
+} from "./chunk-O7PE6FB2.js";
+import {
+  TileflowFontCompilationError,
+  bindTileflowStyleFontBundle,
+  getTileflowAssetBasePath,
+  getTileflowAssetFileName,
+  getTileflowFontWatchPaths,
+  joinTileflowPublicUrl,
+  normalizeTileflowBasePath,
+  prepareTileflowStyleFonts,
+  replaceTileflowStyleFontSources,
+  resolveTileflowArtifactPublicUrls
+} from "./chunk-VEB43KDS.js";
+import {
+  TileflowIconCompilationError,
+  compileTileflowIconPackages,
+  getTileflowIconWatchPaths,
+  iconFileExtensions,
+  inspectTileflowIconCatalogs,
+  prepareTileflowCatalogIcons
+} from "./chunk-BALG4DSG.js";
+import "./chunk-BL3FK4GO.js";
+import {
+  TileflowStyleValidationError,
+  assertValidTileflowStyle,
+  validateTileflowStyle
+} from "./chunk-KDFTE4Q5.js";
+import {
+  TileflowValidationError,
+  assertValidTileflowConfig,
+  defaultTileflowApiUrl,
+  defaultTileflowConfigPath,
+  defaultTileflowManifestPath,
+  getFirstTileflowMapName,
+  getTileflowMapNames,
+  loadTileflowConfig,
+  loadTileflowConfigWithInputs,
+  loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs
+} from "./chunk-BKHIZ7H2.js";
+import "./chunk-D4OE4ITL.js";
 export {
+  TileflowConfigInspectionError,
+  TileflowFontCompilationError,
+  TileflowHostedManifestOverwriteError,
   TileflowIconCompilationError,
   TileflowPreviewSelectionError,
   TileflowStyleValidationError,
   TileflowValidationError,
-  asTileflowProjectConfig,
+  assertTileflowSelfHostedManifestTarget,
   assertValidTileflowConfig,
   assertValidTileflowStyle,
+  bindTileflowStyleFontBundle,
   compileTileflowIconPackages,
   createTileflowArtifactDiagnostics,
+  createTileflowArtifactPlan,
   createTileflowArtifactSession,
   createTileflowArtifactStatus,
   createTileflowBuildArtifacts,
+  createTileflowBuildProvenance,
+  createTileflowCommandFailureDocument,
+  createTileflowCommandSummary,
+  createTileflowComparisonRequestHandler,
   createTileflowDevRequestHandler,
   createTileflowManifest,
   createTileflowNodeRequest,
+  createTileflowStructuredDiagnostics,
   createTileflowStyle,
   createTileflowStyles,
   defaultTileflowApiUrl,
   defaultTileflowConfigPath,
   defaultTileflowManifestPath,
   getFirstTileflowMapName,
+  getTileflowArtifactFiles,
   getTileflowAssetBasePath,
   getTileflowAssetFileName,
+  getTileflowFontWatchPaths,
+  getTileflowIconWatchPaths,
   getTileflowMapNames,
-  getTileflowStyleMapName,
+  getTileflowRequestPath,
+  getTileflowStyleInspectionSelection,
+  getTileflowStyleSelection,
   getTileflowWatchPaths,
   iconFileExtensions,
+  inspectLoadedTileflowConfig,
+  inspectTileflowConfig,
   inspectTileflowFeatures,
   inspectTileflowIconCatalogs,
+  isTileflowArtifactInputPath,
   isTileflowRequestUrl,
   joinTileflowPublicUrl,
   loadTileflowConfig,
+  loadTileflowConfigWithInputs,
   loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs,
   normalizeTileflowBasePath,
-  prepareTileflowProjectIcons,
+  normalizeTileflowLandmarkManifest,
+  prepareTileflowCatalogIcons,
+  prepareTileflowStyleFonts,
+  readBoundedTileflowJsonResponse,
+  readBoundedTileflowResponse,
+  refreshTileflowArtifactSession,
+  renderTileflowPreviewHtml,
+  replaceTileflowStyleFontSources,
+  resolveTileflowArtifactPublicUrls,
   resolveTileflowPreview,
+  serializeTileflowCommandDocument,
+  tileflowArtifactInventoryFileName,
+  tileflowArtifactPlanSchemaVersion,
   tileflowArtifactSessionSchemaVersion,
+  tileflowCommandDocumentSchemaVersion,
+  tileflowComparisonSchemaVersion,
   validateTileflowStyle,
+  writeTileflowArtifactPlan,
   writeTileflowBuildArtifacts,
   writeTileflowNodeResponse
 };