sindicate 0.12.0 → 0.15.0

package/tools/ExportKiwiRoadRefs.cs

@@ -0,0 +1,94 @@
+// EXPORT ROAD REFS — Unity renders every road prefab to a PNG (the GROUND TRUTH in
+// pixels). Drop next to ExportKiwiRoadMaterials.cs in Assets/Editor/, run
+//   Tools ▸ Sindicate ▸ Export Road Reference Images
+// Writes Assets/SindicateExport/refs/<prefab>.png (512px, iso view). Sindicate's compare
+// sheet puts these beside its own renders so every mismatch is visible at a glance.
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+
+public static class ExportKiwiRoadRefs
+{
+    static readonly string[] ROOTS = {
+        "Assets/AIGenerateMap/Prefabs/Roads",
+        "Assets/AIGenerateMap/JunctionPrefabs",
+        "Assets/AIGenerateMap/RoadPrefabs",
+    };
+
+    [MenuItem("Tools/Sindicate/Export Road Reference Images")]
+    public static void Export()
+    {
+        var outDir = "Assets/SindicateExport/refs";
+        Directory.CreateDirectory(outDir);
+
+        var camGO = new GameObject("__sindicateRefCam");
+        var cam = camGO.AddComponent<Camera>();
+        cam.clearFlags = CameraClearFlags.SolidColor;
+        cam.backgroundColor = new Color(0.09f, 0.09f, 0.14f);
+        cam.fieldOfView = 40f;
+        cam.farClipPlane = 5000f;
+        var lightGO = new GameObject("__sindicateRefLight");
+        var light = lightGO.AddComponent<Light>();
+        light.type = LightType.Directional;
+        light.intensity = 1.4f;
+        lightGO.transform.rotation = Quaternion.Euler(50, -30, 0);
+
+        var rt = new RenderTexture(512, 512, 24);
+        var tex = new Texture2D(512, 512, TextureFormat.RGB24, false);
+        int done = 0;
+
+        try
+        {
+            foreach (var root in ROOTS)
+            {
+                foreach (var guid in AssetDatabase.FindAssets("t:Prefab", new[] { root }))
+                {
+                    var path = AssetDatabase.GUIDToAssetPath(guid);
+                    var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(path);
+                    if (prefab == null) continue;
+                    // name refs the same way the materials export names runs: variant dirs
+                    // (Motorway/DualCarriageway) prefixed to disambiguate duplicates
+                    var name = Path.GetFileNameWithoutExtension(path);
+                    if (path.Contains("/Motorway/")) name = "Motorway_" + name;
+                    else if (path.Contains("/DualCarriageway/")) name = "DualCarriageway_" + name;
+
+                    var inst = (GameObject)Object.Instantiate(prefab, new Vector3(0, -5000, 0), Quaternion.identity);
+                    try
+                    {
+                        var bounds = new Bounds(inst.transform.position, Vector3.one);
+                        bool first = true;
+                        foreach (var r in inst.GetComponentsInChildren<Renderer>())
+                        {
+                            if (first) { bounds = r.bounds; first = false; }
+                            else bounds.Encapsulate(r.bounds);
+                        }
+                        var size = Mathf.Max(bounds.size.x, bounds.size.z, bounds.size.y, 2f);
+                        var dist = size * 1.35f;
+                        cam.transform.position = bounds.center + new Vector3(0.7f, 0.8f, 1f).normalized * dist;
+                        cam.transform.LookAt(bounds.center);
+
+                        cam.targetTexture = rt;
+                        cam.Render();
+                        RenderTexture.active = rt;
+                        tex.ReadPixels(new Rect(0, 0, 512, 512), 0, 0);
+                        tex.Apply();
+                        File.WriteAllBytes(Path.Combine(outDir, name + ".png"), tex.EncodeToPNG());
+                        done++;
+                    }
+                    finally { Object.DestroyImmediate(inst); }
+                }
+            }
+        }
+        finally
+        {
+            cam.targetTexture = null;
+            RenderTexture.active = null;
+            Object.DestroyImmediate(rt);
+            Object.DestroyImmediate(tex);
+            Object.DestroyImmediate(camGO);
+            Object.DestroyImmediate(lightGO);
+            AssetDatabase.Refresh();
+        }
+        EditorUtility.DisplayDialog("Sindicate refs", $"Rendered {done} reference images.\n\nTell Claude.", "OK");
+    }
+}

