@tileflow/dev 0.1.0-alpha.14 → 0.1.0-alpha.16

package/dist/index.js

@@ -1,203 +1,1838 @@
 // src/index.ts
 import { createJiti } from "jiti";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync, readFileSync, realpathSync as realpathSync2 } from "fs";
 import { mkdir, writeFile } from "fs/promises";
-import { dirname, resolve as resolve2 } from "path";
+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,
+  createStyleFromProject as createStyleFromProject2,
   validateConfig
 } from "@tileflow/core";
 
 // src/icons.ts
-import { existsSync } from "fs";
-import { readdir } from "fs/promises";
-import { extname, resolve } from "path";
+import { readdir, readFile, realpath, stat } from "fs/promises";
+import { basename, extname, isAbsolute, relative, resolve, sep } from "path";
+import { SaxesParser } from "saxes";
+import {
+  compareCodeUnits,
+  hashTileflowIconPackageManifest,
+  hashTileflowRenderedIconPixels,
+  serializeCanonicalJson,
+  sha256Hex,
+  tileflowHostedIconIdPattern,
+  tileflowIconPackageLabelSchema,
+  tileflowIconPackageLimits,
+  tileflowIconPackageManifestSchema
+} 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;
+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: [...result.compiledBySource.keys()].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 && !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 localSources = getLocalIconSources(project, options.cwd);
-  for (const localSource of localSources) {
-    const mapConfig = nextProject.maps[localSource.mapName];
+  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).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);
+    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 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;
     }
-    const iconSet = resolveIconSet(mapConfig.icons, nextProject.icons);
-    if (!iconSet) {
+    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;
     }
-    const spriteUrl = joinUrl(options.assetBaseUrl, `icons/${localSource.mapName}/sprite`);
-    mapConfig.icons = {
-      ...iconSet,
-      sprite: spriteUrl
+    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 = {
+      assetBaseUrl: options.assetBaseUrl,
+      config: options.config,
+      cwd: this.#cwd,
+      styleBaseUrl: options.styleBaseUrl,
+      tileBaseUrl: options.tileBaseUrl
     };
   }
-  if (localSources.length === 0) {
-    return {
-      assets: [],
-      project: nextProject,
-      watchPaths: []
-    };
+  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);
   }
-  const assets = (await Promise.all(
-    localSources.map(async (source) => buildSpriteAssets(source.sourceDir, source.mapName))
-  )).flat();
+};
+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 {
-    assets,
-    project: nextProject,
-    watchPaths: localSources.map((source) => source.sourceDir)
+    map,
+    message: boundText(sanitizeDiagnosticSecrets(sanitizeUrls(detail)), maxMessageLength),
+    path: boundText(stableStylePath(style, map, rawPath), maxPathLength)
   };
 }
-function getTileflowIconWatchPaths(project, cwd) {
-  return uniqueStrings(getLocalIconSources(project, cwd).map((source) => source.sourceDir));
-}
-function getLocalIconSources(project, cwd) {
-  return Object.entries(project.maps).flatMap(([mapName, mapConfig]) => {
-    const iconSet = resolveIconSet(mapConfig.icons, project.icons);
-    const sourceDir = resolveLocalIconSource(iconSet, cwd);
-    return sourceDir ? [{ mapName, sourceDir }] : [];
+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 resolveLocalIconSource(iconSet, cwd) {
-  if (!iconSet?.source) {
-    return null;
+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 resolve(cwd, iconSet.source);
+  return sanitized.slice(0, 128) || "(unknown)";
 }
-function resolveIconSet(icons, iconSets, path = []) {
-  if (!icons) {
-    return void 0;
+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 icons === "string") {
-    const referenced = iconSets?.[icons];
-    if (referenced) {
-      if (path.includes(icons)) {
-        throw new Error(`Circular Tileflow icon set extends: ${[...path, icons].join(" -> ")}`);
+  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";
+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, { tileBaseUrl: options.tileBaseUrl });
+  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)
+        });
       }
-      return resolveIconSet(referenced, iconSets, [...path, icons]);
+      if (scanTruncated) break;
     }
-    return isRemoteSpriteReference(icons) ? { sprite: icons } : { source: icons };
+    if (scanTruncated) break;
   }
-  const extended = icons.extends ? resolveIconSet(icons.extends, iconSets, path) : void 0;
+  const uniqueFeatures = deduplicateFeatures(features).sort(compareInspectedFeatures);
+  const limitedFeatures = uniqueFeatures.slice(0, options.limit);
+  const metadataVersion = style.metadata?.["tileflow:tilesetVersion"];
   return {
-    ...extended,
-    ...icons,
-    mapping: {
-      ...extended?.mapping,
-      ...icons.mapping
-    }
+    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
   };
 }
