@tileflow/dev 0.1.0-alpha.4 → 0.1.0-alpha.41

package/dist/chunk-C4VPHZ3F.js

@@ -0,0 +1,4062 @@
+import {
+  TileflowAssetDirectoryError,
+  resolveTileflowAssetDirectories
+} from "./chunk-RTU7TD4M.js";
+
+// src/icons.ts
+import { readdir as readdir3, readFile as readFile2, 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 {
+  assertTileflowIconLayoutBounds as assertTileflowIconLayoutBounds2,
+  collectTileflowIconSetReferences as collectTileflowIconSetReferences2,
+  tileflowIconAuthorMetadataSchema,
+  tileflowIconMetadataFileName,
+  TileflowIconSetError as TileflowIconSetError5,
+  tileflowIconsLockfileName as tileflowIconsLockfileName3,
+  tileflowIconSpriteIndexSchema
+} from "@tileflow/core";
+import {
+  compareCodeUnits as compareCodeUnits5,
+  hashTileflowRenderedIconPixels as hashTileflowRenderedIconPixels3,
+  parseResolvedTileflowMap,
+  parseTileflowIconJson as parseTileflowIconJson2,
+  serializeCanonicalJson as serializeCanonicalJson3,
+  sha256Hex as sha256Hex3,
+  tileflowIconIdPattern,
+  tileflowIconPackageLimits as tileflowIconPackageLimits4,
+  tileflowModelContentType
+} 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,
+  tileflowIconPackageLimits as tileflowIconPackageLimits3,
+  TileflowIconSetError as TileflowIconSetError4
+} 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 {
+  assertTileflowSdfPixels as assertTileflowSdfPixels2,
+  compareCodeUnits as compareCodeUnits2,
+  hashTileflowIconPackageManifest as hashTileflowIconPackageManifest2,
+  hashTileflowRenderedIconPixels as hashTileflowRenderedIconPixels2,
+  parseTileflowIconJson,
+  readTileflowIconLayout,
+  scaleTileflowIconLayout as scaleTileflowIconLayout2,
+  serializeCanonicalJson as serializeCanonicalJson2,
+  sha256Hex as sha256Hex2,
+  tileflowIconPackageLimits as tileflowIconPackageLimits2,
+  tileflowIconPackageManifestSchema as tileflowIconPackageManifestSchema2,
+  TileflowIconSetError
+} from "@tileflow/core";
+
+// src/icon-sprite.ts
+import {
+  assertTileflowIconLayoutBounds,
+  assertTileflowSdfPixels,
+  compareCodeUnits,
+  hashTileflowIconPackageManifest,
+  hashTileflowRenderedIconPixels,
+  scaleTileflowIconLayout,
+  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 ${tileflowIconPackageLimits.maxIconCount} unique rendered icons`
+    );
+  const renderedIcons = [];
+  for (const icon of icons) {
+    tileflowIconIdSchema.parse(icon.id);
+    if (icon.layout) assertTileflowIconLayoutBounds(icon.layout, icon.oneX.width, icon.oneX.height);
+    if (icon.appearance) {
+      assertTileflowSdfPixels({ ...icon.oneX, pixelRatio: 1 });
+      assertTileflowSdfPixels({ ...icon.twoX, pixelRatio: 2 });
+    }
+    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,
+      ...icon.appearance ? { appearance: icon.appearance } : {},
+      ...icon.layout ? { layout: icon.layout } : {},
+      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,
+    appearance: icon.appearance,
+    layout: icon.layout
+  }));
+  const twoX = icons.map((icon) => ({
+    ...icon.twoX,
+    name: icon.id,
+    appearance: icon.appearance,
+    layout: icon.layout
+  }));
+  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: icons.some((icon) => icon.appearance || icon.layout) ? "tileflow-icon-package-v2" : "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 maxDimension = tileflowIconPackageLimits.maxAtlasDimension / 2 * pixelRatio;
+  const targetWidth = Math.min(maxDimension, columns * widest);
+  const placements = [];
+  let left = 0;
+  let rowHeight = 0;
+  let top = 0;
+  for (const icon of icons) {
+    if (icon.width > maxDimension)
+      throw new Error(
+        `Generated sprite exceeds ${maxDimension} pixels per dimension at ${pixelRatio}x`
+      );
+    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 > maxDimension || height > maxDimension)
+    throw new Error(
+      `Generated sprite exceeds ${maxDimension} pixels per dimension at ${pixelRatio}x`
+    );
+  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,
+          ...icon.appearance ? { sdf: true, tileflow: icon.appearance } : {},
+          ...icon.layout ? scaleTileflowIconLayout(icon.layout, pixelRatio) : {}
+        }
+      ];
+    })
+  );
+  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];
+      const declared = manifest.renderedIcons.find((icon) => icon.name === name).appearance;
+      const declaredLayout = manifest.renderedIcons.find((icon) => icon.name === name).layout;
+      const oneLayout = readTileflowIconLayout(one);
+      const twoLayout = readTileflowIconLayout(two);
+      if (serializeCanonicalJson2(oneLayout ?? null) !== serializeCanonicalJson2(declaredLayout ?? null) || serializeCanonicalJson2(twoLayout ?? null) !== serializeCanonicalJson2(oneLayout ? scaleTileflowIconLayout2(oneLayout, 2) : null))
+        throw new Error(
+          "Sprite layout must match the manifest and scale exactly between densities"
+        );
+      if (serializeCanonicalJson2(one.tileflow ?? null) !== serializeCanonicalJson2(two.tileflow ?? null) || serializeCanonicalJson2(one.tileflow ?? null) !== serializeCanonicalJson2(declared ?? null))
+        throw new Error("Sprite appearance must match at both densities and in the manifest");
+      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}`);
+      const appearance = oneIndex[id].tileflow;
+      if (appearance) {
+        assertTileflowSdfPixels2({ ...oneX, pixelRatio: 1 });
+        assertTileflowSdfPixels2({ ...twoX, pixelRatio: 2 });
+      }
+      const layout = readTileflowIconLayout(oneIndex[id]);
+      icons.push({
+        id,
+        oneX,
+        twoX,
+        ...appearance ? { appearance } : {},
+        ...layout ? { layout } : {}
+      });
+    }
+    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 },
+            ...icon.appearance ? { appearance: icon.appearance } : {},
+            ...icon.layout ? { layout: icon.layout } : {}
+          },
+          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 ${tileflowIconPackageLimits3.maxIconCount} 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: sorted.some((winner) => winner.icon.appearance || winner.icon.layout) ? "tileflow-icon-composition-v2" : "tileflow-icon-composition-v1",
+    compositionVersion: sorted.some((winner) => winner.icon.appearance || winner.icon.layout) ? 2 : 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,
+      ...icon.appearance ? { appearance: icon.appearance } : {},
+      ...icon.layout ? { layout: icon.layout } : {}
+    }))
+  }) : 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, identity2, 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: identity2, source });
+  }
+}
+function isPathInside(root, candidate) {
+  const pathFromRoot = relative(root, candidate);
+  return pathFromRoot === "" || !isAbsolute(pathFromRoot) && pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep}`);
+}
+
+// src/icon-distance.ts
+var infinity = 1e20;
+function createIconDistanceField(rgba, width, height, ratio) {
+  if (width !== 24 * ratio || height !== 24 * ratio || rgba.length !== width * height * 4)
+    throw new Error("SDF icons require a 24px logical cell at each density.");
+  const outer = new Float64Array(width * height);
+  const inner = new Float64Array(width * height);
+  let occupied = false;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const index = y * width + x;
+      const alpha = rgba[index * 4 + 3] / 255;
+      if (alpha && (x < 6 * ratio || y < 6 * ratio || x >= width - 6 * ratio || y >= height - 6 * ratio))
+        throw new Error(
+          "SDF icons require six transparent pixels of padding inside the 24px cell. Add a transparent border to the source."
+        );
+      occupied ||= alpha > 0;
+      outer[index] = alpha === 1 ? 0 : alpha === 0 ? infinity : Math.max(0, 0.5 - alpha) ** 2;
+      inner[index] = alpha === 1 ? infinity : alpha === 0 ? 0 : Math.max(0, alpha - 0.5) ** 2;
+    }
+  }
+  if (!occupied) throw new Error("An SDF silhouette must contain visible pixels.");
+  transform(outer, width, height);
+  transform(inner, width, height);
+  const result = new Uint8Array(rgba.length);
+  for (let i = 0; i < outer.length; i++) {
+    const distance = Math.sqrt(outer[i]) - Math.sqrt(inner[i]);
+    const alpha = Math.round(255 * Math.max(0, Math.min(1, 0.75 - distance / (8 * ratio))));
+    result.set([255, 255, 255, alpha], i * 4);
+  }
+  return result;
+}
+function transform(grid, width, height) {
+  const size = Math.max(width, height);
+  const samples = new Float64Array(size);
+  const result = new Float64Array(size);
+  const sites = new Uint32Array(size);
+  const bounds = new Float64Array(size + 1);
+  const line = (length) => {
+    let count = 0;
+    sites[0] = 0;
+    bounds[0] = -infinity;
+    bounds[1] = infinity;
+    for (let position = 1; position < length; position++) {
+      let intersection;
+      do {
+        const site = sites[count];
+        intersection = (samples[position] + position ** 2 - samples[site] - site ** 2) / (2 * (position - site));
+        if (intersection > bounds[count]) break;
+        count--;
+      } while (count >= 0);
+      count++;
+      sites[count] = position;
+      bounds[count] = intersection;
+      bounds[count + 1] = infinity;
+    }
+    count = 0;
+    for (let position = 0; position < length; position++) {
+      while (bounds[count + 1] < position) count++;
+      result[position] = (position - sites[count]) ** 2 + samples[sites[count]];
+    }
+  };
+  for (let x = 0; x < width; x++) {
+    for (let y = 0; y < height; y++) samples[y] = grid[y * width + x];
+    line(height);
+    for (let y = 0; y < height; y++) grid[y * width + x] = result[y];
+  }
+  for (let y = 0; y < height; y++) {
+    samples.set(grid.subarray(y * width, (y + 1) * width));
+    line(width);
+    grid.set(result.subarray(0, width), y * width);
+  }
+}
+
+// src/tree-models.ts
+import { MeshoptEncoder } from "meshoptimizer/encoder";
+import { createHash } from "crypto";
+import { lstat as lstat3, readdir as readdir2, readFile } from "fs/promises";
+import { join as join3 } from "path";
+import {
+  compareCodeUnits as compareCodeUnits4,
+  encodeTileflowModels,
+  encodeTileflowTreeModel,
+  readTileflowLandmarkTileFootprints,
+  serializeTileflowLandmarkRegion,
+  tileflowLandmarkTileOf,
+  tileflowModelFileName,
+  tileflowTreeModelLimits as tileflowTreeModelLimits2
+} from "@tileflow/core";
+
+// src/building-model-mesh.ts
+import {
+  isTileflowModelPartName,
+  tileflowModelDefaultLightingRole,
+  tileflowModelLightingRoles,
+  tileflowModelLimits,
+  tileflowModelSurfaceLimits as tileflowModelSurfaceLimits2,
+  tileflowModelTextureChannels as tileflowModelTextureChannels2
+} from "@tileflow/core";
+
+// src/building-model-occlusion.ts
+function buildingModelAmbientVisibility(mesh, options = {}) {
+  const sampler = buildingModelAmbientSampler(mesh, options);
+  const { positions, normals } = mesh;
+  const values = new Array(positions.length / 3);
+  const cache = /* @__PURE__ */ new Map();
+  for (let vertex = 0; vertex < values.length; vertex += 1) {
+    const at = vertex * 3;
+    const point3 = [positions[at], positions[at + 1], positions[at + 2]];
+    const normal = [normals[at], normals[at + 1], normals[at + 2]];
+    const key = [...point3, ...normal].map((v) => Math.round(v * 1e5)).join(",");
+    let value = cache.get(key);
+    if (value === void 0) {
+      value = sampler.sky(point3, normal);
+      cache.set(key, value);
+    }
+    values[vertex] = value;
+  }
+  return values;
+}
+function buildingModelAmbientSampler(mesh, { radius = 2, samples = 48 } = {}) {
+  if (!(radius > 0 && Number.isFinite(radius)) || !Number.isInteger(samples) || samples < 1 || samples > 256)
+    throw new RangeError("Model ambient visibility needs a positive radius and 1 to 256 samples.");
+  const { positions, indices } = mesh;
+  const count = indices.length / 3;
+  const triangles2 = new Float64Array(count * 9);
+  const bounds = new Float64Array(count * 6);
+  const centres = new Float64Array(count * 3);
+  const order = Uint32Array.from({ length: count }, (_, i) => i);
+  for (let i = 0; i < count; i += 1) {
+    const a = indices[i * 3] * 3;
+    const b = indices[i * 3 + 1] * 3;
+    const c = indices[i * 3 + 2] * 3;
+    for (let axis = 0; axis < 3; axis += 1) {
+      const x = positions[a + axis], y = positions[b + axis], z = positions[c + axis];
+      triangles2[i * 9 + axis] = x;
+      triangles2[i * 9 + 3 + axis] = y - x;
+      triangles2[i * 9 + 6 + axis] = z - x;
+      bounds[i * 6 + axis] = Math.min(x, y, z);
+      bounds[i * 6 + 3 + axis] = Math.max(x, y, z);
+      centres[i * 3 + axis] = (x + y + z) / 3;
+    }
+  }
+  const nodes = [];
+  const build = (from, to) => {
+    const box = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+    for (let at = from; at < to; at += 1) {
+      const i = order[at] * 6;
+      for (let axis2 = 0; axis2 < 3; axis2 += 1) {
+        box[axis2] = Math.min(box[axis2], bounds[i + axis2]);
+        box[axis2 + 3] = Math.max(box[axis2 + 3], bounds[i + axis2 + 3]);
+      }
+    }
+    let axis = 0;
+    for (let next = 1; next < 3; next += 1)
+      if (box[next + 3] - box[next] > box[axis + 3] - box[axis]) axis = next;
+    const index = nodes.length;
+    const node = { bounds: box, from, to, left: -1, right: -1, axis };
+    nodes.push(node);
+    if (to - from > 8) {
+      order.subarray(from, to).sort((a, b) => centres[a * 3 + axis] - centres[b * 3 + axis] || a - b);
+      const middle = from + to >>> 1;
+      node.left = build(from, middle);
+      node.right = build(middle, to);
+    }
+    return index;
+  };
+  if (count > 0) build(0, count);
+  const hemispheres = /* @__PURE__ */ new Map();
+  const hemisphere = (count2) => {
+    let pattern = hemispheres.get(count2);
+    if (!pattern) {
+      pattern = Array.from({ length: count2 }, (_, i) => {
+        const r = Math.sqrt((i + 0.5) / count2), angle = i * Math.PI * (3 - Math.sqrt(5));
+        return [r * Math.cos(angle), r * Math.sin(angle), Math.sqrt(1 - r * r)];
+      });
+      hemispheres.set(count2, pattern);
+    }
+    return pattern;
+  };
+  const bias = Math.min(2e-3, radius * 1e-3);
+  const stack = new Int32Array(64);
+  const origin = [0, 0, 0];
+  const direction = [0, 0, 0];
+  const nearest = () => {
+    let best = radius, pending = 1;
+    if (nodes.length === 0) return best;
+    stack[0] = 0;
+    while (pending > 0) {
+      const node = nodes[stack[--pending]];
+      if (!hitsBox(node.bounds, origin, direction, best)) continue;
+      if (node.left >= 0) {
+        const forward = direction[node.axis] >= 0;
+        stack[pending++] = forward ? node.right : node.left;
+        stack[pending++] = forward ? node.left : node.right;
+        continue;
+      }
+      for (let at = node.from; at < node.to; at += 1) {
+        const i = order[at] * 9;
+        const e1x = triangles2[i + 3], e1y = triangles2[i + 4], e1z = triangles2[i + 5];
+        const e2x = triangles2[i + 6], e2y = triangles2[i + 7], e2z = triangles2[i + 8];
+        const px = direction[1] * e2z - direction[2] * e2y;
+        const py = direction[2] * e2x - direction[0] * e2z;
+        const pz = direction[0] * e2y - direction[1] * e2x;
+        const determinant2 = e1x * px + e1y * py + e1z * pz;
+        if (Math.abs(determinant2) < 1e-12) continue;
+        const tx = origin[0] - triangles2[i], ty = origin[1] - triangles2[i + 1], tz = origin[2] - triangles2[i + 2];
+        const inverse = 1 / determinant2;
+        const u = (tx * px + ty * py + tz * pz) * inverse;
+        if (u < 0 || u > 1) continue;
+        const qx = ty * e1z - tz * e1y, qy = tz * e1x - tx * e1z, qz = tx * e1y - ty * e1x;
+        const v = (direction[0] * qx + direction[1] * qy + direction[2] * qz) * inverse;
+        if (v < 0 || u + v > 1) continue;
+        const distance = (e2x * qx + e2y * qy + e2z * qz) * inverse;
+        if (distance > bias && distance < best) best = distance;
+      }
+    }
+    return best;
+  };
+  return {
+    radius,
+    sky(point3, normal, rays = samples, turn = 0) {
+      const [nx, ny, nz] = normal;
+      const flat = Math.abs(nz) < 0.9 ? [-ny, nx, 0] : [nz, 0, -nx];
+      const length = Math.hypot(...flat);
+      if (length === 0) return 1;
+      const [c, s] = [Math.cos(turn), Math.sin(turn)];
+      const base = flat.map((value) => value / length);
+      const cross4 = [
+        ny * base[2] - nz * base[1],
+        nz * base[0] - nx * base[2],
+        nx * base[1] - ny * base[0]
+      ];
+      const tangent = base.map((value, axis) => value * c + cross4[axis] * s);
+      const bitangent = cross4.map((value, axis) => value * c - base[axis] * s);
+      for (let axis = 0; axis < 3; axis += 1) origin[axis] = point3[axis] + normal[axis] * bias;
+      let visibility = 0;
+      const pattern = hemisphere(rays);
+      for (const sample of pattern) {
+        for (let axis = 0; axis < 3; axis += 1)
+          direction[axis] = sample[0] * tangent[axis] + sample[1] * bitangent[axis] + sample[2] * normal[axis];
+        visibility += nearest() / radius;
+      }
+      return visibility / pattern.length;
+    },
+    along(point3, towards) {
+      for (let axis = 0; axis < 3; axis += 1) {
+        origin[axis] = point3[axis] + towards[axis] * bias;
+        direction[axis] = towards[axis];
+      }
+      return nearest();
+    }
+  };
+}
+function hitsBox(box, origin, direction, limit) {
+  let low = 0, high = limit;
+  for (let axis = 0; axis < 3; axis += 1) {
+    const o = origin[axis], d = direction[axis];
+    if (Math.abs(d) < 1e-12) {
+      if (o < box[axis] || o > box[axis + 3]) return false;
+      continue;
+    }
+    const a = (box[axis] - o) / d, b = (box[axis + 3] - o) / d;
+    low = Math.max(low, Math.min(a, b));
+    high = Math.min(high, Math.max(a, b));
+    if (low > high) return false;
+  }
+  return true;
+}
+
+// src/building-model-lightmap.ts
+var paletteSide = 16;
+var maximumSide = 4096;
+function bakeBuildingModelLightmap(mesh, { texels: budget, radius = 2, ...options }) {
+  if (options.points !== void 0 && !(options.points >= 1 && options.points <= 4 && Number.isInteger(options.points)))
+    throw new RangeError("A lightmap samples one to four points along each side of a texel.");
+  const { positions, indices } = mesh;
+  const point3 = (vertex) => [
+    positions[vertex * 3],
+    positions[vertex * 3 + 1],
+    positions[vertex * 3 + 2]
+  ];
+  const charts = chartsOf(indices, point3);
+  const palette = {
+    triangles: [],
+    normal: [0, 0, 1],
+    u: [1, 0, 0],
+    v: [0, 1, 0],
+    min: [0, 0],
+    extent: [0, 0],
+    scale: [0, 0],
+    w: 0,
+    h: 0,
+    x: 0,
+    y: 0,
+    palette: true
+  };
+  charts.push(palette);
+  let density = densityFor(charts, budget);
+  if (density === void 0) return void 0;
+  let layout = pack(charts, density);
+  for (let attempt = 0; attempt < 12 && !(layout && layout.width * layout.height <= budget); attempt++) {
+    density *= 0.9;
+    layout = pack(charts, density);
+  }
+  if (!layout || layout.width * layout.height > budget) return void 0;
+  const { width, height } = layout;
+  const points = options.points ?? Math.min(4, Math.max(2, Math.ceil(1 / (density * 0.35))));
+  const rays = options.rays ?? Math.max(4, Math.round(48 / (points * points)));
+  const sampler = buildingModelAmbientSampler(mesh, { radius });
+  const sums = new Float64Array(width * height);
+  const counts = new Uint16Array(width * height);
+  const taken = new Uint16Array(width * height);
+  const hidden = Math.min(0.05, radius * 0.025);
+  for (const chart of charts) {
+    const local2 = (vertex) => {
+      const p = point3(vertex);
+      return [
+        (dot(chart.u, p) - chart.min[0]) * chart.scale[0] + 0.5,
+        (dot(chart.v, p) - chart.min[1]) * chart.scale[1] + 0.5
+      ];
+    };
+    if (chart.tiny || chart.palette) continue;
+    for (const triangle of chart.triangles) {
+      const corners = [0, 1, 2].map((k) => local2(indices[triangle * 3 + k]));
+      const [a, b, c] = corners;
+      const area = cross2(a, b, c);
+      if (Math.abs(area) < 1e-12) continue;
+      const [A, B, C] = [0, 1, 2].map((k) => point3(indices[triangle * 3 + k]));
+      const rawNormal = crossOf(sub(B, A), sub(C, A));
+      const facing = rawNormal.map((value) => value / (Math.hypot(...rawNormal) || 1));
+      const x0 = Math.max(0, Math.floor(Math.min(a[0], b[0], c[0])));
+      const x1 = Math.min(chart.w - 1, Math.floor(Math.max(a[0], b[0], c[0])));
+      const y0 = Math.max(0, Math.floor(Math.min(a[1], b[1], c[1])));
+      const y1 = Math.min(chart.h - 1, Math.floor(Math.max(a[1], b[1], c[1])));
+      for (let y = y0; y <= y1; y++)
+        for (let x = x0; x <= x1; x++) {
+          const texel = (chart.y + y) * width + chart.x + x;
+          for (let j = 0; j < points; j++)
+            for (let i = 0; i < points; i++) {
+              const bit = 1 << j * points + i;
+              if (taken[texel] & bit) continue;
+              const p = [x + (i + 0.5) / points, y + (j + 0.5) / points];
+              const w0 = cross2(b, c, p) / area, w1 = cross2(c, a, p) / area, w2 = 1 - w0 - w1;
+              if (w0 < -1e-9 || w1 < -1e-9 || w2 < -1e-9) continue;
+              taken[texel] |= bit;
+              const world = [0, 1, 2].map((axis) => w0 * A[axis] + w1 * B[axis] + w2 * C[axis]);
+              if (sampler.along(world, facing) < hidden) continue;
+              const turn = ((j * points + i) * 2.399963 + (x * 0.618034 + y * 0.381966) * 6.283185) % 6.283185;
+              sums[texel] += sampler.sky(world, facing, rays, turn);
+              counts[texel] += 1;
+            }
+        }
+    }
+  }
+  const values = new Float32Array(width * height).fill(-1);
+  for (let texel = 0; texel < values.length; texel++)
+    if (counts[texel]) values[texel] = sums[texel] / counts[texel];
+  for (let level = 0; level < paletteSide * paletteSide; level++) {
+    const x = palette.x + level % paletteSide, y = palette.y + Math.floor(level / paletteSide);
+    values[y * width + x] = level / 255;
+  }
+  const levels = /* @__PURE__ */ new Map();
+  for (const chart of charts) {
+    if (!chart.tiny) continue;
+    let sum = 0, weight = 0;
+    for (const triangle of chart.triangles) {
+      const [a, b, c] = [0, 1, 2].map((k) => point3(indices[triangle * 3 + k]));
+      const raw = crossOf(sub(b, a), sub(c, a));
+      const area = Math.hypot(...raw) / 2;
+      if (!(area > 0)) continue;
+      const facing = raw.map((value) => value / (2 * area));
+      const centre = [0, 1, 2].map((axis) => (a[axis] + b[axis] + c[axis]) / 3);
+      if (sampler.along(centre, facing) < hidden) continue;
+      sum += area * sampler.sky(centre, facing, rays * points * points);
+      weight += area;
+    }
+    levels.set(chart, Math.round((weight > 0 ? sum / weight : 1) * 255));
+  }
+  for (let pass = 0; pass < 3; pass++) {
+    const previous = values.slice();
+    for (let y = 0; y < height; y++)
+      for (let x = 0; x < width; x++) {
+        if (previous[y * width + x] >= 0) continue;
+        let sum = 0, count = 0;
+        for (const [dx, dy] of [
+          [1, 0],
+          [-1, 0],
+          [0, 1],
+          [0, -1]
+        ]) {
+          const xx = x + dx, yy = y + dy;
+          if (xx < 0 || yy < 0 || xx >= width || yy >= height) continue;
+          const value = previous[yy * width + xx];
+          if (value >= 0) {
+            sum += value;
+            count++;
+          }
+        }
+        if (count) values[y * width + x] = sum / count;
+      }
+  }
+  const bytes = new Uint8Array(width * height);
+  for (let texel = 0; texel < bytes.length; texel++)
+    bytes[texel] = Math.round(
+      Math.min(1, Math.max(0, values[texel] < 0 ? 1 : values[texel])) * 255
+    );
+  const sources = [];
+  const uvs = [];
+  const out = new Array(indices.length);
+  for (const chart of charts) {
+    const own = /* @__PURE__ */ new Map();
+    for (const triangle of chart.triangles)
+      for (let k = 0; k < 3; k++) {
+        const vertex = indices[triangle * 3 + k];
+        let index = own.get(vertex);
+        if (index === void 0) {
+          index = sources.length;
+          own.set(vertex, index);
+          sources.push(vertex);
+          const level = levels.get(chart);
+          if (level !== void 0)
+            uvs.push(
+              (palette.x + level % paletteSide + 0.5) / width,
+              (palette.y + Math.floor(level / paletteSide) + 0.5) / height
+            );
+          else {
+            const p = point3(vertex);
+            uvs.push(
+              (chart.x + 0.5 + (dot(chart.u, p) - chart.min[0]) * chart.scale[0]) / width,
+              (chart.y + 0.5 + (dot(chart.v, p) - chart.min[1]) * chart.scale[1]) / height
+            );
+          }
+        }
+        out[triangle * 3 + k] = index;
+      }
+  }
+  for (let at = 0; at < uvs.length; at++) uvs[at] = Math.round(uvs[at] * 65536) / 65536;
+  return {
+    sources,
+    indices: out,
+    uvs,
+    width,
+    height,
+    density,
+    texels: bytes
+  };
+}
+var chartCone = Math.cos(20 * Math.PI / 180);
+function chartsOf(indices, point3) {
+  const key = (p) => p.map((value) => Math.round(value * 1e4)).join(",");
+  const count = indices.length / 3;
+  const normals = [];
+  const areas = [];
+  const edges = /* @__PURE__ */ new Map();
+  const edgeKeys = [];
+  for (let triangle = 0; triangle < count; triangle++) {
+    const [a, b, c] = [0, 1, 2].map((k) => point3(indices[triangle * 3 + k]));
+    const normal = crossOf(sub(b, a), sub(c, a));
+    const length = Math.hypot(...normal);
+    areas.push(length / 2);
+    normals.push(length > 1e-12 ? normal.map((value) => value / length) : [0, 0, 1]);
+    for (const [from, to] of [
+      [a, b],
+      [b, c],
+      [c, a]
+    ]) {
+      const [u, v] = [key(from), key(to)];
+      const edge2 = u < v ? `${u}|${v}` : `${v}|${u}`;
+      edgeKeys.push(edge2);
+      const users = edges.get(edge2);
+      if (users) users.push(triangle);
+      else edges.set(edge2, [triangle]);
+    }
+  }
+  const owner = new Int32Array(count).fill(-1);
+  const order = Array.from({ length: count }, (_, i) => i).sort(
+    (a, b) => areas[b] - areas[a] || a - b
+  );
+  const charts = [];
+  for (const seed of order) {
+    if (owner[seed] !== -1) continue;
+    const normal = normals[seed];
+    const group = [seed];
+    owner[seed] = seed;
+    for (let at = 0; at < group.length; at++)
+      for (let e = 0; e < 3; e++)
+        for (const next of edges.get(edgeKeys[group[at] * 3 + e]))
+          if (owner[next] === -1 && dot(normals[next], normal) >= chartCone) {
+            owner[next] = seed;
+            group.push(next);
+          }
+    charts.push(...flatCharts(group, normal, indices, point3));
+  }
+  return charts;
+}
+function flatCharts(group, normal, indices, point3, depth = 0) {
+  let longest = 0;
+  let u = Math.abs(normal[2]) < 0.9 ? [-normal[1], normal[0], 0] : [normal[2], 0, -normal[0]];
+  let area = 0;
+  for (const triangle of group) {
+    const [a, b, c] = [0, 1, 2].map((k) => point3(indices[triangle * 3 + k]));
+    area += Math.hypot(...crossOf(sub(b, a), sub(c, a))) / 2;
+    for (const [from, to] of [
+      [a, b],
+      [b, c],
+      [c, a]
+    ]) {
+      const d = sub(to, from);
+      const along = d.map((value, axis) => value - normal[axis] * dot(d, normal));
+      const length = Math.hypot(...along);
+      if (length > longest) {
+        longest = length;
+        u = along;
+      }
+    }
+  }
+  const size = Math.hypot(...u) || 1;
+  u = u.map((value) => value / size);
+  const v = crossOf(normal, u);
+  let [minU, minV, maxU, maxV] = [Infinity, Infinity, -Infinity, -Infinity];
+  for (const triangle of group)
+    for (let k = 0; k < 3; k++) {
+      const p = point3(indices[triangle * 3 + k]);
+      minU = Math.min(minU, dot(u, p));
+      maxU = Math.max(maxU, dot(u, p));
+      minV = Math.min(minV, dot(v, p));
+      maxV = Math.max(maxV, dot(v, p));
+    }
+  const flip = maxV - minV > maxU - minU;
+  if (group.length > 1 && depth < 16 && area < 0.5 * (maxU - minU) * (maxV - minV)) {
+    const axis = flip ? v : u;
+    const centre = (triangle) => [0, 1, 2].reduce((sum, k) => sum + dot(axis, point3(indices[triangle * 3 + k])), 0) / 3;
+    const sorted = [...group].sort((a, b) => centre(a) - centre(b) || a - b);
+    const half = sorted.length >> 1;
+    return [
+      ...flatCharts(sorted.slice(0, half), normal, indices, point3, depth + 1),
+      ...flatCharts(sorted.slice(half), normal, indices, point3, depth + 1)
+    ];
+  }
+  return [
+    {
+      triangles: group,
+      normal,
+      u: flip ? v : u,
+      v: flip ? u : v,
+      min: flip ? [minV, minU] : [minU, minV],
+      extent: flip ? [maxV - minV, maxU - minU] : [maxU - minU, maxV - minV],
+      scale: [0, 0],
+      w: 0,
+      h: 0,
+      x: 0,
+      y: 0
+    }
+  ];
+}
+function sizeAt(chart, density) {
+  if (chart.palette) return [paletteSide, paletteSide];
+  chart.tiny = chart.extent[0] * density < 2 && chart.extent[1] * density < 2;
+  if (chart.tiny) return [0, 0];
+  const size = chart.extent.map((extent) => Math.max(2, Math.round(extent * density) + 1));
+  chart.scale = [0, 1].map(
+    (axis) => chart.extent[axis] > 0 ? (size[axis] - 1) / chart.extent[axis] : 0
+  );
+  return size;
+}
+function densityFor(charts, budget) {
+  const area = (density) => charts.reduce((sum, chart) => {
+    const [w, h] = sizeAt(chart, density);
+    return sum + w * h;
+  }, 0);
+  let low = 1 / 16, high = 64;
+  if (area(low) / 0.8 > budget) return void 0;
+  for (let step = 0; step < 24; step++) {
+    const middle = Math.sqrt(low * high);
+    if (area(middle) / 0.8 <= budget) low = middle;
+    else high = middle;
+  }
+  return low;
+}
+function pack(charts, density) {
+  for (const chart of charts) [chart.w, chart.h] = sizeAt(chart, density);
+  const order = charts.map((_, i) => i).sort((a, b) => charts[b].h - charts[a].h || charts[b].w - charts[a].w || a - b);
+  let best;
+  for (let width = 64; width <= maximumSide; width *= 2) {
+    let line = [{ x: 0, y: 0, w: width }];
+    const places = new Array(charts.length);
+    let fits = true;
+    for (const index of order) {
+      const chart = charts[index];
+      if (chart.w === 0) {
+        places[index] = [0, 0];
+        continue;
+      }
+      if (chart.w > width) {
+        fits = false;
+        break;
+      }
+      let place;
+      for (let i = 0; i < line.length; i++) {
+        const x = line[i].x;
+        if (x + chart.w > width) break;
+        let y = 0, covered = 0;
+        for (let j = i; j < line.length && covered < chart.w; j++) {
+          y = Math.max(y, line[j].y);
+          covered += line[j].w;
+        }
+        if (covered < chart.w) continue;
+        if (!place || y < place.y) place = { x, y };
+      }
+      if (!place || place.y + chart.h > maximumSide) {
+        fits = false;
+        break;
+      }
+      places[index] = [place.x, place.y];
+      const next = [];
+      for (const segment of line) {
+        const end = segment.x + segment.w;
+        if (end <= place.x || segment.x >= place.x + chart.w) next.push(segment);
+        else {
+          if (segment.x < place.x) next.push({ x: segment.x, y: segment.y, w: place.x - segment.x });
+          if (end > place.x + chart.w)
+            next.push({ x: place.x + chart.w, y: segment.y, w: end - place.x - chart.w });
+        }
+      }
+      next.push({ x: place.x, y: place.y + chart.h, w: chart.w });
+      next.sort((a, b) => a.x - b.x);
+      line = [];
+      for (const segment of next) {
+        const last = line.at(-1);
+        if (last && last.y === segment.y && last.x + last.w === segment.x) last.w += segment.w;
+        else line.push({ ...segment });
+      }
+    }
+    if (!fits) continue;
+    const height = Math.max(...line.map((segment) => segment.y));
+    if (!best || width * height < best.width * best.height) best = { width, height, places };
+  }
+  if (!best) return void 0;
+  charts.forEach((chart, i) => [chart.x, chart.y] = best.places[i]);
+  return { width: best.width, height: best.height };
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function sub(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function crossOf(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function cross2(a, b, p) {
+  return (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
+}
+
+// src/building-model-materials.ts
+import {
+  checkTileflowModelSurface,
+  tileflowModelTextureChannels
+} from "@tileflow/core";
+function buildingModelSurface(primitives) {
+  if (!primitives.some((primitive) => primitive.surface)) return void 0;
+  const attributes = [];
+  const materials = [];
+  const materialIds = /* @__PURE__ */ new Map();
+  const textures = [];
+  const textureIds = /* @__PURE__ */ new Map();
+  const ranges = [];
+  const emitters = [];
+  let indexCount = 0;
+  for (const primitive of primitives) {
+    const count = primitive.positions.length / 3;
+    const surface = primitive.surface;
+    if (surface) {
+      checkTileflowModelSurface(surface, count, primitive.indices.length);
+      for (const value of surface.attributes) attributes.push(value);
+      emitters.push(...surface.emitters ?? []);
+    } else {
+      for (let vertex = 0; vertex < count; vertex++) attributes.push(0, 0, 0, 0, 1, 1, 1, 1);
+    }
+    const remap = (surface?.materials ?? [{}]).map((material) => {
+      const copy = { ...material };
+      for (const channel of tileflowModelTextureChannels) {
+        const ref = copy[channel];
+        if (!ref) continue;
+        const texture = surface.textures[ref.texture];
+        let id2 = textureIds.get(texture);
+        if (id2 === void 0) {
+          id2 = textures.length;
+          textures.push(texture);
+          textureIds.set(texture, id2);
+        }
+        copy[channel] = { ...ref, texture: id2 };
+      }
+      const key = JSON.stringify(copy);
+      let id = materialIds.get(key);
+      if (id === void 0) {
+        id = materials.length;
+        materials.push(copy);
+        materialIds.set(key, id);
+      }
+      return id;
+    });
+    const sourceRanges = surface?.ranges ?? [
+      { from: 0, count: primitive.indices.length, material: 0 }
+    ];
+    for (const range of sourceRanges) {
+      const material = remap[range.material];
+      const previous = ranges.at(-1);
+      if (previous?.material === material && JSON.stringify(previous.emissiveBounds) === JSON.stringify(range.emissiveBounds))
+        ranges[ranges.length - 1] = { ...previous, count: previous.count + range.count };
+      else ranges.push({ ...range, from: indexCount + range.from, material });
+    }
+    indexCount += primitive.indices.length;
+  }
+  const result = { attributes, materials, textures, ranges, ...emitters.length ? { emitters } : {} };
+  checkTileflowModelSurface(result, attributes.length / 8, indexCount);
+  return result;
+}
+
+// src/gltf-materials.ts
+import {
+  checkTileflowModelSurface as checkTileflowModelSurface2,
+  tileflowModelImageSize,
+  tileflowModelSurfaceLimits
+} from "@tileflow/core";
+function createGltfMaterialReader(json, bin, accessor2) {
+  const textures = [];
+  const textureIds = /* @__PURE__ */ new Map();
+  const imageCache = /* @__PURE__ */ new Map();
+  function imageAt(index) {
+    if (!Number.isInteger(index)) throw new RangeError("A material names a missing image.");
+    const cached = imageCache.get(index);
+    if (cached) return cached;
+    const image = record(list(json.images)[index]);
+    let bytes;
+    let mimeType = image.mimeType;
+    if (typeof image.uri === "string") {
+      const match = /^data:(image\/(?:png|jpeg));base64,([A-Za-z0-9+/=\r\n]+)$/.exec(image.uri);
+      if (!match || image.uri.length > 24 * 1024 * 1024)
+        throw new RangeError("Embed PNG/JPEG images in the GLB; external images are not read.");
+      if (mimeType !== void 0 && mimeType !== match[1])
+        throw new RangeError("An image has conflicting media types.");
+      mimeType = match[1];
+      bytes = new Uint8Array(Buffer.from(match[2], "base64"));
+    } else {
+      if (!Number.isInteger(image.bufferView)) throw new RangeError("Embed each image in the GLB.");
+      const view = record(list(json.bufferViews)[image.bufferView]);
+      const start = view.byteOffset ?? 0;
+      const length = view.byteLength;
+      if (!bin || (view.buffer ?? 0) !== 0 || !Number.isInteger(start) || !Number.isInteger(length) || start < 0 || length <= 0 || start + length > bin.length)
+        throw new RangeError("An embedded image extends outside the GLB.");
+      bytes = bin.subarray(start, start + length);
+    }
+    if (mimeType !== "image/png" && mimeType !== "image/jpeg")
+      throw new RangeError("Use an embedded PNG or JPEG image.");
+    const size = tileflowModelImageSize(bytes, mimeType);
+    if (!size || Math.max(...size) > tileflowModelSurfaceLimits.textureDimension || size[0] * size[1] > tileflowModelSurfaceLimits.texturePixels)
+      throw new RangeError("The model image is invalid or exceeds its pixel budget.");
+    const result = {
+      bytes,
+      width: size[0],
+      height: size[1],
+      mimeType
+    };
+    imageCache.set(index, result);
+    return result;
+  }
+  function textureAt(index) {
+    if (!Number.isInteger(index)) throw new RangeError("A material names a missing texture.");
+    const cached = textureIds.get(index);
+    if (cached !== void 0) return cached;
+    const source = record(list(json.textures)[index]);
+    const image = imageAt(source.source);
+    const sampler = source.sampler === void 0 ? {} : record(list(json.samplers)[source.sampler]);
+    if (source.sampler !== void 0 && (!Number.isInteger(source.sampler) || !list(json.samplers)[source.sampler]))
+      throw new RangeError("A texture names a missing sampler.");
+    const id = textures.length;
+    if (id >= tileflowModelSurfaceLimits.textures)
+      throw new RangeError("The model has too many textures.");
+    textures.push({
+      ...image,
+      ...pick(sampler, ["wrapS", "wrapT", "minFilter", "magFilter"])
+    });
+    textureIds.set(index, id);
+    return id;
+  }
+  function textureRef(value, normal = false) {
+    if (value === void 0) return void 0;
+    const ref = record(value);
+    const transform3 = record(record(ref.extensions).KHR_texture_transform);
+    const texCoord = transform3.texCoord ?? ref.texCoord;
+    return {
+      texture: textureAt(ref.index),
+      ...texCoord === void 0 ? {} : { texCoord },
+      ...pick(transform3, ["offset", "scale", "rotation"]),
+      ...normal && ref.scale !== void 0 ? { strength: ref.scale } : {},
+      ...!normal && ref.strength !== void 0 ? { strength: ref.strength } : {}
+    };
+  }
+  return (primitive, count, indexCount) => {
+    const source = primitive.material === void 0 ? {} : record(list(json.materials)[primitive.material]);
+    if (primitive.material !== void 0 && (!Number.isInteger(primitive.material) || !list(json.materials)[primitive.material]))
+      throw new RangeError("A primitive names a missing material.");
+    const pbr = record(source.pbrMetallicRoughness);
+    const extensions = record(source.extensions);
+    const material = {
+      ...pick(pbr, ["baseColorFactor", "metallicFactor", "roughnessFactor"]),
+      ...pick(source, ["emissiveFactor", "alphaMode", "alphaCutoff", "doubleSided"]),
+      ...extensions.KHR_materials_unlit === void 0 ? {} : { unlit: true },
+      ...pick(record(extensions.KHR_materials_emissive_strength), ["emissiveStrength"]),
+      ...optional("baseColorTexture", textureRef(pbr.baseColorTexture)),
+      ...optional("metallicRoughnessTexture", textureRef(pbr.metallicRoughnessTexture)),
+      ...optional("normalTexture", textureRef(source.normalTexture, true)),
+      ...optional("occlusionTexture", textureRef(source.occlusionTexture)),
+      ...optional("emissiveTexture", textureRef(source.emissiveTexture))
+    };
+    const attributes = record(primitive.attributes);
+    const read = (name, size) => {
+      const index = attributes[name];
+      if (index === void 0) return void 0;
+      if (!Number.isInteger(index)) throw new RangeError(`Invalid ${name} accessor.`);
+      const value = accessor2(index);
+      if (!size.includes(value.size) || value.values.length !== count * value.size)
+        throw new RangeError(`${name} must have one value per vertex.`);
+      return value;
+    };
+    const uv0 = read("TEXCOORD_0", [2]), uv1 = read("TEXCOORD_1", [2]);
+    if (uv1?.values.some((value) => !(value >= 0 && value <= 1)))
+      throw new RangeError("TEXCOORD_1 must lie between zero and one.");
+    const colour = read("COLOR_0", [3, 4]);
+    for (const key of [
+      "baseColorTexture",
+      "metallicRoughnessTexture",
+      "normalTexture",
+      "occlusionTexture",
+      "emissiveTexture"
+    ]) {
+      const ref = material[key];
+      if (ref && !(ref.texCoord === 1 ? uv1 : ref.texCoord === void 0 || ref.texCoord === 0 ? uv0 : void 0))
+        throw new RangeError(`The ${key} needs its declared UV coordinates.`);
+    }
+    const data = new Float32Array(count * 8);
+    for (let vertex = 0; vertex < count; vertex++) {
+      for (let axis = 0; axis < 2; axis++) {
+        data[vertex * 8 + axis] = uv0?.values[vertex * 2 + axis] ?? 0;
+        data[vertex * 8 + 2 + axis] = uv1?.values[vertex * 2 + axis] ?? 0;
+      }
+      for (let channel = 0; channel < 4; channel++)
+        data[vertex * 8 + 4 + channel] = colour && channel < colour.size ? colour.values[vertex * colour.size + channel] : 1;
+    }
+    const surface = {
+      attributes: data,
+      materials: [material],
+      textures,
+      ranges: [{ from: 0, count: indexCount, material: 0 }]
+    };
+    checkTileflowModelSurface2(surface, count, indexCount);
+    return surface;
+  };
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function list(value) {
+  return Array.isArray(value) ? value : [];
+}
+function pick(value, keys) {
+  return Object.fromEntries(
+    keys.filter((key) => value[key] !== void 0).map((key) => [key, value[key]])
+  );
+}
+function optional(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+
+// src/gltf-reader.ts
+var TileflowGltfError = class extends Error {
+  name = "TileflowGltfError";
+};
+var glbMagic = 1179937895;
+var jsonChunk = 1313821514;
+var binChunk = 5130562;
+var triangles = 4;
+var compressions = /* @__PURE__ */ new Set([
+  "KHR_draco_mesh_compression",
+  "EXT_meshopt_compression",
+  "KHR_meshopt_compression",
+  "KHR_mesh_quantization"
+]);
+var componentBytes = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5125: 4,
+  5126: 4
+};
+var typeSizes = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4 };
+function readTileflowGltfTriangles(bytes, { materials = false } = {}) {
+  const { json, bin } = chunks(bytes);
+  const required = array(json.extensionsRequired).filter((name) => typeof name === "string");
+  const compressed = required.find((name) => compressions.has(name));
+  if (compressed)
+    throw new TileflowGltfError(
+      `uses compressed geometry (${String(compressed)}); export it without compression`
+    );
+  for (const buffer of array(json.buffers))
+    if (record2(buffer).uri !== void 0)
+      throw new TileflowGltfError("keeps its geometry in another file; export a single .glb");
+  const nodes = array(json.nodes).map(record2);
+  const scenes = array(json.scenes).map(record2);
+  const scene = scenes[typeof json.scene === "number" ? json.scene : 0];
+  const roots = scene ? array(scene.nodes) : nodes.map((_, index) => index).filter((index) => !nodes.some((node) => array(node.children).includes(index)));
+  const out = [];
+  const physical = materials ? createGltfMaterialReader(json, bin, (index) => accessorWithSize(json, bin, index)) : void 0;
+  const emitters = [];
+  const visit = (index, parent, depth) => {
+    if (typeof index !== "number" || !nodes[index])
+      throw new TileflowGltfError("names a node it does not hold");
+    if (depth > 64) throw new TileflowGltfError("nests its nodes more than 64 deep");
+    const node = nodes[index];
+    const world = multiply(parent, local(node));
+    if (physical) {
+      const lights = record2(record2(node.extras).tileflow).emitters;
+      if (lights !== void 0 && !Array.isArray(lights))
+        throw new TileflowGltfError("area emitters must be an array");
+      for (const value of array(lights)) {
+        const own = record2(value);
+        const point3 = (key) => {
+          const input = array(own[key]);
+          if (input.length !== 3 || !input.every((value2) => typeof value2 === "number" && Number.isFinite(value2)))
+            throw new TileflowGltfError("an area emitter needs finite three-dimensional endpoints");
+          const p = transform2(world, input[0], input[1], input[2], 1);
+          return [p[0], -p[2], p[1]];
+        };
+        const heightScale = Math.hypot(...transform2(world, 0, 1, 0, 0));
+        const depthScale = Math.hypot(...transform2(world, 0, 0, 1, 0));
+        if (typeof own.height !== "number")
+          throw new TileflowGltfError("an area emitter needs its height");
+        emitters.push({
+          start: point3("start"),
+          end: point3("end"),
+          height: own.height * heightScale,
+          ...own.depth === void 0 ? {} : { depth: Number(own.depth) * depthScale },
+          role: own.role,
+          part: own.part
+        });
+      }
+    }
+    if (typeof node.mesh === "number") out.push(...meshOf(json, bin, node.mesh, world, physical));
+    for (const child of array(node.children)) visit(child, world, depth + 1);
+  };
+  for (const root of roots) visit(root, identity(), 0);
+  if (out.length === 0) throw new TileflowGltfError("holds no triangles in its scene");
+  if (emitters.length) {
+    const first = out.find((part) => !/^footprint(?:\.\d+)?$/i.test(part.material ?? ""));
+    if (first?.surface) first.surface = { ...first.surface, emitters };
+  }
+  return out;
+}
+function chunks(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.byteLength < 20 || view.getUint32(0, true) !== glbMagic)
+    throw new TileflowGltfError("is not a glTF binary; export the model as .glb");
+  if (view.getUint32(4, true) !== 2) throw new TileflowGltfError("is not glTF 2.0");
+  if (view.getUint32(8, true) !== bytes.byteLength)
+    throw new TileflowGltfError("is cut short or has trailing bytes");
+  let at = 12;
+  let json;
+  let bin;
+  while (at + 8 <= bytes.byteLength) {
+    const length = view.getUint32(at, true);
+    const type = view.getUint32(at + 4, true);
+    const start = at + 8;
+    if (start + length > bytes.byteLength) throw new TileflowGltfError("has a chunk past its end");
+    const body = bytes.subarray(start, start + length);
+    if (type === jsonChunk && json === void 0) {
+      try {
+        json = record2(JSON.parse(new TextDecoder().decode(body)));
+      } catch {
+        throw new TileflowGltfError("has an unreadable JSON chunk");
+      }
+    } else if (type === binChunk && bin === void 0) bin = body;
+    at = start + length + (4 - length % 4) % 4;
+  }
+  if (!json) throw new TileflowGltfError("has no JSON chunk");
+  return { json, bin };
+}
+function meshOf(json, bin, index, world, physical) {
+  const mesh = record2(array(json.meshes)[index]);
+  const normalMatrix = inverseTranspose(world);
+  const result = array(mesh.primitives).map((value) => {
+    const primitive = record2(value);
+    if ((primitive.mode ?? triangles) !== triangles)
+      throw new TileflowGltfError("draws points or lines; a tree model draws triangles");
+    const attributes = record2(primitive.attributes);
+    if (typeof attributes.POSITION !== "number")
+      throw new TileflowGltfError("has a primitive without positions");
+    const raw = accessor(json, bin, attributes.POSITION, 3);
+    const count = raw.length / 3;
+    const positions = [];
+    for (let vertex = 0; vertex < count; vertex += 1) {
+      const [x, y, z] = transform2(
+        world,
+        raw[vertex * 3],
+        raw[vertex * 3 + 1],
+        raw[vertex * 3 + 2],
+        1
+      );
+      positions.push(x, -z, y);
+    }
+    let normals;
+    if (typeof attributes.NORMAL === "number") {
+      const rawNormals = accessor(json, bin, attributes.NORMAL, 3);
+      normals = [];
+      for (let vertex = 0; vertex < count; vertex += 1) {
+        const [x, y, z] = transform2(
+          normalMatrix,
+          rawNormals[vertex * 3],
+          rawNormals[vertex * 3 + 1],
+          rawNormals[vertex * 3 + 2],
+          0
+        );
+        const size = Math.hypot(x, y, z) || 1;
+        normals.push(x / size, -z / size, y / size);
+      }
+    }
+    const material = typeof primitive.material === "number" ? record2(array(json.materials)[primitive.material]) : void 0;
+    const base = array(record2(material?.pbrMetallicRoughness).baseColorFactor).map(Number);
+    const factor = base.length >= 3 && base.every(Number.isFinite) ? base : [1, 1, 1];
+    const colours = [];
+    const vertexColours = typeof attributes.COLOR_0 === "number" ? accessorWithSize(json, bin, attributes.COLOR_0) : void 0;
+    for (let vertex = 0; vertex < count; vertex += 1)
+      for (let channel = 0; channel < 3; channel += 1)
+        colours.push(
+          factor[channel] * (vertexColours ? vertexColours.values[vertex * vertexColours.size + channel] : 1)
+        );
+    const indices = typeof primitive.indices === "number" ? accessor(json, bin, primitive.indices, 1).map((value2) => Math.round(value2)) : Array.from({ length: count }, (_, vertex) => vertex);
+    if (indices.length % 3 !== 0 || indices.some((vertex) => vertex < 0 || vertex >= count))
+      throw new TileflowGltfError("has triangles that name missing vertices");
+    if (determinant(world) < 0)
+      for (let at = 0; at + 2 < indices.length; at += 3)
+        [indices[at + 1], indices[at + 2]] = [indices[at + 2], indices[at + 1]];
+    return {
+      material: typeof material?.name === "string" ? material.name : void 0,
+      ...record2(record2(material?.extras).tileflow).lightingRole === void 0 ? {} : {
+        lightingRole: record2(record2(material?.extras).tileflow).lightingRole
+      },
+      positions,
+      normals,
+      colours,
+      indices,
+      ...physical ? { surface: physical(primitive, count, indices.length) } : {}
+    };
+  });
+  if (physical) {
+    let low = Infinity, high = -Infinity;
+    for (const part of result)
+      if (!/^footprint(?:\.\d+)?$/i.test(part.material ?? ""))
+        for (let at = 2; at < part.positions.length; at += 3) {
+          low = Math.min(low, part.positions[at]);
+          high = Math.max(high, part.positions[at]);
+        }
+    if (Number.isFinite(low)) {
+      for (const part of result)
+        if (part.surface)
+          part.surface = {
+            ...part.surface,
+            ranges: part.surface.ranges.map((range) => ({
+              ...range,
+              emissiveBounds: [low, high]
+            }))
+          };
+    }
+  }
+  return result;
+}
+function accessor(json, bin, index, size) {
+  const read = accessorWithSize(json, bin, index);
+  if (read.size !== size)
+    throw new TileflowGltfError(`has an accessor of ${read.size} components where ${size} belong`);
+  return read.values;
+}
+function accessorWithSize(json, bin, index) {
+  const accessor2 = record2(array(json.accessors)[index]);
+  if (accessor2.sparse !== void 0)
+    throw new TileflowGltfError("uses sparse accessors; export without them");
+  const size = typeSizes[String(accessor2.type)];
+  const component = Number(accessor2.componentType);
+  const bytesEach = componentBytes[component];
+  const count = Number(accessor2.count);
+  if (!size || !bytesEach || !Number.isInteger(count) || count < 0 || count > 1e6)
+    throw new TileflowGltfError("has an accessor Tileflow cannot read");
+  if (typeof accessor2.bufferView !== "number")
+    return { values: new Array(count * size).fill(0), size };
+  const view = record2(array(json.bufferViews)[accessor2.bufferView]);
+  if (!bin || Number(view.buffer ?? 0) !== 0)
+    throw new TileflowGltfError("has geometry outside its binary chunk");
+  const stride = Number(view.byteStride ?? 0) || size * bytesEach;
+  const start = Number(view.byteOffset ?? 0) + Number(accessor2.byteOffset ?? 0);
+  const end = start + (count - 1) * stride + size * bytesEach;
+  if (count > 0 && (start < 0 || end > Number(view.byteOffset ?? 0) + Number(view.byteLength) || end > bin.byteLength))
+    throw new TileflowGltfError("has an accessor past the end of its buffer");
+  const data = new DataView(bin.buffer, bin.byteOffset, bin.byteLength);
+  const normalized = accessor2.normalized === true;
+  const values = [];
+  for (let item = 0; item < count; item += 1)
+    for (let part = 0; part < size; part += 1) {
+      const at = start + item * stride + part * bytesEach;
+      let value;
+      switch (component) {
+        case 5126:
+          value = data.getFloat32(at, true);
+          break;
+        case 5125:
+          value = data.getUint32(at, true);
+          break;
+        case 5123:
+          value = data.getUint16(at, true);
+          if (normalized) value /= 65535;
+          break;
+        case 5122:
+          value = data.getInt16(at, true);
+          if (normalized) value = Math.max(value / 32767, -1);
+          break;
+        case 5121:
+          value = data.getUint8(at);
+          if (normalized) value /= 255;
+          break;
+        default:
+          value = data.getInt8(at);
+          if (normalized) value = Math.max(value / 127, -1);
+      }
+      if (!Number.isFinite(value)) throw new TileflowGltfError("has a value that is not a number");
+      values.push(value);
+    }
+  return { values, size };
+}
+function identity() {
+  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+function local(node) {
+  const matrix = array(node.matrix).map(Number);
+  if (matrix.length === 16 && matrix.every(Number.isFinite)) return matrix;
+  const [tx, ty, tz] = vector(node.translation, [0, 0, 0]);
+  const [qx, qy, qz, qw] = vector(node.rotation, [0, 0, 0, 1]);
+  const [sx, sy, sz] = vector(node.scale, [1, 1, 1]);
+  const [xx, yy, zz] = [qx * qx, qy * qy, qz * qz];
+  const [xy, xz, yz, wx, wy, wz] = [qx * qy, qx * qz, qy * qz, qw * qx, qw * qy, qw * qz];
+  return [
+    (1 - 2 * (yy + zz)) * sx,
+    2 * (xy + wz) * sx,
+    2 * (xz - wy) * sx,
+    0,
+    2 * (xy - wz) * sy,
+    (1 - 2 * (xx + zz)) * sy,
+    2 * (yz + wx) * sy,
+    0,
+    2 * (xz + wy) * sz,
+    2 * (yz - wx) * sz,
+    (1 - 2 * (xx + yy)) * sz,
+    0,
+    tx,
+    ty,
+    tz,
+    1
+  ];
+}
+function multiply(a, b) {
+  const out = new Array(16).fill(0);
+  for (let column = 0; column < 4; column += 1)
+    for (let row = 0; row < 4; row += 1)
+      for (let k = 0; k < 4; k += 1) out[column * 4 + row] += a[k * 4 + row] * b[column * 4 + k];
+  return out;
+}
+function transform2(m, x, y, z, w) {
+  return [
+    m[0] * x + m[4] * y + m[8] * z + m[12] * w,
+    m[1] * x + m[5] * y + m[9] * z + m[13] * w,
+    m[2] * x + m[6] * y + m[10] * z + m[14] * w
+  ];
+}
+function determinant(m) {
+  return m[0] * (m[5] * m[10] - m[9] * m[6]) - m[4] * (m[1] * m[10] - m[9] * m[2]) + m[8] * (m[1] * m[6] - m[5] * m[2]);
+}
+function inverseTranspose(m) {
+  const [a, b, c, d, e, f, g, h, i] = [
+    m[0],
+    m[1],
+    m[2],
+    m[4],
+    m[5],
+    m[6],
+    m[8],
+    m[9],
+    m[10]
+  ];
+  const det = determinant(m) || 1;
+  return [
+    (e * i - h * f) / det,
+    (g * f - d * i) / det,
+    (d * h - g * e) / det,
+    0,
+    (h * c - b * i) / det,
+    (a * i - g * c) / det,
+    (g * b - a * h) / det,
+    0,
+    (b * f - e * c) / det,
+    (d * c - a * f) / det,
+    (a * e - d * b) / det,
+    0,
+    0,
+    0,
+    0,
+    1
+  ];
+}
+function record2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+function vector(value, fallback) {
+  const list2 = array(value).map(Number);
+  return list2.length === fallback.length && list2.every(Number.isFinite) ? list2 : fallback;
+}
+
+// src/grey-jpeg.ts
+var zigzag = [
+  0,
+  1,
+  8,
+  16,
+  9,
+  2,
+  3,
+  10,
+  17,
+  24,
+  32,
+  25,
+  18,
+  11,
+  4,
+  5,
+  12,
+  19,
+  26,
+  33,
+  40,
+  48,
+  41,
+  34,
+  27,
+  20,
+  13,
+  6,
+  7,
+  14,
+  21,
+  28,
+  35,
+  42,
+  49,
+  56,
+  57,
+  50,
+  43,
+  36,
+  29,
+  22,
+  15,
+  23,
+  30,
+  37,
+  44,
+  51,
+  58,
+  59,
+  52,
+  45,
+  38,
+  31,
+  39,
+  46,
+  53,
+  60,
+  61,
+  54,
+  47,
+  55,
+  62,
+  63
+];
+var luminance = [
+  16,
+  11,
+  10,
+  16,
+  24,
+  40,
+  51,
+  61,
+  12,
+  12,
+  14,
+  19,
+  26,
+  58,
+  60,
+  55,
+  14,
+  13,
+  16,
+  24,
+  40,
+  57,
+  69,
+  56,
+  14,
+  17,
+  22,
+  29,
+  51,
+  87,
+  80,
+  62,
+  18,
+  22,
+  37,
+  56,
+  68,
+  109,
+  103,
+  77,
+  24,
+  35,
+  55,
+  64,
+  81,
+  104,
+  113,
+  92,
+  49,
+  64,
+  78,
+  87,
+  103,
+  121,
+  120,
+  101,
+  72,
+  92,
+  95,
+  98,
+  112,
+  100,
+  103,
+  99
+];
+function huffman(counts, symbols) {
+  const out = { code: [], size: [] };
+  let code = 0, k = 0;
+  for (let length = 1; length <= 16; length++) {
+    for (let i = 0; i < counts[length - 1]; i++) {
+      out.code[symbols[k]] = code;
+      out.size[symbols[k]] = length;
+      code++;
+      k++;
+    }
+    code <<= 1;
+  }
+  return out;
+}
+var basis = Array.from({ length: 64 }, (_, i) => {
+  const u = i >> 3, x = i & 7;
+  return (u === 0 ? Math.SQRT1_2 : 1) * 0.5 * Math.cos((2 * x + 1) * u * Math.PI / 16);
+});
+function encodeGreyJpeg(pixels, width, height, quality) {
+  if (!(width > 0 && height > 0 && width <= 65535 && height <= 65535))
+    throw new RangeError("A JPEG is 1 to 65,535 pixels on each side.");
+  if (pixels.length !== width * height) throw new RangeError("One byte a pixel is required.");
+  const q = Math.min(100, Math.max(1, Math.round(quality)));
+  const scale = q < 50 ? 5e3 / q : 200 - 2 * q;
+  const table = luminance.map(
+    (value) => Math.min(255, Math.max(1, Math.floor((value * scale + 50) / 100)))
+  );
+  const symbols = [];
+  const extra = [];
+  const frequencies = [new Array(257).fill(0), new Array(257).fill(0)];
+  const emit = (table2, symbol, value = 0, size = 0) => {
+    symbols.push(table2 << 8 | symbol);
+    extra.push(size ? (value < 0 ? value + (1 << size) - 1 : value) << 5 | size : 0);
+    frequencies[table2][symbol] += 1;
+  };
+  const magnitude = (value) => {
+    let size = 0;
+    for (let v = Math.abs(value); v > 0; v >>= 1) size++;
+    return size;
+  };
+  const block = new Float64Array(64);
+  const row = new Float64Array(64);
+  const coefficients = new Int32Array(64);
+  let previous = 0;
+  for (let by = 0; by < height; by += 8)
+    for (let bx = 0; bx < width; bx += 8) {
+      for (let y = 0; y < 8; y++)
+        for (let x = 0; x < 8; x++)
+          block[y * 8 + x] = pixels[Math.min(height - 1, by + y) * width + Math.min(width - 1, bx + x)] - 128;
+      for (let y = 0; y < 8; y++)
+        for (let u = 0; u < 8; u++) {
+          let sum = 0;
+          for (let x = 0; x < 8; x++) sum += block[y * 8 + x] * basis[u * 8 + x];
+          row[y * 8 + u] = sum;
+        }
+      for (let v = 0; v < 8; v++)
+        for (let u = 0; u < 8; u++) {
+          let sum = 0;
+          for (let y = 0; y < 8; y++) sum += row[y * 8 + u] * basis[v * 8 + y];
+          coefficients[v * 8 + u] = Math.round(sum / table[v * 8 + u]);
+        }
+      const dc = coefficients[0] - previous;
+      previous = coefficients[0];
+      const dcSize = magnitude(dc);
+      emit(0, dcSize, dc, dcSize);
+      let zeros = 0;
+      for (let k = 1; k < 64; k++) {
+        const value = coefficients[zigzag[k]];
+        if (value === 0) {
+          zeros++;
+          continue;
+        }
+        for (; zeros > 15; zeros -= 16) emit(1, 240);
+        const size = magnitude(value);
+        emit(1, zeros << 4 | size, value, size);
+        zeros = 0;
+      }
+      if (zeros > 0) emit(1, 0);
+    }
+  const tables = frequencies.map(optimalTable);
+  const codes = tables.map(({ counts, values }) => huffman(counts, values));
+  const out = [];
+  const word = (value) => out.push(value >> 8 & 255, value & 255);
+  word(65496);
+  word(65499);
+  word(67);
+  out.push(0, ...zigzag.map((at) => table[at]));
+  word(65472);
+  word(11);
+  out.push(8);
+  word(height);
+  word(width);
+  out.push(1, 1, 17, 0);
+  for (const [index, { counts, values }] of tables.entries()) {
+    word(65476);
+    word(3 + 16 + values.length);
+    out.push(index << 4, ...counts, ...values);
+  }
+  word(65498);
+  word(8);
+  out.push(1, 1, 0, 0, 63, 0);
+  let bits = 0, count = 0;
+  const put = (code, size) => {
+    bits = bits << size | code & (1 << size) - 1;
+    count += size;
+    while (count >= 8) {
+      const byte = bits >> count - 8 & 255;
+      out.push(byte);
+      if (byte === 255) out.push(0);
+      count -= 8;
+    }
+    bits &= (1 << count) - 1;
+  };
+  for (let i = 0; i < symbols.length; i++) {
+    const own = codes[symbols[i] >> 8];
+    const symbol = symbols[i] & 255;
+    put(own.code[symbol], own.size[symbol]);
+    const size = extra[i] & 31;
+    if (size) put(extra[i] >> 5, size);
+  }
+  if (count > 0) put(127, 8 - count);
+  word(65497);
+  return Uint8Array.from(out);
+}
+function optimalTable(frequencies) {
+  const freq = [...frequencies];
+  freq[256] = 1;
+  const codesize = new Array(257).fill(0);
+  const others = new Array(257).fill(-1);
+  for (; ; ) {
+    let v1 = -1, v2 = -1;
+    for (let i = 0; i <= 256; i++) if (freq[i] > 0 && (v1 < 0 || freq[i] <= freq[v1])) v1 = i;
+    for (let i = 0; i <= 256; i++)
+      if (freq[i] > 0 && i !== v1 && (v2 < 0 || freq[i] <= freq[v2])) v2 = i;
+    if (v2 < 0) break;
+    freq[v1] += freq[v2];
+    freq[v2] = 0;
+    for (codesize[v1]++; others[v1] >= 0; codesize[v1]++) v1 = others[v1];
+    others[v1] = v2;
+    for (codesize[v2]++; others[v2] >= 0; codesize[v2]++) v2 = others[v2];
+  }
+  const bits = new Array(33).fill(0);
+  for (let i = 0; i <= 256; i++) if (codesize[i]) bits[codesize[i]]++;
+  for (let i = 32; i > 16; i--)
+    while (bits[i] > 0) {
+      let j = i - 2;
+      while (bits[j] === 0) j--;
+      bits[i] -= 2;
+      bits[i - 1]++;
+      bits[j + 1] += 2;
+      bits[j]--;
+    }
+  let last = 16;
+  while (bits[last] === 0) last--;
+  bits[last]--;
+  const values = [];
+  for (let length = 1; length <= 32; length++)
+    for (let symbol = 0; symbol < 256; symbol++)
+      if (codesize[symbol] === length) values.push(symbol);
+  return { counts: bits.slice(1, 17), values };
+}
+
+// src/tree-model-mesh.ts
+import {
+  tileflowTreeModelLimits,
+  tileflowTreeParts
+} from "@tileflow/core";
+var tileflowTreeModelPartNames = ["bark", "leaves", "fronds", "stem"];
+function prepareTileflowTreeModelMesh(bytes, level) {
+  const primitives = readTileflowGltfTriangles(bytes);
+  const positions = [];
+  const normals = [];
+  const parts = [];
+  const luminance2 = [];
+  const indices = [];
+  for (const primitive of primitives) {
+    const part = partOf(primitive.material);
+    const offset = positions.length / 3;
+    const count2 = primitive.positions.length / 3;
+    positions.push(...primitive.positions);
+    for (let vertex = 0; vertex < count2; vertex += 1) {
+      parts.push(part);
+      normals.push(primitive.normals?.slice(vertex * 3, vertex * 3 + 3));
+      const [r, g, b] = primitive.colours.slice(vertex * 3, vertex * 3 + 3);
+      luminance2.push(0.2126 * r + 0.7152 * g + 0.0722 * b);
+    }
+    for (const index of primitive.indices) indices.push(offset + index);
+  }
+  const count = positions.length / 3;
+  const triangleCount = indices.length / 3;
+  const limit = level === "near" ? tileflowTreeModelLimits.nearTriangles : tileflowTreeModelLimits.farTriangles;
+  if (triangleCount > limit)
+    throw new TileflowGltfError(
+      `has ${triangleCount.toLocaleString("en")} triangles; a ${level} tree model takes at most ${limit.toLocaleString("en")}. Simplify it (for example with Blender's Decimate modifier) and export it again`
+    );
+  if (count > tileflowTreeModelLimits.vertices)
+    throw new TileflowGltfError(
+      `has ${count.toLocaleString("en")} vertices; a tree model takes at most ${tileflowTreeModelLimits.vertices.toLocaleString("en")}. Merge vertices by distance and export it again`
+    );
+  let height = 0;
+  let reach = 0;
+  const crowned = parts.some((part) => isCrown(part));
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    height = Math.max(height, positions[vertex * 3 + 2]);
+    if (!crowned || isCrown(parts[vertex]))
+      reach = Math.max(reach, Math.hypot(positions[vertex * 3], positions[vertex * 3 + 1]));
+  }
+  if (!(height > 0))
+    throw new TileflowGltfError(
+      "stands below its origin; put the origin where the trunk meets the ground, with the tree above it"
+    );
+  if (!(reach > 0)) throw new TileflowGltfError("has no width round its origin");
+  const across = 2 * reach;
+  const unit = [];
+  for (let vertex = 0; vertex < count; vertex += 1)
+    unit.push(
+      positions[vertex * 3] / across,
+      positions[vertex * 3 + 1] / across,
+      positions[vertex * 3 + 2] / height
+    );
+  const faceSums = new Array(count * 3).fill(0);
+  for (let at = 0; at + 2 < indices.length; at += 3) {
+    const [a, b, c] = [indices[at], indices[at + 1], indices[at + 2]];
+    const n = cross(sub2(point(unit, b), point(unit, a)), sub2(point(unit, c), point(unit, a)));
+    for (const vertex of [a, b, c])
+      for (let axis = 0; axis < 3; axis += 1) faceSums[vertex * 3 + axis] += n[axis];
+  }
+  const outNormals = [];
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    const own = normals[vertex];
+    const n = own ? [own[0] * across, own[1] * across, own[2] * height] : faceSums.slice(vertex * 3, vertex * 3 + 3);
+    const size = Math.hypot(n[0], n[1], n[2]) || 1;
+    outNormals.push(n[0] / size, n[1] / size, n[2] / size);
+  }
+  const shades = new Array(count).fill(0);
+  for (const part of new Set(parts)) {
+    const members = parts.flatMap((value, vertex) => value === part ? [vertex] : []);
+    const mean = members.reduce((sum, vertex) => sum + luminance2[vertex], 0) / members.length;
+    const spread = Math.max(0.06, mean * 0.6);
+    for (const vertex of members)
+      shades[vertex] = clamp((luminance2[vertex] - mean) / spread, -1, 1);
+  }
+  let crownLow = 1;
+  let crownHigh = 0;
+  for (let vertex = 0; vertex < count; vertex += 1)
+    if (isCrown(parts[vertex])) {
+      crownLow = Math.min(crownLow, unit[vertex * 3 + 2]);
+      crownHigh = Math.max(crownHigh, unit[vertex * 3 + 2]);
+    }
+  const occlusion = [];
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    const z = unit[vertex * 3 + 2];
+    if (!isCrown(parts[vertex])) {
+      occlusion.push(z > crownLow ? 0.55 : 0.8);
+      continue;
+    }
+    const up = crownHigh > crownLow ? (z - crownLow) / (crownHigh - crownLow) : 1;
+    const out = Math.min(1, Math.hypot(unit[vertex * 3], unit[vertex * 3 + 1]) / 0.5);
+    occlusion.push(clamp(0.4 + 0.35 * up + 0.3 * out, 0.35, 1));
+  }
+  return {
+    // The author's proportions: the trees it stands keep them around the sizes the data gives.
+    proportion: Math.min(3, Math.max(0.1, across / height)),
+    positions: unit,
+    normals: outNormals,
+    parts,
+    shades,
+    occlusion,
+    indices
+  };
+}
+function partOf(material) {
+  const name = material?.trim().toLowerCase().replace(/\.\d+$/u, "");
+  const part = tileflowTreeModelPartNames.find((candidate) => candidate === name);
+  if (part) return tileflowTreeParts[part];
+  throw new TileflowGltfError(
+    material === void 0 ? "has a mesh without a material; name each material bark, leaves, fronds or stem" : `has a material "${material}" that names no part of a tree; name each material bark, leaves, fronds or stem`
+  );
+}
+function isCrown(part) {
+  return part === tileflowTreeParts.leaves || part === tileflowTreeParts.fronds;
+}
+function point(list2, vertex) {
+  return [list2[vertex * 3], list2[vertex * 3 + 1], list2[vertex * 3 + 2]];
+}
+function sub2(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function clamp(value, low, high) {
+  return Math.min(high, Math.max(low, value));
+}
+
+// src/building-model-mesh.ts
+function isTileflowTreeModel(primitives) {
+  const drawn = primitives.filter((primitive) => !isFootprint(primitive));
+  return drawn.length > 0 && drawn.every(
+    (primitive) => tileflowTreeModelPartNames.includes(
+      partOf2(primitive.material)
+    )
+  );
+}
+function tileflowBuildingModelDeclaredFootprint(primitives) {
+  const positions = [];
+  const indices = [];
+  for (const primitive of primitives) {
+    if (!isFootprint(primitive)) continue;
+    const offset = positions.length / 3;
+    positions.push(...primitive.positions);
+    for (const index of primitive.indices) indices.push(offset + index);
+  }
+  return indices.length > 0 ? { positions, indices } : void 0;
+}
+function prepareTileflowBuildingModelMesh(bytes, {
+  ambientOcclusion = true,
+  lightmapTexels = 0
+} = {}) {
+  const primitives = bytes instanceof Uint8Array ? readTileflowGltfTriangles(bytes, { materials: true }) : bytes;
+  const drawn = primitives.filter((primitive) => !isFootprint(primitive));
+  const surface = buildingModelSurface(drawn);
+  const positions = [];
+  const normals = [];
+  const partNames = [];
+  const parts = [];
+  const lightingRoles = [];
+  const luminance2 = [];
+  const indices = [];
+  for (const primitive of drawn) {
+    const name = partOf2(primitive.material);
+    if (name === void 0)
+      throw new TileflowGltfError(
+        primitive.material === void 0 ? "has a mesh without a material; name each material after its part, such as surface, glass, roof or water" : `has a material "${primitive.material}" that names no part; name each material after its part in lower-case words joined by hyphens, such as surface, glass, roof or water`
+      );
+    if (!partNames.includes(name)) partNames.push(name);
+    if (partNames.length > tileflowModelLimits.parts)
+      throw new TileflowGltfError(
+        `names ${partNames.length} parts in its materials; a building model takes at most ${tileflowModelLimits.parts} a level. Give materials of the same part the same name`
+      );
+    const part = partNames.indexOf(name);
+    const offset = positions.length / 3;
+    const role = primitive.lightingRole === void 0 ? tileflowModelDefaultLightingRole(name) : typeof primitive.lightingRole === "string" && Object.hasOwn(tileflowModelLightingRoles, primitive.lightingRole) ? tileflowModelLightingRoles[primitive.lightingRole] : void 0;
+    if (role === void 0)
+      throw new TileflowGltfError(
+        "has an unknown lighting role; use unclassified, wall, door, roof, window, lamp or logo"
+      );
+    const count2 = primitive.positions.length / 3;
+    positions.push(...primitive.positions);
+    for (let vertex = 0; vertex < count2; vertex += 1) {
+      parts.push(part);
+      lightingRoles.push(role);
+      normals.push(primitive.normals?.slice(vertex * 3, vertex * 3 + 3));
+      const [r, g, b] = primitive.colours.slice(vertex * 3, vertex * 3 + 3);
+      luminance2.push(0.2126 * r + 0.7152 * g + 0.0722 * b);
+    }
+    for (const index of primitive.indices) indices.push(offset + index);
+  }
+  const count = positions.length / 3;
+  const triangles2 = indices.length / 3;
+  if (triangles2 > tileflowModelLimits.triangles)
+    throw new TileflowGltfError(
+      `has ${triangles2.toLocaleString("en")} triangles; a building model takes at most ${tileflowModelLimits.triangles.toLocaleString("en")} a level. Simplify it and export it again`
+    );
+  if (count > tileflowModelLimits.vertices)
+    throw new TileflowGltfError(
+      `has ${count.toLocaleString("en")} vertices; a building model takes at most ${tileflowModelLimits.vertices.toLocaleString("en")} a level. Merge vertices by distance and export it again`
+    );
+  let low = Infinity;
+  let high = -Infinity;
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    low = Math.min(low, positions[vertex * 3 + 2]);
+    high = Math.max(high, positions[vertex * 3 + 2]);
+  }
+  if (low < -0.5)
+    throw new TileflowGltfError(
+      `reaches ${(-low).toFixed(1)} m below its origin; put the origin on the ground where the building stands, with the building above it`
+    );
+  if (!(high > 0)) throw new TileflowGltfError("has no height above its origin");
+  const sums = new Array(count * 3).fill(0);
+  for (let at = 0; at + 2 < indices.length; at += 3) {
+    const [a, b, c] = [indices[at], indices[at + 1], indices[at + 2]];
+    const n = cross3(
+      sub3(point2(positions, b), point2(positions, a)),
+      sub3(point2(positions, c), point2(positions, a))
+    );
+    for (const vertex of [a, b, c])
+      for (let axis = 0; axis < 3; axis += 1) sums[vertex * 3 + axis] += n[axis];
+  }
+  const outNormals = [];
+  for (let vertex = 0; vertex < count; vertex += 1) {
+    const n = normals[vertex] ?? sums.slice(vertex * 3, vertex * 3 + 3);
+    const size = Math.hypot(n[0], n[1], n[2]) || 1;
+    outNormals.push(n[0] / size, n[1] / size, n[2] / size);
+  }
+  const shades = new Array(count).fill(0);
+  for (const part of new Set(parts)) {
+    const members = parts.flatMap((value, vertex) => value === part ? [vertex] : []);
+    const mean = members.reduce((sum, vertex) => sum + luminance2[vertex], 0) / members.length;
+    const spread = Math.max(0.06, mean * 0.6);
+    for (const vertex of members)
+      shades[vertex] = clamp2((luminance2[vertex] - mean) / spread, -1, 1);
+  }
+  const texels = typeof lightmapTexels === "function" ? lightmapTexels(surfaceArea(positions, indices)) : lightmapTexels;
+  const lightmap = ambientOcclusion && texels > 0 && surface && lightmapFits(surface) ? bakeBuildingModelLightmap({ positions, normals: outNormals, indices }, { texels }) : void 0;
+  if (!lightmap)
+    return {
+      positions,
+      normals: outNormals,
+      parts,
+      partNames,
+      lightingRoles,
+      shades,
+      ...surface ? { surface } : {},
+      occlusion: ambientOcclusion ? buildingModelAmbientVisibility({ positions, normals: outNormals, indices }) : new Array(count).fill(1),
+      indices
+    };
+  const { sources } = lightmap;
+  const from = (values, width = 1) => sources.flatMap((source) => values.slice(source * width, source * width + width));
+  const attributes = from([...surface.attributes], 8);
+  for (let vertex = 0; vertex < sources.length; vertex++) {
+    attributes[vertex * 8 + 2] = lightmap.uvs[vertex * 2];
+    attributes[vertex * 8 + 3] = lightmap.uvs[vertex * 2 + 1];
+  }
+  const texture = surface.textures.length;
+  return {
+    positions: from(positions, 3),
+    normals: from(outNormals, 3),
+    parts: from(parts),
+    partNames,
+    lightingRoles: from(lightingRoles),
+    shades: from(shades),
+    surface: {
+      ...surface,
+      attributes,
+      materials: surface.materials.map((material) => ({
+        ...material,
+        occlusionTexture: { texture, texCoord: 1 }
+      })),
+      textures: [
+        ...surface.textures,
+        {
+          mimeType: "image/jpeg",
+          bytes: encodeGreyJpeg(lightmap.texels, lightmap.width, lightmap.height, lightmapQuality),
+          width: lightmap.width,
+          height: lightmap.height,
+          wrapS: 33071,
+          wrapT: 33071,
+          minFilter: 9987,
+          magFilter: 9729
+        }
+      ]
+    },
+    occlusion: new Array(sources.length).fill(1),
+    indices: lightmap.indices
+  };
+}
+var lightmapQuality = 35;
+function surfaceArea(positions, indices) {
+  let area = 0;
+  for (let at = 0; at + 2 < indices.length; at += 3) {
+    const a = point2(positions, indices[at]);
+    area += Math.hypot(
+      ...cross3(
+        sub3(point2(positions, indices[at + 1]), a),
+        sub3(point2(positions, indices[at + 2]), a)
+      )
+    ) / 2;
+  }
+  return area;
+}
+function lightmapFits(surface) {
+  return surface.textures.length < tileflowModelSurfaceLimits2.textures && surface.materials.every(
+    (material) => !material.occlusionTexture && tileflowModelTextureChannels2.every((channel) => material[channel]?.texCoord !== 1)
+  );
+}
+function tileflowBuildingModelFootprint(mesh) {
+  const { positions, indices } = mesh;
+  let [minX, minY, maxX, maxY] = [Infinity, Infinity, -Infinity, -Infinity];
+  for (let at = 0; at < positions.length; at += 3) {
+    minX = Math.min(minX, positions[at]);
+    maxX = Math.max(maxX, positions[at]);
+    minY = Math.min(minY, positions[at + 1]);
+    maxY = Math.max(maxY, positions[at + 1]);
+  }
+  const cell = Math.max(1, Math.max(maxX - minX, maxY - minY) / 1024);
+  const columns = Math.ceil((maxX - minX) / cell) + 5;
+  const rows = Math.ceil((maxY - minY) / cell) + 5;
+  const x0 = minX - 2 * cell;
+  const y0 = minY - 2 * cell;
+  const filled = new Uint8Array(columns * rows);
+  for (let at = 0; at + 2 < indices.length; at += 3) {
+    const corners = [indices[at], indices[at + 1], indices[at + 2]].map((vertex) => [
+      (positions[vertex * 3] - x0) / cell,
+      (positions[vertex * 3 + 1] - y0) / cell
+    ]);
+    for (const [cx, cy] of corners) filled[Math.floor(cy) * columns + Math.floor(cx)] = 1;
+    const left = Math.max(0, Math.floor(Math.min(...corners.map((c2) => c2[0]))));
+    const right = Math.min(columns - 1, Math.ceil(Math.max(...corners.map((c2) => c2[0]))));
+    const top = Math.max(0, Math.floor(Math.min(...corners.map((c2) => c2[1]))));
+    const bottom = Math.min(rows - 1, Math.ceil(Math.max(...corners.map((c2) => c2[1]))));
+    const [a, b, c] = corners;
+    const area = edge(a, b, c);
+    if (Math.abs(area) < 1e-9) continue;
+    for (let y = top; y <= bottom; y += 1)
+      for (let x = left; x <= right; x += 1) {
+        const p = [x + 0.5, y + 0.5];
+        const w0 = edge(b, c, p) / area;
+        const w1 = edge(c, a, p) / area;
+        const w2 = edge(a, b, p) / area;
+        if (w0 >= 0 && w1 >= 0 && w2 >= 0) filled[y * columns + x] = 1;
+      }
+  }
+  const grown = new Uint8Array(filled);
+  for (let y = 1; y < rows - 1; y += 1)
+    for (let x = 1; x < columns - 1; x += 1) {
+      if (filled[y * columns + x]) continue;
+      for (let dy = -1; dy <= 1 && !grown[y * columns + x]; dy += 1)
+        for (let dx = -1; dx <= 1; dx += 1)
+          if (filled[(y + dy) * columns + x + dx]) {
+            grown[y * columns + x] = 1;
+            break;
+          }
+    }
+  const outside = new Uint8Array(columns * rows);
+  const stack = [0];
+  outside[0] = 1;
+  while (stack.length) {
+    const at = stack.pop();
+    const x = at % columns;
+    const y = (at - x) / columns;
+    for (const [dx, dy] of [
+      [1, 0],
+      [-1, 0],
+      [0, 1],
+      [0, -1]
+    ]) {
+      const nx = x + dx;
+      const ny = y + dy;
+      if (nx < 0 || ny < 0 || nx >= columns || ny >= rows) continue;
+      const next2 = ny * columns + nx;
+      if (outside[next2] || grown[next2]) continue;
+      outside[next2] = 1;
+      stack.push(next2);
+    }
+  }
+  const covered = (x, y) => x >= 0 && y >= 0 && x < columns && y < rows && !outside[y * columns + x];
+  const next = /* @__PURE__ */ new Map();
+  const add = (from, to) => {
+    const key = `${from[0]},${from[1]}`;
+    const list2 = next.get(key) ?? [];
+    list2.push(to);
+    next.set(key, list2);
+  };
+  for (let y = 0; y < rows; y += 1)
+    for (let x = 0; x < columns; x += 1) {
+      if (!covered(x, y)) continue;
+      if (!covered(x, y - 1)) add([x, y], [x + 1, y]);
+      if (!covered(x + 1, y)) add([x + 1, y], [x + 1, y + 1]);
+      if (!covered(x, y + 1)) add([x + 1, y + 1], [x, y + 1]);
+      if (!covered(x - 1, y)) add([x, y + 1], [x, y]);
+    }
+  const rings = [];
+  for (const [startKey, targets] of next) {
+    while (targets.length) {
+      const start = startKey.split(",").map(Number);
+      const ring = [start];
+      let current = targets.pop();
+      while (`${current[0]},${current[1]}` !== startKey) {
+        ring.push(current);
+        const outs = next.get(`${current[0]},${current[1]}`);
+        if (!outs?.length) break;
+        current = outs.pop();
+      }
+      const simplified = simplify(ring, 0.75);
+      if (simplified.length >= 3)
+        rings.push(simplified.flatMap(([x, y]) => [x0 + x * cell, y0 + y * cell]));
+    }
+  }
+  rings.sort((a, b) => Math.abs(ringArea(b)) - Math.abs(ringArea(a)));
+  const kept = [];
+  let points = 0;
+  for (const ring of rings) {
+    if (points + ring.length / 2 > tileflowModelLimits.footprintPoints) break;
+    kept.push(ring);
+    points += ring.length / 2;
+  }
+  return kept;
+}
+function isFootprint(primitive) {
+  return primitive.material?.trim().toLowerCase().replace(/\.\d+$/u, "") === "footprint";
+}
+function partOf2(material) {
+  const name = material?.trim().toLowerCase().replace(/\.\d+$/u, "");
+  return isTileflowModelPartName(name) ? name : void 0;
+}
+function simplify(ring, tolerance) {
+  if (ring.length <= 4) return [...ring];
+  let far = 0;
+  let distance = -1;
+  for (const [index, [x, y]] of ring.entries()) {
+    const d = Math.hypot(x - ring[0][0], y - ring[0][1]);
+    if (d > distance) {
+      distance = d;
+      far = index;
+    }
+  }
+  const half = (points) => {
+    if (points.length <= 2) return [...points];
+    const [a, b] = [points[0], points[points.length - 1]];
+    let index = 0;
+    let most = -1;
+    for (let at = 1; at < points.length - 1; at += 1) {
+      const d = segmentDistance(points[at], a, b);
+      if (d > most) {
+        most = d;
+        index = at;
+      }
+    }
+    if (most <= tolerance) return [a, b];
+    const left = half(points.slice(0, index + 1));
+    return [...left.slice(0, -1), ...half(points.slice(index))];
+  };
+  const first = half(ring.slice(0, far + 1));
+  const second = half([...ring.slice(far), ring[0]]);
+  return [...first.slice(0, -1), ...second.slice(0, -1)];
+}
+function segmentDistance(p, a, b) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const length = dx * dx + dy * dy;
+  const t = length > 0 ? clamp2(((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / length, 0, 1) : 0;
+  return Math.hypot(p[0] - (a[0] + t * dx), p[1] - (a[1] + t * dy));
+}
+function ringArea(ring) {
+  let area = 0;
+  for (let a = 0, b = ring.length - 2; a < ring.length; b = a, a += 2)
+    area += ring[b] * ring[a + 1] - ring[a] * ring[b + 1];
+  return area / 2;
+}
+function edge(a, b, p) {
+  return (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
+}
+function point2(list2, vertex) {
+  return [list2[vertex * 3], list2[vertex * 3 + 1], list2[vertex * 3 + 2]];
+}
+function sub3(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function cross3(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function clamp2(value, low, high) {
+  return Math.min(high, Math.max(low, value));
+}
+
+// src/tree-models.ts
+var TileflowTreeModelError = class extends Error {
+  code = "TREE_MODEL_INVALID";
+  issues;
+  phase = "tree-model-preparation";
+  constructor(issues) {
+    super(
+      [
+        "Invalid Tileflow tree models",
+        ...issues.map((issue) => `- ${issue.path}: ${issue.message}`)
+      ].join("\n")
+    );
+    this.name = "TileflowTreeModelError";
+    this.issues = issues;
+  }
+};
+var tileflowBuildingModelLimit = 64;
+async function prepareTileflowBuildingModel(id, levels) {
+  const model = buildingModelEntry(id, levels);
+  await MeshoptEncoder.ready;
+  const bytes = encodeTileflowModels([model], MeshoptEncoder);
+  return { bytes, sha256: sha256Of(bytes) };
+}
+async function packageTileflowLandmarkTile(landmarks) {
+  if (landmarks.length === 0) throw new RangeError("A landmark tile holds at least one landmark.");
+  if (new Set(landmarks.map((landmark) => landmark.id)).size !== landmarks.length)
+    throw new RangeError("Every landmark has an id of its own.");
+  let tile;
+  const models = [];
+  for (const landmark of [...landmarks].sort((a, b) => compareCodeUnits4(a.id, b.id))) {
+    if (!(landmark.heading >= 0 && landmark.heading < 360))
+      throw new RangeError(`Landmark ${landmark.id} is turned 0 to 360 degrees.`);
+    let own;
+    try {
+      own = tileflowLandmarkTileOf(landmark.at);
+    } catch {
+      throw new RangeError(`Landmark ${landmark.id} stands at no place on the map.`);
+    }
+    tile ??= own;
+    if (own[0] !== tile[0] || own[1] !== tile[1])
+      throw new RangeError(
+        `Landmark ${landmark.id} stands in tile ${own.join("/")}, not ${tile.join("/")}.`
+      );
+    let model;
+    try {
+      model = buildingModelEntry(landmark.id, landmark.levels);
+    } catch (error) {
+      throw new RangeError(`Landmark ${landmark.id}: ${error.message}`);
+    }
+    models.push({ ...model, at: [landmark.at[0], landmark.at[1]], heading: landmark.heading });
+  }
+  await MeshoptEncoder.ready;
+  const bytes = encodeTileflowModels(models, MeshoptEncoder);
+  const footprints = readTileflowLandmarkTileFootprints(bytes);
+  if (!footprints) throw new Error("The packaged landmark tile cannot be read back.");
+  return { x: tile[0], y: tile[1], bytes, sha256: sha256Of(bytes), landmarks: footprints };
+}
+function encodeTileflowLandmarkRegion(region) {
+  const bytes = serializeTileflowLandmarkRegion(region);
+  return { bytes, sha256: sha256Of(bytes) };
+}
+var nearLightmapTexels = (area) => Math.min(
+  524288,
+  Math.max(65536, Math.round(89 / 0.6 * area ** 0.54), Math.round(1.3 ** 2 * area / 0.6))
+);
+var buildingModelLightmapTexels = {
+  near: nearLightmapTexels,
+  mid: (area) => nearLightmapTexels(area) / 4
+};
+function buildingModelEntry(id, levels) {
+  const primitives = readTileflowGltfTriangles(levels.near, { materials: true });
+  if (isTileflowTreeModel(primitives))
+    throw new TileflowGltfError(
+      "is not a building model; its materials name only the parts of a tree (bark, leaves, fronds and stem)"
+    );
+  const meshes = [
+    prepareTileflowBuildingModelMesh(primitives, {
+      lightmapTexels: buildingModelLightmapTexels.near
+    })
+  ];
+  if (levels.mid)
+    meshes.push(
+      prepareTileflowBuildingModelMesh(levels.mid, {
+        lightmapTexels: buildingModelLightmapTexels.mid
+      })
+    );
+  if (levels.far) meshes.push(prepareTileflowBuildingModelMesh(levels.far));
+  return {
+    id,
+    levels: meshes,
+    footprint: tileflowBuildingModelFootprint(
+      tileflowBuildingModelDeclaredFootprint(primitives) ?? meshes[0]
+    )
+  };
+}
+function sha256Of(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+var fileLimit = 8 * 1024 * 1024;
+var modelId = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+async function prepareTileflowMapTreeModels(directories, options) {
+  const resolved = await resolveTileflowAssetDirectories(directories, {
+    baseDirectory: options.baseDirectory,
+    configPath: options.configPath,
+    cwd: options.cwd,
+    kind: "models",
+    target: options.target
+  });
+  const issues = [];
+  const files = /* @__PURE__ */ new Map();
+  for (const directory of resolved) {
+    let names;
+    try {
+      names = (await readdir2(directory.realPath)).sort();
+    } catch {
+      issues.push({ message: "is not a readable directory", path: directory.configPath });
+      continue;
+    }
+    for (const name of names) {
+      const display = `${directory.configPath}/${name}`;
+      const lower = name.toLowerCase();
+      if (lower.endsWith(".gltf")) {
+        issues.push({
+          message: "is a text glTF; export the model as a glTF binary (.glb)",
+          path: display
+        });
+        continue;
+      }
+      if (!lower.endsWith(".glb")) continue;
+      const level = name.endsWith(".far.glb") ? "far" : name.endsWith(".mid.glb") ? "mid" : "near";
+      const id = name.slice(0, name.length - (level === "near" ? 4 : 8));
+      if (!modelId.test(id) || id.length > 64) {
+        issues.push({
+          message: "a model's file name is its id: lowercase letters, digits and hyphens, up to 64, such as royal-palm.glb",
+          path: display
+        });
+        continue;
+      }
+      const path = join3(directory.realPath, name);
+      const info = await lstat3(path).catch(() => void 0);
+      if (!info?.isFile()) {
+        issues.push({ message: "is not a regular file", path: display });
+        continue;
+      }
+      if (info.size > fileLimit) {
+        issues.push({ message: "is larger than 8 MiB", path: display });
+        continue;
+      }
+      const entry = files.get(id) ?? {};
+      entry[level] = { path, display };
+      files.set(id, entry);
+    }
+  }
+  const models = {};
+  const buildings = {};
+  const identities = [];
+  for (const [id, entry] of [...files].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+    if (!entry.near) {
+      issues.push({ message: `has no ${id}.glb beside it`, path: (entry.mid ?? entry.far).display });
+      continue;
+    }
+    let nearBytes;
+    let primitives;
+    try {
+      nearBytes = new Uint8Array(await readFile(entry.near.path));
+      primitives = readTileflowGltfTriangles(nearBytes);
+    } catch (error) {
+      issues.push({
+        message: error instanceof TileflowGltfError ? error.message : "cannot be read",
+        path: entry.near.display
+      });
+      continue;
+    }
+    if (!isTileflowTreeModel(primitives)) {
+      const files2 = { near: nearBytes };
+      const sources = [];
+      let failing = entry.near;
+      try {
+        for (const level of ["near", "mid", "far"]) {
+          const file = entry[level];
+          if (!file) continue;
+          failing = file;
+          const bytes = level === "near" ? nearBytes : new Uint8Array(await readFile(file.path));
+          files2[level] = bytes;
+          if (level !== "near") prepareTileflowBuildingModelMesh(bytes, { ambientOcclusion: false });
+          const sha256 = createHash("sha256").update(bytes).digest("hex");
+          identities.push({ id, level, sha256 });
+          sources.push({ level, sha256, byteLength: bytes.byteLength });
+        }
+        failing = entry.near;
+        const prepared2 = await prepareTileflowBuildingModel(id, files2);
+        buildings[id] = {
+          fileName: tileflowModelFileName(id, prepared2.sha256),
+          bytes: prepared2.bytes,
+          sha256: prepared2.sha256,
+          sources
+        };
+      } catch (error) {
+        issues.push({
+          message: error instanceof TileflowGltfError || error instanceof RangeError ? error.message : "cannot be read",
+          path: failing.display
+        });
+      }
+      continue;
+    }
+    if (entry.mid) {
+      issues.push({
+        message: "is a tree model; trees have a near model and a far one (<id>.far.glb), not a mid one",
+        path: entry.mid.display
+      });
+      continue;
+    }
+    const prepared = {};
+    for (const level of ["near", "far"]) {
+      const file = entry[level];
+      if (!file) continue;
+      try {
+        const bytes = new Uint8Array(await readFile(file.path));
+        prepared[level] = encodeTileflowTreeModel(
+          prepareTileflowTreeModelMesh(bytes, level),
+          level
+        );
+        identities.push({ id, level, sha256: createHash("sha256").update(bytes).digest("hex") });
+      } catch (error) {
+        issues.push({
+          message: error instanceof TileflowGltfError || error instanceof RangeError ? error.message : "cannot be read",
+          path: file.display
+        });
+      }
+    }
+    if (prepared.near)
+      models[id] = { near: prepared.near, ...prepared.far ? { far: prepared.far } : {} };
+  }
+  if (Object.keys(models).length > tileflowTreeModelLimits2.models)
+    issues.push({
+      message: `holds ${Object.keys(models).length} tree models; a map takes at most ${tileflowTreeModelLimits2.models}`,
+      path: options.configPath
+    });
+  if (Object.keys(buildings).length > tileflowBuildingModelLimit)
+    issues.push({
+      message: `holds ${Object.keys(buildings).length} building models; a map takes at most ${tileflowBuildingModelLimit}`,
+      path: options.configPath
+    });
+  if (issues.length > 0) throw new TileflowTreeModelError(issues);
+  return {
+    models,
+    buildings,
+    identities,
+    watchPaths: resolved.filter((directory) => directory.watch).map((directory) => directory.realPath)
+  };
+}
+
+// src/icon-preview.ts
+import { renderTileflowIconAtlasPixels } from "@tileflow/core";
+async function renderTileflowIconAtlasPreview(source, index) {
+  if (!Object.values(index).some((entry) => entry.sdf)) return source;
+  const sharp = await loadSharp();
+  const { data, info } = await sharp(source, { limitInputPixels: 2048 * 2048 }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  const rendered = renderTileflowIconAtlasPixels(data, info.width, info.height, index);
+  return sharp(rendered, { raw: { width: info.width, height: info.height, channels: 4 } }).png().toBuffer();
+}
+
+// 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}`);
+    }
+    const appearances = Object.fromEntries(
+      composed.package.manifest.renderedIcons.flatMap(
+        (icon) => icon.appearance ? [[icon.name, icon.appearance]] : []
+      )
+    );
+    return [
+      {
+        iconIds: composed.package.manifest.iconNames,
+        ...Object.keys(appearances).length ? { appearances } : {},
+        label: request.mapName,
+        mapName: request.mapName,
+        packageHash: composed.package.contentHash
+      }
+    ];
+  });
+  return {
+    bindings,
+    compositions,
+    packages: [...packagesByHash.values()].sort(
+      (left, right) => compareCodeUnits5(left.contentHash, right.contentHash)
+    ),
+    sourceIdentities,
+    watchFiles: uniqueStrings(
+      result.mapRequests.flatMap(
+        (request) => result.composedBySequence.get(request.sequenceKey)?.watchFiles ?? []
+      )
+    ).sort(compareCodeUnits5),
+    watchPaths: uniqueStrings(
+      result.mapRequests.flatMap(
+        (request) => result.composedBySequence.get(request.sequenceKey)?.watchPaths ?? []
+      )
+    ).sort(compareCodeUnits5)
+  };
+}
+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,
+              ...manifestIcon.appearance ? { appearance: manifestIcon.appearance } : {},
+              ...manifestIcon.layout ? { layout: manifestIcon.layout } : {},
+              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) => compareCodeUnits5(
+      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(compareCodeUnits5).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,
+        ...binding.appearances ? { appearances: binding.appearances } : {}
+      }
+    };
+    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
+      });
+    }
+  }
+  const mapModelSources = {};
+  const modelWatchPaths = [];
+  for (const [mapName, map] of Object.entries(project.maps)) {
+    if (!map.models?.length) continue;
+    const models = await prepareTileflowMapTreeModels(map.models, {
+      baseDirectory: options.baseDirectory ?? options.cwd,
+      configPath: `maps.${mapName}.models`,
+      cwd: options.cwd,
+      target: "local"
+    });
+    const buildingModels = {};
+    for (const [id, model] of Object.entries(models.buildings)) {
+      const fileName = `models/${mapName}/${model.fileName}`;
+      assets.push({ contentType: tileflowModelContentType, fileName, source: model.bytes });
+      buildingModels[id] = joinUrl(options.assetBaseUrl, fileName);
+    }
+    mapAssets[mapName] = {
+      ...mapAssets[mapName],
+      models: models.models,
+      ...Object.keys(buildingModels).length > 0 ? { buildingModels } : {}
+    };
+    mapModelSources[mapName] = models.identities;
+    modelWatchPaths.push(...models.watchPaths);
+  }
+  return {
+    assets,
+    baseDirectory: await realpath3(options.baseDirectory ?? options.cwd),
+    cwd: await realpath3(options.cwd),
+    mapAssets,
+    mapIconCompositions,
+    mapIconSources,
+    ...Object.keys(mapModelSources).length > 0 ? { mapModelSources } : {},
+    project,
+    sourceProject: project,
+    watchFiles: compiled.watchFiles,
+    watchPaths: [...compiled.watchPaths, ...modelWatchPaths]
+  };
+}
+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(compareCodeUnits5);
+}
+function getMapIconRequests(project, mapNames) {
+  const selectedNames = (mapNames === void 0 ? Object.keys(project.maps) : [...new Set(mapNames)]).sort(compareCodeUnits5);
+  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: serializeCanonicalJson3(sources), sources };
+  });
+}
+function uniqueSequences(requests) {
+  return [...new Map(requests.map((request) => [request.sequenceKey, request])).values()].sort(
+    (left, right) => compareCodeUnits5(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 readdir3(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) => compareCodeUnits5(left.name, right.name));
+  const candidates = [];
+  const names = /* @__PURE__ */ new Set();
+  let metadata = {
+    schemaVersion: 1,
+    icons: {}
+  };
+  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 (entry.name === tileflowIconMetadataFileName) {
+      try {
+        if (entryStat.size > tileflowIconPackageLimits4.maxSourceFileBytes)
+          throw new Error("Icon metadata exceeds its byte limit");
+        metadata = tileflowIconAuthorMetadataSchema.parse(
+          parseTileflowIconJson2(
+            await readFile2(realEntryPath, "utf8"),
+            tileflowIconPackageLimits4.maxSourceFileBytes
+          )
+        );
+      } catch (error) {
+        issues.push({
+          path,
+          message: `Invalid icon metadata: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+      continue;
+    }
+    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) => compareCodeUnits5(left.name, right.name));
+  for (const id of Object.keys(metadata.icons)) {
+    if (!names.has(id))
+      issues.push({
+        path: `${directory.configPath}/${tileflowIconMetadataFileName}`,
+        message: `Icon metadata references unknown ID "${id}"`
+      });
+  }
+  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 readFile2(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);
+      }
+      const declared = metadata.icons[candidate.name];
+      icons.push({
+        ...declared?.representation === "sdf" ? { appearance: { representation: declared.representation, defaults: declared.defaults } } : {},
+        ...declared?.layout ? { layout: declared.layout } : {},
+        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`);
+  }
+  let rgba;
+  try {
+    if (icon.appearance && icon.kind === "pattern")
+      throw new Error("SDF metadata is only supported for icons, not patterns.");
+    if (icon.layout) {
+      if (icon.kind === "pattern")
+        throw new Error("Text-fitting metadata is only supported for icons, not patterns.");
+      assertTileflowIconLayoutBounds2(
+        icon.layout,
+        info.width / pixelRatio,
+        info.height / pixelRatio
+      );
+    }
+    rgba = icon.appearance ? createIconDistanceField(new Uint8Array(data), info.width, info.height, pixelRatio) : new Uint8Array(data);
+  } catch (error) {
+    throw new Error(
+      `${icon.displayPath}: ${error instanceof Error ? error.message : "Invalid icon capabilities"}`,
+      { cause: error }
+    );
+  }
+  const png = await sharp(rgba, {
+    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: icon.appearance || icon.layout ? await sha256Hex3(
+        `tileflow-icon-source-v2\0${await sha256Hex3(icon.source)}\0${serializeCanonicalJson3({ ...icon.appearance ? { appearance: icon.appearance } : {}, ...icon.layout ? { layout: icon.layout } : {} })}`
+      ) : 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 ${tileflowIconPackageLimits4.maxIconCount} 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,
+          ...rendered.input.appearance ? { appearance: rendered.input.appearance } : {},
+          ...rendered.input.layout ? { layout: rendered.input.layout } : {},
+          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,
+  prepareTileflowBuildingModel,
+  packageTileflowLandmarkTile,
+  encodeTileflowLandmarkRegion,
+  prepareTileflowMapTreeModels,
+  renderTileflowIconAtlasPreview,
+  TileflowIconCompilationError,
+  iconFileExtensions,
+  compileTileflowIconPackages,
+  inspectTileflowIconCatalogs,
+  prepareTileflowCatalogIcons,
+  getTileflowIconWatchPaths,
+  readTileflowIconDirectory
+};