package/tools/buildKiwiRoadsPack.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// BUILD THE KIWIROADS PACK — one command, correct order. The stages are order-dependent
+// (assemblies must exist before patches merge; FBX must be referenced before they're baked),
+// so running them by hand invites half-built packs.
+//
+//   node tools/buildKiwiRoadsPack.mjs [--export <SindicateExport>] [--kiwi <KiwiAssets>] [--pack <packDir>]
+//
+//   1. truthToAssemblies       Unity truth export → 538 assemblies (+ merges patches/, fbxScale.json)
+//   2. rebuildSimpleRoundabouts  regenerate the meshes Kiwi lost upstream → patches/
+//   3. truthToAssemblies again   so the fresh patches land in the assemblies
+//   4. fbxToGlb                  bake Synty FBX props (with their Unity import scale) → GLB
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const arg = (name, fallback) => {
+  const i = process.argv.indexOf(`--${name}`);
+  return i > 0 ? process.argv[i + 1] : fallback;
+};
+const exportDir = arg('export', '/Users/nick/Desktop/Kiwi/Assets/SindicateExport');
+const kiwiAssets = arg('kiwi', '/Users/nick/Desktop/Kiwi/Assets');
+const packDir = arg('pack', '/Users/nick/Sites/TakeTheCity/public/assets/packs/KiwiRoads');
+
+const run = (script, args, label) => {
+  console.log(`\n── ${label}`);
+  const r = spawnSync(process.execPath, [path.join(here, script), ...args], { stdio: 'inherit' });
+  if (r.status !== 0) { console.error(`FAILED at ${label}`); process.exit(r.status ?? 1); }
+};
+
+run('truthToAssemblies.mjs', [exportDir, kiwiAssets, packDir], 'assemblies from Unity truth');
+run('rebuildSimpleRoundabouts.mjs', [packDir], 'reconstruct SimpleRoundabout meshes');
+run('truthToAssemblies.mjs', [exportDir, kiwiAssets, packDir], 'assemblies again (merge fresh patches)');
+run('fbxToGlb.mjs', [packDir], 'bake FBX props → GLB');
+run('roadKitAnalyze.mjs', [packDir], 'measure sockets → roadkit.json');
+console.log('\npack built.');

