@tileflow/dev 0.1.0-alpha.30 → 0.1.0-alpha.32

package/dist/{chunk-A2VTI43Y.js → chunk-F4PLTZS4.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-7C4F6GAX.js";
 
 // src/icons.ts
-import { readdir as readdir2, readFile, realpath as realpath3, stat } from "fs/promises";
+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 {
@@ -17,14 +17,15 @@ import {
   tileflowIconSpriteIndexSchema
 } from "@tileflow/core";
 import {
-  compareCodeUnits as compareCodeUnits4,
+  compareCodeUnits as compareCodeUnits5,
   hashTileflowRenderedIconPixels as hashTileflowRenderedIconPixels3,
   parseResolvedTileflowMap,
   parseTileflowIconJson as parseTileflowIconJson2,
   serializeCanonicalJson as serializeCanonicalJson3,
   sha256Hex as sha256Hex3,
   tileflowIconIdPattern,
-  tileflowIconPackageLimits as tileflowIconPackageLimits4
+  tileflowIconPackageLimits as tileflowIconPackageLimits4,
+  tileflowModelContentType
 } from "@tileflow/core";
 
 // src/icon-composition.ts
@@ -849,7 +850,7 @@ async function composeTileflowIconSources(input, options) {
       source: winner.source
     }))
   };
-  function addWinner(ordinal, icon, identity, 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)
@@ -857,7 +858,7 @@ async function composeTileflowIconSources(input, options) {
         "ICON_COMPOSITION_INVALID",
         "Composed rendered cells exceed the final sprite capacity"
       );
-    winners.set(icon.id, { ordinal, icon, identity, source });
+    winners.set(icon.id, { ordinal, icon, identity: identity2, source });
   }
 }
 function isPathInside(root, candidate) {
@@ -939,6 +940,964 @@ function transform(grid, width, height) {
   }
 }
 
