sindicate 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sindicate",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Sindicate — open-world game engine for three.js WebGPU. Streaming worlds, characters, mounts & vehicles, missions, crowds.",
   "type": "module",
   "main": "src/index.js",
@@ -35,5 +35,12 @@
     "three": "^0.184.0",
     "three-mesh-bvh": "^0.9.10"
   },
-  "license": "UNLICENSED"
+  "license": "UNLICENSED",
+  "bin": {
+    "sindicate": "tools/sindicate-cli.mjs"
+  },
+  "devDependencies": {
+    "three": "^0.184.0",
+    "three-mesh-bvh": "^0.9.10"
+  }
 }

package/src/core/assets.js

@@ -498,6 +498,21 @@ export async function instantiate(url, opts) {
 // CONTRACT: these materials are shared game-wide — never mutate one on an instance;
 // clone first (see player.applyMoralityLook).
 const atlasMatCache = new Map();
+
+// NodeMaterial.clone() (three r184 WebGPU) silently DROPS the texture and node slots —
+// a private tint clone (player morality, enemy variants, shatter shards) came back
+// bare white. Clone through THIS and the slots ride along.
+export function cloneMat(m) {
+  const c = m.clone();
+  for (const k of ['map', 'normalMap', 'roughnessMap', 'metalnessMap', 'aoMap', 'emissiveMap', 'alphaMap', 'bumpMap']) {
+    if (m[k] && !c[k]) c[k] = m[k];
+  }
+  for (const k of ['colorNode', 'emissiveNode', 'roughnessNode', 'positionNode', 'opacityNode', 'normalNode']) {
+    if (m[k] && !c[k]) c[k] = m[k];
+  }
+  return c;
+}
+
 export function applyAtlas(root, tex, { emissive = null } = {}) {
   root.traverse((o) => {
     if (!o.isMesh) return;

package/src/systems/missions.js

@@ -37,7 +37,7 @@ async function captureThumb(game) {
   try {
     const { renderer, scene, camera } = game;
     if (!renderer?.readRenderTargetPixelsAsync || !scene || !camera) return null;
-    const w = 256, h = 144;
+    const w = 640, h = 360;   // pane-sized: 256px thumbs blown up to the detail pane read as mush
     const rt = (captureThumb._rt ||= new THREE.RenderTarget(w, h));
     renderer.setRenderTarget(rt);
     renderer.render(scene, camera);
@@ -51,7 +51,7 @@ async function captureThumb(game) {
     const ctx = c.getContext('2d'), img = ctx.createImageData(w, h);
     img.data.set(buf);   // top-left origin — no flip (per map.js)
     ctx.putImageData(img, 0, 0);
-    return c.toDataURL('image/jpeg', 0.62);
+    return c.toDataURL('image/jpeg', 0.7);
   } catch (e) { console.warn('[save] thumbnail failed', e?.message ?? e); return null; }
 }
 

package/src/systems/shatter.js

@@ -3,6 +3,7 @@
 // bounce + settle on the floor, then fade them away. Pure CPU integration on a tiny pool — no engine,
 // no per-shard lights, nothing resident (the meshes are added on smash and removed when faded).
 import * as THREE from 'three/webgpu';
+import { cloneMat } from '../core/assets.js';
 
 const G = 17;              // gravity (m/s²-ish, tuned for snappy low-poly debris)
 const REST = 0.34;         // floor bounce restitution
@@ -26,7 +27,7 @@ export class Shatter {
       const tmpl = frags[i % frags.length];
       const m = tmpl.clone(true);
       // independent material instances so each shard fades on its own
-      m.traverse((o) => { if (o.material) o.material = Array.isArray(o.material) ? o.material.map((x) => x.clone()) : o.material.clone(); });
+      m.traverse((o) => { if (o.material) o.material = Array.isArray(o.material) ? o.material.map((x) => cloneMat(x)) : cloneMat(o.material); });
       m.scale.multiplyScalar(scale);
       const pivot = tmpl.userData?.pivot;
       let vel;

package/src/ui/dialogue.js

@@ -42,6 +42,7 @@ let nodeHook = null;
 export function setDialogueOptionHandler(fn) { optionHandler = fn; }
 export function setDialogueNodeHook(fn) { nodeHook = fn; }
 import { padMode, buttonCanvas } from './menuHints.js';
+import { THEME } from './theme.js';
 
 // ── the two-shot, in numbers ────────────────────────────────────────────────────────────────────
 // The lens stands in FRONT of the NPC (he has already turned to face the player, so his front faces
@@ -499,7 +500,7 @@ export class Dialogue {
       #dlg .dlg-byekey { display:inline-flex; align-items:center; vertical-align:middle; margin-right:9px; }
       #dlg .dlg-byekey.kbd { width:18px; height:18px; justify-content:center; line-height:17px; font-size:12px;
         font-weight:700; color:#f4e3b0; border:1px solid #8a6a3a; border-radius:4px; background:rgba(40,28,14,0.92); }
-    `;
+    ` + (THEME.dialogueCss || '');
     document.head.appendChild(css);
   }
 }

package/src/ui/pauseMenu.js

@@ -6,6 +6,7 @@
 import { getQualityName, setQualityName, PRESETS } from '../core/quality.js';
 import { renderHints, refreshHints, padMode } from './menuHints.js';
 import { showSaveLoad } from './saveLoadScreen.js';
+import { THEME } from './theme.js';
 
 // PAUSE CONTENT is GAME data (setPauseContent in engineSetup):
 //   extraItems(game, {resume,close}) → [{label, action}] — game pages (CHARACTER/JOURNAL…)
@@ -17,10 +18,10 @@ import { showSaveLoad } from './saveLoadScreen.js';
 let PAUSE = { saves: null, extraItems: null, settingsRows: null, onQualityChange: null };
 export function setPauseContent(c = {}) { PAUSE = { ...PAUSE, ...c }; }
 
-const GOLD = '#e8c87a';
-const TXT = '#ecdfc2';
-const MUT = '#b6a577';
-const FONT = "Copperplate,'Copperplate Gothic Bold','Palatino','Book Antiqua',Georgia,serif";
+const GOLD = THEME.gold;
+const TXT = THEME.text;
+const MUT = THEME.mut;
+const FONT = THEME.font;
 const clamp = (v, a, b) => Math.max(a, Math.min(b, v));
 const CORNER_SVG = `<svg viewBox="0 0 44 44" width="30" height="30" fill="none" stroke="${GOLD}" stroke-linecap="round"><path d="M3 24 V3 H24" stroke-width="2"/><path d="M9 19 V9 H19" stroke-width="1" opacity="0.6"/><path d="M3 3 h9 l-9 9 z" fill="${GOLD}" stroke="none"/></svg>`;
 const DIVIDER_SVG = `<svg viewBox="0 0 220 14" width="200" height="12" fill="none" stroke="${GOLD}" stroke-width="1.4" stroke-linecap="round"><line x1="8" y1="7" x2="94" y2="7"/><line x1="126" y1="7" x2="212" y2="7"/><circle cx="8" cy="7" r="1.6" fill="${GOLD}"/><circle cx="212" cy="7" r="1.6" fill="${GOLD}"/><path d="M110 1 l7 6 l-7 6 l-7 -6 z" fill="${GOLD}"/></svg>`;
@@ -32,11 +33,15 @@ function el(tag, css, text) {
   return e;
 }
 function framedPanel(w = 420) {
-  const p = el('div', `position:relative;width:${w}px;max-width:90vw;padding:28px 36px 24px;color:${TXT};border:1px solid rgba(232,200,122,0.55);border-radius:3px;`
-    + 'background:linear-gradient(157deg,#241b11 0%,#160f09 58%,#0d0805 100%);box-shadow:0 26px 74px rgba(0,0,0,0.86);');
-  p.appendChild(el('div', 'position:absolute;inset:6px;border:1px solid rgba(232,200,122,0.26);border-radius:2px;pointer-events:none;'));
-  const c = (pos, rot) => { const d = el('div', `position:absolute;${pos}width:30px;height:30px;pointer-events:none;transform:rotate(${rot}deg);`); d.innerHTML = CORNER_SVG; p.appendChild(d); };
-  c('left:3px;top:3px;', 0); c('right:3px;top:3px;', 90); c('right:3px;bottom:3px;', 180); c('left:3px;bottom:3px;', 270);
+  const ground = THEME.panelCss
+    ?? `color:${TXT};border:1px solid rgba(232,200,122,0.55);border-radius:3px;`
+    + 'background:linear-gradient(157deg,#241b11 0%,#160f09 58%,#0d0805 100%);box-shadow:0 26px 74px rgba(0,0,0,0.86);';
+  const p = el('div', `position:relative;width:${w}px;max-width:90vw;padding:28px 36px 24px;${ground}`);
+  if (THEME.filigree) {
+    p.appendChild(el('div', 'position:absolute;inset:6px;border:1px solid rgba(232,200,122,0.26);border-radius:2px;pointer-events:none;'));
+    const c = (pos, rot) => { const d = el('div', `position:absolute;${pos}width:30px;height:30px;pointer-events:none;transform:rotate(${rot}deg);`); d.innerHTML = CORNER_SVG; p.appendChild(d); };
+    c('left:3px;top:3px;', 0); c('right:3px;top:3px;', 90); c('right:3px;bottom:3px;', 180); c('left:3px;bottom:3px;', 270);
+  }
   return p;
 }
 
@@ -55,8 +60,10 @@ export function showPauseMenu(game, opts = {}) {
   const close = () => { if (closed) return; closed = true; cancelAnimationFrame(raf); window.removeEventListener('keydown', onKey); root.remove(); };
   const resume = () => { close(); opts.onResume?.(); };
 
-  const hl = (b, on) => { b.style.background = on ? GOLD : 'rgba(232,200,122,0.06)'; b.style.color = on ? '#1a1207' : TXT; b.style.borderColor = on ? GOLD : 'rgba(232,200,122,0.45)'; };
-  const BTN = `padding:9px 20px;border:1px solid rgba(232,200,122,0.45);border-radius:5px;cursor:pointer;font-family:inherit;letter-spacing:2px;font-size:15px;background:rgba(232,200,122,0.06);color:${TXT};transition:background .12s,color .12s;`;
+  const ACT = THEME.btnActive ?? { bg: GOLD, color: '#1a1207', border: GOLD };
+  const OFF = THEME.btnCss ? { bg: '', color: '', border: '' } : { bg: 'rgba(232,200,122,0.06)', color: TXT, border: 'rgba(232,200,122,0.45)' };
+  const hl = (b, on) => { b.style.background = on ? ACT.bg : OFF.bg; b.style.color = on ? ACT.color : OFF.color; b.style.borderColor = on ? ACT.border : OFF.border; };
+  const BTN = THEME.btnCss ?? `padding:9px 20px;border:1px solid rgba(232,200,122,0.45);border-radius:5px;cursor:pointer;font-family:inherit;letter-spacing:2px;font-size:15px;background:rgba(232,200,122,0.06);color:${TXT};transition:background .12s,color .12s;`;
   const rowWrap = () => el('div', 'display:flex;align-items:center;gap:14px;margin:12px 0;padding:5px 6px;border-radius:5px;');
   const rowLabel = (t) => el('div', `width:110px;text-align:right;color:${MUT};font-size:14px;letter-spacing:1px;text-transform:uppercase;`, t);
 

package/src/ui/saveLoadScreen.js

@@ -7,12 +7,13 @@
 // opts: { mode:'load'|'save', slots:[…ids], list:()=>saves, onLoad(slot), onSave(slot,name),
 //         onDelete(slot), onClose() }. Returns { close }.
 import { renderHints, refreshHints, padMode } from './menuHints.js';
+import { THEME } from './theme.js';
 
 const UI = '/assets/ui/menu';
-const GOLD = '#e8c87a';
-const TXT = '#ecdfc2';
-const MUT = '#b6a577';
-const FONT = "Copperplate,'Copperplate Gothic Bold','Palatino','Book Antiqua',Georgia,serif";
+const GOLD = THEME.gold;
+const TXT = THEME.text;
+const MUT = THEME.mut;
+const FONT = THEME.font;
 
 function el(tag, css, text) {
   const e = document.createElement(tag);
@@ -27,7 +28,7 @@ export function showSaveLoad(opts = {}) {
   const save = opts.mode === 'save';
   const slotIds = opts.slots || ['1', '2', '3', '4', '5', '6'];
 
-  const root = el('div', `position:fixed;inset:0;z-index:130;display:flex;flex-direction:column;font-family:${FONT};background:#0a0705;`);
+  const root = el('div', `position:fixed;inset:0;z-index:130;display:flex;flex-direction:column;font-family:${FONT};background:${THEME.screenBg};`);
   root.appendChild(el('div', `position:absolute;inset:0;background:#000 url(${UI}/title_bg.jpg) center/cover;opacity:0.08;`));
   root.appendChild(el('div', 'position:absolute;inset:0;background:linear-gradient(180deg,rgba(10,7,5,0.86),rgba(10,7,5,0.96));'));
   const head = el('div', 'position:relative;padding:44px 60px 16px;border-bottom:1px solid rgba(232,200,122,0.22);flex:none;');
@@ -49,9 +50,12 @@ export function showSaveLoad(opts = {}) {
 
   const showDetail = (rec) => {
     if (!rec) { detail.innerHTML = `<div style="flex:1;display:flex;align-items:center;justify-content:center;color:${MUT};letter-spacing:2px">${save ? 'NEW SAVE' : 'EMPTY'}</div>`; return; }
-    const img = rec.thumb ? `<img src="${rec.thumb}" style="width:100%;height:100%;object-fit:cover">`
-      : `<div style="flex:1;display:flex;align-items:center;justify-content:center;color:${MUT};font-size:12px;letter-spacing:3px">NO PREVIEW</div>`;
-    detail.innerHTML = `<div style="flex:1;min-height:190px;background:linear-gradient(135deg,#1a130b,#0d0906);display:flex;overflow:hidden">${img}</div>`
+    const img = rec.thumb ? `<img src="${rec.thumb}" style="width:100%;height:100%;object-fit:cover;display:block">`
+      : `<div style="width:100%;height:100%;display:flex;align-items:center;justify-content:center;color:${MUT};font-size:12px;letter-spacing:3px">NO PREVIEW</div>`;
+    // a FRAMED 16:9 plate, not a full-pane stretch — a small thumb blown to the pane reads as mush
+    detail.innerHTML = `<div style="padding:22px 24px 0"><div style="aspect-ratio:16/9;max-height:340px;margin:0 auto;`
+      + `background:linear-gradient(135deg,#1a130b,#0d0906);border:1px solid rgba(232,200,122,0.28);border-radius:3px;`
+      + `box-shadow:0 10px 30px rgba(0,0,0,0.5), inset 0 0 40px rgba(0,0,0,0.35);overflow:hidden">${img}</div></div>`
       + `<div style="padding:20px 24px"><div style="color:${GOLD};font-size:22px;letter-spacing:2px;font-weight:700">${rec.name || rec.title || opts.defaultTitle || 'Saved game'}</div>`
       + `<div style="color:${MUT};font-size:13px;margin-top:8px;line-height:1.9">${rec.auto ? 'Autosave · ' : ''}${fmtDate(rec.savedAt)}<br>Played ${fmtTime(rec.playtime)} &nbsp;·&nbsp; ${opts.moneyLabel ?? 'Purse $'}${rec.money ?? 0}${rec.objective ? '<br>' + rec.objective : ''}</div></div>`;
   };
@@ -59,7 +63,7 @@ export function showSaveLoad(opts = {}) {
   const rebuild = () => {
     const saves = opts.list ? opts.list() : [];
     const bySlot = {}; saves.forEach((s) => { bySlot[String(s.slot)] = s; });
-    const ids = save ? slotIds : ['auto', ...slotIds].filter((id) => bySlot[id]);   // load: only filled; save: all manual slots
+    const ids = save ? slotIds : [...new Set(['auto', ...slotIds])].filter((id) => bySlot[id]);   // load: only filled (auto deduped — a game may list it in its own slots); save: all manual slots
     listEl.innerHTML = ''; items = [];
     if (!ids.length) { listEl.appendChild(el('div', `color:${MUT};opacity:0.8;padding:12px;`, 'No saved games yet.')); showDetail(null); return; }
     ids.forEach((id) => {

package/src/ui/theme.js

@@ -0,0 +1,34 @@
+// THE UI THEME — the rule, codified after the fable title-menu incident: the ENGINE owns
+// the FUNCTIONALITY of a screen; the GAME owns its LOOK. Every value here is declarative
+// (a game ships them as src/game/uiTheme.json and registers it in engineSetup with
+// setUiTheme(theme)), so a re-dress never touches engine code.
+//
+// The defaults are the neutral dark leather-and-gold dress the engine screens shipped with
+// (Dustwater's palette — western's own uiTheme.json restates it explicitly). The engine UI
+// modules are lazily imported AFTER engineSetup runs, so module-load reads of THEME see the
+// game's registration.
+//
+//   font        — the screens' font stack
+//   gold/text/mut — accent, body text, muted labels
+//   panelCss    — the framed panel's ground (popup confirms, the pause panel). Replaces the
+//                 default gradient+border block; the engine still positions and sizes it.
+//   filigree    — draw the gold corner flourishes + inner rule on panels (default true; a
+//                 parchment skin usually wants them off)
+//   btnCss      — the standard button plate (settings rows, confirms, save-slot actions)
+//   btnActive   — { bg, color, border } for the highlighted/selected state
+//   screenBg    — full-screen browser background (save/load screen ground)
+//   dialogueCss — appended after the dialogue panel's own CSS; override any #dlg selector
+export const THEME = {
+  font: "Copperplate,'Copperplate Gothic Bold','Palatino','Book Antiqua',Georgia,serif",
+  gold: '#e8c87a',
+  text: '#ecdfc2',
+  mut: '#b6a577',
+  panelCss: null,       // null = the engine's dark leather gradient
+  filigree: true,
+  btnCss: null,         // null = the engine's gold-outline plate
+  btnActive: null,      // null = { bg: gold, color: '#1a1207', border: gold }
+  screenBg: '#0a0705',
+  dialogueCss: '',
+};
+
+export function setUiTheme(t = {}) { Object.assign(THEME, t); }

package/src/world/bridgeSplice.js

@@ -0,0 +1,176 @@
+// THE BRIDGE SPLICER (world splits, step 3) — every road x river crossing becomes a deck.
+// Moved verbatim from the games (their copies were byte-identical except two spacing
+// numbers, parameterized below): find crossings, drop hits an existing deck already
+// carries, dedupe widest-first, then splice the road STRAIGHT across the channel on a
+// perpendicular chord — clear-bank anchors, collinear approach legs, rejoin points walked
+// along the old road, chord mids at chordStep, long legs re-densified under legGate. Runs
+// to a FIXED POINT (a splice can create a new crossing), then pushes any surviving road
+// vertex out of the water to the near bank.
+//
+// MUTATES `roads` IN PLACE — call it before anything snapshots them (chunk indices, road
+// benches, registrations: the same import-order law both counties already live by).
+// Returns the BRIDGE_SPOTS array: { ax, az, bx, bz, x, z, w } chord anchors + centre +
+// local channel half-width; the games' bridge builders and deck holds read it from there.
+//
+// chordStep/legGate: western runs 28/30 (the travellers' ≤30 m route-leg law — see its
+// verify-travellers note); fable runs 36/40 (its minimap's 74 m window). Inserted points
+// are collinear on the chord, so roadDistance, the paint and the terrain are bit-identical
+// under either spacing — only where the walkers get their waypoints changes.
+// Headless by law: no imports at all.
+
+function segInt(a, b, c, d) { // 2D segment intersection → {x,z,t (road param),u (river param)}
+  const rx = b.x - a.x, rz = b.z - a.z, sx = d.x - c.x, sz = d.z - c.z;
+  const denom = rx * sz - rz * sx;
+  if (Math.abs(denom) < 1e-9) return null;
+  const t = ((c.x - a.x) * sz - (c.z - a.z) * sx) / denom;
+  const u = ((c.x - a.x) * rz - (c.z - a.z) * rx) / denom;
+  if (t < 0 || t > 1 || u < 0 || u > 1) return null;
+  return { x: a.x + rx * t, z: a.z + rz * t, t, u };
+}
+
+function walkRoad(road, i, t, dist) { // walk `dist` m along the polyline → {x,z,seg,clamped}
+  let seg = i, tt = t, remaining = Math.abs(dist), clamped = false;
+  const dir = Math.sign(dist) || 1;
+  while (remaining > 0) {
+    const a = road[seg], b = road[seg + 1];
+    if (!a || !b) break;
+    const len = Math.hypot(b.x - a.x, b.z - a.z) || 1e-6;
+    const along = dir > 0 ? (1 - tt) * len : tt * len;
+    if (along >= remaining) { tt += dir * (remaining / len); break; }
+    remaining -= along;
+    seg += dir; tt = dir > 0 ? 0 : 1;
+    if (seg < 0 || seg >= road.length - 1) { seg = Math.max(0, Math.min(road.length - 2, seg)); tt = dir > 0 ? 1 : 0; clamped = true; break; }
+  }
+  const a = road[seg], b = road[seg + 1];
+  return { x: a.x + (b.x - a.x) * tt, z: a.z + (b.z - a.z) * tt, seg, clamped };
+}
+
+export function spliceBridges(roads, rivers, { chordStep = 28, legGate = 30, approach = 14, margin = 5, pushClear = 6 } = {}) {
+  // metres of dry margin OUTSIDE the nearest river channel (negative = inside the water).
+  const riverClearance = (x, z) => {
+    let best = Infinity;
+    for (const R of rivers) {
+      for (let i = 0; i < R.pts.length - 1; i++) {
+        const a = R.pts[i], b = R.pts[i + 1];
+        const dx = b.x - a.x, dz = b.z - a.z;
+        const len2 = dx * dx + dz * dz || 1e-9;
+        let t = ((x - a.x) * dx + (z - a.z) * dz) / len2;
+        t = t < 0 ? 0 : t > 1 ? 1 : t;
+        const d = Math.hypot(x - (a.x + dx * t), z - (a.z + dz * t));
+        const ww = R.ww[i] + (R.ww[Math.min(i + 1, R.ww.length - 1)] - R.ww[i]) * t;
+        best = Math.min(best, d - ww);
+      }
+    }
+    return best;
+  };
+
+  const BRIDGE_SPOTS = [];
+  const deckVerts = new Set();
+  for (let pass = 0; pass < 4; pass++) {
+    const hits = [];
+    roads.forEach((road, ri) => {
+      for (let i = 0; i < road.length - 1; i++)
+        for (const R of rivers)
+          for (let j = 0; j < R.pts.length - 1; j++) {
+            const h = segInt(road[i], road[i + 1], R.pts[j], R.pts[j + 1]);
+            if (h) hits.push({ ...h, ri, i, w: R.ww[j] + (R.ww[Math.min(j + 1, R.ww.length - 1)] - R.ww[j]) * h.u });
+          }
+    });
+    const carried = (h) => BRIDGE_SPOTS.some((s) => {
+      const dx = s.bx - s.ax, dz = s.bz - s.az, l2 = dx * dx + dz * dz || 1e-9;
+      let t = ((h.x - s.ax) * dx + (h.z - s.az) * dz) / l2; t = t < 0 ? 0 : t > 1 ? 1 : t;
+      return Math.hypot(h.x - (s.ax + dx * t), h.z - (s.az + dz * t)) < 8;
+    });
+    hits.sort((a, b) => b.w - a.w);
+    const keep = [];
+    for (const h of hits) if (!carried(h) && !keep.some((k) => Math.hypot(k.x - h.x, k.z - h.z) < Math.max(24, k.w * 1.6))) keep.push(h);
+    if (!keep.length) break; // fixed point — every crossing is bridged
+    keep.sort((a, b) => (b.ri - a.ri) || (b.i - a.i));
+    const splicedFrom = new Map();
+    for (const h of keep) {
+      const road = roads[h.ri];
+      const bound = splicedFrom.get(h.ri) ?? road.length;
+      if (h.i + 1 >= bound) continue;
+      let rv = { x: 1, z: 0 }, bd = Infinity;
+      for (const R of rivers) for (let i = 0; i < R.pts.length - 1; i++) {
+        const a = R.pts[i], b = R.pts[i + 1];
+        const dx = b.x - a.x, dz = b.z - a.z, len2 = dx * dx + dz * dz || 1e-9;
+        let t = ((h.x - a.x) * dx + (h.z - a.z) * dz) / len2; t = t < 0 ? 0 : t > 1 ? 1 : t;
+        const d = Math.hypot(h.x - (a.x + dx * t), h.z - (a.z + dz * t));
+        if (d < bd) { bd = d; const l = Math.hypot(dx, dz) || 1e-9; rv = { x: dx / l, z: dz / l }; }
+      }
+      let px = -rv.z, pz = rv.x;
+      const rd = { x: road[h.i + 1].x - road[h.i].x, z: road[h.i + 1].z - road[h.i].z };
+      if (px * rd.x + pz * rd.z < 0) { px = -px; pz = -pz; }
+      const clearOut = (sgn) => {
+        const cap = h.w + (h.w > 7 ? 80 : 24);
+        let d = h.w + margin;
+        while (d < cap && riverClearance(h.x + sgn * px * d, h.z + sgn * pz * d) < margin) d += 2;
+        return d < cap ? d : h.w + margin;
+      };
+      const dA = clearOut(-1), dB = clearOut(1);
+      const iA = { x: h.x - px * dA, z: h.z - pz * dA }, iB = { x: h.x + px * dB, z: h.z + pz * dB };
+      const aA = { x: iA.x - px * approach, z: iA.z - pz * approach };
+      const aB = { x: iB.x + px * approach, z: iB.z + pz * approach };
+      const rejoin = (sgn, ref) => {
+        const base = (sgn < 0 ? dA : dB) + approach + 12;
+        let P = null;
+        for (let d = base; d <= base + 60; d += 4) {
+          P = walkRoad(road, h.i, h.t, sgn * d);
+          if (P.clamped || ((P.x - ref.x) * px + (P.z - ref.z) * pz) * sgn >= 4) return P;
+        }
+        return P;
+      };
+      const A = rejoin(-1, aA), B = rejoin(1, aB);
+      if (A.clamped && B.clamped) continue;
+      let to = B.clamped ? road.length - 1 : B.seg;
+      const from = A.clamped ? 0 : A.seg + 1;
+      const joinB = to >= bound;
+      if (joinB) to = bound - 1;
+      if (to < from - 1) continue;
+      const start = A.clamped ? iA : aA, end = B.clamped ? iB : aB;
+      const ins = [];
+      if (!A.clamped && Math.hypot(A.x - start.x, A.z - start.z) > 0.01) ins.push({ x: A.x, z: A.z });
+      ins.push(start);
+      const runL = Math.hypot(end.x - start.x, end.z - start.z);
+      for (let d = chordStep; d < runL - 4; d += chordStep) {
+        const mid = { x: start.x + px * d, z: start.z + pz * d };
+        ins.push(mid); deckVerts.add(mid);
+      }
+      ins.push(end);
+      if (!B.clamped && !joinB && Math.hypot(B.x - end.x, B.z - end.z) > 0.01) ins.push({ x: B.x, z: B.z });
+      for (let k = ins.length - 1; k > 0; k--) {
+        const p = ins[k - 1], q = ins[k];
+        const L = Math.hypot(q.x - p.x, q.z - p.z);
+        if (L > legGate) {
+          const n = Math.ceil(L / chordStep), legMids = [];
+          for (let s = 1; s < n; s++) legMids.push({ x: p.x + (q.x - p.x) * s / n, z: p.z + (q.z - p.z) * s / n });
+          ins.splice(k, 0, ...legMids);
+        }
+      }
+      road.splice(from, to - from + 1, ...ins);
+      splicedFrom.set(h.ri, from);
+      deckVerts.add(start); deckVerts.add(end);
+      BRIDGE_SPOTS.push({ ax: iA.x, az: iA.z, bx: iB.x, bz: iB.z, x: (iA.x + iB.x) / 2, z: (iA.z + iB.z) / 2, w: h.w });
+    }
+  }
+  // Final pass: any road vertex still INSIDE a channel is pushed to the near bank.
+  for (const road of roads) for (const v of road) {
+    if (deckVerts.has(v)) continue;
+    let best = Infinity, nx = 0, nz = 0;
+    for (const R of rivers) for (let i = 0; i < R.pts.length - 1; i++) {
+      const a = R.pts[i], b = R.pts[i + 1];
+      const dx = b.x - a.x, dz = b.z - a.z, len2 = dx * dx + dz * dz || 1e-9;
+      let t = ((v.x - a.x) * dx + (v.z - a.z) * dz) / len2; t = t < 0 ? 0 : t > 1 ? 1 : t;
+      const cxp = a.x + dx * t, czp = a.z + dz * t;
+      const d = Math.hypot(v.x - cxp, v.z - czp);
+      const ww = R.ww[i] + (R.ww[Math.min(i + 1, R.ww.length - 1)] - R.ww[i]) * t;
+      if (d - ww < best) { best = d - ww; nx = cxp; nz = czp; }
+    }
+    if (best >= pushClear) continue;
+    const d = Math.hypot(v.x - nx, v.z - nz) || 1e-6;
+    const k = (pushClear - best) / d;
+    v.x += (v.x - nx) * k; v.z += (v.z - nz) * k;
+  }
+  return BRIDGE_SPOTS;
+}

package/src/world/geo.js

@@ -0,0 +1,53 @@
+// THE GEO TOOLKIT (world splits, step 1) — the terrain-math primitives both games carried
+// as byte-identical private copies: the fbm/ridged noise kit (fixed ImprovedNoise
+// permutation → deterministic, one shared instance is safe), the smoothstep/terrace
+// shapers, and the point-to-segment distance the polyline indices are built on.
+//
+// HEADLESS BY LAW: this module imports ONLY three/addons math — never three/webgpu —
+// because the games' terrainData files (its consumers) run in Node for offline solvers,
+// verify scripts and height-equivalence probes. Keep it that way.
+//
+// EQUIVALENCE CONTRACT: these bodies moved verbatim from western/fable terrainData.js.
+// Any numeric change here changes both counties' ground — prove a refactor with the
+// height-grid probe (441 samples per game) before shipping it.
+import { ImprovedNoise } from 'three/addons/math/ImprovedNoise.js';
+
+const noise = new ImprovedNoise();
+
+export function fbm(x, z, octaves = 4, lacunarity = 2, gain = 0.5, scale = 0.01) {
+  let amp = 1, freq = scale, sum = 0, norm = 0;
+  for (let i = 0; i < octaves; i++) {
+    sum += amp * noise.noise(x * freq, z * freq, 7.31 + i * 13.7);
+    norm += amp; amp *= gain; freq *= lacunarity;
+  }
+  return sum / norm;
+}
+
+export const clamp = (v, a, b) => Math.min(b, Math.max(a, v));
+export const lerp = (a, b, t) => a + (b - a) * t;
+export function smoothstep(a, b, t) { const x = clamp((t - a) / (b - a), 0, 1); return x * x * (3 - 2 * x); }
+
+// ~[0,1]: sharp crests, round valleys — mountain ranges and mesa fields
+export function ridged(x, z, octaves, lac, gain, scale) {
+  let amp = 0.5, freq = scale, sum = 0, norm = 0, prev = 1;
+  for (let i = 0; i < octaves; i++) {
+    let n = 1 - Math.abs(noise.noise(x * freq, z * freq, 41.7 + i * 7.3));
+    n *= n; n *= prev; sum += n * amp; norm += amp; prev = n; amp *= gain; freq *= lac;
+  }
+  return sum / norm;
+}
+
+// quantise to benches with a sharp riser — mesa walls, cliff bands
+export function terrace(h, step, sharp) {
+  const f = h / step, k = Math.floor(f), frac = f - k;
+  return (k + lerp(frac, smoothstep(0.5 - 0.5 * sharp, 0.5 + 0.5 * sharp, frac), sharp)) * step;
+}
+
+// distance from (px,pz) to segment a→b — the primitive under every polyline index
+export function segDist(px, pz, ax, az, bx, bz) {
+  const dx = bx - ax, dz = bz - az;
+  const len2 = dx * dx + dz * dz;
+  let t = len2 ? ((px - ax) * dx + (pz - az) * dz) / len2 : 0;
+  t = clamp(t, 0, 1);
+  return Math.hypot(px - (ax + dx * t), pz - (az + dz * t));
+}

package/src/world/railFormation.js

@@ -0,0 +1,185 @@
+// THE RAIL FORMATION SOLVER (world splits, step 2) — the embankment IS the terrain.
+// Moved verbatim from western's terrainData: the navvy's algorithm that turns a centreline
+// over raw ground into a buildable formation, and the corridor index heightAt interrogates
+// 1.74M times per cold cook. Everything here is PURE MACHINERY — the county supplies the
+// nodes, the surveyed ground, the ruling grade and the weave (its applyRail composition
+// stays game-side, where the river guard and road bench live).
+//
+// HOW A LINE IS SOLVED, at every node of the centreline (~1 m apart):
+//   1. the game SURVEYS the ground into g[] (its own choice of surface — pads in, benches out)
+//   2. LEVEL THE YARDS — each contiguous `flat` run pulled to its own mean
+//   3. THE RULING GRADE — ceil/floor Lipschitz envelopes at maxGrade; their midpoint splits
+//      every obstacle evenly between a cutting and an embankment
+//   4. VERTICAL CURVES — a diffusion pass is a curve and cannot break the ruling grade
+//   5. optional WELD onto an already-solved line (one bed through the turnout, no seam)
+//   6. e[] — earthworks weight: 1 = full bench, 0 = past fillMax, flying on a trestle
+//
+// HEADLESS BY LAW, like geo.js: no three imports at all.
+import { clamp, lerp, smoothstep } from './geo.js';
+
+// Nearest point on a solved line: how far, and how high the formation is there.
+export function nearestOnLine(nodes, Y, x, z) {
+  let bd = Infinity, by = 0;
+  for (let i = 0; i < nodes.length - 1; i++) {
+    const a = nodes[i], b = nodes[i + 1];
+    const dx = b.x - a.x, dz = b.z - a.z, len2 = dx * dx + dz * dz || 1e-9;
+    const t = clamp(((x - a.x) * dx + (z - a.z) * dz) / len2, 0, 1);
+    const d = Math.hypot(x - (a.x + dx * t), z - (a.z + dz * t));
+    if (d < bd) { bd = d; by = lerp(Y[i], Y[i + 1], t); }
+  }
+  return { d: bd, y: by };
+}
+
+// nodes: [{x, z, s, w, flat}] — s = arc length, w = bed half-width, flat = yard node.
+// g: Float64Array of surveyed ground per node (the game samples its own surface).
+// mergeWith: { nodes, y } of an already-solved line to weld through the shared bed.
+// Returns { y, g, e }.
+export function solveFormation(nodes, g, { maxGrade, smooth = 90, mergeIn = 7, mergeOut = 32, fillMax, mergeWith = null }) {
+  const n = nodes.length;
+  g = Float64Array.from(g);
+
+  // ONE BED THROUGH THE TURNOUT: where this line is still in the other's bed, the ground
+  // it is surveyed on IS the other line's formation.
+  if (mergeWith) {
+    for (let i = 0; i < n; i++) {
+      const m = nearestOnLine(mergeWith.nodes, mergeWith.y, nodes[i].x, nodes[i].z);
+      g[i] = lerp(m.y, g[i], smoothstep(mergeIn, mergeOut, m.d));
+    }
+  }
+
+  // LEVEL THE YARDS — each contiguous run of `flat` nodes pulled to its own mean.
+  for (let i = 0; i < n; i++) {
+    if (!nodes[i].flat) continue;
+    let j = i; while (j < n && nodes[j].flat) j++;
+    let sum = 0; for (let k = i; k < j; k++) sum += g[k];
+    const mean = sum / (j - i);
+    for (let k = i; k < j; k++) g[k] = mean;
+    i = j;
+  }
+
+  // THE RULING GRADE — the two Lipschitz envelopes, and their midpoint.
+  const ceil = Float64Array.from(g), floor = Float64Array.from(g);
+  for (let i = 1; i < n; i++) {
+    const d = maxGrade * (nodes[i].s - nodes[i - 1].s);
+    ceil[i] = Math.max(ceil[i], ceil[i - 1] - d);      // may only FALL at the ruling grade
+    floor[i] = Math.min(floor[i], floor[i - 1] + d);   // may only RISE at it
+  }
+  for (let i = n - 2; i >= 0; i--) {
+    const d = maxGrade * (nodes[i + 1].s - nodes[i].s);
+    ceil[i] = Math.max(ceil[i], ceil[i + 1] - d);
+    floor[i] = Math.min(floor[i], floor[i + 1] + d);
+  }
+  const y = new Float64Array(n);
+  for (let i = 0; i < n; i++) y[i] = 0.5 * (ceil[i] + floor[i]);
+
+  // THE VERTICAL CURVES.
+  const tmp = new Float64Array(n);
+  for (let p = 0; p < smooth; p++) {
+    tmp.set(y);
+    for (let i = 1; i < n - 1; i++) y[i] = 0.25 * tmp[i - 1] + 0.5 * tmp[i] + 0.25 * tmp[i + 1];
+  }
+
+  // …and weld the result back onto the line it left — bit-identical through the shared bed.
+  if (mergeWith) {
+    for (let i = 0; i < n; i++) {
+      const m = nearestOnLine(mergeWith.nodes, mergeWith.y, nodes[i].x, nodes[i].z);
+      y[i] = lerp(m.y, y[i], smoothstep(mergeIn, mergeOut, m.d));
+    }
+  }
+
+  // HOW MUCH EARTH TO MOVE. Past fillMax the bank would be a wall — stop building and fly.
+  const e = new Float64Array(n);
+  for (let i = 0; i < n; i++) e[i] = 1 - smoothstep(fillMax, fillMax + 1.5, y[i] - g[i]);
+  return { y, g, e };
+}
+
+// THE CORRIDOR INDEX — chunked AABBs per line plus ONE box round the whole railway, because
+// the county is huge, the railway is a ribbon, and the common answer must cost four compares.
+// lines: { name: { nodes, y, e } }. Returns { railInfo, railDistance, records } — records is
+// the fixed scratch array (one record per line, rewritten in place, zero allocation per call)
+// the game's own corridor blend iterates.
+export function makeRailIndex(lines, { near, chunk = 32 } = {}) {
+  const chunks = [];
+  const box = { minX: Infinity, maxX: -Infinity, minZ: Infinity, maxZ: -Infinity };
+  const rl = {};
+  for (const name of Object.keys(lines)) {
+    rl[name] = { d: Infinity, y: 0, w: 0, e: 1 };
+    const { nodes: N, y: Y, e: E } = lines[name];
+    for (let i = 0; i < N.length - 1; i += chunk) {
+      const end = Math.min(i + chunk, N.length - 1);
+      let minX = Infinity, maxX = -Infinity, minZ = Infinity, maxZ = -Infinity;
+      for (let j = i; j <= end; j++) {
+        const p = N[j];
+        if (p.x < minX) minX = p.x; if (p.x > maxX) maxX = p.x;
+        if (p.z < minZ) minZ = p.z; if (p.z > maxZ) maxZ = p.z;
+      }
+      chunks.push({ name, N, Y, E, i0: i, i1: end, minX: minX - near, maxX: maxX + near, minZ: minZ - near, maxZ: maxZ + near });
+      box.minX = Math.min(box.minX, minX - near); box.maxX = Math.max(box.maxX, maxX + near);
+      box.minZ = Math.min(box.minZ, minZ - near); box.maxZ = Math.max(box.maxZ, maxZ + near);
+    }
+  }
+  const records = Object.values(rl);
+
+  function railInfo(x, z) {
+    for (const r of records) r.d = Infinity;
+    if (x < box.minX || x > box.maxX || z < box.minZ || z > box.maxZ) return rl;
+    for (const c of chunks) {
+      if (x < c.minX || x > c.maxX || z < c.minZ || z > c.maxZ) continue;
+      const R = rl[c.name], N = c.N, Y = c.Y, E = c.E;
+      for (let i = c.i0; i < c.i1; i++) {
+        const a = N[i], b = N[i + 1];
+        const dx = b.x - a.x, dz = b.z - a.z, len2 = dx * dx + dz * dz || 1e-9;
+        const t = clamp(((x - a.x) * dx + (z - a.z) * dz) / len2, 0, 1);
+        const d = Math.hypot(x - (a.x + dx * t), z - (a.z + dz * t));
+        if (d < R.d) {
+          R.d = d;
+          R.y = lerp(Y[i], Y[i + 1], t);
+          R.w = lerp(a.w, b.w, t);
+          R.e = lerp(E[i], E[i + 1], t);
+        }
+      }
+    }
+    return rl;
+  }
+
+  function railDistance(x, z) {
+    const r = railInfo(x, z);
+    let d = Infinity;
+    for (const name in r) if (r[name].d < d) d = r[name].d;
+    return d;
+  }
+
+  return { railInfo, railDistance, records };
+}
+
+// WHERE THE ROADS CROSS THE RAILS — found, not assumed: every road segment against every
+// rail segment. Returns [{x, z, y, tx, tz}] with y = the formation there and (tx,tz) the
+// rail's unit tangent (the axis the deck is measured along).
+export function findCrossings(roads, lines, { minSpacing = 30 } = {}) {
+  const xings = [];
+  const hit = (a, b, c, d) => {
+    const rx = b.x - a.x, rz = b.z - a.z, sx = d.x - c.x, sz = d.z - c.z;
+    const den = rx * sz - rz * sx;
+    if (Math.abs(den) < 1e-9) return null;
+    const t = ((c.x - a.x) * sz - (c.z - a.z) * sx) / den;
+    const u = ((c.x - a.x) * rz - (c.z - a.z) * rx) / den;
+    if (t < 0 || t > 1 || u < 0 || u > 1) return null;
+    return { x: a.x + rx * t, z: a.z + rz * t };
+  };
+  for (const road of roads) {
+    for (let i = 0; i < road.length - 1; i++) {
+      for (const name of Object.keys(lines)) {
+        const { nodes: N, y: Y } = lines[name];
+        for (let j = 0; j < N.length - 1; j++) {
+          const p = hit(road[i], road[i + 1], N[j], N[j + 1]);
+          if (p && !xings.some((q) => Math.hypot(q.x - p.x, q.z - p.z) < minSpacing)) {
+            const tx0 = N[j + 1].x - N[j].x, tz0 = N[j + 1].z - N[j].z;
+            const tl = Math.hypot(tx0, tz0) || 1;
+            xings.push({ x: p.x, z: p.z, y: nearestOnLine(N, Y, p.x, p.z).y, tx: tx0 / tl, tz: tz0 / tl });
+          }
+        }
+      }
+    }
+  }
+  return xings;
+}

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' }; };
@@ -294,6 +560,7 @@ export function sindicateDevTools({
     ...stores.map(binStorePlugin),
     perfSinkPlugin(perfSink),
     guiPlugin(),
+    packImporterPlugin(),
     busPlugin({ name: 'game', prefix: '/__game', originGuard: true }),
     busPlugin({ name: 'editor', prefix: '/__editor' }),
     editorShotsPlugin({ shotsDir: editorShotsDir, mapsDir }),

package/tools/registry.json

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

package/tools/sindicate-cli.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// THE .sindicatepackage CLI (ENGINE_DESIGN §4c) — one distributable wrapper for everything
+// installable. Under the hood: an npm-compatible tarball (package/ prefix) with a
+// sindicate.json manifest at the package root, so code add-ons install with plain npm and
+// the engine tooling can read what a thing IS before installing it.
+//
+//   sindicate pack <dir>                  → <name>-<version>.sindicatepackage (from
+//                                           package.json + sindicate.json in <dir>)
+//   sindicate inspect <file>              → print the manifest
+//   sindicate install <file> [--game .]   → type 'addon'  = npm install the tarball into
+//                                           the game (dep + node_modules, bridge on boot)
+//                                           type 'assets'|'clips' = extract package/assets
+//                                           into <game>/public/assets/packs/<name>/
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+const [, , cmd, target, ...rest] = process.argv;
+const opt = (name, dflt) => { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : dflt; };
+const die = (m) => { console.error(`sindicate: ${m}`); process.exit(1); };
+
+function readManifestFromTarball(file) {
+  try {
+    const out = execFileSync('tar', ['-xzOf', file, 'package/sindicate.json'], { stdio: ['ignore', 'pipe', 'pipe'] });
+    return JSON.parse(out.toString());
+  } catch (e) { die(`${path.basename(file)}: no readable package/sindicate.json — not a .sindicatepackage (${String(e).slice(0, 120)})`); }
+}
+
+if (cmd === 'pack') {
+  const dir = path.resolve(target ?? '.');
+  const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+  const sinPath = path.join(dir, 'sindicate.json');
+  if (!fs.existsSync(sinPath)) die(`${dir}/sindicate.json missing — add { name, version, type, description } first`);
+  const sin = JSON.parse(fs.readFileSync(sinPath, 'utf8'));
+  // npm pack builds the canonical npm tarball (honours "files", writes package/ prefix);
+  // sindicate.json rides along because it is listed in "files" (enforce that here).
+  const files = pkg.files ?? [];
+  if (files.length && !files.includes('sindicate.json')) die(`package.json "files" must include "sindicate.json" so the manifest ships`);
+  const out = execFileSync('npm', ['pack', '--silent'], { cwd: dir }).toString().trim().split('\n').pop();
+  const dest = path.join(dir, `${(sin.name ?? pkg.name).replace('/', '-')}-${pkg.version}.sindicatepackage`);
+  fs.renameSync(path.join(dir, out), dest);
+  console.log(`packed ${dest} (type: ${sin.type})`);
+} else if (cmd === 'inspect') {
+  console.log(JSON.stringify(readManifestFromTarball(path.resolve(target)), null, 2));
+} else if (cmd === 'install') {
+  const file = path.resolve(target);
+  const game = path.resolve(opt('--game', '.'));
+  if (!fs.existsSync(path.join(game, 'package.json'))) die(`${game} is not a game (no package.json) — pass --game <dir>`);
+  const sin = readManifestFromTarball(file);
+  if (sin.engineRange) console.log(`engine range: ${sin.engineRange} (checked at boot by the bridge)`);
+  if (sin.type === 'addon') {
+    // npm only recognises tarballs by extension (.sindicatepackage reads as a folder path
+    // → ENOTDIR), so a .tgz TWIN sits beside the original — and STAYS: npm records the
+    // dep as file:<path-to-tgz>, so deleting it would break the game's next npm install
+    const tgz = file.replace(/\.sindicatepackage$/, '.tgz');
+    fs.copyFileSync(file, tgz);
+    execFileSync('npm', ['install', tgz], { cwd: game, stdio: 'inherit' });
+    console.log(`installed addon '${sin.name}' into ${path.basename(game)} — import it from game code${sin.bridge ? `; bridge: ${sin.bridge}` : ''}`);
+  } else if (sin.type === 'assets' || sin.type === 'clips') {
+    const dest = path.join(game, 'public/assets/packs', sin.name);
+    fs.rmSync(dest, { recursive: true, force: true });
+    fs.mkdirSync(dest, { recursive: true });
+    // extract only the package/assets tree, stripping the two leading path parts
+    execFileSync('tar', ['-xzf', file, '-C', dest, '--strip-components', '2', 'package/assets'], { stdio: 'pipe' });
+    fs.writeFileSync(path.join(dest, 'pack.json'), JSON.stringify({ ...sin, installedAt: new Date().toISOString(), source: 'sindicatepackage' }, null, 2));
+    console.log(`installed ${sin.type} pack '${sin.name}' → ${dest}`);
+  } else die(`unknown type '${sin.type}' (addon | assets | clips | pack-profile)`);
+} else {
+  console.log('usage: sindicate pack <dir> | inspect <file> | install <file> [--game <dir>]');
+  process.exit(cmd ? 1 : 0);
+}