sindicate 0.12.0 → 0.15.0

package/tools/devPlugin.js

@@ -23,6 +23,10 @@
 //     perfSink: process.env.MY_PERF_SINK || '/tmp/mygame-perf.jsonl',
 //   })]
 import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const _toolsDir = path.dirname(fileURLToPath(import.meta.url));
 
 // Guard for the source-writing endpoints: only same-machine pages may write, and the
 // payload must look like the file it claims to be — an empty/garbage body used to be
@@ -205,6 +209,188 @@ function editorShotsPlugin({ shotsDir, mapsDir }) {
   };
 }
 
+// THE PACK IMPORTER (ENGINE_DESIGN §5c) — bring publisher packs (Synty et al.) into the
+// RUNNING GAME's repo. A .unitypackage is a gzip tar of GUID dirs, each holding `pathname`
+// (the original Assets/… path) and `asset` (the bytes) — the parse western's python
+// extractor proved, done here with the OS tar. Assets land in the GAME (public/assets/
+// packs/<name>/), never in Sindicate: the engine stays content-free and licenses stay
+// per-project. Animation FBXs route through accentimation-converter when it's present.
+export function packImporterPlugin({ stagingDir = '_staging', packsDir = 'public/assets/packs', converterPath = '../accentimation-converter' } = {}) {
+  // category rules from the 85-pack survey (135k paths): newer packs live under
+  // Assets/Synty/<Pack>/, older under Assets/<Pack>/Models/; Convex/Collision dirs hold
+  // collision meshes (not display models); /Animations/ FBXs are converter fodder;
+  // .prefab/.asset/.mat/.cs and friends are Unity-only noise.
+  const TEXTURE_RE = /\.(png|jpg|jpeg|tga)$/i;
+  const MODEL_RE = /\.(fbx|glb|gltf|obj)$/i;
+  const ANIM_HINT = /(^|\/)animations?\//i;
+  const COLLISION_RE = /(^|\/)(convex|collision|collisionconvex)\//i;
+  const isAnim = (p) => (ANIM_HINT.test(p) && /\.fbx$/i.test(p)) || /(^|\/)A_[^/]+\.fbx$/i.test(p);
+
+  function inventory(dir) {
+    const out = { models: [], textures: [], animations: [], collision: [], other: [] };
+    const walk = (d, rel = '') => {
+      for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+        if (e.name.startsWith('_')) continue;   // working dirs (_anims) are not pack content
+        const r = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory()) walk(path.join(d, e.name), r);
+        else if (isAnim(r)) out.animations.push(r);
+        else if (COLLISION_RE.test(r) && MODEL_RE.test(r)) out.collision.push(r);
+        else if (MODEL_RE.test(r)) out.models.push(r);
+        else if (TEXTURE_RE.test(r)) out.textures.push(r);
+        else out.other.push(r);
+      }
+    };
+    walk(dir);
+    return out;
+  }
+
+  return {
+    name: 'sindicate-pack-importer',
+    apply: 'serve',
+    configureServer(server) {
+      // upload: stream the .unitypackage to disk, tar-extract, resolve pathname map, stage
+      server.middlewares.use('/__pack/upload', (req, res) => {
+        if (req.method !== 'POST') { res.statusCode = 405; return res.end('POST only'); }
+        const name = (new URL(req.url, 'http://x').searchParams.get('name') || 'pack').replace(/\.unitypackage$/i, '').replace(/[^\w.-]+/g, '_');
+        const upDir = path.join(stagingDir, '_uploads');
+        fs.mkdirSync(upDir, { recursive: true });
+        const tmp = path.join(upDir, `${name}.unitypackage`);
+        const ws = fs.createWriteStream(tmp);
+        req.pipe(ws);
+        ws.on('finish', () => {
+          try {
+            const raw = path.join(stagingDir, '_raw', name);
+            fs.rmSync(raw, { recursive: true, force: true });
+            fs.mkdirSync(raw, { recursive: true });
+            execFileSync('tar', ['-xzf', tmp, '-C', raw], { stdio: 'pipe' });
+            const dest = path.join(stagingDir, name);
+            fs.rmSync(dest, { recursive: true, force: true });
+            let staged = 0;
+            for (const guid of fs.readdirSync(raw)) {
+              const pn = path.join(raw, guid, 'pathname');
+              const as = path.join(raw, guid, 'asset');
+              if (!fs.existsSync(pn) || !fs.existsSync(as)) continue;
+              const orig = fs.readFileSync(pn, 'utf8').split('\n')[0].trim();
+              if (!orig || orig.split('/').includes('..')) continue;
+              const to = path.join(dest, orig);
+              fs.mkdirSync(path.dirname(to), { recursive: true });
+              fs.renameSync(as, to);
+              staged++;
+            }
+            fs.rmSync(raw, { recursive: true, force: true });
+            fs.rmSync(tmp, { force: true });
+            sendJson(res, 200, { pack: name, staged, inventory: summarize(inventory(dest)) });
+          } catch (e) { sendJson(res, 500, { err: String(e).slice(0, 300) }); }
+        });
+        ws.on('error', (e) => sendJson(res, 500, { err: String(e) }));
+      });
+
+      const summarize = (inv) => ({ models: inv.models.length, textures: inv.textures.length, animations: inv.animations.length, collision: inv.collision.length, other: inv.other.length });
+      // THE CATALOG: registry.json (ships with the engine) + live status per entry —
+      // installed (node_modules/<name>/sindicate.json) and packaged (newest
+      // *.sindicatepackage in the repo dir, resolved against the Sites root = game's parent)
+      server.middlewares.use('/__pack/registry', (req, res) => {
+        try {
+          const reg = JSON.parse(fs.readFileSync(path.join(_toolsDir, 'registry.json'), 'utf8'));
+          const sites = path.resolve('..');
+          const out = reg.packages.map((p) => {
+            const manPath = path.join('node_modules', p.name, 'sindicate.json');
+            let installed = null;
+            if (fs.existsSync(manPath)) { try { installed = JSON.parse(fs.readFileSync(manPath, 'utf8')).version; } catch { installed = '?'; } }
+            const repoDir = path.join(sites, p.repo ?? '');
+            let packageFile = null;
+            if (p.repo && fs.existsSync(repoDir)) {
+              const c = fs.readdirSync(repoDir).filter((f) => f.endsWith('.sindicatepackage')).sort();
+              if (c.length) packageFile = path.join(repoDir, c[c.length - 1]);
+            }
+            return { ...p, installed, packageFile, repoExists: p.repo ? fs.existsSync(repoDir) : false };
+          });
+          sendJson(res, 200, { packages: out });
+        } catch (e) { sendJson(res, 500, { err: String(e) }); }
+      });
+
+      // install straight from the catalog: run the sindicate CLI server-side into THIS game
+      server.middlewares.use('/__pack/installAddon', async (req, res) => {
+        if (req.method !== 'POST') { res.statusCode = 405; return res.end('POST only'); }
+        try {
+          const { file } = JSON.parse((await readBody(req)).toString());
+          if (!file || !String(file).endsWith('.sindicatepackage') || !fs.existsSync(file)) return sendJson(res, 400, { err: 'no such package file' });
+          const out = execFileSync('node', [path.join(_toolsDir, 'sindicate-cli.mjs'), 'install', file, '--game', '.'], { stdio: 'pipe', timeout: 300000 });
+          sendJson(res, 200, { ok: true, log: out.toString().slice(-400) });
+        } catch (e) { sendJson(res, 500, { err: String(e.stderr ?? e).slice(0, 300) }); }
+      });
+
+      // installed add-ons: every node_modules package that ships a sindicate.json
+      server.middlewares.use('/__pack/addons', (req, res) => {
+        try {
+          const nm = 'node_modules';
+          const addons = [];
+          if (fs.existsSync(nm)) for (const d of fs.readdirSync(nm)) {
+            if (d.startsWith('.')) continue;
+            const man = path.join(nm, d, 'sindicate.json');
+            if (!fs.existsSync(man)) continue;
+            try { addons.push(JSON.parse(fs.readFileSync(man, 'utf8'))); } catch { /* unreadable manifest */ }
+          }
+          sendJson(res, 200, { addons });
+        } catch (e) { sendJson(res, 500, { err: String(e) }); }
+      });
+
+      // staged packs + inventories
+      server.middlewares.use('/__pack/list', (req, res) => {
+        try {
+          const packs = fs.existsSync(stagingDir)
+            ? fs.readdirSync(stagingDir).filter((d) => !d.startsWith('_') && fs.statSync(path.join(stagingDir, d)).isDirectory())
+                .map((d) => ({ pack: d, inventory: summarize(inventory(path.join(stagingDir, d))) }))
+            : [];
+          const imported = fs.existsSync(packsDir)
+            ? fs.readdirSync(packsDir).filter((d) => fs.existsSync(path.join(packsDir, d, 'pack.json')))
+            : [];
+          sendJson(res, 200, { packs, imported });
+        } catch (e) { sendJson(res, 500, { err: String(e) }); }
+      });
+
+      // import: copy models/textures into the game pack dir; cook animations via the converter
+      server.middlewares.use('/__pack/import', async (req, res) => {
+        if (req.method !== 'POST') { res.statusCode = 405; return res.end('POST only'); }
+        try {
+          const { pack, categories = ['models', 'textures', 'animations'] } = JSON.parse((await readBody(req)).toString());
+          const src = path.join(stagingDir, String(pack).replace(/[^\w.-]+/g, '_'));
+          if (!fs.existsSync(src)) return sendJson(res, 404, { err: 'no such staged pack' });
+          const inv = inventory(src);
+          const out = path.join(packsDir, pack);
+          const copied = { models: 0, textures: 0 };
+          const copy = (rel, sub) => {
+            const to = path.join(out, sub, path.basename(rel));
+            fs.mkdirSync(path.dirname(to), { recursive: true });
+            fs.copyFileSync(path.join(src, rel), to);
+          };
+          if (categories.includes('models')) for (const r of inv.models) { copy(r, 'models'); copied.models++; }
+          if (categories.includes('textures')) for (const r of inv.textures) { copy(r, 'textures'); copied.textures++; }
+          let clips = null;
+          if (categories.includes('animations') && inv.animations.length) {
+            const conv = path.resolve(converterPath, 'bin/accentimation.js');
+            if (fs.existsSync(conv)) {
+              const animDir = path.join(src, '_anims');
+              fs.rmSync(animDir, { recursive: true, force: true });
+              fs.mkdirSync(animDir, { recursive: true });
+              for (const r of inv.animations) fs.copyFileSync(path.join(src, r), path.join(animDir, path.basename(r)));
+              const clipsOut = path.join(out, 'clips');
+              try {
+                execFileSync('node', [conv, 'convert', animDir, '--out', clipsOut], { stdio: 'pipe', timeout: 300000 });
+                clips = fs.readdirSync(clipsOut).filter((f) => f.endsWith('.json')).length;
+              } catch (e) { clips = `converter failed: ${String(e.stderr ?? e).slice(0, 200)}`; }
+            } else clips = `converter not found at ${conv} — animations staged, not cooked`;
+          }
+          const manifest = { name: pack, importedAt: new Date().toISOString(), counts: { ...copied, clips }, source: 'unitypackage' };
+          fs.mkdirSync(out, { recursive: true });
+          fs.writeFileSync(path.join(out, 'pack.json'), JSON.stringify(manifest, null, 2));
+          sendJson(res, 200, { ok: true, pack, copied, clips, dest: out });
+        } catch (e) { sendJson(res, 500, { err: String(e).slice(0, 300) }); }
+      });
+    },
+  };
+}
+
 // THE ENGINE DEV GUI (/__sindicate/) — served by the dev server, talks to the RUNNING
 // game through the game bus. v1: live tunables (core/tune.js groups render as sliders;
 // edits apply in the game the same frame). Panels for add-ons/packs mount here next.
