sindicate 0.16.0 → 0.17.0

package/tools/unitySceneToBuildings.mjs

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+// UNITY SCENE → BUILDINGS. Mine a pack's own demo scene for the things its artists built.
+//
+//   node tools/unitySceneToBuildings.mjs <Scene.unity> <metaDir> <outDir> [--prefix SM_Bld]
+//
+// A Synty building is not a model, it is a STACK: a floor module, corner pieces, a door
+// module, more floors above, a roof, roof corners, a fire escape up the back. Place one
+// module on its own and you get a building with half its walls missing, which is exactly
+// what happens if you read the pack as a list of meshes. The pack ships no assembled
+// buildings — but its demo scene is full of them, built by the people who made the parts.
+//
+// So this reads the scene, composes every instance's transform up its parent chain, groups
+// the building modules into the structures they form, and writes each one out as an assembly
+// in the same shape as the road pieces: a list of parts with local transforms.
+//
+// THE PARENT CHAIN IS THE WHOLE JOB. A scene is a flat list of PrefabInstances, each with a
+// LOCAL transform and an `m_TransformParent` pointing at a stripped Transform, which in turn
+// names the PrefabInstance that owns it. Read the local positions alone — as a first pass at
+// this did — and a whole tower's worth of modules land on the same square metre.
+import fs from 'node:fs';
+import path from 'node:path';
+
+const args = process.argv.slice(2);
+const [scene, metaDir, outDir] = args.filter((a) => !a.startsWith('--'));
+const prefix = (args.find((a) => a.startsWith('--prefix')) ?? '--prefix=SM_Bld').split('=')[1] ?? 'SM_Bld';
+const modelsDir = (args.find((a) => a.startsWith('--models')) ?? '--models=').split('=')[1];
+const touch = +((args.find((a) => a.startsWith('--touch')) ?? '--touch=0.6').split('=')[1]);
+if (!scene || !metaDir || !outDir || !modelsDir) {
+  console.error('usage: unitySceneToBuildings.mjs <Scene.unity> <metaDir> <outDir> --models=<glbDir> [--prefix=SM_Bld] [--touch=0.6]');
+  process.exit(1);
+}
+
+// ── guid → prefab name, from the .meta files that travel with each asset ──
+const byGuid = new Map();
+for (const f of fs.readdirSync(metaDir)) {
+  if (!f.endsWith('.prefab.meta')) continue;
+  const g = /^guid: (\w+)/m.exec(fs.readFileSync(path.join(metaDir, f), 'utf8'));
+  if (g) byGuid.set(g[1], f.slice(0, -12));
+}
+
+// ── the scene ──
+const text = fs.readFileSync(scene, 'utf8');
+const docs = text.split(/^--- !u!(\d+) &(\d+)( stripped)?$/m);
+const instances = new Map();          // fileID → { name, parent, pos, quat, scale }
+const transformOwner = new Map();     // stripped Transform fileID → PrefabInstance fileID
+
+for (let i = 1; i < docs.length; i += 4) {
+  const cls = docs[i], id = docs[i + 1], body = docs[i + 3];
+  if (cls === '4' && docs[i + 2]) {
+    const owner = /m_PrefabInstance: \{fileID: (\d+)\}/.exec(body);
+    if (owner) transformOwner.set(id, owner[1]);
+    continue;
+  }
+  if (cls !== '1001') continue;
+  const guid = /m_SourcePrefab: \{fileID: \d+, guid: (\w+)/.exec(body);
+  const name = guid ? byGuid.get(guid[1]) : null;
+  const parent = /m_TransformParent: \{fileID: (\d+)\}/.exec(body);
+  const num = (p) => {
+    const m = new RegExp(`propertyPath: ${p}\\n\\s+value: ([-\\d.eE+]+)`).exec(body);
+    return m ? +m[1] : null;
+  };
+  instances.set(id, {
+    id, name,
+    parent: parent && parent[1] !== '0' ? parent[1] : null,
+    pos: [num('m_LocalPosition\\.x') ?? 0, num('m_LocalPosition\\.y') ?? 0, num('m_LocalPosition\\.z') ?? 0],
+    quat: [num('m_LocalRotation\\.x') ?? 0, num('m_LocalRotation\\.y') ?? 0, num('m_LocalRotation\\.z') ?? 0, num('m_LocalRotation\\.w') ?? 1],
+    scale: [num('m_LocalScale\\.x') ?? 1, num('m_LocalScale\\.y') ?? 1, num('m_LocalScale\\.z') ?? 1],
+  });
+}
+
+// ── compose each instance's transform up its chain ──
+const qmul = (a, b) => [
+  a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
+  a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0],
+  a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3],
+  a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2],
+];
+const qrot = (q, v) => {
+  const [x, y, z, w] = q, [vx, vy, vz] = v;
+  const ix = w * vx + y * vz - z * vy, iy = w * vy + z * vx - x * vz;
+  const iz = w * vz + x * vy - y * vx, iw = -x * vx - y * vy - z * vz;
+  return [
+    ix * w + iw * -x + iy * -z - iz * -y,
+    iy * w + iw * -y + iz * -x - ix * -z,
+    iz * w + iw * -z + ix * -y - iy * -x,
+  ];
+};
+
+const world = new Map();
+const resolve = (id, seen = new Set()) => {
+  if (world.has(id)) return world.get(id);
+  const it = instances.get(id);
+  if (!it || seen.has(id)) return null;
+  seen.add(id);
+  const parentInst = it.parent ? transformOwner.get(it.parent) : null;
+  const p = parentInst ? resolve(parentInst, seen) : null;
+  const out = p
+    ? {
+        pos: (() => {
+          const s = [it.pos[0] * p.scale[0], it.pos[1] * p.scale[1], it.pos[2] * p.scale[2]];
+          const r = qrot(p.quat, s);
+          return [p.pos[0] + r[0], p.pos[1] + r[1], p.pos[2] + r[2]];
+        })(),
+        quat: qmul(p.quat, it.quat),
+        scale: [it.scale[0] * p.scale[0], it.scale[1] * p.scale[1], it.scale[2] * p.scale[2]],
+      }
+    : { pos: it.pos, quat: it.quat, scale: it.scale };
+  world.set(id, out);
+  return out;
+};
+
+const parts = [];
+for (const [id, it] of instances) {
+  if (!it.name?.startsWith(prefix)) continue;
+  const w = resolve(id);
+  if (w) parts.push({ name: it.name, ...w });
+}
+
+// ── what each module actually occupies ──
+// The grouping below needs real extents, so measure the baked GLB and put its eight corners
+// through the module's own transform.
+const bboxCache = new Map();
+function localBox(file) {
+  if (bboxCache.has(file)) return bboxCache.get(file);
+  let out = null;
+  try {
+    const buf = fs.readFileSync(path.join(modelsDir, file));
+    const gltf = JSON.parse(buf.slice(20, 20 + buf.readUInt32LE(12)).toString('utf8'));
+    const mn = [Infinity, Infinity, Infinity], mx = [-Infinity, -Infinity, -Infinity];
+    for (const mesh of gltf.meshes ?? []) for (const prim of mesh.primitives ?? []) {
+      const acc = gltf.accessors[prim.attributes.POSITION];
+      if (!acc?.min) continue;
+      for (let d = 0; d < 3; d++) { mn[d] = Math.min(mn[d], acc.min[d]); mx[d] = Math.max(mx[d], acc.max[d]); }
+    }
+    if (Number.isFinite(mn[0])) out = { mn, mx };
+  } catch { /* a module we never baked has no box */ }
+  bboxCache.set(file, out);
+  return out;
+}
+function worldBox(p) {
+  const b = localBox(`${p.name}.glb`);
+  if (!b) return null;
+  const mn = [Infinity, Infinity, Infinity], mx = [-Infinity, -Infinity, -Infinity];
+  for (const cx of [b.mn[0], b.mx[0]]) for (const cy of [b.mn[1], b.mx[1]]) for (const cz of [b.mn[2], b.mx[2]]) {
+    const s = [cx * p.scale[0], cy * p.scale[1], cz * p.scale[2]];
+    const r = qrot(p.quat, s);
+    for (let d = 0; d < 3; d++) {
+      const v = r[d] + p.pos[d];
+      mn[d] = Math.min(mn[d], v); mx[d] = Math.max(mx[d], v);
+    }
+  }
+  return { mn, mx };
+}
+
+// ── group the modules into the structures they form ──
+// BY WHAT THEY TOUCH, not by how close their origins are. A first version unioned modules
+// whose centres were within five metres in plan, ignoring height — which merges a tower's
+// ground floor with the fourth floor of the low building next door, and that floor then
+// renders hanging in the air beside the tower with nothing under it. 2.6% of all parts came
+// out floating that way.
+//
+// Two modules belong to the same structure when their world boxes actually meet, in ALL
+// THREE axes. A storey sits on the one below it, a fire escape touches the wall it clings to,
+// and a neighbour across a gap touches nothing.
+const boxes = parts.map(worldBox);
+const parent = parts.map((_, i) => i);
+const find = (a) => { while (parent[a] !== a) { parent[a] = parent[parent[a]]; a = parent[a]; } return a; };
+const union = (a, b) => { const ra = find(a), rb = find(b); if (ra !== rb) parent[ra] = rb; };
+const CELL = 8;
+const cells = new Map();
+parts.forEach((p, i) => {
+  const b = boxes[i];
+  if (!b) return;
+  for (let ci = Math.floor(b.mn[0] / CELL); ci <= Math.floor(b.mx[0] / CELL); ci++) {
+    for (let cj = Math.floor(b.mn[2] / CELL); cj <= Math.floor(b.mx[2] / CELL); cj++) {
+      const k = `${ci},${cj}`;
+      if (!cells.has(k)) cells.set(k, []);
+      cells.get(k).push(i);
+    }
+  }
+});
+const meets = (a, b) => a && b
+  && a.mn[0] - touch <= b.mx[0] && a.mx[0] + touch >= b.mn[0]
+  && a.mn[1] - touch <= b.mx[1] && a.mx[1] + touch >= b.mn[1]
+  && a.mn[2] - touch <= b.mx[2] && a.mx[2] + touch >= b.mn[2];
+for (const ids of cells.values()) {
+  for (let a = 0; a < ids.length; a++) for (let b = a + 1; b < ids.length; b++) {
+    if (meets(boxes[ids[a]], boxes[ids[b]])) union(ids[a], ids[b]);
+  }
+}
+const groups = new Map();
+parts.forEach((p, i) => {
+  const r = find(i);
+  if (!groups.has(r)) groups.set(r, []);
+  groups.get(r).push(p);
+});
+
+// ── DROP ANYTHING NOTHING HOLDS UP ──
+// The demo scene is a showcase, staged for the angles its screenshots were taken from, not a
+// structurally complete city: it contains storeys with the floor below them missing and roof
+// pieces over open air, because from the camera you never saw. Placed in a game you walk
+// around, each one is a slab hanging in the sky.
+//
+// Supported means: standing on the ground, OR overlapping in plan something whose top reaches
+// its underside, OR touching something to the side (a fire escape is held by the wall it is
+// bolted to, a roof trim by the parapet it caps). Iterated, because removing a slab can leave
+// what sat on it holding nothing.
+function prune(group, boxOf) {
+  const box = group.map(boxOf);
+  const keep = group.map(() => true);
+  for (let pass = 0; pass < 12; pass++) {
+    let cut = 0;
+    for (let i = 0; i < group.length; i++) {
+      if (!keep[i] || !box[i]) continue;
+      const a = box[i];
+      if (a.mn[1] <= floorTol) continue;                       // on the ground
+      let held = false;
+      for (let j = 0; j < group.length && !held; j++) {
+        if (i === j || !keep[j] || !box[j]) continue;
+        const b = box[j];
+        const overlaps = b.mx[0] > a.mn[0] + 0.3 && b.mn[0] < a.mx[0] - 0.3
+                      && b.mx[2] > a.mn[2] + 0.3 && b.mn[2] < a.mx[2] - 0.3;
+        if (overlaps && b.mx[1] >= a.mn[1] - floorTol) held = true;      // stands on it
+        else if (!overlaps && meets(a, b) && b.mn[1] <= a.mn[1] + floorTol) held = true;  // leans on it
+      }
+      if (!held) { keep[i] = false; cut++; }
+    }
+    if (!cut) break;
+  }
+  return group.filter((_, i) => keep[i]);
+}
+const floorTol = 0.6;
+let pruned = 0;
+
+// ── write each building out, in the road pieces' assembly shape ──
+fs.mkdirSync(outDir, { recursive: true });
+const index = {};
+let n = 0, skipped = 0;
+const byPart = new Map(parts.map((p, i) => [p, boxes[i]]));
+for (const raw of [...groups.values()].sort((a, b) => b.length - a.length)) {
+  const g = prune(raw, (p) => byPart.get(p));
+  pruned += raw.length - g.length;
+  // a lone module is a fence panel or an air-conditioning unit, not a building
+  if (g.length < 4) { skipped++; continue; }
+  const cx = g.reduce((a, p) => a + p.pos[0], 0) / g.length;
+  const cz = g.reduce((a, p) => a + p.pos[2], 0) / g.length;
+  const floor = Math.min(...g.map((p) => p.pos[1]));
+  // named for what it is mostly made of, so a catalogue can tell a shop from a tower
+  const kinds = {};
+  for (const p of g) {
+    const k = /^SM_Bld_([A-Za-z]+)/.exec(p.name)?.[1] ?? 'Building';
+    kinds[k] = (kinds[k] ?? 0) + 1;
+  }
+  const kind = Object.entries(kinds).sort((a, b) => b[1] - a[1])[0][0];
+  const name = `${kind}_${String(++n).padStart(2, '0')}`;
+  const body = {
+    name,
+    parts: g.map((p) => ({
+      file: `${p.name}.glb`,
+      pos: [+(p.pos[0] - cx).toFixed(4), +(p.pos[1] - floor).toFixed(4), +(p.pos[2] - cz).toFixed(4)],
+      quat: p.quat.map((v) => +v.toFixed(6)),
+      scale: p.scale.map((v) => +v.toFixed(4)),
+    })),
+  };
+  fs.writeFileSync(path.join(outDir, `${name}.json`), JSON.stringify(body));
+  index[name] = { parts: g.length, kind };
+}
+fs.writeFileSync(path.join(outDir, 'index.json'), JSON.stringify(index, null, 0));
+
+const models = new Set(parts.map((p) => p.name));
+console.log(`${parts.length} ${prefix}* modules · ${n} buildings written · ${skipped} loose modules skipped · ${pruned} unsupported parts dropped`);
+console.log(`${models.size} distinct models needed — bake these to GLB`);
+fs.writeFileSync(path.join(outDir, 'models-needed.txt'), [...models].sort().join('\n'));

