sindicate 0.13.0 → 0.15.0

package/tools/roadKitAnalyze.mjs

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+// ROAD KIT ANALYZE — turn a pack of road assemblies into a KIT: what each piece IS and
+// where its arms connect. Without this, junctions are just meshes; with it the solver can
+// place a junction and run a road out of every arm to the next one.
+//
+//   node tools/roadKitAnalyze.mjs <packDir>
+//
+// Writes <packDir>/roadkit.json:
+//   { pieces: { <assembly>: { family, class, arms: n, bbox, surfaceY,
+//                             sockets: [{ id, pos:[x,y,z], dir:[x,z], width }] } } }
+//
+// Sockets come from geometry, not names: an arm's asphalt mesh is measured, its outward
+// face located, and the road's width taken across that face. Names only supply labels.
+// (When Kiwi's exporter is re-run it also emits connector markers — those will override
+// these measurements where present.)
+import fs from 'node:fs';
+import path from 'node:path';
+
+const [packDir] = process.argv.slice(2);
+if (!packDir) { console.error('usage: roadKitAnalyze.mjs <packDir>'); process.exit(1); }
+const modelsDir = path.join(packDir, 'models');
+
+// ── minimal GLB reader: positions of every primitive, merged ──
+const posCache = new Map();
+function positionsOf(file) {
+  if (posCache.has(file)) return posCache.get(file);
+  let out = null;
+  try {
+    const buf = fs.readFileSync(path.join(modelsDir, file));
+    const jsonLen = buf.readUInt32LE(12);
+    const gltf = JSON.parse(buf.slice(20, 20 + jsonLen).toString('utf8'));
+    const binStart = 20 + jsonLen + 8;
+    const chunks = [];
+    for (const mesh of gltf.meshes ?? []) {
+      for (const prim of mesh.primitives ?? []) {
+        const acc = gltf.accessors[prim.attributes.POSITION];
+        const view = gltf.bufferViews[acc.bufferView];
+        const start = binStart + (view.byteOffset ?? 0) + (acc.byteOffset ?? 0);
+        chunks.push(new Float32Array(buf.buffer, buf.byteOffset + start, acc.count * 3));
+      }
+    }
+    if (chunks.length) {
+      const total = chunks.reduce((n, c) => n + c.length, 0);
+      out = new Float32Array(total);
+      let o = 0;
+      for (const c of chunks) { out.set(c, o); o += c.length; }
+    }
+  } catch { /* builtin: or unreadable — handled by caller */ }
+  posCache.set(file, out);
+  return out;
+}
+// Unity built-ins the assemblies reference by name
+const BUILTIN = {
+  Plane: [[-5, 0, -5], [5, 0, 5]], Quad: [[-0.5, -0.5, 0], [0.5, 0.5, 0]],
+  Cube: [[-0.5, -0.5, -0.5], [0.5, 0.5, 0.5]], Sphere: [[-0.5, -0.5, -0.5], [0.5, 0.5, 0.5]],
+  Cylinder: [[-0.5, -1, -0.5], [0.5, 1, 0.5]], Capsule: [[-0.5, -1, -0.5], [0.5, 1, 0.5]],
+};
+function cornersOfBuiltin(name) {
+  const b = BUILTIN[name] ?? BUILTIN.Cube;
+  const pts = [];
+  for (const x of [b[0][0], b[1][0]]) for (const y of [b[0][1], b[1][1]]) for (const z of [b[0][2], b[1][2]]) pts.push([x, y, z]);
+  return pts;
+}
+
+const applyTRS = (v, part) => {
+  const [x, y, z] = [v[0] * part.scale[0], v[1] * part.scale[1], v[2] * part.scale[2]];
+  const [qx, qy, qz, qw] = part.quat;
+  // q * v * q⁻¹
+  const ix = qw * x + qy * z - qz * y, iy = qw * y + qz * x - qx * z;
+  const iz = qw * z + qx * y - qy * x, iw = -qx * x - qy * y - qz * z;
+  return [
+    ix * qw + iw * -qx + iy * -qz - iz * -qy + part.pos[0],
+    iy * qw + iw * -qy + iz * -qx - ix * -qz + part.pos[1],
+    iz * qw + iw * -qz + ix * -qy - iy * -qx + part.pos[2],
+  ];
+};
+
+function worldPoints(part) {
+  if (part.file.startsWith('builtin:')) return cornersOfBuiltin(part.file.slice(8)).map((v) => applyTRS(v, part));
+  const p = positionsOf(part.file);
+  if (!p) return [];
+  const out = [];
+  for (let i = 0; i < p.length; i += 3) out.push(applyTRS([p[i], p[i + 1], p[i + 2]], part));
+  return out;
+}
+
+const bboxOf = (pts) => {
+  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+  for (const p of pts) for (let d = 0; d < 3; d++) { if (p[d] < min[d]) min[d] = p[d]; if (p[d] > max[d]) max[d] = p[d]; }
+  return { min, max };
+};
+
+// An arm is a long thin strip: its own principal axis IS the direction it points, which is
+// exact even for diagonal (Y-junction) arms where "offset from the assembly centre" is not —
+// an asymmetric junction's centre is nowhere near its arms' axis.
+function principalAxis(pts) {
+  let mx = 0, mz = 0;
+  for (const p of pts) { mx += p[0]; mz += p[2]; }
+  mx /= pts.length; mz /= pts.length;
+  let sxx = 0, sxz = 0, szz = 0;
+  for (const p of pts) { const x = p[0] - mx, z = p[2] - mz; sxx += x * x; sxz += x * z; szz += z * z; }
+  const theta = 0.5 * Math.atan2(2 * sxz, sxx - szz);
+  return { axis: [Math.cos(theta), Math.sin(theta)], mean: [mx, mz] };
+}
+
+// an arm's socket: push out along the arm's own direction, measure the outer slab
+function socketFrom(pts, dir, id) {
+  let maxProj = -Infinity;
+  for (const p of pts) { const d = p[0] * dir[0] + p[2] * dir[1]; if (d > maxProj) maxProj = d; }
+  const perp = [-dir[1], dir[0]];
+  // widen the slab until it holds a real face (a hair of axis error can otherwise clip it
+  // down to a single corner vertex, which reads as width 0)
+  let lo = 0, hi = 0, ySum = 0, n = 0;
+  for (const tol of [0.35, 1, 2.5]) {
+    lo = Infinity; hi = -Infinity; ySum = 0; n = 0;
+    for (const p of pts) {
+      if (p[0] * dir[0] + p[2] * dir[1] < maxProj - tol) continue;
+      const l = p[0] * perp[0] + p[2] * perp[1];
+      if (l < lo) lo = l;
+      if (l > hi) hi = l;
+      ySum += p[1]; n++;
+    }
+    if (n && hi - lo > 0.5) break;
+  }
+  if (!n) return null;
+  const mid = (lo + hi) / 2;
+  return {
+    id,
+    pos: [dir[0] * maxProj + perp[0] * mid, +(ySum / n).toFixed(3), dir[1] * maxProj + perp[1] * mid].map((v) => +v.toFixed(3)),
+    dir: dir.map((v) => +v.toFixed(4)),
+    width: +(hi - lo).toFixed(2),
+  };
+}
+
+// THE CROSS-SECTION AT A SOCKET. A country road is one deck with a dashed middle; a motorway
+// is two carriageways either side of a median, each with its own lane dashes. Rather than
+// hard-code either, measure the paint at the opening: sorted lateral positions fall into
+// bands, and a band is a line. A generated road can then be built to match exactly.
+function bandsOf(pts, socket, gap = 0.5) {
+  const [dx, dz] = socket.dir;
+  const right = [-dz, dx];
+  const lat = pts.map((p) => (p[0] - socket.pos[0]) * right[0] + (p[2] - socket.pos[2]) * right[1]).sort((a, b) => a - b);
+  if (!lat.length) return [];
+  const bands = [];
+  let lo = lat[0], prev = lat[0];
+  for (let i = 1; i < lat.length; i++) {
+    if (lat[i] - prev > gap) { bands.push({ at: +((lo + prev) / 2).toFixed(3), width: +(prev - lo).toFixed(3) }); lo = lat[i]; }
+    prev = lat[i];
+  }
+  bands.push({ at: +((lo + prev) / 2).toFixed(3), width: +(prev - lo).toFixed(3) });
+  return bands;
+}
+
+// Every arm is a TWO-WAY road: traffic leaves on one side of the centre line and arrives on
+// the other. WHICH side is a runtime choice, not a property of the geometry — a game (or the
+// designer, mid-edit) must be able to flip between drive-on-left and drive-on-right without
+// re-analysing anything. So lanes are stored by their SIDE of the centre line ('L'/'R',
+// looking out along the socket) and `laneFlow(side, driveOnLeft)` in world/roadKit.js turns
+// that into in/out at read time.
+const DRIVE_ON_LEFT_DEFAULT = !process.argv.includes('--drive-on-right');
+const KIT_LANE_W = 5;            // Kiwi's generator: laneWidth 5, verge 1.5 → 13 m arms
+
+// A motorway's lanes come straight out of its measured paint: the two innermost solid lines
+// fence the median, the outermost fence the shoulders, and the dashes between them divide
+// each carriageway. Traffic on the near side of the median runs one way, the far side the other.
+function motorwayLanes(socket) {
+  const { lines = [], dashes = [] } = socket.section ?? {};
+  const [dx, dz] = socket.dir;
+  const right = [-dz, dx];
+  const at = (off) => [
+    +(socket.pos[0] + right[0] * off).toFixed(3), socket.pos[1],
+    +(socket.pos[2] + right[1] * off).toFixed(3),
+  ];
+  const out = [];
+  for (const side of [-1, 1]) {
+    // the carriageway on this side runs from the median line to the outer edge line
+    const own = lines.filter((l) => Math.sign(l.at) === side).sort((a, b) => Math.abs(a.at) - Math.abs(b.at));
+    if (own.length < 2) continue;
+    const inner = own[0].at, outer = own[own.length - 1].at;
+    const divs = dashes.filter((d) => Math.sign(d.at) === side).map((d) => d.at).sort((a, b) => Math.abs(a) - Math.abs(b));
+    const edges = [inner, ...divs, outer];
+    // drive-on-left: the carriageway LEFT of the centre (negative `right`) carries traffic out
+    for (let i = 0; i < edges.length - 1; i++) {
+      out.push({
+        side: side < 0 ? 'L' : 'R',
+        centre: at((edges[i] + edges[i + 1]) / 2),
+        width: +Math.abs(edges[i + 1] - edges[i]).toFixed(2),
+      });
+    }
+  }
+  return out;
+}
+
+function lanesOf(socket, centreMarks, edgeMarks) {
+  const [dx, dz] = socket.dir;
+  const right = [-dz, dx];       // right-hand side of a driver heading OUT along dir
+  const lat = (p) => (p[0] - socket.pos[0]) * right[0] + (p[2] - socket.pos[2]) * right[1];
+  const mean = (pts) => pts.reduce((s, p) => s + lat(p), 0) / pts.length;
+  // centre line from the arm's own dash mesh; else the middle of the opening
+  const c = centreMarks?.length ? mean(centreMarks) : 0;
+  // carriageway half-width: to the far edge line if we have one, else half the opening
+  let half = socket.width / 2;
+  let lineW = 0.15;
+  if (edgeMarks?.length) {
+    let lo = Infinity, hi = -Infinity;
+    // the two edge lines sit either side of the centre: measure each band separately so we
+    // learn both where the paint is and how wide a line is
+    let rLo = Infinity, rHi = -Infinity, lLo = Infinity, lHi = -Infinity;
+    for (const p of edgeMarks) {
+      const l = lat(p);
+      if (l < lo) lo = l;
+      if (l > hi) hi = l;
+      if (l > c) { if (l < rLo) rLo = l; if (l > rHi) rHi = l; }
+      else { if (l < lLo) lLo = l; if (l > lHi) lHi = l; }
+    }
+    half = Math.max(hi - c, c - lo);
+    const bands = [rHi - rLo, lHi - lLo].filter((w) => Number.isFinite(w) && w > 0.01 && w < 1);
+    if (bands.length) lineW = Math.min(...bands);
+  }
+  const laneW = Math.min(KIT_LANE_W, Math.max(half, 1));
+  const at = (off) => [
+    +(socket.pos[0] + right[0] * off).toFixed(3), socket.pos[1],
+    +(socket.pos[2] + right[1] * off).toFixed(3),
+  ];
+  // 'L' is left of the centre line looking OUT along the socket; which way it flows is the
+  // game's runtime call (see laneFlow)
+  return {
+    lanes: [
+      { side: 'L', centre: at(c - laneW / 2), width: +laneW.toFixed(2) },
+      { side: 'R', centre: at(c + laneW / 2), width: +laneW.toFixed(2) },
+    ],
+    // where the paint actually sits, so a generated road's lines continue the arm's
+    // instead of kinking at the seam (the verge outside the edge line is often 1.5 m)
+    paint: { centre: +c.toFixed(3), half: +half.toFixed(3), lineWidth: +lineW.toFixed(3), measured: !!edgeMarks?.length },
+  };
+}
+
+const asmDir = path.join(packDir, 'assemblies');
+const index = JSON.parse(fs.readFileSync(path.join(asmDir, 'index.json'), 'utf8'));
+const familyOf = (n) => n
+  .replace(/_(?:[NSEW]{1,2}-(?:CR|SR)(?:-(?:GW|P))?)(?:_[NSEW]{1,2}-(?:CR|SR)(?:-(?:GW|P))?)*$/, '')
+  .replace(/_L\d+-R\d+$/, '').replace(/_R\d+$/, '').replace(/_\d+deg$/, '');
+const classify = (fam) => /Roundabout/i.test(fam) ? 'roundabout'
+  : /Interchange|Overpass|Dumbbell/i.test(fam) ? 'interchange'
+  : /RoadSegment/i.test(fam) ? 'segment'
+  : /Junction|Cross|_T_|_Y_|Corner|4Way|TJunction|YJunction/i.test(fam) ? 'junction'
+  : /Transition/i.test(fam) ? 'transition' : 'other';
+
+const pieces = {};
+let withSockets = 0;
+for (const name of index) {
+  const man = JSON.parse(fs.readFileSync(path.join(asmDir, `${name}.json`), 'utf8'));
+  const all = [];
+  const roadPts = [];            // asphalt/markings only — grass and sidewalk would widen arms
+  const armPts = new Map();      // arm label → points of that arm's asphalt
+  const markPts = new Map();     // "<arm>:centre" / "<arm>:edge" → points of that marking
+  const throughPts = [], throughDash = [];   // motorway carriageway lines + its lane dashes
+  for (const part of man.parts) {
+    const pts = worldPoints(part);
+    if (!pts.length) continue;
+    all.push(...pts);
+    if (/road|asphalt|lines|markings/i.test(part.file) || /road/i.test(part.tex ?? '')) roadPts.push(...pts);
+    // generated junction arms carry their label in the mesh name; the reconstructed
+    // roundabout arms are numbered (SimpleRoundabout_Arm3.glb)
+    const m = /Arm_(North|South|East|West|NorthEast|NorthWest|SouthEast|SouthWest)_(?:Asphalt|Road)/i.exec(part.file)
+      ?? /^SimpleRoundabout_Arm(\d)\.glb$/i.exec(part.file);
+    if (m) {
+      const k = m[1];
+      if (!armPts.has(k)) armPts.set(k, []);
+      armPts.get(k).push(...pts);
+    }
+    // interchange pieces: a motorway runs THROUGH them (DualCarriageway, with its lane
+    // dashes) and local roads spur OFF them (CountryRoad, same arms the roundabouts use)
+    if (/^DualCarriageway(_\d+)?\.glb$/i.test(part.file)) throughPts.push(...pts);
+    else if (/^CarriagewayLaneDashes(_\d+)?\.glb$/i.test(part.file)) throughDash.push(...pts);
+    else if (/^CountryRoad(_\d+)?\.glb$/i.test(part.file)) {
+      const k = `spur${armPts.size}:${part.file}`;
+      if (!armPts.has(k)) armPts.set(k, []);
+      armPts.get(k).push(...pts);
+    }
+    // markings tell us where the centre line and the carriageway edges are, which is how
+    // an arm splits into its two directions of travel
+    const mk = /Arm_(North|South|East|West|NorthEast|NorthWest|SouthEast|SouthWest)_(CenterDash|EdgeLines)/i.exec(part.file);
+    if (mk) {
+      const key = `${mk[1]}:${/center/i.test(mk[2]) ? 'centre' : 'edge'}`;
+      if (!markPts.has(key)) markPts.set(key, []);
+      markPts.get(key).push(...pts);
+    }
+  }
+  if (!all.length) continue;
+  const bb = bboxOf(all);
+  const centre = [(bb.min[0] + bb.max[0]) / 2, (bb.min[2] + bb.max[2]) / 2];
+  const sockets = [];
+  for (const [label, pts] of armPts) {
+    // direction from the arm's own axis, pointed AWAY from the junction centre
+    // (the pack is X-mirrored vs Unity, so the label is never trusted for direction)
+    const { axis, mean } = principalAxis(pts);
+    const away = [mean[0] - centre[0], mean[1] - centre[1]];
+    const dir = (axis[0] * away[0] + axis[1] * away[1]) < 0 ? [-axis[0], -axis[1]] : axis;
+    const s = socketFrom(pts, dir, label);
+    if (!s) continue;
+    Object.assign(s, lanesOf(s, markPts.get(`${label}:centre`), markPts.get(`${label}:edge`)));
+    sockets.push(s);
+  }
+  // MOTORWAY: the carriageway runs clean through the interchange, so it offers a socket at
+  // each end. Its cross-section is measured, not assumed — two carriageways, a median, and
+  // however many lanes this variant was generated with.
+  if (throughPts.length) {
+    const { axis } = principalAxis(throughPts);
+    for (const sgn of [1, -1]) {
+      const dir = [axis[0] * sgn, axis[1] * sgn];
+      const s = socketFrom(throughPts, dir, sgn > 0 ? 'M-A' : 'M-B');
+      if (!s) continue;
+      const deck = socketFrom(all, dir, s.id);
+      s.kind = 'motorway';
+      s.width = deck && deck.width > s.width ? deck.width : s.width;
+      s.section = { lines: bandsOf(throughPts, s), dashes: bandsOf(throughDash, s) };
+      s.lanes = motorwayLanes(s);
+      sockets.push(s);
+    }
+  }
+
+  const fam = familyOf(name);
+  // a straight segment's sockets are simply its two ends along its long axis
+  if (!sockets.length && classify(fam) === 'segment') {
+    const { axis } = principalAxis(all);
+    for (const sgn of [1, -1]) {
+      const s = socketFrom(all, [axis[0] * sgn, axis[1] * sgn], sgn > 0 ? 'A' : 'B');
+      if (s) { Object.assign(s, lanesOf(s)); sockets.push(s); }
+    }
+  }
+  // hand-built tile junctions (the City/Countryside FBX ones) have no named arm meshes —
+  // probe the four compass faces of the ROAD surface instead
+  if (!sockets.length && classify(fam) === 'junction' && roadPts.length) {
+    const probes = [['N', [0, 1]], ['E', [1, 0]], ['S', [0, -1]], ['W', [-1, 0]]];
+    for (const [id, dir] of probes) {
+      const s = socketFrom(roadPts, dir, id);
+      if (!s || s.width < 3) continue;
+      // an arm exists only where the ASPHALT runs out to the tile's own edge — a T's
+      // missing arm stops at the far kerb of the through road
+      const tileEdge = dir[0] ? (dir[0] > 0 ? bb.max[0] : -bb.min[0]) : (dir[1] > 0 ? bb.max[2] : -bb.min[2]);
+      const face = s.pos[0] * dir[0] + s.pos[2] * dir[1];
+      if (tileEdge - face < 0.5) { Object.assign(s, lanesOf(s)); sockets.push(s); }
+    }
+  }
+  pieces[name] = {
+    family: fam,
+    class: classify(fam),
+    size: [+(bb.max[0] - bb.min[0]).toFixed(2), +(bb.max[1] - bb.min[1]).toFixed(2), +(bb.max[2] - bb.min[2]).toFixed(2)],
+    bbox: { min: bb.min.map((v) => +v.toFixed(3)), max: bb.max.map((v) => +v.toFixed(3)) },
+    surfaceY: +bb.max[1].toFixed(3),
+    sockets,
+  };
+  if (sockets.length) withSockets++;
+}
+fs.writeFileSync(path.join(packDir, 'roadkit.json'), JSON.stringify({
+  generated: 'roadKitAnalyze',
+  driveOnLeft: DRIVE_ON_LEFT_DEFAULT,   // the kit's DEFAULT side of the road; switchable at runtime
+  laneWidth: KIT_LANE_W,
+  pieces,
+}, null, 0));
+
+const byClass = {};
+for (const p of Object.values(pieces)) byClass[p.class] = (byClass[p.class] ?? 0) + 1;
+console.log(`${Object.keys(pieces).length} pieces analysed · ${withSockets} with measured sockets`);
+console.log('by class:', byClass);