@@ -221,6 +407,86 @@ export function guiPlugin() {
   </style></head><body>
   <h1>SINDICATE</h1><div class="sub">dev panel — tunables apply LIVE in the running game</div>
   <div id="groups"></div><div class="status" id="status">connecting to the game bus…</div>
+  <div class="grp" style="margin-top:26px"><h2>Packages</h2>
+    <div style="font-size:12px;color:#8d8875;margin-bottom:8px">The Sindicate catalog — install into THIS game with one click (or: sindicate install &lt;file&gt; --game .)</div>
+    <div id="ad-list" style="font-size:12px;color:#b8b09a"></div>
+    <div id="ad-status" style="font-size:12px;color:#8d8875;margin-top:6px"></div>
+  </div>
+  <script>
+  async function adRefresh() {
+    try {
+      const j = await fetch('/__pack/registry').then((r) => r.json());
+      const el = document.getElementById('ad-list'); el.innerHTML = '';
+      for (const p of j.packages ?? []) {
+        const row = document.createElement('div');
+        row.style.cssText = 'display:flex;align-items:flex-start;gap:10px;margin:8px 0';
+        const status = p.installed ? '<span style="color:#7dc24a">installed v' + p.installed + '</span>'
+          : p.packageFile ? '<span style="color:#e8c66a">available</span>'
+          : '<span style="color:#6d6858">' + (p.note ?? 'not packaged') + '</span>';
+        row.innerHTML = '<div style="flex:1"><span style="color:#f5ead0">' + p.name + '</span> <span style="color:#6d6858">· ' + p.type + '</span> ' + status
+          + '<br><span style="color:#8d8875">' + (p.description ?? '') + '</span></div>';
+        if (!p.installed && p.packageFile) {
+          const btn = document.createElement('button');
+          btn.textContent = 'Install';
+          btn.style.cssText = 'padding:3px 12px;border:1px solid #3a3a52;border-radius:5px;background:#22223a;color:#e8c66a;cursor:pointer;font-size:12px;flex:none';
+          btn.onclick = async () => {
+            btn.disabled = true;
+            document.getElementById('ad-status').textContent = 'installing ' + p.name + '…';
+            const r = await fetch('/__pack/installAddon', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ file: p.packageFile }) }).then((x) => x.json());
+            document.getElementById('ad-status').textContent = r.ok ? 'installed ' + p.name + ' — restart the dev server to use it' : 'failed: ' + (r.err ?? '?');
+            adRefresh();
+          };
+          row.appendChild(btn);
+        }
+        el.appendChild(row);
+      }
+    } catch (e) { document.getElementById('ad-list').textContent = 'unreachable: ' + e.message; }
+  }
+  adRefresh();
+  </script>
+  <div class="grp" style="margin-top:14px"><h2>Import Packs</h2>
+    <div style="font-size:12px;color:#8d8875;margin-bottom:10px">Drop or choose a .unitypackage — assets land in THIS game's repo (public/assets/packs/). Animations cook through accentimation-converter.</div>
+    <input type="file" id="pk-file" accept=".unitypackage" style="color:#b8b09a;font-size:12px">
+    <div id="pk-status" style="font-size:12px;color:#8d8875;margin-top:8px"></div>
+    <div id="pk-list" style="margin-top:10px"></div>
+  </div>
+  <script>
+  const pkStatus = (m) => { document.getElementById('pk-status').textContent = m; };
+  async function pkRefresh() {
+    try {
+      const j = await fetch('/__pack/list').then((r) => r.json());
+      const el = document.getElementById('pk-list'); el.innerHTML = '';
+      for (const p of j.packs ?? []) {
+        const row = document.createElement('div');
+        row.style.cssText = 'display:flex;align-items:center;gap:10px;margin:6px 0;font-size:12px;color:#b8b09a';
+        const inv = p.inventory;
+        const done = (j.imported ?? []).includes(p.pack);
+        row.innerHTML = '<span style="color:#f5ead0">' + p.pack + '</span><span>' + inv.models + ' models · ' + inv.textures + ' tex · ' + inv.animations + ' anims</span>' + (done ? '<span style="color:#7dc24a">imported</span>' : '');
+        const btn = document.createElement('button');
+        btn.textContent = done ? 'Re-import' : 'Import';
+        btn.style.cssText = 'padding:3px 12px;border:1px solid #3a3a52;border-radius:5px;background:#22223a;color:#e8c66a;cursor:pointer;font-size:12px';
+        btn.onclick = async () => {
+          btn.disabled = true; pkStatus('importing ' + p.pack + '…');
+          const r = await fetch('/__pack/import', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ pack: p.pack }) }).then((x) => x.json());
+          pkStatus(r.ok ? 'imported ' + p.pack + ': ' + r.copied.models + ' models, ' + r.copied.textures + ' textures' + (r.clips != null ? ', clips: ' + r.clips : '') : 'failed: ' + (r.err ?? '?'));
+          btn.disabled = false; pkRefresh();
+        };
+        row.appendChild(btn); el.appendChild(row);
+      }
+      if (!(j.packs ?? []).length) el.innerHTML = '<div style="font-size:12px;color:#6d6858">nothing staged yet</div>';
+    } catch (e) { pkStatus('importer unreachable: ' + e.message); }
+  }
+  document.getElementById('pk-file').onchange = async (ev) => {
+    const f = ev.target.files[0]; if (!f) return;
+    pkStatus('uploading ' + f.name + ' (' + Math.round(f.size / 1048576) + 'MB)…');
+    try {
+      const j = await fetch('/__pack/upload?name=' + encodeURIComponent(f.name), { method: 'POST', body: f }).then((r) => r.json());
+      pkStatus(j.err ? 'failed: ' + j.err : 'staged ' + j.pack + ' — ' + j.staged + ' files');
+      pkRefresh();
+    } catch (e) { pkStatus('upload failed: ' + e.message); }
+  };
+  pkRefresh();
+  </script>
   <script>
   const cmd = (js) => fetch('/__game/cmd', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ js }) }).then((r) => r.json());
   const take = async (id) => { for (let i = 0; i < 40; i++) { const r = await fetch('/__game/take?id=' + id).then((x) => x.json()); if (!r.pending) return r; await new Promise((res) => setTimeout(res, 250)); } return { err: 'timeout' }; };
@@ -273,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 = [],
@@ -294,8 +615,11 @@ export function sindicateDevTools({
     ...stores.map(binStorePlugin),
     perfSinkPlugin(perfSink),
     guiPlugin(),
+    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 };
+}