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

package/dist/{chunk-F4PLTZS4.js → chunk-5RT4CHSK.js}

@@ -949,13 +949,384 @@ import {
   compareCodeUnits as compareCodeUnits4,
   encodeTileflowModels,
   encodeTileflowTreeModel,
+  readTileflowLandmarkTileFootprints,
   serializeTileflowLandmarkRegion,
   tileflowLandmarkTileOf,
+  tileflowModelFileName,
   tileflowTreeModelLimits as tileflowTreeModelLimits2
 } from "@tileflow/core";
 
 // src/building-model-mesh.ts
-import { tileflowModelLimits, tileflowModelParts } from "@tileflow/core";
+import {
+  tileflowModelDefaultLightingRoles,
+  tileflowModelLightingRoles,
+  tileflowModelLimits,
+  tileflowModelParts
+} from "@tileflow/core";
+
+// 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/building-model-occlusion.ts
+function buildingModelAmbientVisibility(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, normals, 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;
+  };
+  build(0, count);
+  const hemisphere = Array.from({ length: samples }, (_, i) => {
+    const r = Math.sqrt((i + 0.5) / samples), angle = i * Math.PI * (3 - Math.sqrt(5));
+    return [r * Math.cos(angle), r * Math.sin(angle), Math.sqrt(1 - r * r)];
+  });
+  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;
+    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;
+  };
+  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 nx = normals[at], ny = normals[at + 1], nz = normals[at + 2];
+    const point3 = [positions[at], positions[at + 1], positions[at + 2]];
+    const key = [...point3, nx, ny, nz].map((v) => Math.round(v * 1e5)).join(",");
+    const cached = cache.get(key);
+    if (cached !== void 0) {
+      values[vertex] = cached;
+      continue;
+    }
+    const tangent = Math.abs(nz) < 0.9 ? [-ny, nx, 0] : [nz, 0, -nx];
+    const length = Math.hypot(...tangent);
+    if (length === 0) {
+      values[vertex] = 1;
+      continue;
+    }
+    for (let axis = 0; axis < 3; axis += 1) {
+      tangent[axis] /= length;
+      origin[axis] = point3[axis] + normals[at + axis] * bias;
+    }
+    const bitangent = [
+      ny * tangent[2] - nz * tangent[1],
+      nz * tangent[0] - nx * tangent[2],
+      nx * tangent[1] - ny * tangent[0]
+    ];
+    let visibility = 0;
+    for (const sample of hemisphere) {
+      for (let axis = 0; axis < 3; axis += 1)
+        direction[axis] = sample[0] * tangent[axis] + sample[1] * bitangent[axis] + sample[2] * normals[at + axis];
+      visibility += nearest() / radius;
+    }
+    values[vertex] = visibility / samples;
+    cache.set(key, values[vertex]);
+  }
+  return values;
+}
+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/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]);
+    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 {
@@ -980,7 +1351,7 @@ var componentBytes = {
   5126: 4
 };
 var typeSizes = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4 };
-function readTileflowGltfTriangles(bytes) {
+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));
@@ -989,24 +1360,57 @@ function readTileflowGltfTriangles(bytes) {
       `uses compressed geometry (${String(compressed)}); export it without compression`
     );
   for (const buffer of array(json.buffers))
