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

package/dist/artifacts.d.ts

@@ -1,7 +1,7 @@
 import { TileflowStyleOptions, MapLibreStyle } from '@tileflow/core';
 import { TileflowBuildCatalog, TileflowBuildStyles, TileflowMapBuildManifestV1, TileflowStyleInspection, TileflowMapBuildProvenanceV1, TileflowPreparedMapAssets } from '@tileflow/core/build';
 import { TileflowRuntimeManifest } from '@tileflow/core/manifest';
-import { TileflowBuildAsset, PreparedTileflowBuildCatalog, TileflowSourceCatalog, PreparedTileflowCatalog } from './icons.js';
+import { e as TileflowBuildAsset, P as PreparedTileflowBuildCatalog, r as TileflowSourceCatalog, d as PreparedTileflowCatalog } from './icons-CkLVtaP-.js';
 export { defaultTileflowConfigPath } from './config.js';
 
 type TileflowLocalTilesetFile = Readonly<{

package/dist/artifacts.js

@@ -22,7 +22,7 @@ import {
   tileflowArtifactSessionSchemaVersion,
   writeTileflowArtifactPlan,
   writeTileflowBuildArtifacts
-} from "./chunk-XTRHREXO.js";
+} from "./chunk-XXVI42UZ.js";
 import "./chunk-ONYQNLNA.js";
 import {
   getTileflowAssetBasePath,
@@ -31,7 +31,7 @@ import {
   normalizeTileflowBasePath,
   resolveTileflowArtifactPublicUrls
 } from "./chunk-RSBV4L2Y.js";
-import "./chunk-CENQR5Q2.js";
+import "./chunk-NUHSYLLS.js";
 import "./chunk-BL3FK4GO.js";
 import "./chunk-KDFTE4Q5.js";
 import {

package/dist/{chunk-CENQR5Q2.js → chunk-NUHSYLLS.js}

@@ -4,20 +4,184 @@ import {
 } from "./chunk-BL3FK4GO.js";
 
 // src/icons.ts
-import { readdir, readFile, realpath, stat } from "fs/promises";
-import { extname, isAbsolute, relative, resolve, sep } from "path";
-import { SaxesParser } from "saxes";
+import {
+  isTileflowIconSetSource,
+  TileflowIconSetError
+} from "@tileflow/core";
+
+// src/icon-sprite.ts
 import {
   compareCodeUnits,
   hashTileflowIconPackageManifest,
   hashTileflowRenderedIconPixels,
-  parseResolvedTileflowMap,
   serializeCanonicalJson,
   sha256Hex,
-  tileflowIconIdPattern,
+  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/icons.ts
+import { readdir, readFile, realpath, stat } from "fs/promises";
+import { extname, isAbsolute, relative, resolve, sep } from "path";
+import { SaxesParser } from "saxes";
+import {
+  compareCodeUnits as compareCodeUnits2,
+  hashTileflowIconPackageManifest as hashTileflowIconPackageManifest2,
+  hashTileflowRenderedIconPixels as hashTileflowRenderedIconPixels2,
+  parseResolvedTileflowMap,
+  serializeCanonicalJson as serializeCanonicalJson2,
+  sha256Hex as sha256Hex2,
+  tileflowIconIdPattern,
+  tileflowIconPackageLimits as tileflowIconPackageLimits2,
+  tileflowIconPackageManifestSchema as tileflowIconPackageManifestSchema2
+} from "@tileflow/core";
 var TileflowIconCompilationError = class extends Error {
   code = "ICON_INVALID";
   issues;
@@ -69,14 +233,14 @@ async function compileTileflowIconPackages(project, options) {
   return {
     bindings,
     packages: [...packagesByHash.values()].sort(
-      (left, right) => compareCodeUnits(left.contentHash, right.contentHash)
+      (left, right) => compareCodeUnits2(left.contentHash, right.contentHash)
     ),
     sourceIdentities,
     watchPaths: uniqueStrings(
       result.mapRequests.flatMap(
         (request) => request.directories.filter((directory) => directory.watch).map((directory) => directory.realPath)
       )
-    ).sort(compareCodeUnits)
+    ).sort(compareCodeUnits2)
   };
 }
 async function inspectTileflowIconCatalogs(project, options) {
@@ -150,7 +314,7 @@ async function inspectTileflowIconCatalogs(project, options) {
       replacements: [...compiled.sourceReplacements]
     };
   }).sort(
-    (left, right) => compareCodeUnits(left.directories.join("\0"), right.directories.join("\0"))
+    (left, right) => compareCodeUnits2(left.directories.join("\0"), right.directories.join("\0"))
   );
   return { catalogs, maps };
 }
@@ -229,23 +393,32 @@ async function getTileflowIconWatchPaths(project, cwd, baseDirectory = cwd) {
     requests.flatMap(
       (request) => request.directories.filter((directory) => directory.watch).map((directory) => directory.realPath)
     )
-  ).sort(compareCodeUnits);
+  ).sort(compareCodeUnits2);
 }
 async function getMapIconRequests(project, cwd, baseDirectory, target, mapNames) {
-  const selectedNames = (mapNames === void 0 ? Object.keys(project.maps) : [...new Set(mapNames)]).sort(compareCodeUnits);
+  const selectedNames = (mapNames === void 0 ? Object.keys(project.maps) : [...new Set(mapNames)]).sort(compareCodeUnits2);
   const requests = [];
   for (const mapName of selectedNames) {
     const mapConfig = project.maps[mapName];
     if (!mapConfig) throw new Error(`Unknown Tileflow map: ${mapName}`);
     const resolvedMap = parseResolvedTileflowMap(mapConfig);
     try {
-      const directories = await resolveTileflowAssetDirectories(resolvedMap.icons ?? [], {
-        baseDirectory,
-        configPath: `maps.${mapName}.icons`,
-        cwd,
-        kind: "icons",
-        target
-      });
+      const sourceDirectories = resolvedMap.icons ?? [];
+      if (sourceDirectories.some(isTileflowIconSetSource))
+        throw new TileflowIconSetError(
+          "ICON_SET_INVALID",
+          "Shared icon sets require the explicit composeTileflowIconSources build port; command integration is not installed"
+        );
+      const directories = await resolveTileflowAssetDirectories(
+        sourceDirectories,
+        {
+          baseDirectory,
+          configPath: `maps.${mapName}.icons`,
+          cwd,
+          kind: "icons",
+          target
+        }
+      );
       requests.push({
         directories,
         mapName,
@@ -267,11 +440,11 @@ function uniqueDirectories(requests) {
         (request) => request.directories.map((directory) => [directory.realPath, directory])
       )
     ).values()
-  ].sort((left, right) => compareCodeUnits(left.realPath, right.realPath));
+  ].sort((left, right) => compareCodeUnits2(left.realPath, right.realPath));
 }
 function uniqueSequences(requests) {
   return [...new Map(requests.map((request) => [request.sequenceKey, request])).values()].sort(
-    (left, right) => compareCodeUnits(left.sequenceKey, right.sequenceKey)
+    (left, right) => compareCodeUnits2(left.sequenceKey, right.sequenceKey)
   );
 }
 function composeIconDirectories(request, inspectedBySource) {
@@ -301,17 +474,17 @@ function composeIconDirectories(request, inspectedBySource) {
     }
   }
   const icons = [...iconsById.values()].sort(
-    (left, right) => compareCodeUnits(left.name, right.name)
+    (left, right) => compareCodeUnits2(left.name, right.name)
   );
   const aggregateBytes = icons.reduce((total, icon) => total + icon.source.byteLength, 0);
-  if (icons.length > tileflowIconPackageLimits.maxIconCount) {
+  if (icons.length > tileflowIconPackageLimits2.maxIconCount) {
     throw new Error(
-      `Composed icon set contains more than ${tileflowIconPackageLimits.maxIconCount} icons`
+      `Composed icon set contains more than ${tileflowIconPackageLimits2.maxIconCount} icons`
     );
   }
-  if (aggregateBytes > tileflowIconPackageLimits.maxSourceBytes) {
+  if (aggregateBytes > tileflowIconPackageLimits2.maxSourceBytes) {
     throw new Error(
-      `Composed icon set exceeds ${tileflowIconPackageLimits.maxSourceBytes} aggregate bytes`
+      `Composed icon set exceeds ${tileflowIconPackageLimits2.maxSourceBytes} aggregate bytes`
     );
   }
   return { icons, replacements };
@@ -334,7 +507,7 @@ async function inspectIconSource(directory, target, issues) {
     });
     return null;
   }
-  entries.sort((left, right) => compareCodeUnits(left.name, right.name));
+  entries.sort((left, right) => compareCodeUnits2(left.name, right.name));
   const candidates = [];
   const names = /* @__PURE__ */ new Set();
   for (const entry of entries) {
@@ -384,9 +557,9 @@ async function inspectIconSource(directory, target, issues) {
         path
       });
     }