package/tools/designer-mcp.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+// THE DESIGNER's MCP SERVER — lets a Claude session drive the World Designer while the
+// human watches the viewport. Zero-dep stdio JSON-RPC (MCP 2024-11-05): every tool call
+// proxies to the game dev server's designer bus (/__designer-bus) or endpoints, and the
+// open /designer.html page executes it live.
+//
+// Register once per game:
+//   claude mcp add dustwater-designer -- node /Users/nick/Sites/Sindicate/tools/designer-mcp.mjs --server http://localhost:5317
+//
+// The designer page must be open in a browser tab (it polls the bus).
+const SERVER = (() => {
+  const i = process.argv.indexOf('--server');
+  return (i >= 0 && process.argv[i + 1]) || process.env.SINDICATE_SERVER || 'http://localhost:5317';
+})();
+
+async function bus(op, args = {}, timeoutMs = 20000) {
+  const { id } = await fetch(`${SERVER}/__designer-bus/cmd`, {
+    method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ op, args }),
+  }).then((r) => r.json());
+  const t0 = Date.now();
+  while (Date.now() - t0 < timeoutMs) {
+    const r = await fetch(`${SERVER}/__designer-bus/take?id=${id}`);
+    if (r.status === 200) {
+      const j = await r.json();
+      if (!j.ok) throw new Error(j.err ?? 'designer op failed');
+      return j.value;
+    }
+    await new Promise((res) => setTimeout(res, 300));
+  }
+  throw new Error(`designer page did not answer in ${timeoutMs / 1000}s — is /designer.html open in a browser tab on ${SERVER}?`);
+}
+
+const num = (d) => ({ type: 'number', description: d });
+const str = (d) => ({ type: 'string', description: d });
+const TOOLS = [
+  { name: 'designer_status', description: 'Current designer state: mode, prefab/road counts, selection, layout name.', inputSchema: { type: 'object', properties: {} },
+    run: () => bus('status') },
+  { name: 'designer_packs', description: 'List imported asset packs available to the designer.', inputSchema: { type: 'object', properties: {} },
+    run: async () => (await fetch(`${SERVER}/__pack/list`).then((r) => r.json())).imported },
+  { name: 'designer_models', description: 'List a pack’s placeable models plus its default texture atlas URL.', inputSchema: { type: 'object', properties: { pack: str('imported pack name') }, required: ['pack'] },
+    run: ({ pack }) => fetch(`${SERVER}/__designer/models?pack=${encodeURIComponent(pack)}`).then((r) => r.json()) },
+  { name: 'designer_palette', description: 'Search the loaded palette (pack/model labels) by substring.', inputSchema: { type: 'object', properties: { filter: str('substring filter, empty for first 200') } },
+    run: ({ filter = '' }) => bus('palette', filter) },
+  { name: 'designer_place', description: 'Place a prefab at world x,z (y defaults to terrain height). Returns its index.', inputSchema: { type: 'object', properties: { file: str('model name without extension'), dir: str('URL dir, e.g. /assets/packs/<pack>/models'), x: num('world x'), z: num('world z'), y: num('optional y override'), ry: num('yaw radians'), tex: str('optional texture URL') }, required: ['file', 'dir', 'x', 'z'] },
+    run: (a) => bus('place', a) },
+  { name: 'designer_move', description: 'Move/rotate placed prefab #i (omitted fields keep their value; y re-snaps to terrain unless given).', inputSchema: { type: 'object', properties: { i: num('prefab index'), x: num(''), z: num(''), y: num(''), ry: num('yaw radians') }, required: ['i'] },
+    run: (a) => bus('move', a) },
+  { name: 'designer_remove', description: 'Delete placed prefab #i.', inputSchema: { type: 'object', properties: { i: num('prefab index') }, required: ['i'] },
+    run: (a) => bus('remove', a) },
+  { name: 'designer_road', description: 'Add a road polyline: pts = [{x,z}, ...] in world metres.', inputSchema: { type: 'object', properties: { pts: { type: 'array', items: { type: 'object', properties: { x: num(''), z: num('') }, required: ['x', 'z'] }, description: 'polyline points' } }, required: ['pts'] },
+    run: (a) => bus('road', a) },
+  { name: 'designer_camera', description: 'Move the viewport camera to x,y,z looking at tx,ty,tz.', inputSchema: { type: 'object', properties: { x: num(''), y: num(''), z: num(''), tx: num('look-at x'), ty: num('look-at y'), tz: num('look-at z') }, required: ['x', 'y', 'z'] },
+    run: (a) => bus('camera', a) },
+  { name: 'designer_save', description: 'Save the layout to designs/<name>.json in the game repo.', inputSchema: { type: 'object', properties: { name: str('design name') }, required: ['name'] },
+    run: (a) => bus('save', a) },
+  { name: 'designer_load', description: 'Load designs/<name>.json into the viewport (replaces current layout).', inputSchema: { type: 'object', properties: { name: str('design name') }, required: ['name'] },
+    run: (a) => bus('load', a, 120000) },
+  { name: 'designer_clear', description: 'Remove every placed prefab and road (does not touch saved files).', inputSchema: { type: 'object', properties: {} },
+    run: () => bus('clear') },
+  { name: 'designer_designs', description: 'List saved design names.', inputSchema: { type: 'object', properties: {} },
+    run: async () => (await fetch(`${SERVER}/__designer/list`).then((r) => r.json())).designs },
+];
+
+// ---- stdio JSON-RPC plumbing (newline-delimited, per the MCP stdio transport) ----
+const reply = (id, result) => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
+const fail = (id, message) => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code: -32603, message } }) + '\n');
+
+let buf = '';
+process.stdin.on('data', (chunk) => {
+  buf += chunk;
+  let nl;
+  while ((nl = buf.indexOf('\n')) >= 0) {
+    const line = buf.slice(0, nl).trim();
+    buf = buf.slice(nl + 1);
+    if (line) handle(line);
+  }
+});
+
+async function handle(line) {
+  let msg;
+  try { msg = JSON.parse(line); } catch { return; }
+  const { id, method, params } = msg;
+  if (method === 'initialize') {
+    return reply(id, {
+      protocolVersion: params?.protocolVersion ?? '2024-11-05',
+      capabilities: { tools: {} },
+      serverInfo: { name: 'sindicate-designer', version: '1.0.0' },
+    });
+  }
+  if (method === 'tools/list') return reply(id, { tools: TOOLS.map(({ run, ...t }) => t) });
+  if (method === 'tools/call') {
+    const tool = TOOLS.find((t) => t.name === params?.name);
+    if (!tool) return fail(id, `unknown tool ${params?.name}`);
+    try {
+      const value = await tool.run(params?.arguments ?? {});
+      return reply(id, { content: [{ type: 'text', text: JSON.stringify(value ?? { ok: true }) }] });
+    } catch (e) {
+      return reply(id, { content: [{ type: 'text', text: String(e?.message ?? e) }], isError: true });
+    }
+  }
+  if (method === 'ping') return reply(id, {});
+  if (id !== undefined) return fail(id, `unknown method ${method}`);   // notifications are ignored
+}

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