@tileflow/dev 0.1.0-alpha.31 → 0.1.0-alpha.33

package/dist/{chunk-IR22ZTQW.js → chunk-QYU4OW5A.js}

@@ -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 as tileflowModelContentType2
 } from "@tileflow/core";
 
 // src/icon-composition.ts
@@ -940,14 +941,26 @@ 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,
+  hashTileflowModelBundleManifest,
+  serializeTileflowLandmarkRegion,
+  tileflowLandmarkTileOf,
+  tileflowModelBundleFileName,
+  tileflowModelBundleLimits,
+  tileflowModelContentType,
   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";
@@ -1243,6 +1256,287 @@ function vector(value, fallback) {
   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,
@@ -1257,7 +1551,7 @@ function prepareTileflowTreeModelMesh(bytes, level) {
   const luminance = [];
   const indices = [];
   for (const primitive of primitives) {
-    const part = partOf(primitive.material);
+    const part = partOf2(primitive.material);
     const offset = positions.length / 3;
     const count2 = primitive.positions.length / 3;
     positions.push(...primitive.positions);
@@ -1304,7 +1598,7 @@ function prepareTileflowTreeModelMesh(bytes, level) {
   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(sub(point(unit, b), point(unit, a)), sub(point(unit, c), point(unit, a)));
+    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];
   }
@@ -1321,7 +1615,7 @@ function prepareTileflowTreeModelMesh(bytes, level) {
     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);
+      shades[vertex] = clamp2((luminance[vertex] - mean) / spread, -1, 1);
   }
   let crownLow = 1;
   let crownHigh = 0;
@@ -1339,7 +1633,7 @@ function prepareTileflowTreeModelMesh(bytes, level) {
     }
     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));
+    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.
@@ -1352,7 +1646,7 @@ function prepareTileflowTreeModelMesh(bytes, level) {
     indices
   };
 }
-function partOf(material) {
+function partOf2(material) {
   const name = material?.trim().toLowerCase().replace(/\.\d+$/u, "");
   const part = tileflowTreeModelPartNames.find((candidate) => candidate === name);
   if (part) return tileflowTreeParts[part];
@@ -1363,20 +1657,20 @@ function partOf(material) {
 function isCrown(part) {
   return part === tileflowTreeParts.leaves || part === tileflowTreeParts.fronds;
 }
-function point(list, vertex) {
+function point2(list, vertex) {
   return [list[vertex * 3], list[vertex * 3 + 1], list[vertex * 3 + 2]];
 }
-function sub(a, b) {
+function sub2(a, b) {
   return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
 }
-function cross(a, b) {
+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 clamp(value, low, high) {
+function clamp2(value, low, high) {
   return Math.min(high, Math.max(low, value));
 }
 
@@ -1396,6 +1690,97 @@ var TileflowTreeModelError = class extends Error {
     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]
+    )
+  };
+}
+async function createTileflowModelBundle(buildings) {
+  const entries = Object.entries(buildings).sort(([a], [b]) => compareCodeUnits4(a, b));
+  if (entries.length === 0) return void 0;
+  const totalBytes = entries.reduce((total, [, model]) => total + model.bytes.byteLength, 0);
+  if (totalBytes > tileflowModelBundleLimits.maxPackageBytes)
+    throw new RangeError(
+      `The map's building models together are ${totalBytes} bytes once prepared; a hosted map takes at most ${tileflowModelBundleLimits.maxPackageBytes}. Simplify or remove models.`
+    );
+  const manifest = {
+    format: "tileflow-model-bundle-v1",
+    models: entries.map(([id, model]) => ({
+      byteLength: model.bytes.byteLength,
+      contentType: tileflowModelContentType,
+      file: model.fileName,
+      id,
+      sha256: model.sha256
+    }))
+  };
+  return {
+    contentHash: await hashTileflowModelBundleManifest(manifest),
+    manifest,
+    files: entries.map(([, model]) => ({
+      contentType: tileflowModelContentType,
+      fileName: model.fileName,
+      source: model.bytes
+    }))
+  };
+}
+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) {
@@ -1427,8 +1812,8 @@ async function prepareTileflowMapTreeModels(directories, options) {
         continue;
       }
       if (!lower.endsWith(".glb")) continue;
-      const far = name.endsWith(".far.glb");
-      const id = name.slice(0, name.length - (far ? 8 : 4));
+      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",
@@ -1447,15 +1832,63 @@ async function prepareTileflowMapTreeModels(directories, options) {
         continue;
       }
       const entry = files.get(id) ?? {};
-      entry[far ? "far" : "near"] = { path, display };
+      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.far.display });
+      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: tileflowModelBundleFileName(id, prepared2.sha256),
+          bytes: prepared2.bytes,
+          sha256: prepared2.sha256
+        };
+      } 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 = {};
@@ -1481,12 +1914,18 @@ async function prepareTileflowMapTreeModels(directories, options) {
   }
   if (Object.keys(models).length > tileflowTreeModelLimits2.models)
     issues.push({
-      message: `holds ${Object.keys(models).length} models; a map takes at most ${tileflowTreeModelLimits2.models}`,
+      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)
   };
@@ -1558,19 +1997,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) {
@@ -1663,7 +2102,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")
     )
@@ -1715,7 +2154,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) {
@@ -1773,7 +2212,17 @@ async function prepareTileflowCatalogIcons(project, options) {
       cwd: options.cwd,
       target: "local"
     });
-    mapAssets[mapName] = { ...mapAssets[mapName], models: models.models };
+    const buildingModels = {};
+    for (const [id, model] of Object.entries(models.buildings)) {
+      const fileName = `models/${mapName}/${model.fileName}`;
+      assets.push({ contentType: tileflowModelContentType2, 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);
   }
@@ -1814,10 +2263,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}`);
@@ -1827,7 +2276,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) {
@@ -1888,7 +2337,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 = {
@@ -1976,7 +2425,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({
@@ -2381,6 +2830,11 @@ export {
   readTileflowIconsLockfile,
   writeTileflowIconsLockfile,
   composeTileflowIconSources,
+  prepareTileflowBuildingModel,
+  packageTileflowLandmarkTile,
+  encodeTileflowLandmarkRegion,
+  createTileflowModelBundle,
+  prepareTileflowMapTreeModels,
   renderTileflowIconAtlasPreview,
   TileflowIconCompilationError,
   iconFileExtensions,