src/engine/models.js

;
;
/* ============================================================================

   MODEL LIBRARY — every unit, structure and world object as real geometry.

   ----------------------------------------------------------------------------

   Models are welded from primitives and authored around the origin with their

   feet on y=0, facing +X (which matches the sim's angle 0). A model's own

   colours are near-neutral livery values; the per-instance tint multiplies

   them, so the same mesh serves both armies and still shows its own panel

   lines, shadow gaps and warning markings.



   Turreted vehicles are two meshes — hull and turret — instanced separately so

   the turret can track a target while the hull drives somewhere else, which is

   the whole reason tanks read as tanks.

   ============================================================================ */
const C=(r,g,b)=>[r/255,g/255,b/255];
const MET   =C(158,166,176), MET_D=C(96,104,114), MET_L=C(206,214,222);
const DARK  =C(52,58,66),   DARKER=C(32,36,42);
const TREAD =C(44,46,50),   RUBBER=C(60,62,68);
const GLASS =C(120,200,255), LAMP =C(255,226,150);
const HOT   =C(255,150,70),  ENERGY=C(140,230,255);
const CONC  =C(150,146,138), CONC_D=C(104,101,95);
const RUST  =C(140,102,72),  BONE =C(206,198,182);
/* Warm bone-amber, not leaf green. The reference material's whole character is

   a pale amber plate field falling to an almost-black wet seam; a mid-green

   base has neither the value range nor the warmth to get there, and no amount

   of lighting recovers it. CLAW stays near-white so the tips read at 40px. */
const CHITIN=C(196,178,124), CHIT_D=C(96,86,58), CLAW=C(232,226,206);
/* Biological livery and flexible tissue never inherit vehicle plate or servo

   textures. BIO_TEAM stays faction-tinted on chitin; BIO_LEG/BIO_MEM use an

   organic relief and mark appendages for procedural secondary motion. */
const BIO_TEAM=C(198,174,220), BIO_LEG=C(148,132,88), BIO_MEM=C(150,138,96);
/* TEAM_* entries are the only surfaces that take the full faction colour:

   hull flanks, turret cheeks, wing roots, roof panels. Keeping livery to a few

   deliberate panels is what makes a unit read as "blue army" without erasing

   its metal, glass and rubber. */
const TEAM_A=C(214,222,230), TEAM_B=C(160,170,182), TEAM_T=C(236,242,248);
/* Architectural palette. Structures are not vehicles: they want a wall

   material and a roof material, both far calmer than hull plating. */
const WALL  =C(176,180,188), WALL_D=C(124,128,136);
/* Anything painted SERVO is treated as a leg by the vertex stage and animates

   through the walk cycle. Use it for shins, thighs, feet and hip rams only. */
const SERVO =C(132,138,148);
const ROOFC =C(150,154,160), ROOF_T=C(196,202,210);
/* Tower-only hard-surface palette.  These references deliberately do not

   replace MET/DARK globally: vehicles and legacy structures keep their current

   finishes while defensive towers receive clearly separated armor, mechanism,

   trim, livery, light, foundation and bore materials. */
const TWR_ARM=C(190,198,208), TWR_ARM_D=C(118,128,140);
const TWR_MACH=C(145,154,166), TWR_TRIM=C(220,226,234);
const TWR_COAT=C(68,76,88), TWR_TEAM=C(218,226,236);
const TWR_GLOW=C(92,214,255), TWR_PAD=C(116,120,128), TWR_BORE=C(13,15,18);
/* Landmark glowOk only passes MAT.TWR_GLOW. This brighter vertex is the

   same tile, so HQ points read at command distance without a rail. */
const HQ_LAMP=C(236,250,255);
const LIT_WIN=C(255,230,170), COOL_WIN=C(170,230,255), FLICK_WIN=C(255,200,140);
const SHOP_WIN=C(255,245,220), NEON_CYAN=C(0,240,255), SOLAR_PANEL=C(35,50,80);
const COPPER_PAT=C(82,132,114), BRICK_RED=C(140,76,64);
const NOVA_MET=C(132,142,156), NOVA_CARB=C(44,48,56);
/* Stage S1 bespoke structure semantics. These are deliberately palette-local

   selectors, rather than a renderer switch: HQ and Techlab can establish their

   own material hierarchy now while the renderer still falls back to the live

   V2 atlas. They are semantic-bake prototypes, NOT UV-authored map packs. */
const NOVA_HQ_ARM=C(152,158,166), NOVA_HQ_STRUCT=C(46,50,56);
const NOVA_HQ_ROOF=C(116,132,152), NOVA_HQ_GLASS=C(44,130,196);
const NOVA_RESEARCH_ARM=C(136,154,178), NOVA_RESEARCH_CORE=C(40,60,82);
const NOVA_RESEARCH_ROOF=C(104,122,144), NOVA_RESEARCH_GLASS=C(50,148,212);
/* Stage S2 keeps production landmarks as individual semantic packs. These are

   palette selectors for the live V2 material atlas, not a claim that custom

   UV-authored maps already exist. Their separation is intentional: when the

   authored BaseAO/NRE/mask pack lands, it can replace just one landmark's

   surfaces without accidentally recolouring another Nova building. */
const NOVA_FACTORY_ARM=C(132,154,180), NOVA_FACTORY_CORE=C(34,46,62);
const NOVA_FACTORY_ROOF=C(100,122,148), NOVA_FACTORY_GLASS=C(48,136,202);
const NOVA_REACTOR_ARM=C(124,150,176), NOVA_REACTOR_CORE=C(30,46,64);
const NOVA_REACTOR_TRIM=C(156,178,202), NOVA_REACTOR_GLOW=C(72,208,255);
const NOVA_AIR_DECK=C(58,76,100), NOVA_AIR_ARM=C(128,150,176);
const NOVA_AIR_ROOF=C(104,126,150), NOVA_AIR_GLASS=C(48,142,210);
const NOVA_FAB_ARM=C(130,152,176), NOVA_FAB_CORE=C(38,50,66);
const NOVA_FAB_ROOF=C(102,124,148), NOVA_FAB_GLASS=C(50,138,204);
/* Stage S3 extends the same isolated semantic treatment to real Nova economy

   and support structures. These are still palette selectors for the live V2

   material atlas, not a claim that bespoke UV-authored maps are complete. */
const NOVA_MEX_ARM=C(126,148,174), NOVA_MEX_CORE=C(34,50,68);
const NOVA_MEX_TRIM=C(160,180,202), NOVA_MEX_GLOW=C(22,70,92);
/* Service-deck plating. Its own palette entry so retiring it from a pad

   cannot disturb TWR_COAT, which many other surfaces still use. */
const NOVA_DECK=C(111,119,131);
const NOVA_GEO_ARM=C(122,146,170), NOVA_GEO_CORE=C(30,46,62);
const NOVA_GEO_TRIM=C(154,178,202), NOVA_GEO_GLOW=C(76,210,255);
const NOVA_SILO_ARM=C(130,150,174), NOVA_SILO_CORE=C(36,48,62);
const NOVA_SILO_ROOF=C(104,124,148), NOVA_SILO_GLOW=C(64,196,248);
const NOVA_UPLINK_ARM=C(128,152,178), NOVA_UPLINK_CORE=C(32,48,66);
const NOVA_UPLINK_TRIM=C(162,184,208), NOVA_UPLINK_GLOW=C(70,210,255);
const NOVA_HARBOR_ARM=C(124,148,174), NOVA_HARBOR_CORE=C(32,48,66);
const NOVA_HARBOR_DECK=C(78,98,124), NOVA_HARBOR_GLASS=C(46,136,202);
/* Stage S4 gives the common Nova defenses distinct semantic palettes.  These

   remain live-V2 selectors, deliberately isolated per building family, so a

   later authored bake can replace one asset without recolouring another. */
const NOVA_SENTINEL_ARM=C(138,160,186), NOVA_SENTINEL_CORE=C(36,48,64);
const NOVA_SENTINEL_TRIM=C(164,188,214), NOVA_SENTINEL_GLOW=C(72,212,255);
const NOVA_BUNKER_ARM=C(132,150,174), NOVA_BUNKER_CORE=C(34,44,58);
const NOVA_BUNKER_TRIM=C(156,176,200), NOVA_BUNKER_GLOW=C(68,198,246);
const NOVA_RAIL_ARM=C(144,166,194), NOVA_RAIL_CORE=C(30,42,60);
const NOVA_RAIL_TRIM=C(174,198,224), NOVA_RAIL_GLOW=C(84,224,255);
const DROP_CANOPY_GLASS=C(34,112,176);       // dark pressure glazing stays blue under the overhead world light
const LEG_IRON=C(88,80,78), LEG_VENT=C(255,100,20);
const SYN_NANO_C=C(120,132,148), SYN_GOLD_C=C(212,175,55), SYN_FLOW=C(0,220,240);
const BROOD_MEMB=C(184,152,120);
const HEADLIGHT_C=C(255,250,220), TAILLIGHT_C=C(255,34,17);

/* Colour constants double as MATERIAL selectors: the builder tracks a current

   material, and this wrapper sets it from whichever palette entry a primitive

   was already using. That upgrades the entire model library to textured

   surfaces without touching a single call site. */
const COL_MAT=new Map();
const COL_TEAM=new Set();          // palette entries painted in team livery
function bindMat(){
  COL_MAT.set(MET,matResolve('hull'));   COL_MAT.set(MET_D,matResolve('hull.dark')); COL_MAT.set(MET_L,matResolve('hull.trim'));
  COL_MAT.set(DARK,matResolve('hull.dark'));COL_MAT.set(DARKER,matResolve('hull.dark'));
  COL_MAT.set(TREAD,matResolve('hull.track')); COL_MAT.set(RUBBER,matResolve('hull.track'));
  COL_MAT.set(GLASS,matResolve('glass.canopy')); COL_MAT.set(LAMP,matResolve('emissive.light'));
  COL_MAT.set(HOT,matResolve('emissive.light'));    COL_MAT.set(ENERGY,matResolve('emissive.energy'));
  COL_MAT.set(CONC,MAT.CONC);   COL_MAT.set(CONC_D,MAT.CONC);
  COL_MAT.set(RUST,MAT.RUST);   COL_MAT.set(BONE,MAT.CONC);
  COL_MAT.set(CHITIN,matResolve('bio.shell')); COL_MAT.set(CHIT_D,matResolve('bio.shell')); COL_MAT.set(CLAW,matResolve('hull.trim'));
  COL_MAT.set(BIO_TEAM,matResolve('bio.shell')); COL_MAT.set(BIO_LEG,matResolve('bio.limb')); COL_MAT.set(BIO_MEM,matResolve('bio.membrane'));
  COL_MAT.set(TEAM_A,matResolve('hull')); COL_MAT.set(TEAM_B,matResolve('hull')); COL_MAT.set(TEAM_T,matResolve('hull.trim'));
  COL_MAT.set(WALL,matResolve('structure.wall'));  COL_MAT.set(WALL_D,matResolve('structure.wall'));
  COL_MAT.set(SERVO,MAT.SERVO);
  COL_MAT.set(ROOFC,matResolve('structure.roof'));  COL_MAT.set(ROOF_T,matResolve('structure.roof'));
  COL_MAT.set(TWR_ARM,MAT.TWR_ARMOR); COL_MAT.set(TWR_ARM_D,MAT.TWR_ARMOR);
  COL_MAT.set(TWR_MACH,MAT.TWR_MACH); COL_MAT.set(TWR_TRIM,MAT.TWR_MACH);
  COL_MAT.set(TWR_COAT,MAT.TWR_COAT); COL_MAT.set(TWR_TEAM,MAT.TWR_ARMOR);
  COL_MAT.set(TWR_GLOW,MAT.TWR_GLOW); COL_MAT.set(HQ_LAMP,MAT.TWR_GLOW); COL_MAT.set(TWR_PAD,MAT.TWR_PAD);
  COL_MAT.set(TWR_BORE,MAT.TWR_BORE);

  COL_MAT.set(LIT_WIN,matResolve('window.warm'));   COL_MAT.set(COOL_WIN,matResolve('window.cool'));
  COL_MAT.set(FLICK_WIN,matResolve('window.flicker')); COL_MAT.set(SHOP_WIN,matResolve('window.shop'));
  COL_MAT.set(NEON_CYAN,MAT.NEON_FACADE);      COL_MAT.set(SOLAR_PANEL,matResolve('roof.solar'));
  COL_MAT.set(COPPER_PAT,matResolve('roof.copper'));     COL_MAT.set(BRICK_RED,MAT.BRICK_MASONRY);
  COL_MAT.set(NOVA_MET,matResolve('faction.nova'));    COL_MAT.set(NOVA_CARB,MAT.NOVA_CARBON);
  /* HQ/Techlab own semantic surface sets until authored UV packs arrive.

     Keeping the mappings local prevents a generic Nova-material edit from

     accidentally changing every production building in the faction. */
  COL_MAT.set(NOVA_HQ_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_HQ_STRUCT,MAT.TWR_COAT);
  COL_MAT.set(NOVA_HQ_ROOF,matResolve('structure.roof')); COL_MAT.set(NOVA_HQ_GLASS,matResolve('glass.canopy'));
  COL_MAT.set(NOVA_RESEARCH_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_RESEARCH_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_RESEARCH_ROOF,matResolve('structure.roof')); COL_MAT.set(NOVA_RESEARCH_GLASS,matResolve('glass.canopy'));
  COL_MAT.set(NOVA_FACTORY_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_FACTORY_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_FACTORY_ROOF,matResolve('structure.roof')); COL_MAT.set(NOVA_FACTORY_GLASS,matResolve('glass.canopy'));
  COL_MAT.set(NOVA_REACTOR_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_REACTOR_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_REACTOR_TRIM,matResolve('hull.trim')); COL_MAT.set(NOVA_REACTOR_GLOW,matResolve('emissive.energy'));
  COL_MAT.set(NOVA_AIR_DECK,matResolve('structure.roof')); COL_MAT.set(NOVA_AIR_ARM,matResolve('faction.nova'));
  COL_MAT.set(NOVA_AIR_ROOF,matResolve('structure.roof')); COL_MAT.set(NOVA_AIR_GLASS,matResolve('glass.canopy'));
  COL_MAT.set(NOVA_FAB_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_FAB_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_FAB_ROOF,matResolve('structure.roof')); COL_MAT.set(NOVA_FAB_GLASS,matResolve('glass.canopy'));
  COL_MAT.set(NOVA_MEX_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_MEX_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_MEX_TRIM,matResolve('hull.trim')); COL_MAT.set(NOVA_MEX_GLOW,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_DECK,MAT.DECK_PLATE);
  COL_MAT.set(NOVA_GEO_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_GEO_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_GEO_TRIM,matResolve('hull.trim')); COL_MAT.set(NOVA_GEO_GLOW,matResolve('emissive.energy'));
  COL_MAT.set(NOVA_SILO_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_SILO_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_SILO_ROOF,matResolve('structure.roof')); COL_MAT.set(NOVA_SILO_GLOW,matResolve('emissive.energy'));
  COL_MAT.set(NOVA_UPLINK_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_UPLINK_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_UPLINK_TRIM,matResolve('hull.trim')); COL_MAT.set(NOVA_UPLINK_GLOW,matResolve('emissive.energy'));
  COL_MAT.set(NOVA_HARBOR_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_HARBOR_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_HARBOR_DECK,matResolve('structure.roof')); COL_MAT.set(NOVA_HARBOR_GLASS,matResolve('glass.canopy'));
  COL_MAT.set(NOVA_SENTINEL_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_SENTINEL_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_SENTINEL_TRIM,matResolve('hull.trim')); COL_MAT.set(NOVA_SENTINEL_GLOW,matResolve('emissive.energy'));
  COL_MAT.set(NOVA_BUNKER_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_BUNKER_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_BUNKER_TRIM,matResolve('hull.trim')); COL_MAT.set(NOVA_BUNKER_GLOW,matResolve('emissive.energy'));
  COL_MAT.set(NOVA_RAIL_ARM,matResolve('faction.nova')); COL_MAT.set(NOVA_RAIL_CORE,MAT.NOVA_CARBON);
  COL_MAT.set(NOVA_RAIL_TRIM,matResolve('hull.trim')); COL_MAT.set(NOVA_RAIL_GLOW,matResolve('emissive.energy'));
  COL_MAT.set(DROP_CANOPY_GLASS,matResolve('glass.canopy'));
  COL_MAT.set(LEG_IRON,matResolve('faction.legion'));       COL_MAT.set(LEG_VENT,MAT.LEGION_THERMITE);
  COL_MAT.set(SYN_NANO_C,matResolve('faction.syndicate'));        COL_MAT.set(SYN_GOLD_C,MAT.SYN_GOLD);
  COL_MAT.set(SYN_FLOW,matResolve('emissive.energy'));       COL_MAT.set(BROOD_MEMB,matResolve('bio.membrane'));
  COL_MAT.set(HEADLIGHT_C,MAT.UNIT_HEADLIGHT); COL_MAT.set(TAILLIGHT_C,MAT.UNIT_TAILLIGHT);
}
bindMat();
COL_TEAM.add(TEAM_A); COL_TEAM.add(TEAM_B); COL_TEAM.add(TEAM_T);
COL_TEAM.add(TWR_TEAM);
COL_TEAM.add(BIO_TEAM);
/* A named role is preferred, but legacy models still pass palette colours.

   The fallback heuristics prevent an unregistered pale cyan face from becoming

   dull steel when an experimental model is added before its palette binding. */
function matDetect(col,role){
  if(role) return matResolve(role);
  const known=COL_MAT.get(col); if(known!=null) return known;
  if(!Array.isArray(col)) return MAT.PLATE;
  const r=col[0]||0,g=col[1]||0,b=col[2]||0;
  if(b>r*1.35&&b>g*1.08&&b>.42) return matResolve('glass');
  if(r>.82&&g>.82&&b>.82) return matResolve('hull.trim');
  if(r<.24&&g<.24&&b<.24) return matResolve('hull.dark');
  return matResolve('hull');
}
/* Patch the builder so every legacy primitive picks its material from its

   palette while new factories can request semantic material roles directly. */
for(const fn of ['box','cyl','sphere','wedge','extrude','ring','bevelBox','inset','tube','greeble']){
  const orig=MeshBuilder.prototype[fn];
  MeshBuilder.prototype[fn]=function(...args){
    /* The colour argument sits at a different index per primitive. Scan from

       the end: position vectors come first, while colour is always the last

       normalized RGB tuple before optional yaw/flags. This lets new palette

       colours get a sensible material fallback instead of silently inheriting

       the previous part's material. */
    for(let k=args.length-1;k>=0;k--){
      const a=args[k];
      if(Array.isArray(a)&&a.length===3&&a.every(v=>typeof v==='number'&&v>=0&&v<=1)){
        this.m=matDetect(a); this.tm=COL_TEAM.has(a); break;
      }
    }
    return orig.apply(this,args);
  };
}

/* Tread bank: two blocks with road wheels between them. Repeated on nearly

   every ground vehicle, so it earns its own function. */
function treads(m,len,wid,h,gauge,wheels){
  for(const s of [-1,1]){
    m.box(0,0,s*gauge,len,h,wid,TREAD);
    m.box(0,h*0.34,s*gauge,len*1.03,h*0.34,wid*1.16,DARKER);   // track links
    const n=wheels||4;
    for(let k=0;k<n;k++){
      const x=-len/2+len*(k+0.5)/n;
      m.cyl(x,h*0.5,s*gauge,h*0.42,h*0.42,wid*0.5,7,RUBBER);
    }
  }
}
/* Rectangular hull with chamfered nose — the base of most vehicles. */
function hullPlate(m,len,wid,h,y,col){
  m.extrude(0,y,0,[[-len*0.5,-wid*0.5],[len*0.30,-wid*0.5],[len*0.5,-wid*0.26],
                   [len*0.5,wid*0.26],[len*0.30,wid*0.5],[-len*0.5,wid*0.5]],h,col);
}
function barrel(m,x,y,z,len,r,col){
  m.cyl(x,y,z,r,r*0.86,0,8,col);                 // placeholder (kept for clarity)
}
/* Append a temporary +Y primitive after rotating it onto +X. Keeping this in

   one helper matters: positions AND normals must move while UV/material data

   stays untouched, and every index must be offset by the receiving mesh. */
function mergeAxisX(m,mm,x,y,z){
  for(let i=0;i<mm.v.length;i+=VFLOATS){
    const px=mm.v[i], py=mm.v[i+1], pz=mm.v[i+2];
    mm.v[i]=py+x; mm.v[i+1]=-px+y; mm.v[i+2]=pz+z;
    const nx=mm.v[i+3], ny=mm.v[i+4];
    mm.v[i+3]=ny; mm.v[i+4]=-nx;
  }
  const o=m.n;
  for(let i=0;i<mm.v.length;i++) m.v.push(mm.v[i]);
  for(const ix of mm.i) m.i.push(ix+o);
  m.n+=mm.n;
  /* Match a native primitive call: the colour wrapper also leaves the active

     material/team state on the receiving builder for any direct faces next. */
  m.m=mm.m; m.tm=mm.tm;
  return m;
}
/* Cylinders and hollow tubes along the weapon-forward +X axis. The native

   primitives stand on +Y, which made callers that passed a yaw build antennae

   instead of barrels. These explicit helpers make that mistake impossible. */
function cylX(m,x,y,z,len,r1,r2,seg,col,cap){
  const mm=MB(); mm.m=m.m; mm.tm=m.tm;
  mm.cyl(0,0,0,r1,r2,len,seg,col,cap);
  return mergeAxisX(m,mm,x,y,z);
}
function tubeX(m,x,y,z,len,rOut,rIn,seg,col){
  const mm=MB(); mm.m=m.m; mm.tm=m.tm;
  mm.tube(0,0,0,rOut,rIn,len,seg,col);
  return mergeAxisX(m,mm,x,y,z);
}
function ringX(m,x,y,z,r0,r1,seg,col){
  const mm=MB(); mm.m=m.m; mm.tm=m.tm;
  mm.ring(0,0,0,r0,r1,seg,col);
  return mergeAxisX(m,mm,x,y,z);
}
/* A gun barrel pointing along +X, with an optional lateral offset. */
function gunX(m,x0,y,len,r,col,z){
  const seg=8, zz=z||0;
  /* No front cap: the following tube exposes a real shadowed bore instead of

     painting a dark circle over a flat barrel end. */
  cylX(m,x0,y,zz,len,r,r*0.88,seg,col,false);
  m.box(x0+len*0.92,y-r*1.25,zz,len*0.16,r*2.5,r*2.6,col);   // muzzle brake
  tubeX(m,x0+len-.10,y,zz,Math.max(.48,r*.82),r*1.18,r*.56,10,TWR_BORE);
  return m;
}

/* ============================================================================

   DETAIL KIT — the vocabulary that makes a hull look manufactured

   ----------------------------------------------------------------------------

   Reference points are C&C3 Tiberium Wars and Supreme Commander 2: heavy

   faceted armour with visible plate breaks, chamfered edges everywhere, and a

   dense scatter of small functional hardware — vents, hydraulics, sensor

   masts, stowage, tow points, exhaust banks. Neither game relies on texture

   for that read; it is all silhouette and surface break-up, which is exactly

   what survives at command-view zoom.



   Everything below is a compound of primitives so a unit can be assembled from

   twenty-odd recognisable parts instead of six boxes.

   ============================================================================ */

/* Faceted armour hull: an N-sided tapered shell rather than a box. Two stacked

   extrusions with the upper one inset give the plate break that reads as

   layered armour from above. */
function hullShell(m,len,wid,hLow,hHigh,col,colTop,taperNose,taperTail){
  const tn=taperNose===undefined?0.42:taperNose, tt=taperTail===undefined?0.62:taperTail;
  const L=len*0.5, W=wid*0.5;
  const prof=[
    [-L,        -W*tt],
    [-L*0.55,   -W],
    [ L*0.42,   -W],
    [ L,        -W*tn],
    [ L,         W*tn],
    [ L*0.42,    W],
    [-L*0.55,    W],
    [-L,         W*tt],
  ];
  m.extrude(0,0,0,prof,hLow,col);
  const k=0.80;
  m.extrude(0,hLow,0,prof.map(p=>[p[0]*k,p[1]*k]),hHigh,colTop||col);
  return m;
}
/* Angled armour plate with a lip — spaced armour, skirts, glacis add-ons. */
function armorPlate(m,x,y,z,w,h,thick,tilt,col,yaw){
  const c=Math.cos(yaw||0), s=Math.sin(yaw||0);
  m.box(x,y,z,w,h,thick,col,yaw||0);
  m.box(x - Math.sin(yaw||0)*0, y+h, z, w*0.96, thick*0.7, thick*1.9, col, yaw||0);
  for(const o of [-0.34,0.34]){                    // bolt strip down the plate
    const ox=w*o;
    m.box(x+ox*c, y+h*0.5, z+ox*s, thick*0.9, h*0.7, thick*0.9, col, yaw||0);
  }
  return m;
}
/* Hydraulic ram: a pair of polished pistons in a housing. Legs, elevation

   gear, suspension arms — anything that should look like it moves. */
function hydraulic(m,x,y,z,len,r,col,yaw){
  const c=Math.cos(yaw||0), s=Math.sin(yaw||0);
  m.cyl(x,y,z,r,r*0.95,len*0.6,8,col);
  m.cyl(x,y+len*0.6,z,r*0.55,r*0.55,len*0.45,8,MET_L);   // bright ram
  m.cyl(x,y+len*0.55,z,r*1.18,r*1.18,len*0.10,8,DARKER); // gland nut
  return m;
}
/* Louvred vent bank — engine decks, radiator faces, intake grilles. */
function ventBank(m,x,y,z,w,d,n,col,yaw){
  const c=Math.cos(yaw||0), s=Math.sin(yaw||0);
  m.inset(x,y,z,w,d,0.36,0.10,DARKER,yaw||0);
  for(let k=0;k<n;k++){
    const t=(k+0.5)/n-0.5, oz=t*d;
    m.box(x - oz*s, y+0.22, z + oz*c, w*0.92, 0.28, d/n*0.45, col, yaw||0);
  }
  return m;
}
/* Sensor mast: pole, dish and a blade antenna. The single most effective way

   to break a flat roofline and make a vehicle look crewed. */
function sensorMast(m,x,y,z,h,col){
  m.cyl(x,y,z,0.20,0.14,h,6,DARKER);
  m.cyl(x,y+h,z,0.9,0.22,0.18,9,col);              // small dish
  m.box(x,y+h*0.55,z,0.10,h*0.42,0.5,MET_L);       // blade antenna
  /* HQ_LAMP is TWR_GLOW, so landmark glowOk keeps the point. LAMP here

     was a leftover orange cube that failed the gate on HQ and bloomed

     on every factory/defense mast. */
  m.cyl(x,y+h+0.22,z,.16,.16,.18,8,HQ_LAMP);
  return m;
}
/* Exhaust bank: stacks with hollow bores and a heat shroud. */
function exhaust(m,x,y,z,n,r,h,col,spread){
  for(let k=0;k<n;k++){
    const oz=(k-(n-1)/2)*(spread||r*2.6);
    m.cyl(x,y,z+oz,r*1.25,r*1.15,h*0.35,8,DARKER);  // shroud
    m.cyl(x,y+h*0.3,z+oz,r,r*0.92,h*0.7,8,col);
    m.tube(x,y+h*0.98,z+oz,r*0.92,r*0.5,h*0.16,8,DARKER);
  }
  return m;
}
/* Stowage: tarps, crates and spare track links strapped to a hull. Clutter is

   what stops a large flat panel reading as an untextured slab. */
function stowage(m,x,y,z,len,wid,col,yaw,seed){
  let sd=seed||7;
  const rr2=()=>{ sd=(sd*1664525+1013904223)&0x7fffffff; return (sd>>>10)/2097152; };
  const c=Math.cos(yaw||0), s=Math.sin(yaw||0);
  for(let k=0;k<4;k++){
    const t=(k+0.5)/4-0.5, px=t*len, pz=(rr2()-0.5)*wid*0.6;
    const bw=len/4*(0.55+rr2()*0.35), bh=0.5+rr2()*0.7, bd=wid*(0.3+rr2()*0.3);
    m.bevelBox(x+px*c-pz*s, y, z+px*s+pz*c, bw,bh,bd, Math.min(bw,bd)*0.22, col, yaw||0);
  }
  return m;
}
/* Ammunition / equipment box with a lid lip and latches. */
function kitBox(m,x,y,z,w,h,d,col,yaw){
  m.bevelBox(x,y,z,w,h,d,Math.min(w,d)*0.14,col,yaw||0);
  m.box(x,y+h,z,w*1.04,h*0.14,d*1.04,DARKER,yaw||0);
  for(const o of [-0.3,0.3]) m.box(x+w*o*Math.cos(yaw||0),y+h*0.55,z+w*o*Math.sin(yaw||0),
                                   w*0.08,h*0.5,d*1.06,MET_L,yaw||0);
  return m;
}
/* SupCom-style emissive strip: a thin glowing line along a hull edge. */
/* ---------------------------------------------------------------------------

   ROOF EDGE / PARAPET

   A roof that ends in a bare chamfer has nothing for the light to catch, so

   from overhead the building's outline dissolves into the ground. A raised lip

   with a darker reveal under it gives every roof a hard bright edge and a line

   of shade beneath — the single cheapest piece of architectural detail there

   is, and the one the eye uses to read a top-down building's extent.

   --------------------------------------------------------------------------- */
function roofEdge(m,x,y,z,w,d,lip,col,trim){
  const hw=w/2, hd=d/2, th=lip||1.6;
  for(const s of [-1,1]){
    m.box(x,y,z+s*(hd-th*0.5), w, th*1.5, th, col);            // side parapets
    m.box(x,y+th*1.5,z+s*(hd-th*0.5), w*0.995, th*0.36, th*1.25, trim||col);
    m.box(x+s*(hw-th*0.5),y,z, th, th*1.5, d-th*2, col);       // end parapets
    m.box(x+s*(hw-th*0.5),y+th*1.5,z, th*1.25, th*0.36, d-th*2, trim||col);
  }
}
function glowStrip(m,x,y,z,len,col,yaw){
  m.box(x,y,z,len,0.22,0.34,col||ENERGY,yaw||0);
  return m;
}
/* ---------------------------------------------------------------------------

   DECK CROWN — roofEdge, but for vehicles.

   roofEdge above exists because "from overhead the building's outline dissolves

   into the ground". That is just as true of a tank, and nothing was doing it:

   this camera looks almost straight down, so a hull's DECK is the surface a

   player actually identifies a unit by, and an extrude cap gives it nothing to

   catch light on. The raised rail draws a hard outline against terrain, the

   nose chevrons state facing without needing a turret, and the rear kick plate

   stops the back edge melting into the tracks. Trim is team colour and it lands

   in the SAME PLACE on every chassis — that consistency is the other half of

   the read, and it is why this is a shared helper and not per-model geometry.

   --------------------------------------------------------------------------- */
function deckCrown(m,x,y,z,len,wid,col,trim){
  const L=len*0.5, W=wid*0.5, th=Math.min(len,wid)*0.09;
  for(const sd of [-1,1]){
    m.box(x,y,z+sd*(W-th*0.5),len*0.94,th*0.85,th,col||MET_D);              // deck rail
    m.box(x,y+th*0.85,z+sd*(W-th*0.5),len*0.90,th*0.30,th*0.8,trim||MET_L); // bright reveal
    m.box(x+L*0.44,y+th*0.2,z+sd*W*0.46,len*0.32,th*0.45,th*1.3,trim||MET_L,sd*0.44); // nose chevron
  }
  m.box(x-L*0.88,y,z,th,th*0.85,wid*0.88,col||MET_D);                       // rear kick plate
  return m;
}
/* ============================================================================

   HARD-SURFACE COMPONENT KIT

   The roster's tell was never polygon count — it was that everything was built

   from PRIMARY shapes: a box is a box, a cylinder is a cylinder, and the eye

   reads that as a logo, not a machine. Real hardware is components: a wheel is

   tire + rim + spokes + hub; a thruster is bell + throat + glow + gimbal; a

   window is frame + mullions + glass. Each helper below builds the COMPONENT,

   with the chamfers and material breaks already in it, so a model assembled

   from these starts at "machine" instead of earning it one box at a time.

   ============================================================================ */

/* Chamfered cylinder — the single most-used hard-surface move. A straight

   cylinder has a razor rim that catches no light; a 45-degree chamfer ring at

   each end gives every drum, hub and housing a lit edge. */
function chamferCyl(m,x,y,z,r,h,seg,col,colRim,yaw){
  const rim=Math.min(h*0.22,r*0.30);
  m.cyl(x,y,z,r-rim,r,rim,seg,colRim||MET_L,yaw);
  m.cyl(x,y+rim,z,r,r,h-rim*2,seg,col,yaw);
  m.cyl(x,y+h-rim,z,r,r-rim,rim,seg,colRim||MET_L,yaw);
  return m;
}

/* A real wheel: treaded tire, rim dish, spokes, hub cap. Axis is Z (side

   mount) — the only orientation ground vehicles use. */
function wheelAsm(m,x,y,z,r,w,col){
  const sd=z>=0?1:-1;
  m.cyl(x,y,z,r,r,w,12,TREAD,Math.PI/2);
  /* tread lugs around the face — reads even at 20px */
  for(let k=0;k<8;k++){
    const a=k/8*TAU;
    m.box(x+Math.cos(a)*r*0.98,y+Math.sin(a)*r*0.98,z,w*0.9,r*0.22,r*0.20,DARKER,a);
  }
  m.cyl(x,y,z+sd*w*0.5,r*0.62,r*0.62,w*0.14,10,col||MET_L,Math.PI/2);   // rim dish
  for(let k=0;k<5;k++){
    const a=k/5*TAU;
    m.box(x+Math.cos(a)*r*0.34,y+Math.sin(a)*r*0.34,z+sd*w*0.56,r*0.5,r*0.16,w*0.10,MET_D,a);
  }
  m.cyl(x,y,z+sd*w*0.60,r*0.22,r*0.18,w*0.16,8,MET_D,Math.PI/2);        // hub cap
  return m;
}

/* Thruster: gimbal collar, bell that WIDENS toward the exit, recessed throat,

   and a glow disc set inside the bell so the emissive reads as heat coming

   from within, not paint on the back face. Points -X (exhaust rearward). */
function thrusterBell(m,x,y,z,r,len,col){
  m.cyl(x,y,z,r*0.74,r*0.62,len*0.30,10,MET_D,Math.PI/2);               // gimbal collar
  m.cyl(x-len*0.30,y,z,r*0.62,r,len*0.70,12,col||MET_L,Math.PI/2);      // bell (flares out)
  m.tube(x-len,y,z,r*0.98,r*0.80,len*0.14,12,DARKER,Math.PI/2);         // rim ring
  m.cyl(x-len*0.86,y,z,r*0.72,r*0.72,len*0.10,10,HOT,Math.PI/2);        // glow, recessed
  return m;
}

/* Cockpit glazing: raised frame, glass panes, and mullions crossing them.

   Glass with no frame reads as a blue sticker; the frame is what sells it. */
function canopyGlass(m,x,y,z,len,wid,hgt,col){
  m.bevelBox(x,y,z,len,hgt*0.35,wid,0.24,col||MET_L);                    // sill
  m.bevelBox(x,y+hgt*0.30,z,len*0.92,hgt*0.70,wid*0.88,0.30,GLASS);      // panes
  m.box(x,y+hgt*0.32,z,len*0.94,hgt*0.66,wid*0.10,col||MET_L);           // centre mullion
  m.box(x,y+hgt*0.32,z,len*0.10,hgt*0.66,wid*0.90,col||MET_L);           // cross mullion
  m.wedge(x+len*0.55,y+hgt*0.9,z,len*0.35,hgt*0.25,wid*0.9,col||MET_L,0,true); // brow
  return m;
}

/* Recessed panel with a lip — the inner-extrusion move as a one-liner, for

   flat faces that need a fabricated break without restructuring the hull. */
function insetPanel(m,x,y,z,len,wid,depth,col,yaw){
  m.box(x,y,z,len,depth,wid,DARKER,yaw);
  m.box(x,y+depth*0.55,z,len*0.86,depth*0.55,wid*0.86,col||MET_D,yaw);
  return m;
}

/* Road wheels with return rollers and a drive sprocket — a proper running

   gear instead of a plain slab, visible along the whole flank.



   WEIGHT CLASS, NOT JUST SIZE. Every ground vehicle from a size-16 Lancer to a

   size-26 Basilisk used the same proportions and the same wheel count, so a

   light and a heavy were the identical machine viewed at two zoom levels — and

   with nothing on screen to measure against, the player had no way to tell

   which one was the expensive one. `cls` (0 light / 1 medium / 2 heavy) widens

   the tracks, adds or removes a road wheel, and gives a heavy a second skirt

   tier, so weight reads at a glance from the running gear alone. Defaults to

   medium, which is what every existing caller was already getting. */
function runningGear(m,len,wid,h,gauge,wheels,col,cls){
  const K=cls==null?1:cls;
  wid*=[0.82,1.0,1.26][K]; wheels=(wheels||5)+[-1,0,1][K];
  for(const s of [-1,1]){
    m.box(0,0,s*gauge,len,h*0.86,wid,TREAD);
    m.box(0,h*0.30,s*gauge,len*1.04,h*0.30,wid*1.20,DARKER);      // track links
    const n=wheels||5;
    for(let k=0;k<n;k++){
      const x=-len/2+len*(k+0.5)/n;
      m.cyl(x,h*0.46,s*gauge,h*0.40,h*0.40,wid*0.52,8,RUBBER);
      m.cyl(x,h*0.46,s*(gauge+wid*0.30),h*0.17,h*0.17,wid*0.12,7,MET_L);   // hub
      hydraulic(m,x,h*0.86,s*gauge*0.72,h*0.7,0.20,col||MET_D,0);          // suspension arm
    }
    m.cyl( len*0.52,h*0.72,s*gauge,h*0.34,h*0.34,wid*0.55,9,MET_D);        // drive sprocket
    m.cyl(-len*0.52,h*0.72,s*gauge,h*0.30,h*0.30,wid*0.55,9,MET_D);        // idler
    for(let k=0;k<3;k++)                                                    // return rollers
      m.cyl(-len*0.3+k*len*0.3,h*1.02,s*gauge,h*0.14,h*0.14,wid*0.42,7,MET_D);
    if(K===2) armorPlate(m,0,h*1.3,s*(gauge+wid*0.5),len*0.94,h*0.8,0.42,0,col||MET_D,0);
  }
  return m;
}
/* ---------------------------------------------------------------------------

   LEAN TRACK UNIT — the same read as runningGear(), for a quarter of the cost.



   Measured, not guessed: runningGear() builds 1,136 / 1,680 / 2,320 triangles

   for light / medium / heavy, and on a medium 840 of those are the per-wheel

   hydraulic() suspension arms — three 8-segment cylinders each, hidden BEHIND

   the track skirt where this camera never looks. A tier-1 unit's entire budget

   is 1,400. That arithmetic is the real reason every tracked vehicle in the

   roster ended up as a flat slab with a stick on it: there was nothing left to

   spend on the part of the silhouette the player actually sees.



   Same components, 6-segment wheels and flat arms: track run, links, road

   wheels with hub faces, drive sprocket, idler, return run, and a chamfered

   armour skirt. The livery stripe rides the TOP EDGE of that skirt, because

   that edge is the one piece of running gear an overhead camera sees and the

   deck is where a turret sits.



   `cls` matches runningGear's contract (0 light / 1 medium / 2 heavy) so the

   two are interchangeable at a call site.

   --------------------------------------------------------------------------- */
function trackUnit(m,len,wid,h,gauge,wheels,col,cls,trim){
  const K=cls==null?1:cls;
  wid*=[0.84,1.0,1.24][K];
  const n=Math.max(3,(wheels||5)+[-1,0,1][K]), C=col||MET_D;
  for(const s of [-1,1]){
    const z=s*gauge;
    /* The run is the TOP and BOTTOM straps of the track, not a solid slab, so

       the road wheels show through the gap between them — the single detail

       that separates a track from a black rubber band at any zoom. */
    m.box(0,0,z,len,h*0.20,wid,TREAD);                             // ground run
    m.box(0,h*0.66,z,len*0.98,h*0.18,wid,TREAD);                   // return run
    m.box(0,h*0.70,z,len*1.02,h*0.12,wid*1.16,DARKER);             // links, proud of it
    for(let k=0;k<n;k++){
      const x=-len/2+len*(k+0.5)/n;
      m.cyl(x,h*0.14,z,h*0.30,h*0.30,wid*0.56,6,RUBBER);           // road wheel
      m.box(x,h*0.30,z+s*wid*0.60,h*0.26,h*0.24,wid*0.14,MET_L);   // hub face, outboard
    }
    m.cyl( len*0.50,h*0.30,z,h*0.40,h*0.40,wid*0.58,6,MET_D);      // drive sprocket
    m.cyl(-len*0.50,h*0.30,z,h*0.36,h*0.36,wid*0.58,6,MET_D);      // idler
    /* SKIRT. A chamfered plate spanning the upper run is what reads as armour

       rather than as machinery, and its top edge is the only part of any

       running gear an overhead camera sees — so the livery stripe lands there

       and not on the deck, where a turret sits on top of it. */
    m.bevelBox(0,h*0.86,z+s*wid*0.12,len*0.94,h*0.56,wid*0.86,h*0.16,C);
    /* Two blocks, not a racing stripe down the whole skirt: livery has to be

       readable AND deliberate, and a continuous band along both tracks is most

       of the visible surface of the vehicle. */
    for(const f of [-1,1])
      m.box(f*len*0.28,h*1.42,z+s*wid*0.30,len*0.26,h*0.13,wid*0.26,trim||TEAM_A);
    if(K===2) m.box(0,h*0.24,z+s*wid*0.62,len*0.88,h*0.40,wid*0.12,C);  // heavy side plate
  }
  return m;
}
/* ---------------------------------------------------------------------------

   GLACIS — a sloped nose plate that actually slopes forward.



   MeshBuilder.wedge() ramps across its THIRD axis, so a wedge dropped in at

   yaw 0 slopes SIDEWAYS. Every "glacis" authored in this library before this

   helper is therefore a lateral A-frame on a hull whose armour was meant to

   rake front-to-back, and it never got caught because a sloped shape still

   looks sloped in a screenshot — you have to look at the SIDE elevation to see

   that the nose is square. Yawing a quarter turn puts the ridge at the rear

   and runs the slope down to the nose, which is what a glacis is.

   Arguments are in vehicle axes: len along +X, wid across Z.

   --------------------------------------------------------------------------- */
function glacisX(m,x,y,z,len,hgt,wid,col){
  m.wedge(x,y,z,wid,hgt,len,col,Math.PI/2);
  return m;
}
/* Layered turret: faceted body, mantlet, chamfered roof, bustle and hatch. */
function turretBody(m,len,wid,h,col,colTop){
  const L=len*0.5, W=wid*0.5;
  const prof=[[-L,-W*0.86],[-L*0.5,-W],[L*0.5,-W*0.9],[L,-W*0.44],
              [L,W*0.44],[L*0.5,W*0.9],[-L*0.5,W],[-L,W*0.86]];
  m.extrude(0,0,0,prof,h*0.72,col);
  m.extrude(0,h*0.72,0,prof.map(p=>[p[0]*0.82,p[1]*0.80]),h*0.28,colTop||col);
  m.box(L*0.86,h*0.30,0,len*0.16,h*0.62,wid*0.52,MET_D);        // mantlet
  return m;
}

/* ---------------------------------------------------------------------------

   UNITS — indexed to match TYPES[]. Each entry returns {hull, turret?}.

   Authored at roughly 10 world units per "size 10" so a unit's `size` field

   scales it directly.

   --------------------------------------------------------------------------- */
const UNIT_MESH=[];        // [type] = {hull:InstMesh, tur:InstMesh|null, s:scale}
const UNIT_GEO=[];

/* ============================================================================

   INFANTRY — soldiers that look like soldiers.

   The production tab says INFANTRY and the models were tiny mechs, which is a

   promise broken twice: the player expects a trooper, and the battlefield

   loses its scale reference — a tank only reads as big when a HUMAN stands

   next to it. One shared builder, varied per kit, so every infantry unit is

   the same species: helmet with a glass visor, armoured torso over a narrower

   waist, pauldrons carrying the livery, a backpack, and a weapon held ACROSS

   the body — the classic soldier read at any pixel size.

   Legs are SERVO deliberately: the walk shader swings SERVO geometry below hip

   height, so these troopers march with the same system that walks the mechs.

   Arms and weapon stay rigid so the gun does not wobble. */
function mfTrooper(m,o){
  o=o||{};
  const H=o.h||8.6, W=o.w||1.0;                 // height, bulk factor
  const hip=H*0.46, sh=H*0.74, hd=H*0.86;
  /* legs — boot, shin, thigh, with a knee step between them */
  for(const sd of [-1,1]){
    m.bevelBox(0.25,0,sd*0.62*W,1.5*W,0.55,0.95*W,0.20,DARK);           // boot
    m.bevelBox(0.05,0.55,sd*0.62*W,0.80*W,hip*0.42,0.80*W,0.18,SERVO);  // shin
    m.cyl(0.05,hip*0.50,sd*0.62*W,0.46*W,0.46*W,0.5,7,MET_D,Math.PI/2); // knee
    m.bevelBox(0.0,hip*0.55,sd*0.62*W,0.92*W,hip*0.48,0.92*W,0.20,SERVO); // thigh
    m.bevelBox(0.0,hip*1.02,sd*0.62*W,1.0*W,0.5,1.0*W,0.16,MET_D);      // hip guard
  }
  /* torso — armour OVER a waist, so there is a silhouette pinch */
  m.bevelBox(0,hip,0,1.3*W,(sh-hip)*0.36,1.5*W,0.22,DARK);              // waist
  m.bevelBox(0.1,hip+(sh-hip)*0.30,0,1.9*W,(sh-hip)*0.74,2.1*W,0.30,o.chest||MET); // chest plate
  /* RAKED GLACIS over the chest — the armour angle is what stops the torso

     reading as a box. Sharp edge running downward, like a breastplate. */
  m.wedge(0.95*W,hip+(sh-hip)*0.36,0,0.8*W,(sh-hip)*0.52,1.9*W,o.chest||MET_L);
  insetPanel(m,0.95*W,hip+(sh-hip)*0.62,0,0.9*W,1.1*W,0.16,o.chest||MET_D,0);      // chest vent
  m.bevelBox(-0.55*W,hip+(sh-hip)*0.5,0,1.0*W,(sh-hip)*0.62,1.9*W,0.24,o.pack||MET_D); // backpack
  /* pauldrons — the livery lands here, at the widest point */
  for(const sd of [-1,1]){
    m.bevelBox(0,sh-0.25,sd*1.25*W,1.35*W,0.62,0.95*W,0.30,TEAM_A);
    m.wedge(0,sh+0.30,sd*1.25*W,1.30*W,0.42,0.92*W,TEAM_A,0,sd<0);       // angled pauldron cap
    m.bevelBox(0.15,sh-1.15,sd*1.30*W,0.72*W,1.1,0.62*W,0.20,SERVO);    // upper arm
    m.bevelBox(0.85*W,sh-1.55,sd*1.05*W,1.3*W,0.60,0.55*W,0.18,DARK);   // forearm, reaching to the gun
  }
  /* head — helmet dome with a GLASS visor slot and a brow ridge */
  m.bevelBox(0.1,sh+0.15,0,1.15*W,(hd-sh)*0.9,1.25*W,0.34,o.helm||MET_L);
  m.box(0.62*W,sh+0.42,0,0.34,0.42,0.95*W,GLASS);                        // visor
  m.box(0.55*W,sh+0.85,0,0.5,0.18,1.1*W,MET_D);                          // brow
  if(o.antenna){ m.cyl(-0.35*W,hd,0.5*W,0.05,0.03,0.9,5,DARKER); }
  return {hip,sh,hd};
}
function mdlStriker(){                       // 0 — line rifleman
  const m=MB();
  const b=mfTrooper(m,{h:8.6,w:1.0,antenna:1});
  /* rifle held across the chest: receiver, barrel with muzzle, magazine,

     stock — pointed +X so the unit faces where it shoots */
  const gy=b.hip+1.6;
  m.bevelBox(1.35,gy,0.15,2.6,0.55,0.45,0.14,MET_D);                     // receiver
  m.cyl(2.7,gy+0.12,0.15,0.14,0.12,1.7,6,DARKER,Math.PI/2);              // barrel
  m.tube(4.4,gy+0.12,0.15,0.20,0.10,0.28,6,MET_L,Math.PI/2);             // muzzle
  m.box(1.6,gy-0.55,0.15,0.4,0.6,0.35,MET_D);                            // magazine
  m.box(0.3,gy+0.05,0.15,0.7,0.4,0.35,DARK);                             // stock
  glowStrip(m,-0.55,b.sh+0.4,0,0.8,ENERGY,0);                            // pack light
  return {hull:m.build(),tur:null,s:0.92};
}
function mdlRhino(){                         // 1 — medium battle tank
  const m=MB();
  runningGear(m,13,3.2,2.8,3.5,5,MET_D);
  /* Faceted hull with a distinct upper plate break, then hardware bolted all

     over it: skirts, stowage, vents, a mast. The plate break plus the clutter

     is what stops an overhead view reading it as a rounded rectangle. */
  hullShell(m,12.4,7.4,2.2,1.5,MET,TEAM_A);
  m.wedge(4.4,3.7,0,3.4,1.5,6.4,MET_L);                   // glacis
  for(const sd of [-1,1]){
    armorPlate(m,0.6,2.2,sd*4.1,9.6,1.9,0.42,0,MET_D,0);  // spaced side skirts
    m.box(-4.9,3.9,sd*2.0,2.0,0.5,1.0,TEAM_A);            // livery flash
  }
  ventBank(m,-4.3,3.72,0,3.6,4.6,5,MET_D,0);              // engine deck louvres
  exhaust(m,-5.9,3.0,0,2,0.42,2.0,MET_D,1.9);
  stowage(m,-1.4,3.72,3.0,5.0,1.6,RUST,0,3);
  kitBox(m,-3.0,3.72,-2.5,2.2,0.9,1.5,MET_D,0);
  sensorMast(m,-5.2,3.9,1.6,2.6,MET_L);
  m.box(4.9,3.5,-2.4,1.0,0.7,1.0,GLASS);                  // driver's vision block
  glowStrip(m,0.5,3.76,0,7.0,ENERGY,0);

  const t=MB();
  turretBody(t,7.2,6.0,2.9,MET,TEAM_T);
  for(const sd of [-1,1]){
    m.tm=0;
    t.box(-0.4,1.1,sd*3.0,4.6,1.5,0.42,TEAM_A);           // cheek livery
    t.box(-2.2,2.1,sd*2.1,1.5,0.9,0.9,DARKER);            // smoke launchers
    t.cyl(-2.2,3.0,sd*2.1,0.26,0.24,0.9,6,DARKER);
  }
  gunX(t,2.6,1.5,7.6,0.52,MET_D);
  t.cyl(4.6,1.5,0,0.72,0.66,1.2,9,MET_D);                 // fume extractor
  t.tube(10.0,1.5,0,0.54,0.30,0.8,8,DARKER);              // bore
  t.cyl(0.2,2.9,-1.5,0.95,0.86,0.8,9,MET_D);              // cupola
  t.tube(0.2,3.7,-1.5,0.95,0.62,0.30,9,MET_L);
  t.box(1.1,3.4,-1.5,1.9,0.34,0.34,DARK);                 // pintle MG
  kitBox(t,-3.3,1.0,0,1.5,1.9,3.2,MET_D,0);               // bustle rack
  stowage(t,-3.3,2.9,0,2.6,2.6,RUST,0,9);
  sensorMast(t,-1.2,3.2,1.9,1.9,MET_L);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:5.2,muzzle:10.2};
}
function mdlGoliath(){                       // 2 — heavy assault tank
  const m=MB();
  runningGear(m,17,4.4,3.6,4.7,6,MET_D,2);
  hullShell(m,16.4,9.8,2.8,1.9,MET,TEAM_A);
  m.wedge(5.8,4.7,0,4.4,1.9,8.6,MET_L);                   // heavy glacis
  armorPlate(m,6.0,4.7,0,3.0,1.5,0.5,0,MET_D,0);          // applique brow
  for(const sd of [-1,1]){
    armorPlate(m,0.8,2.8,sd*5.4,13.0,2.4,0.5,0,MET_D,0);  // full-length skirts
    m.bevelBox(3.4,4.9,sd*4.4,4.6,1.5,2.0,0.3,MET_D);     // sponson blisters
    m.box(-6.4,5.1,sd*2.6,2.6,0.6,1.2,TEAM_A);
    m.cyl(6.6,4.9,sd*3.6,0.30,0.26,1.1,6,MET_L);          // tow points
  }
  ventBank(m,-5.6,4.72,0,4.6,6.4,7,MET_D,0);
  exhaust(m,-7.6,3.6,0,3,0.50,2.6,MET_D,2.4);
  stowage(m,-2.0,4.72,4.0,6.4,2.0,RUST,0,17);
  kitBox(m,-4.2,4.72,-3.4,2.8,1.1,2.0,MET_D,0);
  sensorMast(m,-6.6,5.1,2.4,3.2,MET_L);
  glowStrip(m,0.5,4.78,0,9.5,ENERGY,0);

  const t=MB();
  turretBody(t,9.6,8.0,3.9,MET,TEAM_T);
  for(const sd of [-1,1]){
    t.box(-0.4,1.5,sd*4.0,6.6,2.0,0.5,TEAM_A);
    t.box(-3.0,2.9,sd*2.9,2.0,1.1,1.1,DARKER);
    for(let k=0;k<3;k++) t.cyl(-3.0+k*0.7,4.0,sd*2.9,0.24,0.22,1.0,6,DARKER);
    armorPlate(t,1.6,0.2,sd*4.1,5.0,2.6,0.42,0,MET_D,0);
  }
  gunX(t,3.6,2.0,10.8,0.70,MET_D);
  t.cyl(6.2,2.0,0,0.95,0.88,1.6,9,MET_D);
  t.tube(14.3,2.0,0,0.72,0.40,1.0,8,DARKER);
  t.cyl(0.6,3.9,-2.4,1.15,1.05,0.9,9,MET_D);
  t.tube(0.6,4.8,-2.4,1.15,0.74,0.34,9,MET_L);
  t.box(1.8,4.5,-2.4,2.4,0.4,0.4,DARK);
  kitBox(t,-4.4,1.2,0,1.9,2.4,4.4,MET_D,0);
  stowage(t,-4.4,3.6,0,3.4,3.6,RUST,0,21);
  sensorMast(t,-1.8,4.3,2.6,2.3,MET_L);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:6.3,muzzle:14.4};
}
function mdlThumper(){                       // 3 — self-propelled artillery
  const m=MB();
  runningGear(m,13,3.4,3.0,3.7,5,MET_D);
  hullShell(m,12.4,7.6,2.0,1.3,MET,TEAM_A);
  ventBank(m,-3.6,3.32,0,3.4,5.2,5,MET_D,0);
  exhaust(m,-5.4,2.6,0,2,0.40,1.8,MET_D,2.0);
  for(const sd of [-1,1]){
    /* Deployed recoil spades are the artillery tell in plan view. */
    m.box(-5.8,1.4,sd*4.0,2.2,2.8,0.9,MET_D);
    hydraulic(m,-5.0,2.6,sd*3.6,2.2,0.28,MET_D,0);
    m.box(0.4,3.36,sd*3.6,7.0,0.5,0.7,TEAM_A);
    kitBox(m,2.6,3.32,sd*2.6,2.4,1.0,1.4,MET_D,0);        // shell lockers
  }
  sensorMast(m,-4.6,3.5,1.8,2.4,MET_L);

  const t=MB();
  turretBody(t,5.6,5.8,2.6,MET,TEAM_T);
  gunX(t,1.6,2.2,14.5,0.60,MET_D);                        // very long tube
  t.cyl(4.2,2.2,0,1.05,0.95,2.6,9,MET_D);                 // recuperator
  t.cyl(7.0,2.2,0,0.80,0.74,1.4,9,MET_D);
  t.tube(16.4,2.2,0,0.62,0.34,1.0,8,DARKER);
  for(const sd of [-1,1]){
    t.cyl(1.4,1.1,sd*1.8,1.4,1.3,0.9,9,DARK);             // trunnions
    hydraulic(t,-1.4,1.1,sd*2.0,2.6,0.32,MET_D,0);        // elevation rams
    t.box(-0.6,2.7,sd*2.7,4.2,0.5,0.5,TEAM_A);
  }
  kitBox(t,-2.8,1.2,0,1.7,1.6,3.6,MET_D,0);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:5.4,muzzle:16.1};
}
function mdlCommander(){                     // 4 — hero mech
  const m=MB();
  /* SupCom-style bot proportions: broad pauldrons, deep chest, chunky

     digitigrade legs with visible hydraulics, and glowing power conduits. */
  for(const sd of [-1,1]){
    m.bevelBox(-1.0,0,sd*3.6,5.6,1.8,3.2,0.5,SERVO);      // foot
    m.box(-1.0,1.8,sd*3.6,4.0,0.6,2.6,SERVO);
    m.extrude(-0.4,2.4,sd*3.6,[[-1.6,-1.7],[1.6,-1.7],[2.0,0],[1.6,1.7],[-1.6,1.7],[-2.0,0]],4.8,SERVO);
    hydraulic(m,-1.6,2.4,sd*3.6,4.4,0.42,SERVO,0);        // shin ram
    m.bevelBox(0.2,7.2,sd*3.6,4.0,2.4,4.0,0.6,SERVO);     // knee block
    hydraulic(m,-1.4,9.6,sd*3.6,3.0,0.36,SERVO,0);
    m.box(0.2,9.6,sd*3.6,3.4,2.6,3.4,SERVO);              // thigh
  }
  m.extrude(0,12.2,0,[[-4.2,-4.6],[2.6,-5.0],[4.6,-2.4],[4.6,2.4],[2.6,5.0],[-4.2,4.6]],5.4,MET);
  m.extrude(0,17.6,0,[[-3.4,-3.8],[2.2,-4.2],[3.8,-2.0],[3.8,2.0],[2.2,4.2],[-3.4,3.8]],2.2,TEAM_A);
  m.wedge(3.2,19.8,0,4.0,2.4,7.6,TEAM_T);                 // chest plate
  glowStrip(m,1.0,19.9,0,6.0,ENERGY,0);
  for(const sd of [-1,1]){
    m.bevelBox(0.4,17.0,sd*6.4,4.4,3.6,3.6,0.7,TEAM_A);   // pauldron
    armorPlate(m,0.4,20.6,sd*6.4,4.0,1.4,0.5,0,MET_D,0);
    m.box(0.0,13.6,sd*6.6,3.0,4.0,3.0,MET_D);             // upper arm
    hydraulic(m,-1.2,13.6,sd*6.6,3.4,0.34,MET_L,0);
    gunX(m,1.6,13.6,6.6,0.62,DARK,sd*6.6);                // arm cannon
    tubeX(m,8.4,13.6,sd*6.6,0.8,0.58,0.32,8,DARKER);      // lateral muzzle collar
    m.cyl(-2.6,19.4,sd*2.6,0.66,0.50,3.4,8,MET_D);        // back vents
    m.tube(-2.6,22.8,sd*2.6,0.62,0.36,0.4,8,ENERGY);
  }
  m.bevelBox(-3.6,17.6,0,3.2,3.4,6.4,0.6,DARK);           // backpack
  m.bevelBox(2.2,22.2,0,3.6,2.8,4.4,0.6,TEAM_A);          // head
  m.box(4.0,23.2,0,0.5,1.0,3.0,GLASS);                    // visor
  sensorMast(m,-0.6,25.0,1.4,2.6,MET_L);
  m.box(-1.2,25.0,0,0.9,2.6,0.9,LAMP);                    // command beacon
  /* Nova's commander is the clean-energy flagship, not the generic biped the

     three enemy bios branch from. A suspended command halo and twin capacitor

     towers keep that identity legible even when the weapon is occluded. */
  m.ring(-3.4,23.7,0,2.4,3.4,18,ENERGY);
  for(const sd of [-1,1]){
    m.cyl(-5.0,18.8,sd*3.1,1.05,.82,5.8,10,MET_D);
    m.cyl(-5.0,24.7,sd*3.1,.78,.62,1.0,10,ENERGY);
    m.box(-5.0,22.0,sd*3.1,.45,5.2,1.0,ENERGY);
  }
  return {hull:m.build(),tur:null,s:0.62};
}
function mdlWasp(){                          // 5 — light air
  const m=MB();
  const low=[[-5.0,-1.55],[-3.0,-2.05],[2.5,-2.15],[5.5,-.72],[6.0,0],
             [5.5,.72],[2.5,2.15],[-3.0,2.05],[-5.0,1.55]];
  const mid=[[-4.5,-1.35],[-2.4,-1.72],[2.7,-1.66],[5.0,-.55],[5.4,0],
             [5.0,.55],[2.7,1.66],[-2.4,1.72],[-4.5,1.35]];
  m.extrude(0,0,0,low,1.35,MET_D);                            // armoured keel
  m.extrude(0,1.35,0,mid,1.15,MET);                           // faceted fuselage
  m.extrude(.15,2.50,0,mid.map(p=>[p[0]*.70,p[1]*.63]),.58,TEAM_A);
  canopyGlass(m,2.55,2.88,0,3.5,2.45,1.35,MET_L);             // framed canopy
  m.box(-.65,3.10,0,4.25,.34,1.08,TEAM_T);                    // dorsal identity stripe
  glowStrip(m,-.35,3.47,0,3.05,ENERGY,0);
  ventBank(m,-1.9,3.12,0,1.6,1.30,3,DARK,0);
  /* TWIN THRUSTERS — an aircraft with no visible propulsion reads as a paper

     dart. Bells flare toward the exhaust with the glow recessed inside. */
  for(const sd of [-1,1]) thrusterBell(m,-4.6,1.9,sd*1.05,0.62,1.7,MET_L);
  for(const sd of [-1,1]){
    const wing=sd>0
      ? [[-3.45,1.18],[2.40,1.34],[.85,6.95],[-4.15,6.08]]
      : [[-3.45,-1.18],[-4.15,-6.08],[.85,-6.95],[2.40,-1.34]];
    const panel=sd>0
      ? [[-2.72,1.72],[1.72,1.75],[.72,5.48],[-3.18,5.03]]
      : [[-2.72,-1.72],[-3.18,-5.03],[.72,-5.48],[1.72,-1.75]];
    m.extrude(0,1.02,0,wing,.62,MET_D);                        // one-piece load-bearing wing
    m.extrude(0,1.64,0,panel,.24,TEAM_A);                      // restrained wing livery
    m.box(-1.65,1.02,sd*3.55,4.50,.75,2.25,DARK);              // engine pylon joins wing
    cylX(m,-4.65,1.34,sd*3.75,5.55,1.13,.94,10,DARK,false);   // long nacelle
    ringX(m,-4.69,1.34,sd*3.75,.78,1.18,12,MET_L);
    tubeX(m,-5.12,1.34,sd*3.75,.82,.92,.43,10,TWR_BORE);      // actual hollow exhaust
    ringX(m,-5.15,1.34,sd*3.75,.31,.48,10,HOT);
    ringX(m,.43,1.34,sd*3.75,.67,1.00,10,MET_L);              // intake lip
    m.box(-1.10,1.96,sd*3.75,2.20,.42,1.26,TEAM_T);            // nacelle livery saddle
    ventBank(m,-1.05,2.39,sd*3.75,1.62,.90,3,MET_D,0);
    m.bevelBox(-.30,.48,sd*5.35,2.85,.92,1.28,.24,DARKER);     // attached missile rail
    for(let k=0;k<3;k++)
      cylX(m,-.92+k*.84,.58,sd*5.35,1.25,.24,.18,7,HOT,false);
    m.box(2.20,.54,sd*1.55,2.15,.78,.86,DARK);                 // fixed gun receiver
    gunX(m,2.75,.82,3.15,.27,MET_D,sd*1.55);                  // visible hollow cannon
    m.box(-4.10,2.20,sd*1.45,2.25,1.85,.36,MET_L);            // twin tail fins touch hull
    m.box(-3.65,3.46,sd*.86,1.50,.28,.34,LAMP);               // formation lamps
  }
  m.bevelBox(-4.15,1.58,0,2.35,1.25,3.55,.30,DARKER);         // tail gearbox links fins
  sensorMast(m,-3.85,2.82,0,1.55,MET_L);
  m.greeble(-.40,3.10,0,3.3,1.05,.34,5,MET_D,0,51);
  return {hull:m.build(),tur:null,s:1.0,air:1};
}
function mdlLongbow(){                       // 6 — beam sniper
  const m=MB();
  runningGear(m,12.0,3.0,2.5,3.25,5,MET_D);
  hullShell(m,11.8,7.0,1.9,1.25,MET,TEAM_A,0.34,0.72);
  m.wedge(4.3,3.16,0,3.2,1.15,5.6,MET_L);
  for(const sd of [-1,1]){
    armorPlate(m,0.2,1.9,sd*3.72,8.6,1.6,0.38,0,MET_D,0);
    m.box(-1.0,3.18,sd*3.18,6.2,0.44,0.62,TEAM_A);
    /* Long capacitors keep the sniper role readable when the tracking weapon

       is turned away from the camera. */
    m.cyl(-3.8,3.24,sd*2.15,0.72,0.72,2.3,9,TWR_MACH);
    m.ring(-3.8,5.0,sd*2.15,0.76,0.95,10,TWR_GLOW);
  }
  ventBank(m,-4.1,3.18,0,2.8,3.2,4,MET_D,0);
  exhaust(m,-5.3,2.35,0,2,0.34,1.8,MET_D,1.7);
  sensorMast(m,-4.7,3.28,1.15,2.2,MET_L);
  glowStrip(m,0.0,3.24,0,6.4,ENERGY,0);
  const t=MB();
  turretBody(t,5.6,4.7,2.35,TWR_ARM,TWR_TEAM);
  t.bevelBox(-2.3,0.65,0,2.1,1.5,3.8,0.35,TWR_COAT);
  for(const sd of [-1,1]){
    t.box(-0.3,1.0,sd*2.32,3.8,1.0,0.38,TWR_TEAM);
    hydraulic(t,-1.4,0.15,sd*1.75,1.6,0.23,TWR_MACH,0);
  }
  gunX(t,1.75,1.25,9.7,0.42,TWR_MACH);
  for(const x of [4.4,6.15,7.9]) ringX(t,x,1.25,0,0.60,0.88,12,TWR_GLOW);
  cylX(t,0.7,1.25,0,2.15,0.92,0.72,10,TWR_COAT,false);
  tubeX(t,11.0,1.25,0,0.72,0.60,0.31,10,TWR_BORE);
  t.cyl(-0.9,2.36,-1.15,0.62,0.54,0.50,9,MET_L);
  t.box(-0.9,2.86,-1.15,0.22,0.75,0.22,LAMP);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:4.45};
}
function mdlHornet(){                        // 7 — rocket vehicle
  const m=MB();
  runningGear(m,11.6,3.0,2.55,3.25,5,MET_D);
  hullShell(m,11.4,7.0,1.95,1.25,MET,TEAM_A,0.38,0.70);
  m.wedge(4.1,3.2,0,3.1,1.2,5.5,MET_L);
  ventBank(m,-3.9,3.22,0,2.8,3.8,4,MET_D,0);
  exhaust(m,-5.1,2.4,0,2,0.34,1.8,MET_D,1.7);
  for(const sd of [-1,1]){
    armorPlate(m,0.0,1.95,sd*3.7,8.2,1.6,0.38,0,MET_D,0);
    m.box(0.3,3.24,sd*3.15,6.0,0.45,0.62,TEAM_A);
    kitBox(m,-2.4,3.22,sd*2.35,1.8,0.9,1.25,MET_D,0);
  }
  sensorMast(m,-4.5,3.3,1.1,2.0,MET_L);
  const t=MB();
  t.cyl(-1.5,0,0,2.5,2.15,1.2,12,TWR_PAD);
  t.bevelBox(-0.9,1.2,0,3.2,2.2,5.5,0.45,TWR_COAT);
  for(const sd of [-1,1]){
    t.cyl(-0.7,1.5,sd*2.72,1.05,0.92,0.62,10,TWR_MACH);
    hydraulic(t,-1.8,1.2,sd*2.15,2.0,0.28,TWR_MACH,0);
    t.box(-1.0,3.35,sd*2.72,3.6,0.44,0.40,TWR_TEAM);
  }
  /* Six genuinely open launch tubes replace closed cargo-box silhouettes. */
  for(let row=0;row<2;row++) for(let col=0;col<3;col++){
    const y=2.55+row*1.55, z=-1.9+col*1.9;
    cylX(t,-0.1,y,z,4.45,0.69,0.63,10,TWR_MACH,false);
    ringX(t,4.28,y,z,0.66,0.84,10,TWR_TEAM);
    tubeX(t,4.32,y,z,0.72,0.70,0.39,10,TWR_BORE);
    t.box(-0.45,y+0.73,z,3.7,0.20,0.18,TWR_TRIM);
  }
  t.bevelBox(-2.6,2.0,0,1.5,3.4,4.5,0.32,MET_D);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:4.45};
}
function mdlTitan(){                         // 8 — superheavy walker
  const m=MB();
  for(const sd of [-1,1]){
    /* Every part below the hip uses SERVO. Mixing ordinary armour into a leg

       leaves those plates behind when the vertex-stage gait moves the foot. */
    m.bevelBox(-1.35,0,sd*6.10,9.6,2.15,5.4,.62,SERVO);       // broad planted foot
    m.box(2.95,.42,sd*6.10,2.25,1.25,4.75,SERVO);             // reinforced toe
    m.box(-5.55,.30,sd*6.10,1.25,1.05,4.40,SERVO);            // heel counterweight
    m.cyl(-1.15,2.15,sd*6.10,1.78,1.48,1.05,10,SERVO);       // ankle bearing
    m.extrude(-.55,3.10,sd*6.10,[[-2.45,-2.25],[1.65,-2.25],[2.35,-1.15],
              [2.35,1.15],[1.65,2.25],[-2.45,2.25]],6.20,SERVO);
    m.bevelBox(-.35,4.20,sd*6.10,3.65,3.80,4.95,.48,SERVO);   // shin armour mass
    hydraulic(m,-2.22,3.15,sd*6.10,5.65,.48,SERVO,0);
    hydraulic(m,1.18,3.25,sd*6.10,5.35,.38,SERVO,0);
    m.cyl(.35,9.30,sd*6.10,2.70,2.45,2.25,12,SERVO);         // articulated knee drum
    m.bevelBox(.25,10.15,sd*6.10,6.15,2.65,5.65,.68,SERVO);
    m.extrude(-.15,11.10,sd*6.10,[[-2.20,-2.15],[1.90,-2.15],[2.40,-1.05],
              [2.40,1.05],[1.90,2.15],[-2.20,2.15]],3.95,SERVO);
    m.box(-1.45,11.65,sd*4.35,2.35,3.10,1.35,SERVO);          // inner hip brace, connected
  }
  m.extrude(0,14.35,0,[[-6.7,-7.25],[3.8,-7.8],[7.1,-4.3],[7.1,4.3],
            [3.8,7.8],[-6.7,7.25]],4.45,MET_D);              // pelvis / hip bridge
  m.extrude(.15,18.80,0,[[-6.0,-6.45],[3.6,-6.9],[6.15,-3.7],[6.15,3.7],
            [3.6,6.9],[-6.0,6.45]],2.05,TEAM_A);
  for(const sd of [-1,1]){
    armorPlate(m,.20,18.88,sd*6.30,8.6,1.55,.58,0,MET_L,0);  // hip skirt
    m.cyl(-4.20,16.35,sd*5.15,.62,.54,2.05,8,DARKER);
  }
  m.bevelBox(-4.55,16.35,0,4.65,3.25,10.75,.72,DARKER);      // reactor bridge
  ventBank(m,-4.45,19.76,0,3.30,7.65,6,MET_D,0);

  m.extrude(0,20.85,0,[[-5.9,-6.25],[3.4,-7.15],[6.15,-4.25],[6.15,4.25],
            [3.4,7.15],[-5.9,6.25]],6.30,MET);               // high faceted torso
  m.extrude(.35,27.15,0,[[-4.9,-5.35],[3.0,-5.95],[5.2,-3.35],[5.2,3.35],
            [3.0,5.95],[-4.9,5.35]],2.15,TEAM_A);            // shoulder deck livery
  m.wedge(4.65,23.25,0,4.25,4.15,10.2,TEAM_T,0,true);        // sloped chest glacis
  m.bevelBox(1.35,27.15,0,6.80,1.30,8.65,.42,MET_L);         // collar armour
  glowStrip(m,4.85,27.48,0,5.0,ENERGY,0);
  for(const sd of [-1,1]){
    m.bevelBox(.65,23.05,sd*7.55,6.45,4.35,4.45,.72,MET_D);   // attached shoulder receiver
    m.box(-2.60,23.75,sd*7.55,1.55,2.45,4.05,DARKER);         // ammunition bustle
    m.greeble(-2.60,26.18,sd*7.55,1.20,3.15,.56,4,MET_L,0,sd>0?81:82);
    m.box(3.05,24.28,sd*7.55,3.65,2.20,2.50,DARK);            // trunnion housing
    gunX(m,4.70,25.15,11.25,.82,MET_D,sd*7.55);              // correctly separated cannon
    m.box(.50,27.48,sd*7.55,5.55,.42,3.55,TEAM_A);            // shoulder ownership panel
    m.cyl(-5.10,23.15,sd*4.60,.92,.72,5.35,9,MET_D);         // rear heat exchanger
    m.tube(-5.10,28.42,sd*4.60,.72,.38,.52,9,TWR_BORE);
    m.box(-4.55,21.45,sd*6.00,2.10,4.80,1.10,DARK);           // torso side grille
    for(let k=0;k<4;k++)
      m.box(-4.05,22.00+k*.88,sd*6.58,1.45,.36,.32,MET_L);
  }
  m.bevelBox(-4.80,21.75,0,3.25,5.35,7.30,.65,DARK);          // attached power backpack
  m.greeble(-4.80,27.10,0,2.40,5.20,.70,6,MET_D,0,91);
  m.bevelBox(3.05,29.30,0,5.15,3.65,6.30,.65,MET_L);          // command head
  m.wedge(5.75,30.18,0,1.55,1.70,5.10,GLASS,0,true);          // visor block
  m.box(6.55,30.45,0,.48,1.08,4.35,ENERGY);                   // readable visor strip
  sensorMast(m,-.30,32.15,1.65,2.50,MET_L);
  m.cyl(-1.65,32.20,-1.55,.62,.40,2.85,8,MET_D);
  m.tube(-1.65,34.95,-1.55,.44,.22,.38,8,LAMP);
  kitBox(m,-4.80,20.65,0,2.05,1.28,3.60,MET_D,0);
  return {hull:m.build(),tur:null,s:0.62};
}
function mdlPyro(){                          // 10 — flame trooper
  const m=MB();
  /* Same species as the Striker, bulked out: a flame suit is sealed and

     heavy, so the trooper is wider, the helmet is a full hood, and the

     backpack is the fuel plant — twin tanks with caps and bands, plumbed to

     the projector. The pilot light is the tell at range. */
  const b=mfTrooper(m,{h:8.2,w:1.22,chest:RUST,helm:MET_D,pack:MET_D});
  for(const sd of [-1,1]){                                               // fuel tanks
    m.cyl(-1.15,b.hip+0.4,sd*0.62,0.52,0.52,3.4,8,RUST);
    m.cyl(-1.15,b.hip+3.8,sd*0.62,0.52,0.30,0.5,8,MET_D);                // caps
    m.cyl(-1.15,b.hip+1.9,sd*0.62,0.56,0.56,0.22,8,MET_L);               // bands
  }
  m.cyl(-0.6,b.sh-0.4,0,0.16,0.14,1.9,5,DARKER,Math.PI/2);               // feed hose
  /* projector: short, fat, with a shroud and a pilot flame */
  const gy=b.hip+1.5;
  m.bevelBox(1.5,gy,0.15,2.0,0.7,0.6,0.16,MET_D);
  m.tube(3.1,gy+0.1,0.15,0.34,0.20,0.9,7,MET_L,Math.PI/2);               // shroud
  m.cyl(3.9,gy+0.1,0.15,0.12,0.10,0.5,5,HOT,Math.PI/2);                  // pilot light
  m.box(1.0,gy-0.5,0.15,0.5,0.5,0.4,DARK);                               // grip
  glowStrip(m,3.4,gy+0.45,0.15,0.7,HOT,0);
  return {hull:m.build(),tur:null,s:0.95};
}
function mdlVulture(){                       // 10 — anti-air gun vehicle
  const m=MB();
  runningGear(m,11,2.8,2.6,3.1,4,MET_D);
  hullShell(m,11.0,6.8,2.0,1.2,MET,TEAM_A);
  ventBank(m,-3.2,3.22,0,2.8,4.4,4,MET_D,0);
  exhaust(m,-4.8,2.4,0,2,0.36,1.6,MET_D,1.8);
  for(const sd of [-1,1]) m.box(0.2,3.26,sd*3.2,6.4,0.5,0.6,TEAM_A);
  kitBox(m,3.0,3.22,0,2.2,0.9,3.4,MET_D,0);

  const t=MB();
  t.cyl(0,0,0,2.8,2.4,2.4,12,MET);
  t.extrude(0,2.4,0,[[-2.4,-2.2],[1.4,-2.6],[2.8,-1.2],[2.8,1.2],[1.4,2.6],[-2.4,2.2]],1.0,TEAM_T);
  for(const sd of [-1,1]){
    /* Twin short high-elevation barrels plus a tracking dish: an AA mount has

       to be unmistakable from above or it gets misused as a gun tank. */
    t.box(2.6,2.4,sd*1.4,5.6,1.0,1.0,MET_D);
    t.tube(5.6,2.9,sd*1.4,0.48,0.26,0.8,7,DARKER);
    t.box(0.6,3.6,sd*2.2,2.8,0.42,0.5,TEAM_A);
    hydraulic(t,-0.8,2.4,sd*2.0,1.8,0.26,MET_D,0);
    kitBox(t,-2.0,2.4,sd*2.0,1.5,1.0,1.1,DARKER,0);       // ammo feed boxes
  }
  t.box(-2.9,2.4,0,1.6,2.2,2.6,DARK);
  t.cyl(-2.9,4.6,0,2.9,0.7,0.45,12,MET_L);                // tracking dish
  t.cyl(-2.9,5.05,0,0.30,0.22,1.0,6,DARKER);
  t.box(-2.9,6.05,0,0.28,0.34,0.28,LAMP);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:4.4};
}
function mdlBulwark(){                       // 11 — shield generator vehicle
  const m=MB();
  /* The only vehicle still calling the legacy treads()/hullPlate() pair, so it

     was the only one with no road wheels, no suspension, no hubs and a flat

     unchamfered deck — eight primitives for a 90-mass tier-2 shield platform

     that is meant to look like the toughest thing on the field. */
  runningGear(m,13,3.6,2.8,3.8,5,MET_D,2);
  hullShell(m,13.0,8.4,2.4,1.6,MET,TEAM_A);
  deckCrown(m,0,4.06,0,12.4,8.0,MET_D,TEAM_T);
  m.bevelBox(0,5.8,0,6.2,3.0,7.2,0.5,TEAM_T);               // livery reactor housing
  for(const s of [-1,1]) m.box(0,4.4,s*4.3,11.0,1.6,0.7,TEAM_A);
  for(const s of [-1,1]) for(const f of [-1,1])
    m.cyl(f*2.4,8.8,s*2.4,0.6,0.5,3.4,7,MET_D);             // emitter pylons
  m.sphere(0,10.4,0,3.0,10,ENERGY,0.7,false);               // field core
  m.box(-5.0,5.4,0,2.0,1.4,5.0,DARK);
  return {hull:m.build(),tur:null,s:1.0};
}

/* ============================================================================

   ARTHROPOD KIT — the Brood is grown, and it has to look grown.



   The swarm was three spheres and six boxes. Read from the game's near-top-down

   camera that is a green blob with twigs, and no amount of colour work fixes a

   silhouette that has no anatomy in it. Real arthropods read the way they do

   because of three things, and none of them were present:



     JOINTED LIMBS WITH THE KNEE ABOVE THE BODY. This is the single strongest

       signal. A spider's femur angles UP and OUT from the hip to a raised knee,

       and only then does the tibia come down to the ground — so the body hangs

       slung between its legs rather than sitting on them. A straight peg leg

       reads as furniture; a raised knee reads as alive and as carrying weight.

     SEGMENTED, OVERLAPPING CARAPACE. Chitin is not one smooth surface, it is a

       stack of plates each slightly proud of the one behind, so every segment

       catches a separate highlight and throws a shadow onto its neighbour.

       That stack is what makes the mass look hard and heavy instead of soft.

     TAPER EVERYWHERE. Nothing on a living thing is a constant-radius tube.



   All limb geometry is built in BIO_LEG on purpose: the vertex stage keys its

   two-oscillator spring bend off that material id (see VS3D in mesh.js), so

   legs, antennae and tendrils get weighted follow-through with no bones, no CPU

   skinning and no extra draw calls. Body masses are CHITIN, which the same

   shader gives a breathing pulse. Building the anatomy correctly is therefore

   also what animates it.

   ============================================================================ */

/* A tapered segment between two arbitrary points — the primitive the rest of

   this kit is made of. cyl() only builds Y-axis frustums, which cannot express

   a limb that goes out, up, and then down again. */
function boneSeg(m,a,b,r0,r1,seg,col){
  const dx=b[0]-a[0], dy=b[1]-a[1], dz=b[2]-a[2];
  const len=Math.hypot(dx,dy,dz)||1e-4;
  const ax=dx/len, ay=dy/len, az=dz/len;
  /* Any vector not parallel to the axis gives a stable basis. Picking the axis

     we are LEAST aligned with avoids the degenerate cross product. */
  const up = Math.abs(ay)<0.9 ? [0,1,0] : [1,0,0];
  let ux=up[1]*az-up[2]*ay, uy=up[2]*ax-up[0]*az, uz=up[0]*ay-up[1]*ax;
  let l=Math.hypot(ux,uy,uz)||1; ux/=l; uy/=l; uz/=l;
  const vx=ay*uz-az*uy, vy=az*ux-ax*uz, vz=ax*uy-ay*ux;
  const n=seg||6, A=[], B=[];
  for(let k=0;k<n;k++){
    const th=k/n*Math.PI*2, c=Math.cos(th), s=Math.sin(th);
    A.push([a[0]+(ux*c+vx*s)*r0, a[1]+(uy*c+vy*s)*r0, a[2]+(uz*c+vz*s)*r0]);
    B.push([b[0]+(ux*c+vx*s)*r1, b[1]+(uy*c+vy*s)*r1, b[2]+(uz*c+vz*s)*r1]);
  }
  for(let k=0;k<n;k++){ const j=(k+1)%n; m.quad(A[k],A[j],B[j],B[k],col); }
  return m;
}

/* One walking leg: coxa out from the body, femur out and UP to a raised knee,

   tibia down and further out, tarsus tapering to a point on the ground.

   `side` is -1/+1, `k` staggers each leg's splay so they fan instead of

   marching in parallel. Everything is BIO_LEG so the shader flexes it. */
function broodLeg(m,x,y,z,side,reach,drop,knee,th,col,gaitPhase,hip){
  const c=col||BIO_LEG;
  /* SEVEN SEGMENTS ON SEVEN BONES.

     The count matters because each joint is a place the limb can change

     direction, and it is that repeated change of direction — with a knuckle

     swelling at every one — that the eye reads as a leg carrying weight rather

     than as a bent rod. But the count alone is not enough: with the segments

     welded rigidly to the body they still swung as one hook. Each is now a

     RIGID BODY hinged to its parent, so the limb protracts from the hip, flexes

     at the knee and plants its foot in sequence, the way a hinge chain does.

     `gaitPhase` puts diagonal legs in antiphase — the alternating-tripod gait

     every six- and eight-legged animal actually walks. */
  const R=reach, D=drop, S=side;
  /* THE HIP HAS TO BE INSIDE THE SHELL.

     Every socket used to be a fraction of REACH — 0.10R for the socket, 0.34R

     for the coxa — which silently assumed the body was as wide as a third of

     the leg's span. It was, but only by accident: carapace() was bulging its

     keel and segment plates out the +Z FLANK, and that bulge happened to reach

     the coxa. Correcting the keel to the spine took ~2.2 units of half-width

     off the flank and the legs came away from the body, worst at the waist

     where the shell is narrowest — which is exactly the middle pair.

     `hip` is the real answer: the lateral distance from the centreline where

     this animal's shell actually is. The socket buries itself inside that, the

     coxa sits on it, and the rest of the chain measures its span from there

     instead of from a number that was never about the body at all. */
  const H=(hip==null? 0.34*R : hip)*S;   // shell surface, signed
  const P=[
    [x,                y,            z+H*0.30],            // socket, inside the shell
    [x+R*0.05,         y+knee*0.34,  z+H],                 // coxa — emerges AT the shell
    [x+R*0.10,         y+knee*0.82,  z+H+S*0.34*R],        // trochanter
    [x+R*0.12,         y+knee*1.06,  z+H+S*0.76*R],        // femur head — the high knee
    [x+R*0.02,         y+knee*0.58,  z+H+S*1.10*R],        // patella
    [x-R*0.08,         y-D*0.30,     z+H+S*1.32*R],        // tibia foot
    [x-R*0.18,         y-D*0.80,     z+H+S*1.42*R],        // metatarsus
    [x-R*0.32,         y-D,          z+H+S*1.48*R],        // tarsus tip
  ];
  const RD=[th*1.20, th*1.34, th*1.26, th*1.10, th*0.86, th*0.62, th*0.40, th*0.07];
  /* Hip sweeps fore/aft about the vertical; every joint below it flexes about

     the horizontal, which is how a real limb folds. Amplitude falls off down

     the chain — a hip travels, a tarsus only flicks — and the phase lag is what

     makes the leg unfurl along its length instead of folding as one piece. */
  const g=gaitPhase||0;
  const AX=[[0,1,0],[1,0,0],[1,0,0],[1,0,0],[1,0,0],[1,0,0],[1,0,0]];
  const AMP=[0.26,0.10,0.15,0.21,0.17,0.12,0.09];
  const LAG=[0.00,0.22,0.42,0.66,0.92,1.16,1.38];
  let parent=null; const bone=[];
  for(let k=0;k<7;k++){
    /* Sign the swing by side so both flanks step outward together rather than

       the whole animal crabbing sideways. */
    const ax=AX[k][0]?[S,0,0]:[0,1,0];
    parent=m.joint(P[k],parent,ax,g+LAG[k],AMP[k]*(k?1:S),0);
    bone.push(parent);
  }
  /* FOUR SIDES, NOT SEVEN. A limb segment is a couple of pixels wide on a phone

     at play zoom, and seven-sided tubes on seven segments across eight legs is

     where this model's triangle budget actually went — the first version cost

     5,860 triangles, nearly three times the TITAN, on the unit that spawns in

     the largest numbers in the game. Silhouette is set by the JOINTS, not by

     the roundness of the tubes between them, so this costs nothing visually. */
  for(let k=0;k<P.length-1;k++){
    m.bone(bone[k]);
    const claw=k>=P.length-2;
    boneSeg(m,P[k],P[k+1],RD[k],RD[k+1],claw?4:5,claw?CLAW:c);
  }
  /* Knuckles ride the bone BELOW them, so a joint stays welded to the segment

     it drives and never tears open as the limb folds. Only the three that

     actually read — hip, knee and ankle — get a sphere. */
  for(const k of [3,5]){
    m.bone(bone[k]);
    m.sphere(P[k][0],P[k][1],P[k][2],RD[k]*1.14,4,c,0.86,false);
  }
  /* One spur, on the knee, and only when the limb is big enough for it to be

     more than three pixels. On chaff it is pure cost. */
  if(th>0.66){
    m.bone(bone[3]);
    chitinBlade(m,P[3][0],P[3][1],P[3][2],R*0.20,th*0.36,S*0.30,Math.PI*0.88,CLAW,-0.24);
  }
  m.bone(-1);
  return m;
}

/* ---------------------------------------------------------------------------

   SCULPTED CARAPACE.

   A stack of overlapping spheres was the first attempt and it is wrong for the

   same reason it is wrong in any sculpting package: the intersections show, the

   cross-section is stuck circular, and the silhouette is made of arcs. This is

   one continuous skin instead, with the anatomy written into it as

   displacement — so the segment ridges, the tubercles and the dorsal keel are

   part of the surface and light like it.



   `profile(v)` gives the body's half-width down its length; the section is

   flattened dorsoventrally and given a flat-ish underside, because an insect

   is wider than it is tall and rides low over its legs.

   --------------------------------------------------------------------------- */
function carapace(m,x,y,z,len,wid,hgt,col,o){
  o=o||{};
  const segs=o.segs==null?5:o.segs, ridge=o.ridge==null?0.055:o.ridge;
  const bump=o.bump==null?0.05:o.bump, keel=o.keel||0, seed=(o.seed||11)>>>0;
  const taperF=o.nose==null?0.55:o.nose, taperB=o.tail==null?0.30:o.tail;
  /* Cheap deterministic value noise — the tubercle field. Sampled in surface

     space so the bumps travel with the form instead of sliding across it. */
  const h=(a,b)=>{ let n=(a*374761393+b*668265263+seed)>>>0;
    n=(n^(n>>>13))*1274126177>>>0; return ((n^(n>>>16))>>>0)/4294967296; };
  const noise=(a,b)=>{
    const ia=Math.floor(a), ib=Math.floor(b), fa=a-ia, fb=b-ib;
    const sa=fa*fa*(3-2*fa), sb=fb*fb*(3-2*fb);
    return (h(ia,ib)*(1-sa)+h(ia+1,ib)*sa)*(1-sb)+(h(ia,ib+1)*(1-sa)+h(ia+1,ib+1)*sa)*sb;
  };
  /* DECLARE THE MATERIAL BEFORE SCULPTING.

     `mat()` tracks a CURRENT material and the bindMat patch list only rewrites

     the primitives it names — sculpt() and quad() are not on it, so every

     carapace inherited whatever the previous primitive happened to leave

     behind. Measured: the Ravager's entire body, 1,112 vertices, was MAT.PLATE.

     That is the one material id the organic path keys off, so the animal that

     was rebuilt for subsurface translucency and a breathing pulse was getting

     neither — it was shading as painted metal. One line, six organisms. */
  const CMAT=(typeof COL_MAT!=='undefined'&&COL_MAT.get(col));
  if(CMAT!=null) m.mat(CMAT);
  m.sculpt(x,y,z,o.u||18,o.v||16,(u,v)=>{
    const th=u*Math.PI*2, ct=Math.cos(th), st=Math.sin(th);
    /* Body profile: a fat ellipse biased toward the tail, pinched at both ends

       by different amounts so the head is blunt and the abdomen is full. */
    const s=Math.sin(Math.PI*Math.pow(v,0.86));
    let r=Math.pow(s,0.62)*(1-taperF*Math.pow(1-v,2.2))*(1-taperB*Math.pow(v,3.0));
    /* WAIST. The single most important line on an arthropod: the pinch between

       cephalothorax and abdomen is what makes two body masses out of one lump,

       and without it any amount of surface detail still reads as a bean. */
    if(o.waist) r*=1-o.waist*Math.exp(-Math.pow((v-(o.waistAt||0.45))/(o.waistW||0.10),2));
    /* SEGMENT PLATES, not ripples. A smoothstepped sawtooth gives each segment

       a flat field and a hard step down to the next, which is what casts the

       shadow that makes chitin look like overlapping armour rather than a

       corrugated tube. Deepest along the spine, gone under the belly. */
    /* DORSAL IS +Y, WHICH IS `st`. This mask was `ct` — the +Z flank — so every

       organism's segment plates, second noise octave and "dorsal keel" were

       displaced onto ONE SIDE of the body instead of along the spine. Measured

       on the Sovereign's body params at keel 0.40: z ran -5.94..+9.30, a

       3.4-unit bulge out the right flank, while the back stayed smooth. The

       relief was all still there; it was just ninety degrees from where the

       silhouette needed it, which is why these animals read as beans from the

       side and as a lopsided ridge from above. Six organisms, one axis. */
    const dorsal=Math.max(0,st);
    const seg=v*segs, f=seg-Math.floor(seg);
    const plate=f*f*(3-2*f);
    r+=ridge*(plate-0.5)*2*dorsal;
    r+=bump*(noise(u*13,v*17)-0.5)*2*(0.30+0.70*dorsal);
    r+=bump*0.55*(noise(u*29,v*37)-0.5)*2*dorsal;          // finer second octave
    r+=keel*Math.pow(Math.max(0,st),2.4)*Math.sin(Math.PI*v);
    r=Math.max(0.04,r);
    /* Flattened section with a broad flat underside: |cos| shaping on the

       lower half keeps the belly from ballooning into a circle. */
    const py=st*hgt*r*(st<0?0.48:1.0);
    return [(v-0.5)*len, py, ct*wid*r];
  },
  /* THE MATERIAL IS A VALUE BREAK, NOT A HUE.

     What makes reference chitin read as chitin is not its colour, it is the

     range: pale bone-amber plate FIELDS against seams so dark they are almost

     black, with the seam reading wet. One flat vertex colour cannot express

     that, and no amount of atlas texture puts the dark in the right place

     because the atlas does not know where this body's segments are. Painted

     from the SAME plate function that displaced the surface, so the dark can

     never drift off the crease it belongs in. */
  (u,v)=>{
    const th=u*Math.PI*2, st=Math.sin(th);
    const seg=v*segs, f=seg-Math.floor(seg);
    /* Distance from the nearest seam, 0 at the seam and 1 mid-plate. */
    const d=Math.min(f,1-f)*2;
    /* Bias the mask WIDE: the pale field should own most of each segment and

       the dark should be confined to the crease itself, or the animal just

       reads as uniformly dark and all the sculpting is lost. */
    let k=Math.pow(d,0.42); k=k*k*(3-2*k);
    k*=0.70+0.30*Math.max(0,st);                        // belly stays darker
    k*=0.80+0.20*noise(u*23,v*31);                      // pore stipple
    k=0.18+0.82*k;                                      // never fully black
    const lo=o.seam||[0.10,0.11,0.09], hi=col;
    return [lo[0]+(hi[0]-lo[0])*k, lo[1]+(hi[1]-lo[1])*k, lo[2]+(hi[2]-lo[2])*k];
  },false,false);
  return m;
}

/* Tubercles — the bumpy relief all over the reference carapaces. Deterministic

   from `seed` so a model is identical every build. */
function tubercles(m,x,y,z,rx,rz,n,r,col,seed){
  let s=(seed||7)>>>0;
  const rnd=()=>{ s=(s*1664525+1013904223)>>>0; return s/4294967296; };
  for(let k=0;k<n;k++){
    const a=rnd()*Math.PI*2, d=Math.sqrt(rnd());
    m.sphere(x+Math.cos(a)*rx*d, y+r*0.5*(0.6+rnd()*0.8), z+Math.sin(a)*rz*d,
             r*(0.55+rnd()*0.7),4,col,0.62,true);
  }
  return m;
}

/* A curved blade: mandible, raptorial claw, dorsal spike. Built as a chain so

   it actually curves instead of being a straight cone. */
function chitinBlade(m,x,y,z,len,th,curve,yaw,col,rise){
  /* `rise` is pitch, and it is not optional decoration: without it every blade

     lies flat in the XZ plane, so a rank of dorsal spines renders as a set of

     horizontal rods lying along the back like scaffolding instead of raking

     upward off it. Positive rise sweeps the tip up; the curve term still bends

     it sideways, so a mandible and a spine come off the same builder. */
  const c=col||CLAW, cs=Math.cos(yaw||0), sn=Math.sin(yaw||0), N=3, up=rise==null?0.10:rise;
  let px=x, py=y, pz=z, pr=th;
  for(let k=1;k<=N;k++){
    const t=k/N, sweep=curve*t*t*len;
    const nx=x+(len*t)*cs-sweep*sn, nz=z+(len*t)*sn+sweep*cs;
    const ny=y+len*up*t*(1.35-t*0.35);
    const nr=th*(1-t*0.94);
    boneSeg(m,[px,py,pz],[nx,ny,nz],pr,nr,5,c);
    px=nx; py=ny; pz=nz; pr=nr;
  }
  return m;
}

/* Antenna / tendril: long, very thin, swept back and up. Pure BIO_LEG, so the

   shader's spring bend is what actually sells it — these are the parts that

   trail and settle as the creature moves. */
function tendril(m,x,y,z,len,th,side,rise,col,gaitPhase){
  /* Three hinged links rather than one swept curve. A tendril's whole character

     is that it LAGS — the base follows the head, the tip follows the base a

     beat later — and that only happens if the links are separate rigid bodies

     hinged to each other. Amplitude climbs toward the tip because a free end

     travels furthest, which is the opposite of a weight-bearing leg. */
  const c=col||BIO_LEG, N=4, g=gaitPhase||0;
  const pt=k=>{ const t=k/N;
    return [x-len*t*0.55, y+rise*Math.sin(t*1.35), z+side*len*t*0.26]; };
  let parent=null; const bone=[];
  for(let k=0;k<3;k++){
    parent=m.joint(pt(k*2),parent,[side*0.35,0.30,0.88],g+k*0.55,0.16+k*0.10,0);
    bone.push(parent);
  }
  for(let k=0;k<N;k++){
    m.bone(bone[Math.min(2,k>>1)]);
    boneSeg(m,pt(k),pt(k+1),th*(1-k/N*0.88),th*(1-(k+1)/N*0.88),3,c);
  }
  m.bone(-1);
  return m;
}

/* The red eye cluster from the reference — small, numerous, dead ahead. */
function eyeCluster(m,x,y,z,r,rows,col){
  for(let a=0;a<rows;a++) for(const sd of [-1,1]){
    m.sphere(x+a*r*0.22, y+r*(0.55-a*0.85), z+sd*r*(1.05-a*0.28), r*0.42,5,col||HOT,0.85,false);
  }
  return m;
}

function mdlRavager(){                       // 12/13 — the swarm's line animal
  const m=MB();
  /* Body slung between the legs, not sitting on them: the thorax rides at 3.4

     while the knees reach 5.0, which is the arachnid read. Two masses, not

     three spheres in a row — cephalothorax carrying the head and jaws, and a

     heavier plated abdomen behind it. */
  /* ONE sculpted skin from jaw to tail, not three spheres in a row. The nose

     taper, the segment ridges, the tubercle field and the dorsal keel are all

     displacement inside the same surface, so nothing intersects and the whole

     body reads as one grown thing. */
  carapace(m,-0.7,3.3,0,11.4,3.6,2.1,CHITIN,
    {segs:6,ridge:0.20,bump:0.115,keel:0.30,nose:0.60,tail:0.18,
     waist:0.34,waistAt:0.52,waistW:0.075,seed:1201,u:13,v:16});
  /* Head capsule sits proud of the front of that skin rather than inside it. */
  carapace(m,4.0,3.0,0,3.4,2.1,1.6,CHIT_D,
    {segs:3,ridge:0.16,bump:0.14,keel:0.22,nose:0.40,tail:0.44,seed:83,u:10,v:7});
  eyeCluster(m,5.0,3.3,0,0.66,2,HOT);

  /* Six legs, fanned. The stagger in reach/knee stops them marching in

     parallel, which is what made the old boxes read as a table. */
  for(let k=0;k<3;k++) for(const sd of [-1,1])
    broodLeg(m, 1.9-k*2.2, 3.0, 0, sd, 3.4+k*0.20, 3.3, 2.30-k*0.16, 0.52, null,
             ((k+(sd<0?1:0))&1)*Math.PI, [2.35,1.85,2.40][k]);

  /* Raptorial jaws — curved, opposed, and the widest thing on the animal. */
  for(const sd of [-1,1]){
    chitinBlade(m,4.2,2.7,sd*1.0,3.2,0.42,-sd*0.42,sd*0.30,CLAW);
    chitinBlade(m,4.0,3.3,sd*0.5,2.1,0.26,-sd*0.30,sd*0.14,CLAW);
    tendril(m,4.4,4.3,sd*0.8,4.2,0.20,sd,2.1,BIO_LEG);       // sensory tendrils
  }
  /* Dorsal spines raked back along the abdomen, tallest over the shoulders. */
  for(let k=0;k<3;k++)
    chitinBlade(m,-0.4-k*1.7,4.4-k*0.18,0,2.3-k*0.28,0.36,0.16,Math.PI*0.94,CLAW,0.78-k*0.08);
  /* Paired shoulder horns, the widest point of the carapace in plan — this is

     the part that actually reads from the game's overhead camera. */
  for(const sd of [-1,1]) chitinBlade(m,0.8,4.2,sd*1.7,3.0,0.34,sd*0.34,Math.PI*0.82,CLAW,0.52);
  tubercles(m,1.2,3.9,0,1.6,2.4,4,0.56,CHIT_D,4404);
  return {hull:m.build(),tur:null,s:1.0};
}
function mdlAlphaRavager(){                  // 13 — boss silhouette, never a scaled drone
  const m=MB();
  /* Same anatomy as the drone, half again the mass and carried higher: the

     Alpha has to read as the SAME ANIMAL grown large, not as a different one,

     so it uses the same sculpt and the same seven-jointed limbs with the

     proportions pushed — deeper plates, a heavier abdomen, a taller stance. */
  carapace(m,-0.9,4.4,0,17.0,5.2,3.1,CHITIN,
    {segs:7,ridge:0.24,bump:0.125,keel:0.38,nose:0.58,tail:0.16,
     waist:0.36,waistAt:0.54,waistW:0.070,seed:5501,u:15,v:18});
  carapace(m,6.0,4.0,0,5.2,3.0,2.3,CHIT_D,
    {segs:3,ridge:0.18,bump:0.15,keel:0.26,nose:0.38,tail:0.42,seed:311,u:11,v:8});
  eyeCluster(m,7.6,4.5,0,1.05,3,HOT);
  m.sphere(5.0,6.2,0,1.0,7,HOT,1,false);                     // exposed brood core

  for(let k=0;k<4;k++) for(const sd of [-1,1])
    broodLeg(m, 3.4-k*2.7, 4.0, 0, sd, 4.6+k*0.22, 4.4, 3.10-k*0.18, 0.78, null,
             ((k+(sd<0?1:0))&1)*Math.PI, [3.30,2.60,3.35,3.05][k]);

  for(const sd of [-1,1]){
    chitinBlade(m,6.8,3.9,sd*1.7,5.6,0.72,-sd*0.44,sd*0.28,CLAW,0.10);   // oversized jaws
    chitinBlade(m,6.6,4.7,sd*0.9,3.8,0.44,-sd*0.32,sd*0.13,CLAW,0.14);
    tendril(m,7.0,5.9,sd*1.2,7.0,0.30,sd,3.2,BIO_LEG);
    m.sphere(-1.2,7.0,sd*3.0,2.0,8,BIO_TEAM,0.9,false);                  // brood sacs
    chitinBlade(m,1.2,5.6,sd*2.4,5.0,0.52,sd*0.30,Math.PI*0.84,CLAW,0.56);
  }
  /* Crown of spines, tallest over the shoulders — the boss read at 40px. */
  for(let k=0;k<7;k++)
    chitinBlade(m,-5.0+k*1.55,6.2,0,3.2+Math.sin(k/6*Math.PI)*2.6,0.42,0.12,Math.PI*0.96,CLAW,0.95);
  tubercles(m,-4.0,5.6,0,3.4,2.8,9,0.92,CHIT_D,7);
  return {hull:m.build(),tur:null,s:1.18};
}

function mdlCorvette(){                      // 14 — naval light
  const m=MB();
  const waterline=[[-7.75,-2.18],[-6.45,-3.02],[3.65,-3.42],[7.25,-2.05],[8.25,-.72],
                   [8.25,.72],[7.25,2.05],[3.65,3.42],[-6.45,3.02],[-7.75,2.18]];
  const deck=[[-7.05,-2.02],[-5.85,-2.62],[3.55,-2.92],[6.85,-1.72],[7.55,-.58],
              [7.55,.58],[6.85,1.72],[3.55,2.92],[-5.85,2.62],[-7.05,2.02]];
  m.extrude(0,0,0,waterline,2.28,MET_D);                      // flared displacement hull
  m.extrude(0,2.28,0,deck,1.34,MET);                         // armoured weather deck
  m.extrude(.20,3.62,0,deck.map(p=>[p[0]*.94,p[1]*.88]),.30,TEAM_A);
  for(const sd of [-1,1]){
    m.box(-.25,1.18,sd*3.04,10.8,1.02,.52,DARK);              // continuous waterline belt
    m.box(.60,2.54,sd*2.78,8.55,.42,.62,TEAM_A);              // readable fleet stripe
    for(let k=0;k<5;k++)
      m.box(-4.10+k*2.18,1.56,sd*3.33,1.15,.36,.28,MET_L);   // rub rail breaks
    m.box(-5.20,1.02,sd*1.52,4.15,1.45,1.02,DARKER);          // propulsion tunnel attached aft
    tubeX(m,-8.08,1.12,sd*1.52,1.02,.72,.34,10,TWR_BORE);    // hollow waterjet outlet
    ringX(m,-8.12,1.12,sd*1.52,.68,.96,12,MET_L);
    ringX(m,-8.15,1.12,sd*1.52,.25,.37,10,HOT);
    m.bevelBox(1.75,3.92,sd*2.18,3.55,.68,1.15,.22,MET_D);    // deck-edge equipment lockers
    m.box(1.75,4.58,sd*2.18,2.75,.22,.86,TEAM_T);
  }
  m.bevelBox(-1.25,3.84,0,5.65,2.12,4.35,.52,MET_L);         // integrated superstructure
  m.extrude(-1.05,5.96,0,[[-2.15,-1.72],[1.45,-1.82],[2.42,-.86],[2.42,.86],
            [1.45,1.82],[-2.15,1.72]],1.48,DARK);
  m.bevelBox(-.62,7.44,0,3.25,1.08,2.62,.34,TEAM_A);          // bridge roof / livery
  for(const sd of [-1,1]){
    m.box(1.30,6.43,sd*.91,.42,.72,1.35,GLASS);               // wraparound bridge glazing
    m.box(-1.08,6.84,sd*1.78,2.65,.38,.18,GLASS);
  }
  m.box(1.48,6.43,0,.32,.72,.62,GLASS);
  ventBank(m,-3.42,4.06,0,2.25,3.35,5,MET_D,0);
  kitBox(m,3.95,3.95,0,2.35,.94,2.45,MET_D,0);
  for(const sd of [-1,1]) for(let k=0;k<3;k++)
    m.tube(-4.65+k*.82,3.94,sd*.80,.30,.15,.48,8,DARKER);    // six recessed VLS cells
  sensorMast(m,-1.62,8.48,0,2.42,MET_L);
  m.cyl(-1.62,9.72,0,1.72,.30,.30,12,MET_L);                 // search radar dish
  m.box(-1.62,10.02,0,.24,.84,2.65,DARKER);
  glowStrip(m,-.35,8.53,0,2.55,ENERGY,0);
  m.greeble(.45,3.94,0,2.85,3.35,.34,6,MET_D,0,141);

  const t=MB();
  t.cyl(0,0,0,2.12,1.78,.78,12,DARKER);
  turretBody(t,4.05,3.55,1.78,MET,TEAM_A);
  t.bevelBox(-1.15,1.78,0,1.55,.68,2.60,.22,TEAM_T);          // compact bustle marking
  t.box(1.62,.62,0,1.18,1.12,1.65,DARK);                     // mantlet overlap
  gunX(t,1.92,1.12,5.35,.40,MET_D);
  t.box(-1.52,1.82,0,.82,.72,1.18,MET_L);
  t.tube(-1.52,2.52,0,.31,.15,.44,8,LAMP);
  t.greeble(-.38,1.83,0,1.65,2.25,.28,4,MET_D,0,151);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:3.8,naval:1};
}
function mdlDread(){                         // 15 — naval heavy
  const m=MB();
  const waterline=[[-13.35,-4.15],[-11.55,-5.05],[6.55,-5.65],[11.75,-3.55],[13.35,-1.38],
                   [13.35,1.38],[11.75,3.55],[6.55,5.65],[-11.55,5.05],[-13.35,4.15]];
  const deck=[[-12.55,-3.72],[-10.75,-4.52],[6.15,-5.05],[10.85,-3.08],[12.15,-1.12],
              [12.15,1.12],[10.85,3.08],[6.15,5.05],[-10.75,4.52],[-12.55,3.72]];
  m.extrude(0,0,0,waterline,3.58,MET_D);                      // deep dreadnought hull
  m.extrude(0,3.58,0,deck,1.82,MET);
  m.extrude(.25,5.40,0,deck.map(p=>[p[0]*.95,p[1]*.90]),.38,TEAM_A);
  for(const sd of [-1,1]){
    m.box(-.55,1.52,sd*5.05,19.2,1.18,.66,DARK);              // full-length armour belt
    m.box(.25,3.52,sd*4.72,16.4,.58,.82,TEAM_A);              // broad faction stripe
    for(let k=0;k<5;k++)
      m.bevelBox(-7.85+k*3.60,2.18,sd*5.43,1.58,.62,.34,.10,MET_L);
    const ez=2.48;
    m.box(-9.65,1.40,sd*ez,5.25,2.05,1.42,DARKER);            // one large turbine tunnel per side
    tubeX(m,-13.72,1.55,sd*ez,1.28,.98,.46,10,TWR_BORE);
    ringX(m,-13.76,1.55,sd*ez,.88,1.22,10,MET_L);
    m.bevelBox(2.65,5.80,sd*3.75,5.25,.82,1.48,.26,MET_D);    // deck-edge secondary battery deck
    m.box(2.65,6.60,sd*3.75,4.15,.26,1.02,TEAM_T);
    m.cyl(2.65,6.86,sd*3.75,.72,.58,.72,9,DARKER);
    gunX(m,3.02,7.18,2.75,.22,MET_D,sd*3.75);                // one readable secondary per beam
  }
  m.bevelBox(-2.45,5.78,0,9.15,3.12,7.85,.74,MET_L);         // broad armoured island
  m.extrude(-2.20,8.90,0,[[-3.75,-3.25],[2.55,-3.45],[4.05,-1.70],[4.05,1.70],
            [2.55,3.45],[-3.75,3.25]],2.55,DARK);
  m.extrude(-1.75,11.45,0,[[-2.85,-2.38],[1.85,-2.55],[3.05,-1.18],[3.05,1.18],
            [1.85,2.55],[-2.85,2.38]],1.35,TEAM_A);
  for(const sd of [-1,1]){
    m.box(.72,9.64,sd*2.33,.48,1.02,1.55,GLASS);              // bridge windows
    m.box(-2.30,10.15,sd*3.32,3.35,.42,.22,GLASS);
    exhaust(m,-5.70,8.92,sd*1.62,1,.48,2.20,MET_D,.96);
    m.bevelBox(-7.45,5.82,sd*2.15,2.45,.78,1.58,.24,MET_D);
  }
  m.box(.95,9.64,0,.40,1.02,.88,GLASS);
  ventBank(m,-6.45,5.82,0,3.15,5.45,7,MET_D,0);
  for(let xk=0;xk<3;xk++) for(const sd of [-1,1])
    m.tube(-8.75+xk*1.15,5.80,sd*1.18,.38,.19,.62,8,DARKER); // six armoured VLS cells
  m.bevelBox(7.05,5.80,0,3.65,.76,5.30,.25,DARKER);          // fore sensor / magazine block
  m.greeble(7.05,6.58,0,2.60,4.20,.46,3,MET_D,0,161);
  sensorMast(m,-2.65,12.80,0,3.20,MET_L);
  m.cyl(-2.65,14.58,0,2.45,.42,.34,14,MET_L);                // main air-search dish
  m.box(-2.65,14.90,0,.32,1.22,3.82,DARKER);
  sensorMast(m,-5.25,11.05,2.18,2.25,MET_D);
  glowStrip(m,-.85,12.84,0,4.25,ENERGY,0);
  m.greeble(-.30,5.80,0,5.25,5.25,.42,3,MET_D,0,171);

  const t=MB();
  t.cyl(0,0,0,3.65,3.05,1.12,14,DARKER);
  turretBody(t,7.35,6.20,2.72,MET,TEAM_A);
  t.bevelBox(-2.55,2.05,0,2.65,1.18,5.10,.34,TEAM_T);         // turret bustle ownership panel
  t.box(2.85,.78,0,2.20,1.72,3.80,DARK);                     // shared mantlet joins both barrels
  for(const sd of [-1,1]){
    gunX(t,3.42,1.62,9.45,.56,MET_D,sd*1.12);                // true twin, not coincident geometry
    t.box(-1.55,2.75,sd*2.35,2.75,.32,.54,MET_L);
  }
  t.bevelBox(-2.75,2.78,0,1.35,.92,2.35,.25,MET_L);
  t.tube(-2.75,3.68,0,.38,.18,.56,8,LAMP);
  t.greeble(-.25,2.74,0,3.65,3.72,.36,3,MET_D,0,181);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:5.6,naval:1};
}
function mdlBombard(){                       // 16 — siege artillery
  const m=MB();
  runningGear(m,15.4,4.0,3.15,4.25,6,MET_D);
  hullShell(m,14.8,9.2,2.35,1.45,MET,TEAM_A,0.34,0.74);
  m.wedge(5.1,3.82,0,4.0,1.35,7.4,MET_L);
  for(const sd of [-1,1]){
    armorPlate(m,0.0,2.35,sd*4.9,11.0,2.0,0.48,0,MET_D,0);
    m.box(-6.2,1.25,sd*5.35,3.2,2.5,1.15,MET_D);
    m.wedge(-7.1,0,sd*5.35,3.2,1.0,3.0,TWR_PAD);
    hydraulic(m,-5.2,2.7,sd*4.4,2.8,0.31,TWR_MACH,0);
    kitBox(m,-2.2,3.84,sd*3.5,2.7,1.05,1.7,MET_D,0);
    m.box(0.5,3.86,sd*4.15,7.5,0.50,0.70,TEAM_A);
  }
  ventBank(m,-5.0,3.84,0,3.8,4.8,5,MET_D,0);
  exhaust(m,-7.0,3.0,0,3,0.43,2.2,MET_D,2.0);
  sensorMast(m,-6.1,4.0,2.0,2.7,MET_L);
  const t=MB();
  turretBody(t,7.3,6.8,3.25,TWR_ARM,TWR_TEAM);
  t.bevelBox(-3.0,0.9,0,2.6,2.8,5.4,0.45,TWR_COAT);
  for(const sd of [-1,1]){
    t.cyl(0.4,0.65,sd*2.75,1.32,1.15,1.0,10,TWR_MACH);
    hydraulic(t,-1.5,0.2,sd*2.5,2.8,0.34,TWR_MACH,0);
    t.box(-0.3,2.7,sd*3.35,5.2,0.52,0.42,TEAM_A);
    cylX(t,0.6,2.35,sd*0.94,6.2,0.34,0.30,8,TWR_MACH,false);
  }
  gunX(t,1.25,1.75,15.4,0.78,TWR_MACH);
  cylX(t,1.2,1.75,0,3.2,1.42,1.08,12,TWR_COAT,false);
  for(const x of [7.4,12.2]) ringX(t,x,1.75,0,0.82,1.08,12,TWR_TRIM);
  t.box(14.7,0.72,0,1.4,2.2,3.4,TWR_MACH);
  tubeX(t,16.05,1.75,0,1.1,0.98,0.49,12,TWR_BORE);
  kitBox(t,-3.2,3.35,0,2.0,1.25,4.4,MET_D,0);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:5.95};
}
function mdlRaptor(){                        // 17 — gunship
  const m=MB();
  const keel=[[-6.35,-1.92],[-3.25,-2.55],[2.75,-2.72],[6.15,-1.18],[7.05,0],
              [6.15,1.18],[2.75,2.72],[-3.25,2.55],[-6.35,1.92]];
  const deck=[[-5.75,-1.68],[-2.8,-2.12],[2.65,-2.22],[5.55,-.92],[6.15,0],
              [5.55,.92],[2.65,2.22],[-2.8,2.12],[-5.75,1.68]];
  m.extrude(0,0,0,keel,1.55,MET_D);
  m.extrude(0,1.55,0,deck,1.62,MET);                           // deep troop-carrying fuselage
  m.extrude(-.25,3.17,0,deck.map(p=>[p[0]*.76,p[1]*.70]),.70,TEAM_A);
  m.bevelBox(3.25,3.36,0,3.95,1.36,2.85,.46,GLASS);           // armoured cockpit
  m.wedge(5.30,3.80,0,1.85,.72,2.50,MET_L,0,true);
  m.box(-1.20,3.90,0,4.35,.42,1.05,TEAM_T);
  glowStrip(m,-.65,4.31,0,2.65,ENERGY,0);
  ventBank(m,-3.55,3.86,0,2.45,1.48,4,DARK,0);
  for(const sd of [-1,1]){
    const wing=sd>0
      ? [[-3.95,1.55],[2.65,1.80],[1.25,6.05],[-4.70,5.30]]
      : [[-3.95,-1.55],[-4.70,-5.30],[1.25,-6.05],[2.65,-1.80]];
    m.extrude(0,1.20,0,wing,.78,MET_D);                        // thick gunship wing
    m.box(-1.45,1.36,sd*3.45,5.35,1.12,2.55,DARK);             // load-bearing engine pylon
    cylX(m,-5.15,1.62,sd*3.78,5.95,1.42,1.15,11,DARK,false);  // armoured turbine nacelle
    ringX(m,-5.18,1.62,sd*3.78,1.03,1.48,12,MET_L);
    tubeX(m,-5.67,1.62,sd*3.78,1.02,1.12,.55,12,TWR_BORE);    // shadowed exhaust throat
    ringX(m,-5.71,1.62,sd*3.78,.37,.58,12,HOT);
    ringX(m,.35,1.62,sd*3.78,.88,1.20,12,MET_L);
    m.bevelBox(-1.55,2.56,sd*3.78,2.75,.82,1.75,.28,TEAM_A);   // nacelle livery fairing
    ventBank(m,-1.55,3.39,sd*3.78,1.95,1.18,3,MET_D,0);
    m.bevelBox(-.65,.55,sd*5.28,3.40,1.00,1.42,.28,DARKER);    // attached stores pylon
    for(let k=0;k<3;k++)
      tubeX(m,-1.72+k*1.05,.73,sd*5.28,.85,.30,.14,7,HOT);
    m.box(1.95,.48,sd*1.48,2.55,1.02,.95,DARK);                // chin gun receiver
    gunX(m,2.72,.82,3.55,.31,MET_D,sd*1.48);
    m.box(-4.95,2.55,sd*2.25,2.25,2.80,.42,MET_L);            // twin vertical tails
    m.box(-4.55,4.75,sd*2.25,1.45,.38,.48,TEAM_A);            // tail-tip livery
  }
  m.bevelBox(-5.08,1.82,0,2.75,1.62,3.80,.42,DARKER);         // tail gearbox joins fins
  m.box(-6.42,2.00,0,.60,1.20,2.75,MET_L);                    // rear cargo ramp edge
  sensorMast(m,-4.20,3.38,0,1.52,MET_L);
  m.greeble(-.90,3.88,0,3.05,1.10,.40,5,MET_D,0,117);
  return {hull:m.build(),tur:null,s:1.0,air:1};
}
function mdlScorcher(){                      // 18 — heavy flamer
  const m=MB();
  runningGear(m,15.2,4.0,3.25,4.25,6,MET_D);
  hullShell(m,14.6,9.0,2.45,1.55,MET,TEAM_A,0.32,0.76);
  m.wedge(5.0,4.02,0,4.2,1.45,7.4,MET_L);
  for(const sd of [-1,1]){
    armorPlate(m,0.2,2.45,sd*4.85,11.0,2.1,0.5,0,MET_D,0);
    m.cyl(-4.2,4.05,sd*2.65,2.0,2.0,4.8,11,RUST);
    m.ring(-4.2,5.1,sd*2.65,1.98,2.24,12,TWR_MACH);
    m.ring(-4.2,7.5,sd*2.65,1.98,2.24,12,TWR_MACH);
    m.box(0.5,4.04,sd*4.15,7.8,0.52,0.72,TEAM_A);
    m.tube(-2.2,6.0,sd*4.2,0.38,0.20,1.5,8,TWR_BORE);
  }
  m.box(-4.2,8.92,0,5.4,0.65,6.2,DARKER);
  ventBank(m,-6.1,4.05,0,3.0,4.8,5,MET_D,0);
  exhaust(m,-7.0,3.1,0,3,0.45,2.4,MET_D,2.1);
  const t=MB();
  turretBody(t,6.2,5.8,3.0,TWR_ARM,TWR_TEAM);
  t.bevelBox(-2.1,0.8,0,2.4,2.2,4.7,0.42,TWR_COAT);
  for(const sd of [-1,1]){
    t.box(-0.5,1.25,sd*2.9,4.2,1.0,0.42,TEAM_A);
    hydraulic(t,-1.2,0.2,sd*2.2,2.2,0.30,TWR_MACH,0);
    cylX(t,1.55,1.35,sd*1.05,5.4,0.72,0.62,10,TWR_MACH,false);
    for(const x of [2.3,4.5]) ringX(t,x,1.35,sd*1.05,0.72,0.92,10,TWR_TRIM);
    cylX(t,6.55,1.35,sd*1.05,1.1,0.92,1.28,10,TWR_COAT,false);
    tubeX(t,7.25,1.35,sd*1.05,0.95,1.30,0.69,12,TWR_BORE);
    t.sphere(8.05,1.35,sd*1.05,0.34,7,HOT,1,false);
  }
  t.box(-2.3,3.02,0,1.8,1.4,3.8,MET_D);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:6.1};
}
/* ---------------------------------------------------------------------------

   FACTION CHASSIS KITS

   Recolouring an identical model is not a faction. These are alternate builds

   of the same three roles, so an enemy army is recognisable by SHAPE before

   you read its colour:

     legion    — tracked, slab-armoured, blunt: the standard line, up-armoured

     syndicate — hover skirts instead of treads, raked prow, exposed coils

     horde     — grown carapace, no plating, claws and spines

   --------------------------------------------------------------------------- */
/* Nova's line tank rides on four clean electromagnetic runner pods. The

   separated drive blocks, arrow hull and capacitor-fed accelerator preserve a

   conventional battle-tank role without borrowing the old shared tread box. */
function mdlNovaRhino(){
  const m=MB();
  for(const sd of [-1,1]){
    m.bevelBox(-.5,0,sd*4.0,12.2,1.7,2.15,.40,TWR_COAT);
    m.bevelBox(-.3,1.7,sd*4.0,10.8,1.15,1.75,.30,TWR_ARM_D);
    for(const x of [-4.0,0,4.0]){
      m.cyl(x,.18,sd*4.0,.78,.68,1.05,10,TWR_MACH);
      m.ring(x,1.25,sd*4.0,.55,.84,12,TWR_GLOW);
    }
    m.box(-.2,2.88,sd*4.9,6.8,.20,.34,sd>0?TEAM_A:TWR_GLOW);
  }
  m.extrude(0,2.1,0,[[-6.2,-3.15],[2.2,-3.45],[6.4,-1.55],[6.9,0],
    [6.4,1.55],[2.2,3.45],[-6.2,3.15]],2.15,TWR_ARM_D);
  m.extrude(-.2,4.25,0,[[-5.2,-2.45],[2.0,-2.75],[5.6,-1.15],[6.1,0],
    [5.6,1.15],[2.0,2.75],[-5.2,2.45]],1.25,TWR_ARM);
  m.wedge(4.2,4.6,0,3.7,1.35,5.2,MET_L,0,true);
  m.bevelBox(-3.8,4.5,0,3.1,1.2,4.7,.30,TWR_COAT);
  for(const sd of [-1,1]){
    m.box(-1.0,5.52,sd*2.48,6.8,.22,.55,TEAM_A);
    m.cyl(-4.5,5.0,sd*1.7,.62,.50,2.0,9,TWR_MACH);
    m.ring(-4.5,6.72,sd*1.7,.56,.80,10,TWR_GLOW);
  }
  glowStrip(m,.6,5.58,0,7.4,ENERGY,0);
  const t=MB();
  t.cyl(-.8,0,0,3.6,3.1,1.2,14,TWR_PAD);
  t.extrude(0,1.2,0,[[-3.8,-2.65],[1.7,-3.0],[3.9,-1.25],[4.3,0],
    [3.9,1.25],[1.7,3.0],[-3.8,2.65]],2.2,TWR_ARM);
  t.extrude(-.2,3.4,0,[[-3.0,-2.05],[1.4,-2.3],[3.2,-.9],[3.45,0],
    [3.2,.9],[1.4,2.3],[-3.0,2.05]],.62,TEAM_T);
  cylX(t,2.0,2.05,0,7.6,.66,.54,12,TWR_MACH,false);
  for(const x of [3.0,5.2,7.4]) ringX(t,x,2.05,0,.72,1.00,12,x===7.4?TWR_GLOW:TWR_TRIM);
  tubeX(t,9.45,2.05,0,.85,.76,.37,12,TWR_BORE);
  for(const sd of [-1,1]){
    t.bevelBox(-1.5,2.0,sd*2.65,3.6,1.4,.52,.20,TWR_ARM_D);
    t.box(-1.5,3.34,sd*2.93,2.0,.18,.42,sd>0?TEAM_A:TWR_GLOW);
  }
  t.ring(-1.7,4.25,0,1.35,2.05,16,TWR_GLOW);
  t.sphere(-1.7,4.25,0,.82,8,ENERGY,1,false);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:5.45,muzzle:9.8};
}

/* Ascendancy doctrine makes the same battlefield role a broad assault block:

   full tracks, layered slabs, visible exhaust heat and a long recoil cannon. */
function mdlLegionRhino(){
  const m=MB();
  treads(m,14.0,3.25,3.15,4.25,6);
  m.extrude(-.3,2.1,0,[[-7.0,-4.2],[3.3,-4.2],[6.8,-2.8],[7.2,-1.2],
    [7.2,1.2],[6.8,2.8],[3.3,4.2],[-7.0,4.2]],2.7,TWR_ARM_D);
  m.bevelBox(-1.0,4.8,0,11.8,2.0,6.9,.65,TWR_ARM);
  m.wedge(4.6,4.85,0,4.3,1.8,7.0,TWR_ARM,0,true);
  for(const sd of [-1,1]){
    armorPlate(m,-.1,2.4,sd*4.55,11.8,2.1,.54,0,TWR_COAT,0);
    m.box(-1.8,6.78,sd*3.1,5.8,.24,.68,TEAM_A);
    m.cyl(-5.2,4.85,sd*2.55,.82,.72,2.7,10,TWR_MACH);
    m.ring(-5.2,6.9,sd*2.55,.78,1.04,12,HOT);
  }
  ventBank(m,-4.8,6.82,0,3.6,4.8,5,TWR_MACH,0);
  m.bevelBox(-6.0,3.2,0,2.0,2.8,5.4,.42,DARKER);
  m.box(3.8,6.85,0,3.8,.24,2.2,TWR_TRIM);
  const t=MB();
  t.cyl(-1.0,0,0,4.1,3.65,1.25,14,TWR_PAD);
  t.bevelBox(-.8,1.25,0,8.6,3.2,6.9,.80,TWR_ARM_D);
  t.bevelBox(-.4,4.45,0,7.5,1.0,5.8,.34,TWR_ARM);
  for(const sd of [-1,1]){
    t.bevelBox(-1.8,1.8,sd*3.2,4.2,2.1,.58,.24,TWR_COAT);
    t.box(-1.8,3.82,sd*3.51,2.5,.20,.54,sd>0?TEAM_A:HOT);
    hydraulic(t,-2.2,.55,sd*2.55,2.4,.28,TWR_MACH,0);
  }
  gunX(t,2.7,2.3,9.2,.72,TWR_MACH);
  cylX(t,2.0,2.3,0,3.3,1.28,1.02,12,TWR_COAT,false);
  for(const x of [5.5,8.7]) ringX(t,x,2.3,0,.82,1.12,12,x>8?HOT:TWR_TRIM);
  t.box(10.5,1.35,0,1.4,2.2,3.6,TWR_MACH);
  tubeX(t,11.8,2.3,0,.92,.84,.42,12,TWR_BORE);
  t.bevelBox(-4.1,1.4,0,2.5,2.6,5.0,.42,DARKER);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:6.0,muzzle:12.2};
}

/* A role-specific Syndicate skimmer. Three exposed lift banks and a forked

   coil weapon replace both tracks and a conventional gun tube. */
function mdlSyndicateRhino(){
  const m=MB();
  m.extrude(0,0,0,[[-6.8,-3.5],[-2.4,-4.5],[3.1,-4.2],[6.8,-1.7],[7.2,0],
    [6.8,1.7],[3.1,4.2],[-2.4,4.5],[-6.8,3.5]],1.35,TWR_COAT);
  for(const sd of [-1,1]) for(const x of [-4.4,0,4.4]){
    m.cyl(x,.15,sd*3.55,.75,.62,1.0,10,TWR_MACH);
    m.ring(x,1.18,sd*3.55,.54,.88,12,ENERGY);
    m.sphere(x,1.20,sd*3.55,.42,7,TWR_GLOW,.72,false);
  }
  m.extrude(-.2,1.4,0,[[-6.1,-3.05],[-1.8,-3.7],[3.0,-3.25],[6.4,-1.25],[6.9,0],
    [6.4,1.25],[3.0,3.25],[-1.8,3.7],[-6.1,3.05]],2.05,TWR_ARM_D);
  m.extrude(.2,3.45,0,[[-4.9,-2.35],[-1.0,-2.85],[3.2,-2.45],[5.7,-.9],[6.1,0],
    [5.7,.9],[3.2,2.45],[-1.0,2.85],[-4.9,2.35]],1.4,TWR_ARM);
  for(const sd of [-1,1]){
    m.wedge(3.9,3.55,sd*3.3,4.2,1.2,1.5,TWR_ARM,sd*.10,sd<0);
    m.box(-.4,4.88,sd*2.78,6.8,.20,.52,TEAM_A);
    m.bevelBox(-4.7,3.0,sd*2.1,2.4,1.4,1.5,.25,DARKER);
  }
  m.ring(-3.7,5.45,0,1.4,2.3,16,ENERGY);
  m.box(-3.7,5.38,0,4.8,.20,.58,TEAM_T);
  const t=MB();
  t.cyl(-.8,0,0,3.6,3.15,1.0,14,TWR_PAD);
  t.extrude(0,1.0,0,[[-3.9,-2.5],[1.6,-3.0],[4.0,-1.0],[4.4,0],
    [4.0,1.0],[1.6,3.0],[-3.9,2.5]],2.1,TWR_ARM_D);
  t.extrude(.1,3.1,0,[[-3.0,-1.9],[1.3,-2.3],[3.2,-.75],[3.5,0],
    [3.2,.75],[1.3,2.3],[-3.0,1.9]],.65,TEAM_T);
  for(const sd of [-1,1]){
    const z=sd*1.35;
    cylX(t,2.0,2.05,z,5.6,.64,.50,11,TWR_MACH,false);
    for(const x of [2.8,4.4,6.0]) ringX(t,x,2.05,z,.70,.98,12,sd>0?TWR_GLOW:ENERGY);
    tubeX(t,7.45,2.05,z,.85,.72,.35,12,TWR_BORE);
    t.bevelBox(-.5,1.5,sd*2.6,4.5,1.6,.55,.22,TWR_COAT);
  }
  t.sphere(-2.3,3.8,0,1.5,9,TWR_GLOW,1,false);
  ringX(t,-2.3,3.8,0,1.75,2.35,16,TWR_TRIM);
  return {hull:m.build(),tur:t.build(),s:.98,turH:5.05,muzzle:7.8,muzzleZ:1.35};
}

function mdlSynTank(){
  const m=MB();
  // hover skirt: a continuous chamfered plenum where treads would be
  m.extrude(0,0,0,[[-6.6,-3.8],[3.0,-4.2],[6.6,-2.0],[6.6,2.0],[3.0,4.2],[-6.6,3.8]],1.5,DARKER);
  m.extrude(0,1.5,0,[[-6.2,-3.4],[2.8,-3.8],[6.2,-1.8],[6.2,1.8],[2.8,3.8],[-6.2,3.4]],1.3,MET_D);
  for(const sd of [-1,1]) for(let k=0;k<4;k++)                 // lift coils
    m.cyl(-4.2+k*3.0,0.3,sd*3.4,0.7,0.62,1.0,8,ENERGY);
  m.extrude(0,2.8,0,[[-5.4,-2.8],[2.4,-3.2],[6.0,-1.2],[6.0,1.2],[2.4,3.2],[-5.4,2.8]],2.0,MET);
  m.wedge(4.0,4.8,0,3.6,1.4,5.6,TEAM_A);                       // raked prow
  m.extrude(0,4.8,0,[[-4.4,-2.2],[2.0,-2.6],[4.6,-1.0],[4.6,1.0],[2.0,2.6],[-4.4,2.2]],0.6,TEAM_T);
  glowStrip(m,0,5.45,0,7.0,ENERGY,0);
  for(const sd of [-1,1]){
    m.cyl(-5.2,3.4,sd*2.2,0.55,0.45,2.6,8,MET_D);              // vent stacks
    m.tube(-5.2,6.0,sd*2.2,0.52,0.30,0.4,8,ENERGY);
  }
  m.bevelBox(-4.0,4.8,0,2.6,1.2,4.4,0.3,DARK);
  sensorMast(m,-4.0,6.0,1.4,2.2,MET_L);
  const t=MB();
  t.extrude(0,0,0,[[-3.0,-2.4],[1.8,-2.8],[3.6,-1.2],[3.6,1.2],[1.8,2.8],[-3.0,2.4]],2.2,MET);
  t.extrude(0,2.2,0,[[-2.4,-1.9],[1.4,-2.2],[3.0,-0.9],[3.0,0.9],[1.4,2.2],[-2.4,1.9]],0.7,TEAM_T);
  // twin coil emitters instead of a barrel: energy weapon, visibly
  for(const sd of [-1,1]){
    t.cyl(2.0,1.1,sd*1.1,0.55,0.42,4.4,8,MET_D);
    t.cyl(6.2,1.1,sd*1.1,0.62,0.30,0.9,8,ENERGY);
    for(let k=0;k<3;k++) t.cyl(2.6+k*1.2,1.1,sd*1.1,0.78,0.78,0.30,8,ENERGY);
  }
  t.cyl(-2.4,2.9,0,1.0,0.5,1.4,9,ENERGY);
  return {hull:m.build(),tur:t.build(),s:1.0,turH:5.0,muzzle:7.1,muzzleZ:1.1};
}
function bioLegBank(m,n,span,reach,y){
  for(let k=0;k<n;k++) for(const sd of [-1,1]){
    const x=span*(.5-k/Math.max(1,n-1)), z=sd*(reach*.58+k%2*.22);
    m.sphere(x,y+.2,z,.72,7,CHIT_D,.72,false);
    m.box(x,y,sd*reach,3.2,.58,.72,BIO_LEG,sd*(.16+k*.035));
    m.box(x-.25,.18,sd*(reach+1.45),2.2,.48,.62,BIO_LEG,sd*(.34+k*.025));
    m.sphere(x+.65,.12,sd*(reach+2.25),.44,6,CLAW,.72,false);
  }
}
function bioCrown(m,x,y,count,spread,height){
  for(let k=0;k<count;k++){
    const q=count<2?0:k/(count-1)-.5;
    m.cyl(x+q*spread,y,0,.48-Math.abs(q)*.14,.04,height*(1-Math.abs(q)*.25),6,BIO_LEG);
  }
}
function mdlHordeBeast(){
  const m=MB();
  bioLegBank(m,4,6.6,4.8,1.55);
  m.sphere(0,2.2,0,4.6,10,CHITIN,.80,false);
  m.sphere(-4.4,2.6,0,3.8,9,CHIT_D,.74,false);
  m.sphere(4.0,2.0,0,3.0,9,CHIT_D,.88,false);
  for(const sd of [-1,1]){
    m.box(6.4,2.0,sd*1.2,3.4,.66,.66,BIO_LEG,sd*.12);
    m.box(8.0,1.8,sd*.7,2.0,.5,.5,CLAW,sd*.18);
  }
  bioCrown(m,-.2,5.5,5,6.4,3.2);
  m.sphere(0,5.0,0,1.4,7,BIO_TEAM,1,false);
  m.sphere(-4.4,5.0,0,1.1,7,BIO_TEAM,1,false);
  return {hull:m.build(),tur:null,s:1.0};
}
function mdlHordeSpitter(){
  const m=MB(); bioLegBank(m,3,5.7,4.5,1.35);
  m.sphere(-1.5,2.0,0,4.2,10,CHITIN,.76,false);
  m.sphere(-4.8,2.5,0,3.8,9,CHIT_D,.92,false);
  for(const sd of [-1,1]){
    m.sphere(-3.8,4.8,sd*1.9,1.25,7,BIO_TEAM,.92,false);
    m.box(2.6,1.2,sd*2.7,4.2,.58,.72,BIO_LEG,sd*.16);
  }
  bioCrown(m,-3.8,5.7,4,4.8,2.5);
  const t=MB();
  t.sphere(-1.0,.1,0,3.0,9,CHITIN,.72,false);
  t.sphere(.8,.5,0,2.1,8,CHIT_D,.82,false);
  /* A telescoping throat, not a barrel. Overlapping unequal lobes break every

     straight manufactured edge while retaining a readable forward weapon. */
  for(let k=0;k<5;k++){
    const r=1.34-k*.17;
    t.sphere(2.0+k*1.05,.48+Math.sin(k*.9)*.15,0,r,7,k&1?CHITIN:CHIT_D,.72,false);
  }
  t.sphere(6.6,.46,0,.82,7,LAMP,.62,false);                  // wet acid lumen
  for(const sd of [-1,1]){
    for(let k=0;k<3;k++) t.sphere(1.5+k*1.4,.1,sd*(1.18-k*.20),.48-k*.07,6,BIO_LEG,.68,false);
    t.box(5.7,.12,sd*.76,2.0,.30,.30,CLAW,sd*.18);           // soft mouth hook
    t.sphere(-.4,2.0,sd*1.45,.72,6,BIO_TEAM,1,false);
  }
  return {hull:m.build(),tur:t.build(),s:1.0,turH:4.7};
}
function mdlHordeBombardier(){
  const m=MB(); bioLegBank(m,4,7.0,5.2,1.45);
  m.sphere(-2.5,2.6,0,5.3,11,CHIT_D,.92,false);
  m.sphere(2.8,2.0,0,3.6,9,CHITIN,.76,false);
  for(const sd of [-1,1]){
    m.sphere(-4.2,5.9,sd*2.2,1.6,8,BIO_TEAM,1,false);
    m.box(-.4,1.6,sd*4.0,6.2,.72,.82,BIO_LEG,sd*.1);
  }
  bioCrown(m,-2.6,7.1,7,8.0,4.2);
  const t=MB();
  t.sphere(-1.6,.1,0,3.4,10,CHITIN,.74,false);
  t.sphere(1.0,.55,0,2.4,8,CHIT_D,.84,false);
  for(let k=0;k<7;k++){
    const r=1.65-k*.15;
    t.sphere(2.5+k*1.25,.62+Math.sin(k*.7)*.20,0,r,8,k%2?CHITIN:CHIT_D,.72,false);
    if(k<5) for(const sd of [-1,1])
      t.sphere(2.6+k*1.25,.35,sd*(r*.82),.34,6,BIO_LEG,.70,false);
  }
  t.sphere(10.2,.62,0,.90,7,LAMP,.65,false);
  for(const sd of [-1,1]) t.sphere(-1.0,2.5,sd*1.7,.82,7,BIO_TEAM,1,false);
  return {hull:m.build(),tur:t.build(),s:1.06,turH:5.7};
}
function mdlHordeSupport(){
  const m=MB(); bioLegBank(m,3,5.6,4.8,1.25);
  m.sphere(-1.8,2.0,0,4.4,10,CHITIN,.80,false);
  m.sphere(-5.0,2.8,0,4.0,10,CHIT_D,1.08,false);
  for(let k=0;k<6;k++){
    const a=k/6*TAU;
    m.sphere(-4.8+Math.cos(a)*2.8,5.2,Math.sin(a)*2.8,1.05,7,BIO_TEAM,1,false);
  }
  for(const sd of [-1,1]){
    m.box(1.0,1.0,sd*4.4,5.4,.56,.68,BIO_LEG,sd*.2);
    m.cyl(1.8,3.5,sd*2.3,.42,.06,3.8,6,BIO_LEG);
  }
  bioCrown(m,-3.4,6.2,5,6.2,3.8);
  return {hull:m.build(),tur:null,s:1.0};
}
function mdlHordeFlyer(){
  const m=MB();
  m.sphere(-.4,.5,0,3.3,10,CHITIN,.52,false);
  m.sphere(-3.4,.65,0,2.7,9,CHIT_D,.68,false);
  m.sphere(2.5,.35,0,2.1,8,CHIT_D,.74,false);
  for(const sd of [-1,1]){
    /* Two asymmetrical membrane lobes per side read as an insect wing from

       above. The perimeter is curved/segmented; there is no rectangular panel. */
    const fore=[[-5,sd*1.0],[-2,sd*3.5],[2,sd*7.4],[5,sd*10.7],[3,sd*13.0],[-1,sd*11.4],[-5,sd*5.0]];
    const hind=[[-5,sd*1.0],[-4,sd*4.2],[-2,sd*8.7],[1,sd*10.0],[2,sd*7.5],[-.5,sd*3.0]];
    m.extrude(-.8,.28,0,fore,.22,BIO_MEM);
    m.extrude(-3.8,.14,0,hind,.18,BIO_MEM);
    m.box(0,.55,sd*5.7,10.0,.16,.24,BIO_LEG,sd*1.15);
    m.box(-3.0,.42,sd*4.7,7.6,.15,.21,BIO_LEG,sd*1.30);
    for(let k=0;k<5;k++) m.sphere(-4+k*1.65,.48,sd*(1.2+k*2.15),.38-k*.035,6,BIO_LEG,.62,false);
    for(let k=0;k<3;k++) m.sphere(1.8+k*.9,.12,sd*(1.0-k*.22),.44-k*.08,6,BIO_LEG,.68,false);
    m.sphere(-2.4,1.8,sd*1.65,.76,7,BIO_TEAM,1,false);
  }
  bioCrown(m,-3.4,2.4,3,3.6,2.3);
  return {hull:m.build(),tur:null,s:1.0,air:1};
}
function mdlHordeSwimmer(){
  const m=MB();
  m.sphere(-1.0,1.0,0,5.2,12,CHITIN,.48,false);
  m.sphere(-5.2,1.1,0,3.8,10,CHIT_D,.60,false);
  m.sphere(4.0,.8,0,3.0,9,CHIT_D,.58,false);
  for(const sd of [-1,1]){
    m.wedge(-.8,.55,sd*5.0,9.8,.32,3.4,BIO_MEM,sd*.18,sd<0);
    m.box(-5.8,.25,sd*2.5,5.0,.42,.72,BIO_LEG,sd*.25);
    m.box(5.5,.35,sd*1.7,4.6,.48,.58,BIO_LEG,sd*.28);
    m.sphere(-1.5,3.2,sd*2.6,1.05,7,BIO_TEAM,1,false);
  }
  bioCrown(m,-1.5,4.2,5,6.2,2.8);
  return {hull:m.build(),tur:null,s:1.06};
}
function mdlHordeLeviathan(){
  const m=MB(); bioLegBank(m,5,9.2,6.1,2.0);
  m.sphere(-1.2,3.2,0,6.4,12,CHITIN,.80,false);
  m.sphere(-6.2,3.8,0,5.6,11,CHIT_D,.98,false);
  m.sphere(4.8,2.8,0,4.2,10,CHIT_D,.78,false);
  for(const sd of [-1,1]){
    m.box(7.0,2.6,sd*1.8,5.6,.9,.9,BIO_LEG,sd*.12);
    m.box(9.7,2.1,sd*.9,3.2,.68,.68,CLAW,sd*.2);
    m.sphere(-3.2,7.8,sd*3.1,2.2,9,BIO_TEAM,1,false);
  }
  bioCrown(m,-2.0,8.4,9,10.0,6.0);
  return {hull:m.build(),tur:null,s:1.16};
}
/* ============================================================================

   FACTION INFANTRY DOCTRINE

   Only the RED and BLUE armies field humans. Nova (blue) runs the standard

   rifleman; the Crimson Dominion (red) runs the same species in siege plate —

   visibly heavier, shielded, slower-looking even at 15px. The Syndicate is a

   CYBERNETIC force and fields no humanoids at all: its infantry slot is a

   strider drone, all raked edges and hover mass, because a machine culture

   sending flesh into small-arms fire would contradict everything else on its

   roster. The Brood was already animals. Doctrine lives in the KIT, so both

   the player's army and the AI's obey it automatically.

   ============================================================================ */
function mdlLegionTrooper(){                 // red — breacher in siege plate
  const m=MB();
  const b=mfTrooper(m,{h:8.4,w:1.38,chest:MET_D,helm:MET_D,pack:MET_D});
  /* full-face helm: visor slit only, plus a crest ridge */
  m.box(0.72,b.sh+0.30,0,0.30,0.20,1.05,GLASS);
  m.wedge(0.1,b.hd+0.05,0,1.0,0.5,0.5,TEAM_A);
  /* TOWER SHIELD on the left arm — the one-item read for "more armored".

     Bevelled slab, raked back, with a vision notch. */
  m.bevelBox(1.15,b.hip+0.3,-1.95,0.55,4.6,2.6,0.4,MET);
  m.box(1.45,b.hip+3.3,-1.95,0.2,0.7,1.2,DARKER);            // vision slit
  m.wedge(1.15,b.hip+4.9,-1.95,0.5,0.8,2.5,MET_L,0,true);    // shield crown
  /* stub carbine on the right — short, because the shield is the weapon */
  const gy=b.hip+1.7;
  m.bevelBox(1.5,gy,0.7,1.9,0.6,0.5,0.16,MET_D);
  m.cyl(2.6,gy+0.1,0.7,0.16,0.13,1.1,6,DARKER,Math.PI/2);
  m.box(1.7,gy-0.5,0.7,0.4,0.55,0.4,MET_D);
  glowStrip(m,-0.6,b.sh+0.4,0,0.8,HOT,0);
  return {hull:m.build(),tur:null,s:1.0};
}
function mdlLegionPyro(){                    // red — furnace trooper
  const m=MB();
  const b=mfTrooper(m,{h:8.2,w:1.5,chest:RUST,helm:MET_D,pack:MET_D});
  m.cyl(-1.3,b.hip+0.4,0,0.85,0.85,3.6,9,RUST);              // single fat boiler tank
  m.cyl(-1.3,b.hip+4.0,0,0.85,0.4,0.6,9,MET_D);
  m.cyl(-1.3,b.hip+2.0,0,0.9,0.9,0.26,9,MET_L);              // band
  m.cyl(-0.7,b.sh-0.5,0.3,0.18,0.15,2.1,5,DARKER,Math.PI/2); // hose
  const gy=b.hip+1.5;
  m.bevelBox(1.6,gy,0.2,2.3,0.85,0.75,0.2,MET_D);            // heavy projector
  m.tube(3.4,gy+0.1,0.2,0.45,0.26,1.1,8,MET_L,Math.PI/2);
  m.cyl(4.4,gy+0.1,0.2,0.15,0.12,0.5,5,HOT,Math.PI/2);
  m.wedge(2.4,gy+0.75,0.2,1.6,0.5,1.0,MET_D);                // heat shield
  glowStrip(m,3.6,gy+0.5,0.2,0.8,HOT,0);
  return {hull:m.build(),tur:null,s:1.05};
}
function mdlSynStrider(){                    // cybernetic — infantry-slot drone
  const m=MB();
  /* No box anywhere: a raked diamond chassis, a halo, and three blade legs.

     The profile is one continuous line front to back — this is the "flows

     cleanly to the eye" read, and it is what separates the machine culture

     from the humans at a glance. */
  m.extrude(0,3.4,0,[[-3.4,0],[-1.8,-1.6],[1.6,-1.9],[3.8,-0.7],[4.6,0],
                     [3.8,0.7],[1.6,1.9],[-1.8,1.6]],1.5,MET);
  m.extrude(0.2,4.9,0,[[-2.6,0],[-1.3,-1.2],[1.3,-1.4],[3.0,-0.5],[3.5,0],
                       [3.0,0.5],[1.3,1.4],[-1.3,1.2]],0.8,TEAM_A);
  m.wedge(3.2,5.7,0,1.6,0.6,1.2,MET_L);                      // brow blade
  m.sphere(1.9,5.9,0,0.55,8,ENERGY,1,false);                 // optic
  m.tube(-1.2,5.6,0,1.5,1.15,0.4,14,MET_L);                  // dorsal halo
  m.sphere(-1.2,5.6,0,0.7,8,ENERGY,0.8,false);               // core in the halo
  for(const k of [0,1,2]){                                    // three blade legs
    const a=k/3*TAU+Math.PI/6, cx=Math.cos(a), cz=Math.sin(a);
    m.wedge(cx*1.6,1.8,cz*1.6,0.5,2.2,0.9,MET_D,a);
    m.cyl(cx*2.3,0.2,cz*2.3,0.34,0.05,1.6,5,MET_L);          // blade tip
  }
  for(const sd of [-1,1])
    m.wedge(-2.6,4.0,sd*1.1,2.2,0.5,0.7,TEAM_A,sd*0.35,sd<0); // swept vanes
  thrusterBell(m,-3.4,3.9,0,0.5,1.2,MET_L);                  // rear lifter
  m.cyl(0.8,4.6,0,0.2,0.16,2.2,5,DARKER,Math.PI/2);          // underslung emitter
  m.cyl(3.0,4.6,0,0.3,0.14,0.5,6,ENERGY,Math.PI/2);
  return {hull:m.build(),tur:null,s:0.95};
}
function mdlSynIncinerator(){                // cybernetic — plasma scorcher drone
  const m=MB();
  m.extrude(0,3.2,0,[[-3.8,0],[-2.0,-2.0],[2.2,-2.2],[4.2,0],[2.2,2.2],[-2.0,2.0]],1.7,MET);
  m.extrude(-0.2,4.9,0,[[-2.8,0],[-1.4,-1.5],[1.6,-1.7],[3.1,0],[1.6,1.7],[-1.4,1.5]],0.8,TEAM_A);
  m.tube(0.2,5.8,0,1.8,1.4,0.5,14,MET_L);                    // containment ring
  m.sphere(0.2,5.8,0,0.9,9,HOT,0.8,false);                   // plasma core
  for(const sd of [-1,1]){
    m.wedge(-2.8,4.2,sd*1.3,2.6,0.6,0.8,MET_D,sd*0.3,sd<0);
    thrusterBell(m,-3.8,3.6,sd*0.9,0.42,1.0,MET_L);
  }
  m.cyl(3.4,4.0,0,0.5,0.24,1.6,7,MET_L,Math.PI/2);           // projector throat
  m.cyl(4.8,4.0,0,0.20,0.16,0.6,5,HOT,Math.PI/2);
  for(const k of [0,1,2]){
    const a=k/3*TAU+Math.PI/6, cx=Math.cos(a), cz=Math.sin(a);
    m.wedge(cx*1.7,1.7,cz*1.7,0.55,2.0,1.0,MET_D,a);
  }
  return {hull:m.build(),tur:null,s:1.0};
}
const FAC_KIT={
  nova:{1:mdlNovaRhino},
  legion:{0:mdlLegionTrooper,9:mdlLegionPyro,1:mdlLegionRhino},
  syndicate:{0:mdlSynStrider,9:mdlSynIncinerator,1:mdlSyndicateRhino,2:mdlSynTank,6:mdlSynTank},
  /* Every type an old save, factory, airfield, harbor or transit gate can place

     for the Brood resolves to grown tissue. There is deliberately no shared

     mechanical fallback hidden under an organic decoration layer.



     THIS TABLE IS NOW A FALLBACK, NOT THE ROSTER.

     It mapped 28 slots onto nine builders called with NO arguments, so twelve

     of them were not merely similar — mdlHordeSpitter served slots 1, 2, 7,

     10, 20 and 21 and mdlHordeBombardier served 3, 6, 16, 22, 26 and 27, each

     rendering ONE shared vertex buffer. A tier-1 line brawler and a tier-3

     siege caster were the same animal.

     Those twelve are now split into twelve builders in models-units-brood.js

     and registered in UNIT_MDL_BROOD, which mergeFactionUnitKits() copies over

     this table at init — so for slots 1,2,3,6,7,10,12,13,16,20,21,22,26,27 and

     30..32 the entry below never runs. They stay here on purpose: they are the

     only thing standing between a failed load of that file and the Brood

     fielding somebody else's tanks. Edit the split units THERE, not here; a

     forward reference to them from this literal would be a ReferenceError,

     because in dev the manifest loads each src file as its own script and this

     one executes first. */
  horde:{
    0:mdlHordeBeast,1:mdlHordeSpitter,2:mdlHordeSpitter,3:mdlHordeBombardier,
    4:mdlHordeLeviathan,5:mdlHordeFlyer,6:mdlHordeBombardier,7:mdlHordeSpitter,
    8:mdlHordeLeviathan,9:mdlHordeBeast,10:mdlHordeSpitter,11:mdlHordeSupport,
    12:mdlRavager,13:mdlAlphaRavager,14:mdlHordeSwimmer,15:mdlHordeSwimmer,
    16:mdlHordeBombardier,17:mdlHordeFlyer,18:mdlHordeLeviathan,19:mdlHordeSupport,
    20:mdlHordeSpitter,21:mdlHordeSpitter,22:mdlHordeBombardier,23:mdlHordeSupport,
    24:mdlHordeSupport,25:mdlHordeFlyer,26:mdlHordeBombardier,27:mdlHordeBombardier
  },
};
const FAC_MESH={};   // kit -> {type -> {hull,tur,...}}
/* A faction replacement cannot sensibly turn artillery, aircraft and support

   vehicles into the same hover tank or beetle.  These light doctrine shells

   sit over any role chassis that does NOT have a bespoke replacement: the role

   remains readable, while armour profile, propulsion language and biology make

   the owner readable too.  They are geometry (not a colour wash), because the

   user's complaint is still valid in greyscale and at minimap-adjacent zoom. */
function mdlNovaDoctrine(air){
  const m=MB();
  if(air){
    for(const sd of [-1,1]){
      m.box(-.4,.52,sd*4.45,10.2,.42,1.05,ENERGY,sd*.06);
      for(const x of [-3.0,.2,3.2]){
        m.ring(x,.78,sd*4.45,.62,1.08,12,ENERGY);
        m.sphere(x,.82,sd*4.45,.50,7,ENERGY,.74,false);
      }
      m.wedge(2.3,.68,sd*5.25,5.5,.38,1.25,TEAM_T,sd*.1,sd<0);
    }
    m.sphere(-2.8,1.28,0,1.25,9,ENERGY,1,false);
  }else{
    for(const sd of [-1,1]){
      m.box(-.3,2.45,sd*4.65,10.4,.50,1.24,ENERGY);
      for(const x of [-3.0,0,3.0]){
        m.ring(x,2.72,sd*4.65,.66,1.16,12,ENERGY);
        m.sphere(x,2.76,sd*4.65,.52,7,ENERGY,.76,false);
      }
      m.wedge(3.8,2.15,sd*5.0,3.8,.45,1.35,TEAM_T,0,sd<0);
    }
    m.ring(-2.9,5.1,0,1.28,2.12,16,ENERGY);
    m.sphere(-2.9,5.1,0,1.05,9,ENERGY,1,false);
  }
  return m.build();
}
function mdlLegionDoctrine(air){
  const m=MB();
  if(air){
    for(const sd of [-1,1]){
      m.wedge(-0.4,0.5,sd*5.0,8.8,0.75,2.2,TWR_ARM_D,0,sd<0);
      m.box(-0.6,1.28,sd*5.75,5.8,0.26,1.45,TEAM_A);
      m.bevelBox(-2.7,0.1,sd*3.3,2.9,1.7,2.0,.28,TWR_COAT);
      m.box(-4.2,1.82,sd*3.3,1.2,.22,.72,HOT);
    }
    m.wedge(3.8,0.45,0,4.4,1.0,3.0,TWR_ARM,0,false);
  }else{
    for(const sd of [-1,1]){
      m.bevelBox(-0.6,1.0,sd*5.2,10.8,2.5,1.35,.30,TWR_ARM_D);
      m.box(-0.2,3.55,sd*5.85,6.8,.24,1.55,TEAM_A);
      m.wedge(4.8,1.05,sd*5.2,2.8,2.35,1.35,TWR_ARM,0,sd<0);
      m.bevelBox(-4.9,3.2,sd*3.25,1.35,3.6,1.25,.24,TWR_COAT);
      m.box(-4.9,6.84,sd*3.25,.72,.28,.72,HOT);
    }
    m.bevelBox(-3.2,4.5,0,3.4,1.0,5.0,.22,TWR_ARM_D);
  }
  return m.build();
}
function mdlSyndicateDoctrine(air){
  const m=MB();
  if(air){
    for(const sd of [-1,1]){
      m.wedge(-0.5,0.35,sd*5.35,9.8,.52,2.0,TWR_COAT,sd*.10,sd<0);
      m.box(0,0.91,sd*6.15,5.6,.18,.72,TEAM_T);
      m.cyl(-2.7,.30,sd*4.35,.72,.62,.46,10,TWR_MACH);
      m.ring(-2.7,.78,sd*4.35,.76,1.08,12,ENERGY);
    }
    m.wedge(4.2,.4,0,4.8,.72,2.6,TWR_ARM,0,false);
  }else{
    /* The side plena hide the shared running gear at command zoom; exposed

       lift coils and a raked fork carry the Coalition's contact-sheet design. */
    for(const sd of [-1,1]){
      m.bevelBox(-.4,.18,sd*4.85,11.4,1.75,1.65,.34,TWR_COAT);
      m.box(-.2,1.96,sd*5.05,7.2,.20,1.24,TEAM_T);
      for(const x of [-3.6,0,3.6]){
        m.cyl(x,.16,sd*5.0,.62,.56,.48,10,TWR_MACH);
        m.ring(x,.66,sd*5.0,.68,1.02,12,ENERGY);
      }
      m.wedge(4.9,1.1,sd*4.7,3.1,2.1,1.5,TWR_ARM,0,sd<0);
    }
    m.ring(-2.7,3.8,0,1.2,2.05,16,ENERGY);
    m.box(-2.7,3.75,0,4.8,.22,.62,TEAM_T);
  }
  return m.build();
}
const FAC_DOCTRINE_MDL={
  nova:{ground:()=>mdlNovaDoctrine(false),air:()=>mdlNovaDoctrine(true)},
  legion:{ground:()=>mdlLegionDoctrine(false),air:()=>mdlLegionDoctrine(true)},
  syndicate:{ground:()=>mdlSyndicateDoctrine(false),air:()=>mdlSyndicateDoctrine(true)},
};
const FAC_DOCTRINE_MESH={};
/* THE FACTION KITS WERE THREE UNITS DEEP.

   Buildings were 27/27 for every army, but FAC_KIT — the UNIT overrides — held

   three entries for the Dominion and five for the Coalition against a 33-slot

   roster. Every other chassis fell through to the Nova hull with a thin

   doctrine shell over it, which is exactly what "still using the blue faction's

   models" looks like from the outside. The per-faction unit kits live in their

   own files and are merged here rather than at their own top level, because

   FAC_KIT is declared in this file and they load after it. */
function mergeFactionUnitKits(){
  const add=(kit,map)=>{ if(!map||!FAC_KIT[kit]) return 0;
    let n=0; for(const k in map){ FAC_KIT[kit][k]=map[k]; n++; } return n; };
  const n=[
    add('legion',   typeof UNIT_MDL_LEGION   !=='undefined'?UNIT_MDL_LEGION   :null),
    add('syndicate',typeof UNIT_MDL_SYNDICATE!=='undefined'?UNIT_MDL_SYNDICATE:null),
    add('nova',     typeof UNIT_MDL_NOVA     !=='undefined'?UNIT_MDL_NOVA     :null),
    add('horde',    typeof UNIT_MDL_BROOD    !=='undefined'?UNIT_MDL_BROOD    :null)
  ];
  return n;
}
/* The four kits keep their bespoke packs in their own tables; this is the only

   place that needs to read across all four, so it asks rather than importing a

   registry that does not exist. Asset maps are a bounded visual pilot, not a

   switch that turns every generated template into live battle art. A pack must

   opt in with a named token before the query may unwrap and reupload its mesh.

   That keeps an unfinished map set from silently changing a whole faction. */
function mfPackMaps(kit,slot){
  try{
    const T=kit==='nova'?(typeof TFC_NOVA_BESPOKE_PACKS!=='undefined'&&TFC_NOVA_BESPOKE_PACKS)
      :kit==='legion'?(typeof DOM_LEGION_BESPOKE_PACKS!=='undefined'&&DOM_LEGION_BESPOKE_PACKS)
      :kit==='horde'?(typeof BRD_BESPOKE_PACKS!=='undefined'&&BRD_BESPOKE_PACKS)
      :(typeof COA_SYN_BESPOKE_PACKS!=='undefined'&&COA_SYN_BESPOKE_PACKS);
    const p=T&&T[slot];
    if(!p||!p.maps||!p.assetSkin) return null;
    const q=new URLSearchParams(location.search).get('assetskin');
    return (q==='1'||q===p.assetSkin)?p.maps:null;
  }catch(e){ return null; }
}
function initFactionKits(){
  mergeFactionUnitKits();
  for(const k in FAC_KIT){
    FAC_MESH[k]={};
    const cache={};
    for(const ty in FAC_KIT[k]){
      const fn=FAC_KIT[k][ty];
      if(!cache[fn.name]){
        const g=fn();
        cache[fn.name]={hull:new InstMesh(gl,g.hull,900), tur:g.tur?new InstMesh(gl,g.tur,900):null,
                        s:g.s||1, turH:g.turH||0, muzzle:g.muzzle||0, muzzleZ:g.muzzleZ||0};
        /* Per-asset baked maps, when this slot declares a triplet AND the flag

           is on. Async and self-cancelling: if any of the three fails to decode

           the mesh simply stays on the shared atlas, which is why this can be

           attempted for any pack without checking what exists on disk. */
        if(typeof mfAssetSkinEnabled==='function'&&mfAssetSkinEnabled()){
          const maps=(typeof mfPackMaps==='function')?mfPackMaps(k,ty):null;
          if(maps&&typeof mfAssetSkin==='function') mfAssetSkin(gl,cache[fn.name].hull,maps);
        }
      }
      FAC_MESH[k][ty]=cache[fn.name];
    }
  }
  for(const k in FAC_DOCTRINE_MDL){
    FAC_DOCTRINE_MESH[k]={
      ground:new InstMesh(gl,FAC_DOCTRINE_MDL[k].ground(),1600),
      air:new InstMesh(gl,FAC_DOCTRINE_MDL[k].air(),800)
    };
  }
}

function mdlConstructor(){                   // 19 — engineer
  const m=MB();
  /* The engineer is the only unarmed thing the player drives around a battle,

     so it has to look like PLANT — a works vehicle — rather than an unarmed

     tank. Four bare wheels under a bevelled box was not carrying that: no

     suspension, no bed, no load, and the "arm" was a stick with a ball on it.

     Rebuilt around what a builder actually is: a flat load bed with cargo

     strapped to it, a proper wheeled chassis with hubs and arches, and a

     two-stage telescopic boom with a fabricator head at the end. */
  m.bevelBox(0,1.9,0,8.2,2.4,5.2,0.45,MET);                    // chassis rail
  m.wedge(3.6,4.3,0,2.6,1.0,4.6,MET_L);                        // sloped nose
  /* LOAD BED: a recessed inner extrusion with a lip, which is what makes a

     flatbed read as a bed rather than as the top of a box. */
  const BB=[[-4.0,-2.4],[1.2,-2.4],[1.2,2.4],[-4.0,2.4]];
  m.extrude(0,4.3,0,BB,0.35,MET_D);
  m.extrude(0,4.65,0,BB.map(q=>[q[0]*0.90,q[1]*0.84]),0.22,DARKER);
  for(const sd of [-1,1]) m.box(-1.4,4.65,sd*2.3,5.2,0.55,0.22,MET_L);   // bed rails

  for(const sd of [-1,1]){
    for(const fx of [2.5,-2.5]){
      m.cyl(fx,1.0,sd*3.0,1.55,1.55,1.5,10,RUBBER,Math.PI/2);  // wheel
      m.cyl(fx,1.0,sd*3.5,0.62,0.62,0.5,8,MET_L,Math.PI/2);    // hub
      hydraulic(m,fx,2.2,sd*2.6,1.1,0.22,MET_D,0);             // suspension
      m.wedge(fx,3.3,sd*2.9,3.4,0.9,1.5,MET_D);                // wheel arch
    }
    m.bevelBox(0.6,4.9,sd*2.0,3.0,1.1,0.9,0.22,TEAM_A);        // side livery
  }

  /* TELESCOPIC BOOM: shoulder, lower stage, upper stage stepped in, then the

     fabricator head. The step is what says telescopic. */
  m.bevelBox(1.7,4.7,0,2.0,2.0,2.2,0.32,MET_D);                // turntable
  m.cyl(1.7,6.7,0,0.90,0.80,0.6,10,MET_L);
  m.box(2.5,7.0,0,3.0,0.85,0.85,MET_L,0.34);                   // lower stage
  m.box(4.4,8.0,0,3.0,0.62,0.62,MET_D,0.34);                   // upper stage
  m.bevelBox(6.2,8.8,0,1.3,1.0,1.1,0.24,MET_D);                // head housing
  m.cyl(6.9,8.8,0,0.85,0.42,0.9,10,ENERGY,Math.PI/2);          // fabricator emitter
  hydraulic(m,2.4,5.5,0,2.6,0.28,MET_L,0);

  /* Cargo actually strapped to the bed, and a rotating beacon — the two things

     that read "works vehicle" from any angle. */
  kitBox(m,-2.4,4.87,0.9,2.2,1.3,2.6,MET_D,0);
  kitBox(m,-3.4,4.87,-1.4,1.5,0.9,1.6,RUST,0.3);
  stowage(m,-0.4,4.87,-1.8,2.4,1.0,RUST,0,41);
  m.cyl(-3.9,4.9,1.9,0.26,0.20,1.9,6,DARKER);
  m.cyl(-3.9,6.8,1.9,0.40,0.34,0.42,8,LAMP);                   // beacon
  glowStrip(m,-1.2,4.92,0,3.8,ENERGY,0);
  deckCrown(m,-1.0,4.88,0,7.0,5.2,MET_D,TEAM_T);
  return {hull:m.build(),tur:null,s:1.0};
}
const UNIT_MDL=[mdlStriker,mdlRhino,mdlGoliath,mdlThumper,mdlCommander,mdlWasp,mdlLongbow,
  mdlHornet,mdlTitan,mdlPyro,mdlVulture,mdlBulwark,mdlRavager,mdlAlphaRavager,mdlCorvette,
  mdlDread,mdlBombard,mdlRaptor,mdlScorcher,mdlConstructor,
  /* second wave — indices 20..27 */
  mdlReaper,mdlCinder,mdlLancer,mdlResonator,mdlWarden,mdlKestrel,mdlBasilisk,mdlHarbinger,
  /* faction heroes — 28..30 */
  mdlPraetor,mdlArchon,mdlBroodmother];

/* WHAT A MODEL IS MADE OF, answered by the model tables themselves.

   Salvage needs to know whether the thing that just died was grown or built,

   and the only honest source is the SAME resolution the renderer uses:

   kit override first, base roster second. Keeping this here - beside FAC_KIT

   and UNIT_MDL - means editing a faction's kit automatically updates what its

   dead drop; a separate list in sim.js would drift the first time a slot was

   reassigned, and the failure (a strider drone bleeding, a rifleman shedding

   plate) would be invisible until someone happened to reclaim the wrong pile. */
const HUMAN_MDL=new Set([
  mdlStriker,mdlPyro,                        // the base humans (Nova fields them)
  mdlLegionTrooper,mdlLegionPyro,            // Dominion siege infantry - heavier, still people
]);
const ORGANIC_MDL=new Set([
  ...HUMAN_MDL,
  mdlRavager,mdlAlphaRavager,mdlBroodmother, // wildlife and the Sovereign
  mdlHordeBeast,mdlHordeSpitter,mdlHordeBombardier,mdlHordeLeviathan,
  mdlHordeFlyer,mdlHordeSupport,mdlHordeSwimmer,
]);
function unitModelOrganic(kit,type){
  const fn=(FAC_KIT[kit]&&FAC_KIT[kit][type])||UNIT_MDL[type];
  return ORGANIC_MDL.has(fn)?1:0;
}
/* A person, specifically - the distinction dropRemains needs: fallen soldiers

   leave no salvage pile at all, while a grown warbeast of any size renders

   into biomass. */
function unitModelHuman(kit,type){
  const fn=(FAC_KIT[kit]&&FAC_KIT[kit][type])||UNIT_MDL[type];
  return HUMAN_MDL.has(fn)?1:0;
}

/* ---------------------------------------------------------------------------

   BUILDINGS — authored to their real footprint so they sit inside the square

   build plates rather than floating on top of them.

   --------------------------------------------------------------------------- */
const BLD_GEO={}, BLD_MESH={}, BLD_FACTION_MESH={};
/* Shared tower foundations. Contact-sheet structures need a common construction

   language without becoming palette-swapped copies: this handles only the

   footprint, bearing reveal and sparse status strips. Each weapon/function

   still owns its silhouette above the bearing. */
function towerOct(r){
  return [[-r*.55,-r],[r*.55,-r],[r,-r*.55],[r,r*.55],
          [r*.55,r],[-r*.55,r],[-r,r*.55],[-r,-r*.55]];
}
function towerPad(m,r,tier,bearing){
  tier=tier||1;
  m.extrude(0,0,0,towerOct(r),3,TWR_PAD);
  m.extrude(0,3,0,towerOct(r*.86),5,TWR_ARM_D);
  m.extrude(0,8,0,towerOct(r*.70),3,TWR_ARM);
  for(const s of [-1,1]){
    m.bevelBox(s*r*.68,3,0,r*.22,4.4,r*.44,.5,TWR_COAT);
    m.box(s*r*.68,7.4,0,r*.08,.22,r*.24,s>0?TWR_GLOW:TWR_TEAM);
  }
  if(tier>=2) for(const s of [-1,1]){
    m.bevelBox(0,5,s*r*.72,r*.42,3.4,r*.18,.4,TWR_ARM_D);
    m.box(0,8.4,s*r*.72,r*.24,.22,r*.06,TWR_GLOW);
  }
  if(tier>=3) for(const a of [0,Math.PI/2,Math.PI,Math.PI*1.5]){
    const x=Math.cos(a)*r*.69,z=Math.sin(a)*r*.69;
    m.cyl(x,8,z,r*.075,r*.06,2.8,8,TWR_MACH);
  }
  if(bearing){
    m.cyl(0,10.7,0,r*.52,r*.52,1.0,16,TWR_COAT);
    m.cyl(0,11.7,0,r*.44,r*.40,.8,16,TWR_TRIM);
  }
  return m;
}
/* Nova economy/production architecture uses the same quiet physical finishes

   as the rebuilt defense kit, but not its octagonal weapon silhouette.  A

   shallow bevel, dark reveal and sparse pair of status rails make each model

   feel planted and give baked AO somewhere useful to collect.  Keeping this

   shared layer restrained is important: function-specific machinery above it

   should identify a building before colour or surface noise does. */
function novaServicePad(m,w,d,h,quiet){
  h=h||2.4;
  m.bevelBox(0,0,0,w,h,d,Math.min(1.35,w*.04,d*.04),TWR_PAD);
  m.bevelBox(0,h,0,w-2.2,1.0,d-2.2,.45,NOVA_DECK);
  /* Status rails must stay short. w*.30 on the Command HQ (87) wrote a

     26-unit TWR_GLOW bar — the glowing artifact, not a lamp. HQ passes

     quiet so restoring TWR_GLOW points cannot revive that rail. */
  const mark=quiet?TWR_TRIM:TWR_TEAM;
  m.box(0,h+.98,-d*.43,Math.min(w*.30,8.0),.20,.34,mark);
  m.box(0,h+.98, d*.43,Math.min(w*.18,6.2),.20,.34,quiet?TWR_TRIM:TWR_GLOW);
  return h+1.0;
}
function mdlMex(){
  const m=MB();
  const y=novaServicePad(m,33,33,2.6,true);
  /* A four-way ore intake is legible from any camera facing.  The old derrick

     was four identical thin posts around a box, so command view reduced it to

     visual grit and never communicated extraction. */
  m.cyl(0,y,0,9.4,8.2,4.0,12,NOVA_MEX_CORE);
  m.cyl(0,y+4.0,0,7.5,6.0,3.0,12,NOVA_MEX_ARM);
  m.cyl(0,y+7.0,0,4.2,3.5,12.0,12,NOVA_MEX_CORE);
  m.tube(0,y+18.8,0,3.6,2.0,1.3,12,TWR_BORE);
  for(let k=0;k<4;k++){
    const a=k/4*TAU,x=Math.cos(a)*11.2,z=Math.sin(a)*11.2;
    m.bevelBox(x,y+.2,z,9.2,4.2,6.0,.75,NOVA_MEX_CORE,a);
    m.cyl(x,y+4.4,z,2.6,2.1,3.0,10,NOVA_MEX_TRIM);
    m.box(x,y+7.3,z,2.3,.24,2.3,NOVA_MEX_CORE,a);
    m.box(Math.cos(a)*6.7,y+2.7,Math.sin(a)*6.7,8.2,1.2,1.6,NOVA_MEX_ARM,a);
  }
  ringX(m,0,y+12.2,0,4.3,5.1,14,NOVA_MEX_TRIM);
  /* A 1.15 emissive.light sphere sat past the 0.936 bloom thresh and became

     the white disc on every occupied node after deposit sprites were cut. */
  m.sphere(0,y+13.0,0,1.15,8,NOVA_MEX_CORE,1,false);
  return m.build();
}
function mdlPgen(){
  const m=MB();
  const y=novaServicePad(m,37,29,2.5);
  /* Twin shielded reactor cans and one exposed capacitor give this a broad,

     low energy-plant silhouette without repeating access panels on every

     face.  Material changes, not tiny geometry, carry the PBR detail. */
  for(const s of [-1,1]){
    m.cyl(s*6.6,y,0,5.6,5.2,12.0,12,NOVA_REACTOR_CORE);
    m.cyl(s*6.6,y+12.0,0,5.25,4.3,2.2,12,NOVA_REACTOR_ARM);
    m.cyl(s*6.6,y+4.8,0,5.75,5.75,.8,12,NOVA_REACTOR_TRIM);
    m.box(s*6.6,y+9.0,-5.25,5.6,1.0,.38,s<0?NOVA_REACTOR_ARM:NOVA_REACTOR_GLOW);
  }
  m.cyl(0,y+2.0,0,3.2,2.5,15.0,12,NOVA_REACTOR_CORE);
  m.sphere(0,y+17.5,0,3.2,10,NOVA_REACTOR_GLOW,1,false);
  ringX(m,0,y+17.5,0,4.1,4.8,14,NOVA_REACTOR_TRIM);
  for(const s of [-1,1]){
    m.bevelBox(s*15.0,y,0,4.6,8.0,18.0,.7,NOVA_REACTOR_CORE);
    /* Keep the long radiator axis on Z. Rotating this bank made its 13-unit

       depth become width and silently overhang the 38-unit build plot. */
    ventBank(m,s*15.0,y+8.0,0,3.0,13.0,4,TWR_MACH,0);
  }
  return m.build();
}
function mdlFac(){
  const m=MB();
  const y=novaServicePad(m,63,49,3.0);
  /* The production lane is a single large read: calm shed, dark open bay and

     a control tower.  Roof panels and two vent cassettes replace the old

     saw-tooth/greeble field, cutting both noise and vertices. */
  m.bevelBox(-7.0,y,0,43.0,17.0,42.0,2.2,NOVA_FACTORY_ARM);
  m.bevelBox(-7.0,y+17.0,0,40.0,2.0,39.0,.8,NOVA_FACTORY_ROOF);
  roofEdge(m,-7.0,y+19.0,0,40.0,39.0,1.0,NOVA_FACTORY_CORE,NOVA_FACTORY_ROOF);
  for(const s of [-1,1]){
    m.bevelBox(-7.0,y+20.8,s*10.0,15.0,2.7,8.0,.6,NOVA_FACTORY_CORE);
    ventBank(m,-7.0,y+23.5,s*10.0,10.5,5.5,4,TWR_MACH,0);
  }
  /* Deep assembly opening on +X, framed by blue identification and guide

     lights.  The dark surface is deliberately behind the wall plane. */
  m.box(14.55,y+2.0,0,.7,12.5,22.0,TWR_BORE);
  for(const s of [-1,1]){
    m.bevelBox(15.3,y+1.0,s*12.0,2.6,15.0,3.2,.45,NOVA_FACTORY_CORE);
    m.box(15.8,y+6.0,s*10.15,.35,7.5,.35,TWR_GLOW);
  }
  m.bevelBox(15.3,y+13.5,0,2.6,3.2,27.0,.5,NOVA_FACTORY_ARM);
  m.box(15.8,y+16.4,0,.35,.26,16.0,TWR_TEAM);
  /* Offset command/assembly tower keeps the footprint directional. */
  m.bevelBox(23.0,y,0,15.0,24.0,28.0,1.6,NOVA_FACTORY_CORE);
  m.bevelBox(23.0,y+24.0,0,16.5,2.0,29.5,.7,NOVA_FACTORY_ROOF);
  for(const s of [-1,1]) m.box(23.0,y+15.0,s*14.1,10.0,5.0,.55,NOVA_FACTORY_GLASS);
  m.box(15.45,y+15.0,0,.5,5.0,20.0,NOVA_FACTORY_GLASS);
  sensorMast(m,25.0,y+26.0,-8.5,7.0,TWR_MACH);
  for(const s of [-1,1]) exhaust(m,-25.5,y+15.0,s*13.0,1,1.4,10.0,TWR_MACH,2.0);
  return m.build();
}
function mdlTurretBase(tier){
  const m=MB();
  tier=tier||1;
  const oct=r=>[[-r*.55,-r],[r*.55,-r],[r,-r*.55],[r,r*.55],
                 [r*.55,r],[-r*.55,r],[-r,r*.55],[-r,-r*.55]];
  m.extrude(0,0,0,oct(13),3,NOVA_SENTINEL_CORE);            // quiet coated foundation
  m.extrude(0,3,0,oct(11.4),6,NOVA_SENTINEL_CORE);           // armoured lower plinth
  m.extrude(0,9,0,oct(9.7),3,NOVA_SENTINEL_ARM);             // recessed upper tier
  for(const sx of [-1,1]) for(const sz of [-1,1]){
    m.bevelBox(sx*9.3,3,sz*9.3,4.2,4.6,4.2,.65,NOVA_SENTINEL_CORE); // anchor housings
    m.cyl(sx*9.3,7.72,sz*9.3,.28,.28,.22,8,HQ_LAMP);
  }
  for(const s of [-1,1]){
    m.box(0,11.75,s*8.5,7.4,.25,.42,TWR_TEAM);              // sparse faction livery
    m.box(s*8.5,11.75,0,.42,.25,7.4,NOVA_SENTINEL_GLOW);    // mount status guides
  }
  if(tier>=2) for(const s of [-1,1]){
    m.bevelBox(s*10.1,7.0,0,3.3,3.6,7.4,.45,NOVA_SENTINEL_CORE); // Mk2 side power pods
    m.box(s*10.1,10.6,0,1.1,.22,4.5,NOVA_SENTINEL_GLOW);
  }
  if(tier>=3) for(const s of [-1,1]){
    m.cyl(0,8.8,s*9.7,1.75,1.45,3.1,10,NOVA_SENTINEL_TRIM); // Mk3 reserve capacitors
    m.box(0,11.75,s*9.7,2.3,.24,.8,TWR_GLOW);
  }
  m.cyl(0,12,0,8.25,8.25,1.15,16,NOVA_SENTINEL_CORE);       // azimuth shadow gap
  m.cyl(0,13.15,0,7.15,6.65,.85,16,NOVA_SENTINEL_TRIM);     // y=14 bearing surface
  return m.build();
}
function mdlTurretGun(tier){
  const m=MB();
  tier=tier||1;
  m.cyl(0,0,0,6.5,6.1,2.7,16,NOVA_SENTINEL_TRIM);           // rotating race
  m.cyl(0,2.7,0,5.9,5.4,1.0,16,NOVA_SENTINEL_TRIM);
  m.bevelBox(-1.4,3.4,0,13.8,6.2,11.4,1.05,NOVA_SENTINEL_CORE); // receiver
  m.bevelBox(-2.6,9.6,0,6.4,1.7,5.8,.52,NOVA_SENTINEL_ARM);  // quiet armour roof
  m.box(-2.6,11.3,0,1.35,.18,4.2,TWR_TEAM);                 // narrow livery inset
  m.bevelBox(-7.1,4.2,0,4.8,5.4,9.2,.75,NOVA_SENTINEL_CORE); // capacitor bustle
  for(const s of [-1,1]){
    m.bevelBox(-3.3,5.0,s*6.15,5.8,3.2,1.65,.35,TWR_COAT);   // cooling cheeks
    m.box(-3.3,8.2,s*6.2,3.5,.26,1.75,NOVA_SENTINEL_GLOW);
    m.cyl(2.2,2.8,s*4.4,.66,.5,4.6,9,NOVA_SENTINEL_TRIM);    // elevation rams
    m.box(8.6,6.9,s*2.55,4.8,1.45,1.0,NOVA_SENTINEL_CORE);   // compact barrel braces
    m.box(8.5,9.35,s*1.45,3.8,.28,.36,NOVA_SENTINEL_GLOW);   // short recoil guides
  }
  m.bevelBox(4.35,4.8,0,4.5,6.0,8.0,.75,NOVA_SENTINEL_ARM); // mantlet
  cylX(m,4.6,8.0,0,10.7,1.30,1.02,12,NOVA_SENTINEL_TRIM,false);
  for(const x of [6.2,9.2,12.2]) cylX(m,x,8.0,0,.75,1.68,1.68,12,NOVA_SENTINEL_TRIM);
  m.bevelBox(15.2,6.0,0,3.15,4.0,4.8,.52,NOVA_SENTINEL_CORE); // muzzle shroud
  tubeX(m,15.9,8.0,0,1.15,1.58,.80,12,TWR_BORE);            // bore ends at x=17.05
  m.cyl(-5.7,7.55,4.7,.22,.22,.28,8,HQ_LAMP);               // service indicator
  if(tier>=2) for(const s of [-1,1]){
    m.bevelBox(-7.4,7.2,s*5.0,4.2,3.8,1.25,.34,TWR_ARM);    // Mk2 capacitor cassettes
    m.box(-7.4,10.8,s*5.05,2.5,.25,1.35,TWR_GLOW);
  }
  if(tier>=3){
    m.bevelBox(-8.0,10.2,0,4.8,3.3,7.2,.55,TWR_COAT);        // Mk3 reactor crown
    m.box(-8.0,13.35,0,1.2,.24,3.6,TWR_TEAM);
    for(const s of [-1,1]){
      m.box(11.0,10.5,s*3.15,8.0,.72,.76,TWR_ARM_D);         // heavy outer accelerator rails
      m.box(11.0,11.24,s*3.15,5.4,.20,.34,TWR_GLOW);
    }
  }
  return m.build();
}
function mdlBunkerBase(tier){
  const m=MB(); tier=tier||1;
  towerPad(m,20,tier,false);
  /* Low, broad casemate: the armor is calm and the dark mechanism is confined

     to service recesses instead of coating the entire structure. */
  m.extrude(0,11,0,[[-15,-14],[12,-14],[17,-8],[17,8],[12,14],[-15,14],[-18,0]],5,NOVA_BUNKER_ARM);
  for(const s of [-1,1]){
    m.bevelBox(-11,11,s*14.2,8.5,5.0,2.3,.45,NOVA_BUNKER_CORE);
    m.box(-11,15.8,s*14.4,5.3,.25,2.45,s>0?TWR_TEAM:TWR_GLOW);
    m.bevelBox(11,11,s*12.7,6.0,4.2,5.0,.65,NOVA_BUNKER_CORE);
  }
  ventBank(m,-15.4,15.9,0,1.0,13,5,TWR_MACH,Math.PI/2);
  if(tier>=2) for(const s of [-1,1]){
    m.bevelBox(-2,15.8,s*11.2,10,2.0,3.2,.45,TWR_ARM_D);
    m.box(-2,17.7,s*11.25,6.5,.24,1.1,NOVA_BUNKER_GLOW);
  }
  if(tier>=3){
    m.bevelBox(-12,16,0,5.5,4.3,11,.6,NOVA_BUNKER_CORE);
    m.box(-12,20.1,0,1.2,.22,6.4,TWR_TEAM);
  }
  m.cyl(0,16,0,9.2,9.2,1.1,16,NOVA_BUNKER_CORE);
  m.cyl(0,17.1,0,8.0,7.4,.9,16,NOVA_BUNKER_TRIM);   // y=18 turret bearing
  return m.build();
}
function mdlBunkerGun(tier){
  const m=MB(); tier=tier||1;
  m.cyl(0,0,0,7.4,6.9,2.6,16,NOVA_BUNKER_TRIM);
  m.bevelBox(-1.4,2.6,0,15.5,6.5,14.2,1.1,NOVA_BUNKER_CORE);
  m.bevelBox(-5.8,4.3,0,6.5,5.2,11.8,.8,NOVA_BUNKER_CORE);
  m.bevelBox(-1.4,9.1,0,7.8,1.8,8.2,.5,NOVA_BUNKER_ARM);
  m.box(-1.4,10.85,0,1.4,.18,5.2,TWR_TEAM);
  for(const s of [-1,1]){
    m.bevelBox(5.0,5.0,s*3.35,5.8,4.2,2.2,.45,NOVA_BUNKER_ARM);
    gunX(m,6.8,7.1,14.8,.78,NOVA_BUNKER_TRIM,s*3.35); // twin recessed cannon bores
    m.box(-3.6,7.6,s*7.5,5.4,2.6,1.3,NOVA_BUNKER_CORE);
    m.box(-3.6,10.1,s*7.55,3.0,.22,1.4,NOVA_BUNKER_GLOW);
  }
  if(tier>=2) for(const s of [-1,1]){
    m.bevelBox(-8.0,7.0,s*5.6,4.0,3.2,2.0,.4,TWR_ARM);
    m.box(-8.0,10.1,s*5.65,2.2,.20,2.1,TWR_GLOW);
  }
  if(tier>=3){
    m.bevelBox(-7.0,9.4,0,5.0,3.0,8.5,.5,TWR_COAT);
    sensorMast(m,-8.0,12.4,0,4.5,TWR_MACH);
  }
  return m.build();
}
function mdlRailBase(tier){
  const m=MB(); tier=tier||1;
  const oct=r=>[[-r*.55,-r],[r*.55,-r],[r,-r*.55],[r,r*.55],
                 [r*.55,r],[-r*.55,r],[-r,r*.55],[-r,-r*.55]];
  m.extrude(0,0,0,oct(21),4,NOVA_RAIL_CORE);                  // compact quiet foundation
  m.extrude(0,4,0,oct(18.2),8,NOVA_RAIL_CORE);                // heavy lower armour
  m.extrude(0,12,0,oct(15.2),5,NOVA_RAIL_ARM);                // inset second tier
  for(let k=0;k<4;k++){
    const a=k/4*TAU, x=Math.cos(a)*15.6, z=Math.sin(a)*15.6;
    m.bevelBox(x,4,z,7.2,7.6,9.2,.75,NOVA_RAIL_CORE);         // radial capacitor pod
    m.cyl(x,11.6,z,2.4,1.9,3.2,10,NOVA_RAIL_TRIM);
    m.box(x,14.6,z,3.2,.28,1.0,k%2?NOVA_RAIL_GLOW:TWR_TEAM,a);// restrained status strip
  }
  for(const s of [-1,1]){
    m.box(0,16.7,s*11.8,10,.26,.46,TWR_TEAM);
    m.box(s*11.8,16.7,0,.46,.26,10,NOVA_RAIL_GLOW);
  }
  m.cyl(0,17,0,12.5,12.5,2.0,18,NOVA_RAIL_CORE);             // recessed rotation race
  m.cyl(0,19,0,11.0,9.7,2.0,18,NOVA_RAIL_TRIM);
  if(tier>=2) for(const s of [-1,1]) m.cyl(s*16.4,4,0,2.15,1.75,8.0,10,NOVA_RAIL_TRIM);
  if(tier>=3) m.box(0,16.9,0,14,.22,.5,TWR_TEAM);
  m.cyl(0,21,0,9.8,9.0,1.0,18,NOVA_RAIL_TRIM);                // y=22 bearing surface
  return m.build();
}
function mdlRailGun(tier){
  const m=MB();
  m.cyl(0,0,0,8.7,8.0,3.2,18,NOVA_RAIL_TRIM);                // azimuth drum
  m.cyl(0,3.2,0,7.7,7.1,1.2,18,NOVA_RAIL_TRIM);
  m.bevelBox(-2.4,4.0,0,18.0,8.0,15.6,1.35,NOVA_RAIL_CORE);  // armoured receiver
  m.bevelBox(-4.2,12.0,0,7.2,2.2,8.4,.62,NOVA_RAIL_ARM);     // quiet armour roof
  m.box(-4.2,14.2,0,1.55,.18,5.8,TWR_TEAM);                  // narrow livery inset
  m.bevelBox(-10.0,4.7,0,5.8,7.0,12.8,.9,NOVA_RAIL_CORE);    // reactor bustle
  for(const s of [-1,1]){
    m.bevelBox(-8.2,7.0,s*7.15,4.8,4.2,1.9,.4,TWR_ARM);      // capacitor cheeks
    m.box(-8.2,10.4,s*7.2,2.9,.30,2.0,NOVA_RAIL_GLOW);
    m.cyl(1.2,3.0,s*6.2,.82,.58,5.4,10,NOVA_RAIL_TRIM);       // elevation pistons
    m.bevelBox(13.2,7.55,s*2.9,20.0,2.8,1.85,.38,NOVA_RAIL_TRIM); // twin accelerator rails
  }
  m.bevelBox(4.5,5.7,0,5.4,6.8,10.2,.85,NOVA_RAIL_ARM);     // reinforced mantlet
  cylX(m,4.0,9.0,0,19.1,1.48,1.12,14,NOVA_RAIL_TRIM,false); // open central penetrator
  for(const x of [6.8,12.5,18.2]){
    m.bevelBox(x,6.45,0,1.35,5.15,8.5,.34,TWR_ARM_D);        // heavy barrel braces
    cylX(m,x-.32,9.0,0,.65,2.12,2.12,14,NOVA_RAIL_GLOW);     // energized coil faces
  }
  for(const s of [-1,1]) m.box(13.2,10.85,s*1.45,17.4,.30,.38,NOVA_RAIL_GLOW);
  m.bevelBox(23.15,6.35,0,3.0,5.3,8.1,.55,NOVA_RAIL_CORE);   // rectangular muzzle casing
  tubeX(m,23.1,9.0,0,1.72,2.38,1.02,14,TWR_BORE);           // bore ends at x=24.82
  m.cyl(-10.8,12.3,4.8,.22,.22,.28,8,HQ_LAMP);
  if((tier||1)>=2) for(const s of [-1,1]) m.box(-8.2,12.0,s*7.2,2.2,.24,1.6,TWR_GLOW);
  if((tier||1)>=3) cylX(m,4.0,6.4,0,17.0,.7,.5,10,NOVA_RAIL_GLOW,false);
  return m.build();
}
function mdlSgen(tier){
  const m=MB(); tier=tier||1;
  towerPad(m,16,tier,false);
  m.cyl(0,11,0,8.8,7.2,7.0,14,TWR_ARM);
  m.cyl(0,18,0,6.9,5.5,3.0,14,TWR_MACH);
  for(let k=0;k<4;k++){
    const a=k/4*TAU+Math.PI/4,x=Math.cos(a)*10.8,z=Math.sin(a)*10.8;
    m.bevelBox(x,10.0,z,4.2,7.5,4.2,.6,TWR_COAT,a);
    m.cyl(x,17.5,z,1.35,.85,9.0+(tier-1)*1.5,8,TWR_MACH);
    m.box(x,25.6+(tier-1)*1.5,z,1.2,.26,1.2,TWR_GLOW,a);
  }
  m.sphere(0,21.0,0,5.3+(tier-1)*.55,12,TWR_GLOW,.9,false);
  ringX(m,0,21.0,0,7.0+(tier-1)*1.1,8.3+(tier-1)*1.1,18,TWR_TRIM);
  if(tier>=2) ringX(m,0,21.0,0,9.2,9.8,18,TWR_GLOW);
  if(tier>=3){
    m.cyl(0,27.5,0,1.2,.6,6.5,8,TWR_MACH);
    m.sphere(0,34.0,0,1.8,9,TWR_GLOW,1,false);
  }
  m.box(0,18.4,7.2,5.5,.24,.8,TWR_TEAM);
  return m.build();
}
function mdlTgate(){
  const m=MB();
  m.box(0,0,0,72,5,60,CONC_D);
  for(const s of [-1,1]){                                      // gantry arches
    m.box(0,5,s*24,60,6,10,MET);
    m.box(-26,11,s*24,8,30,10,MET_D);
    m.box(26,11,s*24,8,30,10,MET_D);
  }
  m.box(0,41,0,66,7,58,MET);                                   // overhead crane deck
  m.box(0,5,0,44,3,34,DARKER);                                 // build pad
  m.cyl(0,8,0,16,15,4,14,ENERGY);
  for(const s of [-1,1]) m.cyl(s*30,53.15,0,.36,.36,.28,8,HQ_LAMP);
  /* A single identification rail on each crane face is enough for ownership

     at command zoom; colouring the whole gantry would bury its steel finish. */
  for(const s of [-1,1]) m.box(0,46.8,s*28.8,34,.28,.36,TWR_TEAM);
  return m.build();
}
function mdlNest(){
  /* Nest is Brood-owned at runtime (bldFactionKey forces horde). This Nova

     fallback used to be a chitin mound — the exact cross-faction leak the

     kit resolver exists to prevent if a preview or old save ever asks the

     Frontline catalogue for `nest`. A containment bunker keeps the slot

     readable as Nova without growing tissue. */
  const m=MB();
  const y=novaServicePad(m,41,35,2.4);
  m.bevelBox(0,y,0,28.0,8.5,24.0,1.4,NOVA_BUNKER_ARM);
  m.bevelBox(0,y+8.5,0,24.0,1.6,20.0,.55,NOVA_BUNKER_TRIM);
  roofEdge(m,0,y+10.1,0,24.0,20.0,.7,NOVA_BUNKER_CORE,TWR_TRIM);
  m.cyl(0,y+10.1,0,7.2,6.0,6.5,12,NOVA_BUNKER_CORE);
  m.cyl(0,y+16.6,0,5.4,3.2,2.2,12,NOVA_BUNKER_TRIM);
  m.tube(0,y+18.8,0,3.4,1.6,1.4,10,TWR_BORE);
  m.ring(0,y+20.1,0,2.2,3.6,14,NOVA_BUNKER_GLOW);
  for(const s of [-1,1]){
    m.bevelBox(s*11.5,y+1.0,0,6.0,7.2,8.5,.7,NOVA_BUNKER_ARM);
    m.box(s*11.5,y+8.15,0,3.4,.22,2.2,s>0?TWR_TEAM:TWR_GLOW);
    sensorMast(m,s*11.5,y+8.4,s*6.2,5.2,NOVA_BUNKER_ARM);
  }
  return m.build();
}
function mdlHarbor(){
  const m=MB();
  const y=novaServicePad(m,73,43,2.5);
  /* A U-shaped drydock survives the top-down camera much better than the old

     shed plus flat rectangle.  The empty dark slip is the focal shape; the

     service block and crane make its launch direction (+X) unambiguous. */
  m.bevelBox(-20.0,y,0,29.0,15.0,36.0,1.6,NOVA_HARBOR_ARM);
  m.bevelBox(-20.0,y+15.0,0,27.0,1.8,34.0,.65,NOVA_HARBOR_DECK);
  roofEdge(m,-20.0,y+16.8,0,27.0,34.0,.9,NOVA_HARBOR_CORE,NOVA_HARBOR_DECK);
  m.bevelBox(14.0,y+.1,0,39.0,1.5,28.0,.45,TWR_BORE);          // recessed ship cradle
  for(const s of [-1,1]){
    m.bevelBox(12.0,y+1.0,s*16.8,43.0,6.0,6.0,.8,NOVA_HARBOR_CORE);
    m.box(12.0,y+6.9,s*16.8,31.0,.24,2.0,s>0?TWR_GLOW:TWR_TEAM);
    for(const x of [-4,10,24]) m.cyl(x,y+7.0,s*16.8,1.2,.85,3.6,8,NOVA_HARBOR_ARM);
  }
  /* Twin launch rails are intentionally long, simple emissive strokes. */
  for(const s of [-1,1]){
    m.box(14.0,y+1.65,s*5.8,37.0,.45,.85,NOVA_UPLINK_GLOW);
    m.box(14.0,y+1.55,s*7.2,37.0,.65,.65,NOVA_HARBOR_CORE);
  }
  m.bevelBox(-29.0,y+16.8,-9.5,10.0,13.0,12.0,1.0,NOVA_HARBOR_CORE);
  m.bevelBox(-29.0,y+29.8,-9.5,11.0,2.0,13.0,.5,NOVA_HARBOR_DECK);
  m.box(-23.7,y+23.2,-9.5,.5,5.5,8.5,NOVA_HARBOR_GLASS);
  sensorMast(m,-29.0,y+31.8,-9.5,6.5,NOVA_HARBOR_ARM);
  m.box(-5.0,y+18.6,15.4,11.0,.24,.45,TWR_TEAM);
  return m.build();
}
function mdlBastionBase(tier){
  const m=MB(); tier=tier||1;
  towerPad(m,21,tier,false);
  m.extrude(0,11,0,towerOct(17.2),6,TWR_ARM_D);
  m.extrude(0,17,0,towerOct(14.4),4,TWR_ARM);
  for(const a of [0,Math.PI/2,Math.PI,Math.PI*1.5]){
    const x=Math.cos(a)*15.0,z=Math.sin(a)*15.0;
    m.bevelBox(x,12,z,6.8,7.4,8.2,.7,TWR_COAT,a);
    m.box(x,19.2,z,3.4,.25,1.0,a===0?TWR_TEAM:TWR_GLOW,a);
  }
  if(tier>=2) for(const s of [-1,1]){
    m.cyl(-7.5,18,s*10.2,2.4,2.0,4.1,10,TWR_MACH);
    m.box(-7.5,22.0,s*10.2,3.1,.24,1.0,TWR_GLOW);
  }
  if(tier>=3) m.bevelBox(-10.5,18,0,5.5,4.2,11.0,.6,TWR_ARM);
  m.cyl(0,20.6,0,12.2,12.2,1.2,18,TWR_COAT);
  m.cyl(0,21.8,0,10.8,9.8,1.2,18,TWR_TRIM);        // y=23 bearing
  return m.build();
}
function mdlBastionGun(tier){
  const m=MB(); tier=tier||1;
  m.cyl(0,0,0,9.2,8.5,3.0,18,TWR_MACH);
  m.bevelBox(-2.5,3.0,0,19.0,8.8,17.2,1.35,TWR_ARM_D);
  m.bevelBox(-8.8,4.3,0,6.3,7.0,13.5,.9,TWR_COAT);           // shell hoist
  for(const s of [-1,1]){
    m.cyl(-7.8,5.0,s*7.8,2.7,2.4,5.2,10,TWR_MACH);          // magazine drums
    m.box(-7.8,10.0,s*7.8,3.2,.25,1.2,TWR_GLOW);
    m.cyl(2.5,2.8,s*6.3,.9,.65,5.0,10,TWR_MACH);             // elevation rams
  }
  m.bevelBox(4.0,5.0,0,7.0,7.0,12.5,.9,TWR_ARM);            // mantlet
  /* A short, unmistakably broad mortar with an actual inner tube. The old gun

     was a capped pencil and read as a generic cannon from command view. */
  cylX(m,4.6,9.5,0,11.0,3.45,2.75,14,TWR_MACH,false);
  for(const x of [6.3,10.6]) cylX(m,x,9.5,0,.75,4.05,4.05,14,TWR_TRIM);
  m.bevelBox(14.2,6.0,0,3.2,7.0,8.8,.55,TWR_ARM_D);
  tubeX(m,14.3,9.5,0,2.0,4.15,2.45,14,TWR_BORE);
  m.bevelBox(-3.0,11.8,0,8.5,2.1,9.0,.55,TWR_ARM);
  m.box(-3.0,13.8,0,1.5,.22,5.5,TWR_TEAM);
  if(tier>=2) for(const s of [-1,1]){
    m.bevelBox(-10.4,9.3,s*5.6,4.1,4.2,2.0,.4,TWR_ARM);
    m.box(-10.4,13.3,s*5.65,2.4,.22,2.1,TWR_GLOW);
  }
  if(tier>=3){
    m.bevelBox(-9.0,12.0,0,5.5,3.4,10.2,.6,TWR_COAT);
    sensorMast(m,-10.2,15.4,0,5.2,TWR_MACH);
  }
  return m.build();
}
function mdlTechlab(){
  const m=MB();
  const y=novaServicePad(m,47,39,2.5);
  /* The old hemisphere dominated every material underneath it.  A stepped

     data vault with a small, exposed analysis core keeps the science identity

     while leaving broad wall/roof planes for the architectural PBR kit. */
  /* Research is a Nova landmark, not a recoloured utility shed. Its unique

     semantic selectors keep armour, recesses and roof response separated even

     before its authored BaseAO/NRE/mask pack is baked. */
  m.bevelBox(-3.0,y,0,34.0,13.0,29.0,1.8,NOVA_RESEARCH_ARM);
  m.bevelBox(-3.0,y+13.0,0,31.0,1.8,26.0,.7,NOVA_RESEARCH_ROOF);
  roofEdge(m,-3.0,y+14.8,0,31.0,26.0,.85,NOVA_RESEARCH_CORE,TWR_TRIM);
  for(const s of [-1,1]){
    m.bevelBox(-15.5,y+3.0,s*14.8,6.5,12.0,7.0,.9,NOVA_RESEARCH_CORE);
    m.box(-15.5,y+14.7,s*14.8,3.4,.24,3.5,s>0?TWR_GLOW:TWR_TEAM);
  }
  m.cyl(7.0,y+14.9,0,7.2,6.2,3.0,14,NOVA_RESEARCH_ARM);
  m.cyl(7.0,y+17.9,0,4.8,3.5,4.0,12,NOVA_RESEARCH_CORE);
  m.sphere(7.0,y+22.8,0,3.5,11,TWR_GLOW,1,false);
  ringX(m,7.0,y+22.8,0,5.0,5.8,16,TWR_TRIM);
  m.bevelBox(17.0,y,0,10.0,10.0,18.0,1.0,NOVA_RESEARCH_CORE);
  for(const s of [-1,1]) m.box(17.0,y+6.0,s*9.1,6.0,2.6,.42,NOVA_RESEARCH_GLASS);
  m.cyl(-8.5,y+16.6,0,1.0,.7,8.5,8,TWR_MACH);
  ringX(m,-8.5,y+25.1,0,3.5,5.4,16,TWR_ARM);
  ringX(m,-8.45,y+25.1,0,.9,1.5,12,TWR_GLOW);
  return m.build();
}
function mdlAA(tier){
  const m=MB(); tier=tier||1;
  const oct=r=>[[-r*.55,-r],[r*.55,-r],[r,-r*.55],[r,r*.55],
                 [r*.55,r],[-r*.55,r],[-r,r*.55],[-r,-r*.55]];
  m.extrude(0,0,0,oct(15),3,TWR_PAD);                         // compact stabilised pad
  m.extrude(0,3,0,oct(12.5),5,TWR_ARM_D);                    // faceted armour skirt
  m.extrude(0,8,0,oct(10.2),2,TWR_ARM);                      // upper equipment tier
  for(const s of [-1,1]){
    m.bevelBox(s*10.6,3,0,4.2,4.0,8.2,.55,TWR_COAT);         // power housings
    m.box(s*10.6,7.0,0,1.3,.24,4.4,s>0?TWR_GLOW:TWR_TEAM);
  }
  if(tier>=2) for(const s of [-1,1]){
    m.cyl(s*11.4,8.2,0,1.55,1.25,2.6,10,TWR_MACH);
    m.box(s*11.4,10.9,0,1.0,.20,3.0,TWR_GLOW);
  }
  if(tier>=3){
    m.box(0,10.35,0,1.05,.18,7.2,TWR_TEAM);
    m.sphere(0,12.2,8.4,1.3,8,GLASS,.72,true);
  }
  m.cyl(0,9.55,0,7.6,7.0,.6,14,TWR_COAT);                    // azimuth shadow gap
  m.cyl(0,10.15,0,6.8,6.25,.85,14,TWR_TRIM);                 // y=11 bearing surface
  return m.build();
}
function mdlAAGun(tier){
  const m=MB();
  m.cyl(0,0,0,6.5,6.0,2.2,14,TWR_MACH);                      // rotating race
  m.cyl(0,2.2,0,5.9,5.35,.9,14,TWR_TRIM);
  m.bevelBox(-1.0,3.0,0,10.8,5.0,10.0,.82,TWR_ARM_D);       // gun director body
  m.bevelBox(-3.0,8.0,0,5.8,1.7,6.2,.42,TWR_ARM);           // quiet IFF roof
  m.box(-3.0,9.7,0,1.15,.16,4.3,TWR_TEAM);                  // narrow team identifier
  for(const s of [-1,1]){
    m.bevelBox(-2.6,4.2,s*5.35,4.8,3.0,1.45,.32,TWR_COAT);   // feed boxes
    m.box(-2.6,7.2,s*5.4,2.8,.24,1.55,TWR_GLOW);             // ammunition status
    m.box(7.0,5.9,s*2.4,8.2,1.0,.72,TWR_MACH);               // barrel cradle
    gunX(m,1.8,7.0,12.8,.44,TWR_MACH,s*2.4);                 // separated autocannons
  }
  m.bevelBox(2.0,4.8,0,3.6,4.2,7.0,.55,TWR_ARM);            // armoured mantlet
  m.cyl(-4.5,9.7,0,1.15,.82,2.8,10,TWR_MACH);                // radar pedestal
  m.sphere(-4.5,12.5,0,1.65,10,GLASS,.72,true);              // tracking radar dome
  m.cyl(-4.5,9.55,3.8,.20,.20,.24,8,HQ_LAMP);                // acquisition lamp
  if((tier||1)>=2) m.box(0,9.2,0,8.4,.18,1.0,TWR_GLOW);
  if((tier||1)>=3) for(const s of [-1,1]) gunX(m,1.8,5.2,11.2,.36,TWR_MACH,s*4.4);
  return m.build();
}
function mdlAirfield(){
  const m=MB();
  const y=novaServicePad(m,91,41,2.0);
  /* Broad uninterrupted deck bands read as a runway at gameplay zoom.  Seven

     raised centreline blocks used to turn it into a ladder and added collision-

     looking clutter despite being purely decorative. */
  m.bevelBox(4.0,y,0,74.0,1.2,25.0,.45,NOVA_AIR_DECK);
  m.box(4.0,y+1.2,0,68.0,.20,1.2,TWR_TEAM);
  for(const s of [-1,1]){
    m.box(5.0,y+1.22,s*10.5,70.0,.20,.42,TWR_GLOW);
    for(const x of [-24,0,24,38]) m.cyl(x,y+1.32,s*10.5,.22,.22,.20,8,HQ_LAMP);
  }
  /* One deep hangar and a distinct glazed flight-control tower form an

     asymmetrical silhouette while preserving most of the deck as negative

     space. */
  m.bevelBox(-30.5,y,-10.0,28.0,14.0,18.0,1.5,NOVA_AIR_ARM);
  m.bevelBox(-30.5,y+14.0,-10.0,29.5,2.0,19.5,.7,NOVA_AIR_ROOF);
  roofEdge(m,-30.5,y+16.0,-10.0,29.5,19.5,.8,NOVA_AIR_DECK,NOVA_AIR_ROOF);
  m.box(-15.9,y+2.0,-10.0,.6,10.0,13.0,TWR_BORE);
  m.box(-15.5,y+12.0,-10.0,.45,.25,10.0,TWR_TEAM);
  m.bevelBox(34.0,y,13.0,12.0,20.0,13.0,1.0,NOVA_AIR_DECK);
  m.bevelBox(34.0,y+20.0,13.0,15.0,5.5,15.0,.8,NOVA_AIR_ARM);
  for(const s of [-1,1]) m.box(34.0,y+21.0,13.0+s*7.35,10.0,3.2,.45,NOVA_AIR_GLASS);
  m.box(26.7,y+21.0,13.0,.45,3.2,10.0,NOVA_AIR_GLASS);
  sensorMast(m,34.0,y+25.5,13.0,7.0,TWR_MACH);
  return m.build();
}
function mdlUplink(tier){
  const m=MB(); tier=tier||1;
  towerPad(m,15,tier,false);
  m.bevelBox(-4.2,11,0,12,9,18,.9,NOVA_UPLINK_CORE);          // electronics bunker
  m.bevelBox(-4.2,20,0,9.5,2.0,13,.5,NOVA_UPLINK_ARM);
  m.box(-4.2,21.9,0,1.3,.20,8.0,TWR_TEAM);
  for(const s of [-1,1]){
    m.cyl(5.0,11,s*5.0,1.1,.72,19+(tier-1)*2.0,7,NOVA_UPLINK_TRIM);
    m.box(5.0,29+(tier-1)*2.0,s*5.0,1.0,.22,1.0,NOVA_UPLINK_GLOW);
  }
  m.cyl(5.0,11,0,2.0,1.55,16+(tier-1)*2.0,10,NOVA_UPLINK_CORE);
  m.bevelBox(5.0,27+(tier-1)*2.0,0,8.2,4.6,6.2,.7,NOVA_UPLINK_CORE);
  /* The contact-sheet Targeting Array is defined by its dish, so the dish is

     larger than the mast and visibly hollow even in the 32 px build thumbnail. */
  ringX(m,5.0,35+(tier-1)*2.0,0,5.4+(tier-1)*.8,8.7+(tier-1)*1.0,20,NOVA_UPLINK_ARM);
  ringX(m,5.05,35+(tier-1)*2.0,0,1.1,2.0,14,NOVA_UPLINK_GLOW);
  cylX(m,5.0,35+(tier-1)*2.0,0,3.4,1.0,.6,10,NOVA_UPLINK_TRIM,false);
  if(tier>=2) for(const s of [-1,1]) sensorMast(m,-8.5,22,s*5.0,8,NOVA_UPLINK_TRIM);
  if(tier>=3) m.sphere(8.6,35+(tier-1)*2.0,0,1.6,10,NOVA_UPLINK_GLOW,1,false);
  return m.build();
}
/* ============================================================================

   HEADQUARTERS

   ----------------------------------------------------------------------------

   The first version was the carrier hull parked on the ground: a single

   extruded arrowhead in vehicle plating. From a top-down command camera that

   reads as a dark blob, because a building seen from above is almost entirely

   ROOF, and an arrowhead has no roof plan to read.



   This is authored as architecture instead. A stepped mass — apron, main

   block, inset roof deck — with four corner buttress towers that give the

   silhouette its square footprint, a command tower at the back, and a landing

   pad at the front. Everything is laid out on the plan the player is actually

   looking down at: pad, walkway, vent banks, mast. Wall and roof use the

   architectural materials, whose texture frequency is a third of vehicle

   plating, so a facade shows two or three real bays instead of dissolving.

   ============================================================================ */
function mdlHQ(){
  const m=MB();
  const y=novaServicePad(m,87,73,3.2,true);
  /* Three large masses replace the former collection of corner towers,

     greebles and transformer boxes.  The HQ remains the broadest Nova

     silhouette while now fitting its real 88x74 collision plot. */
  /* High-value command deck: the HQ is the player's visual anchor and needs

     to separate from grass at a glance. Dark material is reserved for seams,

     vents and the open bay, never the whole roof. */
  m.bevelBox(-5.0,y,0,68.0,18.0,55.0,2.8,NOVA_HQ_ARM);
  m.bevelBox(-5.0,y+18.0,0,61.0,3.0,49.0,1.0,NOVA_HQ_ROOF);
  roofEdge(m,-5.0,y+21.0,0,61.0,49.0,1.2,NOVA_HQ_STRUCT,NOVA_HQ_ROOF);
  for(const s of [-1,1]){
    m.bevelBox(-33.5,y,s*25.5,14.0,23.0,17.0,1.5,NOVA_HQ_STRUCT);
    m.bevelBox(-33.5,y+23.0,s*25.5,15.5,1.8,18.5,.65,NOVA_HQ_ROOF);
    m.box(-33.5,y+15.0,s*34.2,8.0,4.5,.45,NOVA_HQ_GLASS);
    m.box(-33.5,y+24.65,s*25.5,2.4,.16,2.4,TWR_COAT);
    /* Both wings get a point lamp. TWR_TEAM here was a dark socket after

       glowOk, and a cyan team bevel before it. */
    m.cyl(-33.5,y+24.85,s*25.5,.44,.44,.30,8,HQ_LAMP);
  }
  /* Raised command block and glazing band anchor the rear half. */
  m.bevelBox(-23.0,y+21.0,0,25.0,17.0,31.0,2.0,NOVA_HQ_ARM);
  m.bevelBox(-23.0,y+38.0,0,27.0,2.2,33.0,.8,NOVA_HQ_ROOF);
  roofEdge(m,-23.0,y+40.2,0,27.0,33.0,.9,NOVA_HQ_STRUCT,NOVA_HQ_ROOF);
  for(const s of [-1,1]) m.box(-23.0,y+31.0,s*15.7,18.0,5.0,.50,NOVA_HQ_GLASS);
  m.box(-10.2,y+31.0,0,.50,5.0,23.0,NOVA_HQ_GLASS);
  ventBank(m,-23.0,y+42.1,0,10.0,10.0,4,TWR_MACH,0);
  sensorMast(m,-31.0,y+42.0,-8.0,9.0,TWR_MACH);
  for(const s of [-1,1]) m.cyl(-23.0+s*11.2,y+40.85,s*14.6,.38,.38,.26,8,HQ_LAMP);
  for(const s of [-1,1]) m.cyl(-5.0+s*28.0,y+22.15,s*22.6,.34,.34,.22,8,HQ_LAMP);
  /* The front deck stays intentionally open.  Two rings and cross hairs are

     enough to read as a landing pad without a field of lamps. TWR_TEAM on

     the inner ring was Nova livery — the cyan crush at HIGH. */
  m.cyl(17.0,y+21.0,0,15.0,15.0,1.0,20,NOVA_HQ_ROOF);
  m.ring(17.0,y+22.0,0,12.7,14.6,22,NOVA_HQ_STRUCT);
  m.ring(17.0,y+22.1,0,9.2,10.4,22,TWR_TRIM);
  m.box(17.0,y+22.18,0,16.4,.16,1.15,TWR_TRIM);
  m.box(17.0,y+22.18,0,1.15,.16,16.4,TWR_TRIM);
  m.cyl(17.0,y+22.32,0,.62,.62,.28,10,HQ_LAMP);
  for(const s of [-1,1]){
    m.cyl(17.0+s*7.4,y+22.30,0,.38,.38,.22,8,HQ_LAMP);
    m.cyl(17.0,y+22.30,s*7.4,.38,.38,.22,8,HQ_LAMP);
  }
  /* Recessed deployment bay and ramp make +X the readable front. */
  m.box(29.3,y+2.0,0,.65,13.0,27.0,TWR_BORE);
  for(const s of [-1,1]){
    m.bevelBox(30.3,y+1.0,s*14.5,3.0,16.0,3.2,.45,TWR_ARM_D);
    /* Door lamps, not 8-unit glow slabs. The old strip bloomed into a

       cyan column at the bay cheek. */
    m.cyl(30.8,y+10.2,s*12.7,.22,.22,.28,8,HQ_LAMP);
    m.cyl(30.8,y+4.4,s*12.7,.22,.22,.28,8,TWR_TRIM);
  }
  m.bevelBox(30.3,y+14.0,0,3.0,4.0,32.0,.55,TWR_ARM);
  m.box(30.8,y+17.8,0,.30,.24,22.0,TWR_TRIM);
  m.bevelBox(36.5,y-.3,0,13.0,1.4,27.0,.4,TWR_PAD);
  return m.build();
}
/* ---------------------------------------------------------------------------

   ORBITAL DROPSHIP — a spacecraft, not a building

   The pre-deployment carrier was borrowing the DEPLOYED HQ's mesh, which is

   why it read as a bunker sliding around the map instead of the ship its own

   icon promises. This is a proper hull: long spine, swept lifting body, engine

   nacelles with lit bells, cargo pods slung underneath, and gear that only

   comes down at touchdown. It flies nose-first and banks into its turns.

   --------------------------------------------------------------------------- */
function mdlDropship(){
  const m=MB();
  /* One load-bearing lifting body. The previous craft intentionally left

     daylight around its nacelles, but on a phone those islands read as broken

     model pieces. The shoulders now include the engines inside the same plan

     silhouette; only retractable landing gear is a separate draw. */
  const hull=[[-54,-7],[-42,-14],[-19,-21],[12,-20],[38,-12],[56,0],[38,12],[12,20],[-19,21],[-42,14],[-54,7]];
  const upper=[[-46,-5],[-31,-11],[-8,-14],[20,-13],[41,-7],[50,0],[41,7],[20,13],[-8,14],[-31,11],[-46,5]];
  const crown=[[-33,-4],[-18,-8],[10,-9],[31,-6],[43,0],[31,6],[10,9],[-18,8],[-33,4]];
  m.extrude(0,1,0,hull,5.8,NOVA_MET);                        // continuous light steel keel
  m.extrude(0,6.8,0,upper,4.8,MET_L);                        // bright lifting-body shoulder
  m.extrude(6,11.6,0,crown,2.0,MET_L);                       // command deck
  m.extrude(5,13.7,0,crown.map(p=>[p[0]*.82,p[1]*.72]),.42,TEAM_A);
  /* The old bridge was still a half-height sphere parked on the hull. From the

     command camera it read as a flattened bubble, not pressure glazing. Build

     the canopy as a raked recessed volume with an armoured sill and mullions;

     every glass edge now physically disappears into metal. */
  m.wedge(32.5,13.9,0,13.8,2.0,21.5,NOVA_CARB,Math.PI/2,true); // armoured tub
  m.wedge(32.8,15.1,0,11.3,4.7,18.2,DROP_CANOPY_GLASS,Math.PI/2,true); // faceted pressure canopy
  for(const sd of [-1,1]){
    m.box(32.0,15.0,sd*5.45,18.0,1.15,.85,NOVA_MET);          // side sill
    m.box(30.0,18.7,sd*4.6,1.05,.78,8.6,NOVA_MET);            // rear frame
  }
  m.box(37.2,17.0,0,1.05,.72,10.4,NOVA_MET);                  // forward frame
  m.wedge(43.0,13.7,0,11.8,3.0,12.0,NOVA_MET,Math.PI/2,true); // nose closure
  for(const sd of [-1,1]){
    /* One continuous side sponson replaces the old stack of shoulder, pod,

       wedge, cylinder and loose nozzle. It overlaps the fuselage by a full

       eight units and terminates in one integrated cruise bell. The four VTOL

       units attach to the sockets below as genuinely animated sub-meshes. */
    m.bevelBox(-9,5.8,sd*10.4,55,7.2,8.8,1.15,NOVA_MET);
    m.wedge(15,11.4,sd*11.0,27,4.8,8.6,NOVA_MET,0,sd<0);
    m.box(-7,12.1,sd*10.2,34,.9,2.1,NOVA_CARB);
    m.bevelBox(-34,7.0,sd*10.5,19,8.2,9.2,1.15,MET_D);
    tubeX(m,-45.2,8.4,sd*10.5,6.2,4.8,3.6,16,DARKER);
    tubeX(m,-49.4,8.4,sd*10.5,3.2,3.5,1.7,16,ENERGY);
    m.box(-6,13.1,sd*14.6,28,.34,1.25,TEAM_A);
    for(const x of [-15,16]){
      m.bevelBox(x,4.8,sd*13.2,11.8,5.4,7.8,.85,NOVA_CARB);  // VTOL load-bearing socket
      m.box(x,10.0,sd*13.2,7.2,.34,5.0,TWR_MACH);           // visible rotation bearing
    }
  }
  /* Cargo keel and recessed lift apertures make the eventual base deployment

     mechanically plausible without reading as additional loose vehicles. */
  m.bevelBox(4,.1,0,48,3.8,16,1.2,DARKER);
  m.box(20,-1.85,0,14,.5,12,ENERGY);
  for(const x of [-17,12])for(const sd of [-1,1]){
    m.bevelBox(x,1.0,sd*9.7,10.5,4.0,7.8,.85,NOVA_CARB);     // turbine fairing
    m.cyl(x,1.8,sd*10.4,4.0,3.6,1.0,16,TWR_MACH);
    m.ring(x,2.85,sd*10.4,3.2,4.5,18,ENERGY);
  }
  glowStrip(m,3,14.25,0,43,ENERGY,0);
  sensorMast(m,-28,14.0,0,5.5,MET_L);
  return m.build();
}
/* Four tilting ducted-lift units. The hinge is evaluated by the existing GPU

   bone path: high-altitude cruise rotates the ducts aft; descent brings them

   upright. This restores the original lander's transforming-VTOL idea without

   another CPU animation system or four extra per-frame model rebuilds. */
function mdlDropVtol(){
  const m=MB(),hinge=m.joint([0,8,0],null,[0,0,1],0,1.04,0);
  m.bone(hinge);
  /* An open rectangular duct reads at phone zoom and leaves the fan visible;

     a solid cylinder looked like another disconnected barrel. */
  m.bevelBox(0,3.2,-5.0,14.2,8.4,2.2,.65,NOVA_MET);
  m.bevelBox(0,3.2, 5.0,14.2,8.4,2.2,.65,NOVA_MET);
  m.bevelBox(-6.0,3.2,0,2.2,8.4,8.0,.65,NOVA_MET);
  m.bevelBox( 6.0,3.2,0,2.2,8.4,8.0,.65,NOVA_MET);
  m.ring(0,11.7,0,4.2,6.5,20,TWR_MACH);
  m.ring(0,2.8,0,4.6,6.1,20,DARKER);
  m.box(0,8.0,-6.2,8.0,.34,.75,TEAM_A);
  m.box(0,8.0, 6.2,8.0,.34,.75,TEAM_A);
  m.box(-6.9,7.4,0,.45,2.4,5.2,ENERGY);
  m.box( 6.9,7.4,0,.45,2.4,5.2,ENERGY);
  m.bone(null);
  return m.build();
}
/* Visible rotor, separate so its yaw can spin continuously instead of merely

   oscillating with the tilt hinge. It is only shown while the duct is near

   vertical; in cruise the fan is edge-on and the aft bells carry the thrust. */
function mdlDropRotor(){
  const m=MB();
  m.cyl(0,0,0,1.15,1.15,1.0,12,TWR_MACH,true);
  for(let k=0;k<4;k++)m.box(3.4,.28,0,6.0,.34,1.05,TWR_TRIM,k*Math.PI*.5);
  m.ring(0,.72,0,5.7,6.25,20,ENERGY);
  return m.build();
}
/* Landing gear, drawn only once the ship is on the deck. */
function mdlDropGear(){
  const m=MB();
  /* Two continuous landing skids replace four isolated black feet. Each skid

     overlaps the belly fairing for most of its length, while paired oleos make

     the load path visible at the near-vertical mobile camera. */
  for(const sd of [-1,1]){
    const z=sd*10.2;
    m.bevelBox(-2,.05,z,51,1.7,4.8,.6,DARKER);
    m.bevelBox(-2,1.55,z,45,2.0,4.2,.6,NOVA_CARB);
    for(const x of [-18,14]){
      m.wedge(x,3.35,z,8.6,4.7,4.3,MET_D,0,sd<0);
      m.cyl(x,2.15,z,1.45,1.2,4.7,8,TWR_MACH);
      m.box(x,7.65,z,7.2,1.35,4.6,NOVA_MET);
    }
  }
  return m.build();
}

/* A deployer is the first full-screen faction silhouette a player sees. Reusing

   the Nova carrier for every army made the later faction geometry feel like a

   skin swap before the match had even begun. These craft share no hull: the

   Legion lands a slab-armoured assault brick, the Syndicate rides a thin hover

   delta, and the Brood arrives inside a living drop-organism. */
function mdlLegionDropship(){
  const m=MB();
  m.extrude(-2,0,0,[[-45,-17],[-35,-24],[27,-24],[44,-14],[50,0],[44,14],[27,24],[-35,24],[-45,17]],13,TWR_ARM_D);
  m.bevelBox(-8,13,0,68,12,34,2.2,TWR_ARM);
  m.wedge(34,20,0,26,8,25,TWR_COAT);                         // breaching prow
  m.bevelBox(25,28,0,18,7,18,1.4,TWR_ARM);
  m.box(35,31,0,1.2,3.4,12,GLASS);
  for(const sd of [-1,1]){
    m.bevelBox(-2,8,sd*24,52,15,12,1.8,TWR_COAT);             // troop cassettes
    m.box(2,23.2,sd*24,29,.35,10,TEAM_A);
    m.wedge(19,13,sd*24,18,12,12,TWR_ARM,0,sd<0);
    m.bevelBox(-34,12,sd*21,18,18,15,1.5,TWR_ARM_D);
    for(const z of [sd*17,sd*25]){
      m.cyl(-45,12,z,5.0,4.2,6.0,12,TWR_MACH);
      m.cyl(-51.2,12,z,3.8,2.8,2.2,12,HOT);
    }
  }
  m.bevelBox(-38,23,0,18,12,20,1.6,TWR_COAT);                // armoured reactor keep
  m.bevelBox(-11,-7,0,55,6,28,1.4,TWR_ARM_D);                 // siege landing keel
  m.box(16,-10.2,0,22,.28,16,HOT);                            // hot deploy-ramp seam
  for(let k=-1;k<=1;k++){
    m.tube(-48,29,k*6.2,1.35,.78,5.0,9,TWR_BORE,0);
    m.box(-42,33,k*6.2,10,.5,2.1,HOT);
  }
  sensorMast(m,-14,35,0,9,TWR_MACH);                          // assault command mast
  return m.build();
}
function mdlLegionDropGear(){
  const m=MB();
  for(const sd of [-1,1]) for(const f of [-1,1]){
    const x=f*30,z=sd*23;
    m.bevelBox(x,0,z,14,3.0,10,.75,TWR_PAD);
    m.cyl(x,3,z,2.4,1.8,11,9,TWR_MACH);
    m.box(x,12,z,4.2,8,4.2,TWR_ARM_D);
  }
  return m.build();
}
function mdlSyndicateDropship(){
  const m=MB();
  /* A shallow manta plan keeps the machine visibly agile even when stationary;

     the separated lift rings replace landing struts entirely. */
  m.extrude(2,1,0,[[-38,-8],[-20,-16],[10,-28],[43,-11],[52,0],[43,11],[10,28],[-20,16],[-38,8]],6,TWR_COAT);
  m.extrude(5,7,0,[[-31,-5],[-13,-10],[21,-16],[43,-7],[49,0],[43,7],[21,16],[-13,10],[-31,5]],4,TEAM_A);
  m.wedge(31,12,0,28,5,14,TWR_ARM,0,false);
  m.box(43,15,0,.8,2.5,8,GLASS);
  for(const sd of [-1,1]){
    m.wedge(1,8,sd*19,44,3,13,TWR_ARM_D,sd*.08,sd<0);
    m.box(3,11.2,sd*23,25,.28,2.0,TEAM_T,sd*.08);
    for(const x of [-22,0,22]){
      m.cyl(x,2.4,sd*18,2.2,1.8,1.0,14,TWR_MACH);
      m.ring(x,3.6,sd*18,2.5,4.4,18,ENERGY);
    }
  }
  m.ring(-22,12,0,3.6,6.8,20,ENERGY);
  m.sphere(-22,12,0,3.2,10,GLASS,.92,false);
  m.ring(7,3,0,8.0,11.8,22,ENERGY);                           // active teleport keel
  m.box(13,1.6,0,22,.45,15,GLASS);                            // luminous cargo aperture
  for(const sd of [-1,1]) m.tube(-38,7,sd*7,2.2,1.2,2.2,12,ENERGY,0);
  return m.build();
}
function mdlHordeDropship(){
  const m=MB();
  /* No pad, plate, glass, bolt, nozzle or manufactured edge: this is an animal

     that survives atmospheric entry and disgorges a hive, not a ship wearing a

     biological decal. BIO_MEM/BIO_LEG also opt into the spring shader. */
  m.sphere(-4,7,0,18,16,CHITIN,.62,false);                    // central thorax
  m.sphere(-27,7,0,14,14,CHIT_D,.78,false);                  // brood abdomen
  m.sphere(18,8,0,11,13,CHITIN,.72,false);                   // head shield
  m.sphere(4,1,0,11,12,BIO_MEM,.44,false);                   // hanging brood womb
  m.ring(4,0,0,5.8,9.2,16,BIO_TEAM);
  for(const sd of [-1,1]){
    m.sphere(-19,12,sd*10,7,10,BIO_TEAM,.72,false);           // luminous brood sacs
    /* Three separated, tapered petals leave daylight between their outlines.

       That negative space and the beaded veins make them read as living wings

       rather than the former single aircraft-like planar panel. */
    /* Overlapping flattened lobes produce scalloped, curved membranes with no

       planar face large enough to be mistaken for a metal wing. */
    for(let k=0;k<8;k++){
      const q=k/7,r=4.8-q*2.5;
      m.sphere(-15+q*25,8.2+Math.sin(q*Math.PI)*2.0,sd*(5+q*40),r,8,BIO_MEM,.20,false);
      m.sphere(-15+q*25,9.0,sd*(5+q*40),.88-q*.42,7,BIO_LEG,.56,false);
    }
    for(let k=0;k<7;k++){
      const q=k/6,r=4.2-q*2.3;
      m.sphere(-23+q*17,6.7+Math.sin(q*Math.PI)*1.5,sd*(5+q*31),r,8,BIO_MEM,.20,false);
      m.sphere(-23+q*17,7.5,sd*(5+q*31),.76-q*.34,7,BIO_LEG,.56,false);
    }
    for(let k=0;k<6;k++){
      const q=k/5,r=3.7-q*2.0;
      m.sphere(-29+q*11,5.5+Math.sin(q*Math.PI),sd*(4+q*25),r,8,BIO_MEM,.20,false);
      m.sphere(-29+q*11,6.2,sd*(4+q*25),.66-q*.28,6,BIO_LEG,.56,false);
    }
    for(let k=0;k<6;k++) m.sphere(8+k*2.2,7.5-k*.18,sd*(7-k*.8),1.0-k*.10,7,k<4?BIO_LEG:CLAW,.62,false);
    m.sphere(24,12,sd*5,2.2,8,LAMP,1,false);                  // compound eye
    for(let k=0;k<3;k++){
      for(let j=0;j<5;j++)
        m.sphere(-7-k*6-j*2.3,4-j*1.25,sd*(8+k*3+j*.8),.82-j*.09,6,BIO_LEG,.64,false);
    }
  }
  for(let k=0;k<7;k++){
    const a=-1.1+k*.36;
    m.cyl(-20-k*1.2,18+Math.sin(a)*2,Math.cos(a)*5,.78,.03,7+k*.6,7,CLAW);
  }
  for(const sd of [-1,1]) for(let k=0;k<4;k++)
    m.sphere(4-k*4.3,1.5-k*.9,sd*(3+k*2.2),1.15-k*.12,7,BIO_LEG,.60,false);
  return m.build();
}
function mdlHordeDropGear(){
  const m=MB();
  for(const sd of [-1,1]) for(const f of [-1,1]){
    const x=f*20,z=sd*12;
    for(let j=0;j<5;j++)
      m.sphere(x+f*j*2.2,7-j*1.55,z+sd*j*1.7,1.15-j*.12,7,BIO_LEG,.68,false);
    m.sphere(x+f*9,.5,z+sd*8,2.1,7,CLAW,.7,false);
  }
  return m.build();
}

const DROP_MDL={
  nova:mdlDropship,
  legion:mdlLegionDropship,
  syndicate:mdlSyndicateDropship,
  horde:mdlHordeDropship
};
const DROP_GEAR_MDL={nova:mdlDropGear,legion:mdlLegionDropGear,horde:mdlHordeDropGear};
const DROP_VTOL_MDL={nova:mdlDropVtol};
const DROP_ROTOR_MDL={nova:mdlDropRotor};
/* Profiles keep exhaust/hover cues attached to authored hardpoints. Aliases

   consolidate Brood/Swarm/Infestation into one biology without presenting

   neutral wildlife as a fifth art faction. */
const DROP_PROFILE={
  /* The command camera views the lander through terrain shadow and UI bloom.

     A deeper blue multiplication looked nearly black there, so this is a

     light steel-blue hull tint; dedicated team panels still carry the banner. */
  nova:{scale:1.08,team:[112,124,136],glow:[142,228,255],ring:[170,224,255],eng:[[-49,-10],[-49,10]],vtol:[[-15,-15],[-15,15],[16,-15],[16,15]],lights:[[42,0],[15,-15],[15,15],[-30,0]]},
  legion:{scale:1.12,team:[255,120,90],glow:[255,116,62],ring:[255,142,82],eng:[[-51,-25],[-51,-17],[-51,17],[-51,25]],lights:[[39,0],[15,-25],[15,25],[-35,0]]},
  syndicate:{scale:1.02,team:[150,235,95],glow:[138,255,112],ring:[152,255,126],eng:[[-38,-7],[-38,7],[-22,-18],[-22,18]],lights:[[45,0],[12,-24],[12,24],[-27,0]],hover:true},
  horde:{scale:1.04,team:[186,120,255],glow:[188,92,255],ring:[140,238,92],eng:[[-27,-10],[-27,10],[-16,-15],[-16,15]],lights:[[23,0],[-5,-20],[-5,20],[-25,0]],bio:true}
};
const DROP_ALIASES={
  terran:'nova',frontline:'nova',federation:'nova',
  ascendancy:'legion',red:'legion',
  machine:'syndicate',coalition:'syndicate',
  brood:'horde',swarm:'horde',infestation:'horde'
};
const DROP_MESH={};
function dropFactionKey(k){
  k=String(k||'nova').trim().toLowerCase();
  if(DROP_MDL[k]) return k;
  if(DROP_ALIASES[k]) return DROP_ALIASES[k];
  /* Resolve full lore/doctrine labels as well as compact simulation IDs. Keep

     Machine Ascendancy ahead of the generic Ascendancy alias. */
  if(k.includes('machine ascendancy')||k.includes('syndicate')||k.includes('coalition')) return 'syndicate';
  if(k.includes('infestation')||k.includes('brood')||k.includes('swarm')) return 'horde';
  if(k.includes('terran frontline')||k.includes('nova federation')||k.includes('frontline')||k.includes('federation')) return 'nova';
  if(k.includes('red ascendancy')||k.includes('bloodward')||k.includes('legion')||k.includes('ascendancy')) return 'legion';
  return 'nova';
}

function mdlHellstormBase(tier){
  const m=MB(); tier=tier||1;
  towerPad(m,17,tier,false);
  m.cyl(0,11,0,9.2,8.0,5.8,14,TWR_ARM_D);
  for(const s of [-1,1]){
    m.bevelBox(-3.0,12.0,s*11.5,7.0,8.0,3.5,.55,TWR_COAT);     // ammunition boxes
    m.box(-3.0,19.8,s*11.55,4.2,.25,3.6,TWR_GLOW);
  }
  m.cyl(0,16.8,0,8.1,8.1,.7,16,TWR_COAT);
  m.cyl(0,17.5,0,7.2,6.7,.5,16,TWR_TRIM);                      // y=18 tracking bearing
  return m.build();
}
function mdlHellstormGun(tier){
  const m=MB(); tier=tier||1;
  m.cyl(0,0,0,6.8,6.2,2.0,16,TWR_MACH);
  m.bevelBox(-1.0,2.0,0,15.5,5.5,13.5,.9,TWR_ARM);
  m.bevelBox(-6.3,1.0,0,6.4,7.5,11.0,.7,TWR_COAT);            // rotating feed housing
  /* Horizontal rotary cluster with open bores. Barrel count grows by tier, but

     each tube remains thick enough to survive normal phone zoom. Keeping this

     assembly separate is required: projectiles track through a full turn and

     the authored barrels must follow the same azimuth. */
  const count=tier===1?4:tier===2?6:8;
  for(let k=0;k<count;k++){
    const a=k/count*TAU, z=Math.cos(a)*2.7, y=7.0+Math.sin(a)*2.7;
    gunX(m,2.5,y,13.5,.45,TWR_MACH,z);
  }
  cylX(m,1.2,7.0,0,5.0,3.8,3.6,12,TWR_COAT,false);
  m.bevelBox(-1.0,9.6,0,8.0,1.8,7.5,.45,TWR_ARM_D);
  m.box(-1.0,11.3,0,1.3,.20,4.8,TWR_TEAM);
  if(tier>=3) sensorMast(m,-6.8,6.8,0,6.0,TWR_MACH);
  return m.build();
}
function mdlArc(tier){
  const m=MB(); tier=tier||1;
  towerPad(m,16,tier,false);
  m.cyl(0,11,0,9.0,7.3,8.0,14,TWR_ARM);
  m.cyl(0,19,0,6.5,5.5,4.0,14,TWR_MACH);
  for(let k=0;k<3+(tier-1);k++){
    const y=23+k*4.0, ro=6.6-k*.72;
    m.cyl(0,y,0,ro,ro*.80,2.0,14,k%2?TWR_TRIM:TWR_MACH);
    m.cyl(0,y+2.0,0,ro*.80,ro*.72,2.0,14,TWR_COAT);
  }
  const crown=31+(tier-1)*4;
  m.cyl(0,23,0,1.35,.72,crown-20,9,TWR_MACH);
  m.sphere(0,crown+2.0,0,4.7+(tier-1)*.65,12,TWR_GLOW,1,false);
  ringX(m,0,crown+2.0,0,5.3+(tier-1)*.65,6.1+(tier-1)*.65,18,TWR_TRIM);
  for(let k=0;k<3;k++){
    const a=k/3*TAU,x=Math.cos(a)*10.8,z=Math.sin(a)*10.8;
    m.cyl(x,11,z,1.35,.72,crown-15,7,TWR_COAT);
    m.box(x,crown-4,z,1.0,.24,1.0,k===0?TWR_TEAM:TWR_GLOW,a);
  }
  if(tier>=3) for(const a of [0,Math.PI/2,Math.PI,Math.PI*1.5]){
    m.cyl(Math.cos(a)*7.6,crown-2,Math.sin(a)*7.6,.55,.18,7.5,7,TWR_MACH);
  }
  return m.build();
}
function mdlNovaBase(tier){
  const m=MB(); tier=tier||1;
  /* r=24.5 keeps the complete base inside Nova's asymmetric 58x50 plot. The

     previous r=27 pad silently occupied four units of neighbouring ground. */
  towerPad(m,24.5,tier,false);
  m.extrude(0,11,0,towerOct(20.0),6.5,TWR_ARM_D);
  m.extrude(0,17.5,0,towerOct(16.5),3.2,TWR_ARM);
  for(const s of [-1,1]){
    m.bevelBox(-9.0,13.0,s*17.0,10.0,7.0,4.0,.6,TWR_COAT);
    m.box(-9.0,19.8,s*17.05,5.5,.24,4.1,s>0?TWR_TEAM:TWR_GLOW);
  }
  m.bevelBox(14.5,11.0,0,9.0,8.0,16.0,.8,TWR_COAT);           // fixed fire-control bunker
  m.box(14.5,18.8,0,1.3,.22,9.0,TWR_TEAM);
  m.cyl(0,20.4,0,11.0,11.0,.8,18,TWR_COAT);
  m.cyl(0,21.2,0,9.8,9.0,.8,18,TWR_TRIM);                      // y=22 tracking bearing
  return m.build();
}
function mdlNovaGun(tier){
  const m=MB(); tier=tier||1;
  m.cyl(0,0,0,8.8,8.2,2.2,18,TWR_MACH);
  m.bevelBox(-1.5,2.2,0,21.0,7.0,17.0,1.0,TWR_ARM_D);
  m.bevelBox(-5.5,8.8,0,11.0,2.0,14.0,.55,TWR_ARM);
  const rows=tier===1?2:tier===2?3:4;
  for(let r=0;r<rows;r++) for(const s of [-1,1]){
    const y=4.8+r*4.2,z=s*4.3;
    m.bevelBox(5.2,y-2.0,z,4.2,4.0,5.2,.5,TWR_MACH);
    tubeX(m,6.6,y,z,3.0,2.0,1.22,10,TWR_BORE);                 // open tracking launch cell
    m.box(2.9,y+1.85,z,4.0,.20,2.6,r===0&&s>0?TWR_TEAM:TWR_GLOW);
  }
  m.bevelBox(-9.0,3.0,0,5.0,7.0,13.0,.7,TWR_COAT);            // reload mechanism
  if(tier>=2) sensorMast(m,-8.5,10.0,-4.5,5.0,TWR_MACH);
  if(tier>=3) m.box(-5.5,20.0,0,1.2,.22,7.0,TWR_TEAM);
  return m.build();
}
/* Contact-sheet additions that have no legacy placeholder. These are live

   structures, not gallery props, and therefore share the exact runtime model

   contract (base plus optional tracking assembly) used by every other tower. */
function mdlMiningLaserBase(tier){
  const m=MB(); tier=tier||1;
  towerPad(m,18,tier,false);
  m.extrude(0,11,0,towerOct(14.2),3.6,TWR_ARM_D);
  for(const s of [-1,1]){
    m.bevelBox(-5.0,11,s*11.8,8.0,6.0,3.8,.55,TWR_COAT);
    m.box(-5.0,16.8,s*11.85,4.5,.24,4.0,s>0?TWR_GLOW:TWR_TEAM);
  }
  m.cyl(0,14.2,0,9.4,9.4,1.0,16,TWR_COAT);
  m.cyl(0,15.2,0,8.2,7.5,.8,16,TWR_TRIM);          // y=16 bearing
  return m.build();
}
function mdlMiningLaserGun(tier){
  const m=MB(); tier=tier||1;
  m.cyl(0,0,0,7.6,7.0,2.5,16,TWR_MACH);
  m.bevelBox(-2.5,2.5,0,17.0,7.4,14.0,1.15,TWR_ARM_D);
  m.bevelBox(-8.7,4.1,0,5.8,6.5,11.8,.8,TWR_COAT);
  for(const s of [-1,1]){
    m.cyl(-6.8,6.1,s*6.5,2.3,2.0,4.4,10,TWR_MACH);
    m.box(-6.8,10.3,s*6.55,2.8,.22,2.0,TWR_GLOW);
    m.box(10.0,7.1,s*2.8,12.0,1.1,.78,TWR_MACH);
  }
  m.bevelBox(4.2,5.0,0,6.5,6.4,10.5,.8,TWR_ARM);
  cylX(m,4.5,8.2,0,17.0,1.8,1.35,14,TWR_MACH,false);
  for(const x of [7.0,12.0,17.0]){
    cylX(m,x,8.2,0,.72,2.6,2.6,14,TWR_TRIM);
    m.box(x,10.8,0,.7,.20,3.0,TWR_GLOW);
  }
  m.bevelBox(20.0,5.4,0,3.5,5.6,7.2,.5,TWR_ARM_D);
  tubeX(m,20.4,8.2,0,2.0,2.8,1.15,14,TWR_BORE);    // optical emitter throat
  m.bevelBox(-3.0,9.9,0,8.0,1.8,8.0,.45,TWR_ARM);
  m.box(-3.0,11.6,0,1.3,.20,4.8,TWR_TEAM);
  if(tier>=2) for(const s of [-1,1]) m.bevelBox(-9.8,8.4,s*4.5,4.0,3.3,2.0,.4,TWR_ARM);
  if(tier>=3) sensorMast(m,-10.5,11.7,0,5.0,TWR_MACH);
  return m.build();
}
function mdlMissileBastionBase(tier){
  const m=MB(); tier=tier||1;
  towerPad(m,22,tier,false);
  m.extrude(0,11,0,towerOct(17.8),5.0,TWR_ARM_D);
  for(const s of [-1,1]){
    m.bevelBox(-2.0,11.0,s*15.7,10.0,6.5,3.0,.5,TWR_COAT);
    m.box(-2.0,17.3,s*15.75,6.0,.22,3.1,s>0?TWR_TEAM:TWR_GLOW);
  }
  m.cyl(0,16.0,0,11.8,11.8,1.0,18,TWR_COAT);
  m.cyl(0,17.0,0,10.5,9.6,1.0,18,TWR_TRIM);                    // y=18 tracking bearing
  return m.build();
}
function mdlMissileBastionGun(tier){
  const m=MB(); tier=tier||1;
  m.cyl(0,0,0,9.7,9.1,2.2,18,TWR_MACH);
  m.bevelBox(-3.0,2.2,0,25.0,9.0,28.0,1.4,TWR_ARM);
  m.bevelBox(-8.5,5.2,0,9.0,6.2,23.0,.9,TWR_COAT);            // rotating feed / fire-control block
  const rows=tier===1?2:tier===2?3:4, cols=2;
  for(let r=0;r<rows;r++) for(let c=0;c<cols;c++){
    const y=6.2+r*4.0,z=(c-.5)*8.2;
    tubeX(m,7.6,y,z,2.4,2.05,1.30,10,TWR_BORE);                // visible recessed missile cell
    m.bevelBox(5.8,y-2.2,z,4.0,4.4,5.2,.55,TWR_MACH);
  }
  m.bevelBox(-3.0,11.2+(tier-1)*2.0,0,16.0,2.0,18.0,.55,TWR_ARM_D);
  m.box(-3.0,13.1+(tier-1)*2.0,0,1.5,.22,10.0,TWR_TEAM);
  if(tier>=2) sensorMast(m,-11.0,11.2,0,6.5,TWR_MACH);
  if(tier>=3) ringX(m,-11.0,18.2,0,1.8,2.7,14,TWR_GLOW);
  return m.build();
}
function mdlPlasmaCharger(tier){
  const m=MB(); tier=tier||1;
  towerPad(m,20,tier,false);
  m.extrude(0,11,0,towerOct(16.0),6.0,TWR_ARM_D);
  m.cyl(0,17,0,11.6,9.8,4.5,16,TWR_ARM);
  for(let k=0;k<4;k++){
    const a=k/4*TAU+Math.PI/4,x=Math.cos(a)*12.4,z=Math.sin(a)*12.4;
    m.bevelBox(x,14.0,z,5.0,10.0,5.0,.7,TWR_COAT,a);
    m.cyl(x,23.5,z,1.45,.72,7.0+(tier-1)*1.4,8,TWR_MACH);
    m.box(x,30.2+(tier-1)*1.4,z,1.2,.24,1.2,TWR_GLOW,a);
  }
  m.cyl(0,21.5,0,7.5,5.6,6.0,16,TWR_MACH);
  m.sphere(0,29.0+(tier-1)*1.5,0,6.0+(tier-1)*1.0,14,TWR_GLOW,1,false);
  for(let k=0;k<2+(tier-1);k++){
    const y=25.5+k*3.2, r=8.2+k*.45;
    m.ring(0,y,0,r-.6,r,20,k%2?TWR_TRIM:TWR_MACH);
  }
  if(tier>=3){
    ringX(m,0,30.0,0,8.2,9.2,20,TWR_TRIM);
    m.cyl(0,36.0,0,1.1,.5,5.5,8,TWR_MACH);
  }
  m.box(0,21.2,9.6,5.0,.24,.9,TWR_TEAM);
  return m.build();
}
/* SEAFORT used to draw the land Concussion Mortar. A floating dual-purpose

   battery has a hull, a pontoon deck and a surface+AA mount — none of which

   a poured oct pad can fake. 48x48 plot. Bearing at y=16. */
function mdlSeafortBase(tier){
  const m=MB(); tier=tier||1;
  const hull=[[-20,-16],[-12,-21],[12,-21],[20,-16],[20,16],[12,21],[-12,21],[-20,16]];
  m.extrude(0,0,0,hull,3.2,NOVA_HARBOR_CORE);
  m.extrude(0,3.2,0,hull.map(p=>[p[0]*.92,p[1]*.90]),1.4,NOVA_HARBOR_DECK);
  for(const s of [-1,1]){
    m.bevelBox(-6.0,0,s*18.2,26,2.6,4.0,.5,NOVA_HARBOR_ARM);
    m.box(-6.0,2.62,s*18.3,16,.20,1.5,s>0?TWR_TEAM:TWR_GLOW);
    m.cyl(-15.0,0,s*14.2,1.55,1.35,3.2,8,TWR_MACH);
  }
  m.bevelBox(-7.0,4.6,0,16,8.2,18,.9,TWR_ARM_D);
  m.extrude(0,12.8,0,towerOct(11.2),2.2,TWR_ARM);
  m.cyl(0,14.6,0,9.4,9.4,.8,16,TWR_COAT);
  m.cyl(0,15.4,0,8.2,7.4,.6,16,TWR_TRIM);                    // y=16 bearing
  m.bevelBox(14.5,4.6,-8.0,10,6.8,10,.7,TWR_COAT);           // AA director
  m.sphere(14.5,13.0,-8.0,2.35,10,GLASS,.72,true);
  if(tier>=2) sensorMast(m,-15.5,4.6,10.0,6.4,TWR_MACH);
  if(tier>=3) m.box(0,13.0,0,1.2,.20,8.0,TWR_TEAM);
  return m.build();
}
function mdlSeafortGun(tier){
  const m=MB(); tier=tier||1;
  m.cyl(0,0,0,7.2,6.6,2.2,16,TWR_MACH);
  m.bevelBox(-2.2,2.2,0,15.5,6.6,13.5,1.0,TWR_ARM_D);
  cylX(m,3.2,6.2,0,11.5,2.25,1.75,12,TWR_MACH,false);        // surface battery
  for(const x of [6.4,10.8]) cylX(m,x,6.2,0,.7,2.75,2.75,12,TWR_TRIM);
  m.bevelBox(13.6,4.4,0,2.8,5.6,7.2,.45,TWR_ARM);
  tubeX(m,14.2,6.2,0,1.7,2.55,1.25,12,TWR_BORE);
  for(const s of [-1,1]){                                    // twin AA
    m.box(5.2,9.2,s*3.15,8.4,.72,.55,TWR_MACH);
    gunX(m,2.4,9.2,10.5,.36,TWR_MACH,s*3.15);
  }
  m.box(-2.6,8.7,0,1.15,.20,5.8,TWR_TEAM);
  if(tier>=2) for(const s of [-1,1]) m.bevelBox(-6.4,4.0,s*5.0,4.0,3.1,2.0,.35,TWR_ARM);
  if(tier>=3) sensorMast(m,-7.0,8.6,0,4.0,TWR_MACH);
  return m.build();
}
/* STORMCALLER used the NOVA silo mesh. A banked-charge volley battery is a

   capacitor farm with a 16-cell rack, not an orbital superweapon. 46x46. */
function mdlStormcallerBase(tier){
  const m=MB(); tier=tier||1;
  towerPad(m,20,tier,false);
  m.extrude(0,11,0,towerOct(15.2),4.0,TWR_ARM_D);
  for(const s of [-1,1]){
    m.bevelBox(-1.5,11,s*13.4,18,6.8,3.8,.5,TWR_COAT);
    for(const x of [-6,0,6]){
      m.cyl(x,17.8,s*13.4,1.28,1.05,3.0+(tier-1)*.7,8,TWR_MACH);
      m.tube(x,20.7+(tier-1)*.7,s*13.4,1.08,.52,.5,8,TWR_BORE);
      m.ring(x,21.3+(tier-1)*.7,s*13.4,.58,1.0,10,TWR_GLOW);
    }
    m.box(-1.5,17.7,s*13.5,10,.20,2.1,s>0?TWR_TEAM:TWR_GLOW);
  }
  m.cyl(0,15.0,0,8.4,7.6,2.0,16,TWR_MACH);
  m.sphere(0,18.2,0,3.4+(tier-1)*.35,12,TWR_GLOW,1,false);   // banked charge
  m.cyl(0,20.4,0,9.0,9.0,.8,16,TWR_COAT);
  m.cyl(0,21.2,0,7.8,7.0,.8,16,TWR_TRIM);                    // y=22 bearing
  return m.build();
}
function mdlStormcallerGun(tier){
  const m=MB(); tier=tier||1;
  m.cyl(0,0,0,7.4,6.8,2.0,16,TWR_MACH);
  m.bevelBox(-2.4,2.0,0,17,7.2,15.5,.95,TWR_ARM_D);
  for(let r=0;r<4;r++) for(let c=0;c<4;c++){
    const y=4.15+(r-1.5)*2.0,z=(c-1.5)*3.05;
    m.bevelBox(4.0,y-1.05,z,3.2,2.1,2.3,.26,TWR_MACH);
    tubeX(m,5.4,y,z,2.15,1.08,.68,8,TWR_BORE);               // 16-cell volley rack
  }
  m.bevelBox(-8.0,3.0,0,4.8,6.0,11.5,.55,TWR_COAT);
  if(tier>=2) sensorMast(m,-8.8,9.0,0,4.4,TWR_MACH);
  if(tier>=3) m.box(-3.0,9.4,0,1.15,.20,7.6,TWR_TEAM);
  return m.build();
}
function mdlWall(){
  const m=MB();
  m.box(0,0,0,28,3,20,CONC_D);
  m.box(0,3,0,26,13,15,CONC);                                  // rampart body
  m.box(0,16,0,27,3,17,CONC_D);                                // parapet cap
  for(const s of [-1,1]) m.box(0,19,s*7,26,3,3,CONC);          // crenellation
  for(const f of [-1,1]) m.box(f*12,3,0,4,17,17,MET_D);        // buttress posts
  m.box(0,21.8,0,11,.24,1.0,TWR_TEAM);                         // restrained ownership rail
  return m.build();
}
function mdlGate(){
  const m=MB();
  m.box(0,0,0,28,3,20,CONC_D);
  for(const f of [-1,1]) m.box(f*11,3,0,6,20,18,CONC);         // gate towers
  m.box(0,19,0,26,4,17,CONC_D);
  m.box(0,3,0,16,15,4,ENERGY);                                 // energy curtain
  for(const f of [-1,1]) m.cyl(f*11,24.62,0,.32,.32,.24,8,HQ_LAMP);
  m.box(0,22.8,0,9,.24,1.0,TWR_TEAM);                          // gatehouse livery, not curtain tint
  return m.build();
}
function mdlGeo(){
  const m=MB();
  const y=novaServicePad(m,37,31,2.5);
  /* The geothermal plant is a pressure vessel, not a second small reactor:

     broad condenser wings and a hollow central steam throat distinguish it

     from the Pgen before colour or animation is considered. */
  m.cyl(0,y,0,8.5,7.7,8.0,12,NOVA_GEO_CORE);
  m.cyl(0,y+8.0,0,6.7,5.0,9.0,12,NOVA_GEO_ARM);
  m.cyl(0,y+17.0,0,5.1,4.2,3.0,12,NOVA_GEO_TRIM);
  m.tube(0,y+19.8,0,4.3,2.4,1.4,12,TWR_BORE);
  for(const s of [-1,1]){
    m.bevelBox(s*13.3,y,0,7.0,12.0,18.0,.9,NOVA_GEO_CORE);
    ventBank(m,s*13.3,y+12.0,0,4.2,13.0,4,NOVA_GEO_TRIM,0);
    m.box(s*13.3,y+12.2,-9.1,3.6,.22,.45,s>0?NOVA_GEO_GLOW:TWR_TEAM);
    m.box(s*8.8,y+5.5,0,5.5,1.3,1.8,NOVA_GEO_ARM);
  }
  ringX(m,0,y+12.5,0,5.4,6.0,14,NOVA_GEO_TRIM);
  m.sphere(0,y+15.0,0,1.7,9,NOVA_GEO_GLOW,1,false);
  return m.build();
}
function mdlSilo(){
  const m=MB();
  m.box(0,0,0,26,3,26,NOVA_SILO_CORE);
  for(const [dx,dz,r] of [[-5,-5,7],[6,-4,6],[0,7,6.5]])
    m.cyl(dx,3,dz,r,r*0.94,20,10,NOVA_SILO_ARM);
  for(const [dx,dz,r] of [[-5,-5,7],[6,-4,6],[0,7,6.5]]){
    m.cyl(dx,23,dz,r*0.96,r*0.5,4,10,NOVA_SILO_ROOF);
    m.cyl(dx,11,dz,r*1.04,r*1.04,1.4,10,NOVA_SILO_CORE);         // banding
  }
  m.box(11,3,0,5,9,5,NOVA_SILO_CORE);
  m.box(13.55,7.0,0,.24,4.0,3.0,TWR_TEAM);                     // control-house faction plate
  m.box(13.72,11.1,0,.18,.22,2.2,NOVA_SILO_GLOW);              // silo status line
  return m.build();
}
function mdlFab(){
  const m=MB();
  const y=novaServicePad(m,37,29,2.5);
  /* A compact conversion line: feed hoppers on the rear, one calm processing

     hall, and an unmistakable energized output stack.  Rusted duplicate drums

     made the former asset look abandoned rather than high-tech. */
  m.bevelBox(-5.0,y,0,22.0,14.0,23.0,1.5,NOVA_FAB_ARM);
  m.bevelBox(-5.0,y+14.0,0,20.0,1.8,21.0,.65,NOVA_FAB_ROOF);
  roofEdge(m,-5.0,y+15.8,0,20.0,21.0,.75,NOVA_FAB_CORE,NOVA_FAB_ROOF);
  for(const s of [-1,1]){
    m.cyl(-14.0,y,s*7.0,3.2,2.7,10.0,10,NOVA_FAB_CORE);
    m.cyl(-14.0,y+10.0,s*7.0,2.7,1.8,2.0,10,NOVA_FAB_ARM);
    m.box(-11.0,y+5.5,s*7.0,4.5,1.2,1.4,NOVA_FAB_CORE);
  }
  m.cyl(11.0,y,0,5.0,4.4,19.0,12,NOVA_FAB_CORE);
  m.cyl(11.0,y+5.0,0,5.2,5.2,.8,12,NOVA_FAB_ROOF);
  m.cyl(11.0,y+19.0,0,4.5,3.1,3.4,12,NOVA_FAB_ARM);
  m.tube(11.0,y+22.3,0,3.2,1.7,1.0,12,TWR_BORE);
  for(const s of [-1,1]) m.box(11.0,y+12.0,s*4.5,3.8,.24,.45,s>0?TWR_GLOW:TWR_TEAM);
  m.box(-5.0,y+8.0,11.65,13.0,2.5,.4,NOVA_FAB_GLASS);
  m.box(2.0,y+3.0,0,8.0,1.4,1.8,TWR_GLOW);
  return m.build();
}
const BLD_MDL={
  mex:mdlMex, pgen:mdlPgen, fac:mdlFac, turret:mdlTurretBase, bunker:mdlBunkerBase, sgen:mdlSgen,
  tgate:mdlTgate, nest:mdlNest, harbor:mdlHarbor, bastion:mdlBastionBase,
  techlab:mdlTechlab, aatower:mdlAA, airfield:mdlAirfield, uplink:mdlUplink,
  hq:mdlHQ, hellstorm:mdlHellstormBase, arc:mdlArc, rail:mdlRailBase, nova:mdlNovaBase, wall:mdlWall,
  minelaser:mdlMiningLaserBase, missilebastion:mdlMissileBastionBase, plasma:mdlPlasmaCharger,
  gate:mdlGate, geo:mdlGeo, silo:mdlSilo, fab:mdlFab,
  seafort:mdlSeafortBase, stormcaller:mdlStormcallerBase,
};
const BLD_TUR_MDL={
  turret:mdlTurretGun, bunker:mdlBunkerGun, bastion:mdlBastionGun,
  aatower:mdlAAGun, hellstorm:mdlHellstormGun, rail:mdlRailGun,
  nova:mdlNovaGun, minelaser:mdlMiningLaserGun, missilebastion:mdlMissileBastionGun,
  seafort:mdlSeafortGun, stormcaller:mdlStormcallerGun
};
/* Sentinel is the production template for visual Mk1/Mk2/Mk3 geometry. Other

   faction/weapon families are catalogued in design/tower-factions and can join

   this registry without changing the renderer again. */
const BLD_TIER_MDL={
  turret:[1,2,3].map(tier=>({base:()=>mdlTurretBase(tier),tur:()=>mdlTurretGun(tier)})),
  bunker:[1,2,3].map(tier=>({base:()=>mdlBunkerBase(tier),tur:()=>mdlBunkerGun(tier)})),
  bastion:[1,2,3].map(tier=>({base:()=>mdlBastionBase(tier),tur:()=>mdlBastionGun(tier)})),
  sgen:[1,2,3].map(tier=>({base:()=>mdlSgen(tier)})),
  uplink:[1,2,3].map(tier=>({base:()=>mdlUplink(tier)})),
  hellstorm:[1,2,3].map(tier=>({base:()=>mdlHellstormBase(tier),tur:()=>mdlHellstormGun(tier)})),
  arc:[1,2,3].map(tier=>({base:()=>mdlArc(tier)})),
  nova:[1,2,3].map(tier=>({base:()=>mdlNovaBase(tier),tur:()=>mdlNovaGun(tier)})),
  minelaser:[1,2,3].map(tier=>({base:()=>mdlMiningLaserBase(tier),tur:()=>mdlMiningLaserGun(tier)})),
  missilebastion:[1,2,3].map(tier=>({base:()=>mdlMissileBastionBase(tier),tur:()=>mdlMissileBastionGun(tier)})),
  plasma:[1,2,3].map(tier=>({base:()=>mdlPlasmaCharger(tier)})),
  aatower:[1,2,3].map(tier=>({base:()=>mdlAA(tier),tur:()=>mdlAAGun(tier)})),
  rail:[1,2,3].map(tier=>({base:()=>mdlRailBase(tier),tur:()=>mdlRailGun(tier)})),
  seafort:[1,2,3].map(tier=>({base:()=>mdlSeafortBase(tier),tur:()=>mdlSeafortGun(tier)})),
  stormcaller:[1,2,3].map(tier=>({base:()=>mdlStormcallerBase(tier),tur:()=>mdlStormcallerGun(tier)}))
};
/* Height at which each turret meets its mount, in the model's own units. */
const BLD_TUR_H={ turret:14, bunker:18, bastion:23, aatower:11, hellstorm:18,
  rail:22, nova:22, minelaser:16, missilebastion:18, seafort:16, stormcaller:22 };
/* Weapon assemblies are deliberately oversized for command-view readability;

   their bases retain the real collision footprint while the moving mass reads

   clearly at phone scale. Keep projectile/beam muzzle offsets in sim.js in

   step with these values. */
const BLD_TUR_S={ turret:1.20, bunker:1.12, bastion:1.14, aatower:1.18, hellstorm:1,
  rail:1.15, nova:1, minelaser:1.14, missilebastion:1, seafort:1.10, stormcaller:1.06 };

/* ---------------------------------------------------------------------------

   WORLD OBJECTS — ruins, scenery, resources, effects.

   --------------------------------------------------------------------------- */
function mdlCityTower(){ return loadWorldModel('mdlCityTower'); }
function mdlCityDome(){ return loadWorldModel('mdlCityDome'); }
function mdlCityHall(){ return loadWorldModel('mdlCityHall'); }
function mdlCityTank(){ return loadWorldModel('mdlCityTank'); }
function mdlRock(){ return loadWorldModel('mdlRock'); }
function mdlTree(){ return loadWorldModel('mdlTree'); }
/* Region flora. One imported broadleaf was the "one tree everywhere" tell.

   These stay procedural and cheap so MEDIUM can instance fewer of the same

   silhouette instead of a second atlas. Authored near-neutral; instance tint

   carries the kit colour. */
function mdlTreePine(){
  const m=MB();
  m.mat(MAT.EARTH);
  m.cyl(0,0,0,1.15,0.72,8.2,6,C(72,56,40));
  m.mat(MAT.DENSE_LEAF);
  m.cyl(0,6.2,0,6.4,0.18,8.0,7,C(46,72,48),false);
  m.cyl(0,10.4,0,4.7,0.14,7.0,7,C(40,68,44),false);
  m.cyl(0,15.0,0,2.9,0.04,5.8,7,C(36,64,40),false);
  return m.build();
}
function mdlTreePalm(){
  const m=MB();
  m.mat(MAT.EARTH);
  m.cyl(0,0,0,0.92,0.52,14.2,6,C(118,92,58));
  m.mat(MAT.LEAF);
  for(let k=0;k<6;k++){
    const a=k/6*TAU;
    m.box(Math.cos(a)*4.3,15.4,Math.sin(a)*4.3,7.6,0.34,1.35,C(70,110,48),a);
  }
  return m.build();
}
function mdlTreeDead(){
  const m=MB();
  m.mat(MAT.EARTH);
  m.cyl(0,0,0,1.02,0.44,12.4,6,C(58,48,40));
  m.box(2.3,9.2,0,5.6,0.68,0.68,C(64,52,42),0.42);
  m.box(-1.7,11.1,1.2,4.3,0.52,0.52,C(60,50,40),-0.72);
  return m.build();
}
function mdlTreeSpore(){
  const m=MB();
  m.mat(MAT.BROOD_CHITIN);
  m.cyl(0,0,0,1.45,0.88,10.2,7,C(88,48,72));
  m.sphere(0,12.1,0,4.3,8,C(160,70,140),0.72);
  m.mat(MAT.BROOD_SLIME);
  m.sphere(0,13.3,0,2.35,7,C(210,90,170),0.80);
  return m.build();
}
function mdlBush(){
  const m=MB();
  m.mat(MAT.LEAF);
  m.sphere(0,1.55,0,2.75,7,C(62,96,44),0.72);
  m.sphere(1.55,1.15,0.55,1.75,6,C(70,104,48),0.70);
  m.sphere(-1.25,1.05,-0.75,1.55,6,C(54,88,40),0.70);
  return m.build();
}
function mdlRockIce(){
  const m=MB();
  m.mat(MAT.ICE_PACK);
  m.sphere(0,2.15,0,4.15,7,C(200,220,236),0.55);
  m.box(-1.15,0,1.35,3.4,2.75,2.15,C(170,190,210),0.38);
  return m.build();
}
function mdlRockSlag(){
  const m=MB();
  m.mat(MAT.BASALT_CRUST);
  m.sphere(0,2.0,0,4.0,7,C(52,44,42),0.50);
  m.box(1.35,0,-0.75,3.15,2.35,2.55,C(40,36,34),0.48);
  m.mat(MAT.BLAST_SLAG);
  m.box(0,2.35,0,1.55,0.48,1.55,C(80,48,36),0.18);
  return m.build();
}
/* A crystal is not four cones. Real mineral habit is a CLUSTER: hexagonal

   prisms sharing a root, leaning apart, each ending in a pointed

   termination - and the faces are FLAT, because flat facets are what catch

   the light as a unit and flash when the camera orbits. Every face here is

   its own plane with its own normal (no smoothing), the shafts kink at a

   mid-ring the way natural columns do, and the whole cluster wears the CRYST

   material so the shader's transmission/fresnel path lights it from inside.

   Authored near-white: the instance tint carries the deposit band colour

   (cyan/green/pink), and a saturated authored hue would fight it. */
function crystalSpike(m,bx,bz,r,h,lx,lz,ph,BASE,MID,TIP){
  const seg=6, mh=h*0.60, A=[], B=[];
  const N=(a,b,c)=>{ const ux=b[0]-a[0],uy=b[1]-a[1],uz=b[2]-a[2],
    vx=c[0]-a[0],vy=c[1]-a[1],vz=c[2]-a[2];
    let nx=uy*vz-uz*vy,ny=uz*vx-ux*vz,nz=ux*vy-uy*vx;
    const l=Math.hypot(nx,ny,nz)||1; return [nx/l,ny/l,nz/l]; };
  for(let k=0;k<seg;k++){
    const a=ph+k/seg*TAU;
    A.push([bx+Math.cos(a)*r,        -1.5, bz+Math.sin(a)*r]);
    /* The mid ring twists 0.12 rad and steps toward the lean: the kink that

       separates "grown column" from "extruded prop". */
    B.push([bx+lx*0.55+Math.cos(a+0.12)*r*0.74, mh, bz+lz*0.55+Math.sin(a+0.12)*r*0.74]);
  }
  const apex=[bx+lx,h,bz+lz];
  for(let k=0;k<seg;k++){
    const j=(k+1)%seg;
    m.quad(A[k],A[j],B[j],B[k],(k%3)?((k%2)?MID:BASE):C(160,190,210));
    const n=N(B[k],apex,B[j]);
    m.tri(B[k],apex,B[j],n[0],n[1],n[2],(k%2)?TIP:MID);
  }
}
function mdlCrystal(){
  const m=MB(); m.mat(MAT.CRYST);
  const BASE=C(120,148,168), MID=C(196,222,238), TIP=C(255,255,255);
  crystalSpike(m, 0.0, 0.0, 3.1, 17.5,  1.7, 0.9, 0.30, BASE,MID,TIP);
  crystalSpike(m, 3.7, 1.1, 2.1, 11.0,  2.3, 1.1, 1.70, BASE,MID,TIP);
  crystalSpike(m,-3.1, 2.3, 1.8,  9.5, -2.1, 1.5, 0.90, BASE,MID,TIP);
  crystalSpike(m,-1.9,-3.3, 1.6,  8.0, -1.1,-2.3, 2.40, BASE,MID,TIP);
  crystalSpike(m, 2.3,-2.9, 1.3,  6.5,  1.5,-1.7, 4.00, BASE,MID,TIP);
  crystalSpike(m,-4.3,-0.7, 1.1,  5.0, -2.5,-0.5, 5.20, BASE,MID,TIP);
  return m.build();
}
function mdlDeposit(){
  /* Shards only. The two STONE cylinders (r 32 / r 17) were the dark

     disk under every crystal node — same hole the terrain scar painted.

     Veins mark the bed; FX.crystal owns the outcrop. */
  const m=MB();
  m.mat(MAT.CRYST);
  const BASE=C(150,178,198), MID=C(214,236,248), TIP=C(255,255,255);
  for(let k=0;k<6;k++){
    const a=k/6*TAU, d=6+(k%2)*4;
    crystalSpike(m, Math.cos(a)*d, Math.sin(a)*d, 3.0-(k%3)*0.6, 9.5+(k%3)*3.5,
                 Math.cos(a)*2.0, Math.sin(a)*2.0, k*1.13, BASE,MID,TIP);
  }
  crystalSpike(m, 0,0,3.8,14.5,0.5,-0.4,0.55,BASE,MID,TIP);
  return m.build();
}
function mdlGeyser(){
  /* Natural vent. Two swaps made the phone-shot hatch:

     1) mdlGeyser() → loadWorldModel('mdlGeyser') (12-gon CONC frustum);

        today's civic ROOF/TRIM remap painted its +Y as a metal iris.

     2) hud.js still stamped sprites.geyser (dark ellipses + 5 rim arcs)

        on top in 3D. A sphere pile from look-down is the same cone.

     Rock spires + offset steam — STONE, not CRYST, so it is not a mass node. */
  const m=MB();
  const ROCK=C(118,108,92), ASH=C(86,80,70), RIM=C(148,138,118), GLOW=C(210,236,248);
  m.mat(MAT.STONE);
  /* Irregular boulders only. crystalSpike facets read as iris plates from

     look-down — that is the hatch again. */
  m.sphere(0,2.8,0,6.2,7,ROCK,0.48);
  m.sphere(-5.6,2.2,3.8,4.4,6,ASH,0.55);
  m.sphere(5.2,2.0,-4.2,4.1,6,RIM,0.52);
  m.sphere(-3.4,1.8,-5.0,3.6,6,ASH,0.60);
  m.sphere(4.8,1.6,4.6,3.4,6,ROCK,0.58);
  m.sphere(1.2,2.4,5.8,3.0,6,RIM,0.62);
  m.sphere(-0.4,11.5,0.6,3.2,7,ROCK,0.78);
  m.sphere(0.8,16.8,-0.4,2.6,7,ASH,0.82);
  m.sphere(-0.5,21.4,0.8,2.0,7,RIM,0.80);
  m.mat(MAT.CRYST);
  m.sphere(0.2,24.6,0.3,3.2,7,GLOW,0.88);
  m.sphere(-0.8,27.8,0.7,2.4,6,GLOW,1.02);
  m.sphere(0.9,30.2,-0.3,1.7,6,GLOW,0.72);
  return m.build();
}
function mdlCrate(){ return loadWorldModel('mdlCrate'); }
function mdlWreck(){ return loadWorldModel('mdlWreck'); }
function mdlBerm(){ return loadWorldModel('mdlBerm'); }
/* Effect geometry — all real solids, no camera-facing quads anywhere. */
function mdlShell(){ return MB().sphere(0,0,0,1,10,C(255,255,255),1,false).build(); }
function mdlBolt(){  return MB().cyl(0,-0.5,0,0.32,0.10,1.6,6,C(255,255,255)).build(); }
function mdlShard(){ return MB().box(0,-0.5,0,1,1,1,C(255,255,255)).build(); }
function mdlBeamSeg(){                        // unit cylinder along +Y, scaled in the shader
  return MB().cyl(0,0,0,1,1,1,7,C(255,255,255),false).build();
}
function mdlCone(){  return MB().cyl(0,0,0,1,0.06,1,10,C(255,255,255),false).build(); }
function mdlRing(){  return MB().ring(0,0,0,0.82,1,30,C(255,255,255)).build(); }
function mdlDisc(){  return MB().ring(0,0,0,0,1,26,C(255,255,255)).build(); }
/* ---------------------------------------------------------------------------

   FLASHLIGHT KIT

   The old headlamp was a camera-facing ribbon: a thin streak that never read

   as light FALLING ON THE GROUND. What sells a flashlight in a top-down view

   is the lit floor, not the beam in the air — a wedge of brightness widening

   from the lamp across the terrain, ending in a pool. Both meshes lie flat on

   the ground and draw in the additive pass, so they brighten whatever they

   cover; the depth test stops them painting across rocks and walls, which

   doubles as free occlusion.



   Gradients are baked as constant-colour bands: under additive blending black

   adds nothing, so a band fading toward black IS the soft edge — no texture.

   Instance scale = reach along +X, the cross-axis lane = cone width, so the

   beam keeps a fixed angle at any length, exactly as a real cone does.

   --------------------------------------------------------------------------- */
function mdlLightWedge(){
  const m=MB();
  const bands=[[0.03,0.28,1.00],[0.28,0.56,0.62],[0.56,0.82,0.30],[0.82,1.00,0.10]];
  for(const [x0,x1,v] of bands){
    const z0=x0*0.5, z1=x1*0.5;                    // half-angle baked: width tracks length
    const cz0=z0*0.42, cz1=z1*0.42;                // bright core strip
    m.quad([x0,0,-cz0],[x1,0,-cz1],[x1,0,cz1],[x0,0,cz0],[v,v,v]);
    const e=v*0.32;                                 // soft flanks
    m.quad([x0,0,-z0],[x1,0,-z1],[x1,0,-cz1],[x0,0,-cz0],[e,e,e]);
    m.quad([x0,0,cz0],[x1,0,cz1],[x1,0,z1],[x0,0,z0],[e,e,e]);
  }
  return m.build();
}
/* Radial pool: bright core falling off to nothing. Serves as the beam's end

   splash and as machine underglow — the hull sitting in its own worklight. */
function mdlLightPool(){
  const m=MB();
  const steps=[[0,0.34,1.00],[0.34,0.60,0.66],[0.60,0.84,0.32],[0.84,1.0,0.09]];
  for(const [r0,r1,v] of steps) m.ring(0,0,0,r0,r1,26,[v,v,v]);
  return m.build();
}
/* ---------------------------------------------------------------------------

   SHADOW DECAL

   The single largest difference between this and the reference art was not

   geometry or texture — it was that nothing cast a shadow, so every building

   and vehicle looked pasted onto the ground rather than standing on it. This

   is the receiver: a flat disc whose vertex colour runs from dark at the core

   to white at the rim. Drawn through the unlit program with a MULTIPLY blend,

   white leaves the ground untouched and dark multiplies it down, so the rings

   read as one soft-edged shadow rather than a stack of decals.

   --------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------

   MODULE MARK — the field badge a crafted module puts on the machine carrying

   it. A ring with a floating core, tinted to the module. Its whole job is to be

   noticed when it stops being there: when a module wears out, the mark simply

   is not drawn, and the player sees that a boost is gone rather than reading

   it in a menu later.

   --------------------------------------------------------------------------- */
function mdlModMark(){
  const m=MB();
  m.ring(0,0,0,0.62,1.0,18,C(255,255,255));
  m.ring(0,0.05,0,1.12,1.30,18,C(255,255,255));
  m.sphere(0,0.34,0,0.34,8,C(255,255,255),1,false);
  for(let k=0;k<3;k++){
    const a=k/3*TAU;
    m.box(Math.cos(a)*0.86,0.02,Math.sin(a)*0.86,0.30,0.10,0.16,C(255,255,255),a);
  }
  return m.build();
}
function mdlShadow(){
  const m=MB();
  const steps=[[0,0.40,0.42],[0.40,0.58,0.55],[0.58,0.74,0.68],[0.74,0.88,0.82],[0.88,1.0,0.94]];
  for(const [r0,r1,v] of steps) m.ring(0,0,0,r0,r1,26,[v,v,v]);
  return m.build();
}
function mdlPlate(){                          // flat unit square on the ground
  const m=MB();
  m.quad([-0.5,0,-0.5],[0.5,0,-0.5],[0.5,0,0.5],[-0.5,0,0.5],C(255,255,255));   // faces up
  return m.build();
}
/* A unit-LENGTH, hairline-WIDTH strip. Instances carry a single uniform scale,

   so a thin line can't be made by squashing a square — it needs its own mesh

   with the thinness baked in. Everything rectilinear on the ground (build-zone

   borders, range squares, guides) is drawn from this. */
function mdlLine(){
  const m=MB();
  m.quad([-0.5,0,-0.5],[0.5,0,-0.5],[0.5,0,0.5],[-0.5,0,0.5],C(255,255,255));   // 1 x 1; width comes from the instance
  return m.build();
}

/* ---------------------------------------------------------------------------

   Upload everything once, at boot. Caps are sized to what can realistically be

   on screen at once, not to MAXU — culling keeps the instance streams small.

   --------------------------------------------------------------------------- */
const FX={};
/* ============================================================================

   SECOND-WAVE CHASSIS

   Each of these exists to make a role readable at a glance. A crowd-control

   launcher has to look like a launcher from directly overhead, an anti-tank

   gun has to read as one long barrel, and a hero has to be unmistakable in a

   press of two hundred units.

   ============================================================================ */
/* THESE SIX SHARED ONE HEXAGON.

   Reaper, Cinder, Lancer, Resonator, Warden and Harbinger were all a 6-point

   extrude whose profiles differed by under 0.6 world units — the same plan-view

   shape in six colours. Top-down, the hull footprint IS the silhouette, so at

   40px of screen they were the same vehicle. Each now gets a genuinely

   different outline: octagon, drum, arrowhead, spade. */
function mdlReaper(){                        // saturation launcher — wide octagonal carrier
  const m=MB();
  runningGear(m,12,3.0,2.6,3.2,5,MET_D,1);
  m.extrude(0,3.4,0,[[-6.2,-5.0],[-3.6,-6.3],[3.6,-6.3],[6.2,-5.0],
                     [6.2,5.0],[3.6,6.3],[-3.6,6.3],[-6.2,5.0]],2.6,MET);
  /* The hull was a bare octagonal slab with a box cradle on it — correct

     silhouette, no fabrication. A launcher is a BOX OF TUBES on a frame, so

     the frame has to be visible: a recessed deck, a cradle that is a trapezoid

     with end cheeks rather than a slab, elevation rams under it, and the tubes

     bedded into a real backplate instead of floating. */
  m.extrude(0,6.0,0,[[-5.4,-4.3],[-3.1,-5.4],[3.1,-5.4],[5.4,-4.3],
                     [5.4,4.3],[3.1,5.4],[-3.1,5.4],[-5.4,4.3]],0.6,MET_D);
  m.wedge(4.4,6.0,0,2.4,0.9,7.6,MET_L);                     // glacis
  /* CRADLE: trapezoid body, cheek plates at each end, and the whole thing

     pitched up so it reads as elevated rather than as a lid. */
  m.extrude(-0.6,6.6,0,[[-4.2,-3.4],[3.4,-2.9],[4.2,-1.5],[4.2,1.5],
                        [3.4,2.9],[-4.2,3.4]],2.6,TEAM_A);
  for(const sd of [-1,1]){
    m.bevelBox(-0.6,6.6,sd*3.3,8.0,2.7,0.7,0.24,MET_D);     // cheek plates
    m.cyl(-3.0,6.2,sd*2.4,0.42,0.34,2.0,7,MET_L);           // elevation ram
    m.bevelBox(2.6,6.4,sd*4.5,3.0,1.3,1.1,0.26,MET_D);      // sponson pods
    m.cyl(5.0,6.5,sd*3.0,0.30,0.26,1.1,6,MET_L);            // tie-downs
  }
  m.box(-4.6,7.0,0,1.0,2.4,6.2,MET_D);                      // backplate the tubes bed into
  for(let r=0;r<3;r++) for(const sd of [-1,1]){
    m.tube(1.2+r*0.2,7.4+r*1.5,sd*(1.1+r*0.9),0.85,0.55,5.6,8,DARKER,0);
    m.ring(4.0+r*0.2,7.4+r*1.5,sd*(1.1+r*0.9),0.58,0.90,8,MET_L);   // muzzle collars
  }
  m.bevelBox(-4.4,7.6,0,2.4,2.0,4.6,0.32,MET_D);            // reload gantry
  ventBank(m,-3.0,6.62,0,2.4,3.0,4,MET_D,0);
  stowage(m,-1.2,6.62,4.0,3.0,1.1,RUST,0,53);
  exhaust(m,-5.6,4.8,0,2,0.40,2.0,MET_D,2.0);
  glowStrip(m,-0.6,9.9,0,6.4,HOT,0);
  deckCrown(m,0,6.02,0,12.4,12.6,MET_D,TEAM_T);
  return {hull:m.build(),tur:null,s:1.0};
}
function mdlCinder(){                        // incendiary sprayer — tanks and nozzle
  const m=MB();
  runningGear(m,11,2.8,2.4,3.0,5,MET_D,1);
  /* Squared-off tanker plan, and the fuel drums below now break its outline

     rather than hiding inside a hex the same width as everyone else's. */
  m.extrude(0,3.2,0,[[-5.8,-4.4],[4.2,-4.4],[5.4,-2.2],[5.4,2.2],[4.2,4.4],[-5.8,4.4]],2.4,MET);
  /* The drums were doing all the work and the body under them was bare. A

     flame vehicle is PLUMBING: tanks need end caps, bands and a cradle; the

     nozzle needs a pump, a feed line running back to the tanks, and a heat

     shield. Every one of those also breaks the silhouette. */
  m.extrude(0,5.6,0,[[-5.2,-3.7],[3.8,-3.7],[4.8,-1.9],[4.8,1.9],[3.8,3.7],[-5.2,3.7]],0.5,MET_D);
  m.wedge(4.2,5.6,0,2.2,0.9,6.4,MET_L);                     // glacis
  for(const sd of [-1,1]){
    m.cyl(-2.6,5.9,sd*2.2,1.9,1.9,5.4,10,RUST,Math.PI/2);   // fuel drum
    m.cyl(-5.3,5.9,sd*2.2,2.0,1.6,0.5,10,MET_D,Math.PI/2);  // end caps
    m.cyl( 0.1,5.9,sd*2.2,1.6,2.0,0.5,10,MET_D,Math.PI/2);
    for(let k=0;k<2;k++) m.cyl(-4.0+k*2.4,5.9,sd*2.2,2.02,2.02,0.30,10,MET_L,Math.PI/2); // bands
    m.bevelBox(-2.6,4.9,sd*2.2,5.6,1.0,1.5,0.24,MET_D);     // tank cradle
    m.cyl(1.4,6.6,sd*1.5,0.26,0.24,4.6,6,DARKER,Math.PI/2); // feed line to the pump
  }
  m.bevelBox(2.6,5.9,0,3.2,1.9,2.6,0.36,MET_D);             // pump housing
  m.cyl(2.6,7.8,0,0.75,0.60,0.9,9,MET_L);                   // pressure vessel
  m.bevelBox(4.8,6.1,0,1.5,1.3,1.9,0.28,MET_L);             // nozzle mount
  m.tube(6.4,6.1,0,0.9,0.55,3.2,8,HOT,Math.PI/2);           // nozzle
  m.wedge(5.6,7.1,0,1.8,0.7,2.6,MET_D);                     // heat shield over the nozzle
  m.bevelBox(-5.4,6.1,0,1.5,1.5,4.2,0.3,DARKER);
  ventBank(m,-1.0,5.68,0,2.0,2.2,3,MET_D,0);
  exhaust(m,-5.6,4.6,0,2,0.36,1.8,MET_D,1.8);
  glowStrip(m,-2.6,8.4,0,4.6,HOT,0);
  deckCrown(m,-0.2,5.62,0,11.2,8.8,MET_D,TEAM_T);
  return {hull:m.build(),tur:null,s:1.0};
}
function mdlLancer(){                        // gauss rifle — one very long barrel
  const m=MB();
  runningGear(m,12,2.8,2.4,3.2,5,MET_D,0);
  m.extrude(0,3.2,0,[[-6.6,-1.9],[1.8,-2.5],[7.4,-1.0],[8.8,0],
                     [7.4,1.0],[1.8,2.5],[-6.6,1.9]],2.2,MET);
  m.bevelBox(-1.0,5.4,0,6.0,2.4,4.4,0.5,TEAM_A);
  m.cyl(4.0,6.4,0,0.75,0.62,13.0,10,MET_D,Math.PI/2);       // rail
  for(let k=0;k<4;k++) m.tube(5.0+k*2.6,6.4,0,1.05,0.78,0.55,10,ENERGY,Math.PI/2);  // coils
  m.box(-4.4,6.2,0,2.4,2.6,3.6,DARKER);                     // capacitor bank
  m.wedge(4.6,5.42,0,3.6,1.1,3.2,MET_L);                    // nose spine
  for(const sd of [-1,1]) m.bevelBox(-1.6,4.9,sd*2.1,7.0,1.3,0.9,.24,MET_D);   // side rails
  exhaust(m,-6.2,4.9,0,2,.40,2.0,MET_D,1.8);
  glowStrip(m,-4.4,7.6,0,3.0,ENERGY,0);
  deckCrown(m,-0.4,5.42,0,12.0,5.0,MET_D,TEAM_T);
  return {hull:m.build(),tur:null,s:1.0};
}
function mdlResonator(){                     // sonic — dish and ribs
  const m=MB();
  /* The circular plan is the right call and it stays — nothing else in the

     roster is round from above, so it is identifiable in one glance. What was

     missing is everything that makes a round thing look ENGINEERED: the drum

     had no rim, no ribs, no seam, so it read as a barrel someone left on a

     tank. Chamfered rim, radial ribs, and an emitter stack that is obviously a

     resonator rather than a turret. */
  runningGear(m,11,2.8,2.4,3.0,5,MET_D,1);
  m.cyl(0,3.2,0,4.7,4.4,1.9,16,MET);                        // drum body
  m.cyl(0,5.1,0,4.4,4.0,0.55,16,MET_L);                     // chamfered rim
  m.cyl(0,5.65,0,3.7,3.7,0.30,16,MET_D);                    // recessed deck
  /* RADIAL RIBS. Eight spokes turn a smooth cylinder into a fabricated housing,

     and from overhead they are what breaks the circle up. */
  for(let k=0;k<8;k++){
    const a=k/8*TAU;
    m.box(Math.cos(a)*3.0,5.66,Math.sin(a)*3.0,2.6,0.34,0.52,MET_L,a);
  }
  m.box(-4.4,3.2,0,2.4,2.2,5.8,MET_D);                      // rear counterweight
  armorPlate(m,-4.4,4.2,0,4.6,1.2,0.38,0,TEAM_A,0);

  /* EMITTER STACK — three rings on a short column, widest at the base, so the

     shape reads as a horn projecting upward. */
  m.cyl(1.4,5.95,0,2.2,1.7,1.1,14,MET_D);
  for(let k=0;k<3;k++) m.ring(1.4,7.05+k*0.52,0,1.9-k*0.46,2.5-k*0.46,18,k?ENERGY:MET_L);
  m.cyl(1.4,8.7,0,0.9,0.5,0.7,12,ENERGY);
  for(const sd of [-1,1]){
    m.bevelBox(-3.0,5.9,sd*1.9,2.6,1.5,1.3,0.30,TEAM_A);    // capacitor pods
    m.box(-3.0,7.4,sd*1.6,2.4,0.42,0.42,ENERGY);
    m.cyl(3.6,5.5,sd*2.4,0.30,0.26,1.1,6,MET_D);            // tie-downs
  }
  ventBank(m,-2.0,5.68,2.4,2.0,1.6,3,MET_D,0);
  glowStrip(m,0,5.98,0,3.2,ENERGY,0);
  return {hull:m.build(),tur:null,s:1.0};
}
function mdlWarden(){                        // field repair — crane and drum
  const m=MB();
  /* A support vehicle has to read as a TOOL, not as a gun with the barrel taken

     off. It was a plain hex slab with a drum on top; the drum was the only

     thing saying "repair", and from overhead a drum is a circle like any other.

     Rebuilt around the working end: a hose reel with visible spooled line, a

     folding gantry that reaches OVER the thing being repaired, and hazard

     chevrons on the deck. Hard-surface throughout — bevels, plate breaks and an

     inner extrusion — because it is a machine. */
  runningGear(m,10,2.6,2.2,2.8,4,MET_D,0);
  const HB=[[-4.8,-2.9],[-2.4,-3.3],[2.6,-3.1],[4.5,-1.6],[4.5,1.6],[2.6,3.1],[-2.4,3.3],[-4.8,2.9]];
  m.extrude(0,3.0,0,HB,2.0,MET);
  m.extrude(0,5.0,0,HB.map(q=>[q[0]*0.82,q[1]*0.82]),0.7,MET_D);      // recessed deck
  armorPlate(m,-0.4,5.1,0,4.4,1.1,0.36,0,TEAM_A,0);

  /* HOSE REEL. Two cheeks with a spooled drum between them reads as a reel at a

     glance; a bare cylinder does not. */
  for(const sd of [-1,1]) m.cyl(-1.4,5.7,sd*1.9,2.0,2.0,0.42,12,MET_L,Math.PI/2);
  for(let k=0;k<5;k++) m.cyl(-1.4,5.7,-1.5+k*0.75,1.62-k*0.06,1.62-k*0.06,0.62,10,DARKER,Math.PI/2);
  m.tube(-1.4,7.5,0,1.5,0.9,0.5,12,ENERGY);                            // emitter head

  /* FOLDING GANTRY — the arm reaches forward and DOWN over the casualty, which

     is the shape that says "working on something" rather than "aiming". */
  m.bevelBox(2.2,5.6,0,1.7,1.9,2.0,0.32,MET_D);                        // shoulder
  m.cyl(2.2,7.4,0,0.40,0.36,1.5,7,MET_L);
  m.box(3.8,8.5,0,3.8,0.62,0.62,MET_L);                                // upper boom
  m.box(5.6,7.6,0,0.58,2.0,0.58,MET_D);                                // drop link
  m.cyl(5.6,6.5,0,0.85,0.55,0.8,9,ENERGY);                             // repair emitter
  hydraulic(m,2.9,5.9,0,2.4,0.26,MET_L,0);

  /* Hazard chevrons on the rear deck — the visual language of a service

     vehicle, and it lands where the top-down camera actually looks. */
  for(let k=0;k<3;k++) m.box(-3.4+k*0.9,5.74,0,0.44,0.14,4.2,k&1?MET_D:LAMP,0.42);
  ventBank(m,-4.0,5.72,0,1.6,3.0,3,MET_D,0);
  stowage(m,0.8,5.72,2.3,2.4,1.0,RUST,0,23);
  glowStrip(m,2.2,6.66,0,2.6,ENERGY,0);
  deckCrown(m,0,5.72,0,8.6,6.2,MET_D,TEAM_T);
  return {hull:m.build(),tur:null,s:0.95};
}
function mdlKestrel(){                       // scout aircraft — thin delta
  const m=MB();
  const keel=[[-7.25,-1.30],[-4.25,-1.72],[2.35,-2.05],[6.45,-.82],[7.65,0],
              [6.45,.82],[2.35,2.05],[-4.25,1.72],[-7.25,1.30]];
  const spine=[[-6.30,-1.02],[-3.65,-1.30],[2.40,-1.48],[5.85,-.58],[6.65,0],
               [5.85,.58],[2.40,1.48],[-3.65,1.30],[-6.30,1.02]];
  m.extrude(0,0,0,keel,1.12,MET_D);                          // shallow sensor-aircraft keel
  m.extrude(0,1.12,0,spine,1.18,MET);
  m.extrude(.30,2.30,0,spine.map(p=>[p[0]*.76,p[1]*.65]),.48,TEAM_A);
  m.bevelBox(3.60,2.46,0,2.85,.88,1.72,.32,GLASS);            // low-profile sensor canopy
  m.wedge(5.43,2.68,0,1.48,.44,1.48,MET_L,0,true);
  m.box(-.72,2.80,0,4.25,.28,.76,TEAM_T);                     // dorsal livery rail
  glowStrip(m,-.15,3.07,0,2.60,ENERGY,0);
  for(const sd of [-1,1]){
    const wing=sd>0
      ? [[-4.65,1.05],[2.70,1.28],[.55,6.10],[-5.45,5.02]]
      : [[-4.65,-1.05],[-5.45,-5.02],[.55,-6.10],[2.70,-1.28]];
    const panel=sd>0
      ? [[-3.72,1.55],[1.72,1.60],[.35,5.02],[-4.28,4.42]]
      : [[-3.72,-1.55],[-4.28,-4.42],[.35,-5.02],[1.72,-1.60]];
    m.extrude(0,.64,0,wing,.60,MET_D);                        // continuous delta wing
    m.extrude(0,1.24,0,panel,.23,TEAM_A);                     // team panel follows silhouette
    m.box(-3.55,1.26,sd*4.78,3.35,.55,1.10,DARK);             // attached wing spar housing
    m.bevelBox(-3.90,1.80,sd*4.78,2.35,.62,.88,.22,MET_L);
    m.box(-4.60,2.36,sd*4.78,2.15,1.55,.34,TEAM_A);           // canted-looking wingtip fin
    m.box(-4.18,3.64,sd*4.78,1.25,.26,.42,LAMP);              // navigation lamp on fin
    m.box(-4.90,.78,sd*1.14,3.05,.88,1.32,DARKER);            // twin micro-turbines merge into tail
    cylX(m,-7.12,.92,sd*1.14,3.42,.72,.61,10,DARK,false);
    tubeX(m,-7.66,.92,sd*1.14,.88,.58,.27,10,TWR_BORE);      // real hollow exhaust
    ringX(m,-7.70,.92,sd*1.14,.52,.78,12,MET_L);
    ringX(m,-7.73,.92,sd*1.14,.20,.30,10,HOT);
    ringX(m,-3.74,.92,sd*1.14,.44,.65,10,MET_L);              // intake rim
    m.box(3.72,.42,sd*.83,2.15,.72,.64,DARK);                 // attached nose-gun receiver
    gunX(m,4.45,.68,2.58,.22,MET_D,sd*.83);
    m.bevelBox(-.95,.38,sd*4.92,2.50,.76,.92,.22,DARKER);     // sensor / countermeasure pod
    for(let k=0;k<3;k++)
      m.box(-1.72+k*.78,1.15,sd*4.92,.42,.30,.48,MET_L);
  }
  m.bevelBox(-5.48,1.62,0,2.55,1.02,2.45,.28,DARKER);        // tail join prevents floating fins
  ventBank(m,-2.62,2.80,0,1.95,1.10,4,MET_D,0);
  m.greeble(.05,2.80,0,2.55,.82,.28,5,MET_D,0,251);
  sensorMast(m,-4.48,2.60,0,1.12,MET_L);
  return {hull:m.build(),tur:null,s:0.92};
}
function mdlBasilisk(){                      // heavy siege tank, turreted
  const m=MB();
  /* THE DETAIL BUDGET RAN BACKWARDS. This is a tier-3 experimental at 260 mass

     and 1050 energy, and its hull was five primitive calls — against roughly

     twenty on the Goliath, a tier-2 costing a quarter as much. A player who

     pays four times the price should not receive a model with a quarter of the

     surface break-up. Brought up to the Goliath's vocabulary and past it:

     that is what "experimental" has to look like. */
  runningGear(m,17,4.4,3.6,4.6,7,MET_D,2);
  m.extrude(0,4.2,0,[[-8.4,-4.8],[4.6,-5.4],[7.4,-2.6],[7.4,2.6],[4.6,5.4],[-8.4,4.8]],3.4,MET);
  m.wedge(6.4,7.6,0,4.6,2.2,9.2,MET_L);                     // heavy glacis
  for(const sd of [-1,1]){
    armorPlate(m,0.5,7.6,sd*4.6,9.0,2.0,0.7,0,TEAM_A,0);
    m.bevelBox(3.2,8.0,sd*3.8,5.0,1.6,2.2,.35,MET_D);       // sponson blisters
    m.cyl(6.8,7.9,sd*3.2,.32,.28,1.2,6,MET_L);              // tow points
  }
  ventBank(m,-5.4,7.62,0,4.8,6.8,7,MET_D,0);
  exhaust(m,-7.8,6.2,0,3,.52,2.8,MET_D,2.6);
  stowage(m,-2.2,7.62,4.2,6.6,2.0,RUST,0,29);
  sensorMast(m,-6.8,7.9,2.6,3.4,MET_L);
  deckCrown(m,0,7.66,0,14.0,9.4,MET_D,TEAM_T);
  m.bevelBox(-6.0,7.8,0,3.6,2.4,7.0,0.6,DARK);
  return {hull:m.build(), tur:(()=>{
    const t=MB();
    t.bevelBox(-0.6,0,0,7.4,3.4,6.4,0.8,TEAM_A);
    t.cyl(3.0,1.6,0,0.95,0.80,11.0,10,MET_D,Math.PI/2);
    t.tube(13.4,1.6,0,1.25,0.90,1.0,10,DARKER,Math.PI/2);   // muzzle brake
    t.box(-3.6,2.6,0,2.4,1.6,4.0,MET_L);
    return t.build();
  })(), s:1.05, turH:7.6};
}
function mdlHarbinger(){                     // long-range cluster artillery
  const m=MB();
  runningGear(m,16,4.0,3.2,4.2,6,MET_D,2);
  m.extrude(0,3.8,0,[[-9.0,-3.2],[-6.2,-5.6],[4.2,-5.6],[7.2,-2.2],
                     [7.2,2.2],[4.2,5.6],[-6.2,5.6],[-9.0,3.2]],3.0,MET);
  m.bevelBox(-1.0,6.8,0,9.0,2.6,8.0,0.7,TEAM_A);
  for(let r=0;r<2;r++) for(let c=-1;c<=1;c++)
    m.tube(0.0,8.4+r*2.0,c*2.6,1.15,0.78,7.2,8,DARKER,0);
  for(const sd of [-1,1]){
    m.box(-6.0,5.4,sd*4.6,3.0,1.4,1.4,MET_L);                        // outriggers
    m.bevelBox(-6.2,4.9,sd*5.0,2.4,1.2,1.0,.28,MET_D);               // outrigger feet
    armorPlate(m,0.0,6.4,sd*5.2,10.0,2.2,0.6,0,TEAM_A,0);            // flank skirts
    m.cyl(5.6,6.5,sd*2.8,.34,.30,1.2,6,MET_L);                       // tow points
  }
  ventBank(m,-4.6,6.84,0,4.2,6.0,6,MET_D,0);
  exhaust(m,-7.4,5.6,0,3,.48,2.6,MET_D,2.4);
  stowage(m,-2.0,6.84,3.9,5.6,1.8,RUST,0,17);
  glowStrip(m,-1.0,8.2,0,7.0,HOT,0);
  deckCrown(m,-0.4,6.82,0,16.0,11.0,MET_D,TEAM_T);
  return {hull:m.build(),tur:null,s:1.05};
}
/* ---- FACTION HEROES ------------------------------------------------------- */
function mdlPraetor(){                       // Legion — a walking siege battery
  const m=MB();
  for(const sd of [-1,1]){
    m.bevelBox(-1.2,0,sd*4.4,7.0,2.2,4.0,0.6,SERVO);
    m.extrude(-0.4,2.2,sd*4.4,[[-2.0,-2.1],[2.0,-2.1],[2.4,0],[2.0,2.1],[-2.0,2.1],[-2.4,0]],5.6,SERVO);
    hydraulic(m,-2.0,2.2,sd*4.4,5.2,0.52,SERVO,0);
    m.bevelBox(0.2,7.8,sd*4.4,4.8,3.0,4.8,0.7,SERVO);
    m.box(0.2,10.8,sd*4.4,4.2,3.2,4.2,SERVO);
  }
  m.extrude(0,13.6,0,[[-5.4,-5.8],[3.2,-6.2],[5.8,-3.0],[5.8,3.0],[3.2,6.2],[-5.4,5.8]],6.4,MET);
  m.extrude(0,20.0,0,[[-4.4,-4.8],[2.6,-5.2],[4.8,-2.4],[4.8,2.4],[2.6,5.2],[-4.4,4.8]],2.4,TEAM_A);
  for(const sd of [-1,1]){
    m.bevelBox(0.2,19.0,sd*7.4,5.4,4.4,4.4,0.8,TEAM_A);     // pauldrons
    armorPlate(m,0.2,23.4,sd*7.4,5.0,1.8,0.6,0,MET_D,0);
    for(let r=0;r<2;r++) m.tube(-1.0,21.0+r*1.8,sd*7.4,1.0,0.68,5.4,8,DARKER,0);  // shoulder mortars
  }
  cylX(m,4.6,16.4,0,12.0,1.15,0.95,10,MET_D,false);          // siege cannon
  tubeX(m,16.0,16.4,0,1.2,1.5,1.05,10,DARKER);              // open muzzle collar
  m.bevelBox(-4.6,20.2,0,4.0,3.2,7.0,0.7,DARK);
  m.bevelBox(2.6,24.6,0,4.0,3.0,5.0,0.6,TEAM_A);            // head
  m.box(4.6,25.6,0,0.6,1.2,3.4,HOT);
  glowStrip(m,0,22.6,0,7.0,HOT,0);
  return {hull:m.build(),tur:null,s:1.10};
}
function mdlArchon(){                        // Syndicate — hovering, shielded
  const m=MB();
  /* NINE PRIMITIVES, and one of them was wrong in a way no screenshot catches:

     the plenum skirt was an OPEN cyl(), so from any angle below the horizon the

     Broker had a black hole where its underside should be — cyl() only caps

     when its ninth argument is truthy, and this one passed nothing. The rest

     was a slab, a glass ball, three flat rings and two wedges that read as

     signboards, on the faction hero of the cybernetic army.

     Rebuilt as Syndicate hardware. Three things do the work: a CLOSED plenum

     ring carrying six discrete lift pods, so the round base reads as engineered

     repetition instead of as a disc; a chassis with a real plate break and

     applique armour over it; and the sonic weapon actually PRESENT at the nose,

     because TYPES gives this thing 70 damage on a 0.55 cooldown and the old

     model had nowhere for it to come from. */

  /* ---- PLENUM. Solid and chamfered, not a bucket: an open ring is a well the

     camera looks straight down into, and the old skirt was worse than that

     because cyl() left it uncapped at both ends. --------------------------- */
  chamferCyl(m,0,0.35,0,5.4,1.75,10,MET_D,MET_L);           // lift drum
  m.ring(0,0.30,0,1.6,4.6,10,ENERGY);                       // under-wash, seen at low angles
  /* SIX LIFT PODS. Repetition at a fixed angular interval is what makes a round

     thing read as machined; a smooth ring reads as a coin. */
  for(let k=0;k<6;k++){
    const a=k/6*TAU, cx=Math.cos(a)*4.9, cz=Math.sin(a)*4.9;
    m.bevelBox(cx,1.05,cz,2.5,1.35,2.1,0.34,MET,a);
    m.box(cx,0.72,cz,1.7,0.34,1.3,HOT,a);                   // pod throat, underslung
  }

  /* ---- CHASSIS. A DART in plan, not an octagon. This camera looks almost

     straight down, so PLAN VIEW IS THE SILHOUETTE, and a hero that cannot state

     which way it faces from directly above is unreadable exactly when it

     matters. Prow at +X, shoulders at the back, two extrusions stepped so there

     is a real plate break all the way round.

     The body stays BRIGHT (MET / MET_L) and only the plinth and the recesses go

     dark: the reference chassis in this file read the way they do because of

     that value split, and a hull painted MET_D everywhere loses its own panel

     breaks before the tint is even applied. ------------------------------- */
  const LO=[[-5.0,-3.4],[-2.8,-4.3],[1.4,-3.9],[5.4,-1.5],[7.0,0],
            [5.4,1.5],[1.4,3.9],[-2.8,4.3],[-5.0,3.4]];
  m.extrude(0,2.30,0,LO,2.2,MET_D);                          // dark plinth
  m.extrude(0,4.50,0,LO.map(p=>[p[0]*0.93,p[1]*0.90]),1.5,MET);
  m.extrude(0,6.00,0,LO.map(p=>[p[0]*0.80,p[1]*0.72]),0.55,MET_L);
  /* THE LIVERY IS ONE PANEL, and it is the one the camera looks straight at:

     the whole upper deck. Scattering five thin stripes over a hull reads as

     pinstriping at 60px; a single top-facing plate reads as an army. */
  m.extrude(0,6.55,0,LO.map(p=>[p[0]*0.66,p[1]*0.58]),0.34,TEAM_A);
  for(const sd of [-1,1]){
    armorPlate(m,-0.4,2.7,sd*4.3,6.6,1.8,0.42,0,MET_D,0);    // applique belt
    m.box(0.2,4.44,sd*3.55,7.0,0.42,0.70,TEAM_B);            // flank accent
    insetPanel(m,-2.6,6.06,sd*2.2,3.0,1.6,0.28,MET_D,0);     // recessed deck panel
    m.wedge(3.8,6.02,sd*1.7,3.0,0.8,2.2,MET_L,0,sd<0);       // prow shoulder fairings
  }
  ventBank(m,-3.6,6.06,0,2.0,3.2,4,MET_D,0);
  glacisX(m,4.8,6.02,0,3.2,0.9,3.2,MET_L);                   // raked nose deck

  /* ---- SONIC PROJECTORS. Two horns carried OUTSIDE the prow and projecting

     past it, so the weapon is part of the OUTLINE rather than a detail sitting

     on top of it. A sound weapon wants a flared throat, not gunX's bore. --- */
  for(const sd of [-1,1]){
    m.bevelBox(4.0,3.2,sd*3.1,3.6,2.4,2.4,0.42,MET);         // trunnion housing
    cylX(m,4.6,4.4,sd*3.1,3.8,0.62,1.45,8,MET_L,false);      // flared horn
    ringX(m,8.2,4.4,sd*3.1,0.44,1.54,8,ENERGY);              // emitter face
    hydraulic(m,2.6,3.2,sd*3.1,1.8,0.26,MET_L,0);            // elevation ram
    m.box(2.6,5.66,sd*3.1,2.8,0.34,1.8,TEAM_B);              // feed cover livery
  }

  /* ---- CORTEX. A naked glass ball is a marble. Set the glass INSIDE a

     bevelled cowl so only a band of it shows and the sensor reads as armoured

     hardware carrying an eye. -------------------------------------------- */
  m.bevelBox(-0.6,6.89,0,4.4,1.7,4.0,0.55,MET);              // cortex housing
  m.sphere(-0.6,8.05,0,1.6,8,GLASS,0.62,true);               // glazed dome
  m.bevelBox(-0.6,8.55,0,3.4,0.65,3.2,0.40,MET_L);           // cowl cap over it
  m.box(1.2,8.05,0,0.55,0.5,1.9,LAMP);                       // forward eye slit

  /* ---- DORSAL VANES. Swept delta fins, root fairing to tip cap, raked BACK so

     they point away from the prow and reinforce the facing. --------------- */
  for(const sd of [-1,1]){
    m.extrude(0,6.30,sd*2.9,[[-4.6,-0.36],[-1.2,-0.36],[0.9,0.36],[-3.4,0.36]],3.0,MET);
    m.box(-2.6,9.30,sd*2.9,4.0,0.34,0.80,MET_L);             // vane cap
    m.wedge(-0.4,6.30,sd*2.9,2.0,1.7,0.82,MET_L,0,sd<0);     // root fairing
    glowStrip(m,-2.6,7.20,sd*3.35,3.2,ENERGY,0);             // coil conduit
  }
  m.bevelBox(-4.9,6.06,0,2.6,2.4,4.2,0.5,MET_D);             // reactor bustle
  exhaust(m,-6.0,6.06,0,2,0.44,1.5,MET_D,2.0);
  return {hull:m.build(),tur:null,s:1.06};
}
function mdlBroodmother(){                   // Horde — a walking hive
  const m=MB();
  /* The progenitor. Same kit as the drone and the Alpha, at hive scale — the

     player has to recognise it instantly as the thing all the others came out

     of, and that only works if it is built from the same anatomy rather than

     from a different set of shapes that happen to be purple. Eight legs, a

     swollen egg-bearing abdomen, and a crown. */
  carapace(m,-1.2,6.2,0,22.0,6.6,4.2,CHITIN,
    {segs:8,ridge:0.26,bump:0.13,keel:0.44,nose:0.52,tail:0.12,
     waist:0.38,waistAt:0.56,waistW:0.065,seed:9091,u:18,v:22});
  carapace(m,8.0,5.9,0,6.4,3.8,3.0,CHIT_D,
    {segs:3,ridge:0.20,bump:0.16,keel:0.30,nose:0.36,tail:0.42,seed:404,u:12,v:9});
  eyeCluster(m,10.0,6.5,0,1.35,3,LAMP);

  for(let k=0;k<4;k++) for(const sd of [-1,1])
    broodLeg(m, 4.0-k*3.0, 5.6, 0, sd, 5.8+k*0.26, 5.6, 3.90-k*0.20, 0.96, null,
             ((k+(sd<0?1:0))&1)*Math.PI, [4.05,3.15,4.10,3.70][k]);

  for(const sd of [-1,1]){
    chitinBlade(m,9.0,5.6,sd*2.0,7.2,0.90,-sd*0.46,sd*0.26,CLAW,0.08);   // hive jaws
    chitinBlade(m,8.8,6.6,sd*1.1,4.8,0.54,-sd*0.34,sd*0.12,CLAW,0.12);
    tendril(m,9.2,7.9,sd*1.5,9.5,0.38,sd,4.2,BIO_LEG);
    tendril(m,7.4,8.4,sd*2.4,7.6,0.30,sd,3.4,BIO_LEG);
    /* Brood-lumen lobes — the egg sacs. Lit tissue, so they carry the faction

       colour and glow through the translucency term. */
    m.sphere(-7.0,8.0,sd*2.7,2.3,9,BIO_TEAM,0.74,false);
    m.sphere(-3.8,8.6,sd*2.9,1.6,8,BIO_TEAM,0.74,false);
    chitinBlade(m,1.6,7.6,sd*3.0,6.4,0.62,sd*0.28,Math.PI*0.84,CLAW,0.60);
  }
  /* Dorsal crown, and a ring of spiracle vents around the abdomen. */
  for(let k=0;k<8;k++)
    chitinBlade(m,-6.4+k*1.75,8.4,0,3.4+Math.sin(k/7*Math.PI)*3.0,0.50,0.10,Math.PI*0.96,CLAW,1.00);
  for(let k=0;k<6;k++){
    const a=k/6*TAU;
    m.tube(-6.0+Math.cos(a)*3.4,8.9,Math.sin(a)*3.4,0.78,0.40,0.66,8,CHIT_D);
  }
  tubercles(m,-5.4,7.8,0,4.4,3.6,12,1.15,CHIT_D,61);
  return {hull:m.build(),tur:null,s:1.16};
}
/* Build an instancing registry from a faction model map. A faction may replace

   only the silhouettes it owns; bldMeshFor() falls back to Nova geometry for

   old saves or intentionally shared structures. A complete single-mesh weapon

   omits a turret map, preventing a legacy Nova barrel from being drawn over it. */
function initBldMeshSet(modelMap,turMap,tierMap,turH,turS,cap){
  const out={}; cap=cap||260;
  for(const k in BLD_MDL){
    if(!modelMap||typeof modelMap[k]!=='function') continue;
    const tiers=tierMap&&tierMap[k];
    const variants=tiers?tiers.map(V=>({
      base:new InstMesh(gl,V.base(),cap),tur:V.tur?new InstMesh(gl,V.tur(),cap):null
    })):null;
    out[k]=variants?{base:variants[0].base,tur:variants[0].tur,variants}: {
      base:new InstMesh(gl,modelMap[k](),cap),
      tur:turMap&&turMap[k]?new InstMesh(gl,turMap[k](),cap):null,
      variants:null
    };
    out[k].turH=turH&&turH[k]!=null?turH[k]:(BLD_TUR_H[k]||14);
    out[k].turS=turS&&turS[k]!=null?turS[k]:(BLD_TUR_S[k]||1);
  }
  return out;
}
/* THE PREVIEWS DISAGREED WITH THE BATTLEFIELD.

   Every faction has a complete bespoke building kit (27/27) and its own unit

   chassis, and the battlefield resolves both correctly. But three surfaces went

   straight to the base maps instead: the build-menu and intel "LIVE 3D MODEL"

   thumbnails, the main-menu model carousel, and the placement ghost. A Brood

   player therefore designed their base out of a Nova catalogue, watched a Nova

   ghost slide across the ground, and only saw grown tissue after the structure

   finished. These two are the one seam every preview should ask. */
function factionKitKey(raw){
  const r=String(raw||'').trim().toLowerCase();
  if(!r) return (typeof playerKitKey==='function')?playerKitKey():'nova';
  if(r==='nova'||r==='legion'||r==='syndicate'||r==='horde') return r;
  if(typeof FACTIONS!=='undefined'&&FACTIONS[r]&&FACTIONS[r].kit) return FACTIONS[r].kit;
  /* Saves and authored missions predate the short runtime keys. Resolve their

     doctrinal names here so a Coalition building can never fall through into

     another faction's already-resident GPU registry. */
  if(r.includes('machine')||r.includes('syndicate')||r.includes('coalition')) return 'syndicate';
  if(r.includes('brood')||r.includes('swarm')||r.includes('infestation')||r.includes('horde')) return 'horde';
  if(r.includes('dominion')||r.includes('red ascendancy')||r.includes('legion')) return 'legion';
  if(r.includes('frontline')||r.includes('federation')||r.includes('terran')) return 'nova';
  /* Preserve an unknown key so strict preview callers can reject it. Turning

     malformed data into Nova would silently reintroduce the cross-faction art

     leak this resolver exists to expose. Battlefield callers still retain

     their explicit legacy fallback in bldMeshFor(). */
  return r;
}
/* FACTION MODEL OWNERSHIP IS CLOSED, NOT A FALLBACK CHAIN.

   The shared TYPES table is a save-compatible rules vocabulary; it is not an

   art catalogue. Every live faction model must therefore exist in that

   faction's exact kit. Slots 12/13/30/31 are Brood organisms and may never

   leak through UNIT_MESH as a blue, red or green substitute. */
function factionUnitModelAllowed(ty,kit){
  const k=factionKitKey(kit||((typeof playerKitKey==='function')?playerKitKey():'nova'));
  return !!(typeof FAC_KIT!=='undefined'&&FAC_KIT[k]&&typeof FAC_KIT[k][ty]==='function');
}
function factionUnitMeshFor(ty,kit){
  const k=factionKitKey(kit||((typeof playerKitKey==='function')?playerKitKey():'nova'));
  if(!factionUnitModelAllowed(ty,k)) return null;
  return (typeof FAC_MESH!=='undefined'&&FAC_MESH[k]&&FAC_MESH[k][ty])||null;
}
function factionUnitGeo(ty,kit,strict){
  const k=factionKitKey(kit||((typeof playerKitKey==='function')?playerKitKey():'nova'));
  const fn=(typeof FAC_KIT!=='undefined'&&FAC_KIT[k]&&FAC_KIT[k][ty])||null;
  if(fn){ try{ return fn(); }catch(e){} }
  /* Returning the base registry here was the leak: Nova was exempt from the

     old strict check, so Blue slot 12 or 30 resolved to a Ravager or Brood

     Sovereign. Missing faction art must be visible as missing, never disguised

     as another faction's successfully rendered model. */
  return null;
}
function factionBldMdlSet(kit,strict){
  const k=factionKitKey(kit||((typeof playerKitKey==='function')?playerKitKey():'nova'));
  if(k==='legion'&&typeof BLD_MDL_LEGION!=='undefined')
    return {mdl:BLD_MDL_LEGION,tur:BLD_TUR_MDL_LEGION,h:BLD_TUR_H_LEGION,sc:BLD_TUR_S_LEGION};
  if(k==='syndicate'&&typeof BLD_MDL_MACHINE!=='undefined')
    return {mdl:BLD_MDL_MACHINE,tur:BLD_TUR_MDL_MACHINE,h:BLD_TUR_H_MACHINE,sc:BLD_TUR_S_MACHINE};
  if(k==='horde'&&typeof BLD_MDL_INFESTATION!=='undefined')
    return {mdl:BLD_MDL_INFESTATION,tur:BLD_TUR_MDL_INFESTATION,h:BLD_TUR_H_INFESTATION,sc:BLD_TUR_S_INFESTATION};
  if(strict&&k!=='nova') return null;
  return {mdl:BLD_MDL,tur:BLD_TUR_MDL,h:BLD_TUR_H,sc:BLD_TUR_S};
}
function bldFactionKey(B){
  /* Live ownership is authoritative. Older sessions could persist the wrong

     `fac` value while the opponent picker was still resolving, and the old

     early return below made that stale Brood tag permanently override a

     Coalition player's structures. Team 0/1 now follow the currently selected

     armies; the saved tag remains only for neutral/replay objects. */
  if(!B||B.team===0) return factionKitKey((typeof playerKitKey==='function')?playerKitKey():'nova');
  if(B.team===1){
    const f=(typeof AI!=='undefined'&&AI&&AI.fac)||(B&&B.fac)||'legion';
    return factionKitKey(f);
  }
  if(B.team===2||B.type==='nest') return 'horde';
  return factionKitKey(B.fac||'nova');
}
/* Alternate architecture kits are large enough that uploading all three to

   the GPU on the main menu wastes both start-up time and mobile memory. A

   skirmish uses one enemy faction, so create that registry the first time it

   is requested and keep it for the rest of the session. The JavaScript model

   factories remain cheap; only WebGL vertex/index buffers are deferred. */
function ensureBldFactionMeshes(fac){
  fac=factionKitKey(fac);
  if(!fac||fac==='nova') return BLD_MESH;
  if(BLD_FACTION_MESH[fac]) return BLD_FACTION_MESH[fac];
  let set=null;
  if(fac==='legion'&&typeof BLD_MDL_LEGION!=='undefined')
    set=initBldMeshSet(BLD_MDL_LEGION,
      typeof BLD_TUR_MDL_LEGION!=='undefined'?BLD_TUR_MDL_LEGION:null,
      typeof BLD_TIER_MDL_LEGION!=='undefined'?BLD_TIER_MDL_LEGION:null,
      typeof BLD_TUR_H_LEGION!=='undefined'?BLD_TUR_H_LEGION:null,
      typeof BLD_TUR_S_LEGION!=='undefined'?BLD_TUR_S_LEGION:null,260);
  else if(fac==='syndicate'&&typeof BLD_MDL_MACHINE!=='undefined')
    set=initBldMeshSet(BLD_MDL_MACHINE,
      typeof BLD_TUR_MDL_MACHINE!=='undefined'?BLD_TUR_MDL_MACHINE:null,
      typeof BLD_TIER_MDL_MACHINE!=='undefined'?BLD_TIER_MDL_MACHINE:null,
      typeof BLD_TUR_H_MACHINE!=='undefined'?BLD_TUR_H_MACHINE:null,
      typeof BLD_TUR_S_MACHINE!=='undefined'?BLD_TUR_S_MACHINE:null,260);
  else if(fac==='horde'&&typeof BLD_MDL_INFESTATION!=='undefined')
    set=initBldMeshSet(BLD_MDL_INFESTATION,
      typeof BLD_TUR_MDL_INFESTATION!=='undefined'?BLD_TUR_MDL_INFESTATION:null,
      typeof BLD_TIER_MDL_INFESTATION!=='undefined'?BLD_TIER_MDL_INFESTATION:null,
      typeof BLD_TUR_H_INFESTATION!=='undefined'?BLD_TUR_H_INFESTATION:null,
      typeof BLD_TUR_S_INFESTATION!=='undefined'?BLD_TUR_S_INFESTATION:null,260);
  if(set) BLD_FACTION_MESH[fac]=set;
  return set;
}
function bldMeshFor(B){
  const fac=bldFactionKey(B),set=ensureBldFactionMeshes(fac);
  const type=B.type;
  /* A missing non-Nova mesh is a visible content error, not permission to put

     a blue building in another faction. Complete-kit audits gate releases;

     returning null here keeps a regression honest in the live game too. */
  if(fac!=='nova')return (set&&set[type])||null;
  return BLD_MESH[type]||null;
}
/* Imported geometry (Blender exports, VRoid soldiers) lands here, keyed by

   UNIT_MDL slot. assets/data/meshes.js assigns into it at load; initModels

   prefers an imported body over the procedural builder, so hand-written and

   imported models are interchangeable per unit with no other change. */
const MF_BLENDER_GEO={};
function initModels(){
  for(let t=0;t<UNIT_MDL.length;t++){
    const ext=MF_BLENDER_GEO[t];
    const g=ext?{hull:ext,tur:null,s:1}:UNIT_MDL[t]();
    UNIT_GEO[t]=g;
    UNIT_MESH[t]={
      hull:new InstMesh(gl,g.hull, t===12||t===13?4200:1400),
      tur: g.tur? new InstMesh(gl,g.tur, 1400):null,
      s:g.s||1, turH:g.turH||0, air:g.air||0, muzzle:g.muzzle||0, muzzleZ:g.muzzleZ||0
    };
  }
  Object.assign(BLD_MESH,initBldMeshSet(BLD_MDL,BLD_TUR_MDL,BLD_TIER_MDL,BLD_TUR_H,BLD_TUR_S,260));
  FX.cityT =new InstMesh(gl,mdlCityTower(),420);
  FX.cityD =new InstMesh(gl,mdlCityDome(),420);
  FX.cityH =new InstMesh(gl,mdlCityHall(),160);
  FX.cityK =new InstMesh(gl,mdlCityTank(),160);
  FX.rock  =new InstMesh(gl,mdlRock(),900);
  FX.tree  =new InstMesh(gl,mdlTree(),900);
  FX.treePine=new InstMesh(gl,mdlTreePine(),700);
  FX.treePalm=new InstMesh(gl,mdlTreePalm(),500);
  FX.treeDead=new InstMesh(gl,mdlTreeDead(),500);
  FX.treeSpore=new InstMesh(gl,mdlTreeSpore(),600);
  FX.bush  =new InstMesh(gl,mdlBush(),800);
  FX.rockIce=new InstMesh(gl,mdlRockIce(),700);
  FX.rockSlag=new InstMesh(gl,mdlRockSlag(),700);
  FX.crystal=new InstMesh(gl,mdlCrystal(),220);
  FX.dep   =new InstMesh(gl,mdlDeposit(),120);
  FX.geyser=new InstMesh(gl,mdlGeyser(),80);
  FX.crate =new InstMesh(gl,mdlCrate(),60);
  for(const k in DROP_MDL){
    DROP_MESH[k]={
      body:new InstMesh(gl,DROP_MDL[k](),4),
      gear:DROP_GEAR_MDL[k]?new InstMesh(gl,DROP_GEAR_MDL[k](),4):null,
      vtol:DROP_VTOL_MDL[k]?new InstMesh(gl,DROP_VTOL_MDL[k](),16):null,
      rotor:DROP_ROTOR_MDL[k]?new InstMesh(gl,DROP_ROTOR_MDL[k](),16):null
    };
  }
  /* Compatibility aliases keep old capture/release tooling working; live

     rendering selects through DROP_MESH and never assumes the Nova body. */
  FX.drop=DROP_MESH.nova.body;
  FX.dropGear=DROP_MESH.nova.gear;
  FX.wreck =new InstMesh(gl,mdlWreck(),480);
  FX.berm  =new InstMesh(gl,mdlBerm(),420);
  FX.shell =new InstMesh(gl,mdlShell(),1400);
  FX.bolt  =new InstMesh(gl,mdlBolt(),3000);
  FX.shard =new InstMesh(gl,mdlShard(),5000);
  FX.beam  =new InstMesh(gl,mdlBeamSeg(),1200);
  FX.cone  =new InstMesh(gl,mdlCone(),700);
  FX.ring  =new InstMesh(gl,mdlRing(),900);
  FX.disc  =new InstMesh(gl,mdlDisc(),900);
  initFactionKits();
  FX.plate =new InstMesh(gl,mdlPlate(),2600);
  FX.shadow=new InstMesh(gl,mdlShadow(),4000);
  FX.modMark=new InstMesh(gl,mdlModMark(),64);
  FX.line  =new InstMesh(gl,mdlLine(),9000);
  FX.wedge =new InstMesh(gl,mdlLightWedge(),200);   // flashlight cones on the ground
  FX.pool  =new InstMesh(gl,mdlLightPool(),480);    // beam splashes + machine underglow
}