@tileflow/dev 0.1.0-alpha.23 → 0.1.0-alpha.25

package/dist/chunk-D2QWYYIF.js

@@ -0,0 +1,1605 @@
+import {
+  TileflowAssetDirectoryError,
+  resolveTileflowAssetDirectories
+} from "./chunk-7C4F6GAX.js";
+
+// src/icons.ts
+import { readdir as readdir2, readFile, realpath as realpath3, stat } from "fs/promises";
+import { extname, isAbsolute as isAbsolute2, relative as relative2, resolve as resolvePath, sep as sep2 } from "path";
+import { SaxesParser } from "saxes";
+import {
+  collectTileflowIconSetReferences as collectTileflowIconSetReferences2,
+  TileflowIconSetError as TileflowIconSetError5,
+  tileflowIconsLockfileName as tileflowIconsLockfileName3,
+  tileflowIconSpriteIndexSchema
+} from "@tileflow/core";
+import {
+  compareCodeUnits as compareCodeUnits4,
+  hashTileflowRenderedIconPixels as hashTileflowRenderedIconPixels3,
+  parseResolvedTileflowMap,
+  parseTileflowIconJson as parseTileflowIconJson2,
+  serializeCanonicalJson as serializeCanonicalJson2,
+  sha256Hex as sha256Hex3,
+  tileflowIconIdPattern,
+  tileflowIconPackageLimits as tileflowIconPackageLimits4
+} from "@tileflow/core";
+
+// src/icon-composition.ts
+import { realpath as realpath2 } from "fs/promises";
+import { isAbsolute, relative, resolve as resolve3, sep } from "path";
+import { tileflowIconsLockfileName as tileflowIconsLockfileName2 } from "@tileflow/core";
+import {
+  collectTileflowIconSetReferences,
+  compareCodeUnits as compareCodeUnits3,
+  parseTileflowIconComposition,
+  parseTileflowIconsLockfile as parseTileflowIconsLockfile2,
+  TileflowIconSetError as TileflowIconSetError4,
+  tileflowIconPackageLimits as tileflowIconPackageLimits3
+} from "@tileflow/core";
+
+// src/icon-cache.ts
+import { hashTileflowIconPackageManifest as hashTileflowIconPackageManifest3 } from "@tileflow/core";
+import { constants } from "fs";
+import { lstat, mkdir, mkdtemp, open, readdir, realpath, rename, rm } from "fs/promises";
+import { homedir, platform } from "os";
+import { join, resolve } from "path";
+import {
+  TileflowIconSetError as TileflowIconSetError2,
+  tileflowIconSetPinSchema
+} from "@tileflow/core";
+
+// src/icon-artifact.ts
+import {
+  tileflowIconSpriteIndexSchema as indexSchema
+} from "@tileflow/core";
+import {
+  compareCodeUnits as compareCodeUnits2,
+  hashTileflowIconPackageManifest as hashTileflowIconPackageManifest2,
+  hashTileflowRenderedIconPixels as hashTileflowRenderedIconPixels2,
+  parseTileflowIconJson,
+  sha256Hex as sha256Hex2,
+  TileflowIconSetError,
+  tileflowIconPackageLimits as tileflowIconPackageLimits2,
+  tileflowIconPackageManifestSchema as tileflowIconPackageManifestSchema2
+} from "@tileflow/core";
+
+// src/icon-sprite.ts
+import {
+  compareCodeUnits,
+  hashTileflowIconPackageManifest,
+  hashTileflowRenderedIconPixels,
+  serializeCanonicalJson,
+  sha256Hex,
+  tileflowIconIdSchema,
+  tileflowIconPackageLimits,
+  tileflowIconPackageManifestSchema
+} from "@tileflow/core";
+async function packTileflowRenderedIcons(input) {
+  const icons = [...input].sort((left, right) => compareCodeUnits(left.id, right.id));
+  if (icons.length < 1 || icons.length > tileflowIconPackageLimits.maxIconCount || new Set(icons.map((icon) => icon.id)).size !== icons.length)
+    throw new Error("Expected 1 through 256 unique rendered icons");
+  const renderedIcons = [];
+  for (const icon of icons) {
+    tileflowIconIdSchema.parse(icon.id);
+    if (icon.twoX.width !== icon.oneX.width * 2 || icon.twoX.height !== icon.oneX.height * 2)
+      throw new Error("Rendered density geometry must double exactly");
+    renderedIcons.push({
+      name: icon.id,
+      pixelSha256: {
+        oneX: await hashTileflowRenderedIconPixels({ ...icon.oneX, pixelRatio: 1 }),
+        twoX: await hashTileflowRenderedIconPixels({ ...icon.twoX, pixelRatio: 2 })
+      }
+    });
+  }
+  const oneX = icons.map((icon) => ({ ...icon.oneX, name: icon.id }));
+  const twoX = icons.map((icon) => ({ ...icon.twoX, name: icon.id }));
+  const layoutOneX = createSpriteLayout(oneX, 1);
+  const layoutTwoX = createSpriteLayout(twoX, 2);
+  if (layoutTwoX.width !== layoutOneX.width * 2 || layoutTwoX.height !== layoutOneX.height * 2)
+    throw new Error("Composed atlas exceeds the paired density geometry limit");
+  const files = [
+    {
+      contentType: "application/json",
+      fileName: "sprite.json",
+      source: new TextEncoder().encode(`${serializeCanonicalJson(layoutOneX.index)}
+`)
+    },
+    {
+      contentType: "image/png",
+      fileName: "sprite.png",
+      source: await createSpriteImage(oneX, layoutOneX)
+    },
+    {
+      contentType: "application/json",
+      fileName: "sprite@2x.json",
+      source: new TextEncoder().encode(`${serializeCanonicalJson(layoutTwoX.index)}
+`)
+    },
+    {
+      contentType: "image/png",
+      fileName: "sprite@2x.png",
+      source: await createSpriteImage(twoX, layoutTwoX)
+    }
+  ];
+  assertGeneratedFileLimits(files);
+  const manifest = tileflowIconPackageManifestSchema.parse({
+    format: "tileflow-icon-package-v1",
+    files: await Promise.all(
+      files.map(async (file) => ({
+        name: file.fileName,
+        byteLength: file.source.byteLength,
+        contentType: file.contentType,
+        sha256: await sha256Hex(file.source)
+      }))
+    ),
+    iconNames: icons.map((icon) => icon.id),
+    renderedIcons,
+    sprites: {
+      oneX: { width: layoutOneX.width, height: layoutOneX.height, pixelRatio: 1 },
+      twoX: { width: layoutTwoX.width, height: layoutTwoX.height, pixelRatio: 2 }
+    }
+  });
+  return { contentHash: await hashTileflowIconPackageManifest(manifest), manifest, files };
+}
+function createSpriteLayout(icons, pixelRatio) {
+  const columns = Math.ceil(Math.sqrt(icons.length));
+  const widest = Math.max(...icons.map((icon) => icon.width));
+  const targetWidth = Math.min(tileflowIconPackageLimits.maxAtlasDimension, columns * widest);
+  const placements = [];
+  let left = 0;
+  let rowHeight = 0;
+  let top = 0;
+  for (const icon of icons) {
+    if (icon.width > tileflowIconPackageLimits.maxAtlasDimension)
+      throw new Error(
+        `Generated sprite exceeds ${tileflowIconPackageLimits.maxAtlasDimension} pixels per dimension`
+      );
+    if (left > 0 && left + icon.width > targetWidth) {
+      top += rowHeight;
+      left = 0;
+      rowHeight = 0;
+    }
+    placements.push({ left, top });
+    left += icon.width;
+    rowHeight = Math.max(rowHeight, icon.height);
+  }
+  const width = targetWidth;
+  const height = top + rowHeight;
+  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, ordinal) => {
+      const placement = placements[ordinal];
+      return [
+        icon.name,
+        { height: icon.height, pixelRatio, width: icon.width, x: placement.left, y: placement.top }
+      ];
+    })
+  );
+  return { height, index, width };
+}
+async function createSpriteImage(icons, layout) {
+  const sharp = await loadSharp();
+  const atlas = new Uint8Array(layout.width * layout.height * 4);
+  for (const icon of icons) {
+    const placement = layout.index[icon.name];
+    if (!placement || icon.width !== placement.width || icon.height !== placement.height || icon.rgba.byteLength !== icon.width * icon.height * 4)
+      throw new Error("Rendered icon dimensions do not match the sprite layout");
+    const rowBytes = icon.width * 4;
+    for (let row = 0; row < icon.height; row += 1) {
+      const sourceStart = row * rowBytes;
+      const targetStart = ((placement.y + row) * layout.width + placement.x) * 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`
+    );
+}
+async function loadSharp() {
+  try {
+    return (await import("sharp")).default;
+  } catch (cause) {
+    throw new Error(
+      'Local icon sprites require the optional "sharp" package. Install sharp or disable local icons.',
+      { cause }
+    );
+  }
+}
+
+// src/icon-artifact.ts
+async function verifyTileflowIconArtifact(input) {
+  try {
+    const manifest = tileflowIconPackageManifestSchema2.parse(input.manifest);
+    const contentHash = input.contentHash;
+    if (input.files.length !== 4 || new Set(input.files.map((file) => file.fileName)).size !== 4)
+      throw new Error("An artifact must contain exactly the four generated files");
+    const files = manifest.files.map((expected) => {
+      const source = input.files.find((file) => file.fileName === expected.name);
+      if (!source || source.contentType !== expected.contentType || source.source.byteLength !== expected.byteLength)
+        throw new Error("Generated file identity does not match the manifest");
+      return {
+        contentType: source.contentType,
+        fileName: source.fileName,
+        source: new Uint8Array(source.source)
+      };
+    });
+    if (await hashTileflowIconPackageManifest2(manifest) !== contentHash)
+      throw new Error("Artifact manifest hash mismatch");
+    for (const [index, file] of files.entries()) {
+      if (await sha256Hex2(file.source) !== manifest.files[index].sha256)
+        throw new Error(`Generated ${file.fileName} checksum mismatch`);
+    }
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    const oneIndex = indexSchema.parse(
+      parseTileflowIconJson(
+        decoder.decode(files[0].source),
+        tileflowIconPackageLimits2.maxGeneratedFileBytes
+      )
+    );
+    const twoIndex = indexSchema.parse(
+      parseTileflowIconJson(
+        decoder.decode(files[2].source),
+        tileflowIconPackageLimits2.maxGeneratedFileBytes
+      )
+    );
+    for (const index of [oneIndex, twoIndex]) {
+      const names = Object.keys(index).sort(compareCodeUnits2);
+      if (names.length !== manifest.iconNames.length || names.some((name, ordinal) => name !== manifest.iconNames[ordinal]))
+        throw new Error("Sprite index does not exactly match the manifest icon names");
+    }
+    for (const [index, dimensions, ratio] of [
+      [oneIndex, manifest.sprites.oneX, 1],
+      [twoIndex, manifest.sprites.twoX, 2]
+    ]) {
+      const rectangles = Object.values(index);
+      for (const [ordinal, rect] of rectangles.entries()) {
+        if (rect.pixelRatio !== ratio || rect.x + rect.width > dimensions.width || rect.y + rect.height > dimensions.height)
+          throw new Error("Sprite rectangle is outside the atlas or has the wrong density");
+        for (const other of rectangles.slice(0, ordinal)) {
+          if (rect.x < other.x + other.width && other.x < rect.x + rect.width && rect.y < other.y + other.height && other.y < rect.y + rect.height)
+            throw new Error("Sprite rectangles must not overlap");
+        }
+      }
+    }
+    for (const name of manifest.iconNames) {
+      const one = oneIndex[name];
+      const two = twoIndex[name];
+      if (two.x !== one.x * 2 || two.y !== one.y * 2 || two.width !== one.width * 2 || two.height !== one.height * 2)
+        throw new Error("Sprite densities must have exactly doubled geometry");
+    }
+    const oneAtlas = await decodeAtlas(files[1].source, manifest.sprites.oneX);
+    const twoAtlas = await decodeAtlas(files[3].source, manifest.sprites.twoX);
+    const icons = [];
+    for (const [ordinal, id] of manifest.iconNames.entries()) {
+      const oneX = extractCell(oneAtlas, oneIndex[id]);
+      const twoX = extractCell(twoAtlas, twoIndex[id]);
+      const expected = manifest.renderedIcons[ordinal].pixelSha256;
+      if (await hashTileflowRenderedIconPixels2({ ...oneX, pixelRatio: 1 }) !== expected.oneX || await hashTileflowRenderedIconPixels2({ ...twoX, pixelRatio: 2 }) !== expected.twoX)
+        throw new Error(`Rendered pixels do not match the manifest for ${id}`);
+      icons.push({ id, oneX, twoX });
+    }
+    return { package: { contentHash, manifest, files }, icons };
+  } catch (cause) {
+    throw new TileflowIconSetError(
+      "ICON_PACKAGE_INTEGRITY",
+      "Generated icon artifact verification failed",
+      { cause }
+    );
+  }
+}
+async function decodeAtlas(bytes, dimensions) {
+  if ([137, 80, 78, 71, 13, 10, 26, 10].some((byte, index) => bytes[index] !== byte))
+    throw new Error("Expected PNG bytes");
+  const sharp = await loadSharp();
+  const image = sharp(bytes, {
+    failOn: "error",
+    limitInputPixels: tileflowIconPackageLimits2.maxAtlasDimension ** 2
+  });
+  const metadata = await image.metadata();
+  if (metadata.format !== "png" || (metadata.pages ?? 1) !== 1 || metadata.width !== dimensions.width || metadata.height !== dimensions.height)
+    throw new Error("PNG geometry does not match the manifest");
+  const { data, info } = await image.ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  if (info.channels !== 4 || info.width !== dimensions.width || info.height !== dimensions.height || data.length !== dimensions.width * dimensions.height * 4)
+    throw new Error("Expected bounded RGBA atlas pixels");
+  return { ...dimensions, rgba: new Uint8Array(data) };
+}
+function extractCell(atlas, rect) {
+  const rgba = new Uint8Array(rect.width * rect.height * 4);
+  const rowBytes = rect.width * 4;
+  for (let row = 0; row < rect.height; row += 1) {
+    const start = ((rect.y + row) * atlas.width + rect.x) * 4;
+    rgba.set(atlas.rgba.subarray(start, start + rowBytes), row * rowBytes);
+  }
+  return { height: rect.height, width: rect.width, rgba };
+}
+
+// src/icon-cache.ts
+function getTileflowIconCacheDirectory(options = {}) {
+  const defaultRoot = platform() === "darwin" ? join(homedir(), "Library", "Caches") : platform() === "win32" ? process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local") : process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
+  return join(
+    resolve(options.cacheRoot ?? process.env.TILEFLOW_ICON_CACHE_DIR ?? defaultRoot),
+    "tileflow",
+    "icons",
+    "v1"
+  );
+}
+async function loadTileflowIconSetArtifact(input, options = {}) {
+  const pin = tileflowIconSetPinSchema.parse(input);
+  if (await hashTileflowIconPackageManifest3(pin.manifest) !== pin.contentHash)
+    throw new TileflowIconSetError2("ICON_LOCK_INVALID", "Locked manifest hash mismatch");
+  let cacheFailure;
+  try {
+    return await readCached(pin, options);
+  } catch (cause) {
+    if (cause instanceof TileflowIconSetError2 && cause.code === "ICON_CACHE_UNSAFE") throw cause;
+    cacheFailure = cause;
+  }
+  if (options.offline) {
+    throw new TileflowIconSetError2(
+      isMissing(cacheFailure) ? "ICON_CACHE_MISS" : "ICON_PACKAGE_INTEGRITY",
+      "The exact verified icon artifact is unavailable offline; hydrate this pin explicitly",
+      { cause: cacheFailure }
+    );
+  }
+  const url = new URL(pin.spriteUrl);
+  const allowed = options.deliveryOrigins ?? ["https://api.tileflow.dev"];
+  if (!allowed.some((origin) => origin === url.origin && new URL(origin).href === `${origin}/`)) {
+    throw new TileflowIconSetError2(
+      "ICON_DOWNLOAD_FAILED",
+      "Icon artifact delivery origin is not trusted"
+    );
+  }
+  const files = [];
+  const signal = options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(3e4)]) : AbortSignal.timeout(3e4);
+  try {
+    for (const expected of pin.manifest.files) {
+      signal.throwIfAborted();
+      const fileUrl = `${pin.spriteUrl}${expected.name.slice("sprite".length)}`;
+      const response = await (options.fetch ?? globalThis.fetch)(fileUrl, {
+        method: "GET",
+        credentials: "omit",
+        redirect: "error",
+        headers: { Accept: expected.contentType, "Accept-Encoding": "identity" },
+        signal
+      });
+      if (response.status !== 200 || response.redirected || response.url && response.url !== fileUrl || !response.body)
+        throw new Error("Unexpected artifact response");
+      const type = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+      const length = response.headers.get("content-length");
+      const encoding = response.headers.get("content-encoding")?.trim().toLowerCase();
+      const isIdentityEncoding = encoding === void 0 || encoding === "" || encoding === "identity";
+      if (type !== expected.contentType || length !== null && (!/^\d+$/u.test(length) || isIdentityEncoding && Number(length) !== expected.byteLength)) {
+        await response.body.cancel();
+        throw new Error("Artifact response headers do not match the manifest");
+      }
+      const reader = response.body.getReader();
+      const source = new Uint8Array(expected.byteLength);
+      let offset = 0;
+      try {
+        while (true) {
+          const chunk = await reader.read();
+          if (chunk.done) break;
+          if (offset + chunk.value.byteLength > source.byteLength)
+            throw new Error("Artifact response exceeds its exact byte length");
+          source.set(chunk.value, offset);
+          offset += chunk.value.byteLength;
+        }
+        if (offset !== source.byteLength) throw new Error("Artifact response was truncated");
+      } catch (cause) {
+        await reader.cancel().catch(() => void 0);
+        throw cause;
+      } finally {
+        reader.releaseLock();
+      }
+      files.push({ fileName: expected.name, contentType: expected.contentType, source });
+    }
+  } catch (cause) {
+    throw new TileflowIconSetError2("ICON_DOWNLOAD_FAILED", "Exact icon artifact download failed", {
+      cause
+    });
+  }
+  return storeTileflowIconSetArtifact(
+    pin,
+    { contentHash: pin.contentHash, manifest: pin.manifest, files },
+    options
+  );
+}
+async function storeTileflowIconSetArtifact(input, artifact, options = {}) {
+  const pin = tileflowIconSetPinSchema.parse(input);
+  if (await hashTileflowIconPackageManifest3(pin.manifest) !== pin.contentHash)
+    throw new TileflowIconSetError2("ICON_LOCK_INVALID", "Locked manifest hash mismatch");
+  if (artifact.contentHash !== pin.contentHash)
+    throw new TileflowIconSetError2(
+      "ICON_PACKAGE_INTEGRITY",
+      "Artifact does not match the selected pin"
+    );
+  const verified = await verifyTileflowIconArtifact({
+    contentHash: pin.contentHash,
+    manifest: pin.manifest,
+    files: artifact.files
+  });
+  const root = await safeCacheRoot(options, true);
+  const target = join(root, pin.contentHash);
+  const temporary = await mkdtemp(join(root, `.incoming-${pin.contentHash}-`));
+  try {
+    for (const file of verified.package.files) {
+      const handle = await open(join(temporary, file.fileName), "wx", 384);
+      try {
+        await handle.writeFile(file.source);
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+    }
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      try {
+        await rename(temporary, target);
+        return verified;
+      } catch (cause) {
+        if (!hasCode(cause, "EEXIST") && !hasCode(cause, "ENOTEMPTY") && !hasCode(cause, "EPERM"))
+          throw cause;
+      }
+      try {
+        return await readCached(pin, options);
+      } catch (cause) {
+        if (cause instanceof TileflowIconSetError2 && cause.code === "ICON_CACHE_UNSAFE")
+          throw cause;
+      }
+      try {
+        await assertDirectory(target);
+        const retired = await mkdtemp(join(root, `.retired-${pin.contentHash}-`));
+        try {
+          await rename(target, join(retired, "entry"));
+        } catch (cause) {
+          if (!isMissing(cause)) throw cause;
+        } finally {
+          await rm(retired, { recursive: true, force: true });
+        }
+      } catch (cause) {
+        if (!isMissing(cause)) throw cause;
+      }
+    }
+    throw new TileflowIconSetError2(
+      "ICON_CACHE_UNSAFE",
+      "Concurrent cache repairs did not converge; retry this exact pin"
+    );
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+}
+async function readCached(pin, options) {
+  const root = await safeCacheRoot(options, false);
+  const directory = join(root, pin.contentHash);
+  await assertDirectory(directory);
+  const entries = (await readdir(directory)).sort();
+  const expectedNames = pin.manifest.files.map((file) => file.name).sort();
+  if (entries.length !== 4 || entries.some((name, index) => name !== expectedNames[index]))
+    throw new TileflowIconSetError2(
+      "ICON_PACKAGE_INTEGRITY",
+      "Cache entry does not contain exactly four generated files"
+    );
+  const files = [];
+  for (const expected of pin.manifest.files) {
+    files.push({
+      fileName: expected.name,
+      contentType: expected.contentType,
+      source: await readSafeFile(join(directory, expected.name), expected.byteLength)
+    });
+  }
+  return verifyTileflowIconArtifact({ contentHash: pin.contentHash, manifest: pin.manifest, files });
+}
+async function safeCacheRoot(options, create) {
+  const root = getTileflowIconCacheDirectory(options);
+  const base = resolve(root, "..", "..", "..");
+  if (create) await mkdir(base, { recursive: true, mode: 448 });
+  await assertDirectory(base);
+  let current = await realpath(base);
+  for (const segment of ["tileflow", "icons", "v1"]) {
+    current = join(current, segment);
+    if (create)
+      await mkdir(current, { mode: 448 }).catch((cause) => {
+        if (!hasCode(cause, "EEXIST")) throw cause;
+      });
+    await assertDirectory(current);
+  }
+  return current;
+}
+async function assertDirectory(path) {
+  const entry = await lstat(path);
+  if (!entry.isDirectory() || entry.isSymbolicLink())
+    throw new TileflowIconSetError2(
+      "ICON_CACHE_UNSAFE",
+      "Icon cache paths must be directories, not symlinks"
+    );
+}
+async function readSafeFile(path, maximumBytes, exact = true) {
+  const entry = await lstat(path);
+  if (!entry.isFile() || entry.isSymbolicLink())
+    throw new TileflowIconSetError2(
+      "ICON_CACHE_UNSAFE",
+      "Icon files must be regular files, not symlinks"
+    );
+  const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const opened = await handle.stat();
+    if (!opened.isFile() || opened.ino !== entry.ino || opened.dev !== entry.dev || opened.size > maximumBytes || exact && opened.size !== maximumBytes)
+      throw new TileflowIconSetError2(
+        "ICON_PACKAGE_INTEGRITY",
+        "Icon file size or identity changed"
+      );
+    const buffer = new Uint8Array(maximumBytes + 1);
+    let offset = 0;
+    while (offset < buffer.length) {
+      const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, null);
+      if (bytesRead === 0) break;
+      offset += bytesRead;
+    }
+    if (offset > maximumBytes || exact && offset !== maximumBytes)
+      throw new TileflowIconSetError2("ICON_PACKAGE_INTEGRITY", "Icon file byte length changed");
+    return buffer.slice(0, offset);
+  } finally {
+    await handle.close();
+  }
+}
+function hasCode(error, code) {
+  return error !== null && typeof error === "object" && "code" in error && error.code === code;
+}
+function isMissing(error) {
+  return hasCode(error, "ENOENT");
+}
+
+// src/icon-lockfile.ts
+import { lstat as lstat2, mkdir as mkdir2, mkdtemp as mkdtemp2, open as open2, rename as rename2, rm as rm2, rmdir } from "fs/promises";
+import { join as join2, resolve as resolve2 } from "path";
+import {
+  parseTileflowIconsLockfile,
+  serializeTileflowIconsLockfile,
+  TileflowIconSetError as TileflowIconSetError3,
+  tileflowIconsLockfileMaximumBytes,
+  tileflowIconsLockfileName
+} from "@tileflow/core";
+async function readTileflowIconsLockfileText(baseDirectory) {
+  return readLockText(join2(resolve2(baseDirectory), tileflowIconsLockfileName));
+}
+async function readTileflowIconsLockfile(baseDirectory, sources) {
+  const text = await readLockText(join2(resolve2(baseDirectory), tileflowIconsLockfileName));
+  if (text === null)
+    throw new TileflowIconSetError3(
+      "ICON_LOCK_MISSING",
+      "Missing tileflow.icons.lock.json; install exact icon set revisions explicitly"
+    );
+  return parseTileflowIconsLockfile(text, sources);
+}
+async function writeTileflowIconsLockfile(baseDirectory, input, expectedContents) {
+  const content = await serializeTileflowIconsLockfile(input);
+  const directory = resolve2(baseDirectory);
+  const destination = join2(directory, tileflowIconsLockfileName);
+  const guard = join2(directory, `.${tileflowIconsLockfileName}.writing`);
+  try {
+    await mkdir2(guard, { mode: 448 });
+  } catch (cause) {
+    throw new TileflowIconSetError3(
+      "ICON_LOCK_CONFLICT",
+      "Another icon lock writer is active; a stale .writing guard may be removed only after confirming its writer has exited",
+      { cause }
+    );
+  }
+  let temporary;
+  try {
+    const actual = await readLockText(destination);
+    if (actual !== expectedContents)
+      throw new TileflowIconSetError3(
+        "ICON_LOCK_CONFLICT",
+        "Icon lock changed since it was read; reload and retry without discarding other pins"
+      );
+    if (actual === content) return;
+    temporary = await mkdtemp2(join2(directory, ".tileflow-icons-lock-"));
+    const file = join2(temporary, "lock");
+    const handle = await open2(file, "wx", 384);
+    try {
+      await handle.writeFile(content, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    if (await readLockText(destination) !== actual)
+      throw new TileflowIconSetError3(
+        "ICON_LOCK_CONFLICT",
+        "Icon lock changed while preparing an update"
+      );
+    await rename2(file, destination);
+  } finally {
+    if (temporary) await rm2(temporary, { recursive: true, force: true });
+    await rmdir(guard);
+  }
+}
+async function readLockText(path) {
+  try {
+    const entry = await lstat2(path);
+    if (!entry.isFile() || entry.isSymbolicLink())
+      throw new TileflowIconSetError3(
+        "ICON_LOCK_INVALID",
+        "The icon lock must be a regular file, not a symlink"
+      );
+    return new TextDecoder("utf-8", { fatal: true }).decode(
+      await readSafeFile(path, tileflowIconsLockfileMaximumBytes, false)
+    );
+  } catch (cause) {
+    if (cause !== null && typeof cause === "object" && "code" in cause && cause.code === "ENOENT")
+      return null;
+    throw cause;
+  }
+}
+
+// src/icon-composition.ts
+async function composeTileflowIconSources(input, options) {
+  const sources = structuredClone(input);
+  const references = collectTileflowIconSetReferences(sources);
+  let realCwd;
+  const lock = references.length > 0 ? options.lock === void 0 ? await readTileflowIconsLockfile(options.baseDirectory ?? options.cwd, sources) : await parseTileflowIconsLockfile2(options.lock, sources) : await parseTileflowIconsLockfile2(options.lock ?? { lockfileVersion: 1, sets: {} }, sources);
+  const contributors = new Array(sources.length);
+  const details = new Array(sources.length);
+  const winners = /* @__PURE__ */ new Map();
+  const watchPaths = /* @__PURE__ */ new Set();
+  const watchFiles = /* @__PURE__ */ new Set();
+  if (references.length > 0 && options.lock === void 0)
+    watchFiles.add(resolve3(options.baseDirectory ?? options.cwd, tileflowIconsLockfileName2));
+  let reused;
+  let pixelBytes = 0;
+  let localSourceBytes = 0;
+  for (let ordinal = sources.length - 1; ordinal >= 0; ordinal -= 1) {
+    const source = sources[ordinal];
+    if (typeof source === "object" && source.kind === "icon-set") {
+      const pin = lock.sets[source.reference];
+      const loaded = await loadTileflowIconSetArtifact(pin, options);
+      contributors[ordinal] = {
+        kind: "icon-set",
+        reference: source.reference,
+        teamId: pin.teamId,
+        setId: pin.setId,
+        versionId: pin.versionId,
+        version: pin.version,
+        packageId: pin.packageId,
+        contentHash: pin.contentHash,
+        iconIds: [...pin.manifest.iconNames]
+      };
+      details[ordinal] = {
+        iconIds: [...pin.manifest.iconNames],
+        kind: "icon-set",
+        label: source.reference,
+        packageId: pin.packageId,
+        reference: source.reference,
+        setId: pin.setId,
+        version: pin.version,
+        versionId: pin.versionId
+      };
+      if (sources.length === 1) reused = loaded.package;
+      for (const icon of loaded.icons) {
+        if (winners.has(icon.id)) continue;
+        const pixels = pin.manifest.renderedIcons.find(
+          (entry) => entry.name === icon.id
+        ).pixelSha256;
+        addWinner(
+          ordinal,
+          icon,
+          {
+            kind: "rendered-icon",
+            id: icon.id,
+            width: icon.oneX.width,
+            height: icon.oneX.height,
+            pixelSha256: { ...pixels }
+          },
+          null
+        );
+      }
+    } else {
+      const directory = await readTileflowIconDirectory(source, {
+        cwd: options.cwd,
+        baseDirectory: options.baseDirectory ?? options.cwd,
+        ...options.configPath === void 0 ? {} : { configPath: options.configPath },
+        ordinal,
+        target: options.target ?? "local"
+      });
+      if (directory.watchPath) watchPaths.add(directory.watchPath);
+      contributors[ordinal] = typeof source === "string" ? { kind: "local", iconIds: directory.iconIds } : { kind: "package", package: source.package, iconIds: directory.iconIds };
+      details[ordinal] = {
+        entries: directory.entries,
+        iconIds: directory.iconIds,
+        insideWorkingTree: isPathInside(
+          realCwd ??= await realpath2(options.cwd),
+          directory.realPath
+        ),
+        kind: typeof source === "string" ? "local" : "package",
+        label: directory.label
+      };
+      const selected = directory.iconIds.filter((id) => !winners.has(id));
+      if (winners.size + selected.length > tileflowIconPackageLimits3.maxIconCount)
+        throw new TileflowIconSetError4(
+          "ICON_COMPOSITION_INVALID",
+          "Composed icon set exceeds 256 effective icons"
+        );
+      for (const item of await directory.render(selected)) {
+        localSourceBytes += item.sourceBytes;
+        if (localSourceBytes > tileflowIconPackageLimits3.maxSourceBytes)
+          throw new TileflowIconSetError4(
+            "ICON_COMPOSITION_INVALID",
+            "Effective local icon originals exceed the source-byte limit"
+          );
+        addWinner(ordinal, item.icon, item.identity, item.source);
+      }
+    }
+  }
+  const sorted = [...winners.values()].sort(
+    (left, right) => compareCodeUnits3(left.icon.id, right.icon.id)
+  );
+  const iconPackage = sorted.length ? reused ?? await packTileflowRenderedIcons(sorted.map((winner) => winner.icon)) : null;
+  const composition = references.length && iconPackage ? parseTileflowIconComposition({
+    format: "tileflow-icon-composition-v1",
+    compositionVersion: 1,
+    packageHash: iconPackage.contentHash,
+    contributors,
+    winners: sorted.map(({ ordinal, icon }, index) => ({
+      id: icon.id,
+      contributor: ordinal,
+      width: icon.oneX.width,
+      height: icon.oneX.height,
+      pixelSha256: iconPackage.manifest.renderedIcons[index].pixelSha256
+    }))
+  }) : null;
+  const previous = /* @__PURE__ */ new Map();
+  const replacements = [];
+  for (const [ordinal, contributor] of contributors.entries()) {
+    for (const id of contributor.iconIds) {
+      const replaced = previous.get(id);
+      if (replaced !== void 0) replacements.push({ id, replaced, winner: ordinal });
+      previous.set(id, ordinal);
+    }
+  }
+  return {
+    package: iconPackage,
+    composition,
+    contributors: details,
+    sourceIdentities: sorted.map((winner) => winner.identity),
+    replacements,
+    watchFiles: [...watchFiles].sort(compareCodeUnits3),
+    watchPaths: [...watchPaths].sort(compareCodeUnits3),
+    winners: sorted.map((winner) => ({
+      contributor: winner.ordinal,
+      id: winner.icon.id,
+      identity: winner.identity,
+      source: winner.source
+    }))
+  };
+  function addWinner(ordinal, icon, identity, source) {
+    pixelBytes += icon.oneX.rgba.byteLength + icon.twoX.rgba.byteLength;
+    const maximumPixelBytes = (tileflowIconPackageLimits3.maxAtlasDimension ** 2 + (tileflowIconPackageLimits3.maxAtlasDimension / 2) ** 2) * 4;
+    if (winners.size >= tileflowIconPackageLimits3.maxIconCount || pixelBytes > maximumPixelBytes)
+      throw new TileflowIconSetError4(
+        "ICON_COMPOSITION_INVALID",
+        "Composed rendered cells exceed the final sprite capacity"
+      );
+    winners.set(icon.id, { ordinal, icon, identity, source });
+  }
+}
+function isPathInside(root, candidate) {
+  const pathFromRoot = relative(root, candidate);
+  return pathFromRoot === "" || !isAbsolute(pathFromRoot) && pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep}`);
+}
+
+// src/icons.ts
+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 composeMapIconSources(project, options);
+  const packagesByHash = /* @__PURE__ */ new Map();
+  for (const composed of result.composedBySequence.values()) {
+    if (composed.package) packagesByHash.set(composed.package.contentHash, composed.package);
+  }
+  const compositions = {};
+  const sourceIdentities = {};
+  for (const request of result.mapRequests) {
+    const composed = result.composedBySequence.get(request.sequenceKey);
+    sourceIdentities[request.mapName] = composed?.sourceIdentities ?? [];
+    if (composed?.composition) compositions[request.mapName] = composed.composition;
+  }
+  const bindings = result.mapRequests.flatMap((request) => {
+    if (request.sources.length === 0) return [];
+    const composed = result.composedBySequence.get(request.sequenceKey);
+    if (!composed?.package) {
+      throw new Error(`Missing compiled icon package for map ${request.mapName}`);
+    }
+    return [
+      {
+        iconIds: composed.package.manifest.iconNames,
+        label: request.mapName,
+        mapName: request.mapName,
+        packageHash: composed.package.contentHash
+      }
+    ];
+  });
+  return {
+    bindings,
+    compositions,
+    packages: [...packagesByHash.values()].sort(
+      (left, right) => compareCodeUnits4(left.contentHash, right.contentHash)
+    ),
+    sourceIdentities,
+    watchFiles: uniqueStrings(
+      result.mapRequests.flatMap(
+        (request) => result.composedBySequence.get(request.sequenceKey)?.watchFiles ?? []
+      )
+    ).sort(compareCodeUnits4),
+    watchPaths: uniqueStrings(
+      result.mapRequests.flatMap(
+        (request) => result.composedBySequence.get(request.sequenceKey)?.watchPaths ?? []
+      )
+    ).sort(compareCodeUnits4)
+  };
+}
+async function inspectTileflowIconCatalogs(project, options) {
+  const result = await composeMapIconSources(project, {
+    ...options,
+    target: "local"
+  });
+  const maps = result.mapRequests.map((request) => {
+    if (request.sources.length === 0) return { name: request.mapName, icons: { kind: "none" } };
+    const composed = result.composedBySequence.get(request.sequenceKey);
+    if (!composed?.package)
+      throw new Error(`Missing compiled icon catalog for map ${request.mapName}`);
+    return {
+      name: request.mapName,
+      icons: {
+        composition: composed.composition,
+        contributors: composed.contributors.map(describeComposedContributor),
+        iconIds: [...composed.package.manifest.iconNames],
+        kind: "sources",
+        label: request.mapName,
+        packageHash: composed.package.contentHash
+      }
+    };
+  });
+  const requestBySequence = new Map(
+    result.mapRequests.filter((request) => request.sources.length > 0).map((request) => [request.sequenceKey, request])
+  );
+  const catalogs = await Promise.all(
+    [...result.composedBySequence.entries()].map(
+      async ([sequenceKey, composed]) => {
+        const request = requestBySequence.get(sequenceKey);
+        if (!request || !composed.package)
+          throw new Error(`Missing icon contributor sequence ${sequenceKey}`);
+        const atlas = await readComposedAtlasIndexes(composed.package);
+        return {
+          composition: composed.composition,
+          compiledPackage: composed.package,
+          contributors: composed.contributors.map(describeComposedContributor),
+          icons: composed.winners.map((winner, index) => {
+            const manifestIcon = composed.package.manifest.renderedIcons[index];
+            const oneXAtlas = atlas.oneX[winner.id];
+            const twoXAtlas = atlas.twoX[winner.id];
+            const contributor = composed.contributors[winner.contributor];
+            if (!manifestIcon || manifestIcon.name !== winner.id || !oneXAtlas || !twoXAtlas || !contributor) {
+              throw new Error(`Missing compiled catalog metadata for icon ${winner.id}`);
+            }
+            return {
+              id: winner.id,
+              rendered: {
+                oneX: {
+                  atlas: atlasRectangle(oneXAtlas),
+                  height: oneXAtlas.height,
+                  pixelRatio: 1,
+                  pixelSha256: manifestIcon.pixelSha256.oneX,
+                  width: oneXAtlas.width
+                },
+                twoX: {
+                  atlas: atlasRectangle(twoXAtlas),
+                  height: twoXAtlas.height,
+                  pixelRatio: 2,
+                  pixelSha256: manifestIcon.pixelSha256.twoX,
+                  width: twoXAtlas.width
+                }
+              },
+              source: winner.source === null ? {
+                contributor: winner.contributor,
+                kind: "icon-set",
+                reference: contributor.kind === "icon-set" ? contributor.reference : "",
+                version: contributor.kind === "icon-set" ? contributor.version : 0
+              } : {
+                byteLength: winner.source.byteLength,
+                contributor: winner.contributor,
+                dimensions: { ...winner.source.dimensions },
+                format: winner.source.format,
+                kind: "file",
+                path: winner.source.path
+              }
+            };
+          }),
+          insideWorkingTree: composed.contributors.every(
+            (contributor) => contributor.kind === "icon-set" || contributor.insideWorkingTree
+          ),
+          replacements: composed.replacements.map(
+            (replacement) => describeComposedReplacement(replacement, composed.contributors)
+          )
+        };
+      }
+    )
+  );
+  catalogs.sort(
+    (left, right) => compareCodeUnits4(
+      left.contributors.map((contributor) => contributor.label).join("\0"),
+      right.contributors.map((contributor) => contributor.label).join("\0")
+    )
+  );
+  return { catalogs, maps };
+}
+async function composeMapIconSources(project, options) {
+  const mapRequests = getMapIconRequests(project, options.mapNames);
+  const workspaceRequests = options.mapNames === void 0 ? mapRequests : getMapIconRequests(project);
+  const baseDirectory = options.baseDirectory ?? options.cwd;
+  const workspaceLock = await readWorkspaceIconSetLock(workspaceRequests, baseDirectory);
+  const lockPath = workspaceLock ? resolvePath(baseDirectory, tileflowIconsLockfileName3) : void 0;
+  const issues = [];
+  const composedBySequence = /* @__PURE__ */ new Map();
+  for (const request of uniqueSequences(mapRequests)) {
+    if (request.sources.length === 0) continue;
+    try {
+      const lock = workspaceLock ? selectMapIconSetLock(workspaceLock, request.sources) : void 0;
+      const composed = await composeTileflowIconSources(request.sources, {
+        ...options.icons,
+        baseDirectory,
+        configPath: `maps.${request.mapName}.icons`,
+        cwd: options.cwd,
+        ...lock ? { lock } : {},
+        target: options.target
+      });
+      composedBySequence.set(
+        request.sequenceKey,
+        lockPath && lock ? { ...composed, watchFiles: uniqueStrings([...composed.watchFiles, lockPath]) } : composed
+      );
+    } catch (error) {
+      if (error instanceof TileflowIconSetError5) throw error;
+      if (error instanceof TileflowIconCompilationError) issues.push(...error.issues);
+      else if (error instanceof TileflowAssetDirectoryError) issues.push(...error.issues);
+      else
+        issues.push({
+          message: error instanceof Error ? error.message : "Icon compilation failed",
+          path: `maps.${request.mapName}.icons`
+        });
+    }
+  }
+  if (issues.length > 0) throw new TileflowIconCompilationError(issues);
+  return { composedBySequence, mapRequests };
+}
+async function readWorkspaceIconSetLock(requests, baseDirectory) {
+  const references = /* @__PURE__ */ new Set();
+  for (const request of requests) {
+    for (const reference of collectTileflowIconSetReferences2(request.sources))
+      references.add(reference);
+  }
+  if (references.size === 0) return void 0;
+  const sources = [...references].sort(compareCodeUnits4).map((reference) => ({ kind: "icon-set", reference }));
+  return readTileflowIconsLockfile(baseDirectory, sources);
+}
+function selectMapIconSetLock(lock, sources) {
+  const references = collectTileflowIconSetReferences2(sources);
+  if (references.length === 0) return void 0;
+  return {
+    lockfileVersion: 1,
+    sets: Object.fromEntries(references.map((reference) => [reference, lock.sets[reference]]))
+  };
+}
+async function prepareTileflowCatalogIcons(project, options) {
+  const compiled = await compileTileflowIconPackages(project, {
+    baseDirectory: options.baseDirectory,
+    cwd: options.cwd,
+    ...options.icons ? { icons: options.icons } : {},
+    target: "local"
+  });
+  const packagesByHash = new Map(
+    compiled.packages.map((iconPackage) => [iconPackage.contentHash, iconPackage])
+  );
+  const assets = [];
+  const mapAssets = {};
+  const mapIconCompositions = {};
+  const mapIconSources = {};
+  for (const mapName of Object.keys(project.maps)) mapIconSources[mapName] = [];
+  for (const binding of compiled.bindings) {
+    const iconPackage = packagesByHash.get(binding.packageHash);
+    if (!iconPackage) throw new Error(`Missing compiled icon package for map ${binding.mapName}`);
+    const spriteUrl = joinUrl(options.assetBaseUrl, `icons/${binding.mapName}/sprite`);
+    mapAssets[binding.mapName] = { icons: { ids: binding.iconIds, sprite: spriteUrl } };
+    mapIconSources[binding.mapName] = compiled.sourceIdentities[binding.mapName] ?? [];
+    const composition = compiled.compositions[binding.mapName];
+    if (composition) mapIconCompositions[binding.mapName] = composition;
+    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,
+    baseDirectory: await realpath3(options.baseDirectory ?? options.cwd),
+    cwd: await realpath3(options.cwd),
+    mapAssets,
+    mapIconCompositions,
+    mapIconSources,
+    project,
+    sourceProject: project,
+    watchFiles: compiled.watchFiles,
+    watchPaths: compiled.watchPaths
+  };
+}
+async function getTileflowIconWatchPaths(project, cwd, baseDirectory = cwd) {
+  const requests = getMapIconRequests(project);
+  const paths = /* @__PURE__ */ new Set();
+  let realBaseDirectory;
+  for (const request of uniqueSequences(requests)) {
+    for (const source of request.sources) {
+      if (typeof source === "object" && source.kind === "icon-set") {
+        realBaseDirectory ??= await realpath3(baseDirectory);
+        paths.add(resolvePath(realBaseDirectory, tileflowIconsLockfileName3));
+        continue;
+      }
+      try {
+        const directory = await readTileflowIconDirectory(source, {
+          baseDirectory,
+          configPath: `maps.${request.mapName}.icons`,
+          cwd,
+          target: "local"
+        });
+        if (directory.watchPath) paths.add(directory.watchPath);
+      } catch {
+      }
+    }
+  }
+  return [...paths].sort(compareCodeUnits4);
+}
+function getMapIconRequests(project, mapNames) {
+  const selectedNames = (mapNames === void 0 ? Object.keys(project.maps) : [...new Set(mapNames)]).sort(compareCodeUnits4);
+  return selectedNames.map((mapName) => {
+    const mapConfig = project.maps[mapName];
+    if (!mapConfig) throw new Error(`Unknown Tileflow map: ${mapName}`);
+    const sources = parseResolvedTileflowMap(mapConfig).icons ?? [];
+    return { mapName, sequenceKey: serializeCanonicalJson2(sources), sources };
+  });
+}
+function uniqueSequences(requests) {
+  return [...new Map(requests.map((request) => [request.sequenceKey, request])).values()].sort(
+    (left, right) => compareCodeUnits4(left.sequenceKey, right.sequenceKey)
+  );
+}
+function describeComposedContributor(contributor) {
+  return contributor.kind === "icon-set" ? {
+    iconIds: [...contributor.iconIds],
+    kind: "icon-set",
+    label: contributor.label,
+    reference: contributor.reference,
+    version: contributor.version
+  } : {
+    iconIds: [...contributor.iconIds],
+    insideWorkingTree: contributor.insideWorkingTree,
+    kind: contributor.kind,
+    label: contributor.label
+  };
+}
+function describeComposedReplacement(replacement, contributors) {
+  return {
+    id: replacement.id,
+    replaced: describeContributorExport(contributors[replacement.replaced], replacement.id),
+    winner: describeContributorExport(contributors[replacement.winner], replacement.id)
+  };
+}
+function describeContributorExport(contributor, id) {
+  if (!contributor) return id;
+  if (contributor.kind === "icon-set") return contributor.label;
+  return contributor.entries.find((entry) => entry.id === id)?.path ?? contributor.label;
+}
+async function readComposedAtlasIndexes(iconPackage) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const read = (fileName) => {
+    const file = iconPackage.files.find((candidate) => candidate.fileName === fileName);
+    if (!file) throw new Error(`Missing generated ${fileName}`);
+    return tileflowIconSpriteIndexSchema.parse(
+      parseTileflowIconJson2(
+        decoder.decode(file.source),
+        tileflowIconPackageLimits4.maxGeneratedFileBytes
+      )
+    );
+  };
+  return { oneX: read("sprite.json"), twoX: read("sprite@2x.json") };
+}
+function describeAssetDirectory(directory) {
+  return typeof directory.authoring === "string" ? directory.authoring : `npm:${directory.authoring.package}/${directory.authoring.path}`;
+}
+function describeAssetFile(directory, fileName) {
+  return `${describeAssetDirectory(directory).replace(/\/+$/u, "")}/${fileName}`;
+}
+async function inspectIconSource(directory, target, issues) {
+  let entries;
+  const issueCount = issues.length;
+  try {
+    entries = await readdir2(directory.realPath, { withFileTypes: true });
+  } catch (error) {
+    issues.push({
+      message: describeFileSystemError(error, "Icon source could not be read"),
+      path: directory.configPath
+    });
+    return null;
+  }
+  entries.sort((left, right) => compareCodeUnits4(left.name, right.name));
+  const candidates = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const entryPath = resolvePath(directory.realPath, entry.name);
+    const path = `${directory.configPath}/${entry.name}`;
+    if (entry.isDirectory()) {
+      issues.push({ message: "Nested directories are not supported", path });
+      continue;
+    }
+    let entryStat;
+    let realEntryPath = entryPath;
+    try {
+      if (entry.isSymbolicLink()) {
+        realEntryPath = await realpath3(entryPath);
+        if (!isPathInside2(directory.containmentRoot, realEntryPath)) {
+          issues.push({ message: "Icon symlink escapes its owning directory boundary", path });
+          continue;
+        }
+      }
+      entryStat = await stat(realEntryPath);
+    } catch (error) {
+      issues.push({ message: describeFileSystemError(error, "Icon entry could not be read"), path });
+      continue;
+    }
+    if (!entryStat.isFile()) {
+      issues.push({ message: "Icon entries must be regular files", path });
+      continue;
+    }
+    const extension = extname(entry.name).toLowerCase();
+    if (!iconFileExtensions.has(extension)) {
+      continue;
+    }
+    const sourceName = entry.name.slice(0, -extname(entry.name).length);
+    const kind = sourceName.endsWith(".pattern") ? "pattern" : "icon";
+    const name = kind === "pattern" ? sourceName.slice(0, -".pattern".length) : sourceName;
+    if (names.has(name)) {
+      issues.push({
+        message: `Duplicate icon basename "${name}"`,
+        path
+      });
+      continue;
+    }
+    names.add(name);
+    if (!tileflowIconIdPattern.test(name) || name.length > 64) {
+      issues.push({
+        message: "Icon filenames must produce a lower-kebab ID of at most 64 characters",
+        path
+      });
+    }
+    if (entryStat.size > tileflowIconPackageLimits4.maxSourceFileBytes) {
+      issues.push({
+        message: `Icon source exceeds ${tileflowIconPackageLimits4.maxSourceFileBytes} bytes`,
+        path
+      });
+    }
+    candidates.push({
+      displayPath: describeAssetFile(directory, entry.name),
+      fileName: entry.name,
+      format: iconSourceFormat(extension),
+      kind,
+      name,
+      path: realEntryPath,
+      size: entryStat.size
+    });
+  }
+  candidates.sort((left, right) => compareCodeUnits4(left.name, right.name));
+  if (candidates.length === 0) {
+    issues.push({
+      message: "No supported .svg, .png, .jpg, .jpeg, or .webp icon files were found",
+      path: directory.configPath
+    });
+  }
+  if (issues.length > issueCount) {
+    return null;
+  }
+  const icons = [];
+  for (const candidate of candidates) {
+    const displayPath = candidate.displayPath;
+    try {
+      const source = await readFile(candidate.path);
+      if (source.byteLength !== candidate.size || source.byteLength > tileflowIconPackageLimits4.maxSourceFileBytes) {
+        throw new Error("Icon changed while it was being validated");
+      }
+      if (target === "hosted" && extname(candidate.fileName).toLowerCase() === ".svg") {
+        validateHostedSvg(source, displayPath);
+      }
+      icons.push({
+        displayPath,
+        fileName: candidate.fileName,
+        format: candidate.format,
+        kind: candidate.kind,
+        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 > issueCount) {
+    return null;
+  }
+  return { icons };
+}
+async function validateDecodedDimensions(icon) {
+  const sharp = await loadSharp();
+  const metadata = await sharp(icon.source, {
+    density: 72,
+    failOn: "error",
+    limitInputPixels: tileflowIconPackageLimits4.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 > tileflowIconPackageLimits4.maxDecodedPixelsPerIcon) {
+    throw new Error(
+      `${icon.fileName} exceeds ${tileflowIconPackageLimits4.maxDecodedPixelsPerIcon} decoded pixels`
+    );
+  }
+  return { height, width };
+}
+async function renderIcon(icon, dimensions, pixelRatio) {
+  const sharp = await loadSharp();
+  const targetWidth = (icon.kind === "pattern" ? dimensions.width : iconSpriteSize) * pixelRatio;
+  const targetHeight = (icon.kind === "pattern" ? dimensions.height : iconSpriteSize) * pixelRatio;
+  const { data, info } = await sharp(icon.source, {
+    density: 72 * pixelRatio,
+    failOn: "error",
+    limitInputPixels: tileflowIconPackageLimits4.maxDecodedPixelsPerIcon
+  }).resize(targetWidth, targetHeight, {
+    background: { alpha: 0, b: 0, g: 0, r: 0 },
+    fit: "contain"
+  }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  if (info.channels !== 4 || info.width !== targetWidth || info.height !== targetHeight) {
+    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 };
+}
+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;
+}
+function atlasRectangle(entry) {
+  return { height: entry.height, width: entry.width, x: entry.x, y: entry.y };
+}
+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 isPathInside2(root, candidate) {
+  const pathFromRoot = relative2(root, candidate);
+  return pathFromRoot === "" || !isAbsolute2(pathFromRoot) && pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep2}`);
+}
+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 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)];
+}
+async function renderIconInputs(inputs) {
+  let renderedOneXPixels = 0;
+  return mapWithConcurrency(inputs, tileflowIconPackageLimits4.decodeConcurrency, async (icon) => {
+    const dimensions = await validateDecodedDimensions(icon);
+    const oneXWidth = icon.kind === "pattern" ? dimensions.width : iconSpriteSize;
+    const oneXHeight = icon.kind === "pattern" ? dimensions.height : iconSpriteSize;
+    const maximumOneXDimension = tileflowIconPackageLimits4.maxAtlasDimension / 2;
+    renderedOneXPixels += oneXWidth * oneXHeight;
+    if (oneXWidth > maximumOneXDimension || oneXHeight > maximumOneXDimension || renderedOneXPixels > maximumOneXDimension ** 2) {
+      throw new Error(
+        "Rendered icon inputs exceed the paired sprite capacity before rasterization"
+      );
+    }
+    if (icon.kind === "pattern" && (dimensions.width < 2 || dimensions.width > 512 || (dimensions.width & dimensions.width - 1) !== 0)) {
+      throw new Error(
+        `${icon.fileName} pattern width must be a power of two from 2 through 512 pixels`
+      );
+    }
+    const oneX = await renderIcon(icon, dimensions, 1);
+    const twoX = await renderIcon(icon, dimensions, 2);
+    return {
+      dimensions,
+      input: icon,
+      oneX,
+      pixelSha256: {
+        oneX: await hashTileflowRenderedIconPixels3({
+          height: oneX.height,
+          pixelRatio: 1,
+          rgba: oneX.rgba,
+          width: oneX.width
+        }),
+        twoX: await hashTileflowRenderedIconPixels3({
+          height: twoX.height,
+          pixelRatio: 2,
+          rgba: twoX.rgba,
+          width: twoX.width
+        })
+      },
+      sourceSha256: await sha256Hex3(icon.source),
+      twoX
+    };
+  });
+}
+async function readTileflowIconDirectory(source, options) {
+  const configPath = options.configPath ?? "icons";
+  const directory = (await resolveTileflowAssetDirectories([source], {
+    baseDirectory: options.baseDirectory,
+    configPath,
+    cwd: options.cwd,
+    kind: "icons",
+    ordinalOffset: options.ordinal ?? 0,
+    target: options.target
+  }))[0];
+  if (!directory)
+    throw new TileflowIconCompilationError([{ path: configPath, message: "Missing icon directory" }]);
+  const issues = [];
+  const inspected = await inspectIconSource(directory, options.target, issues);
+  if (!inspected || issues.length) throw new TileflowIconCompilationError(issues);
+  if (inspected.icons.length > tileflowIconPackageLimits4.maxIconCount)
+    throw new TileflowIconCompilationError([
+      { path: configPath, message: "One icon contributor supports at most 256 exports" }
+    ]);
+  const entries = inspected.icons.map(
+    (icon) => ({
+      byteLength: icon.source.byteLength,
+      format: icon.format,
+      id: icon.name,
+      kind: icon.kind,
+      path: icon.displayPath
+    })
+  );
+  return {
+    containmentRoot: directory.containmentRoot,
+    entries,
+    iconIds: entries.map((entry) => entry.id),
+    label: describeAssetDirectory(directory),
+    realPath: directory.realPath,
+    ...directory.watch ? { watchPath: directory.realPath } : {},
+    render: async (ids) => {
+      const selected = new Set(ids);
+      const inputs = inspected.icons.filter((icon) => selected.has(icon.name));
+      if (inputs.length !== ids.length || inputs.reduce((sum, icon) => sum + icon.source.byteLength, 0) > tileflowIconPackageLimits4.maxSourceBytes)
+        throw new TileflowIconCompilationError([
+          {
+            path: configPath,
+            message: "Selected icon inputs exceed their source budget or have invalid IDs"
+          }
+        ]);
+      return (await renderIconInputs(inputs)).map((rendered) => ({
+        icon: {
+          id: rendered.input.name,
+          oneX: {
+            height: rendered.oneX.height,
+            width: rendered.oneX.width,
+            rgba: rendered.oneX.rgba
+          },
+          twoX: {
+            height: rendered.twoX.height,
+            width: rendered.twoX.width,
+            rgba: rendered.twoX.rgba
+          }
+        },
+        // Canonical key order keeps the in-memory build manifest byte-identical to its artifact.
+        identity: {
+          format: rendered.input.format,
+          id: rendered.input.name,
+          kind: rendered.input.kind,
+          sha256: rendered.sourceSha256
+        },
+        source: {
+          byteLength: rendered.input.source.byteLength,
+          dimensions: { ...rendered.dimensions },
+          format: rendered.input.format,
+          id: rendered.input.name,
+          kind: rendered.input.kind,
+          path: rendered.input.displayPath
+        },
+        sourceBytes: rendered.input.source.byteLength
+      }));
+    }
+  };
+}
+
+export {
+  packTileflowRenderedIcons,
+  verifyTileflowIconArtifact,
+  getTileflowIconCacheDirectory,
+  loadTileflowIconSetArtifact,
+  storeTileflowIconSetArtifact,
+  readTileflowIconsLockfileText,
+  readTileflowIconsLockfile,
+  writeTileflowIconsLockfile,
+  composeTileflowIconSources,
+  TileflowIconCompilationError,
+  iconFileExtensions,
+  compileTileflowIconPackages,
+  inspectTileflowIconCatalogs,
+  prepareTileflowCatalogIcons,
+  getTileflowIconWatchPaths,
+  readTileflowIconDirectory
+};