sindicate 0.12.0 → 0.15.0

package/tools/rebuildSimpleRoundabouts.mjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+// REBUILD SIMPLE ROUNDABOUTS — Kiwi's SimpleRoundabout_01_R1..R4 prefabs reference five
+// generated meshes (Roundabout + CountryRoad_1..4) whose .assets were deleted from the
+// project (guids dangle in every copy; Unity renders the prefabs lights-only). This is a
+// 1:1 port of the generator that built them — InterCityRoadWindow_Roundabout.cs
+// GenerateRoundabout() / GenerateRoundaboutCountryRoad() with the batch defaults from
+// SaveAllSimpleRoundaboutPrefabs() — emitting pack GLBs plus assembly patches that
+// truthToAssemblies merges on every rebuild.
+//
+//   node tools/rebuildSimpleRoundabouts.mjs <packDir>
+//
+// Geometry is generated in Unity space exactly as the C# did, then flipped to the pack's
+// right-handed convention the same way unityMeshToGlb does (negate X, reverse winding).
+// UVs are constant palette texels into T_SimpligonUniverse_02_A_01.png (no tiling) —
+// same convention as every surviving generated road mesh.
+import fs from 'node:fs';
+import path from 'node:path';
+import { writeGlb } from './glbWrite.mjs';
+
+const [packDir] = process.argv.slice(2);
+if (!packDir) { console.error('usage: rebuildSimpleRoundabouts.mjs <packDir>'); process.exit(1); }
+
+// batch defaults (SaveAllSimpleRoundaboutPrefabs used the window's serialized defaults)
+const SEGMENTS = 64;
+const INNER_R = 30, LANES = 2, LANE_W = 5, SHOULDER = 1.5;
+const OUTER_R = INNER_R + LANES * LANE_W;               // 40
+const TOTAL_INNER = INNER_R - SHOULDER;                 // 28.5
+const TOTAL_OUTER = OUTER_R + SHOULDER;                 // 41.5
+const MARK_Y = 0.02;
+const RING_EDGE_W = 0.15;
+const CURB_H = 0.15, CURB_W = 0.4;
+const ISLAND_R = TOTAL_INNER - 0.5;                     // 28.0
+const ARM_LEN = 50, ARM_SEGS = 20;
+const VERGE_W = 1.5, ARM_HALF_W = LANE_W + VERGE_W;     // 6.5 (2 lanes @5 + verges: 5*2/2+1.5)
+const ARM_EDGE_W = 0.1;
+const TRI_LEN = 4, TRI_HALF_W = 1.25;
+const CAP_SEGS = 10, CAP_OVERLAP = 0.15;
+// palette texels in the Simpligon atlas (flat-colour sampling, no tiling)
+const UV_ASPHALT = [0.2871, 0.0361];
+const UV_WHITE = [0.2871, 0.1105];
+const UV_GRASS = [0.2141, 0.0398];
+const TEX = 'T_SimpligonUniverse_02_A_01.png';
+
+function builder(name) {
+  const pos = [], uv = [], idx = [];
+  const b = {
+    name,
+    get count() { return pos.length / 3; },
+    vert(p, t) { pos.push(p[0], p[1], p[2]); uv.push(t[0], t[1]); return pos.length / 3 - 1; },
+    tri(a, c, d) { idx.push(a, c, d); },
+    // strip quads over interleaved [left/inner, right/outer] pairs — the generator's pattern
+    stripTris(base, rows) {
+      for (let i = 0; i < rows - 1; i++) {
+        const k = base + i * 2;
+        b.tri(k, k + 2, k + 1);
+        b.tri(k + 1, k + 2, k + 3);
+      }
+    },
+    mesh() {
+      // Unity → pack handedness: negate X, reverse winding (same as unityMeshToGlb)
+      const P = new Float32Array(pos);
+      for (let i = 0; i < P.length; i += 3) P[i] *= -1;
+      for (let i = 0; i + 2 < idx.length; i += 3) { const t = idx[i]; idx[i] = idx[i + 2]; idx[i + 2] = t; }
+      const N = new Float32Array(P.length);
+      for (let i = 1; i < N.length; i += 3) N[i] = 1;    // everything is horizontal: (0,1,0)
+      return {
+        name, vertexCount: P.length / 3, indices: idx,
+        attrs: { POSITION: { array: P, dim: 3 }, NORMAL: { array: N, dim: 3 }, TEXCOORD_0: { array: new Float32Array(uv), dim: 2 } },
+        subs: [{ firstIndex: 0, indexCount: idx.length, baseVertex: 0 }],
+      };
+    },
+  };
+  return b;
+}
+
+// AddRingSegment: 65 rows inclusive (duplicated seam), pairs [inner, outer], x=cos z=sin
+function addRing(b, rI, rO, y, t) {
+  const base = b.count;
+  for (let i = 0; i <= SEGMENTS; i++) {
+    const a = i * (Math.PI * 2 / SEGMENTS);
+    b.vert([Math.cos(a) * rI, y, Math.sin(a) * rI], t);
+    b.vert([Math.cos(a) * rO, y, Math.sin(a) * rO], t);
+  }
+  b.stripTris(base, SEGMENTS + 1);
+}
+
+function buildRing() {
+  const b = builder('Roundabout');
+  addRing(b, TOTAL_INNER, TOTAL_OUTER, 0, UV_ASPHALT);                        // deck annulus
+  addRing(b, INNER_R - RING_EDGE_W, INNER_R, MARK_Y, UV_WHITE);               // inner edge line
+  addRing(b, OUTER_R, OUTER_R + RING_EDGE_W, MARK_Y, UV_WHITE);               // outer edge line
+  // lane-divider dash arcs at r=35 (lanes=2 → one divider)
+  const laneR = INNER_R + 1 * LANE_W, dashW = 0.12;
+  const numDashes = Math.floor((Math.PI * 2 * laneR) / 5);                    // 3m dash / 2m gap
+  const cycle = (Math.PI * 2) / numDashes, dashAngle = cycle * (3 / 5);
+  for (let d = 0; d < numDashes; d++) {
+    const base = b.count;
+    for (let s = 0; s <= 4; s++) {
+      const a = d * cycle + dashAngle * (s / 4);
+      b.vert([Math.cos(a) * (laneR - dashW / 2), MARK_Y, Math.sin(a) * (laneR - dashW / 2)], UV_WHITE);
+      b.vert([Math.cos(a) * (laneR + dashW / 2), MARK_Y, Math.sin(a) * (laneR + dashW / 2)], UV_WHITE);
+    }
+    b.stripTris(base, 5);
+  }
+  addRing(b, ISLAND_R - CURB_W, ISLAND_R, CURB_H, UV_GRASS);                  // island kerb ring
+  // island fill disk (fan)
+  const c = b.vert([0, CURB_H * 0.5, 0], UV_GRASS);
+  for (let i = 0; i <= SEGMENTS; i++) {
+    const a = i * (Math.PI * 2 / SEGMENTS);
+    b.vert([Math.cos(a) * (ISLAND_R - CURB_W), CURB_H * 0.5, Math.sin(a) * (ISLAND_R - CURB_W)], UV_GRASS);
+  }
+  for (let i = 0; i < SEGMENTS; i++) b.tri(c, c + 1 + i + 1, c + 1 + i);
+  return b.mesh();
+}
+
+function buildArm(k) {
+  const b = builder(`CountryRoad_${k}`);
+  const aDeg = (k - 1) * 90, aRad = (aDeg * Math.PI) / 180;
+  const out = [Math.sin(aRad), 0, Math.cos(aRad)];                            // 0° = +Z, 90° = +X
+  const end = out.map((v) => v * TOTAL_OUTER);                                // junction point
+  const start = out.map((v) => v * (TOTAL_OUTER + ARM_LEN));
+  const tangent = [-out[0], 0, -out[2]];                                      // toward the ring
+  const right = [tangent[2], 0, -tangent[0]];                                 // Cross(up, tangent)
+  const P = (i) => start.map((v, d) => v + (end[d] - v) * (i / ARM_SEGS));
+  const flare = (i) => { const t = i / ARM_SEGS; return t > 1 - TRI_LEN / ARM_LEN ? TRI_HALF_W * ((t - (1 - TRI_LEN / ARM_LEN)) / (TRI_LEN / ARM_LEN)) : 0; };
+  const at = (i, off, y) => { const p = P(i); return [p[0] + right[0] * off, y, p[2] + right[2] * off]; };
+
+  let base = b.count;                                                          // asphalt strip
+  for (let i = 0; i <= ARM_SEGS; i++) {
+    const f = flare(i);
+    b.vert(at(i, -ARM_HALF_W - f, 0), UV_ASPHALT);
+    b.vert(at(i, ARM_HALF_W + f, 0), UV_ASPHALT);
+  }
+  b.stripTris(base, ARM_SEGS + 1);
+  base = b.count;                                                              // left solid edge line
+  for (let i = 0; i <= ARM_SEGS; i++) {
+    const f = flare(i);
+    b.vert(at(i, -ARM_HALF_W - f, MARK_Y), UV_WHITE);
+    b.vert(at(i, -ARM_HALF_W - f + ARM_EDGE_W, MARK_Y), UV_WHITE);
+  }
+  b.stripTris(base, ARM_SEGS + 1);
+  base = b.count;                                                              // right solid edge line
+  for (let i = 0; i <= ARM_SEGS; i++) {
+    const f = flare(i);
+    b.vert(at(i, ARM_HALF_W + f - ARM_EDGE_W, MARK_Y), UV_WHITE);
+    b.vert(at(i, ARM_HALF_W + f, MARK_Y), UV_WHITE);
+  }
+  b.stripTris(base, ARM_SEGS + 1);
+  base = b.count;                                                              // centre dashed line
+  const flareStartIndex = Math.floor((1 - TRI_LEN / ARM_LEN) * ARM_SEGS);      // 18
+  for (let i = 0; i <= flareStartIndex; i++) {
+    b.vert(at(i, -ARM_EDGE_W / 2, MARK_Y), UV_WHITE);
+    b.vert(at(i, ARM_EDGE_W / 2, MARK_Y), UV_WHITE);
+  }
+  for (let i = 0; i < flareStartIndex; i += 2) {                               // even segments only → dashes
+    const k2 = base + i * 2;
+    b.tri(k2, k2 + 2, k2 + 1);
+    b.tri(k2 + 1, k2 + 2, k2 + 3);
+  }
+  base = b.count;                                                              // triangle ghost island
+  for (let i = flareStartIndex; i <= ARM_SEGS; i++) {
+    const halfW = TRI_HALF_W * ((i - flareStartIndex) / (ARM_SEGS - flareStartIndex));
+    b.vert(at(i, -halfW, MARK_Y), UV_WHITE);
+    b.vert(at(i, halfW, MARK_Y), UV_WHITE);
+  }
+  b.stripTris(base, ARM_SEGS - flareStartIndex + 1);
+  // curved end cap wrapping onto the ring
+  const totalEdge = ARM_HALF_W + TRI_HALF_W;                                   // 7.75
+  const angOff = totalEdge / TOTAL_OUTER;
+  const fFinal = flare(ARM_SEGS);
+  const capL = at(ARM_SEGS, -ARM_HALF_W - fFinal, 0), capR = at(ARM_SEGS, ARM_HALF_W + fFinal, 0);
+  const row1 = b.count;
+  for (let j = 0; j <= CAP_SEGS; j++) b.vert(capL.map((v, d) => v + (capR[d] - v) * (j / CAP_SEGS)), UV_ASPHALT);
+  const row2 = b.count;
+  for (let j = 0; j <= CAP_SEGS; j++) {
+    const a = aRad + angOff + (aRad - angOff - (aRad + angOff)) * (j / CAP_SEGS);
+    b.vert([Math.sin(a) * (TOTAL_OUTER - CAP_OVERLAP), 0, Math.cos(a) * (TOTAL_OUTER - CAP_OVERLAP)], UV_ASPHALT);
+  }
+  for (let j = 0; j < CAP_SEGS; j++) {
+    b.tri(row1 + j, row2 + j, row1 + j + 1);
+    b.tri(row2 + j, row2 + j + 1, row1 + j + 1);
+  }
+  return b.mesh();
+}
+
+// ---- emit GLBs + patches ----
+const modelsDir = path.join(packDir, 'models');
+const patchDir = path.join(packDir, 'patches');
+fs.mkdirSync(patchDir, { recursive: true });
+const files = { ring: 'SimpleRoundabout_Ring.glb' };
+const r = writeGlb(buildRing(), path.join(modelsDir, files.ring));
+console.log(`${files.ring}: ${r.verts} verts, ${r.tris} tris`);
+for (let k = 1; k <= 4; k++) {
+  files[k] = `SimpleRoundabout_Arm${k}.glb`;
+  const a = writeGlb(buildArm(k), path.join(modelsDir, files[k]));
+  console.log(`${files[k]}: ${a.verts} verts, ${a.tris} tris`);
+}
+const part = (file) => ({ file, pos: [0, 0, 0], quat: [0, 0, 0, 1], scale: [1, 1, 1], tex: TEX });
+for (let n = 1; n <= 4; n++) {
+  const parts = [part(files.ring)];
+  for (let k = 1; k <= n; k++) parts.push(part(files[k]));
+  fs.writeFileSync(path.join(patchDir, `SimpleRoundabout_01_R${n}.json`), JSON.stringify({ parts }, null, 1));
+}
+// list the new GLBs in the pack's model index so the Parts view can browse them
+const idxPath = path.join(packDir, 'index.json');
+if (fs.existsSync(idxPath)) {
+  const index = JSON.parse(fs.readFileSync(idxPath, 'utf8'));
+  const add = Object.values(files).filter((f) => !index.includes(f));
+  if (add.length) fs.writeFileSync(idxPath, JSON.stringify([...index, ...add].sort()));
+}
+console.log('4 assembly patches written — run truthToAssemblies to merge');