+// 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,
+  serializeTileflowLandmarkRegion,
+  tileflowLandmarkTileOf,
+  tileflowTreeModelLimits as tileflowTreeModelLimits2
+} from "@tileflow/core";
+
+// src/building-model-mesh.ts
+import { tileflowModelLimits, tileflowModelParts } from "@tileflow/core";
+
+// 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) {
+  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 (record(buffer).uri !== void 0)
+      throw new TileflowGltfError("keeps its geometry in another file; export a single .glb");
+  const nodes = array(json.nodes).map(record);
+  const scenes = array(json.scenes).map(record);
+  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 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 (typeof node.mesh === "number") out.push(...meshOf(json, bin, node.mesh, world));
+    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");
+  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 = record(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) {
+  const mesh = record(array(json.meshes)[index]);
+  const normalMatrix = inverseTranspose(world);
+  return array(mesh.primitives).map((value) => {
+    const primitive = record(value);
+    if ((primitive.mode ?? triangles) !== triangles)
+      throw new TileflowGltfError("draws points or lines; a tree model draws triangles");
+    const attributes = record(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" ? record(array(json.materials)[primitive.material]) : void 0;
+    const base = array(record(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,
+      positions,
+      normals,
+      colours,
+      indices
+    };
+  });
+}
+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 = record(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 = record(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 record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+function vector(value, fallback) {
+  const list = array(value).map(Number);
+  return list.length === fallback.length && list.every(Number.isFinite) ? list : fallback;
+}
+
+// src/building-model-mesh.ts
+var tileflowBuildingModelPartNames = Object.keys(tileflowModelParts);
+function isTileflowBuildingModel(primitives) {
+  const drawn = primitives.filter((primitive) => !isFootprint(primitive));
+  return drawn.length > 0 && drawn.every((primitive) => partOf(primitive.material) !== void 0);
+}
+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) {
+  const primitives = bytes instanceof Uint8Array ? readTileflowGltfTriangles(bytes) : bytes;
+  const positions = [];
+  const normals = [];
+  const parts = [];
+  const luminance = [];
+  const indices = [];
+  for (const primitive of primitives) {
+    if (isFootprint(primitive)) continue;
+    const part = partOf(primitive.material);
+    if (part === void 0)
+      throw new TileflowGltfError(
+        primitive.material === void 0 ? "has a mesh without a material; name each material surface, secondary, glass, accent or roof" : `has a material "${primitive.material}" that names no part of a building; name each material surface, secondary, glass, accent or roof`
+      );
+    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);
+      luminance.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 = cross(
+      sub(point(positions, b), point(positions, a)),
+      sub(point(positions, c), point(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 + luminance[vertex], 0) / members.length;
+    const spread = Math.max(0.06, mean * 0.6);
+    for (const vertex of members)
+      shades[vertex] = clamp((luminance[vertex] - mean) / spread, -1, 1);
+  }
+  return {
+    positions,
+    normals: outNormals,
+    parts,
+    shades,
+    occlusion: new Array(count).fill(1),
+    indices
+  };
+}
+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 list = next.get(key) ?? [];
+    list.push(to);
+    next.set(key, list);
+  };
+  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 partOf(material) {
+  const name = material?.trim().toLowerCase().replace(/\.\d+$/u, "");
+  const part = tileflowBuildingModelPartNames.find((candidate) => candidate === name);
+  return part === void 0 ? void 0 : tileflowModelParts[part];
+}
+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 ? clamp(((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 point(list, vertex) {
+  return [list[vertex * 3], list[vertex * 3 + 1], list[vertex * 3 + 2]];
+}
+function sub(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/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 luminance = [];
+  const indices = [];
+  for (const primitive of primitives) {
+    const part = partOf2(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);
+      luminance.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 = cross2(sub2(point2(unit, b), point2(unit, a)), sub2(point2(unit, c), point2(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 + luminance[vertex], 0) / members.length;
+    const spread = Math.max(0.06, mean * 0.6);
+    for (const vertex of members)
+      shades[vertex] = clamp2((luminance[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(clamp2(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 partOf2(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 point2(list, vertex) {
+  return [list[vertex * 3], list[vertex * 3 + 1], list[vertex * 3 + 2]];
+}
+function sub2(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function cross2(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);
+  return { x: tile[0], y: tile[1], bytes, sha256: sha256Of(bytes) };
+}
+function encodeTileflowLandmarkRegion(region) {
+  const bytes = serializeTileflowLandmarkRegion(region);
+  return { bytes, sha256: sha256Of(bytes) };
+}
+function buildingModelEntry(id, levels) {
+  const primitives = readTileflowGltfTriangles(levels.near);
+  if (!isTileflowBuildingModel(primitives))
+    throw new TileflowGltfError(
+      "is not a building model; name each material surface, secondary, glass, accent or roof"
+    );
+  const meshes = [prepareTileflowBuildingModelMesh(primitives)];
+  for (const level of [levels.mid, levels.far])
+    if (level) meshes.push(prepareTileflowBuildingModelMesh(level));
+  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 (isTileflowBuildingModel(primitives)) {
+      const files2 = { near: nearBytes };
+      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);
+          identities.push({ id, level, sha256: createHash("sha256").update(bytes).digest("hex") });
+        }
+        failing = entry.near;
+        const prepared2 = await prepareTileflowBuildingModel(id, files2);
+        buildings[id] = {
+          fileName: `${id}-${prepared2.sha256.slice(0, 16)}.glb`,
+          bytes: prepared2.bytes
+        };
+      } 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) {
@@ -1005,19 +1964,19 @@ async function compileTileflowIconPackages(project, options) {
     bindings,
     compositions,
     packages: [...packagesByHash.values()].sort(
-      (left, right) => compareCodeUnits4(left.contentHash, right.contentHash)
+      (left, right) => compareCodeUnits5(left.contentHash, right.contentHash)
     ),
     sourceIdentities,
     watchFiles: uniqueStrings(
       result.mapRequests.flatMap(
         (request) => result.composedBySequence.get(request.sequenceKey)?.watchFiles ?? []
       )
-    ).sort(compareCodeUnits4),
+    ).sort(compareCodeUnits5),
     watchPaths: uniqueStrings(
       result.mapRequests.flatMap(
         (request) => result.composedBySequence.get(request.sequenceKey)?.watchPaths ?? []
       )
-    ).sort(compareCodeUnits4)
+    ).sort(compareCodeUnits5)
   };
 }
 async function inspectTileflowIconCatalogs(project, options) {
@@ -1110,7 +2069,7 @@ async function inspectTileflowIconCatalogs(project, options) {
     )
   );
   catalogs.sort(
-    (left, right) => compareCodeUnits4(
+    (left, right) => compareCodeUnits5(
       left.contributors.map((contributor) => contributor.label).join("\0"),
       right.contributors.map((contributor) => contributor.label).join("\0")
     )
@@ -1162,7 +2121,7 @@ async function readWorkspaceIconSetLock(requests, baseDirectory) {
       references.add(reference);
   }
   if (references.size === 0) return void 0;
-  const sources = [...references].sort(compareCodeUnits4).map((reference) => ({ kind: "icon-set", reference }));
+  const sources = [...references].sort(compareCodeUnits5).map((reference) => ({ kind: "icon-set", reference }));
   return readTileflowIconsLockfile(baseDirectory, sources);
 }
 function selectMapIconSetLock(lock, sources) {
@@ -1210,6 +2169,30 @@ async function prepareTileflowCatalogIcons(project, options) {
       });
     }
   }
+  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),
@@ -1217,10 +2200,11 @@ async function prepareTileflowCatalogIcons(project, options) {
     mapAssets,
     mapIconCompositions,
     mapIconSources,
+    ...Object.keys(mapModelSources).length > 0 ? { mapModelSources } : {},
     project,
     sourceProject: project,
     watchFiles: compiled.watchFiles,
-    watchPaths: compiled.watchPaths
+    watchPaths: [...compiled.watchPaths, ...modelWatchPaths]
   };
 }
 async function getTileflowIconWatchPaths(project, cwd, baseDirectory = cwd) {
@@ -1246,10 +2230,10 @@ async function getTileflowIconWatchPaths(project, cwd, baseDirectory = cwd) {
       }
     }
   }
-  return [...paths].sort(compareCodeUnits4);
+  return [...paths].sort(compareCodeUnits5);
 }
 function getMapIconRequests(project, mapNames) {
-  const selectedNames = (mapNames === void 0 ? Object.keys(project.maps) : [...new Set(mapNames)]).sort(compareCodeUnits4);
+  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}`);
@@ -1259,7 +2243,7 @@ function getMapIconRequests(project, mapNames) {
 }
 function uniqueSequences(requests) {
   return [...new Map(requests.map((request) => [request.sequenceKey, request])).values()].sort(
-    (left, right) => compareCodeUnits4(left.sequenceKey, right.sequenceKey)
+    (left, right) => compareCodeUnits5(left.sequenceKey, right.sequenceKey)
   );
 }
 function describeComposedContributor(contributor) {
@@ -1312,7 +2296,7 @@ async function inspectIconSource(directory, target, issues) {
   let entries;
   const issueCount = issues.length;
   try {
-    entries = await readdir2(directory.realPath, { withFileTypes: true });
+    entries = await readdir3(directory.realPath, { withFileTypes: true });
   } catch (error) {
     issues.push({
       message: describeFileSystemError(error, "Icon source could not be read"),
@@ -1320,7 +2304,7 @@ async function inspectIconSource(directory, target, issues) {
     });
     return null;
   }
-  entries.sort((left, right) => compareCodeUnits4(left.name, right.name));
+  entries.sort((left, right) => compareCodeUnits5(left.name, right.name));
   const candidates = [];
   const names = /* @__PURE__ */ new Set();
   let metadata = {
@@ -1360,7 +2344,7 @@ async function inspectIconSource(directory, target, issues) {
           throw new Error("Icon metadata exceeds its byte limit");
         metadata = tileflowIconAuthorMetadataSchema.parse(
           parseTileflowIconJson2(
-            await readFile(realEntryPath, "utf8"),
+            await readFile2(realEntryPath, "utf8"),
             tileflowIconPackageLimits4.maxSourceFileBytes
           )
         );
@@ -1408,7 +2392,7 @@ async function inspectIconSource(directory, target, issues) {
       size: entryStat.size
     });
   }
-  candidates.sort((left, right) => compareCodeUnits4(left.name, right.name));
+  candidates.sort((left, right) => compareCodeUnits5(left.name, right.name));
   for (const id of Object.keys(metadata.icons)) {
     if (!names.has(id))
       issues.push({
@@ -1429,7 +2413,7 @@ async function inspectIconSource(directory, target, issues) {
   for (const candidate of candidates) {
     const displayPath = candidate.displayPath;
     try {
-      const source = await readFile(candidate.path);
+      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");
       }
@@ -1813,6 +2797,10 @@ export {
   readTileflowIconsLockfile,
   writeTileflowIconsLockfile,
   composeTileflowIconSources,
+  prepareTileflowBuildingModel,
+  packageTileflowLandmarkTile,
+  encodeTileflowLandmarkRegion,
+  prepareTileflowMapTreeModels,
   renderTileflowIconAtlasPreview,
   TileflowIconCompilationError,
   iconFileExtensions,