-async function buildSpriteAssets(sourceDir, mapName) {
-  const icons = await readIconFiles(sourceDir);
-  if (icons.length === 0) {
-    throw new Error(`No SVG or PNG icons found in ${sourceDir}.`);
+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.`
+    );
   }
-  const [sprite, sprite2x] = await Promise.all([
-    buildSprite(sourceDir, icons, 1),
-    buildSprite(sourceDir, icons, 2)
-  ]);
-  return [
-    jsonAsset(`icons/${mapName}/sprite.json`, sprite.index),
-    binaryAsset(`icons/${mapName}/sprite.png`, sprite.image, "image/png"),
-    jsonAsset(`icons/${mapName}/sprite@2x.json`, sprite2x.index),
-    binaryAsset(`icons/${mapName}/sprite@2x.png`, sprite2x.image, "image/png")
-  ];
+  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
+  };
 }
-async function readIconFiles(sourceDir) {
-  if (!existsSync(sourceDir)) {
-    throw new Error(`Icon source not found: ${sourceDir}`);
+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}.`
+    );
   }
-  const entries = await readdir(sourceDir, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && iconFileExtensions.has(extname(entry.name).toLowerCase())).map((entry) => ({
-    name: entry.name.slice(0, -extname(entry.name).length),
-    path: resolve(sourceDir, entry.name)
-  })).sort((left, right) => left.name.localeCompare(right.name));
+  return value;
 }
-async function buildSprite(sourceDir, icons, pixelRatio) {
-  const sharp = await loadSharp();
-  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;
-  const index = {};
-  const composite = await Promise.all(
-    icons.map(async (icon, indexNumber) => {
-      const column = indexNumber % columns;
-      const row = Math.floor(indexNumber / columns);
-      const left = column * cellSize;
-      const top = row * cellSize;
-      index[icon.name] = {
-        height: cellSize,
-        pixelRatio,
-        width: cellSize,
-        x: left,
-        y: top
-      };
-      return {
-        input: await sharp(icon.path, { density: 72 * pixelRatio }).resize(cellSize, cellSize, {
-          background: { alpha: 0, b: 0, g: 0, r: 0 },
-          fit: "contain"
-        }).png().toBuffer(),
-        left,
-        top
-      };
-    })
-  );
-  const image = await sharp({
-    create: {
-      background: { alpha: 0, b: 0, g: 0, r: 0 },
-      channels: 4,
-      height,
-      width
+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}".`);
     }
-  }).composite(composite).png().toBuffer();
-  return {
-    image,
-    index,
-    sourceDir
-  };
+  }
+  return normalized;
 }
-async function loadSharp() {
-  try {
-    return (await import("sharp")).default;
-  } catch (error) {
+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(
-      'Local icon sprites require the optional "sharp" package. Install sharp or disable local icons.',
-      { cause: error }
+      `Feature inspection requires exactly one vector source for the selected layers; found ${candidates.length}.`
     );
   }
+  const [id, definition] = candidates[0];
+  return { id, definition };
 }
