sindicate 0.13.0 → 0.16.0

package/tools/designer.js

@@ -0,0 +1,316 @@
+// THE WORLD DESIGNER (v1) — the engine's world editor. A game exposes it with a one-line
+// designer.html entry:
+//
+//   <script type="module">
+//     import { startDesigner } from 'sindicate/tools/designer.js';
+//     startDesigner({ heightAt: (x, z) => 0 });   // pass the game's heightAt for real terrain
+//   </script>
+//
+// v1: orbit viewport · prefab palette (imported packs via /__pack, plus the game's own
+// asset dirs) · click-to-place on the ground · drag-move · Q/E rotate · Delete removes ·
+// road polyline mode · save/load layout JSON through the dev middleware
+// (designs/<name>.json in the GAME repo — machine-written layouts are JSON by law).
+//
+// The DESIGNER BUS (served by designerPlugin alongside /__pack) lets an MCP server drive
+// every one of these actions programmatically while the human watches the viewport.
+import * as THREE from 'three/webgpu';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { loadModel } from '../src/core/assets.js';
+
+const state = {
+  layout: { name: 'untitled', prefabs: [], roads: [] },
+  placed: [],          // { entry, object } parallel to layout.prefabs
+  sel: -1,
+  mode: 'place',       // 'place' | 'road' | 'select'
+  activePrefab: null,  // { file, dir, tex }
+  roadPts: [],
+  heightAt: () => 0,
+};
+
+export async function startDesigner({ heightAt, worldSize = 2000 } = {}) {
+  if (heightAt) state.heightAt = heightAt;
+  document.body.style.cssText = 'margin:0;overflow:hidden;background:#101018;font:13px -apple-system,sans-serif;color:#e8e2d0';
+
+  // ── viewport ──
+  const renderer = new THREE.WebGPURenderer({ antialias: true });
+  await renderer.init();
+  renderer.setSize(innerWidth, innerHeight);
+  renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
+  document.body.appendChild(renderer.domElement);
+  const scene = new THREE.Scene();
+  scene.background = new THREE.Color(0x181826);
+  const camera = new THREE.PerspectiveCamera(55, innerWidth / innerHeight, 0.1, worldSize * 4);
+  camera.position.set(0, worldSize * 0.28, worldSize * 0.4);   // open on the whole map, not a patch of dirt
+  const controls = new OrbitControls(camera, renderer.domElement);
+  controls.target.set(0, 0, 0);
+  scene.add(new THREE.HemisphereLight(0xffffff, 0x334455, 1.2));
+  const sun = new THREE.DirectionalLight(0xfff2dd, 2.2);
+  sun.position.set(120, 180, 80);
+  scene.add(sun);
+  // the game's REAL ground, low-res — placement is judged against what the world will be,
+  // not a flat grid. 256² segments of heightAt (~66k calls, both games' heightAt is pure
+  // math) shaded by relief: valley umber up to pale bone.
+  const TSEG = 256;
+  const tGeo = new THREE.PlaneGeometry(worldSize, worldSize, TSEG, TSEG).rotateX(-Math.PI / 2);
+  {
+    const pos = tGeo.attributes.position;
+    const cols = new Float32Array(pos.count * 3);
+    let lo = Infinity, hi = -Infinity;
+    for (let i = 0; i < pos.count; i++) {
+      const h = state.heightAt(pos.getX(i), pos.getZ(i));
+      pos.setY(i, h);
+      if (h < lo) lo = h;
+      if (h > hi) hi = h;
+    }
+    for (let i = 0; i < pos.count; i++) {
+      const t = (pos.getY(i) - lo) / Math.max(1e-6, hi - lo);
+      cols[i * 3] = 0.24 + 0.5 * t; cols[i * 3 + 1] = 0.22 + 0.42 * t; cols[i * 3 + 2] = 0.18 + 0.3 * t;
+    }
+    tGeo.setAttribute('color', new THREE.BufferAttribute(cols, 3));
+    tGeo.computeVertexNormals();
+  }
+  const terrain = new THREE.Mesh(tGeo, new THREE.MeshStandardMaterial({ vertexColors: true, roughness: 1 }));
+  terrain.name = 'designer:terrain';
+  scene.add(terrain);
+  if (!heightAt) scene.add(new THREE.GridHelper(worldSize, 200, 0x3a3a52, 0x26263a));   // flat fallback still reads as a floor
+  const groundPlane = new THREE.Mesh(new THREE.PlaneGeometry(worldSize * 4, worldSize * 4).rotateX(-Math.PI / 2),
+    new THREE.MeshBasicMaterial({ visible: false }));
+  scene.add(groundPlane);
+
+  const roadLines = new THREE.Group(); scene.add(roadLines);
+  addEventListener('resize', () => {
+    camera.aspect = innerWidth / innerHeight; camera.updateProjectionMatrix();
+    renderer.setSize(innerWidth, innerHeight);
+  });
+
+  // ── UI shell ──
+  const ui = document.createElement('div');
+  ui.style.cssText = 'position:fixed;left:0;top:0;bottom:0;width:280px;overflow-y:auto;background:rgba(16,16,26,0.94);border-right:1px solid #2c2c40;padding:14px;z-index:10';
+  ui.innerHTML = `
+    <div style="color:#e8c66a;font-weight:700;letter-spacing:2px;margin-bottom:2px">SINDICATE DESIGNER</div>
+    <div id="d-status" style="color:#8d8875;font-size:11px;margin-bottom:10px">v1</div>
+    <div style="display:flex;gap:6px;margin-bottom:10px">
+      <input id="d-name" value="untitled" style="flex:1;background:#1c1c2b;border:1px solid #2c2c40;border-radius:5px;color:#e8e2d0;padding:4px 8px;font-size:12px">
+      <button id="d-save" style="${BTN}">Save</button>
+      <button id="d-load" style="${BTN}">Load</button>
+    </div>
+    <div style="display:flex;gap:6px;margin-bottom:12px">
+      <button id="d-mode-place" style="${BTN}">Place</button>
+      <button id="d-mode-road" style="${BTN}">Road</button>
+      <button id="d-mode-select" style="${BTN}">Select</button>
+    </div>
+    <div style="color:#8d8875;font-size:11px;margin-bottom:8px">click = place/pick · drag = move · Q/E rotate · Backspace delete · road mode: click points, Enter ends road</div>
+    <input id="d-filter" placeholder="filter prefabs…" style="width:100%;background:#1c1c2b;border:1px solid #2c2c40;border-radius:5px;color:#e8e2d0;padding:5px 8px;font-size:12px;margin-bottom:8px">
+    <div id="d-palette" style="font-size:12px"></div>`;
+  document.body.appendChild(ui);
+  const status = (m) => { ui.querySelector('#d-status').textContent = m; };
+
+  // ── palette: imported packs + staged inventories via the dev middleware ──
+  let palette = [];   // { label, file, dir, tex }  dir = URL prefix the model loads from
+  async function loadPalette() {
+    try {
+      const reg = await fetch('/__pack/list').then((r) => r.json());
+      for (const p of reg.imported ?? []) {
+        const files = await fetch(`/__designer/models?pack=${encodeURIComponent(p)}`).then((r) => r.json()).catch(() => ({ models: [] }));
+        for (const f of files.models ?? []) {
+          const file = f.replace(/\.(fbx|glb)$/i, '');
+          const ext = /\.glb$/i.test(f) ? 'glb' : 'fbx';
+          palette.push({ label: `${p}/${file}`, file, ext, dir: `/assets/packs/${p}/models`, ...(files.tex ? { tex: files.tex } : {}) });
+        }
+      }
+    } catch (e) { console.warn('[designer] pack palette failed', e); }
+    renderPalette();
+    status(`${palette.length} prefabs`);
+  }
+  function renderPalette(filter = '') {
+    const el = ui.querySelector('#d-palette');
+    el.innerHTML = '';
+    const f = filter.toLowerCase();
+    for (const p of palette.filter((p) => !f || p.label.toLowerCase().includes(f)).slice(0, 400)) {
+      const row = document.createElement('div');
+      row.textContent = p.label;
+      row.style.cssText = 'padding:3px 6px;border-radius:4px;cursor:pointer;color:#b8b09a;white-space:nowrap;overflow:hidden;text-overflow:ellipsis' + (state.activePrefab?.label === p.label ? ';background:#2c2c48;color:#e8c66a' : '');
+      row.onclick = () => { state.activePrefab = p; state.mode = 'place'; renderPalette(ui.querySelector('#d-filter').value); status('placing: ' + p.label); };
+      el.appendChild(row);
+    }
+  }
+  ui.querySelector('#d-filter').oninput = (e) => renderPalette(e.target.value);
+  ui.querySelector('#d-mode-place').onclick = () => { state.mode = 'place'; status('mode: place'); };
+  ui.querySelector('#d-mode-road').onclick = () => { state.mode = 'road'; state.roadPts = []; status('mode: road — click points, Enter to finish'); };
+  ui.querySelector('#d-mode-select').onclick = () => { state.mode = 'select'; status('mode: select'); };
+
+  // ── placement ──
+  const raycaster = new THREE.Raycaster();
+  const mouse = new THREE.Vector2();
+  const groundHit = (ev) => {
+    mouse.set((ev.clientX / innerWidth) * 2 - 1, -(ev.clientY / innerHeight) * 2 + 1);
+    raycaster.setFromCamera(mouse, camera);
+    const hit = raycaster.intersectObjects([terrain, groundPlane])[0];   // real ground first, flat far-field after
+    return hit ? { x: hit.point.x, z: hit.point.z } : null;
+  };
+
+  // every mutation lands in sessionStorage: vite's dep-optimize reload (first FBX load
+  // discovers new deps) or a stray F5 must never eat a layout in progress
+  const persist = () => { try { sessionStorage.setItem('sindicate-designer', JSON.stringify(state.layout)); } catch { /* full */ } };
+
+  async function placePrefab(entry) {
+    const obj = new THREE.Group();
+    obj.name = `dz:${entry.file}`;
+    try {
+      const bare = entry.file.replace(/\.(fbx|glb)$/i, '');
+      const ext = entry.ext ?? (/\.glb$/i.test(entry.file) ? 'glb' : 'fbx');
+      const model = await loadModel(`${entry.dir}/${bare}.${ext}`, entry.tex ? { texture: entry.tex } : {});
+      obj.add(model.clone ? model.clone() : model);
+    } catch (e) {
+      // placeholder box if the model can't load — the layout entry still lands
+      obj.add(new THREE.Mesh(new THREE.BoxGeometry(2, 2, 2), new THREE.MeshStandardMaterial({ color: 0xcc5533 })));
+    }
+    obj.position.set(entry.x, entry.y ?? state.heightAt(entry.x, entry.z), entry.z);
+    obj.rotation.y = entry.ry ?? 0;
+    scene.add(obj);
+    state.layout.prefabs.push(entry);
+    state.placed.push({ entry, object: obj });
+    persist();
+    return state.placed.length - 1;
+  }
+
+  function select(i) {
+    if (state.sel >= 0) state.placed[state.sel]?.object.traverse((o) => { if (o.material?.emissive) o.material.emissive?.setHex?.(0x000000); });
+    state.sel = i;
+    if (i >= 0) status(`selected #${i} ${state.placed[i].entry.file}`);
+  }
+
+  function removeSelected() {
+    if (state.sel < 0) return;
+    const { object } = state.placed[state.sel];
+    scene.remove(object);
+    state.placed.splice(state.sel, 1);
+    state.layout.prefabs.splice(state.sel, 1);
+    select(-1);
+    persist();
+  }
+
+  function redrawRoads() {
+    roadLines.clear();
+    for (const road of state.layout.roads) {
+      const pts = road.map((p) => new THREE.Vector3(p.x, state.heightAt(p.x, p.z) + 0.3, p.z));
+      roadLines.add(new THREE.Line(new THREE.BufferGeometry().setFromPoints(pts), new THREE.LineBasicMaterial({ color: 0xe8c66a })));
+    }
+    if (state.roadPts.length > 1) {
+      const pts = state.roadPts.map((p) => new THREE.Vector3(p.x, state.heightAt(p.x, p.z) + 0.3, p.z));
+      roadLines.add(new THREE.Line(new THREE.BufferGeometry().setFromPoints(pts), new THREE.LineBasicMaterial({ color: 0x7dc24a })));
+    }
+  }
+
+  renderer.domElement.addEventListener('pointerdown', async (ev) => {
+    if (ev.button !== 0 || ev.target !== renderer.domElement) return;
+    const g = groundHit(ev);
+    if (!g) return;
+    if (state.mode === 'place' && state.activePrefab) {
+      const y = state.heightAt(g.x, g.z);
+      await placePrefab({ file: state.activePrefab.file, dir: state.activePrefab.dir, ...(state.activePrefab.ext ? { ext: state.activePrefab.ext } : {}), x: +g.x.toFixed(2), y: +y.toFixed(2), z: +g.z.toFixed(2), ry: 0, ...(state.activePrefab.tex ? { tex: state.activePrefab.tex } : {}) });
+      status(`placed ${state.activePrefab.file} (${state.layout.prefabs.length} total)`);
+    } else if (state.mode === 'road') {
+      state.roadPts.push({ x: +g.x.toFixed(1), z: +g.z.toFixed(1) });
+      redrawRoads();
+    } else if (state.mode === 'select') {
+      raycaster.setFromCamera(mouse, camera);
+      const hits = raycaster.intersectObjects(state.placed.map((p) => p.object), true);
+      if (hits.length) {
+        const root = state.placed.findIndex((p) => { let o = hits[0].object; while (o) { if (o === p.object) return true; o = o.parent; } return false; });
+        select(root);
+      } else select(-1);
+    }
+  });
+
+  addEventListener('keydown', (ev) => {
+    if (ev.target.tagName === 'INPUT') return;
+    if (ev.key === 'Enter' && state.mode === 'road' && state.roadPts.length > 1) {
+      state.layout.roads.push(state.roadPts);
+      state.roadPts = [];
+      redrawRoads();
+      persist();
+      status(`road saved (${state.layout.roads.length} roads)`);
+    }
+    if (state.sel >= 0) {
+      const p = state.placed[state.sel];
+      if (ev.key === 'q' || ev.key === 'Q') { p.entry.ry = +((p.entry.ry + Math.PI / 8) % (Math.PI * 2)).toFixed(3); p.object.rotation.y = p.entry.ry; }
+      if (ev.key === 'e' || ev.key === 'E') { p.entry.ry = +((p.entry.ry - Math.PI / 8) % (Math.PI * 2)).toFixed(3); p.object.rotation.y = p.entry.ry; }
+      if (ev.key === 'Backspace' || ev.key === 'Delete') removeSelected();
+    }
+  });
+
+  // ── save / load ──
+  async function save(name) {
+    state.layout.name = name;
+    const r = await fetch(`/__designer/save?name=${encodeURIComponent(name)}`, {
+      method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(state.layout, null, 2),
+    });
+    status(r.ok ? `saved designs/${name}.json (${state.layout.prefabs.length} prefabs, ${state.layout.roads.length} roads)` : 'save failed');
+    return r.ok;
+  }
+  async function load(name) {
+    const j = await fetch(`/__designer/load?name=${encodeURIComponent(name)}`).then((r) => r.json());
+    if (j.err) { status('load failed: ' + j.err); return false; }
+    for (const p of state.placed) scene.remove(p.object);
+    state.placed = []; state.layout = j; state.sel = -1;
+    ui.querySelector('#d-name').value = j.name ?? name;
+    const entries = [...state.layout.prefabs];
+    state.layout.prefabs = [];
+    for (const e of entries) await placePrefab(e);
+    redrawRoads();
+    persist();
+    status(`loaded ${name} (${state.layout.prefabs.length} prefabs, ${state.layout.roads.length} roads)`);
+    return true;
+  }
+  ui.querySelector('#d-save').onclick = () => save(ui.querySelector('#d-name').value.trim() || 'untitled');
+  ui.querySelector('#d-load').onclick = () => load(ui.querySelector('#d-name').value.trim() || 'untitled');
+
+  // ── THE DESIGNER BUS — the MCP server drives everything above through this ──
+  const api = {
+    status: () => ({ mode: state.mode, prefabs: state.layout.prefabs.length, roads: state.layout.roads.length, sel: state.sel, active: state.activePrefab?.label ?? null, name: state.layout.name }),
+    palette: (f = '') => palette.filter((p) => !f || p.label.toLowerCase().includes(f.toLowerCase())).slice(0, 200).map((p) => p.label),
+    place: async ({ file, dir, x, z, y, ry = 0, tex, ext }) => { const i = await placePrefab({ file, dir, ...(ext ? { ext } : {}), x, y: y ?? state.heightAt(x, z), z, ry, ...(tex ? { tex } : {}) }); return { placed: i, total: state.layout.prefabs.length }; },
+    move: ({ i, x, z, y, ry }) => { const p = state.placed[i]; if (!p) return { err: 'no such index' };
+      if (x != null) p.entry.x = x; if (z != null) p.entry.z = z;
+      p.entry.y = y ?? state.heightAt(p.entry.x, p.entry.z);
+      if (ry != null) p.entry.ry = ry;
+      p.object.position.set(p.entry.x, p.entry.y, p.entry.z); p.object.rotation.y = p.entry.ry; persist(); return { ok: true }; },
+    remove: ({ i }) => { select(i); removeSelected(); return { total: state.layout.prefabs.length }; },
+    road: ({ pts }) => { state.layout.roads.push(pts); redrawRoads(); persist(); return { roads: state.layout.roads.length }; },
+    camera: ({ x, y, z, tx = 0, ty = 0, tz = 0 }) => { camera.position.set(x, y, z); controls.target.set(tx, ty, tz); controls.update(); return { ok: true }; },
+    save: ({ name }) => save(name ?? state.layout.name),
+    load: ({ name }) => load(name),
+    clear: () => { for (const p of state.placed) scene.remove(p.object); state.placed = []; state.layout = { name: state.layout.name, prefabs: [], roads: [] }; redrawRoads(); persist(); return { ok: true }; },
+  };
+  (async function pollBus() {
+    try {
+      const { cmds } = await fetch('/__designer-bus/poll').then((r) => r.json());
+      for (const c of cmds) {
+        let value, err = null;
+        try { value = await api[c.op]?.(c.args ?? {}); if (api[c.op] === undefined) err = `unknown op '${c.op}'`; }
+        catch (e) { err = String(e); }
+        await fetch('/__designer-bus/result', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ id: c.id, ok: !err, value, err }) });
+      }
+    } catch { /* dev server hiccup */ }
+    setTimeout(pollBus, 400);
+  })();
+
+  // restore a layout in progress (reload survivor — see persist())
+  try {
+    const kept = JSON.parse(sessionStorage.getItem('sindicate-designer') ?? 'null');
+    if (kept && (kept.prefabs?.length || kept.roads?.length)) {
+      state.layout = { name: kept.name ?? 'untitled', prefabs: [], roads: kept.roads ?? [] };
+      ui.querySelector('#d-name').value = state.layout.name;
+      for (const e of kept.prefabs ?? []) await placePrefab(e);
+      redrawRoads();
+      status(`restored working layout (${state.layout.prefabs.length} prefabs, ${state.layout.roads.length} roads)`);
+    }
+  } catch { /* nothing kept */ }
+
+  await loadPalette();
+  renderer.setAnimationLoop(() => { controls.update(); renderer.render(scene, camera); });
+  status(`ready — ${palette.length} prefabs`);
+}
+
+const BTN = 'padding:4px 10px;border:1px solid #3a3a52;border-radius:5px;background:#22223a;color:#e8c66a;cursor:pointer;font-size:12px';