package/tools/truthToAssemblies.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+// TRUTH → ASSEMBLIES — rebuild the KiwiRoads assemblies from Unity's OWN export
+// (road-materials.json: per renderer, the prefab, mesh, Unity-resolved world transform
+// and material stack). No YAML archaeology: Unity resolved its hierarchy itself.
+//
+//   node tools/truthToAssemblies.mjs <SindicateExport> <kiwiAssets> <packDir>
+//
+// · entries come in CONTIGUOUS RUNS per prefab (the exporter walked prefab-by-prefab);
+//   same-named Motorway/DualCarriageway variants are split by run and labeled by where
+//   their mesh guids live on disk.
+// · parts reference the deduped lib (meshGuid → asset path → aliases.json) or shared FBX
+//   props (copied into the pack on demand).
+// · handedness: pos x → −x, quat (x,y,z,w) → (x,−y,−z,w) — same as unityMeshToGlb.
+// · materials: mainTex + color tint + tiling carried per part; textures copied in.
+import fs from 'node:fs';
+import path from 'node:path';
+
+const [exportDir, kiwiAssets, packDir] = process.argv.slice(2);
+if (!exportDir || !kiwiAssets || !packDir) { console.error('usage: truthToAssemblies.mjs <SindicateExport> <kiwiAssets> <packDir>'); process.exit(1); }
+
+// guid → asset path
+const guidMap = new Map();
+(function scan(dir) {
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) { scan(p); continue; }
+    if (!e.name.endsWith('.meta')) continue;
+    const m = fs.readFileSync(p, 'utf8').match(/guid: ([0-9a-f]{32})/);
+    if (m) guidMap.set(m[1], p.slice(0, -5));
+  }
+})(kiwiAssets);
+
+const aliases = JSON.parse(fs.readFileSync(path.join(packDir, 'aliases.json'), 'utf8'));
+const ROADMESHES = path.join(kiwiAssets, 'AIGenerateMap/Generated/RoadMeshes');
+const libFor = (assetPath) => {
+  const rel = assetPath.startsWith(ROADMESHES)
+    ? path.relative(ROADMESHES, assetPath).replace(/\.asset$/, '.glb')
+    : path.basename(assetPath).replace(/\.asset$/, '.glb');
+  return aliases[rel] ?? null;
+};
+
+const truth = JSON.parse(fs.readFileSync(path.join(exportDir, 'road-materials.json'), 'utf8')).entries;
+
+// split into contiguous prefab runs
+const runs = [];
+for (const e of truth) {
+  const last = runs[runs.length - 1];
+  if (last && last.prefab === e.prefab) last.entries.push(e);
+  else runs.push({ prefab: e.prefab, entries: [e] });
+}
+// name each run; disambiguate dup-named variants by their meshes' disk location
+const nameCounts = {};
+for (const r of runs) nameCounts[r.prefab] = (nameCounts[r.prefab] ?? 0) + 1;
+function variantLabel(run) {
+  if (nameCounts[run.prefab] === 1) return run.prefab;
+  for (const e of run.entries) {
+    const p = e.meshGuid && guidMap.get(e.meshGuid);
+    if (!p) continue;
+    if (p.includes('/Motorway/')) return `Motorway_${run.prefab}`;
+    if (p.includes('/DualCarriageway/')) return `DualCarriageway_${run.prefab}`;
+  }
+  return `${run.prefab}_v${(variantLabel._n = (variantLabel._n ?? 0) + 1)}`;
+}
+
+const flipPos = (p) => [-p[0], p[1], p[2]].map((v) => +v.toFixed(5));
+const flipQuat = (q) => [q[0], -q[1], -q[2], q[3]].map((v) => +v.toFixed(6));
+
+// FBX props keep Unity's per-file import scale: effective = globalScale × cm fileScale.
+// PolygonCity files are metre-authored with globalScale 100 (net ×1); PolygonTown are
+// true centimetres with globalScale 1 (net ×0.01). Hard-coding 0.01 shrank every
+// PolygonCity road deck to a 5cm speck — the invisible-countryside-roads bug.
+function metaScale(assetPath) {
+  try {
+    const meta = fs.readFileSync(assetPath + '.meta', 'utf8');
+    const g = +(meta.match(/globalScale: ([\d.eE+-]+)/)?.[1] ?? 1);
+    const useFile = (meta.match(/useFileScale: (\d)/)?.[1] ?? '1') === '1';
+    return g * (useFile ? 0.01 : 1);
+  } catch { return 0.01; }
+}
+
+const modelsDir = path.join(packDir, 'models');
+const outDir = path.join(packDir, 'assemblies');
+fs.rmSync(outDir, { recursive: true, force: true });
+fs.mkdirSync(outDir, { recursive: true });
+const fbxCopied = new Set();
+const fbxSource = {};   // final filename → assetPath (same-named props from different packs collide)
+const fbxScale = {};    // final filename → Unity effective import scale, shipped as fbxScale.json
+let missingMeshes = 0;
+const made = [];
+for (const run of runs) {
+  const name = variantLabel(run).replace(/[^\w.-]+/g, '_');
+  const parts = [];
+  for (const e of run.entries) {
+    if (e.active === false) continue;   // disabled variant geometry — Unity hides it, so do we
+    let file = null;
+    const assetPath = e.meshGuid && guidMap.get(e.meshGuid);
+    if (e.mesh === 'unity default resources' && e.meshName) file = `builtin:${e.meshName}`;
+    else if (assetPath?.endsWith('.asset')) file = libFor(assetPath);
+    else if (assetPath && /\.fbx$/i.test(assetPath)) {
+      file = path.basename(assetPath);
+      if (fbxSource[file] && fbxSource[file] !== assetPath) {
+        // same basename from a different pack — prefix with the pack dir (Polygon*)
+        const pack = assetPath.split(path.sep).findLast((s) => /^Polygon/i.test(s)) ?? path.basename(path.dirname(assetPath));
+        file = `${pack}_${file}`;
+      }
+      if (!fbxSource[file]) {
+        fs.copyFileSync(assetPath, path.join(modelsDir, file));   // always overwrite — purge stale first-run copies
+        fbxSource[file] = assetPath;
+        fbxScale[file] = +metaScale(assetPath).toFixed(6);
+        fbxCopied.add(file);
+      }
+    }
+    if (!file) { missingMeshes++; continue; }
+    const m0 = (e.materials ?? []).find((m) => m);
+    parts.push({
+      file,
+      pos: flipPos(e.pos), quat: flipQuat(e.quat), scale: e.scale.map((v) => +v.toFixed(5)),
+      ...(m0?.mainTex ? { tex: m0.mainTex } : {}),
+      ...(m0 && m0.color?.some((c, i) => Math.abs(c - 1) > 0.01 && i < 3) ? { color: m0.color.slice(0, 3).map((c) => +c.toFixed(3)) } : {}),
+      ...(m0 && (m0.tiling?.[0] !== 1 || m0.tiling?.[1] !== 1) ? { tiling: m0.tiling } : {}),
+    });
+  }
+  if (!parts.length) continue;
+  fs.writeFileSync(path.join(outDir, `${name}.json`), JSON.stringify({ name, parts }));
+  made.push(name);
+}
+// reconstructed parts where Kiwi's own assets are gone upstream (e.g. SimpleRoundabout
+// road meshes whose generated .assets were deleted): patches/<Assembly>.json parts are
+// merged in on every rebuild so the reconstruction survives truth re-exports.
+const patchDir = path.join(packDir, 'patches');
+let patched = 0;
+if (fs.existsSync(patchDir)) {
+  for (const f of fs.readdirSync(patchDir)) {
+    if (!f.endsWith('.json')) continue;
+    const name = f.slice(0, -5);
+    const patch = JSON.parse(fs.readFileSync(path.join(patchDir, f), 'utf8'));
+    const outPath = path.join(outDir, `${name}.json`);
+    const man = fs.existsSync(outPath) ? JSON.parse(fs.readFileSync(outPath, 'utf8')) : { name, parts: [] };
+    man.parts.push(...patch.parts);
+    fs.writeFileSync(outPath, JSON.stringify(man));
+    if (!made.includes(name)) made.push(name);
+    patched++;
+  }
+}
+fs.writeFileSync(path.join(outDir, 'index.json'), JSON.stringify([...new Set(made)].sort()));
+fs.writeFileSync(path.join(packDir, 'fbxScale.json'), JSON.stringify(fbxScale, null, 1));
+if (patched) console.log(`${patched} assembly patches merged`);
+
+// textures
+const texSrc = path.join(exportDir, 'textures');
+const texDir = path.join(packDir, 'textures');
+fs.mkdirSync(texDir, { recursive: true });
+let texN = 0;
+for (const t of fs.readdirSync(texSrc)) {
+  if (t.endsWith('.meta')) continue;   // Unity bookkeeping, not an asset
+  fs.copyFileSync(path.join(texSrc, t), path.join(texDir, t));
+  texN++;
+}
+
+console.log(`${made.length} assemblies from Unity truth · ${fbxCopied.size} new FBX parts copied · ${texN} textures · ${missingMeshes} entries without a resolvable mesh`);

