sindicate 0.13.0 → 0.16.0

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

package/tools/unityPackageExtract.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+// UNITYPACKAGE EXTRACT — pull NAMED assets out of a .unitypackage.
+//
+// The dev-server importer takes a whole pack; this is for when you want a handful of things
+// out of a 90 MB archive (the cars from POLYGON City, say) without staging the other 2,000
+// assets. A .unitypackage is a gzip tar of GUID directories, each holding `pathname`,
+// `asset` and `asset.meta`; this rebuilds the real filenames for whatever matches.
+//
+//   node tools/unityPackageExtract.mjs <pkg.unitypackage> <outDir> <regex> [--list]
+//
+// The .meta travels with each asset because Unity keeps the FBX import scale there, and
+// Synty packs mix metre- and centimetre-authored models (see tools/fbxToGlb.mjs).
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+
+const [pkg, outDir, pattern, ...rest] = process.argv.slice(2);
+if (!pkg || !outDir || !pattern) {
+  console.error('usage: unityPackageExtract.mjs <pkg.unitypackage> <outDir> <regex> [--list]');
+  process.exit(1);
+}
+const listOnly = rest.includes('--list');
+const re = new RegExp(pattern, 'i');
+
+const work = fs.mkdtempSync(path.join(os.tmpdir(), 'unitypkg-'));
+try {
+  execFileSync('tar', ['xzf', pkg, '-C', work], { stdio: ['ignore', 'ignore', 'pipe'] });
+  const hits = [];
+  for (const dir of fs.readdirSync(work)) {
+    const base = path.join(work, dir);
+    const pnFile = path.join(base, 'pathname');
+    if (!fs.existsSync(pnFile)) continue;
+    const assetPath = fs.readFileSync(pnFile, 'utf8').split('\n')[0].trim();
+    if (!re.test(assetPath)) continue;
+    if (!fs.existsSync(path.join(base, 'asset'))) continue;    // a folder entry, not a file
+    hits.push({ dir: base, assetPath });
+  }
+  hits.sort((a, b) => a.assetPath.localeCompare(b.assetPath));
+  if (listOnly) {
+    for (const h of hits) console.log(h.assetPath);
+    console.log(`\n${hits.length} matching assets`);
+  } else {
+    fs.mkdirSync(outDir, { recursive: true });
+    for (const h of hits) {
+      const name = path.basename(h.assetPath);
+      fs.copyFileSync(path.join(h.dir, 'asset'), path.join(outDir, name));
+      const meta = path.join(h.dir, 'asset.meta');
+      if (fs.existsSync(meta)) fs.copyFileSync(meta, path.join(outDir, `${name}.meta`));
+      console.log(`${name}  ←  ${h.assetPath}`);
+    }
+    console.log(`\n${hits.length} assets extracted to ${outDir}`);
+  }
+} finally {
+  fs.rmSync(work, { recursive: true, force: true });
+}