-    if (entryStat.size > tileflowIconPackageLimits.maxSourceFileBytes) {
+    if (entryStat.size > tileflowIconPackageLimits2.maxSourceFileBytes) {
       issues.push({
-        message: `Icon source exceeds ${tileflowIconPackageLimits.maxSourceFileBytes} bytes`,
+        message: `Icon source exceeds ${tileflowIconPackageLimits2.maxSourceFileBytes} bytes`,
         path
       });
     }
@@ -400,7 +573,7 @@ async function inspectIconSource(directory, target, issues) {
       size: entryStat.size
     });
   }
-  candidates.sort((left, right) => compareCodeUnits(left.name, right.name));
+  candidates.sort((left, right) => compareCodeUnits2(left.name, right.name));
   if (candidates.length === 0) {
     issues.push({
       message: "No supported .svg, .png, .jpg, .jpeg, or .webp icon files were found",
@@ -415,7 +588,7 @@ async function inspectIconSource(directory, target, issues) {
     const displayPath = candidate.displayPath;
     try {
       const source = await readFile(candidate.path);
-      if (source.byteLength !== candidate.size || source.byteLength > tileflowIconPackageLimits.maxSourceFileBytes) {
+      if (source.byteLength !== candidate.size || source.byteLength > tileflowIconPackageLimits2.maxSourceFileBytes) {
         throw new Error("Icon changed while it was being validated");
       }
       if (target === "hosted" && extname(candidate.fileName).toLowerCase() === ".svg") {
@@ -443,41 +616,7 @@ async function inspectIconSource(directory, target, issues) {
   return { icons };
 }
 async function compileInspectedIconSource(inspected) {
-  const rendered = await mapWithConcurrency(
-    inspected.icons,
-    tileflowIconPackageLimits.decodeConcurrency,
-    async (icon) => {
-      const dimensions = await validateDecodedDimensions(icon);
-      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 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
-          })
-        },
-        sourceSha256: await sha256Hex(icon.source),
-        twoX
-      };
-    }
-  );
+  const rendered = await renderIconInputs(inspected.icons);
   const layoutOneX = createSpriteLayout(
     rendered.map(({ input, oneX }) => ({ ...oneX, name: input.name })),
     1
@@ -496,9 +635,9 @@ async function compileInspectedIconSource(inspected) {
       layoutTwoX
     )
   ]);
-  const oneXJson = new TextEncoder().encode(`${serializeCanonicalJson(layoutOneX.index)}
+  const oneXJson = new TextEncoder().encode(`${serializeCanonicalJson2(layoutOneX.index)}
 `);
-  const twoXJson = new TextEncoder().encode(`${serializeCanonicalJson(layoutTwoX.index)}
+  const twoXJson = new TextEncoder().encode(`${serializeCanonicalJson2(layoutTwoX.index)}
 `);
   const files = [
     { contentType: "application/json", fileName: "sprite.json", source: oneXJson },
@@ -507,8 +646,8 @@ async function compileInspectedIconSource(inspected) {
     { 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({
+  const fileDigests = await Promise.all(files.map((file) => sha256Hex2(file.source)));
+  const manifest = tileflowIconPackageManifestSchema2.parse({
     files: files.map((file, index) => ({
       byteLength: file.source.byteLength,
       contentType: file.contentType,
@@ -534,75 +673,28 @@ async function compileInspectedIconSource(inspected) {
     layoutOneX,
     layoutTwoX,
     package: {
-      contentHash: await hashTileflowIconPackageManifest(manifest),
+      contentHash: await hashTileflowIconPackageManifest2(manifest),
       files,
       manifest
     },
     sourceReplacements: inspected.replacements ?? []
   };
 }
-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, indexNumber) => {
-      const placement = placements[indexNumber];
-      return [
-        icon.name,
-        {
-          height: icon.height,
-          pixelRatio,
-          width: icon.width,
-          x: placement.left,
-          y: placement.top
-        }
-      ];
-    })
-  );
-  return { height, index, width };
-}
 async function validateDecodedDimensions(icon) {
   const sharp = await loadSharp();
   const metadata = await sharp(icon.source, {
     density: 72,
     failOn: "error",
-    limitInputPixels: tileflowIconPackageLimits.maxDecodedPixelsPerIcon
+    limitInputPixels: tileflowIconPackageLimits2.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) {
+  if (width * height > tileflowIconPackageLimits2.maxDecodedPixelsPerIcon) {
     throw new Error(
-      `${icon.fileName} exceeds ${tileflowIconPackageLimits.maxDecodedPixelsPerIcon} decoded pixels`
+      `${icon.fileName} exceeds ${tileflowIconPackageLimits2.maxDecodedPixelsPerIcon} decoded pixels`
     );
   }
   return { height, width };
@@ -614,7 +706,7 @@ async function renderIcon(icon, dimensions, pixelRatio) {
   const { data, info } = await sharp(icon.source, {
     density: 72 * pixelRatio,
     failOn: "error",
-    limitInputPixels: tileflowIconPackageLimits.maxDecodedPixelsPerIcon
+    limitInputPixels: tileflowIconPackageLimits2.maxDecodedPixelsPerIcon
   }).resize(targetWidth, targetHeight, {
     background: { alpha: 0, b: 0, g: 0, r: 0 },
     fit: "contain"
@@ -628,45 +720,6 @@ async function renderIcon(icon, dimensions, pixelRatio) {
   }).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 icon of icons) {
-    const placement = layout.index[icon.name];
-    if (!placement || icon.width !== placement.width || icon.height !== placement.height) {
-      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`
-    );
-  }
-}
 function validateHostedSvg(source, displayPath) {
   const parser = new SaxesParser({ fileName: displayPath, xmlns: true });
   const decoder = new TextDecoder("utf-8", { fatal: true });
@@ -781,16 +834,6 @@ async function mapWithConcurrency(values, concurrency, map) {
   );
   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 atlasRectangle(entry) {
   return { height: entry.height, width: entry.width, x: entry.x, y: entry.y };
 }
@@ -833,12 +876,111 @@ function joinUrl(base, path) {
 function uniqueStrings(values) {
   return [...new Set(values)];
 }
+async function renderIconInputs(inputs) {
+  let renderedOneXPixels = 0;
+  return mapWithConcurrency(inputs, tileflowIconPackageLimits2.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 = tileflowIconPackageLimits2.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 hashTileflowRenderedIconPixels2({
+          height: oneX.height,
+          pixelRatio: 1,
+          rgba: oneX.rgba,
+          width: oneX.width
+        }),
+        twoX: await hashTileflowRenderedIconPixels2({
+          height: twoX.height,
+          pixelRatio: 2,
+          rgba: twoX.rgba,
+          width: twoX.width
+        })
+      },
+      sourceSha256: await sha256Hex2(icon.source),
+      twoX
+    };
+  });
+}
+async function readTileflowIconDirectory(source, options) {
+  const directory = (await resolveTileflowAssetDirectories([source], {
+    ...options,
+    configPath: "icons",
+    kind: "icons"
+  }))[0];
+  if (!directory)
+    throw new TileflowIconCompilationError([{ path: "icons", 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 > tileflowIconPackageLimits2.maxIconCount)
+    throw new TileflowIconCompilationError([
+      { path: "icons", message: "One icon contributor supports at most 256 exports" }
+    ]);
+  return {
+    iconIds: inspected.icons.map((icon) => icon.name),
+    ...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) > tileflowIconPackageLimits2.maxSourceBytes)
+        throw new TileflowIconCompilationError([
+          {
+            path: "icons",
+            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
+          }
+        },
+        identity: {
+          id: rendered.input.name,
+          kind: rendered.input.kind,
+          format: rendered.input.format,
+          sha256: rendered.sourceSha256
+        },
+        sourceBytes: rendered.input.source.byteLength
+      }));
+    }
+  };
+}
 
 export {
+  packTileflowRenderedIcons,
+  loadSharp,
   TileflowIconCompilationError,
   iconFileExtensions,
   compileTileflowIconPackages,
   inspectTileflowIconCatalogs,
   prepareTileflowCatalogIcons,
-  getTileflowIconWatchPaths
+  getTileflowIconWatchPaths,
+  readTileflowIconDirectory
 };