package/tools/unityMeshToGlb.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+// UNITY .ASSET MESH → GLB — salvage text-serialized Unity meshes (YAML, serializedVersion
+// 12) without opening Unity. Built to recover Nick's hand-tuned Kiwi road pieces
+// (junctions, road segments, interchanges) into a Sindicate pack.
+//
+//   node tools/unityMeshToGlb.mjs <src.asset|srcDir> <outDir>
+//
+// Reads m_VertexData (interleaved stream-0 channels: 0=position 1=normal 2=tangent
+// 3=color 4=uv0, format 0 = float32), m_IndexBuffer (u16/u32 by m_IndexFormat) and
+// m_SubMeshes; converts LEFT-handed Unity → RIGHT-handed glTF (negate X on positions
+// and normals, reverse triangle winding); emits a minimal GLB with one primitive per
+// submesh. Skips compressed meshes (m_CompressedMesh with non-zero payload) — none of
+// the Kiwi road meshes are compressed.
+import fs from 'node:fs';
+import path from 'node:path';
+import { writeGlb } from './glbWrite.mjs';
+
+const CH_NAMES = ['POSITION', 'NORMAL', 'TANGENT', 'COLOR_0', 'TEXCOORD_0', 'TEXCOORD_1'];
+
+function parseMeshYaml(text, name) {
+  const num = (re) => { const m = text.match(re); return m ? Number(m[1]) : null; };
+  const hex = (re) => { const m = text.match(re); return m ? m[1] : ''; };
+  const vertexCount = num(/m_VertexCount: (\d+)/);
+  const indexFormat = num(/m_IndexFormat: (\d+)/) ?? 0;
+  const indexHex = hex(/m_IndexBuffer: ([0-9a-f]+)/);
+  const dataHex = hex(/_typelessdata: ([0-9a-f]+)/);
+  if (!vertexCount || !indexHex || !dataHex) throw new Error(`${name}: not a parseable mesh (missing buffers)`);
+
+  // channels: 14 fixed slots, stream/offset/format/dimension quads in order
+  const chBlock = text.match(/m_Channels:\n((?:\s+- stream: .*\n(?:\s+\w+: .*\n)*)+)/);
+  if (!chBlock) throw new Error(`${name}: no channel table`);
+  const quads = [...chBlock[1].matchAll(/- stream: (\d+)\n\s+offset: (\d+)\n\s+format: (\d+)\n\s+dimension: (\d+)/g)]
+    .map((m) => ({ stream: +m[1], offset: +m[2], format: +m[3], dimension: +m[4] & 0x7f }));
+  const active = quads.map((c, i) => ({ ...c, slot: i })).filter((c) => c.dimension > 0);
+  for (const c of active) {
+    if (c.stream !== 0) throw new Error(`${name}: multi-stream vertex data not supported (slot ${c.slot})`);
+    if (c.format !== 0) throw new Error(`${name}: non-float32 channel (slot ${c.slot} format ${c.format})`);
+  }
+  const stride = Math.max(...active.map((c) => c.offset + c.dimension * 4));
+
+  const data = Buffer.from(dataHex, 'hex');
+  if (data.length < vertexCount * stride) throw new Error(`${name}: vertex buffer short (${data.length} < ${vertexCount}×${stride})`);
+  const idxBuf = Buffer.from(indexHex, 'hex');
+  const idxSize = indexFormat === 0 ? 2 : 4;
+  const indices = [];
+  for (let o = 0; o + idxSize <= idxBuf.length; o += idxSize) {
+    indices.push(indexFormat === 0 ? idxBuf.readUInt16LE(o) : idxBuf.readUInt32LE(o));
+  }
+
+  // submeshes (topology 0 = triangles only)
+  const subs = [...text.matchAll(/firstByte: (\d+)\n\s+indexCount: (\d+)\n\s+topology: (\d+)\n\s+baseVertex: (\d+)/g)]
+    .map((m) => ({ firstIndex: +m[1] / idxSize, indexCount: +m[2], topology: +m[3], baseVertex: +m[4] }));
+  for (const s of subs) if (s.topology !== 0) throw new Error(`${name}: non-triangle submesh`);
+
+  // de-interleave the channels we keep, converting handedness
+  const attrs = {};
+  for (const c of active) {
+    if (c.slot > 5) continue;                              // uv1 is the last we care about
+    const semantic = CH_NAMES[c.slot];
+    if (!semantic) continue;
+    const out = new Float32Array(vertexCount * c.dimension);
+    for (let v = 0; v < vertexCount; v++) {
+      const base = v * stride + c.offset;
+      for (let d = 0; d < c.dimension; d++) out[v * c.dimension + d] = data.readFloatLE(base + d * 4);
+      if ((c.slot === 0 || c.slot === 1) && c.dimension >= 1) out[v * c.dimension] *= -1;   // negate X
+    }
+    attrs[semantic] = { array: out, dim: c.dimension };
+  }
+  if (!attrs.POSITION) throw new Error(`${name}: no positions`);
+  // reverse winding (handedness flip turns faces inside out otherwise)
+  for (let i = 0; i + 2 < indices.length; i += 3) { const t = indices[i]; indices[i] = indices[i + 2]; indices[i + 2] = t; }
+
+  return { name, vertexCount, indices, attrs, subs };
+}
+
+
+const [src, outDir] = process.argv.slice(2);
+if (!src || !outDir) { console.error('usage: unityMeshToGlb.mjs <src.asset|srcDir> <outDir>'); process.exit(1); }
+fs.mkdirSync(outDir, { recursive: true });
+const files = fs.statSync(src).isDirectory()
+  ? fs.readdirSync(src).filter((f) => f.endsWith('.asset')).map((f) => path.join(src, f))
+  : [src];
+let ok = 0, skip = 0;
+for (const f of files) {
+  const name = path.basename(f, '.asset');
+  try {
+    const text = fs.readFileSync(f, 'utf8');
+    if (!/^%YAML/.test(text) || !/!u!43 /.test(text)) { skip++; continue; }   // not a text mesh asset
+    const mesh = parseMeshYaml(text, name);
+    const r = writeGlb(mesh, path.join(outDir, `${name}.glb`));
+    console.log(`${name}: ${r.verts} verts, ${r.tris} tris, ${r.prims} prim(s), ${(r.bytes / 1024).toFixed(0)}KB`);
+    ok++;
+  } catch (e) { console.warn(`SKIP ${name}: ${e.message}`); skip++; }
+}
+console.log(`\n${ok} converted, ${skip} skipped`);