package/tools/registry.json

@@ -0,0 +1,45 @@
+{
+  "//": "The Sindicate package catalog — what exists in the ecosystem and where it lives on this machine (repo paths relative to the Sites root, i.e. the games' parent dir). The dev GUI reads this via /__pack/registry and installs straight from it.",
+  "packages": [
+    {
+      "name": "rayhit-three",
+      "type": "addon",
+      "description": "Runtime mesh fracturing & physics destruction — Voronoi shattering, demolition, bombs, structural collapse.",
+      "repo": "rayhit-three"
+    },
+    {
+      "name": "weather-threejs",
+      "type": "addon",
+      "description": "Stylized weather, atmosphere & time-of-day — sky, sun/moon/stars, clouds, fog, rain & snow, forecast system.",
+      "repo": "weather-threejs"
+    },
+    {
+      "name": "accentimations",
+      "type": "clips",
+      "description": "The animation pack: 259 cooked clips + manifest. Dev flow consumes it via file: + registerClipPack; a packaged release is pending.",
+      "repo": "Accentimations",
+      "note": "consumed via file: dependency in dev — not yet packaged"
+    },
+    {
+      "name": "kitforge",
+      "type": "addon",
+      "description": "Kit-piece cataloguer + render-to-PNG thumbnails (feeds the importer's future thumbnail grid).",
+      "repo": "kitforge",
+      "note": "not yet manifested"
+    },
+    {
+      "name": "fft-water",
+      "type": "addon",
+      "description": "FFT ocean/water surface (from transport-tycoon-remake) — extraction pending.",
+      "repo": "transport-tycoon-remake",
+      "note": "planned — extraction not started"
+    },
+    {
+      "name": "glodify",
+      "type": "service",
+      "description": "LOD baker (CLI/REST service) — games consume its output files; never installed as a package.",
+      "repo": "glodify",
+      "note": "service, not installable"
+    }
+  ]
+}

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);