package/tools/devPlugin.js

@@ -539,6 +539,61 @@ export function guiPlugin() {
   };
 }
 
+// THE WORLD DESIGNER's server half — layout JSON persistence (designs/<name>.json in the
+// GAME repo: machine-written layouts are JSON by law) + the imported-pack model listing
+// the palette feeds on. The designer BUS (an MCP server's way in) is a busPlugin instance
+// registered alongside this in sindicateDevTools.
+export function designerPlugin({ packsDir = 'public/assets/packs', designsDir = 'designs' } = {}) {
+  const NAME_RE = /^[\w.-]+$/;
+  return {
+    name: 'sindicate-designer',
+    apply: 'serve',
+    configureServer(server) {
+      // model + texture inventory of ONE imported pack (palette fodder)
+      server.middlewares.use('/__designer/models', (req, res) => {
+        try {
+          const pack = new URL(req.url, 'http://x').searchParams.get('pack') || '';
+          if (!NAME_RE.test(pack)) return sendJson(res, 400, { err: 'bad pack name' });
+          const mDir = path.join(packsDir, pack, 'models');
+          const tDir = path.join(packsDir, pack, 'textures');
+          const models = fs.existsSync(mDir) ? fs.readdirSync(mDir).filter((f) => /\.(fbx|glb)$/i.test(f)) : [];
+          const textures = fs.existsSync(tDir) ? fs.readdirSync(tDir).filter((f) => /\.(png|jpg|jpeg|tga)$/i.test(f)) : [];
+          // the pack's likeliest shared atlas — Synty convention first, else the first texture
+          const atlas = textures.find((t) => /_Texture_01/i.test(t)) ?? textures.find((t) => /texture/i.test(t)) ?? textures[0] ?? null;
+          sendJson(res, 200, { models, textures, tex: atlas ? `/assets/packs/${pack}/textures/${atlas}` : null });
+        } catch (e) { sendJson(res, 500, { err: String(e) }); }
+      });
+      server.middlewares.use('/__designer/save', async (req, res) => {
+        if (req.method !== 'POST') return sendJson(res, 405, { err: 'POST only' });
+        const name = new URL(req.url, 'http://x').searchParams.get('name') || '';
+        if (!NAME_RE.test(name)) return sendJson(res, 400, { err: 'bad design name' });
+        try {
+          const body = JSON.parse((await readBody(req)).toString());   // parse = validate: only real JSON lands on disk
+          fs.mkdirSync(designsDir, { recursive: true });
+          fs.writeFileSync(path.join(designsDir, `${name}.json`), JSON.stringify(body, null, 2));
+          sendJson(res, 200, { ok: true, file: `${designsDir}/${name}.json` });
+        } catch (e) { sendJson(res, 500, { err: String(e) }); }
+      });
+      server.middlewares.use('/__designer/load', (req, res) => {
+        const name = new URL(req.url, 'http://x').searchParams.get('name') || '';
+        if (!NAME_RE.test(name)) return sendJson(res, 400, { err: 'bad design name' });
+        const file = path.join(designsDir, `${name}.json`);
+        if (!fs.existsSync(file)) return sendJson(res, 404, { err: 'no such design' });
+        try { sendJson(res, 200, JSON.parse(fs.readFileSync(file, 'utf8'))); }
+        catch (e) { sendJson(res, 500, { err: String(e) }); }
+      });
+      server.middlewares.use('/__designer/list', (req, res) => {
+        try {
+          const designs = fs.existsSync(designsDir)
+            ? fs.readdirSync(designsDir).filter((f) => f.endsWith('.json')).map((f) => f.slice(0, -5))
+            : [];
+          sendJson(res, 200, { designs });
+        } catch (e) { sendJson(res, 500, { err: String(e) }); }
+      });
+    },
+  };
+}
+
 export function sindicateDevTools({
   sourceWrites = [],
   assetLists = [],
@@ -563,6 +618,8 @@ export function sindicateDevTools({
     packImporterPlugin(),
     busPlugin({ name: 'game', prefix: '/__game', originGuard: true }),
     busPlugin({ name: 'editor', prefix: '/__editor' }),
+    busPlugin({ name: 'designer', prefix: '/__designer-bus' }),
+    designerPlugin(),
     editorShotsPlugin({ shotsDir: editorShotsDir, mapsDir }),
   ];
 }

package/tools/fbxToGlb.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+// FBX → GLB (pack bake) — Synty props arrive as raw .fbx with their unit scale living in
+// Unity's per-file import settings (PolygonCity is metre-authored at globalScale 100,
+// PolygonTown is centimetres at 1). Shipping raw FBX makes every consumer carry both an
+// FBXLoader and the scale table; baking to GLB with the scale applied kills both.
+//
+//   node tools/fbxToGlb.mjs <packDir>
+//
+// Reads <packDir>/fbxScale.json (written by truthToAssemblies from the Unity .meta files),
+// converts every listed .fbx, rewrites the assemblies + patches + index to point at the GLBs,
+// and leaves the .fbx sources in place (nothing is deleted — re-runnable).
+//
+// Geometry convention: whatever three's FBXLoader produces, world-baked. That is exactly what
+// the viewers rendered before, so the flipped instance transforms from truthToAssemblies keep
+// matching. No handedness change happens here.
+import fs from 'node:fs';
+import path from 'node:path';
+import { writeGlb } from './glbWrite.mjs';
+
+// three's FBXLoader touches a few DOM APIs (texture loading paths we never hit)
+globalThis.self = globalThis;
+globalThis.window = globalThis;
+const stubEl = () => ({ style: {}, addEventListener() {}, removeEventListener() {}, setAttribute() {}, getContext: () => null });
+globalThis.document = { createElementNS: stubEl, createElement: stubEl };
+
+const THREE = await import('three');
+const { FBXLoader } = await import('three/examples/jsm/loaders/FBXLoader.js');
+
+const [packDir] = process.argv.slice(2);
+if (!packDir) { console.error('usage: fbxToGlb.mjs <packDir>'); process.exit(1); }
+
+const modelsDir = path.join(packDir, 'models');
+const scalePath = path.join(packDir, 'fbxScale.json');
+const scales = fs.existsSync(scalePath) ? JSON.parse(fs.readFileSync(scalePath, 'utf8')) : {};
+const loader = new FBXLoader();
+
+function convert(fbxName, scale) {
+  const buf = fs.readFileSync(path.join(modelsDir, fbxName));
+  const root = loader.parse(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength), '');
+  root.scale.setScalar(scale);
+  root.updateMatrixWorld(true);
+
+  // world-bake every mesh into one buffer (parts get a single material from the truth data,
+  // so submesh splits buy nothing and cost draw calls)
+  const pos = [], nrm = [], uv = [], idx = [];
+  const v = new THREE.Vector3();
+  const nm = new THREE.Matrix3();
+  root.traverse((o) => {
+    if (!o.isMesh) return;
+    const g = o.geometry;
+    const p = g.attributes.position;
+    if (!p) return;
+    const base = pos.length / 3;
+    nm.getNormalMatrix(o.matrixWorld);
+    for (let i = 0; i < p.count; i++) {
+      v.fromBufferAttribute(p, i).applyMatrix4(o.matrixWorld);
+      pos.push(v.x, v.y, v.z);
+      if (g.attributes.normal) {
+        v.fromBufferAttribute(g.attributes.normal, i).applyMatrix3(nm).normalize();
+        nrm.push(v.x, v.y, v.z);
+      } else nrm.push(0, 1, 0);
+      if (g.attributes.uv) uv.push(g.attributes.uv.getX(i), g.attributes.uv.getY(i));
+      else uv.push(0, 0);
+    }
+    if (g.index) for (let i = 0; i < g.index.count; i++) idx.push(g.index.getX(i) + base);
+    else for (let i = 0; i < p.count; i++) idx.push(base + i);
+  });
+  if (!pos.length) throw new Error('no geometry');
+  const glbName = fbxName.replace(/\.fbx$/i, '.glb');
+  const r = writeGlb({
+    name: path.basename(glbName, '.glb'),
+    vertexCount: pos.length / 3,
+    indices: idx,
+    attrs: {
+      POSITION: { array: new Float32Array(pos), dim: 3 },
+      NORMAL: { array: new Float32Array(nrm), dim: 3 },
+      TEXCOORD_0: { array: new Float32Array(uv), dim: 2 },
+    },
+    subs: [{ firstIndex: 0, indexCount: idx.length, baseVertex: 0 }],
+  }, path.join(modelsDir, glbName));
+  return { glbName, ...r };
+}
+
+const renamed = {};
+for (const [fbxName, scale] of Object.entries(scales)) {
+  if (!fs.existsSync(path.join(modelsDir, fbxName))) { console.warn(`missing ${fbxName}`); continue; }
+  try {
+    const r = convert(fbxName, scale);
+    renamed[fbxName] = r.glbName;
+    console.log(`${fbxName} ×${scale} → ${r.glbName}  ${r.verts} verts, ${r.tris} tris`);
+  } catch (e) { console.warn(`FAILED ${fbxName}: ${e.message}`); }
+}
+
+// repoint assemblies, patches and the model index at the GLBs
+let touched = 0;
+for (const dir of ['assemblies', 'patches']) {
+  const d = path.join(packDir, dir);
+  if (!fs.existsSync(d)) continue;
+  for (const f of fs.readdirSync(d)) {
+    if (!f.endsWith('.json') || f === 'index.json') continue;
+    const p = path.join(d, f);
+    const man = JSON.parse(fs.readFileSync(p, 'utf8'));
+    let hit = false;
+    for (const part of man.parts) if (renamed[part.file]) { part.file = renamed[part.file]; hit = true; }
+    if (hit) { fs.writeFileSync(p, JSON.stringify(man)); touched++; }
+  }
+}
+const idxPath = path.join(packDir, 'index.json');
+if (fs.existsSync(idxPath)) {
+  const index = JSON.parse(fs.readFileSync(idxPath, 'utf8'))
+    .map((f) => renamed[f] ?? f)
+    .filter((f) => !/\.fbx$/i.test(f));
+  fs.writeFileSync(idxPath, JSON.stringify([...new Set(index)].sort()));
+}
+console.log(`${Object.keys(renamed).length} converted · ${touched} manifests repointed`);

package/tools/glbWrite.mjs

@@ -0,0 +1,62 @@
+// GLB WRITER — shared by unityMeshToGlb (Unity YAML mesh recovery) and
+// rebuildSimpleRoundabouts (synthesized replacements for Kiwi's deleted meshes).
+// mesh = { name, vertexCount, indices, attrs: { POSITION: {array, dim}, ... }, subs }
+import fs from 'node:fs';
+
+export function writeGlb(mesh, outFile) {
+  const buffers = [];
+  let byteLen = 0;
+  const views = [];
+  const push = (buf, target) => {
+    while (byteLen % 4) { buffers.push(Buffer.alloc(1)); byteLen++; }
+    views.push({ buffer: 0, byteOffset: byteLen, byteLength: buf.length, ...(target ? { target } : {}) });
+    buffers.push(buf); byteLen += buf.length;
+    return views.length - 1;
+  };
+  const accessors = [];
+  const attrAcc = {};
+  for (const [sem, a] of Object.entries(mesh.attrs)) {
+    const buf = Buffer.from(a.array.buffer, a.array.byteOffset, a.array.byteLength);
+    const view = push(buf, 34962);
+    let min, max;
+    if (sem === 'POSITION') {
+      min = [Infinity, Infinity, Infinity]; max = [-Infinity, -Infinity, -Infinity];
+      for (let v = 0; v < mesh.vertexCount; v++) for (let d = 0; d < 3; d++) {
+        const x = a.array[v * 3 + d];
+        if (x < min[d]) min[d] = x;
+        if (x > max[d]) max[d] = x;
+      }
+    }
+    accessors.push({ bufferView: view, componentType: 5126, count: mesh.vertexCount, type: ['SCALAR', 'VEC2', 'VEC3', 'VEC4'][a.dim - 1], ...(min ? { min, max } : {}) });
+    attrAcc[sem] = accessors.length - 1;
+  }
+  const primitives = mesh.subs.map((s) => {
+    const idx = new Uint32Array(mesh.indices.slice(s.firstIndex, s.firstIndex + s.indexCount).map((i) => i + s.baseVertex));
+    const view = push(Buffer.from(idx.buffer), 34963);
+    accessors.push({ bufferView: view, componentType: 5125, count: idx.length, type: 'SCALAR' });
+    return { attributes: attrAcc, indices: accessors.length - 1, mode: 4 };
+  });
+  const gltf = {
+    asset: { version: '2.0', generator: 'sindicate unityMeshToGlb' },
+    scene: 0,
+    scenes: [{ nodes: [0] }],
+    nodes: [{ mesh: 0, name: mesh.name }],
+    meshes: [{ name: mesh.name, primitives }],
+    accessors,
+    bufferViews: views,
+    buffers: [{ byteLength: byteLen }],
+  };
+  const bin = Buffer.concat(buffers, byteLen);
+  let json = Buffer.from(JSON.stringify(gltf));
+  while (json.length % 4) json = Buffer.concat([json, Buffer.from(' ')]);
+  const binPad = (4 - (bin.length % 4)) % 4;
+  const paddedBin = binPad ? Buffer.concat([bin, Buffer.alloc(binPad)]) : bin;
+  const total = 12 + 8 + json.length + 8 + paddedBin.length;
+  const out = Buffer.alloc(total);
+  out.writeUInt32LE(0x46546c67, 0); out.writeUInt32LE(2, 4); out.writeUInt32LE(total, 8);
+  out.writeUInt32LE(json.length, 12); out.writeUInt32LE(0x4e4f534a, 16); json.copy(out, 20);
+  let o = 20 + json.length;
+  out.writeUInt32LE(paddedBin.length, o); out.writeUInt32LE(0x004e4942, o + 4); paddedBin.copy(out, o + 8);
+  fs.writeFileSync(outFile, out);
+  return { verts: mesh.vertexCount, tris: mesh.indices.length / 3, prims: primitives.length, bytes: total };
+}