package/tools/wholeBuildings.mjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+// WHICH MODELS ARE A WHOLE BUILDING — decided by measuring the mesh, not by reading its name.
+//
+//   node tools/wholeBuildings.mjs <glbDir> <outDir>
+//
+// A modular building kit ships walls, floors, roofs and corners alongside the few models that
+// are a finished building on their own. Place a wall panel as a building and you get exactly
+// what it is: a building with most of its walls missing. Naming conventions do not separate
+// them reliably — `SM_Bld_OfficeOld_Large_01` is one storey, `SM_Bld_OfficeRound_01` is a
+// whole tower, and nothing in the name says so.
+//
+// So measure. A model is a whole building when:
+//   1. it is at least MIN_H tall and MIN_W across in BOTH horizontal axes — rules out panels,
+//      slabs, kerbs and trims;
+//   2. it has geometry in every horizontal slice from its base to its top — a floor slab has
+//      all its vertices in one thin band and fails here;
+//   3. it has geometry on ALL FOUR SIDES of its footprint — the missing-walls test;
+// It is then CAPPED if it needs it. These towers are open-topped shells you can see straight
+// down into from above, and the pack has no cap for them: its `<Family>_Roof_01` models are
+// parapets that cover 0-19% of the footprint, because Synty built this kit to be seen from
+// street level in a game and never from the air. Rejecting every uncapped model leaves zero
+// buildings — measured, all 75 fail — so the tool measures the hole and records a lid for the
+// consumer to draw, rather than pretending the asset has one.
+//
+// The output is one single-part assembly per building plus a catalogue, in the same shape the
+// multi-part assemblies use, so a consumer needs no special case for either.
+import fs from 'node:fs';
+import path from 'node:path';
+
+const [glbDir, outDir] = process.argv.slice(2);
+if (!glbDir || !outDir) {
+  console.error('usage: wholeBuildings.mjs <glbDir> <outDir>');
+  process.exit(1);
+}
+
+const MIN_H = 6;        // metres — anything shorter is a wall, a kerb or a bit of trim
+const MIN_W = 6;        // and anything narrower is a panel seen edge-on
+const BANDS = 6;        // vertical slices that must all contain geometry
+const SIDE_FILL = 0.6;  // how much of each side of the footprint must carry geometry
+const LID_BAND = 0.12;  // the top slice of the model that counts as its roof
+const LID_FILL = 0.55;  // how much of the footprint's middle that slice must cover
+
+// every vertex position in a GLB, as a flat sequence — the test needs the actual points, not
+// just the bounding box a panel and a tower can share
+function positions(file) {
+  const buf = fs.readFileSync(file);
+  const jsonLen = buf.readUInt32LE(12);
+  const gltf = JSON.parse(buf.slice(20, 20 + jsonLen).toString('utf8'));
+  const binOffset = 20 + jsonLen + 8;
+  const out = [];
+  for (const mesh of gltf.meshes ?? []) {
+    for (const prim of mesh.primitives ?? []) {
+      const acc = gltf.accessors[prim.attributes.POSITION];
+      if (!acc || acc.componentType !== 5126 || acc.type !== 'VEC3') continue;
+      const view = gltf.bufferViews[acc.bufferView];
+      const start = binOffset + (view.byteOffset ?? 0) + (acc.byteOffset ?? 0);
+      const stride = view.byteStride ?? 12;
+      for (let i = 0; i < acc.count; i++) {
+        const o = start + i * stride;
+        if (o + 12 > buf.length) break;
+        out.push(buf.readFloatLE(o), buf.readFloatLE(o + 4), buf.readFloatLE(o + 8));
+      }
+    }
+  }
+  return out;
+}
+
+function judge(p) {
+  if (p.length < 3 * 12) return { whole: false, why: 'almost no geometry' };
+  const mn = [Infinity, Infinity, Infinity], mx = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < p.length; i += 3) {
+    for (let d = 0; d < 3; d++) {
+      if (p[i + d] < mn[d]) mn[d] = p[i + d];
+      if (p[i + d] > mx[d]) mx[d] = p[i + d];
+    }
+  }
+  const size = [mx[0] - mn[0], mx[1] - mn[1], mx[2] - mn[2]];
+  if (size[1] < MIN_H) return { whole: false, why: `only ${size[1].toFixed(1)} m tall`, size, mn };
+  if (Math.min(size[0], size[2]) < MIN_W) {
+    return { whole: false, why: `only ${Math.min(size[0], size[2]).toFixed(1)} m across — a panel`, size, mn };
+  }
+
+  // 2. every vertical band occupied — a slab lives in one band
+  const band = new Array(BANDS).fill(0);
+  // 3. and every side of the footprint occupied — this is the missing-walls test
+  const N = 8;
+  const edgeN = new Array(N).fill(0), edgeS = new Array(N).fill(0);
+  const edgeE = new Array(N).fill(0), edgeW = new Array(N).fill(0);
+  const bin = (v, lo, span, n) => Math.min(n - 1, Math.max(0, Math.floor(((v - lo) / span) * n)));
+  for (let i = 0; i < p.length; i += 3) {
+    const x = p[i], y = p[i + 1], z = p[i + 2];
+    band[bin(y, mn[1], size[1], BANDS)] = 1;
+    const fx = (x - mn[0]) / size[0], fz = (z - mn[2]) / size[2];
+    if (fz < 0.2) edgeS[bin(x, mn[0], size[0], N)] = 1;
+    if (fz > 0.8) edgeN[bin(x, mn[0], size[0], N)] = 1;
+    if (fx < 0.2) edgeW[bin(z, mn[2], size[2], N)] = 1;
+    if (fx > 0.8) edgeE[bin(z, mn[2], size[2], N)] = 1;
+  }
+  const gaps = band.filter((b) => !b).length;
+  if (gaps) return { whole: false, why: `${gaps}/${BANDS} vertical bands empty — a floor or a roof`, size, mn };
+  const fill = (e) => e.reduce((a, b) => a + b, 0) / N;
+  const sides = [fill(edgeN), fill(edgeE), fill(edgeS), fill(edgeW)];
+  const open = sides.filter((f) => f < SIDE_FILL).length;
+  if (open) {
+    return { whole: false, why: `${open} of 4 sides open (${sides.map((f) => (f * 100).toFixed(0) + '%').join('/')})`, size, mn };
+  }
+
+  // 4. IS IT OPEN AT THE TOP? Not a rejection — a measurement. Look at the top slice and ask
+  //    whether anything covers the MIDDLE of the footprint: walls sit at the perimeter, so an
+  //    open tube has nothing there and needs a lid drawing over it.
+  const G = 6;
+  const top = new Array(G * G).fill(0);
+  const lidFrom = mn[1] + size[1] * (1 - LID_BAND);
+  for (let i = 0; i < p.length; i += 3) {
+    if (p[i + 1] < lidFrom) continue;
+    const gx = bin(p[i], mn[0], size[0], G), gz = bin(p[i + 2], mn[2], size[2], G);
+    top[gz * G + gx] = 1;
+  }
+  let inner = 0, innerCells = 0;
+  for (let gz = 1; gz < G - 1; gz++) for (let gx = 1; gx < G - 1; gx++) {
+    innerCells++;
+    inner += top[gz * G + gx];
+  }
+  const lid = inner / innerCells;
+
+  // ROUND OR SQUARE? A lid has to match the thing it caps: a square slab on a cylinder
+  // overhangs at the corners. Measure how far the plan reaches into the corners of its own
+  // bounding box, normalised so the answer does not depend on size — a circle tops out at
+  // 1.0 because every point is on the inscribed ellipse, a rectangle reaches 1.41 at its
+  // corners. (A grid of cells cannot tell these apart at any resolution a corner cell is
+  // coarser than the gap; this is exact.)
+  const cx0 = mn[0] + size[0] / 2, cz0 = mn[2] + size[2] / 2;
+  let reach = 0;
+  for (let i = 0; i < p.length; i += 3) {
+    const u = (p[i] - cx0) / (size[0] / 2), v = (p[i + 2] - cz0) / (size[2] / 2);
+    const r = Math.hypot(u, v);
+    if (r > reach) reach = r;
+  }
+  const shape = reach < 1.15 ? 'round' : 'square';
+
+  return { whole: true, size, mn, sides, lid, shape, needsCap: lid < LID_FILL };
+}
+
+// PUT ITS OWN ROOF ON IT. This pack contains no finished building at all — every model is a
+// shell, a floor or a roof, and the tests above reject all 75 of them. But it ships tower
+// SHELLS (`OfficeOld_Large_01` is a 25 m body) alongside a matching `<Family>_Roof_01`, so the
+// building is the shell with its own roof on top. Which roof belongs to which shell is
+// Synty's naming, not a guess — and the result is then put through the same tests, so a
+// wrong pairing is rejected rather than shipped.
+const files = fs.readdirSync(glbDir).filter((f) => f.endsWith('.glb')).sort();
+const geom = new Map();
+for (const f of files) {
+  try { geom.set(f, positions(path.join(glbDir, f))); } catch { /* skip unreadable */ }
+}
+const familyOf = (f) => f.replace(/\.glb$/, '').replace(/^SM_Bld_/, '').replace(/_\d+$/, '');
+const roofFor = (f) => {
+  const fam = familyOf(f);
+  for (const cand of [`SM_Bld_${fam}_Roof_01.glb`, `SM_Bld_${fam}_Roof.glb`]) {
+    if (geom.has(cand)) return cand;
+  }
+  return null;
+};
+const heightOf = (p) => {
+  let lo = Infinity, hi = -Infinity;
+  for (let i = 1; i < p.length; i += 3) { if (p[i] < lo) lo = p[i]; if (p[i] > hi) hi = p[i]; }
+  return { lo, hi };
+};
+
+fs.mkdirSync(outDir, { recursive: true });
+const catalogue = {};
+const rejected = [];
+for (const f of files) {
+  const own = geom.get(f);
+  if (!own) { rejected.push([f, 'unreadable']); continue; }
+  // the shell alone, then the shell with its roof stacked on
+  const tries = [{ parts: [[f, 0]], pts: own }];
+  const roof = roofFor(f);
+  if (roof && roof !== f) {
+    const top = heightOf(own).hi;
+    const rp = geom.get(roof);
+    const lift = top - heightOf(rp).lo;
+    const merged = own.slice();
+    for (let i = 0; i < rp.length; i += 3) merged.push(rp[i], rp[i + 1] + lift, rp[i + 2]);
+    tries.push({ parts: [[f, 0], [roof, lift]], pts: merged });
+  }
+  let won = null, why = null;
+  for (const t of tries) {
+    const v = judge(t.pts);
+    if (v.whole) { won = { ...t, v }; break; }
+    why ??= v.why;
+    why = v.why;                                    // report the best attempt's reason
+  }
+  if (!won) { rejected.push([f, why]); continue; }
+  const name = f.replace(/\.glb$/, '').replace(/^SM_Bld_/, '');
+  const s = won.v.size, mn = won.v.mn;
+  catalogue[name] = {
+    size: s.map((v) => +v.toFixed(2)),
+    centre: [0, 1, 2].map((d) => +(mn[d] + s[d] / 2).toFixed(2)),
+    base: +mn[1].toFixed(2),
+    parts: won.parts.length,
+    kind: /^([A-Za-z]+)/.exec(name)?.[1] ?? 'Building',
+  };
+  // CENTRE IT ON ITS OWN PLOT. A model is authored wherever its artist left it — some are
+  // centred on the origin, some start at it and run 22 m in +x. The planner works in
+  // footprint centres and spaces buildings by half-widths, so a model whose geometry sits off
+  // to one side is placed half a building away from where the planner thinks it is, and its
+  // neighbour is then built straight through it.
+  const offX = mn[0] + s[0] / 2, offZ = mn[2] + s[2] / 2;
+  fs.writeFileSync(path.join(outDir, `${name}.json`), JSON.stringify({
+    name,
+    parts: won.parts.map(([file, lift]) => ({
+      file,
+      pos: [+(-offX).toFixed(4), +(lift - mn[1]).toFixed(4), +(-offZ).toFixed(4)],
+      quat: [0, 0, 0, 1], scale: [1, 1, 1],
+    })),
+    // a flat lid over the hole, in the building's own local frame — the consumer draws it
+    ...(won.v.needsCap ? { cap: {
+      shape: won.v.shape,
+      y: +(s[1] - 0.05).toFixed(3),
+      sizeX: +(s[0] * 0.98).toFixed(3),
+      sizeZ: +(s[2] * 0.98).toFixed(3),
+      offX: 0, offZ: 0,                            // the parts are recentred above
+    } } : {}),
+  }));
+}
+fs.writeFileSync(path.join(outDir, 'catalogue.json'), JSON.stringify(catalogue));
+fs.writeFileSync(path.join(outDir, 'index.json'), JSON.stringify(
+  Object.fromEntries(Object.entries(catalogue).map(([k, v]) => [k, { parts: 1, kind: v.kind }]))));
+
+const capped = Object.keys(catalogue).length;
+console.log(`${capped} whole buildings · ${rejected.length} rejected`);
+for (const [name, why] of rejected.slice(0, 8)) console.log(`   rejected  ${name.replace('.glb', '').padEnd(38)} ${why}`);
+if (rejected.length > 8) console.log(`   ...and ${rejected.length - 8} more`);