package/tools/unityPrefabToAssembly.mjs

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+// UNITY .PREFAB → ASSEMBLY MANIFEST — rebuild Nick's CONSTRUCTED Kiwi road junctions
+// (roundabouts, overpasses, dumbbells) as manifests of SHARED parts + transforms:
+//   { name, parts: [{ file, pos:[x,y,z], quat:[x,y,z,w], scale:[x,y,z] }], missing: [] }
+// Parts reference the deduped KiwiRoads library (aliases.json), so a hundred-piece
+// interchange costs a few kilobytes and every guardrail mesh is loaded ONCE — reuse,
+// never copies.
+//
+//   node tools/unityPrefabToAssembly.mjs <kiwiAssetsDir> <packDir> <prefabDir...>
+//
+// Parses the YAML class docs: GameObject(1), Transform(4), MeshFilter(33) and nested
+// PrefabInstance(1001) (m_SourcePrefab guid + m_Modifications overrides on the source's
+// root transform), recursing into Kiwi-local source prefabs. Meshes referenced from FBX
+// model files (Synty signs/barriers) are recorded in `missing` with their file names —
+// they wire to the POLYGON_City pack import later. Handedness matches unityMeshToGlb:
+// position x negated, quaternion (x,y,z,w) → (x,-y,-z,w).
+import fs from 'node:fs';
+import path from 'node:path';
+
+const [kiwiAssets, packDir, ...prefabDirs] = process.argv.slice(2);
+if (!kiwiAssets || !packDir || !prefabDirs.length) {
+  console.error('usage: unityPrefabToAssembly.mjs <kiwiAssetsDir> <packDir> <prefabDir...>');
+  process.exit(1);
+}
+
+// ── guid → asset path map (scan .meta files once) ──
+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);
+console.log(`guid map: ${guidMap.size} assets`);
+
+// material guid → its main texture's asset path (URP _BaseMap or legacy _MainTex)
+const texNeeded = new Map();
+const matTexCache = new Map();
+function textureOfMaterial(matGuid) {
+  if (!matGuid) return null;
+  if (matTexCache.has(matGuid)) return matTexCache.get(matGuid);
+  let texPath = null;
+  const matPath = guidMap.get(matGuid);
+  if (matPath && matPath.endsWith('.mat')) {
+    const y = fs.readFileSync(matPath, 'utf8');
+    const m = y.match(/_(?:BaseMap|MainTex):\n\s+m_Texture: \{fileID: \d+, guid: ([0-9a-f]{32})/);
+    const tp = m ? guidMap.get(m[1]) : null;
+    if (tp && /\.(png|jpg|jpeg|tga)$/i.test(tp)) { texPath = tp; texNeeded.set(path.basename(tp), tp); }
+  }
+  matTexCache.set(matGuid, texPath);
+  return texPath;
+}
+
+// ── converted-name resolution: asset path → canonical lib GLB (via aliases.json) ──
+const aliases = JSON.parse(fs.readFileSync(path.join(packDir, 'aliases.json'), 'utf8'));
+const ROADMESHES = path.join(kiwiAssets, 'AIGenerateMap/Generated/RoadMeshes');
+function libNameFor(assetPath) {
+  let rel;
+  if (assetPath.startsWith(ROADMESHES)) rel = path.relative(ROADMESHES, assetPath).replace(/\.asset$/, '.glb');
+  else rel = path.basename(assetPath).replace(/\.asset$/, '.glb');
+  return aliases[rel] ?? null;
+}
+
+// ── minimal Unity YAML doc parser ──
+function parseDocs(text) {
+  const docs = [];
+  const re = /^--- !u!(\d+) &(-?\d+)( stripped)?$/gm;
+  let m, prev = null;
+  while ((m = re.exec(text))) {
+    if (prev) prev.body = text.slice(prev.end, m.index);
+    prev = { cls: +m[1], id: m[2], stripped: !!m[3], end: m.index + m[0].length };
+    docs.push(prev);
+  }
+  if (prev) prev.body = text.slice(prev.end);
+  return docs;
+}
+const ref = (body, key) => body.match(new RegExp(`${key}: \\{fileID: (-?\\d+)(?:, guid: ([0-9a-f]{32}))?`))?.slice(1) ?? [null, null];
+const vec = (body, key, dims) => {
+  const m = body.match(new RegExp(`${key}: \\{x: ([-\\d.e]+), y: ([-\\d.e]+), z: ([-\\d.e]+)(?:, w: ([-\\d.e]+))?\\}`));
+  if (!m) return null;
+  return m.slice(1, 1 + dims).map(Number);
+};
+
+// ── quaternion/matrix helpers (column-major 4x4, y-up) ──
+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 tx = 2 * (y * vz - z * vy), ty = 2 * (z * vx - x * vz), tz = 2 * (x * vy - y * vx);
+  return [vx + w * tx + y * tz - z * ty, vy + w * ty + z * tx - x * tz, vz + w * tz + x * ty - y * tx];
+};
+const trsCompose = (p, q, s, cp, cq, cs) => ({
+  // parent (p,q,s) ∘ child (cp,cq,cs)
+  p: (() => { const sc = [cp[0] * s[0], cp[1] * s[1], cp[2] * s[2]]; const r = qRot(q, sc); return [p[0] + r[0], p[1] + r[1], p[2] + r[2]]; })(),
+  q: qMul(q, cq),
+  s: [s[0] * cs[0], s[1] * cs[1], s[2] * cs[2]],
+});
+const ID = { p: [0, 0, 0], q: [0, 0, 0, 1], s: [1, 1, 1] };
+
+// ── prefab → parts (recursive over nested PrefabInstances) ──
+const prefabCache = new Map();
+const fbxNeeded = new Map();   // basename → source path (copied into the pack after assembly)
+function loadPrefab(file) {
+  if (prefabCache.has(file)) return prefabCache.get(file);
+  const docs = parseDocs(fs.readFileSync(file, 'utf8'));
+  const gos = new Map(), transforms = new Map(), filters = [], instances = [], renderers = new Map(), stripped = new Map();
+  for (const d of docs) {
+    if (d.cls === 1) gos.set(d.id, { name: d.body.match(/m_Name: (.*)/)?.[1] ?? '?' });
+    else if (d.cls === 4) {
+      if (d.stripped) {
+        // a stripped Transform stands in for a transform INSIDE a PrefabInstance —
+        // children parented to it belong under that instance's world transform
+        stripped.set(d.id, d.body.match(/m_PrefabInstance: \{fileID: (-?\d+)/)?.[1] ?? null);
+        continue;
+      }
+      transforms.set(d.id, {
+        go: ref(d.body, 'm_GameObject')[0],
+        father: ref(d.body, 'm_Father')[0],
+        p: vec(d.body, 'm_LocalPosition', 3) ?? [0, 0, 0],
+        q: vec(d.body, 'm_LocalRotation', 4) ?? [0, 0, 0, 1],
+        s: vec(d.body, 'm_LocalScale', 3) ?? [1, 1, 1],
+      });
+    } else if (d.cls === 33) {
+      const [fid, guid] = ref(d.body, 'm_Mesh');
+      filters.push({ go: ref(d.body, 'm_GameObject')[0], meshGuid: guid, meshFid: fid });
+    } else if (d.cls === 23) {
+      const matGuid = d.body.match(/m_Materials:\n\s+- \{fileID: \d+, guid: ([0-9a-f]{32})/)?.[1] ?? null;
+      renderers.set(ref(d.body, 'm_GameObject')[0], matGuid);
+    } else if (d.cls === 1001) {
+      const srcGuid = d.body.match(/m_SourcePrefab: \{fileID: \d+, guid: ([0-9a-f]{32})/)?.[1];
+      const parent = d.body.match(/m_TransformParent: \{fileID: (-?\d+)/)?.[1] ?? '0';
+      // OVERRIDES ARE PER-TARGET: group by the fileID they modify inside the source
+      const modsByTarget = {};
+      for (const mm of d.body.matchAll(/- target: \{fileID: (-?\d+), guid: [0-9a-f]{32}, type: \d+\}\n\s+propertyPath: (m_Local(?:Position|Rotation|Scale)\.[xyzw])\n\s+value: ([-\d.e]+)/g)) {
+        (modsByTarget[mm[1]] ??= {})[mm[2]] = Number(mm[3]);
+      }
+      instances.push({ id: d.id, srcGuid, parent, modsByTarget });
+    }
+  }
+  const out = { gos, transforms, filters, instances, renderers, stripped };
+  prefabCache.set(file, out);
+  return out;
+}
+
+function worldOf(transforms, tid) {
+  const chain = [];
+  let cur = tid;
+  let guard = 0;
+  while (cur && cur !== '0' && transforms.has(cur) && guard++ < 64) { chain.unshift(transforms.get(cur)); cur = transforms.get(cur).father; }
+  let acc = ID;
+  for (const t of chain) acc = trsCompose(acc.p, acc.q, acc.s, t.p, t.q, t.s);
+  return acc;
+}
+
+function assemble(file, base = ID, depth = 0) {
+  if (depth > 4) return { parts: [], missing: [] };
+  const { gos, transforms, filters, instances } = loadPrefab(file);
+  const tByGo = new Map([...transforms.entries()].map(([id, t]) => [t.go, id]));
+  const parts = [], missing = [];
+  for (const f of filters) {
+    const tid = tByGo.get(f.go);
+    const w = tid ? worldOf(transforms, tid) : ID;
+    const acc = trsCompose(base.p, base.q, base.s, w.p, w.q, w.s);
+    const assetPath = f.meshGuid ? guidMap.get(f.meshGuid) : null;
+    const texPath = textureOfMaterial(loadPrefab(file).renderers.get(f.go));
+    const tex = texPath ? path.basename(texPath) : undefined;
+    if (assetPath && assetPath.endsWith('.asset')) {
+      const lib = libNameFor(assetPath);
+      if (lib) { parts.push({ file: lib, ...(tex ? { tex } : {}), ...acc }); continue; }
+    }
+    if (assetPath && /\.fbx$/i.test(assetPath)) {
+      fbxNeeded.set(path.basename(assetPath), assetPath);
+      parts.push({ file: path.basename(assetPath), ...(tex ? { tex } : {}), ...acc });
+      continue;
+    }
+    missing.push({ mesh: assetPath ? path.basename(assetPath) : `guid:${f.meshGuid}#${f.meshFid}`, from: gos.get(f.go)?.name });
+  }
+  const instWorlds = new Map();   // instance id → resolved world (for stripped-parented children)
+  for (const inst of instances) {
+    const src = inst.srcGuid ? guidMap.get(inst.srcGuid) : null;
+    // the SOURCE's own root transform provides the DEFAULTS; mods targeting that root override
+    let srcRoot = { p: [0, 0, 0], q: [0, 0, 0, 1], s: [1, 1, 1] }, srcRootId = null;
+    if (src && src.endsWith('.prefab')) {
+      const sp = loadPrefab(src);
+      for (const [tid, t] of sp.transforms) if (!t.father || t.father === '0') { srcRoot = t; srcRootId = tid; break; }
+    }
+    const mods = (srcRootId && inst.modsByTarget[srcRootId]) ?? Object.values(inst.modsByTarget)[0] ?? {};
+    const local = {
+      p: [mods['m_LocalPosition.x'] ?? srcRoot.p[0], mods['m_LocalPosition.y'] ?? srcRoot.p[1], mods['m_LocalPosition.z'] ?? srcRoot.p[2]],
+      q: [mods['m_LocalRotation.x'] ?? srcRoot.q[0], mods['m_LocalRotation.y'] ?? srcRoot.q[1], mods['m_LocalRotation.z'] ?? srcRoot.q[2], mods['m_LocalRotation.w'] ?? srcRoot.q[3]],
+      s: [mods['m_LocalScale.x'] ?? srcRoot.s[0], mods['m_LocalScale.y'] ?? srcRoot.s[1], mods['m_LocalScale.z'] ?? srcRoot.s[2]],
+    };
+    // the instance parents into THIS prefab's hierarchy — possibly via a STRIPPED transform
+    // standing in for a transform inside an earlier PrefabInstance
+    const here = loadPrefab(file);
+    let parentW = ID;
+    if (inst.parent && inst.parent !== '0') {
+      if (here.transforms.has(inst.parent)) parentW = worldOf(here.transforms, inst.parent);
+      else if (here.stripped.has(inst.parent)) parentW = instWorlds.get(here.stripped.get(inst.parent)) ?? ID;
+    }
+    const baseW = trsCompose(base.p, base.q, base.s, parentW.p, parentW.q, parentW.s);
+    const instW = trsCompose(baseW.p, baseW.q, baseW.s, local.p, local.q, local.s);
+    instWorlds.set(inst.id, instW);
+    if (src && src.endsWith('.prefab')) {
+      const sub = assemble(src, instW, depth + 1);
+      parts.push(...sub.parts);
+      missing.push(...sub.missing);
+    } else if (src && /\.fbx$/i.test(src)) {
+      fbxNeeded.set(path.basename(src), src);
+      parts.push({ file: path.basename(src), ...instW });
+    } else if (src) {
+      missing.push({ mesh: path.basename(src), from: 'unresolved instance' });
+    }
+  }
+  return { parts, missing };
+}
+
+// unity → three handedness on the FINAL transforms
+const flip = (t) => ({
+  pos: [-t.p[0], t.p[1], t.p[2]].map((v) => +v.toFixed(5)),
+  quat: [t.q[0], -t.q[1], -t.q[2], t.q[3]].map((v) => +v.toFixed(6)),
+  scale: t.s.map((v) => +v.toFixed(5)),
+});
+
+const outDir = path.join(packDir, 'assemblies');
+fs.mkdirSync(outDir, { recursive: true });
+const made = [];
+for (const dir of prefabDirs) {
+  const files = [];
+  (function walk(d) {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name.endsWith('.prefab')) files.push(p);
+    }
+  })(dir);
+  for (const f of files) {
+    // variant dirs (Motorway/DualCarriageway/L2-R1…) share basenames — the name carries the path
+    const relName = path.relative(dir, f).replace(/\.prefab$/, '');
+    const name = relName.split(path.sep).filter((seg, i, a) => !a[i + 1]?.startsWith(seg)).join('_').replace(/[^\w.-]+/g, '_');
+    try {
+      const { parts, missing } = assemble(f);
+      const manifest = {
+        name,
+        parts: parts.map((p) => ({ file: p.file, ...(p.tex ? { tex: p.tex } : {}), ...flip(p) })),
+        missing: missing.map((m) => (m.p ? { mesh: m.mesh, from: m.from, ...flip(m) } : m)),
+      };
+      fs.writeFileSync(path.join(outDir, `${name}.json`), JSON.stringify(manifest));
+      made.push(name);
+      console.log(`${name}: ${parts.length} parts, ${missing.length} missing`);
+    } catch (e) { console.warn(`SKIP ${name}: ${e.message}`); }
+  }
+}
+fs.writeFileSync(path.join(outDir, 'index.json'), JSON.stringify([...new Set(made)].sort()));
+// copy every referenced Synty FBX into the pack's model library (shared, deduped by name)
+const modelsDir = path.join(packDir, 'models');
+let copied = 0;
+for (const [name, srcPath] of fbxNeeded) {
+  const dst = path.join(modelsDir, name);
+  if (!fs.existsSync(dst)) { fs.copyFileSync(srcPath, dst); copied++; }
+}
+const texDir = path.join(packDir, 'textures');
+fs.mkdirSync(texDir, { recursive: true });
+let texCopied = 0;
+for (const [name, srcPath] of texNeeded) {
+  const dst = path.join(texDir, name);
+  if (!fs.existsSync(dst)) { fs.copyFileSync(srcPath, dst); texCopied++; }
+}
+console.log(`\n${made.length} assemblies · ${fbxNeeded.size} shared FBX parts (${copied} copied) · ${texNeeded.size} textures (${texCopied} copied)`);