-function jsonAsset(fileName, value) {
+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 {
-    contentType: "application/json; charset=utf-8",
-    fileName,
-    source: `${JSON.stringify(value, null, 2)}
-`
+    maxzoom: finiteZoom(tileJson.maxzoom, 22),
+    minzoom: finiteZoom(tileJson.minzoom, 0),
+    origin: finalTileJsonUrl.origin,
+    scheme: tileJson.scheme === "tms" ? "tms" : "xyz",
+    template,
+    tileJsonPath: finalTileJsonUrl.pathname
   };
 }
-function binaryAsset(fileName, source, contentType) {
+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 {
-    contentType,
-    fileName,
-    source
+    tiles,
+    ...typeof value.maxzoom === "number" ? { maxzoom: value.maxzoom } : {},
+    ...typeof value.minzoom === "number" ? { minzoom: value.minzoom } : {},
+    ...typeof value.scheme === "string" ? { scheme: value.scheme } : {}
   };
 }
-function cloneProject(project) {
-  return JSON.parse(JSON.stringify(project));
+function finiteZoom(value, fallback) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 24 ? value : fallback;
 }
-function isRemoteSpriteReference(value) {
-  return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("/") || value.startsWith("data:");
+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 joinUrl(base, path) {
-  const trimmedBase = base.replace(/\/+$/g, "");
-  const trimmedPath = path.replace(/^\/+/g, "");
-  return trimmedBase ? `${trimmedBase}/${trimmedPath}` : trimmedPath;
+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 uniqueStrings(values) {
-  return [...new Set(values)];
+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
@@ -206,7 +1841,9 @@ var defaultTileflowConfigPath = "tileflow.config.ts";
 var defaultTileflowManifestPath = "public/tileflow/manifest.json";
 var defaultTileflowTileset = "world";
 var TileflowValidationError = class extends Error {
+  code = "CONFIG_INVALID";
   messages;
+  phase = "config-validation";
   constructor(messages) {
     super("Invalid Tileflow config");
     this.name = "TileflowValidationError";
@@ -215,10 +1852,13 @@ var TileflowValidationError = class extends Error {
 };
 async function loadTileflowConfig(configPath = defaultTileflowConfigPath, options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const resolvedPath = resolve2(cwd, configPath);
-  if (!existsSync2(resolvedPath)) {
+  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
@@ -271,7 +1911,22 @@ function createTileflowManifest(project, options = {}) {
   return createManifest(project, options);
 }
 function createTileflowStyle(project, mapName, options = {}) {
-  return createStyleFromProject(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, {
@@ -283,22 +1938,21 @@ async function createTileflowBuildArtifacts(options = {}) {
     cwd: options.cwd ?? process.cwd()
   });
   const styleOptions = { tileBaseUrl: options.tileBaseUrl };
-  const styles = Object.fromEntries(
-    getTileflowMapNames(prepared.project).map((mapName) => [
-      mapName,
-      createStyleFromProject(prepared.project, mapName, styleOptions)
-    ])
-  );
+  const styles = createTileflowStyles(prepared.project, styleOptions);
   return {
     assets: prepared.assets,
     manifest: createManifest(prepared.project, {
       styleBaseUrl: options.styleBaseUrl,
       tileBaseUrl: options.tileBaseUrl
     }),
+    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, {
@@ -309,25 +1963,25 @@ async function getTileflowWatchPaths(options = {}) {
 }
 async function writeTileflowBuildArtifacts(options) {
   const cwd = options.cwd ?? process.cwd();
-  const outDir = resolve2(cwd, options.outDir);
-  const stylesDir = resolve2(outDir, "styles");
+  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(
-      resolve2(stylesDir, `${mapName}.json`),
+      resolve3(stylesDir, `${mapName}.json`),
       `${JSON.stringify(style, null, 2)}
 `,
       "utf8"
     );
   }
   for (const asset of artifacts.assets) {
-    const outputPath = resolve2(outDir, asset.fileName);
-    await mkdir(dirname(outputPath), { recursive: true });
+    const outputPath = resolve3(outDir, asset.fileName);
+    await mkdir(dirname2(outputPath), { recursive: true });
     await writeFile(outputPath, asset.source);
   }
   await writeFile(
-    resolve2(outDir, "manifest.json"),
+    resolve3(outDir, "manifest.json"),
     `${JSON.stringify(artifacts.manifest, null, 2)}
 `,
     "utf8"
@@ -353,7 +2007,25 @@ async function writeTileflowNodeResponse(response, tileflowResponse) {
   tileflowResponse.headers.forEach((value, key) => {
     response.setHeader(key, value);
   });
-  response.end(Buffer.from(await tileflowResponse.arrayBuffer()));
+  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, "");
@@ -383,64 +2055,63 @@ function createTileflowDevRequestHandler(options = {}) {
     }
     const url = new URL(request.url);
     const path = stripTileflowBasePath(url.pathname, basePath);
-    const loadPreparedProject = async () => {
-      const project = await loadValidTileflowConfig(configPath, {
-        cwd,
-        fresh: true
-      });
-      return prepareTileflowProjectIcons(project, {
-        assetBaseUrl: `${url.origin}${basePath}`,
-        cwd
-      });
-    };
     if (path === null) {
       return jsonResponse({ error: "Not found" }, 404);
     }
     try {
-      if (path === "/" || path === "") {
-        const project = await loadValidTileflowConfig(configPath, {
+      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,
-          fresh: true
+          styleBaseUrl: options.styleBaseUrl ?? `${url.origin}${basePath}`,
+          tileBaseUrl
         });
-        return htmlResponse(previewHtml(getFirstTileflowMapName(project), basePath));
+        state = {
+          artifacts,
+          generation: 1,
+          lastGoodGeneration: 1,
+          status: "ready"
+        };
+      }
+      if (path === "/__status") {
+        return jsonResponse(createTileflowArtifactStatus(state));
+      }
+      if (path === "/" || path === "") {
+        const mapName = artifacts ? getFirstTileflowMapName(artifacts.project) : void 0;
+        return htmlResponse(previewHtml(mapName, basePath, state));
       }
+      if (!artifacts) return unavailableArtifactsResponse(state);
       if (path === "/manifest.json") {
-        const project = await loadValidTileflowConfig(configPath, {
-          cwd,
-          fresh: true
-        });
-        const styleBaseUrl = options.styleBaseUrl ?? `${url.origin}${basePath}`;
-        return jsonResponse(
-          createManifest(project, {
-            styleBaseUrl,
-            tileBaseUrl
-          })
-        );
+        return jsonResponse(artifacts.manifest);
       }
       if (path === "/style.json") {
-        const prepared = await loadPreparedProject();
-        return jsonResponse(
-          createStyleFromProject(prepared.project, getFirstTileflowMapName(prepared.project), {
-            tileBaseUrl
-          })
-        );
+        return jsonResponse(artifacts.styles[getFirstTileflowMapName(artifacts.project)]);
       }
       if (path.startsWith("/styles/")) {
-        const prepared = await loadPreparedProject();
         const mapName = getTileflowStyleMapName(path);
-        if (!prepared.project.maps[mapName]) {
+        if (!Object.hasOwn(artifacts.styles, mapName)) {
           return jsonResponse({ error: `Unknown map: ${mapName}` }, 404);
         }
-        return jsonResponse(
-          createStyleFromProject(prepared.project, mapName, {
-            tileBaseUrl
-          })
-        );
+        return jsonResponse(artifacts.styles[mapName]);
       }
       if (path.startsWith("/icons/")) {
-        const prepared = await loadPreparedProject();
         const assetName = path.replace(/^\/+/, "");
-        const asset = prepared.assets.find((candidate) => candidate.fileName === assetName);
+        const asset = artifacts.assets.find((candidate) => candidate.fileName === assetName);
         if (!asset) {
           return jsonResponse({ error: `Unknown icon asset: ${assetName}` }, 404);
         }
@@ -453,6 +2124,60 @@ function createTileflowDevRequestHandler(options = {}) {
     }
   };
 }
+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;
@@ -474,6 +2199,15 @@ function stripTileflowBasePath(pathname, basePath) {
   return null;
 }
 function tileflowErrorResponse(error) {
+  if (error instanceof TileflowStyleValidationError) {
+    return jsonResponse(
+      {
+        error: error.message,
+        issues: error.issues
+      },
+      400
+    );
+  }
   if (error instanceof TileflowValidationError) {
     return jsonResponse(
       {
@@ -529,21 +2263,19 @@ function resolveAssetBaseUrl(options) {
 function isRelativePublicUrl(value) {
   return !(value.startsWith("http://") || value.startsWith("https://") || value.startsWith("/") || value.startsWith("data:"));
 }
-function previewHtml(mapName, basePath) {
-  const styleUrl = `${basePath}/styles/${mapName}.json`;
+function previewHtml(mapName, basePath, state) {
+  const styleUrl = mapName ? `${basePath}/styles/${mapName}.json` : void 0;
+  const initialStatus = createTileflowArtifactStatus(state);
   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="preconnect" href="https://fonts.googleapis.com" />
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet" />
-    <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.css" />
+    <link rel="stylesheet" href="${basePath}/__runtime/maplibre-gl.css" />
     <style>
       html, body, #map { height: 100%; margin: 0; }
-      body { font-family: Inter, ui-sans-serif, system-ui, sans-serif; }
+      body { font-family: ui-sans-serif, system-ui, sans-serif; }
       .badge {
         position: fixed;
         left: 16px;
@@ -556,35 +2288,131 @@ function previewHtml(mapName, basePath) {
         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">Tileflow preview</div>
+    <div class="badge" id="badge">Tileflow preview</div>
+    <div class="status" id="status" role="status"></div>
     <div id="map"></div>
-    <script type="module">
-      import maplibregl from "https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.js";
+    <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 styleUrl = ${JSON.stringify(styleUrl)};
 
-      const map = new maplibregl.Map({
-        container: "map",
-        style: "${styleUrl}",
-        center: [-3.7038, 40.4168],
-        zoom: 12
-      });
+      if (styleUrl) {
+        const map = new maplibregl.Map({
+          container: "map",
+          style: styleUrl,
+          center: [-3.7038, 40.4168],
+          zoom: 12
+        });
+        map.addControl(new maplibregl.NavigationControl(), "top-right");
+      }
+
+      function applyStatus(next) {
+        badge.textContent = "Tileflow preview \xB7 " + next.status;
+        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();
+        }
+      }
 
-      map.addControl(new maplibregl.NavigationControl(), "top-right");
+      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>`;
 }
+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}`);
+}
 export {
+  TileflowIconCompilationError,
+  TileflowStyleValidationError,
   TileflowValidationError,
   asTileflowProjectConfig,
   assertValidTileflowConfig,
+  assertValidTileflowStyle,
+  compileTileflowIconPackages,
+  createTileflowArtifactDiagnostics,
+  createTileflowArtifactSession,
+  createTileflowArtifactStatus,
   createTileflowBuildArtifacts,
   createTileflowDevRequestHandler,
   createTileflowManifest,
   createTileflowNodeRequest,
   createTileflowStyle,
+  createTileflowStyles,
   defaultTileflowApiUrl,
   defaultTileflowConfigPath,
   defaultTileflowManifestPath,
@@ -595,11 +2423,17 @@ export {
   getTileflowMapNames,
   getTileflowStyleMapName,
   getTileflowWatchPaths,
+  iconFileExtensions,
+  inspectTileflowFeatures,
+  inspectTileflowIconCatalogs,
   isTileflowRequestUrl,
   joinTileflowPublicUrl,
   loadTileflowConfig,
   loadValidTileflowConfig,
   normalizeTileflowBasePath,
+  prepareTileflowProjectIcons,
+  tileflowArtifactSessionSchemaVersion,
+  validateTileflowStyle,
   writeTileflowBuildArtifacts,
   writeTileflowNodeResponse
 };