-    if (record(buffer).uri !== void 0)
+    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(record);
-  const scenes = array(json.scenes).map(record);
+  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 (typeof node.mesh === "number") out.push(...meshOf(json, bin, node.mesh, world));
+    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) {
@@ -1027,7 +1431,7 @@ function chunks(bytes) {
     const body = bytes.subarray(start, start + length);
     if (type === jsonChunk && json === void 0) {
       try {
-        json = record(JSON.parse(new TextDecoder().decode(body)));
+        json = record2(JSON.parse(new TextDecoder().decode(body)));
       } catch {
         throw new TileflowGltfError("has an unreadable JSON chunk");
       }
@@ -1037,14 +1441,14 @@ function chunks(bytes) {
   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]);
+function meshOf(json, bin, index, world, physical) {
+  const mesh = record2(array(json.meshes)[index]);
   const normalMatrix = inverseTranspose(world);
-  return array(mesh.primitives).map((value) => {
-    const primitive = record(value);
+  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 = record(primitive.attributes);
+    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);
@@ -1076,8 +1480,8 @@ function meshOf(json, bin, index, world) {
         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 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;
@@ -1094,12 +1498,37 @@ function meshOf(json, bin, index, world) {
         [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
+      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);
@@ -1108,7 +1537,7 @@ function accessor(json, bin, index, size) {
   return read.values;
 }
 function accessorWithSize(json, bin, index) {
-  const accessor2 = record(array(json.accessors)[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)];
@@ -1119,7 +1548,7 @@ function accessorWithSize(json, bin, index) {
     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]);
+  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;
@@ -1241,15 +1670,15 @@ function inverseTranspose(m) {
     1
   ];
 }
-function record(value) {
+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 list = array(value).map(Number);
-  return list.length === fallback.length && list.every(Number.isFinite) ? list : fallback;
+  const list2 = array(value).map(Number);
+  return list2.length === fallback.length && list2.every(Number.isFinite) ? list2 : fallback;
 }
 
 // src/building-model-mesh.ts
@@ -1269,25 +1698,33 @@ function tileflowBuildingModelDeclaredFootprint(primitives) {
   }
   return indices.length > 0 ? { positions, indices } : void 0;
 }
-function prepareTileflowBuildingModelMesh(bytes) {
-  const primitives = bytes instanceof Uint8Array ? readTileflowGltfTriangles(bytes) : bytes;
+function prepareTileflowBuildingModelMesh(bytes, { ambientOcclusion = true } = {}) {
+  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 parts = [];
+  const lightingRoles = [];
   const luminance = [];
   const indices = [];
-  for (const primitive of primitives) {
-    if (isFootprint(primitive)) continue;
+  for (const primitive of drawn) {
     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 role = primitive.lightingRole === void 0 ? tileflowModelDefaultLightingRoles[part] : 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);
       luminance.push(0.2126 * r + 0.7152 * g + 0.0722 * b);
@@ -1343,8 +1780,10 @@ function prepareTileflowBuildingModelMesh(bytes) {
     positions,
     normals: outNormals,
     parts,
+    lightingRoles,
     shades,
-    occlusion: new Array(count).fill(1),
+    ...surface ? { surface } : {},
+    occlusion: ambientOcclusion ? buildingModelAmbientVisibility({ positions, normals: outNormals, indices }) : new Array(count).fill(1),
     indices
   };
 }
@@ -1422,9 +1861,9 @@ function tileflowBuildingModelFootprint(mesh) {
   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);
+    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) {
@@ -1516,8 +1955,8 @@ function ringArea(ring) {
 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 point(list2, vertex) {
+  return [list2[vertex * 3], list2[vertex * 3 + 1], list2[vertex * 3 + 2]];
 }
 function sub(a, b) {
   return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
@@ -1653,8 +2092,8 @@ function partOf2(material) {
 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 point2(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]];
@@ -1723,14 +2162,16 @@ async function packageTileflowLandmarkTile(landmarks) {
   }
   await MeshoptEncoder.ready;
   const bytes = encodeTileflowModels(models, MeshoptEncoder);
-  return { x: tile[0], y: tile[1], bytes, sha256: sha256Of(bytes) };
+  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) };
 }
 function buildingModelEntry(id, levels) {
-  const primitives = readTileflowGltfTriangles(levels.near);
+  const primitives = readTileflowGltfTriangles(levels.near, { materials: true });
   if (!isTileflowBuildingModel(primitives))
     throw new TileflowGltfError(
       "is not a building model; name each material surface, secondary, glass, accent or roof"
@@ -1826,6 +2267,7 @@ async function prepareTileflowMapTreeModels(directories, options) {
     }
     if (isTileflowBuildingModel(primitives)) {
       const files2 = { near: nearBytes };
+      const sources = [];
       let failing = entry.near;
       try {
         for (const level of ["near", "mid", "far"]) {
@@ -1834,14 +2276,18 @@ async function prepareTileflowMapTreeModels(directories, options) {
           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") });
+          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: `${id}-${prepared2.sha256.slice(0, 16)}.glb`,
-          bytes: prepared2.bytes
+          fileName: tileflowModelFileName(id, prepared2.sha256),
+          bytes: prepared2.bytes,
+          sha256: prepared2.sha256,
+          sources
         };
       } catch (error) {
         issues.push({