src/ui/render3d.js

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

   3D RENDER PASS

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

   Draw order matters here in a way it never did for sprites:

     1. opaque geometry, depth-write ON  — terrain, models, ruins, scenery

     2. water, depth-test ON, blended    — so shorelines and hulls occlude it

     3. additive effects, depth-write OFF — fire, energy, beams, light shafts

   Depth sorting is the GPU's job now, so nothing needs painter's ordering and

   a tank genuinely disappears behind a hill instead of being drawn over it.

   ============================================================================ */
let sunDir=[0.42,0.78,0.30];
const _tmpV=[0,0,0];
/* Read-only renderer telemetry for device QA. This makes an "effects are gone"

   report diagnosable without a debug console overlay or mutating a live match. */
const _burnVec=new Float32Array(64), _burnKind=new Float32Array(16);
const MF_COMBAT_VFX_TELEMETRY={projectiles:0,beams:0,particles:0,additive:0,maxProjectiles:0,maxBeams:0,maxParticles:0,framesWithCombat:0};
if(typeof window!=='undefined')window.MFCombatVfxTelemetry=MF_COMBAT_VFX_TELEMETRY;
const MF_COMBAT_VFX_DIAGNOSTIC=typeof location!=='undefined'&&location.search.indexOf('beamshow=1')>=0;

function sunFor(nA){
  /* The sun swings across the sky with the day cycle and reddens at the

     horizon, which is where all the "cinematic" feel comes from now — it's

     real directional light, not a colour wash over a flat image. */
  const ang=Math.PI*0.12 + (1-nA)*Math.PI*0.62;
  const az=0.6+nA*0.9;
  const y=Math.max(0.06,Math.sin(ang));
  const h=Math.cos(ang);
  const l=Math.hypot(Math.cos(az)*h,y,Math.sin(az)*h)||1;
  sunDir[0]=Math.cos(az)*h/l; sunDir[1]=y/l; sunDir[2]=Math.sin(az)*h/l;
  const low=1-Math.min(1,y*2.2);                 // 1 at the horizon
  const day=1-nA;
  return {
    dir:sunDir,
    // key light: warm and strong at noon, deep amber at the horizon
    /* Exposure budget: a fully sunlit face gets sky + key, and that sum times

       a typical albedo has to land just under 1.0 or the whole world clips to

       white. sky ~0.40 + key ~1.06 against a 0.55 albedo is the sweet spot. */
    col:[ (0.44+day*0.62)*(1+low*0.30), (0.42+day*0.58)*(1-low*0.10), (0.42+day*0.54)*(1-low*0.34) ],
    /* Midnight still needs to be command-readable on an outdoor phone. The

       previous sky floor was physically moody but crushed terrain and unit

       silhouettes into the same near-black value. This is cool moonlight,

       not a second sun: direct light remains low while the ambient floor

       retains form and lets tactical lights add useful contrast. */
    sky:[ 0.34+day*0.11, 0.39+day*0.12, 0.51+day*0.16 ],
    gnd:[ 0.20+day*0.08, 0.21+day*0.08, 0.24+day*0.07 ],
    /* Horizon weather, not a second key light. Noon used to sit brighter

       than sky ambient, so even a thin veil bleached grass toward milk.

       Stay under the sky so distance haze recedes without crushing

       daytime midtones. */
    fog:[ 0.24+day*0.20+low*0.12, 0.29+day*0.21, 0.39+day*0.22 ],
  };
}

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

   GROUND SHADOWS

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

   Everything in the reference art casts one, and nothing here did. That single

   omission is what made structures look pasted on: with no shadow there is no

   contact point, so the eye reads a building as a decal lying on the grass

   rather than a mass standing on it.



   These are decals, not a shadow map. MEDIUM/LOW stay on this cheap path.

   HIGH/CINEMATIC add a sun-depth atlas beside it (mesh.js csmBegin) and

   skip the stretched CAST so the two do not double-darken. SSAO stays

   contact creasing; this pass is the weld-to-grass near blob.



   The decal is stretched along the light and offset by the object's height, so

   shadows lengthen and swing round as the sun moves across the day cycle.



   Blend is MULTIPLY: the mesh is white at its rim and dark at its core, so the

   rim leaves the ground exactly as it was and only the core darkens. That is

   what lets overlapping shadows merge into one soft pool instead of stacking

   into hard black rectangles.



   HIGH/CINEMATIC with shadowQ>=2 replace the stretched CAST blob with a

   real sun-depth atlas (csmBegin / csmApply). Contact near-blobs stay —

   they weld a footprint to grass; CSM owns the directional mass. MEDIUM

   (shadowQ 1) and LOW (0) never enter that pass.

   ============================================================================ */
function drawShadows(S){
  if(!FX.shadow) return;
  const sq=(typeof GFX!=='undefined'&&GFX.shadowQ!=null)?GFX.shadowQ:2;
  /* shadowQ 0 is a real off — not a hidden stride. The Advanced Shadows

     row would otherwise look like it worked while every building still

     painted a blob. */
  if(sq<=0) return;
  const csmOn=typeof csmActive==='function'&&csmActive();
  const contact=!(typeof GFX!=='undefined'&&GFX.contact===false);
  const cb=camBounds();
  const vis=(x,y,pad)=>x>=cb.x0-(pad||0)&&x<=cb.x1+(pad||0)&&y>=cb.y0-(pad||0)&&y<=cb.y1+(pad||0);
  const gh=(x,y)=>terrainH(x,y);
  const sd=S.dir;
  const el=Math.max(0.22,sd[1]);
  const kx=-sd[0]/el, kz=-sd[2]/el;          // ground offset per unit of height
  const q=typeof mfGfxKey==='function'?mfGfxKey():'high';
  const cine=q==='cinematic'&&sq>=2;
  const stretch=Math.min(2.4,Math.hypot(kx,kz))*(sq===1?0.78:cine?1.12:1);
  const yaw=Math.atan2(kz,kx);
  /* Instance alpha stays at full: the MULTIPLY blend takes the fragment colour

     directly, so any alpha below 1 would darken the white rim as well and put

     a visible disc edge around every object. Shadow strength lives in the mesh

     vertex colours instead. */
  const A=255;
  const putCast=(x,y,rad,hgt,wide)=>{
    const cx=x+kx*hgt*0.55, cy=y+kz*hgt*0.55;
    if(!vis(cx,cy,rad+hgt)) return;
    FX.shadow.add(cx,cy,gh(cx,cy)+2.4, rad*0.55+hgt*stretch*0.12, yaw, 255,255,255,A, (wide||rad)*0.58);
  };
  /* Near cascade: tight footprint under the object. HIGH uses this on

     buildings; CINEMATIC on nearby everything. When the sun-depth atlas is

     live the stretched CAST is skipped so the two do not double-darken. */
  const putNear=(x,y,rad,hgt,wide)=>{
    const cx=x+kx*hgt*0.18, cy=y+kz*hgt*0.18;
    if(!vis(cx,cy,rad)) return;
    FX.shadow.add(cx,cy,gh(cx,cy)+1.8, rad*0.42, yaw, 255,255,255,A, (wide||rad)*0.46);
  };
  const put=(x,y,rad,hgt,wide,near)=>{
    if(near) putNear(x,y,rad,hgt,wide);
    if(!csmOn) putCast(x,y,rad,hgt,wide);
  };
  for(const B of blds){
    if(!B.alive||!vis(B.x,B.y,B.r*2)) continue;
    if(!fogEntityVisible(B.team,B.x,B.y)) continue;
    const f=(typeof bldFoot==='function')?bldFoot(B):[B.r*1.6,B.r*1.6];
    const sw=(Math.round((B.rot||0)/(Math.PI/2))&1)===1;
    const fw=(sw?f[1]:f[0])*0.56, fh=(sw?f[0]:f[1])*0.56;
    put(B.x,B.y,Math.max(fw,fh),B.r*1.8,Math.min(fw,fh)*1.05,sq>=2);
  }
  /* Generated civilian/military structures are relics, not `blds`, so the

     original shadow pass skipped the entire city. V2 materials could be

     perfectly lit and still look pasted on because no mass reached the ground.

     Use the planned footprint and an authored height estimate; the terrain

     apron carries the small contact AO while this supplies the directional

     cast shadow. */
  for(const R of relics){
    if(!R.alive||!vis(R.x,R.y,Math.max(R.w,R.h)+110)||!fogPointVisible(R.x,R.y))continue;
    const hgt=R.kind===0?118:R.kind===2?58:R.kind===3?42:R.kind===4?66:R.kind===5?290:52;
    put(R.x,R.y,Math.max(R.w,R.h)*.57,hgt,Math.min(R.w,R.h)*.55,sq>=2);
  }
  /* At strategic range a regiment's individual contact shadows occupy fewer

     than two pixels and merge into one tone. Sample ordinary units there but

     retain selected units and commanders; off-camera units were already fully

     culled above, so this is the second (distance/material) LOD band. */
  /* MEDIUM (shadowQ=1) used stride 2–4, near HIGH at tactical zoom. 3/6

     still paints commanders and selected units every frame.

     contact=false keeps building/relic blobs (the mass-on-grass read) and

     drops unit/scenery — that is the Advanced Contact Shadows row. */
  const shadowStride=cine?1:(sq===1?Math.max(3,orthoSpan>1800?6:3):(orthoSpan>2550?4:orthoSpan>2050?2:1));
  if(contact){
    for(let i=0;i<unitHigh;i++){
      if(!ualive[i]) continue;
      if(!fogEntityVisible(uteam[i],ux[i],uy[i])) continue;
      const T=TYPES[utype[i]];
      const important=usel[i]||i===heroIdx||T.cat==='hero'||(typeof isEnemyCommander==='function'&&isEnemyCommander(i));
      if(shadowStride>1&&!important&&(i%shadowStride))continue;
      const near=cine&&dist2(ux[i],uy[i],cam.x,cam.y)<520*520;
      put(ux[i],uy[i],T.size*0.70,T.air?T.size*2.6:T.size*0.8,undefined,near);
    }
    /* Scenery casts too. A boulder with no shadow beside a tank with one reads

       as a decal painted on the grass. MEDIUM skips crystals (tiny, many). */
    for(const o of rocks)    if(vis(o.x,o.y,60)&&fogPointVisible(o.x,o.y)) put(o.x,o.y,o.s*0.62,o.s*0.75);
    for(const o of trees)    if(vis(o.x,o.y,60)&&fogPointVisible(o.x,o.y)) put(o.x,o.y,o.s*0.52,o.s*1.15);
    if(typeof cover!=='undefined') for(const o of cover)
      if(vis(o.x,o.y,40)&&fogPointVisible(o.x,o.y)) put(o.x,o.y,o.s*0.46,o.s*0.55);
    if(sq>=2) for(const o of crystals){
      const D=deposits[o.dep],tier=depositTier(D);if(!D||o.band>tier||!vis(o.x,o.y,60))continue;
      if(!fogPointVisible(o.x,o.y))continue;
      put(o.x,o.y,o.s*(o.core?.15:.11),o.s*(o.core?.34:.24));
    }
    if(typeof carrier!=='undefined'&&carrier.active&&carrierEffectiveAlt()<80)
      put(carrier.x,carrier.y,22,Math.max(2,carrierEffectiveAlt()*0.22));
  }
  if(!FX.shadow.n) return;
  gl.useProgram(progG);
  gl.uniformMatrix4fv(UG.uVP,false,matVP);
  gl.enable(gl.BLEND);
  gl.blendFunc(gl.ZERO,gl.SRC_COLOR);        // multiply: white is a no-op
  gl.depthMask(false);
  gl.disable(gl.CULL_FACE);
  /* Keep DEPTH_TEST. Turning it off laid the whole stepped shadow disc on

     the pavement as concentric dark rings (live recapture). Offset + a 2.2

     raise keeps contact without z-fighting the kerb into grain. */
  gl.enable(gl.POLYGON_OFFSET_FILL);
  gl.polygonOffset(-12,-48);
  FX.shadow.flush(gl);
  gl.disable(gl.POLYGON_OFFSET_FILL);
  gl.enable(gl.CULL_FACE);
  gl.depthMask(true);
  gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
  gl.disable(gl.BLEND);
}
function csmDrawBuildingCasters(){
  if(typeof BLD_MESH==='undefined') return;
  const sets=[BLD_MESH,...Object.values(BLD_FACTION_MESH||{})];
  for(const set of sets){
    if(!set) continue;
    for(const k in set){
      const M=set[k];
      if(M.variants) for(const V of M.variants){ csmDrawMesh(V.base); if(V.tur) csmDrawMesh(V.tur); }
      else { csmDrawMesh(M.base); if(M.tur) csmDrawMesh(M.tur); }
    }
  }
}
function csmDrawSceneryCasters(){
  if(typeof FX==='undefined') return;
  for(const k of ['rock','tree','crystal','cityT','cityD','cityH','cityK','cityC','sky1','sky2','skyA','skyS','wreck'])
    if(FX[k]) csmDrawMesh(FX[k]);
  if(typeof worldSites!=='undefined'){
    for(const S of worldSites) if(S.fill) csmDrawMesh(S.fill);
    if(typeof WORLD_KIT!=='undefined') for(const k in WORLD_KIT) if(WORLD_KIT[k].mesh) csmDrawMesh(WORLD_KIT[k].mesh);
  }
}
function csmDrawUnitCasters(){
  if(typeof UNIT_MESH!=='undefined') for(const M of UNIT_MESH){ if(!M) continue; csmDrawMesh(M.hull); if(M.tur) csmDrawMesh(M.tur); }
  if(typeof FAC_MESH!=='undefined') for(const k in FAC_MESH) for(const ty in FAC_MESH[k]){
    const M=FAC_MESH[k][ty]; csmDrawMesh(M.hull); if(M.tur) csmDrawMesh(M.tur);
  }
  if(typeof COMMANDER_KIT_MESH!=='undefined') for(const k in COMMANDER_KIT_MESH){
    const M=COMMANDER_KIT_MESH[k]; if(!M) continue; csmDrawMesh(M.hull); if(M.tur) csmDrawMesh(M.tur);
  }
  if(typeof FAC_DOCTRINE_MESH!=='undefined') for(const k in FAC_DOCTRINE_MESH){
    csmDrawMesh(FAC_DOCTRINE_MESH[k].ground); csmDrawMesh(FAC_DOCTRINE_MESH[k].air);
  }
}
function csmDrawModuleCasters(){
  if(typeof MOD_ATTACH_MESH==='undefined') return;
  for(const id in MOD_ATTACH_MESH) for(const M of MOD_ATTACH_MESH[id]) csmDrawMesh(M);
}
/* HIGH skins commanders, size>=21, and anything inside 720 of the look-at.

   CINEMATIC skins every boned mesh in csmBindSkin — the flag is redundant. */
function csmMarkUnitSkin(M,T,heroUnit,X,Y){
  if(!M||!M.hull||!M.hull.bones) return;
  const q=typeof mfGfxKey==='function'?mfGfxKey():'high';
  if(q!=='high'&&q!=='cinematic') return;
  if(q==='cinematic'||heroUnit||T.cat==='hero'||T.size>=21||dist2(X,Y,cam.x,cam.y)<720*720){
    M.hull.csmSkin=1;
    if(M.tur&&M.tur.bones) M.tur.csmSkin=1;
  }
}
/* Light values in sunFor() are display-space colours picked by eye. The shading

   maths is linear, so they are converted once here rather than in the shader. */
const _lin=c=>[Math.pow(c[0],2.2),Math.pow(c[1],2.2),Math.pow(c[2],2.2)];
/* --------------------------------------------------------------------------

   CINEMATIC LOCAL LIGHTS



   The world renderer deliberately remains forward-rendered. A phone battle can

   have hundreds of lamps, engines and sparks, but only the eight strongest

   camera-relevant sources are promoted into the material shader. Everything

   else keeps its emissive billboard, which preserves the feeling of a living

   base without turning a large fight into a G-buffer bandwidth problem.

   -------------------------------------------------------------------------- */
const _sceneLightPR=new Float32Array(8*4),_sceneLightCI=new Float32Array(8*4);
let _sceneLightN=0;
function sceneLightCap(){
  const n=(typeof GFX!=='undefined'&&GFX.lights!=null)?(GFX.lights|0):8;
  return Math.max(0,Math.min(8,n));
}
function sceneLightPush(x,y,z,range,cr,cg,cb,intensity,score){
  const cap=sceneLightCap();
  if(cap<=0) return;
  let at=_sceneLightN;
  if(at<cap) _sceneLightN++;
  else {
    let worst=0,ws=_sceneLightCI[3];
    for(let i=1;i<cap;i++) if(_sceneLightCI[i*4+3]<ws){ws=_sceneLightCI[i*4+3];worst=i;}
    /* The alpha lane temporarily stores ranking until the list is complete. */
    if(score<=ws) return;
    at=worst;
  }
  const o=at*4;
  _sceneLightPR[o]=x; _sceneLightPR[o+1]=y; _sceneLightPR[o+2]=z; _sceneLightPR[o+3]=range;
  _sceneLightCI[o]=cr; _sceneLightCI[o+1]=cg; _sceneLightCI[o+2]=cb; _sceneLightCI[o+3]=score;
  /* Store physical intensity in an otherwise unused negative range slot? No:

     keep it in a compact scratch sidecar so the upload stays straightforward. */
  _sceneLightI[at]=intensity;
}
const _sceneLightI=new Float32Array(8);
function sceneLightColor(fac){
  if(fac==='horde') return [0.44,0.95,0.25];
  if(fac==='legion') return [1.0,0.32,0.13];
  if(fac==='syndicate') return [0.46,1.0,0.34];
  return [0.20,0.72,1.0];
}
function selectCinematicLights(nA){
  _sceneLightN=0;
  const night=0.35+nA*0.85;
  for(const L of blds){
    if(!L.alive||!fogEntityVisible(L.team,L.x,L.y)) continue;
    const critical=L.hp<L.hpm*.38;
    /* Power structures are NOT cinematic hero lights: a promoted pgen painted

       a 140-unit white pool that bloomed like a detonation. Reactors keep the

       small glow sprite; only true landmarks spend a scene light. */
    const hero=L.type==='hq'||L.type==='arc'||L.type==='techlab'||L.type==='nova';
    if(!hero&&!critical&&!(L.hitT>0)) continue;
    const dx=L.x-cam.x,dy=L.y-cam.y,d2=dx*dx+dy*dy;
    if(d2>orthoSpan*orthoSpan*.62) continue;
    const c=_lin(sceneLightColor(bldFactionKey(L)));
    const isHQ=L.type==='hq',damage=critical||L.hitT>0;
    const range=isHQ?112:(damage?82:70);
    const boost=damage?1.65:(isHQ?1.35:1);
    /* Favour key structures over a nearer minor lamp, but still require them

       to be within the current strategic view. */
    const score=boost*range*range/(d2+range*range);
    sceneLightPush(L.x,L.y,terrainH(L.x,L.y)+(isHQ?34:22),range,c[0],c[1],c[2],
                   Math.min(0.88,(0.46+night*.38)*boost),score);
  }
  /* Powered civic windows and industrial warning lamps use the same eight

     camera-relevant-light budget as bases and vehicles. The emissive facade is

     still visible when a source is not promoted; only the strongest nearby

     districts spend fragment lighting work. */
  for(const R of relics){
    if(!R.alive||!fogPointVisible(R.x,R.y)||(R.kind!==4&&R.kind!==2&&R.kind!==3&&R.kind!==5))continue;
    const dx=R.x-cam.x,dy=R.y-cam.y,d2=dx*dx+dy*dy;
    if(d2>orthoSpan*orthoSpan*.54)continue;
    const civic=R.kind===4||R.kind===5,c=_lin(civic?[.15,.68,1.0]:[1.0,.24,.035]);
    const range=R.kind===5?128:civic?78:58,intensity=(R.kind===5?.30:civic?.23:.16)+night*(R.kind===5?.55:civic?.42:.31);
    sceneLightPush(R.x,R.y,terrainH(R.x,R.y)+(R.kind===5?96:civic?24:18),range,c[0],c[1],c[2],intensity,
                   (civic?1.05:.72)*range*range/(d2+range*range));
  }
  /* The commander and a few nearby vehicles participate in actual material

     lighting. Billboard headlamps illuminate the ground visually; these local

     sources make adjacent hulls and building faces react to them too. */
  let promoted=0;
  for(let i=0;i<unitHigh&&promoted<18;i++){
    if(!ualive[i]||uteam[i]!==0)continue;
    const T=TYPES[utype[i]];if(T.air||unitIsBrood(i))continue;
    const isCommander=i===heroIdx,chosen=!!usel[i];
    if(!isCommander&&!chosen&&(i%19)!==0)continue;
    const dx=ux[i]-cam.x,dy=uy[i]-cam.y,d2=dx*dx+dy*dy;
    if(d2>orthoSpan*orthoSpan*.48)continue;
    const c=_lin(sceneLightColor(typeof playerFactionKey==='function'?playerFactionKey():'nova'));
    const range=isCommander?108:58,boost=isCommander?1.42:(chosen?1.05:.76);
    /* THROWN AHEAD, not centred on the hull. A light sitting inside the unit

       brightens the unit and leaves the direction it faces dark — the exact

       opposite of a flashlight. Placing the source low and forward along the

       facing makes terrain, rocks and building walls IN FRONT catch the beam,

       so where the unit looks is where the player can see. */
    const fa=uang[i]-Math.PI/2, ahead=isCommander?T.size*3.4:T.size*1.9;
    const lx=ux[i]+Math.cos(fa)*ahead, ly=uy[i]+Math.sin(fa)*ahead;
    sceneLightPush(lx,ly,terrainH(lx,ly)+7,range,c[0],c[1],c[2],(.26+night*.42)*boost,boost*range*range/(d2+range*range));
    /* The commander also keeps a soft source on the hull itself, so the

       machine reads lit rather than emitting from empty ground. */
    if(isCommander)
      sceneLightPush(ux[i],uy[i],terrainH(ux[i],uy[i])+T.size*.52,66,c[0],c[1],c[2],(.16+night*.22)*boost,boost*.6);
    promoted++;
  }
  if(typeof singularities!=='undefined') for(const Sg of singularities){
    const dxs=Sg.x-cam.x,dys=Sg.y-cam.y;
    sceneLightPush(Sg.x,Sg.y,terrainH(Sg.x,Sg.y)+22,150,_lin([172,120,255])[0],_lin([172,120,255])[1],_lin([172,120,255])[2],
      0.9+0.5*Math.sin((typeof stats!=='undefined'?stats.t:0)*9),150*150/(dxs*dxs+dys*dys+150*150)+3);
  }
  if(carrier.active&&carrier.phase<2){
    const c=_lin(sceneLightColor(dropFactionKey(carrier.fac)));
    const alt=Math.max(18,carrierEffectiveAlt()*.65);
    const dx=carrier.x-cam.x,dy=carrier.y-cam.y,d2=dx*dx+dy*dy;
    sceneLightPush(carrier.x,carrier.y,terrainH(carrier.x,carrier.y)+alt,28,c[0],c[1],c[2],0.08,28*28/(d2+28*28)+1);
  }
  /* The shader expects intensity in the fourth colour lane. Selection used it

     as a ranking key, so restore the small sidecar just before upload. */
  for(let i=0;i<_sceneLightN;i++) _sceneLightCI[i*4+3]=_sceneLightI[i];
}
function visualDebugMode(){
  const v=typeof window!=='undefined' ? Number(window.MFVisualDebug||0) : 0;
  return Math.max(0,Math.min(7,v|0));
}
let MF_BONES_ON=false;
function begin3D(nA){
  const S=sunFor(nA);
  gl.useProgram(prog3D);
  /* FX and custom passes share InstMesh but do not own prog3D's uniforms.

     Re-entering the model pass is the one reliable boundary where a previous

     rig or per-asset skin must be cleared. This keeps an unlit flush from

     touching a foreign uniform location and prevents stale V2 maps/bones from

     bleeding into the next ordinary unit or structure. */
  if(typeof U3!=='undefined'){
    if(MF_ASSET_ON&&U3.uAssetOn) gl.uniform1f(U3.uAssetOn,0.0);
    if(MF_BONES_ON&&U3.uBoneN!==undefined&&U3.uBoneN!==null) gl.uniform1i(U3.uBoneN,0);
  }
  MF_ASSET_ON=false;
  MF_BONES_ON=false;
  /* If the procedural material atlases were not generated (context recovery

     race, mobile memory pressure, or a startup ordering change), rebuild now

     instead of drawing every building with missing/muted PBR detail. */
  if(!matTex || !matNrmTex || !matOrmTex || !matDamageTex || !matDetailTex){
    if(typeof buildMatAtlas==='function') try{ buildMatAtlas(); }catch(e){}
  }
  gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D,matDamageTex);
  gl.activeTexture(gl.TEXTURE2); gl.bindTexture(gl.TEXTURE_2D,matNrmTex);
  gl.activeTexture(gl.TEXTURE3); gl.bindTexture(gl.TEXTURE_2D,matOrmTex);
  /* Texture units 4/5/6 remain reserved for the post chain. Unit 7 is reused

     after terrain/fog and makes the live V2 micro-detail available to every

     instanced unit and building without adding draw calls. */
  gl.activeTexture(gl.TEXTURE7); gl.bindTexture(gl.TEXTURE_2D,matDetailTex);
  /* Unit 8 carries the live fog-of-war map into the MODEL pass so units,

     buildings and remembered scenery darken with the ground they stand on. */
  if(typeof fogTex!=='undefined'&&fogTex){ gl.activeTexture(gl.TEXTURE8); gl.bindTexture(gl.TEXTURE_2D,fogTex); }
  /* Units 4-6 carry the per-asset baked triplet when a draw declares one. They

     must reference a COMPLETE texture even when it is unused: WebGL2 validates

     every sampler the program references at draw time, not only the ones the

     taken branch reads, and an unbound unit drops the whole draw call -- which

     is every mesh in the game vanishing while the program still reports as

     linked. The atlas stands in; uAssetOn keeps it from ever being sampled. */
  gl.activeTexture(gl.TEXTURE4); gl.bindTexture(gl.TEXTURE_2D,matTex);
  gl.activeTexture(gl.TEXTURE5); gl.bindTexture(gl.TEXTURE_2D,matTex);
  gl.activeTexture(gl.TEXTURE6); gl.bindTexture(gl.TEXTURE_2D,matTex);
  gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D,matTex);
  gl.uniformMatrix4fv(U3.uVP,false,matVP);
  gl.uniform3f(U3.uEye,eyeX,eyeY,eyeZ);
  gl.uniform3f(U3.uSun,S.dir[0],S.dir[1],S.dir[2]);
  /* View direction under an orthographic projection is the same for every

     pixel in the frame, so the Blinn half-vector is a per-frame constant. */
  const vx=matV[2], vy=matV[6], vz=matV[10];
  let hx=S.dir[0]+vx, hy=S.dir[1]+vy, hz=S.dir[2]+vz;
  const hl=Math.hypot(hx,hy,hz)||1;
  gl.uniform3f(U3.uHalf,hx/hl,hy/hl,hz/hl);
  { const c=_lin(S.col); gl.uniform3f(U3.uSunC,c[0],c[1],c[2]); }
  { const c=_lin(S.sky); gl.uniform3f(U3.uAmbSky,c[0],c[1],c[2]); }
  { const c=_lin(S.gnd); gl.uniform3f(U3.uAmbGnd,c[0],c[1],c[2]); }
  { const c=_lin(S.fog); gl.uniform3f(U3.uFogC,c[0],c[1],c[2]); }
  if(U3.uHazeQ) gl.uniform1f(U3.uHazeQ, typeof mfHazeQ==='function'?mfHazeQ():1);
  gl.uniform1f(U3.uEmis,0);
  if(U3.uNight) gl.uniform1f(U3.uNight,nA);
  if(U3.uTime) gl.uniform1f(U3.uTime,(typeof performance!=='undefined'?performance.now():0)*0.001);
  gl.uniform1i(U3.uDebugMode,visualDebugMode());
  if(U3.uFowMap!=null){ gl.uniform1i(U3.uFowMap,8);
    gl.uniform1f(U3.uFowOn,(typeof fogGameplayActive==='function'&&fogGameplayActive()&&!demoMode&&typeof fogTex!=='undefined'&&fogTex)?1:0); }
  gl.uniform1i(U3.uLightCount,_sceneLightN);
  if(_sceneLightN){
    gl.uniform4fv(U3.uLightPosR,_sceneLightPR);
    gl.uniform4fv(U3.uLightColI,_sceneLightCI);
  }
  return S;
}
function setEmis(v){ gl.uniform1f(U3.uEmis,v); }

/* A battlefield limit should read as command infrastructure, not the renderer

   running out of world. The red core and EVERY grid rung sit on the safe side;

   procedural exclusion art starts beyond them in the terrain shader. It is

   flushed by the unlit additive pass, so sensor fog cannot turn it black and

   the physical-edge haze cannot erase it. */
function terrainExclusionStyle(mapKey,themeKey){
  const TH=THEMES[themeKey]||THEMES.verdant;
  const style=mapKey==='isles'?1:(themeKey==='ashland'||mapKey==='crater'?2:
    (themeKey==='arctic'||mapKey==='highland'?3:0));
  const tint=style===1?TH.wDeep:(style===2?(TH.cliff||[64,48,42]):
    (style===3?(themeKey==='arctic'?[108,128,150]:[76,88,104]):(TH.g0||[62,82,54])));
  return {style,tint};
}
let mapBoundaryDrawCount=0,mapBoundaryOutsideCount=0;
function queueBattlefieldEdgeGrid(t,vis){
  mapBoundaryDrawCount=0;mapBoundaryOutsideCount=0;
  const B=typeof battlefieldPlayBounds==='function'?battlefieldPlayBounds(0):{lo:0,hi:MAP,span:MAP};
  const d=typeof battlefieldSignedDistance==='function'?Math.abs(battlefieldSignedDistance(cam.x,cam.y,0)):
    Math.min(Math.abs(cam.x-B.lo),Math.abs(cam.x-B.hi),Math.abs(cam.y-B.lo),Math.abs(cam.y-B.hi));
  const reach=Math.max(480,orthoSpan*.42);
  if(d>=reach) return 0;
  const reveal=clamp((reach-d)/(reach*.64),0,1),span=B.hi-B.lo;
  const seg=Math.max(64,Math.round(span/28)),inner=Math.min(112,span*.07),safe=9;
  const pulse=.78+.22*Math.sin(t*3.2), coreA=(180+55*pulse)*reveal, gridA=(58+38*pulse)*reveal;
  const inside=(x,y,pad)=>typeof battlefieldContains==='function'?battlefieldContains(x,y,pad||0):
    x>=B.lo+(pad||0)&&x<=B.hi-(pad||0)&&y>=B.lo+(pad||0)&&y<=B.hi-(pad||0);
  const put=(x,y,len,ang,r,g,b,a,w,endpoints)=>{
    if(a<5||!vis(x,y,len*.55+55)) return;
    FX.line.add(x,y,terrainH(x,y)+7.5,len,ang,r,g,b,a,w);
    if(!inside(x,y,0)||(endpoints&&endpoints.some(P=>!inside(P[0],P[1],0))))mapBoundaryOutsideCount++;
    mapBoundaryDrawCount++;
  };
  const point=(a,pad)=>typeof battlefieldBoundaryPoint==='function'?battlefieldBoundaryPoint(a,pad):[
    (B.lo+B.hi)*.5+Math.cos(a)*span*.48,(B.lo+B.hi)*.5+Math.sin(a)*span*.48];
  /* Sample the authored silhouette itself.  Coastal inlets become a soft,

     rounded perimeter; scorched maps keep sharper chamfers; storm fronts bow

     asymmetrically.  No map is forced through the old four-sided stamp. */
  for(let k=0;k<seg;k++){
    const a0=k/seg*TAU,a1=(k+1)/seg*TAU;
    const A=point(a0,safe),C=point(a1,safe),dx=C[0]-A[0],dy=C[1]-A[1],len=Math.hypot(dx,dy);
    put((A[0]+C[0])*.5,(A[1]+C[1])*.5,len,Math.atan2(dy,dx),255,42,30,coreA,3.8,[A,C]);
    const D=point(a0,safe+inner*.42),E=point(a1,safe+inner*.42),ex=E[0]-D[0],ey=E[1]-D[1];
    put((D[0]+E[0])*.5,(D[1]+E[1])*.5,Math.hypot(ex,ey),Math.atan2(ey,ex),255,72,48,gridA,2.0,[D,E]);
    if((k&3)===0){
      const O=point((a0+a1)*.5,safe+2),I=point((a0+a1)*.5,safe+inner),rx=I[0]-O[0],ry=I[1]-O[1];
      put((O[0]+I[0])*.5,(O[1]+I[1])*.5,Math.hypot(rx,ry),Math.atan2(ry,rx),255,58,42,gridA*1.15,1.8,[O,I]);
    }
  }
  const nodeR=5.2+1.0*pulse;
  for(let k=0;k<8;k++){
    const P=point(k/8*TAU,safe+nodeR+1),x=P[0],y=P[1];
    if(!vis(x,y,90))continue;
    FX.ring.add(x,y,terrainH(x,y)+9,nodeR,-t*.55,255,58,38,205*reveal);
    if(!inside(x,y,nodeR*.15))mapBoundaryOutsideCount++;
    mapBoundaryDrawCount++;
  }
  return mapBoundaryDrawCount;
}

/* A beam is a camera-facing textured ribbon, not a row of glow dots. Project

   both endpoints first so the rectangle follows the beam on screen even while

   the player rotates and tilts the camera. Long paths are split into a handful

   of depth-correct spans; that keeps hills and large units able to occlude the

   effect without turning one weapon into dozens of draw calls. */
function addBeamRibbon(uv,x0,h0,y0,x1,h1,y1,width,r,g,b,a,maxPx){
  const a0=w2s(x0,y0,h0), a1=w2s(x1,y1,h1);
  const pxLen=Math.hypot(a1[0]-a0[0],a1[1]-a0[1]);
  const seg=Math.max(1,Math.min(6,Math.ceil(pxLen/(maxPx||170))));
  let ax=x0, ay=y0, ah=h0;
  for(let k=1;k<=seg;k++){
    const q=k/seg, ex=x0+(x1-x0)*q, ey=y0+(y1-y0)*q, eh=h0+(h1-h0)*q;
    const s0=w2s(ax,ay,ah), s1=w2s(ex,ey,eh);
    const sx=s1[0]-s0[0], sy=s1[1]-s0[1];
    const screenLen=Math.hypot(sx,sy);
    if(screenLen>.2){
      /* Atlas cells keep ~16% transparent padding for mip safety. Adjacent

         spans therefore need deliberate overlap; 1.28 closes that padding at

         every zoom without letting a ribbon overshoot its true endpoints by

         more than one soft glow fringe. */
      const worldLen=Math.max(width*1.2,screenLen*orthoSpan/Math.max(1,VH)*1.28);
      /* The atlas beam runs along local +Y. Screen Y points down, hence this

         less-obvious angle instead of atan2(sy,sx). */
      const rot=Math.atan2(-sx,-sy);
      bbAdd.addOrientedRect(uv,(ax+ex)*.5,(ay+ey)*.5,(ah+eh)*.5,
        width,worldLen,rot,r,g,b,a);
    }
    ax=ex; ay=ey; ah=eh;
  }
}
function addBeam3D(mesh,x0,h0,y0,x1,h1,y1,rad,r,g,b,a){
  const q=typeof mfVfxQ==='function'?mfVfxQ():1;
  const width=Math.max(1.28,rad*(q>=1.25?3.20:q>=0.95?2.88:q>=0.65?2.48:2.18));
  /* Three ribbon layers, no per-frame GPU spray on the shaft. A live tracer

     used to birth embers at its head every frame; those drifted off the

     trajectory and read as sparks orbiting the fight. Haze is a soft sheath

     so the line stays directed at tactical zoom — LOW keeps sheath+core. */
  if(rad>0.82&&(q>=0.45||perfScale>.28)) addBeamRibbon(sprites.glow,x0,h0,y0,x1,h1,y1,
    width*(q>=1?2.75:2.15),r,g,b,a*(q>=1?.46:.32),210);
  addBeamRibbon(sprites.beam||sprites.glow,x0,h0,y0,x1,h1,y1,width,r,g,b,Math.min(255,a*1.08),150);
  addBeamRibbon(sprites.beam||sprites.glow,x0,h0,y0,x1,h1,y1,
    Math.max(0.72,width*0.48),255,253,248,Math.min(255,a*1.22),150);
}
/* Double-helix filaments give the largest weapons an authored silhouette. The

   radius closes at both ends so the strands grow out of the emitter and merge

   into the impact, rather than looking like two unrelated cables. */
function addBeamHelix(bm,h0,h1,radius,turns,r,g,b,a,t,oneStrand){
  const dx=bm.x1-bm.x0, dy=bm.y1-bm.y0, dl=Math.hypot(dx,dy)||1;
  const ox=-dy/dl, oy=dx/dl, steps=10;
  const strands=oneStrand?1:2;
  for(let s=0;s<strands;s++){
    let ax=bm.x0, ay=bm.y0, ah=h0;
    for(let k=1;k<=steps;k++){
      const q=k/steps, taper=Math.sin(q*Math.PI);
      const ph=q*turns*TAU+t*8+bm.seed*5+s*Math.PI;
      const off=Math.sin(ph)*radius*taper;
      const ex=bm.x0+dx*q+ox*off, ey=bm.y0+dy*q+oy*off;
      const eh=h0+(h1-h0)*q+Math.cos(ph)*radius*.48*taper;
      addBeamRibbon(sprites.beam||sprites.glow,ax,ah,ay,ex,eh,ey,
        Math.max(1.15,bm.w*.66),r,g,b,a,220);
      addBeamRibbon(sprites.beam||sprites.glow,ax,ah,ay,ex,eh,ey,
        Math.max(.52,bm.w*.17),245,252,255,a*.72,220);
      ax=ex; ay=ey; ah=eh;
    }
  }
}
function addBeamBurst(x,y,h,size,r,g,b,a){
  /* Terminus sits on the hit. Radial streaks use a POSITION seed, not time —

     a spinning seed read as sparks orbiting the target instead of a strike. */
  bbAdd.add(sprites.glow,x,y,h,size*1.72,0,r,g,b,a*.90);
  bbAdd.add(sprites.glow,x,y,h,size*0.68,0,255,253,244,a);
  const q=typeof mfVfxQ==='function'?mfVfxQ():1;
  if(q>=0.45&&size>1.6){
    const n=q>=1.2?8:q>=0.95?6:4;
    const seed=x*0.073+y*0.051;
    for(let k=0;k<n;k++){
      const ang=seed+k*(6.283185/n);
      const len=size*(q>=0.95?4.4:2.9);
      addBeamRibbon(sprites.beam||sprites.glow,x,h,y,x+Math.cos(ang)*len,h,y+Math.sin(ang)*len,
        Math.max(0.82,size*0.24),r,g,b,a*.74,90);
    }
  }
  if(typeof gpfxEnergyBlast==='function'&&q>=0.4&&size>2.2
     &&(typeof gpfxLive==='undefined'||gpfxLive<GPFX_CAP-80))
    gpfxEnergyBlast(x,y,h,size>6?32:16,[r,g,b],{speed:128,up:0.34,life:0.58,size:3.0,min:4});
}
function addMuzzleFlash(x,y,h,dx,dy,size,r,g,b,a){
  /* Brief barrel bloom plus a cone along the shot. Both stay on the

     weapon; nothing here is given velocity that would orbit the chassis. */
  if(a<8||size<0.4) return;
  const l=Math.hypot(dx,dy)||1, nx=dx/l, ny=dy/l;
  const q=typeof mfVfxQ==='function'?mfVfxQ():1;
  const cone=Math.max(8.2,size*(q>=0.95?2.65:2.05));
  bbAdd.add(sprites.glow,x,y,h,size*1.48,0,r,g,b,a);
  bbAdd.add(sprites.glow,x,y,h,size*.58,0,255,252,242,a);
  addBeamRibbon(sprites.beam||sprites.glow,x,h,y,x+nx*cone,h,y+ny*cone,
    Math.max(1.35,size*.58),255,248,228,a,80);
  /* MEDIUM+ GPU spray at the already-lifted muzzle. n stays under the

     water-ripple stamp (n>=20). LOW keeps the cone so the shot is not mute. */
  if(typeof gpfxBurst==='function'&&q>=0.45&&perfScale>.28
     &&(typeof camDist==='undefined'||camDist<2400)&&gpfxLive<GPFX_CAP-64)
    gpfxBurst(x,y,h,typeof gpfxN==='function'?gpfxN(12,4):7,
      {speed:68,up:0.22,life:0.40,col:[r,g,b],size:2.35,drag:0.92,jit:1.2,dir:[nx,ny]});
}

/* Combat VFX is authored in 2D (fx/fy, beam x0/y0). The draw path used a

   flat gh()+13 deck, so muzzle/impact sat on the dirt while turrets sit at

   M.turH*ss. Spatial-hash only — no sim writes. */
function fxWeaponH(x,y,muzzle){
  const base=(typeof terrainH==='function'?terrainH(x,y):0);
  const rad=muzzle?36:14;
  if(typeof nearestUnitAny==='function'){
    const u=nearestUnitAny(x,y,rad);
    if(u>=0){
      const T=TYPES[utype[u]];
      const M=typeof UNIT_MESH!=='undefined'?UNIT_MESH[utype[u]]:null;
      const ss=(T.size/15)*(M&&M.s||1)*1.5*(T.vscale||1);
      const th=(M&&M.turH>0?M.turH:(T.air?6:4.6))*ss;
      const hy=unitGroundY(T,ux[u],uy[u]);
      return muzzle?hy+th:hy+th*0.55;
    }
  }
  if(typeof blds!=='undefined'&&typeof BCS!=='undefined'&&typeof BGW!=='undefined'&&bGrid){
    const cr=1, r2=rad*rad;
    const cx=clamp(x/BCS|0,0,BGW-1), cy=clamp(y/BCS|0,0,BGW-1);
    let best=-1, bd=r2;
    for(let gy=Math.max(0,cy-cr);gy<=Math.min(BGW-1,cy+cr);gy++)
     for(let gx=Math.max(0,cx-cr);gx<=Math.min(BGW-1,cx+cr);gx++){
      const cell=bGrid[gy*BGW+gx]; if(!cell) continue;
      for(const bi of cell){
        const B=blds[bi]; if(!B||!B.alive||B.prog<1) continue;
        const th0=typeof BLD_TUR_H!=='undefined'?BLD_TUR_H[B.type]:0;
        if(!th0) continue;
        const d=dist2(x,y,B.x,B.y); if(d>=bd) continue;
        bd=d; best=bi;
      }
    }
    if(best>=0){
      const B=blds[best];
      const M=typeof bldMeshFor==='function'?bldMeshFor(B):null;
      const grow=B.prog||1;
      const th=(M&&M.turH)||(typeof BLD_TUR_H!=='undefined'&&BLD_TUR_H[B.type])||14;
      const hy=(BT[B.type]&&BT[B.type].placement==='water')?0:base;
      return hy+th*grow*(muzzle?1:0.62);
    }
  }
  return base+(muzzle?13:2.4);
}

/* Rail batteries and strategic silos are base landmarks. Their geometry is

   faction-authored, but at an RTS camera distance a small, quiet charge motif

   is what keeps the role readable in motion. These are billboard/ring effects

   only: no lights, emitters or simulation particles, so a dense fortress does

   not turn into additive fog on a phone. The caller has already passed both

   viewport and fog-of-war visibility gates. */
function addFactionStrategicBuildingVfx(B,fac,H,bob,grow,t,M){
  if(B.prog<1||perfScale<.32||(B.type!=='rail'&&B.type!=='nova')) return;
  const pal=fac==='legion'?[[255,76,48],[255,171,72]]:
    fac==='syndicate'?[[186,78,255],[118,246,182]]:
    fac==='horde'?[[136,232,72],[198,84,255]]:
    [[72,205,255],[205,244,255]];
  const p=.72+Math.sin(t*(B.type==='nova'?2.0:3.2)+B.x*.017+B.y*.011)*.28;
  const th=(M.turH||BLD_TUR_H[B.type]||(B.type==='nova'?20:18))*grow;
  const top=H+bob+th+(B.type==='nova'?10:6)*grow;
  const a=(B.cool||0)<=0?1:.46;
  if(B.type==='rail'){
    const ang=(B.tang||0)-Math.PI/2,dx=Math.cos(ang)*(10+2*(B.lvl||1))*grow;
    const dy=Math.sin(ang)*(10+2*(B.lvl||1))*grow;
    bbAdd.add(sprites.glow,B.x+dx,B.y+dy,top,(7+3*p)*grow,0,pal[0][0],pal[0][1],pal[0][2],145*a);
    bbAdd.add(sprites.ring||sprites.glow,B.x+dx,B.y+dy,top,(5.2+1.7*p)*grow,
      t*.45,pal[1][0],pal[1][1],pal[1][2],118*a);
    if(perfScale>.56) bbAdd.add(sprites.glow,B.x-dx*.42,B.y-dy*.42,top-3*grow,
      10*grow,0,pal[0][0],pal[0][1],pal[0][2],55*a);
    return;
  }
  /* NOVA's slow orbital lock is intentionally wider than its weapon muzzle:

     it telegraphs a strategic asset without resembling ordinary gunfire. */
  FX.ring.add(B.x,B.y,H+1.5,34+5*p,t*.18,pal[0][0],pal[0][1],pal[0][2],52*a);
  bbAdd.add(sprites.glow,B.x,B.y,top,(14+5*p)*grow,0,pal[0][0],pal[0][1],pal[0][2],98*a);
  bbAdd.add(sprites.ring||sprites.glow,B.x,B.y,top,(11+3*p)*grow,-t*.25,
    pal[1][0],pal[1][1],pal[1][2],125*a);
  if(perfScale>.56){
    const n=Math.min(4,1+(B.lvl||1));
    for(let k=0;k<n;k++){
      const q=t*.22+k*TAU/n,rr=(12+2*(B.lvl||1))*grow;
      bbAdd.add(sprites.glow,B.x+Math.cos(q)*rr,B.y+Math.sin(q)*rr,top-3*grow,
        3.2*grow,0,pal[1][0],pal[1][1],pal[1][2],155*a);
    }
  }
}

let fxT=0;
let bzShow=0;                 // territory overlay fades in briefly after it changes
function flashBuildZone(){ bzShow=1; }
/* One border segment: a thin plate a full cell long, laid on the ground so it

   follows the terrain instead of floating over it. */
function bzEdge(wx,wy,h,rot,a){
  // one cell-long hairline, plus a soft under-glow to give the frontier weight
  FX.line.add(wx,wy,h,BZ*1.04,rot, 170,240,255, 250*a, 4.4);
  FX.plate.add(wx,wy,h-0.2,BZ*0.9,0, 90,205,255, 62*a);
}
function drawDropCraft(fac,x,y,alt,ang,t,alpha,gear,thrust,vtolPose){
  const key=typeof dropFactionKey==='function'?dropFactionKey(fac):'nova';
  const D=DROP_MESH[key]||DROP_MESH.nova, P=DROP_PROFILE[key]||DROP_PROFILE.nova;
  if(!D||!D.body) return;
  const tc=P.team||TEAMC[0], anim=P.bio?t*2.7:0;
  D.body.add(x,y,alt,P.scale||1,ang,tc[0],tc[1],tc[2],alpha,undefined,anim);
  if(gear&&D.gear)
    D.gear.add(x,y,alt,P.scale||1,ang,tc[0],tc[1],tc[2],alpha,undefined,anim);
  const ca=Math.cos(ang),sa=Math.sin(ang),g=P.glow;
  const xf=(lx,lz)=>[x+lx*ca-lz*sa,y+lx*sa+lz*ca];
  /* Nova's four lift ducts are real articulated geometry, not exhaust sprites.

     The model's hinge maps 0=upright hover and 1=aft-tilted cruise. Rotors are

     separate instances so their blades can continuously spin while the duct

     itself performs the slower altitude-driven transition. */
  if(D.vtol&&P.vtol){
    const pose=clamp(vtolPose||0,0,1),phase=Math.asin(pose),fanA=clamp(1-pose*1.35,0,1);
    for(let k=0;k<P.vtol.length;k++){
      const H=P.vtol[k],q=xf(H[0],H[1]);
      D.vtol.add(q[0],q[1],alt,P.scale||1,ang,tc[0],tc[1],tc[2],alpha,undefined,phase);
      if(D.rotor&&fanA>.02)
        D.rotor.add(q[0],q[1],alt+12.2*(P.scale||1),P.scale||1,
          ang+t*(k&1?-11.5:11.5),tc[0],tc[1],tc[2],alpha*fanA);
    }
  }
  /* Stamp before flush — dropship streams empty on flush, so a later unit

     pass cannot see them. Same InstMesh path, no new format. */
  if(typeof csmActive==='function'&&csmActive()&&typeof csmBegin==='function'&&csmBegin(false)){
    csmDrawMesh(D.body);
    if(D.gear) csmDrawMesh(D.gear);
    if(D.vtol) csmDrawMesh(D.vtol);
    if(D.rotor) csmDrawMesh(D.rotor);
    csmEnd(_csmFrameNA);
  }
  D.body.flush(gl);
  if(gear&&D.gear) D.gear.flush(gl);
  if(D.vtol&&P.vtol){ D.vtol.flush(gl); if(D.rotor) D.rotor.flush(gl); }
  /* Engine bells are ENERGY on the mesh. Additive glow sprites at P.eng

     bloomed into the orange/yellow sparks on the two rear ports. Dust is

     type-10 alpha, not these. */
}
/* Per-frame render scratch, allocated once. Everything here used to be created

   fresh inside render() and thrown away 60 times a second. */
let _hbI=new Int32Array(4096), _hbF=new Float32Array(4096);
const _hbCells=new Map(), _wallStreams=new Set();
let _csmFrameNA=0;

function unitGroundY(T,x,y){
  if(T.air) return terrainH(x,y)+58;
  if(T.naval){
    /* Visual bob only. Sim pathing stays on the flat naval mask — a

       bouncing flowfield is a bug, and sim.js is contended. */
    return (typeof waterSurfaceY==='function'?waterSurfaceY(x,y):0)+0.95;
  }
  return terrainH(x,y);
}

function queueWaterFx(){
  if(typeof waterFxBegin!=='function'||!waterIdxCount) return;
  waterFxBegin();
  const wet=typeof authoredWaterAt==='function'?authoredWaterAt:()=>false;
  const cb=camBounds();
  const vis=(x,y,p)=>x>=cb.x0-(p||0)&&x<=cb.x1+(p||0)&&y>=cb.y0-(p||0)&&y<=cb.y1+(p||0);
  const push=(i)=>{
    if(!ualive[i]||!umov[i]) return;
    const T=TYPES[utype[i]];
    if(!T||!T.naval) return;
    if(!vis(ux[i],uy[i],90)) return;
    if(!fogEntityVisible(uteam[i],ux[i],uy[i])) return;
    /* Hulls face +X at mesh yaw 0, which is uang-π/2. mdlWake is authored

       aft along -X; the water-sheet V uses the same angle so foam trails

       the hull instead of sitting 90° off the bow. */
    const len=T.size*(T.vscale||1)*3.6;
    waterFxWake(ux[i],uy[i],uang[i]-Math.PI/2,len,T.size*1.2);
  };
  for(let i=0;i<unitHigh;i++) if(usel[i]||i===heroIdx) push(i);
  for(let i=0;i<unitHigh;i++){ if(usel[i]||i===heroIdx) continue; push(i); }
  if(typeof waterFxEmitCraterWakes==='function') waterFxEmitCraterWakes();
  /* Shock rings / explosions only, and only the newest 256 of the 9000-slot

     ring — a full scan was a tax for stamps that fire once while young. */
  if(typeof fHead==='undefined'||typeof MAXPART==='undefined') return;
  const look=Math.min(MAXPART,256);
  for(let k=0;k<look;k++){
    const i=(fHead-1-k+MAXPART)%MAXPART;
    if(flife[i]<=0) continue;
    const ty=ftype[i];
    if(ty!==0&&ty!==3&&ty!==6) continue;
    if(ty===0&&fsize[i]<12) continue;
    if(flife[i]/fmax[i]<0.72) continue;
    if(!vis(fx[i],fy[i],70)) continue;
    if(wet(fx[i],fy[i])){
      waterFxImpact(fx[i],fy[i], ty===6?14:ty===3?Math.max(8,fsize[i]*0.9):10, ty===3?1.35:0.95);
      continue;
    }
    const near=typeof waterNearAuthored==='function'&&waterNearAuthored(fx[i],fy[i],28);
    if(near) waterFxImpact(near[0],near[1], ty===6?12:9, ty===3?1.2:0.85);
  }
}

function render(dtDraw){
  const labNight=typeof materialV2LabNightAmount==='function'?materialV2LabNightAmount():null;
  const S_nA=labNight==null?nightAmt():labNight;
  _csmFrameNA=S_nA;
  /* One biome ground colour per frame, shared by every structure skirt: the

     terrain palette's hill tone pulled toward its cliff rock — what freshly

     turned ground beside a foundation actually looks like. */
  const _skT=THEMES[curTheme]||THEMES.verdant;
  const _skC=[Math.round(_skT.h0[0]*0.62+_skT.cliff[0]*0.38),
              Math.round(_skT.h0[1]*0.62+_skT.cliff[1]*0.38),
              Math.round(_skT.h0[2]*0.62+_skT.cliff[2]*0.38)];
  const t=performance.now()/1000;      // animation clock, shared by every wobble here
  fxT+=dtDraw;
  /* Keep the command network readable while the catalogue is open. Previously

     flashBuildZone() expired before a player finished comparing structures,

     so the actual answer to “where can I build?” vanished before a choice was

     made. Placement has its cheaper local-cell overlay below. */
  const buildCatalogue=document.getElementById('buildMenu');
  const buildCatalogueOpen=!!(buildCatalogue&&buildCatalogue.style.display==='block');
  if(buildCatalogueOpen) bzShow=1;
  else if(bzShow>0) bzShow=Math.max(0,bzShow-dtDraw*0.5);
  /* Screen shake is now a camera-space nudge rather than a world offset — with

     a perspective camera you shake the EYE, not the contents of the world. */
  if(shake>0){
    cam.x+=rr(-shake,shake)*shakeMult*0.9;
    cam.y+=rr(-shake,shake)*shakeMult*0.9;
    shake*=0.86; if(shake<0.3) shake=0;
    clampCam(); camUpdateMatrices();
  }
  drawCalls=0; triCount=0;

  gl.viewport(0,0,cv.width,cv.height);
  const Sun=sunFor(S_nA);
  selectCinematicLights(S_nA);
  /* Opaque geometry renders offscreen so screen-space AO can read its depth.

     If the target can't be created the call returns false and everything below

     draws straight to the canvas exactly as before. */
  const aoActive=aoBeginScene();
  if(aoActive&&typeof aoW==='number'&&aoW>0) gl.viewport(0,0,aoW,aoH);
  /* Clear to EXACTLY the fog colour. The border haze fades the last stretch of

     ground into uFogC, so anything the camera sees past the edge has to be the

     same value or the illusion ends in a visible seam. */
  gl.clearColor(Sun.fog[0],Sun.fog[1],Sun.fog[2],1);
  gl.clearDepth(1);
  gl.enable(gl.DEPTH_TEST);
  gl.depthMask(true);
  gl.disable(gl.BLEND);
  gl.enable(gl.CULL_FACE);
  gl.clear(gl.COLOR_BUFFER_BIT|gl.DEPTH_BUFFER_BIT);
  if(typeof mfGfxScissor==='function') mfGfxScissor(true);

  begin3D(S_nA);

  const B=camBounds();
  const x0=B.x0, x1=B.x1, y0=B.y0, y1=B.y1;
  const vis=(x,y,pad)=>x>=x0-(pad||0)&&x<=x1+(pad||0)&&y>=y0-(pad||0)&&y<=y1+(pad||0);
  /* Rendering relevance has three bands and never changes simulation state:

       0 outside the expanded camera — submit nothing;

       1 visible strategic/far — legacy/far material and no cosmetic hardware;

       2 tactical/important — full V2 material and secondary detail.

     Owned and allied armies keep fighting off-screen; they simply stop

     consuming draw bandwidth until the camera can see them again. */
  const renderBand=(x,y,pad,important)=>{
    if(!vis(x,y,pad))return 0;
    if(important)return 2;
    const far=orthoSpan>(typeof mfLodSpan==='function'?mfLodSpan(2250):2250)||dist2(x,y,cam.x,cam.y)>Math.pow(orthoSpan*.58+pad,2);
    return far?1:2;
  };
  const gh=(x,y)=>terrainH(x,y);
  /* Stage 1 ring LOD. vis() drops off-screen; usel drops unselected mass.

     Army-select at 1000 still paints a carpet at tactical zoom — cap at 48

     and cell-collapse. Command altitude (orthoSpan>1400) keeps the commander

     only: 48 rings at that height is still a smear. Draw budget, not a fake

     4000 pop cap. Count once so icon plates and ground rings share it. */
  let selOnCam=0;
  for(let i=0;i<unitHigh;i++) if(ualive[i]&&usel[i]&&vis(ux[i],uy[i],40)) selOnCam++;
  const SEL_RING_LOD=48;
  const RING_STRATEGIC=orthoSpan>(typeof mfLodSpan==='function'?mfLodSpan(1400):1400);
  const ringKeepCmd=i=>i===heroIdx||(TYPES[utype[i]]&&TYPES[utype[i]].cat==='hero')
    ||(typeof isEnemyCommander==='function'&&isEnemyCommander(i));
  if(typeof mfIconStackRebuild==='function') mfIconStackRebuild(vis, ringKeepCmd);

  /* ---------------- terrain ----------------

     Drawn with its own program so it can sample the painted map canvas plus a

     tiling detail layer, rather than flat vertex colour.



     UNLESS THAT PROGRAM DID NOT BUILD. On a GPU where the terrain shader fails

     to compile or link, every other program still works — so units, buildings,

     rocks and crystals render normally and the GROUND is simply absent. That is

     the "map isn't rendering" report, and it is invisible from here because the

     failure only ever reached a phone's console. The terrain VAO carries the

     model program's exact vertex layout, so we can still draw real lit ground:

     vertex colour and material instead of the painted map, which is a downgrade

     but not a void. */
  if(typeof terrainProgOK!=='undefined'&&!terrainProgOK&&prog3D){
    begin3D(S_nA);
    setEmis(0);
    drawTerrainFallback();
    begin3D(S_nA);
  } else {
  gl.useProgram(progT);
  gl.uniformMatrix4fv(UT.uVP,false,matVP);
  gl.uniform3f(UT.uEye,eyeX,eyeY,eyeZ);
  gl.uniform3f(UT.uSun,Sun.dir[0],Sun.dir[1],Sun.dir[2]);
  { const c=_lin(Sun.col); gl.uniform3f(UT.uSunC,c[0],c[1],c[2]); }
  { const c=_lin(Sun.sky); gl.uniform3f(UT.uAmbSky,c[0],c[1],c[2]); }
  { const c=_lin(Sun.gnd); gl.uniform3f(UT.uAmbGnd,c[0],c[1],c[2]); }
  { const c=_lin(Sun.fog); gl.uniform3f(UT.uFogC,c[0],c[1],c[2]); }
  if(UT.uHazeQ) gl.uniform1f(UT.uHazeQ, typeof mfHazeQ==='function'?mfHazeQ():1);
  gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D,terrainTex);
  gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D,detailTex);
  /* Units 4/5/6 belong to the post chain. Fog uses 7 and immediately restores

     the active unit, so it cannot alias a material or AO sampler. */
  gl.activeTexture(gl.TEXTURE7); gl.bindTexture(gl.TEXTURE_2D,fogTex||terrainTex);
   gl.uniform1f(UT.uFogActive,fogGameplayActive()&&!demoMode&&fogTex?1:0);
  /* Splat inputs live on 8/9 — above the post chain's 4/5/6, so neither side

     can alias the other. Tile cells are integers into the 11x11 atlas. */
  const _rt=(typeof terrGroundTex!=='undefined')&&terrGroundTex&&terrSoilTex&&terrPaveTex&&terrGrassTex;
  gl.activeTexture(gl.TEXTURE8); gl.bindTexture(gl.TEXTURE_2D,_rt?terrGroundTex:matTex);
  gl.activeTexture(gl.TEXTURE9); gl.bindTexture(gl.TEXTURE_2D,(typeof groundMaskTex!=='undefined'&&groundMaskTex)||terrainTex);
  gl.activeTexture(gl.TEXTURE10); gl.bindTexture(gl.TEXTURE_2D,(typeof heightTex!=='undefined'&&heightTex)||terrainTex);
  gl.activeTexture(gl.TEXTURE11); gl.bindTexture(gl.TEXTURE_2D,_rt?terrSoilTex:matTex);
  gl.activeTexture(gl.TEXTURE12); gl.bindTexture(gl.TEXTURE_2D,_rt?terrPaveTex:matTex);
  gl.activeTexture(gl.TEXTURE13); gl.bindTexture(gl.TEXTURE_2D,_rt?terrGrassTex:matTex);
  const _rn=(typeof terrGroundNrm!=='undefined')&&terrGroundNrm&&terrSoilNrm&&terrPaveNrm&&terrGrassNrm;
  gl.activeTexture(gl.TEXTURE2); gl.bindTexture(gl.TEXTURE_2D,_rn?terrGroundNrm:matNrmTex);
  gl.activeTexture(gl.TEXTURE3); gl.bindTexture(gl.TEXTURE_2D,_rn?terrSoilNrm:matNrmTex);
  gl.activeTexture(gl.TEXTURE14); gl.bindTexture(gl.TEXTURE_2D,_rn?terrPaveNrm:matNrmTex);
  gl.activeTexture(gl.TEXTURE15); gl.bindTexture(gl.TEXTURE_2D,_rn?terrGrassNrm:matNrmTex);
  gl.activeTexture(gl.TEXTURE0);
  gl.uniform1f(UT.uRealTex,_rt?1:0);
  {
    const E=typeof battlefieldPlayBounds==='function'?battlefieldPlayBounds(0):{lo:0,hi:MAP};
    const ES=terrainExclusionStyle(curMap,curTheme),style=ES.style,ec=ES.tint;
    const lc=_lin([ec[0]/255,ec[1]/255,ec[2]/255]);
    gl.uniform2f(UT.uPlayBounds,E.lo,E.hi);
    gl.uniform1f(UT.uEdgeStyle,style);gl.uniform1f(UT.uEdgeTime,t);
    /* Impact burns: newest first, culled to view, cooled by age. Explosive

       glow dies in ~11 s, its char fades by ~70 s; civic ember fields hold

       heat longer (~90 s) so a burning city stays readable. Kinetic churn

       settles in ~22 s. Cheap: at most 16 vec4s a frame. */
    if(typeof groundBurns!=='undefined'){
      const now=stats.t;
      const burnLife=G=>!G.kind?22:(G.civic?90:70);
      for(let i=groundBurns.length-1;i>=0;i--){
        const G=groundBurns[i];
        if(now-G.t0>burnLife(G)) groundBurns.splice(i,1);
      }
      const bv=_burnVec, bk=_burnKind; let bn=0;
      for(let i=groundBurns.length-1;i>=0&&bn<16;i--){
        const G=groundBurns[i];
        if(!vis(G.x,G.y,G.r+60)) continue;
        const life=burnLife(G);
        bv[bn*4]=G.x; bv[bn*4+1]=G.y; bv[bn*4+2]=G.r;
        bv[bn*4+3]=clamp((now-G.t0)/life,0,1);
        bk[bn]=G.kind; bn++;
      }
      gl.uniform1i(UT.uBurnN,bn);
      if(bn){ gl.uniform4fv(UT.uBurns,bv); gl.uniform1fv(UT.uBurnKind,bk); }
    } else gl.uniform1i(UT.uBurnN,0);
    gl.uniform3f(UT.uEdgeTint,lc[0],lc[1],lc[2]);
  }
  gl.activeTexture(gl.TEXTURE0);
  drawTerrainEdge();
  drawTerrain();
  }
  if(typeof csmPrepare==='function') csmPrepare(Sun);
  if(typeof materialV2QueueShadows==='function')materialV2QueueShadows(Sun);
  drawShadows(Sun);                 // ground shadows go on before anything stands on them
  begin3D(S_nA);                    // back to the lit model program

  /* Material V2 is an opt-in laboratory until its mobile/army gates pass.

     It draws into the ordinary opaque/SSAO target, then restores begin3D so

     every production stream remains on the legacy shader. */
  if(typeof renderMaterialV2Lab==='function')renderMaterialV2Lab(S_nA,t);

  // ---------------- scenery ----------------
  const qDraw=typeof qualityKey==='function'?qualityKey():'high';
  /* MEDIUM/LOW: every other rock/tree at command zoom. HIGH still submits

     the full stand — one instanced draw either way; this is instance fill

     at a height where a trunk is ~2 px. */
  const sceneryStep=(qDraw==='medium'||qDraw==='low')&&orthoSpan>(typeof mfLodSpan==='function'?mfLodSpan(2000):2000)?2:1;
  const BK=typeof biomeKit==='function'?biomeKit():null;
  const rockTint=(BK&&BK.rockTint)||[190,186,178];
  const floraMesh=k=>k==='pine'?(FX.treePine||FX.tree):k==='palm'?(FX.treePalm||FX.tree):
    k==='dead'?(FX.treeDead||FX.tree):k==='spore'?(FX.treeSpore||FX.tree):FX.tree;
  const rockMesh=k=>k==='ice'?(FX.rockIce||FX.rock):k==='slag'?(FX.rockSlag||FX.rock):FX.rock;
  for(let ri=0;ri<rocks.length;ri++){
    if(sceneryStep>1&&(ri%sceneryStep)) continue;
    const r=rocks[ri];
    if(!vis(r.x,r.y,40)||!fogPointVisible(r.x,r.y)) continue;
    rockMesh(r.k).add(r.x,r.y,gh(r.x,r.y),r.s*0.035,r.a,rockTint[0],rockTint[1],rockTint[2],255);
  }
  /* Settlements: one instanced draw per kit piece + one per site fill mesh.

     Fog rule matches buildings — an unscouted town stays dark. */
  if(typeof worldSites!=='undefined') for(const S of worldSites){
    if(!vis(S.x,S.y,S.r+140)||!fogPointVisible(S.x,S.y)) continue;
    if(S.fill&&S.fill.n!==undefined) S.fill.add(S.x,S.y,gh(S.x,S.y),1,0,255,255,255,255);
    for(const p of S.props){
      if(!vis(p.x,p.y,p.s+30)) continue;
      const K=WORLD_KIT[p.k]; if(K) K.mesh.add(p.x,p.y,gh(p.x,p.y),p.s,p.a,255,255,255,255);
    }
  }
  const tt=(BK&&BK.treeTint)||THEMES[curTheme].treeTint;
  const ct=(BK&&BK.coverTint)||[86,118,58];
  for(let ti=0;ti<trees.length;ti++){
    if(sceneryStep>1&&(ti%sceneryStep)) continue;
    const tr=trees[ti];
    if(!vis(tr.x,tr.y,50)||!fogPointVisible(tr.x,tr.y)) continue;
    floraMesh(tr.k).add(tr.x,tr.y,gh(tr.x,tr.y),tr.s*0.030,tr.a,tt[0],tt[1],tt[2],255);
  }
  if(typeof cover!=='undefined'&&FX.bush) for(let ci=0;ci<cover.length;ci++){
    if(sceneryStep>1&&(ci%sceneryStep)) continue;
    const b=cover[ci];
    if(!vis(b.x,b.y,36)||!fogPointVisible(b.x,b.y)) continue;
    FX.bush.add(b.x,b.y,gh(b.x,b.y),b.s*0.042,b.a,ct[0],ct[1],ct[2],255);
  }
  for(const cs of crystals){
    const D=deposits[cs.dep],tier=depositTier(D);if(!D||cs.band>tier||!vis(cs.x,cs.y,52))continue;
    if(!fogPointVisible(cs.x,cs.y))continue;
    const fill=clamp((D.remaining-(tier-1)*DEPOSIT_BAND)/DEPOSIT_BAND,0,1),edge=cs.band===tier?(.46+.54*fill):1;
    const col=cs.band===3?[255,120,255]:cs.band===2?[105,255,176]:[105,226,255];
    const sc=cs.s*(cs.core?.073:.058)*edge;
    const H=gh(cs.x,cs.y);
    FX.crystal.add(cs.x,cs.y,H,sc,cs.a,col[0],col[1],col[2],255);
    /* Facet glints. A crystal that never flashes is a rock. Each cluster

       twinkles on its own phase (position-hashed), one short bright spark at

       a time - plus a standing cool glow pooled at the base, the light the

       translucent shader path implies it is leaking into the ground. */
    /* FADE, do not gate: a hard cutoff pops glows on and off when a machine

       legitimately crosses the threshold; scaled alpha arrives as dimming.

       Floor stays up during deploy — matchLive is false there, and the 0.45

       perfScale cutoff left crystals looking like unlit rocks. */
    const deployGlow=(!matchLive&&typeof carrier!=='undefined'&&carrier.active)?0.9:0;
    const glowQ=Math.max(0.65, deployGlow, clamp((perfScale-0.28)/0.45,0,1));
    if(glowQ>0.02){
      const tw=Math.sin(t*2.1+cs.x*0.37+cs.y*0.113);
      if(tw>0.97){
        const f=(tw-0.97)*33, ga=cs.a+cs.x;
        bbAdd.add(sprites.spark||sprites.glow,
          cs.x+Math.cos(ga)*sc*46, cs.y+Math.sin(ga)*sc*46, H+sc*175*(0.55+0.4*Math.sin(cs.y)),
          1.8+f*2.2, t*2+cs.x, 235,250,255, 140*f*glowQ);
      }
      if(cs.core){
        bbAdd.add(sprites.glow,cs.x,cs.y,H+1.5,sc*14,0,col[0],col[1],col[2],32*glowQ);
      } else {
        bbAdd.add(sprites.glow,cs.x,cs.y,H+1.3,sc*8,0,col[0],col[1],col[2],20*glowQ);
      }
    }
  }
  /* Resource nodes are ore mounds / vents, tinted by kit habit. Cyan/pink

     orbs were the same sticker on every planet. */
  const massHabit=(BK&&BK.mass)||'ore', enHabit=(BK&&BK.energy)||'vent';
  const massCol=massHabit==='ice'?[188,210,226]:massHabit==='slag'?[118,78,58]:
    massHabit==='ichor'?[128,64,82]:[168,148,118];
  const enCol=enHabit==='frost'?[176,216,226]:enHabit==='heat'?[226,128,58]:
    enHabit==='spore'?[186,78,140]:[92,196,206];
  for(const D of deposits){ if(!vis(D.x,D.y,96)||!fogPointVisible(D.x,D.y)) continue;
    const tier=depositTier(D);
    const col=tier?massCol:[88,84,78];
    const H=gh(D.x,D.y);
    FX.dep.add(D.x,D.y,H,1.18+tier*.17,0,col[0],col[1],col[2],tier?255:145);
  }
  for(const G of geysers){ if(!vis(G.x,G.y,96)||!fogPointVisible(G.x,G.y)) continue;
    const tier=typeof geyserTier==='function'?geyserTier(G):(G.taken?2:3);
    const pc=tier?enCol:[83,82,78];
    const pulse=.72+.28*Math.sin(t*2.6+(G.pulse||G.x*.01)),H=gh(G.x,G.y);
    FX.geyser.add(G.x,G.y,H,1.12+tier*.1,0,pc[0],pc[1],pc[2],tier?(G.taken?205:255):125);
    if(tier&&qDraw==='high'){
      bbAdd.add(sprites.glow,G.x,G.y,H+10,(14+tier*3)*pulse,0,pc[0],pc[1],pc[2],G.taken?48:72);
    }
  }
  // crater berms — real mounds standing on the deformed ground
  for(const M of relief){ if(!vis(M.x,M.y,60)||!fogPointVisible(M.x,M.y)) continue;
    FX.berm.add(M.x,M.y,gh(M.x,M.y),M.w*0.075,M.a,208,196,178,255); }
  // salvage fields
  /* Salvage is coloured by what it came from, so a player can tell at a glance

     whether a field is worth walking to: cold alloy reads as scrap and pays

     energy, pale carcass reads as biomass and does not. Tinting here rather

     than in the model keeps it one instanced draw for every kind. */
  for(const W of wrecks){ if(!vis(W.x,W.y,50)||!fogPointVisible(W.x,W.y)) continue;
    const f=0.7+0.5*(W.mass/Math.max(1,W.m0));
    const c = W.kind===5 ? [206,190,150]      // biomass — bone-pale carcass
            : W.kind===2 ? [172,166,158]      // city ruin — dusty concrete
            : [200,190,178];                  // scrap and fallen structures
    FX.wreck.add(W.x,W.y,gh(W.x,W.y),W.s*0.045*f*(W.kind===5?0.8:1),W.a, c[0],c[1],c[2],255); }
  for(const Cc of crates){ if(!vis(Cc.x,Cc.y,60)||(!fogPointVisible(Cc.x,Cc.y)&&!Cc.seen)) continue;
    const cc=Cc.kind&&Cc.kind.col||[255,240,190],rs=1+(Cc.kind&&Cc.kind.rarity||0)*.08;
    FX.crate.add(Cc.x,Cc.y,gh(Cc.x,Cc.y)+Cc.alt*0.55+(Cc.alt>0?0:Math.sin(t*2.4+Cc.x)*1.6),rs,Cc.alt>0?t*2.2:t*0.35,cc[0],cc[1],cc[2],255); }

  // ---------------- derelict districts ----------------
  const worldV2=typeof mfWorldV2Enabled==='function'&&mfWorldV2Enabled();
  for(const R of relics){
    const deadAge=R.alive?0:Math.max(0,(typeof stats!=='undefined'?stats.t:t)-(R.fallT||0));
    if(!R.alive && deadAge>20) continue;
    const rLod=renderBand(R.x,R.y,120,false);
    if(!rLod||!fogPointVisible(R.x,R.y)) continue;
    const dmg=R.alive?(R.hp/R.hpm):0, tint=R.alive?(180+70*dmg):96;
    /* Each ruin mesh is authored at a reference footprint; the instance scale

       maps the planned plot size onto it. Tower blocks are the tall ones, so

       they get the tightest divisor or they overwhelm the skyline. */
    /* Divisors map a plot footprint onto each mesh's own authored reference

       size. The derelict meshes are authored at tens of units; the WORLD_KIT

       meshes are authored NORMALISED (height 0.63-1.49), so their divisor is 1

       and the plot footprint IS the scale. Dividing them by 34 like a ruin

       rendered 1-unit-tall buildings -- present in every count, invisible on

       screen. */
    const sc=Math.max(R.w,R.h)/ (R.kind===2?104 : R.kind===0?46 : R.kind===3?52 : R.kind===4?46 : R.kind===5?44
             : (R.kind===6||R.kind===7)?1 : 44)*(R.alive?1:clamp(0.16+0.12*(1-deadAge/20),0.16,0.28));
    const wreckYaw=(R.a||0)+(R.lean||0)+(R.alive?0:0.42);
    /* Kind 4 is the intact civic block. Falling back to the low block if its

       mesh is missing is not paranoia: models-civic.js has to be registered in

       BOTH boot.js and assets/data/manifest.json, and a file that is listed in

       only one silently does not load — which would otherwise turn every civic

       plot into a null dereference in the hot render loop.

       Kind 5 is the skyline anchor: the alien crystalline monolith on the

       foreign worlds, otherwise the two skyscrapers alternated by position

       hash so twin districts don't clone. */
    const alien5=curTheme==='vespera'||curTheme==='ashland';
    /* Kinds 6/7 are authored template plots and draw from WORLD_KIT, keyed by

       the role the template named. Same null-guard discipline as kind 4 above:

       worldkit.js is registered in both manifests, but a kit whose initialiser

       never ran leaves WORLD_KIT empty, and an unguarded lookup here is a null

       dereference in the hot render loop. Falling back to the derelict block

       shows a building rather than nothing. */
    const kitM=(R.kind===6||R.kind===7)&&typeof WORLD_KIT!=='undefined'&&R.role
      ? (WORLD_KIT[R.role]&&WORLD_KIT[R.role].mesh) : null;
    const mesh=kitM || (R.kind===2?FX.cityH : R.kind===3?FX.cityK : R.kind===0?FX.cityT
             : R.kind===4?(FX.cityC||FX.cityD)
             : R.kind===5?((alien5?FX.skyA:(((R.x*7+R.y*13)|0)%2?FX.sky2:FX.sky1))||FX.cityT)
             : FX.cityD);
    /* V2 and legacy are deliberately separate instance streams. Until all

       three maps have decoded (or on LOW quality), the old mesh draws instead

       of leaving an empty lot. Skyline anchors have no V2 stream — they are

       authored geometry and always draw through their own mesh. */
    if(R.kind===5){
      const vt=curTheme==='vespera';
      /* Past the shear the anchor draws as its own stump. The alien monolith

         has no stump form — a crystal growth shatters rather than shearing,

         so it keeps its silhouette and loses it all at zero. */
      const m5=(R.part&&mesh!==FX.skyA&&FX.skyS)?FX.skyS:mesh;
      m5.add(R.x,R.y,gh(R.x,R.y),sc,wreckYaw,
               vt?226:(curTheme==='ashland'?255:tint),
               vt?205:(curTheme==='ashland'?214:tint-6),
               vt?244:(curTheme==='ashland'?196:tint-16),255);
    } else if(!worldV2||!mfWorldV2Queue(R,sc,gh(R.x,R.y),rLod))
      mesh.add(R.x,R.y,gh(R.x,R.y),sc*(R.kind===0?0.9:1),wreckYaw,tint,tint-6,tint-16,255);
    if(FX.decal) FX.decal.add(R.x,R.y,gh(R.x,R.y)+0.2,sc*1.05,R.a,12,18,28,130);
    /* The berm that ties the block to the ground. Footprint-shaped (the

       cross-axis lane carries depth), tinted with the BIOME so the transition

       belongs to this world rather than to the model's own grey. */
    if(FX.skirt&&rLod<2)
      FX.skirt.add(R.x,R.y,gh(R.x,R.y)+0.14,R.w*1.34,R.a,_skC[0],_skC[1],_skC[2],255,R.h*1.34);
  }
  const worldV2CsmDefer=worldV2&&typeof csmActive==='function'&&csmActive();
  if(worldV2&&!worldV2CsmDefer)mfWorldV2Flush(Sun,S_nA,t);

  /* Structure hardstands are no longer drawn as geometry at all. They are

     levelled into the heightfield and painted into the terrain texture the

     moment a structure is placed, so they ARE the ground — which removes an

     entire pass of ground-hugging quads and, with it, the z-fighting that

     made them flicker as white sheets on shallower depth buffers. */

  /* A building keeps its simulation type, while its resolved owner selects a

     completely different model registry. Iterating buildings once preserves

     instancing without multiplying the hot loop by every faction and type. */
  for(const Bd of blds){
    const wreckAge=(!Bd.alive&&Bd.fallT)?Math.max(0,(typeof stats!=='undefined'?stats.t:t)-Bd.fallT):-1;
    const wreck=wreckAge>=0&&wreckAge<14;
    if(!Bd.alive&&!wreck) continue;
    const bImportant=Bd.alive&&Bd.team===0&&(Bd.type==='hq'||Bd===blds[openBld]);
    const bLod=renderBand(Bd.x,Bd.y,140,bImportant);
    if(!bLod) continue;
    if(!fogEntityVisible(Bd.team,Bd.x,Bd.y)) continue;
    const fac=bldFactionKey(Bd);
    /* STRATEGIC TIER — STRUCTURES. The mirror of the unit branch at :1175, and

       until now the missing half of the feature: mfIconCellForBld, mfBldSpan

       and the eight building glyphs existed, were rasterised into the atlas

       every session, and had no caller. A field of unit symbols floating over

       unreadable building meshes is not a strategic view.



       SITED AFTER THE FOG GATE ABOVE, never in place of it. Disclosure is fog's

       decision at every tier; an icon is only a different way of drawing

       something the player is already allowed to see. (The literal

       fogEntityVisible(Bd.team,Bd.x,Bd.y) line above is pinned by

       tools/test-faction-strategic-defense.mjs.)



       Sited before bldMeshFor() so a fully iconised structure also skips the

       mesh registry lookup, the berm, the turret and the strategic VFX — the

       same CPU saving the unit branch takes.



       WHAT ACTUALLY CONVERTS, measured at VH=915: mfBldSpan is footprint-based

       (size*2.2), so a wall crosses to a pure icon at span 2952 and a Sentinel

       reaches q=0.82 at SPAN_MAX=3400, while a Factory sits at q=0 and a

       Carrier HQ would need span 10199. The crossings scale with VH, so this is

       the 915 px phone case and a shorter viewport converts MORE, not less: at

       VH=800 the Sentinel is a pure icon and the Extractor reaches q=0.83.

       Small emplacements become symbols; landmarks keep their silhouettes for

       the whole zoom range. That is the

       Supreme-Commander read this file's header argues for, and it is why the

       icon LAYERS over the mesh rather than fading it — fading a building by

       screen footprint is exactly the regression in

       docs/POSTMORTEM-1.33.31-REGRESSION.md. */
    const BTd=BT[Bd.type];
    const bIcon=wreck?0:((typeof mfIconQ==='function'&&BTd)?mfIconQ(mfBldSpan(BTd)):0);
    if(bIcon>0&&mfIconEnsure()){
      const bH=(BTd.placement==='water'?0:gh(Bd.x,Bd.y))+2,
            bBody=mfIconBody(Bd.team), bInk=mfIconInk(Bd.team),
            bDpx=mfIconDpxBld(BTd), bIa=255*bIcon;
      /* Domain 'str' — the flat anchored base variant of this faction's plate.

         A structure is not a vehicle and should not wear the ground plate. */
      bbIcon.add(mfIconPlateFor(fac,null,'str'),Bd.x,Bd.y,bH,bDpx,0,bBody[0],bBody[1],bBody[2],bIa);
      bbIcon.add(mfIconCellForBld(BTd,fac),Bd.x,Bd.y,bH,bDpx*0.60,0,bInk[0],bInk[1],bInk[2],bIa);
      if(bImportant){ const bBr=(typeof TEAMB!=='undefined'&&TEAMB[Bd.team])||bBody;
        bbIcon.add(MF_ICO.pl_ring,Bd.x,Bd.y,bH,bDpx*1.26,0,bBr[0],bBr[1],bBr[2],bIa); }
      /* Only a FINISHED structure may drop its mesh. A construction site still

         has to show `grow` — replacing a half-built factory with a completed

         symbol would report a building the player does not yet own. */
      if(bIcon>=1&&Bd.prog>=1) continue;
    }
    const M=bldMeshFor(Bd); if(!M) continue;
    /* Buildings need a lighter faction-grade tint than tiny units: at phone

       zoom the regular team-blue multiplication crushed PBR panels into one

       navy silhouette. The livery remains coloured, but steel and glass read. */
    const tc=fac==='nova'?[188,226,255]:fac==='legion'?[255,156,126]:fac==='syndicate'?[174,224,255]:fac==='horde'?[214,166,255]:(TEAMC[Bd.team]||TEAMC[2]),
          H=BT[Bd.type]&&BT[Bd.type].placement==='water'?0:gh(Bd.x,Bd.y);
    const deployAge=Bd.type==='hq'&&Bd.deployT?Math.max(0,t-Bd.deployT):99;
    const deployQ=clamp(deployAge/2.1,0,1);
    /* The functional HQ is created on touchdown, but its art unfolds over two

       seconds. This avoids the old visual lie where a dropship disappeared

       and a completed base teleported into the exact same footprint. */
    const grow=(Bd.prog<1 ? 0.30+0.70*Bd.prog : 1)*(deployAge<2.1?.62+.38*deployQ:1)*(wreck?clamp(0.22+0.16*(1-wreckAge/14),0.22,0.38):1);
    const an=t*1.6+(Bd.anim||0);
    let bob=0, sq=1, em=0;
    switch(Bd.type){
      case 'mex':  bob=Math.sin(an*2.6)*1.2; break;
      case 'pgen': case 'geo': em=0.05+Math.sin(an*1.7)*0.04; break;
      case 'fac': case 'tgate': case 'airfield': case 'harbor':
        if(Bd.queue.length){ bob=Math.sin(an*3.6)*0.8; em=0.03+Math.abs(Math.sin(an*4))*0.04; } break;
      case 'fab':  em=0.08+Math.abs(Math.sin(an*5.2))*0.10; break;
      case 'techlab': em=0.03+Math.sin(an*2.2)*0.03; break;
      case 'arc':  em=0.06+Math.abs(Math.sin(an*3.4))*0.12; break;
      case 'nest': sq=1+Math.sin(an*1.9)*0.05; break;
      case 'nova': em=Bd.cool<=0?0.10+Math.sin(an*3)*0.06:0; break;
      /* Charged Stormcaller hums visibly; a firing one strobes. */
      case 'stormcaller': em=Bd.sq?0.22+Math.abs(Math.sin(an*9))*0.2:Bd.cool<=0?0.12+Math.sin(an*2.6)*0.07:0.02; break;
    }
    if(fac==='syndicate'){
      bob+=1.15+Math.sin(an*2.25+Bd.x*.01)*0.55;
      em+=0.05+Math.abs(Math.sin(an*2.1))*0.05;
    }else if(fac==='horde'){
      bob*=0.18;
      sq*=1+Math.sin(an*1.72+Bd.y*.012)*0.026;
      em+=0.025+Math.abs(Math.sin(an*2.8))*0.035;
    }
    if(Bd.hitT>0) em+=0.35;
    if(deployAge<2.4){
      const pulse=1-deployAge/2.4,pc=fac==='horde'?[168,235,78]:fac==='legion'?[255,132,78]:fac==='syndicate'?[76,215,255]:[132,218,255];
      FX.ring.add(Bd.x,Bd.y,H+2,42+deployQ*48,t*1.4,pc[0],pc[1],pc[2],190*pulse);
      FX.ring.add(Bd.x,Bd.y,H+3,24+deployQ*34,-t*1.9,pc[0],pc[1],pc[2],125*pulse);
      if(fac==='horde'){
        for(let q=0;q<5;q++){
          const a=q/5*TAU+t*.35,r=28+deployQ*43;
          bbAdd.add(sprites.glow,Bd.x+Math.cos(a)*r,Bd.y+Math.sin(a)*r,H+5,7,0,pc[0],pc[1],pc[2],105*pulse);
        }
      }
    }
    const vi=Math.min((M.variants&&M.variants.length||1)-1,Math.max(0,(Bd.lvl||1)-1));
    const V=M.variants?M.variants[vi]:M;
    const damageState=wreck?0.999:(Bd.prog<1?0:Math.min(.999,1-clamp(Bd.hp/Math.max(1,Bd.hpm),0,1)));
    /* HQs are landmarks, so they receive the dedicated V2 landmark profile

       instead of merely being another building using a faction tint. This is

       the live production route for future authored HQ map packs. */
    /* HQ=landmark (profile 2). Other structures use profile 3 so FS3D

       scorches them under fire; units stay on band 0 / commander 1. */
    const surfaceState=(Bd.type==='hq'?4:6)+damageState;
    /* Encode pulse above opaque alpha; the solid shader separates it into a

       per-instance emission value. A shared mesh can now batch every building

       of this faction/type without one animated reactor flushing (and tinting)

       unrelated instances that were already queued. */
    if(wreck){ em=0; bob=0; }
    V.base.add(Bd.x,Bd.y,H+bob,grow*sq,(Bd.rot||0)+(wreck?0.20:0),tc[0],tc[1],tc[2],255*(1+em),undefined,undefined,surfaceState);
    /* THE SAME BERM THE DERELICTS GET. A faction structure dropped onto a

       graded pad meets it at a perfect edge and reads as a game piece sitting

       on a board; this is the turned ground, spoil and broken slab that makes

       it read as EMPLACED. It follows `grow`, so it rises out of the ground

       with the building during construction rather than popping in complete,

       and it is biome-tinted, so the same factory belongs on ice and on ash. */
    if(FX.skirt&&Bd.prog>=1&&bLod<2){
      /* Sized to the PAVED APRON, not the hull. The join that reads as pasted

         on is concrete-to-terrain at the pad's outer edge, not hull-to-pad —

         skirting the hull only decorates ground that already matched. The

         foundation is bldFoot x 1.30 snapped to grid, so the berm straddles

         that boundary and dies into the biome just outside it. */
      const fr=(typeof foundationRect==='function')?foundationRect(Bd):null;
      const fw=(fr?fr[0]:(BT[Bd.type]&&BT[Bd.type].size||18)*2.2)*grow;
      const fh=(fr?fr[1]:(BT[Bd.type]&&BT[Bd.type].size||18)*2.2)*grow;
      FX.skirt.add(Bd.x,Bd.y,H+0.14,fw*1.05,Bd.rot||0,_skC[0],_skC[1],_skC[2],255,fh*1.05);
    }
    if(V.tur){
      V.tur.add(Bd.x,Bd.y,H+(M.turH||BLD_TUR_H[Bd.type]||14)*grow+bob,
        grow*(M.turS||BLD_TUR_S[Bd.type]||1),(Bd.tang||0)-Math.PI/2,tc[0],tc[1],tc[2],255,undefined,undefined,surfaceState);
    }
    if(!wreck&&(bLod===2||Bd.type==='hq'))addFactionStrategicBuildingVfx(Bd,fac,H,bob,grow,t,M);
    /* The command structure is the player's visual anchor. A restrained

       world-space beacon remains readable at strategic zoom, while the BASE

       button centers the same live object in one tap. */
    if(!wreck&&Bd.team===0&&Bd.type==='hq'&&Bd.prog>=1){
      const pulse=.76+.24*Math.sin(t*2.2);
      const bc=fac==='legion'?[255,112,76]:fac==='syndicate'?[72,214,255]:[92,210,255];
      FX.ring.add(Bd.x,Bd.y,H+2,58+pulse*7,t*.28,bc[0],bc[1],bc[2],74);
      /* Close-up: the old 18-unit glow sprite bloomed into a white halo on

         the roof. Keep a small beacon only at command zoom. */
      if(orthoSpan>560)
        bbAdd.add(sprites.glow,Bd.x,Bd.y,H+42,7+pulse*2,0,bc[0],bc[1],bc[2],62);
      if(orthoSpan>720)
        addBeamRibbon(sprites.glow,Bd.x,H+34,Bd.y,Bd.x,H+210,Bd.y,9,bc[0],bc[1],bc[2],42,120);
    }
  }
  if(typeof csmBegin==='function'&&typeof csmActive==='function'&&csmActive()&&csmBegin(true)){
    if(typeof csmDrawTerrain==='function') csmDrawTerrain();
    if(typeof mfWorld2Meshes!=='undefined') for(const k in mfWorld2Meshes) csmDrawMesh(mfWorld2Meshes[k]);
    csmDrawBuildingCasters();
    csmDrawSceneryCasters();
    csmEnd(S_nA);
  }
  if(worldV2CsmDefer)mfWorldV2Flush(Sun,S_nA,t);
  const bldMeshSets=[BLD_MESH,...Object.values(BLD_FACTION_MESH)];
  for(const set of bldMeshSets) for(const k in set){
    const M=set[k];
    if(M.variants) for(const V of M.variants){V.base.flush(gl);if(V.tur)V.tur.flush(gl);}
    else {M.base.flush(gl);if(M.tur)M.tur.flush(gl);}
  }
  /* Flush every world-object stream. Each of these is one draw call for an

     entire class of object — all the rocks on screen, all the tower blocks,

     every wreck — which is the whole point of instancing. */
  FX.rock.flush(gl); if(FX.rockIce) FX.rockIce.flush(gl); if(FX.rockSlag) FX.rockSlag.flush(gl);
  FX.tree.flush(gl); if(FX.treePine) FX.treePine.flush(gl); if(FX.treePalm) FX.treePalm.flush(gl);
  if(FX.treeDead) FX.treeDead.flush(gl); if(FX.treeSpore) FX.treeSpore.flush(gl);
  if(FX.bush) FX.bush.flush(gl); FX.crystal.flush(gl);
  if(typeof worldSites!=='undefined'){
    for(const S of worldSites) if(S.fill&&S.fill.n) S.fill.flush(gl);
    if(typeof WORLD_KIT!=='undefined') for(const k in WORLD_KIT){ const M=WORLD_KIT[k]; if(M.mesh.n) M.mesh.flush(gl); }
  }
  FX.dep.flush(gl); FX.geyser.flush(gl); FX.berm.flush(gl);
  FX.wreck.flush(gl); FX.crate.flush(gl);
  FX.cityT.flush(gl); FX.cityD.flush(gl); FX.cityH.flush(gl); FX.cityK.flush(gl);
  if(FX.cityC) FX.cityC.flush(gl);
  if(FX.skirt){
    /* +0.14 raise is not enough at HIGH DPR: 24-bit depth still stitches

       the berm into the pad as a shimmering seam. Offset, then restore. */
    gl.enable(gl.POLYGON_OFFSET_FILL);
    gl.polygonOffset(-6,-20);
    FX.skirt.flush(gl);
    gl.disable(gl.POLYGON_OFFSET_FILL);
  }
  FX.plate.flush(gl); FX.line.flush(gl);

  /* ---- curtain wall spans ------------------------------------------

     Each linked pair of barricades gets a rampart section built between

     them, so a wall run becomes one continuous fortification instead of a

     dotted line of separate blocks. Drawn as stretched wall geometry along

     the link axis, which is the visible payoff for laying walls in a line. */
  _wallStreams.clear();
  const wallStreams=_wallStreams;
  for(const W of blds){
    if(!W.alive||(W.type!=='wall'&&W.type!=='gate')||!W.linkA||!W.linkA.length) continue;
    if(!vis(W.x,W.y,90)) continue;
    if(!fogEntityVisible(W.team,W.x,W.y)) continue;
    const tc=TEAMC[W.team]||TEAMC[2];
    const family=BLD_FACTION_MESH[bldFactionKey(W)];
    const WM=(family&&family.wall)||BLD_MESH.wall;
    const WV=WM.variants?WM.variants[Math.min(WM.variants.length-1,Math.max(0,(W.lvl||1)-1))]:WM;
    for(const la of W.linkA){
      if(Math.cos(la)<0 || (Math.abs(Math.cos(la))<1e-6 && Math.sin(la)<0)) continue;
      const mx2=W.x+Math.cos(la)*WALL_LINK*0.34, my2=W.y+Math.sin(la)*WALL_LINK*0.34;
      const wallState=1-clamp(W.hp/Math.max(1,W.hpm),0,1);
      WV.base.add(mx2,my2,gh(mx2,my2),0.62,la,tc[0],tc[1],tc[2],255,undefined,undefined,wallState);
      wallStreams.add(WV.base);
    }
  }
  if(typeof csmBegin==='function'&&typeof csmActive==='function'&&csmActive()&&csmBegin(false)){
    for(const stream of wallStreams) csmDrawMesh(stream);
    csmEnd(S_nA);
  }
  for(const stream of wallStreams) stream.flush(gl);

  /* ---- power conduits -------------------------------------------------

     The paved service run is baked into the ground; this is the live cable

     lying on top of it, with a charge pulse travelling each span. The

     difference between "six buildings near each other" and "a base" is

     almost entirely these lines. */
  for(const Bc of blds){
    if(!Bc.alive||!Bc.conduit||!Bc.conduit.length) continue;
    if(!vis(Bc.x,Bc.y,200)) continue;
    if(!fogEntityVisible(Bc.team,Bc.x,Bc.y)) continue;
    const tb=TEAMB[Bc.team]||TEAMB[2];
    for(const O of Bc.conduit){
      if(!O.alive) continue;
      if(!fogEntityVisible(O.team,O.x,O.y)) continue;
      if(O.x<Bc.x||(O.x===Bc.x&&O.y<Bc.y)) continue;      // draw each run once
      const live=(Bc.prog>=1&&O.prog>=1)?1:0.34;
      const mx2=(Bc.x+O.x)/2, my2=(Bc.y+O.y)/2;
      const len=Math.hypot(O.x-Bc.x,O.y-Bc.y);
      const ang=Math.atan2(O.y-Bc.y,O.x-Bc.x);
      FX.line.add(mx2,my2,gh(mx2,my2)+2.4,len,ang, tb[0],tb[1],tb[2], 140*live, 2.4);
      const ph=(t*0.55+(Bc.x+Bc.y)*0.004)%1;
      const pxp=Bc.x+(O.x-Bc.x)*ph, pyp=Bc.y+(O.y-Bc.y)*ph;
      bbAdd.add(sprites.glow,pxp,pyp,gh(pxp,pyp)+5,14,0, tb[0],tb[1],tb[2], 210*live);
    }
  }

  /* ---------------- orbital dropship (pre-deployment) ----------------

     Flown, not placed. It holds a hover altitude, banks into its turns and

     runs its engines — none of which a building does, which was exactly why

     borrowing the deployed HQ's mesh made it read as a sliding bunker. */
  if(typeof singularities!=='undefined') for(const Sg of singularities){
    const dxs=Sg.x-cam.x,dys=Sg.y-cam.y;
    sceneLightPush(Sg.x,Sg.y,terrainH(Sg.x,Sg.y)+22,150,_lin([172,120,255])[0],_lin([172,120,255])[1],_lin([172,120,255])[2],
      0.9+0.5*Math.sin((typeof stats!=='undefined'?stats.t:0)*9),150*150/(dxs*dxs+dys*dys+150*150)+3);
  }
  if(carrier.active&&carrier.phase<2){
    const H=gh(carrier.x,carrier.y),key=dropFactionKey(carrier.fac);
    const hover=carrier.phase===1? 26+Math.sin(t*1.5)*2.4 : 0;
    const flightAlt=carrierEffectiveAlt();
    const alt=H+flightAlt*0.85+hover;
    const dx=carrier.tx-carrier.x, dy=carrier.ty-carrier.y;
    const moving=Math.hypot(dx,dy)>10;
    const thrust=flightAlt>0?1:(moving?0.8:0.36);
    const vtolPose=clamp(flightAlt/Math.max(1,CARRIER_CRUISE_ALT),0,1);
    drawDropCraft(key,carrier.x,carrier.y,alt,carrier.ang,t,255,
                  carrier.phase===1&&flightAlt<8,thrust,vtolPose);
  }

  /* Enemy headquarters retain their own landed craft during the player's

     planning phase, then visibly lift away at match start. This is a bounded

     arrival cue, not a second interactive carrier simulation. */
  for(const A of aiDeployArrivals){
    if(!vis(A.x,A.y,150)||!fogPointVisible(A.x,A.y)) continue;
    const elapsed=A.depart?Math.max(0,t-A.depart):0;
    if(elapsed>8) continue;
    const fade=A.depart?clamp(1-elapsed/8,0,1):1;
    const rise=A.depart?elapsed*elapsed*11:0;
    const drift=A.depart?elapsed*13:0;
    const x=A.x+Math.cos(A.ang)*drift,y=A.y+Math.sin(A.ang)*drift;
    const alt=gh(A.x,A.y)+28+Math.sin(t*1.35+A.x*.01)*1.6+rise;
    drawDropCraft(A.fac,x,y,alt,A.ang,t,255*fade,!A.depart||elapsed<.8,.48+fade*.35,
                  clamp(rise/Math.max(1,CARRIER_CRUISE_ALT),0,1));
    if(!A.depart||elapsed<1.3){
      const P=DROP_PROFILE[dropFactionKey(A.fac)];
      bbAdd.add(sprites.glow,A.x,A.y,gh(A.x,A.y)+1.1,12,0,P.glow[0],P.glow[1],P.glow[2],24*fade);
    }
  }

  // ---------------- units ----------------
  const step=teamCount[2]>9000?2:1;
  /* Resolved once per frame, not per unit: the equipped module set only changes

     between matches, and modAttachSync() short-circuits on an unchanged

     signature so this is a string compare in the steady state. */
  const modKit=(typeof modAttachSync==='function')?modAttachSync():[];
  for(let i=0;i<unitHigh;i++){
    if(!ualive[i]) continue;
    const X=ux[i], Y=uy[i];
    const T=TYPES[utype[i]],uImportant=usel[i]||i===heroIdx||T.cat==='hero'||(typeof isEnemyCommander==='function'&&isEnemyCommander(i));
    const uLod=renderBand(X,Y,80,uImportant);
    if(!uLod) continue;
    if(!fogEntityVisible(uteam[i],X,Y)) continue;
    if(uteam[i]===2 && step>1 && (i&1)) continue;
    /* Enemy factions field DIFFERENT HARDWARE, not a recolour: the Syndicate

       hovers on plenum skirts with coil emitters, the Horde is grown carapace

       and claws. You should know what you're fighting from the silhouette

       before the colour registers. */
    /* Team 0 was hard-wired to the Nova kit, which is what made the player's

       own faction choice cosmetic. Both sides now resolve their kit the same

       way, from whichever faction is actually fielding the unit. */
    const ownFac=(typeof playerFaction!=='undefined'&&playerFaction)||'nova';
    const ownKit=(typeof playerKitKey==='function')?playerKitKey():
      ((typeof FACTIONS!=='undefined'&&FACTIONS[ownFac]&&FACTIONS[ownFac].kit)||'nova');
    const unitKit=uteam[i]===0?ownKit:uteam[i]===2?'horde':
      (uteam[i]===1&&AI.fac&&FACTIONS[AI.fac]?FACTIONS[AI.fac].kit:null);
    /* STRATEGIC TIER. Past the point where this unit's own footprint stops

       reading (~24 px fading to ~15 px — per type, not per camera constant) a

       flat symbol carries role and allegiance better than a smear of mesh.

       The plate silhouette is the FACTION and the glyph is the role, so an

       icon claims the same allegiance its mesh would; resolved from the same

       unitKit the 3D path uses rather than a parallel guess.



       Sited after the kit resolves but before factionUnitMeshFor(), so a fully

       iconised unit still skips the mesh lookup, doctrine shells, equipped

       modules and organic motion — the tier saves CPU as well as pixels.



       The mesh is never faded, only dropped: the icon reaches full opacity

       while the mesh is still a ~15 px smear, and fading a mesh by screen

       footprint is precisely what flattened every building in

       docs/POSTMORTEM-1.33.31-REGRESSION.md. */
    const uIcon=(typeof mfIconQ==='function')?mfIconQ(mfUnitSpan(T)):0;
    /* A commander is marked on a ramp of its own, and ONLY marked: uMark drives

       the symbol's alpha while uIcon alone still decides whether the mesh is

       dropped below. Overloading one q for both would delete the commander's

       silhouette the moment it earned a badge — at SPAN_MIN that is a 229 px

       hero replaced by a 46 px plate. The icon layers OVER the mesh here; it

       never replaces or fades one (docs/POSTMORTEM-1.33.31-REGRESSION.md). */
    const uCmdQ=(typeof mfCmdIconQ==='function')?mfCmdIconQ(T):0;
    const uMark=uIcon>uCmdQ?uIcon:uCmdQ;
    const stackSkip=typeof mfIconStackSkip==='function'&&mfIconStackSkip(i);
    if(uMark>0&&!stackSkip&&mfIconEnsure()){
      const ih=unitGroundY(T,X,Y)+2,
            body=mfIconBody(uteam[i]), ink=mfIconInk(uteam[i]),
            dpx=(typeof mfIconDpx==='function')?mfIconDpx(T)
                :clamp(18+mfUnitSpan(T)*0.12,22,40)*mfWorldPx(),
            ia=255*uMark,
            iKit=unitKit||(uteam[i]===2?'horde':null);
      bbIcon.add(mfIconPlateFor(iKit,T),X,Y,ih,dpx,0,body[0],body[1],body[2],ia);
      /* iKit again, not a second guess: the glyph is the owner's delivered

         faction art and must claim the same allegiance the plate does. A kit

         with no art for this role falls back to the procedural glyph inside

         mfIconCellForUnit, so this stays one lookup and one instance. */
      bbIcon.add(mfIconCellForUnit(T,iKit),X,Y,ih,dpx*0.60,0,ink[0],ink[1],ink[2],ia);
      /* Selected mass at cap: the plate already shows allegiance. A ring on

         every selected icon is the same fillrate trap as FX.ring. Keep

         commanders. Skip unselected (uImportant), skip command-zoom mass,

         keep the ring for small on-camera squads. */
      if(uImportant&&(ringKeepCmd(i)||(!RING_STRATEGIC&&selOnCam<=SEL_RING_LOD&&usel[i]))){
        const br=(typeof TEAMB!=='undefined'&&TEAMB[uteam[i]])||body;
        bbIcon.add(MF_ICO.pl_ring,X,Y,ih,dpx*1.26,0,br[0],br[1],br[2],ia);
      }
      if(uIcon>=1) continue;          // fully iconised: no mesh work at all
    }
    if(stackSkip) continue;
    /* Never begin from UNIT_MESH and then hope an override exists. That made

       the mixed global registry an accidental cross-faction fallback: Blue

       slot 12 became a Ravager and a missing Brood slot became a tank. */
    let M=unitKit&&typeof factionUnitMeshFor==='function'?factionUnitMeshFor(utype[i],unitKit):null;
    /* Per-instance kit, keyed by that hero's commanderId. Player uses

       playerCommanderId; enemy/ally seats use AI.bases/allies.commanderId.

       Replacing FAC_MESH[type] would retint every chassis of that type. */
    if((T.cat==='hero'||T.hero||utype[i]===4||utype[i]===28||utype[i]===29)&&typeof commanderKitMeshFor==='function'){
      const cid=typeof commanderIdForUnit==='function'?commanderIdForUnit(i):
        (i===heroIdx&&typeof playerCommanderId!=='undefined'?playerCommanderId:null);
      if(cid){ const KM=commanderKitMeshFor(cid); if(KM) M=KM; }
    }
    if(!M) continue;
    const tc=TEAMC[uteam[i]];
    const H=unitGroundY(T,X,Y);
    /* Drawn deliberately LARGER than their collision size. At command-view

       zoom a literally-scaled tank is about twenty pixels across, which is

       not enough to read a silhouette; every RTS oversizes units for

       legibility and keeps the sim honest underneath. */
    const sc=T.size/15*M.s*1.5*(T.vscale||1);
    const a=umode[i]===4?110:255;
    // wildlife pulses and lurches; machines don't
    let ss=sc, wide=sc, doctrine=null;
    if(uteam[i]===2) ss*=1+Math.sin(t*6.2+i*2.399)*0.07;
    /* ai.js already authored scale/squash as faction doctrine, but only the old

       sprite fallback consumed it.  Applying it to the live WebGL path makes

       Ascendancy armour columns broad/heavy, Coalition hulls compact/narrow,

       and Brood bodies visibly small and numerous.  A light geometry shell is

       added only where no bespoke faction chassis exists, so artillery stays

       artillery rather than every role becoming the same faction tank. */
    const bespoke=M!==UNIT_MESH[utype[i]],heroUnit=T.cat==='hero'||!!T.hero||utype[i]===4||i===heroIdx||isEnemyCommander(i);
    /* Doctrine shells exist to keep a SHARED role chassis faction-readable.

       Commanders already have authored silhouettes. Layering the generic

       ground shell over a walking hero created a second rigid vehicle whose

       rails stayed planted while the Commander's legs moved beneath it. */
    if(uteam[i]===0&&!heroUnit&&utype[i]<28&&utype[i]!==12&&utype[i]!==13&&!bespoke&&FAC_DOCTRINE_MESH[ownFac]){
      doctrine=FAC_DOCTRINE_MESH[ownFac][T.air?'air':'ground'];
      const PF=FACTIONS[ownFac];
      if(PF&&ownFac!=='nova'){ ss*=PF.scale||1; wide=ss/(PF.squash||1); }
    }else if(uteam[i]===1&&typeof FACTIONS!=='undefined'&&FACTIONS[AI.fac]){
      const F=FACTIONS[AI.fac];
      ss*=F.scale||1;
      wide=ss/(F.squash||1);
      if(!heroUnit&&!bespoke&&utype[i]<28&&FAC_DOCTRINE_MESH[F.kit])
        doctrine=FAC_DOCTRINE_MESH[F.kit][T.air?'air':'ground'];
    }else wide=ss;
    const bank=T.air?Math.sin(t*1.7+i)*0.10:0;
    /* Walk phase. Driven by DISTANCE covered rather than by the clock, so a

       damaged or slowed machine takes shorter strides instead of moon-walking,

       and a stationary one plants its feet. Legged units only — anything on

       tracks, wheels, wings or a plenum skirt passes zero and the vertex stage

       leaves it alone. */
    const organic=uteam[i]===2||(uteam[i]===1&&AI.fac==='horde')||utype[i]===12||utype[i]===13||utype[i]===30;
    /* Procedural spring phase replaces per-bone CPU simulation. Tactical view

       gets breathing, mandible lag and flexible limbs; strategic/low quality

       supplies zero so the shader skips all secondary-motion math. */
    const organicSpan=(typeof GFX!=='undefined'&&GFX.organicSpan!=null)?GFX.organicSpan:2700;
    const organicPhase=organic&&perfScale>.36&&orthoSpan<organicSpan
      ? t*(umov[i]?6.8:2.15)+i*1.618+(uwalk[i]||0)*.45 : 0;
    const anim=organicPhase||((T.legs&&umov[i])?(uwalk[i]||1e-4):0);
    const bob=T.air?Math.sin(t*2.1+i)*2.4:0;
    const damageState=Math.min(.999,1-clamp(uhp[i]/Math.max(1,uhpm[i]),0,1));
    /* Commanders are the first live custom V2 profile. This covers Nova,

       Dominion and Syndicate commanders without forcing their unrelated meshes

       into one material or splitting each army into additional draw calls. */
    const surfaceState=(heroUnit?2:0)+damageState;
    M.hull.add(X,Y,H+bob,ss,uang[i]-Math.PI/2+bank,tc[0],tc[1],tc[2],a,wide,anim,surfaceState);
    if(M.tur) M.tur.add(X,Y,H+M.turH*ss,ss,uturr[i]-Math.PI/2,tc[0],tc[1],tc[2],a,wide,organicPhase,surfaceState);
    csmMarkUnitSkin(M,T,heroUnit,X,Y);
    if(doctrine) doctrine.add(X,Y,H+bob,ss,uang[i]-Math.PI/2+bank,tc[0],tc[1],tc[2],a,wide,undefined,surfaceState);
    /* Crafted modules are hardware, so the army wears it. Player machines only:

       the enemy is not fitted with your loadout, and a mounting bracket on a

       brood organism is not a thing. Empty when nothing is equipped, which is

       the common case and costs one array-length test per unit. */
    if(uLod===2&&modKit.length&&uteam[i]===0&&!T.brood){
      for(let k=0;k<modKit.length;k++){
        const K=modKit[k], am=K.mesh[modAttachVariant(i,k,K.mesh.length)];
        /* M.turH is the hull's own deck line — the height the game already

           uses to sit a turret on this chassis. Mounting from there is what

           makes the kit look bolted on instead of hovering. */
        /* Mounted hardware belongs to the upper chassis. Passing zero here

           made it hover rigidly while a legged unit's body bobbed underneath;

           the shared phase gives non-SERVO attachment vertices the same body

           motion without treating the equipment itself as another leg. */
        /* A module is readable equipment, not a second vehicle. The generic

           vehicle rule multiplied it by the Commander's already-large scale

           and mounted it at a tank turret height, producing an oversized

           rigid-looking block around the legs. Heroes get a torso hardpoint

           and a bounded accessory scale; the low-profile Syndicate Archon has

           its own deck height because it hovers instead of standing upright. */
        const heroMount=T.hero==='syndicate'?5.8:15.2;
        const mountH=heroUnit?heroMount:(M.turH||2.6);
        const heroGearScale=T.hero==='syndicate'?.42:.58;
        const gearScale=ss*K.s*(heroUnit?heroGearScale:1);
        am.add(X,Y,H+bob+(mountH+K.h)*ss,gearScale,uang[i]-Math.PI/2+bank,
               K.col[0],K.col[1],K.col[2],a,heroUnit?gearScale:wide,anim);
      }
    }
  }
  if(typeof mfIconStackDraw==='function') mfIconStackDraw(gh);
  if(typeof csmBegin==='function'&&typeof csmActive==='function'&&csmActive()&&csmBegin(false)){
    csmDrawUnitCasters();
    csmDrawModuleCasters();
    csmEnd(S_nA);
  }
  if(modKit.length&&typeof modAttachFlush==='function') modAttachFlush();
  for(const M of UNIT_MESH){ if(!M) continue; M.hull.flush(gl); if(M.tur) M.tur.flush(gl); }
  for(const k in FAC_MESH) for(const ty in FAC_MESH[k]){
    const M=FAC_MESH[k][ty]; M.hull.flush(gl); if(M.tur) M.tur.flush(gl);
  }
  if(typeof commanderKitMeshFlush==='function') commanderKitMeshFlush();
  for(const k in FAC_DOCTRINE_MESH){
    FAC_DOCTRINE_MESH[k].ground.flush(gl); FAC_DOCTRINE_MESH[k].air.flush(gl);
  }

  /* ---------------- ground overlays ------------------------------------

     Selection markers, the build territory and the placement ghost are all

     translucent decals lying on the terrain, so they need the blend state on.

     Drawn in the opaque pass they came out as a solid wash of colour that hid

     the entire map. Depth test stays on so a marker behind a hill is hidden;

     depth WRITE goes off so overlapping decals don't fight each other. */
  gl.enable(gl.BLEND);
  gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
  gl.depthMask(false);
  gl.disable(gl.CULL_FACE);
  /* ---- AMBIENT OCCLUSION -------------------------------------------------

     Resolved here: after every opaque surface is down, before any decal, water

     or glow. Overlays and effects then draw on top with the same depth buffer,

     so a selection ring or an explosion never picks up a contact shadow. */
  if(typeof csmApply==='function'&&csmApply()) begin3D(S_nA);
  if(aoActive){
    /* Tint toward a lifted sky, not 0.45*albedo. The old mix(c*sky, c, ao)

       with 80% occlusion crushed noon buildings into silhouettes. */
    aoResolve([
      Math.min(1, Sun.sky[0]*0.22+0.78),
      Math.min(1, Sun.sky[1]*0.22+0.80),
      Math.min(1, Sun.sky[2]*0.22+0.84)
    ]);
    /* aoResolve leaves the fullscreen AO program current. Everything below —

       selection rings, the build territory, the placement ghost — is real

       geometry drawn with the MODEL program, and was silently being issued

       against the post-process shader instead. That is why placing a structure

       showed no highlight and no ghost. */
    begin3D(S_nA);
  }

  // ---------------- selection + orders (flat geometry on the ground) --------
  /* Stage 1: skip unselected (usel) and off-screen (vis). Command zoom keeps

     commanders only. Tactical mass above SEL_RING_LOD collapses to one ring

     per view-sized cell — same pattern as health bars. */
  {
    const putSelRing=i=>{
      const T=TYPES[utype[i]];
      FX.ring.add(ux[i],uy[i],gh(ux[i],uy[i])+1.4,T.size*(T.vscale||1)*1.05,0,90,255,150,210);
    };
    if(RING_STRATEGIC){
      for(let i=0;i<unitHigh;i++){
        if(!ualive[i]||!usel[i]||!vis(ux[i],uy[i],40)) continue;
        if(ringKeepCmd(i)) putSelRing(i);
      }
    } else if(typeof mfIconStackOn==='function'&&mfIconStackOn()&&typeof mfIconStackRingLeads==='function'){
      /* Stacked rings: one per proximity cell, plus commanders. Reuses the

         stack rebuild; does not revert SEL_RING_LOD for the unstacked band. */
      const leads=mfIconStackRingLeads(vis, ringKeepCmd)||[];
      for(let h=0;h<leads.length;h++){
        const lead=leads[h], C=typeof mfIconStackCentroid==='function'?mfIconStackCentroid(lead):[ux[lead],uy[lead],1];
        const T=TYPES[utype[lead]], r=T.size*(T.vscale||1)*1.05*(1+Math.min(0.8,Math.log(C[2]||1)*0.35));
        FX.ring.add(C[0],C[1],gh(C[0],C[1])+1.4,r,0,90,255,150,210);
      }
      for(let i=0;i<unitHigh;i++){
        if(!ualive[i]||!usel[i]||!vis(ux[i],uy[i],40)) continue;
        if(ringKeepCmd(i)) putSelRing(i);
        else if(typeof mfIconStackSkip!=='function'||!mfIconStackSkip(i)) putSelRing(i);
      }
    } else if(selOnCam>SEL_RING_LOD){
      if(_hbI.length<unitHigh) _hbI=new Int32Array(unitHigh);
      let n=0;
      for(let i=0;i<unitHigh;i++){
        if(!ualive[i]||!usel[i]||!vis(ux[i],uy[i],40)) continue;
        if(ringKeepCmd(i)){ putSelRing(i); continue; }
        _hbI[n++]=i;
      }
      const cell=Math.max(48,orthoSpan/17);
      _hbCells.clear();
      for(let k=0;k<n;k++){
        const i=_hbI[k], key=((uy[i]/cell)|0)*8192+((ux[i]/cell)|0);
        if(!_hbCells.has(key)) _hbCells.set(key,i);
      }
      for(const i of _hbCells.values()) putSelRing(i);
    } else if(selOnCam){
      for(let i=0;i<unitHigh;i++){
        if(!ualive[i]||!usel[i]||!vis(ux[i],uy[i],40)) continue;
        putSelRing(i);
      }
    }
  }
  /* ---- FORMATION + PATROL ORDERS ---------------------------------------

     The sprite fallback already drew these cues, but the active mesh renderer

     never did, so a committed route disappeared on every current device. Keep

     them on the terrain/decal pass: they inherit depth, survive camera tilt,

     and cannot become another screen-space HUD pile. */
  {
    const p3Paths=!(META&&META.settings&&META.settings.orderPaths===false);
    const p3Route=(pts,closed,draft,activeStep)=>{
      if(!pts||pts.length<2)return;
      const segs=closed?pts.length:pts.length-1,base=draft?[92,224,255]:[100,245,170];
      for(let j=0;j<segs;j++){
        const A=pts[j],B2=pts[(j+1)%pts.length],dx=B2.x-A.x,dy=B2.y-A.y,len=Math.hypot(dx,dy);
        if(len<4)continue;
        const active=activeStep!=null&&(j+1)%pts.length===activeStep,col=active?[255,202,82]:base;
        const mx=(A.x+B2.x)*.5,my=(A.y+B2.y)*.5;
        if(vis(mx,my,len*.55+30)){
          FX.line.add(mx,my,gh(mx,my)+3.2,len,Math.atan2(dy,dx),col[0],col[1],col[2],active?225:(draft?175:105),active?4.4:(draft?3.2:2.4));
          for(let q=0;q<3;q++){
            const f=(t*.32+q/3+j*.11)%1,px3=A.x+dx*f,py3=A.y+dy*f;
            if(vis(px3,py3,20))FX.ring.add(px3,py3,gh(px3,py3)+3.7,active?3.8:2.6,-t*.6,col[0],col[1],col[2],active?205:135);
          }
        }
      }
      for(let j=0;j<pts.length;j++){
        const P=pts[j];if(!vis(P.x,P.y,35))continue;
        const active=j===activeStep,col=active?[255,202,82]:base,pulse=(active?8.5:5.8)+Math.sin(t*4+j)*(active?1.4:.7);
        FX.ring.add(P.x,P.y,gh(P.x,P.y)+4.0,pulse,t*.3,col[0],col[1],col[2],active?245:(draft?210:165));
      }
    };
    if(p3Paths){
      const seen={};
      for(let i=0;i<unitHigh;i++){
        if(!ualive[i]||!usel[i]||ustate[i]!==5)continue;
        const ri=uPatrolRoute[i],R=ri>=0?patrolRoutes[ri]:null;
        if(R&&R.pts&&!seen[ri]){
          seen[ri]=1;p3Route(R.pts,true,false,R.step);
          const row=R.targets&&R.targets[R.step];
          if(row){
            const stride=Math.max(1,Math.ceil(row.length/36));
            for(let k=0;k<row.length;k+=stride){
              const P=row[k];if(vis(P.x,P.y,24))FX.ring.add(P.x,P.y,gh(P.x,P.y)+4.4,3.7,t*.45+k*.07,255,212,96,175);
            }
          }
        } else if(ri<0){
          const dx=upx2[i]-upx1[i],dy=upy2[i]-upy1[i];
          if(Math.hypot(dx,dy)>=10)p3Route([{x:upx1[i],y:upy1[i]},{x:upx2[i],y:upy2[i]}],true,false,null);
        }
      }
      if(typeof patrolDraft!=='undefined'&&patrolDraft)p3Route(patrolDraft.pts,patrolDraft.pts.length>2,true,null);
    }
    const now3=performance.now(),confirm3=typeof orderConfirm!=='undefined'&&orderConfirm&&now3<orderConfirm.until;
    if(typeof orderConfirm!=='undefined'&&orderConfirm&&!confirm3)orderConfirm=null;
    const form3=(typeof orderPreview!=='undefined'&&orderPreview)||(confirm3?orderConfirm:null);
    if(form3&&!(META&&META.settings&&META.settings.formationPreview===false)){
      const members=form3.members.filter(i=>ualive[i]&&usel[i]),fd=FORMS[form3.form]||FORMS[0];
      /* Memoised in input.js: the assignment only changes when the target or

         the group does, not once per frame. */
      const slots=formationPreviewSlots(form3,members,fd.id);
      let cx3=0,cy3=0;for(const i of members){cx3+=ux[i];cy3+=uy[i];}
      if(members.length){
        cx3/=members.length;cy3/=members.length;
        const dx=form3.x-cx3,dy=form3.y-cy3,len=Math.hypot(dx,dy),fade=orderPreview?1:clamp((form3.until-now3)/950,0,1);
        /* noLine: a tap-move confirm whose real route is drawn by orderfx -

           the straight beam would contradict the traced path around water. */
        if(len>3&&!form3.noLine)FX.line.add((cx3+form3.x)*.5,(cy3+form3.y)*.5,gh((cx3+form3.x)*.5,(cy3+form3.y)*.5)+3.5,
          len,Math.atan2(dy,dx),88,224,255,145*fade,3.2);
        FX.ring.add(form3.x,form3.y,gh(form3.x,form3.y)+4.2,9.2,t*.8,95,235,255,230*fade);
        for(let k=0;k<slots.length;k++){
          const P=slots[k],T=TYPES[utype[members[k]]];
          if(vis(P.x,P.y,T.size+20))FX.ring.add(P.x,P.y,gh(P.x,P.y)+4.6,Math.max(4.2,T.size*.62),t*.45+k*.08,105,238,255,205*fade);
        }
      }
    }
    if(typeof moveFxDraw==='function')moveFxDraw(vis,t);
  }
  /* ---- CHARGED ARTILLERY FIRE PLAN -------------------------------------

     Preview the exact six impact footprints and each participating battery's

     reach. During the interruptible charge the same geometry fills and brightens

     instead of replacing the plan with a generic spinner. */
  {
    const A=(aiming===5&&artBarrageAim)?artBarrageAim:artBarrageCharge;
    if(A){
      const pts=A.pattern||artBarragePattern(A.x,A.y);
      const prog=artBarrageCharge?clamp(artBarrageCharge.t/artBarrageCharge.total,0,1):0;
      if(vis(A.x,A.y,ART_BARRAGE.spread+ART_BARRAGE.aoe+40)){
        FX.ring.add(A.x,A.y,gh(A.x,A.y)+4,(ART_BARRAGE.spread+ART_BARRAGE.aoe)/3,
          t*.34,255,166,62,145+prog*80);
        for(let k=0;k<pts.length;k++){
          const P=pts[k];if(!vis(P.x,P.y,ART_BARRAGE.aoe+20))continue;
          FX.ring.add(P.x,P.y,gh(P.x,P.y)+4.5,ART_BARRAGE.aoe/3,
            -t*.65+k*.22,255,210,92,175+prog*65);
          bbAdd.add(sprites.glow,P.x,P.y,gh(P.x,P.y)+8,5+prog*5,0,255,116,38,105+prog*105);
        }
      }
      const src=artBarrageCharge?artBarrageCharge.members.map(m=>m.i):artBarrageSelected();
      for(const i of src){
        if(!ualive[i]||uteam[i]!==0||TYPES[utype[i]].cat!=='art')continue;
        const len=Math.hypot(A.x-ux[i],A.y-uy[i]);
        if(vis(ux[i],uy[i],ART_BARRAGE.range+30)&&aiming===5)
          FX.ring.add(ux[i],uy[i],gh(ux[i],uy[i])+2.8,ART_BARRAGE.range/3,0,255,184,70,28);
        if(vis((ux[i]+A.x)*.5,(uy[i]+A.y)*.5,len*.5+20))
          FX.line.add((ux[i]+A.x)*.5,(uy[i]+A.y)*.5,gh((ux[i]+A.x)*.5,(uy[i]+A.y)*.5)+5,
            len,Math.atan2(A.y-uy[i],A.x-ux[i]),255,184,68,48+prog*105,2.5+prog*2.2);
        if(vis(ux[i],uy[i],40)){
          const S=TYPES[utype[i]].size*(1.05+prog*.32);
          FX.ring.add(ux[i],uy[i],gh(ux[i],uy[i])+4,S,t*(.5+prog),255,197,82,160+prog*85);
          bbAdd.add(sprites.glow,ux[i],uy[i],gh(ux[i],uy[i])+TYPES[utype[i]].size*.7,
            6+prog*12,0,255,145,42,75+prog*130);
        }
      }
    }
  }
  /* ---- DEFENCE COVERAGE -------------------------------------------------

     Opening a defensive structure is the player's explicit request for its

     tactical detail, so show its live range and nearby overlapping fields at

     that moment. Placement does the same before money is committed. Rings use

     the renderer's authored 3x decal scale (hence /3), matching the true sim

     radius instead of the oversized circles used by the old placement HUD. */
  const openDef=openBld>=0&&blds[openBld]&&blds[openBld].alive?blds[openBld]:null;
  const placeDef=placing&&DEF_WEAPON_DATA[placing.type]?placing:null;
  const coverAnchor=placeDef||((openDef&&DEF_WEAPON_DATA[openDef.type])?openDef:null);
  if(coverAnchor){
    const ax=coverAnchor.x,ay=coverAnchor.y;
    for(const B of bldLive){
      if(!B.alive||B.team!==0||B.prog<1||!DEF_WEAPON_DATA[B.type]||!vis(B.x,B.y,620)) continue;
      if(B!==openDef&&dist2(ax,ay,B.x,B.y)>720*720) continue;
      const W=bldWeaponSnapshot(B,B.lvl||1),sel=B===openDef;
      FX.ring.add(B.x,B.y,gh(B.x,B.y)+2.1,W.range/3,t*.08,74,204,255,sel?185:48);
      if(W.minRange) FX.ring.add(B.x,B.y,gh(B.x,B.y)+2.4,W.minRange/3,-t*.12,255,118,76,sel?145:32);
    }
    if(placeDef){
      const ghost={type:placeDef.type,lvl:1,team:0,boost:0,boostM:UPLINK_BOOST};
      const W=bldWeaponSnapshot(ghost,1);
      FX.ring.add(placeDef.x,placeDef.y,gh(placeDef.x,placeDef.y)+2.5,W.range/3,t*.12,90,235,150,205);
      if(W.minRange) FX.ring.add(placeDef.x,placeDef.y,gh(placeDef.x,placeDef.y)+2.8,W.minRange/3,-t*.18,255,118,76,160);
    }
  } else if(openDef&&(openDef.type==='sgen'||openDef.type==='uplink')){
    const S=bldSupportSnapshot(openDef,openDef.lvl||1),col=openDef.type==='sgen'?[88,235,178]:[92,205,255];
    FX.ring.add(openDef.x,openDef.y,gh(openDef.x,openDef.y)+2.2,S.field/3,t*.1,col[0],col[1],col[2],185);
  }
  for(const B of bldLive){
    if(B.alive&&B.type==='techlab'&&B.guardT>0&&vis(B.x,B.y,120)){
      const p=.65+.35*Math.sin(t*7+B.x*.01);
      FX.ring.add(B.x,B.y,gh(B.x,B.y)+2.7,(BT.techlab.size*1.65)/3,-t*.7,95,225,255,130+90*p);
      FX.ring.add(B.x,B.y,gh(B.x,B.y)+3.0,(BT.techlab.size*1.15)/3,t*.9,255,220,105,95+75*p);
    }
  }
  /* The warning corridor ends at the threatened player position and only

     extends a few hundred metres outward. It communicates approach direction

     without drawing a breadcrumb trail back to an unseen enemy base. */
  if(typeof waveThreat!=='undefined'&&waveThreat&&stats.t<=waveThreat.expires){
    const W=waveThreat,ang=Math.atan2(W.dy,W.dx),px=-W.dy,py=W.dx,p=.65+.35*Math.sin(t*5.5);
    FX.ring.add(W.x,W.y,gh(W.x,W.y)+2.7,27+3*p,-t*.35,255,174,70,155+70*p);
    for(const side of [-1,1]){
      const mx=W.x+W.dx*235+px*side*42,my=W.y+W.dy*235+py*side*42;
      FX.line.add(mx,my,gh(mx,my)+2.5,350,ang,255,154,58,62+40*p,2.0);
    }
    for(let k=0;k<4;k++){
      const d=95+k*82,x=W.x+W.dx*d,y=W.y+W.dy*d;
      FX.line.add(x,y,gh(x,y)+3,48,ang,255,202,92,125+60*p,3.0);
    }
  }
  /* ---- BUILD TERRITORY -------------------------------------------------

     Drawn straight from the rasterised zone grid, so what you see is exactly

     what placementValid() enforces. A cell whose neighbour is outside the zone

     contributes a border segment; the result is a hard rectilinear frontier

     that grows in squares as you plant Uplinks, instead of a smear of circles

     that never matched the rule.                                          */
  /* The placement UI already draws the exact local grid, invalid footprint

     cells, alignment guides and builder ranges in hud.js. Scanning the full

     raster territory here as well emitted thousands of plates/lines per frame

     and made the battle appear frozen until the player hit X. The expensive

     frontier is now only a short change pulse; placement keeps its precise

     local feedback below. */
  if(bzShow>0&&!placing){
    const glow=bzShow;
    /* Mobile builder zones are drawn directly rather than rasterised into the

       static grid: they move every frame, and re-stamping a 37k-cell grid at

       frame rate to chase two units would be absurd. */
    forBuilders(0,(bx,by,r)=>{
      for(const [ex,ey,rot2] of [[0,-r,0],[0,r,0],[-r,0,Math.PI/2],[r,0,Math.PI/2]])
        FX.line.add(bx+ex,by+ey,gh(bx+ex,by+ey)+2.4,r*2,rot2, 130,235,190, 190*glow, 3.0);
      FX.ring.add(bx,by,gh(bx,by)+1.8, 22, t*0.9, 130,235,190, 150*glow);
    });
    const cx0=Math.max(0,bzG(x0)-1), cx1=Math.min(BZN-1,bzG(x1)+1);
    const cy0=Math.max(0,bzG(y0)-1), cy1=Math.min(BZN-1,bzG(y1)+1);
    const pulse=0.55+Math.sin(t*2.4)*0.2;
    let drawn=0;
    for(let gy=cy0;gy<=cy1&&drawn<9000;gy++) for(let gx=cx0;gx<=cx1;gx++){
      const st=bzAt(gx,gy);
      if(st===BZ_OUT) continue;
      const wx=bzW(gx), wy=bzW(gy), H=gh(wx,wy)+1.5;
      /* Blocked cells are called out individually in red — water, cliffs, and

         ground already occupied by a structure, ruin or resource node. Seeing

         WHY a spot is unavailable before you commit is the whole point;

         previously the only feedback was a rejection message after the fact. */
      const navalCell=false;
      if(st===BZ_BAD&&!navalCell){
        FX.plate.add(wx,wy,H+0.3,BZ*0.80,0, 255,70,60, 76*glow);
        // a diagonal slash reads as "occupied" at a glance, even in a solid block
        FX.line.add(wx,wy,H+0.6,BZ*1.15,Math.PI*0.25, 255,120,100, 150*glow, 2.2);
      } else if(((gx+gy)&1)===0){
        FX.plate.add(wx,wy,navalCell?1.0:H,BZ*0.62,0, navalCell?70:95,navalCell?230:205,255, (navalCell?48:30)*glow);
      }
      // border: a segment for every edge that leaves the territory entirely
      if(!bzIn(gx-1,gy)){ bzEdge(wx-BZ*0.5,wy,H+0.5,Math.PI/2,glow*pulse); drawn++; }
      if(!bzIn(gx+1,gy)){ bzEdge(wx+BZ*0.5,wy,H+0.5,Math.PI/2,glow*pulse); drawn++; }
      if(!bzIn(gx,gy-1)){ bzEdge(wx,wy-BZ*0.5,H+0.5,0,glow*pulse); drawn++; }
      if(!bzIn(gx,gy+1)){ bzEdge(wx,wy+BZ*0.5,H+0.5,0,glow*pulse); drawn++; }
    }
  }
  if(placing){
    const T=BT[placing.type];
    const ok=placementValid(), f=bldFoot(placing.type), rt=placing.rot||0;
    const H=T.placement==='water'?0:gh(placing.x,placing.y);
    const col=ok?[90,235,150]:[255,80,70];
    FX.plate.add(placing.x,placing.y,H+1.6,1,rt,col[0],col[1],col[2],255);
    const c2=Math.cos(rt), s2=Math.sin(rt);
    // footprint outline: four hairlines plus a facing tick down the front
    const edge=(ex,ey,len,r2)=>FX.line.add(placing.x+ex*c2-ey*s2, placing.y+ex*s2+ey*c2,
                                           H+2.2, len, rt+r2, col[0],col[1],col[2],255, 2.2);
    edge(0,-f[1]/2,f[0],0); edge(0,f[1]/2,f[0],0);
    edge(-f[0]/2,0,f[1],Math.PI/2); edge(f[0]/2,0,f[1],Math.PI/2);
    edge(f[0]*0.34,0,f[0]*0.3,0);
    /* The ghost is a promise about what is going to be there. Showing a Nova

       silo to a Brood player breaks that promise for the whole placement. */
    const M=(typeof bldMeshFor==='function'?bldMeshFor({type:placing.type,team:0}):null)||BLD_MESH[placing.type];
    if(M){ M.base.add(placing.x,placing.y,H,1,rt,col[0],col[1],col[2],200); M.base.flush(gl); }
  }
  /* Pull flat decals toward the camera so 24-bit depth does not stitch them

     into the terrain as cyan scanlines / broken C-rings. Depth TEST off as

     well: a ring of radius 50 sits at one world Y and still loses to kerbs

     and scar lips a few units taller than the node centre. */
  gl.disable(gl.DEPTH_TEST);
  gl.enable(gl.POLYGON_OFFSET_FILL);
  gl.polygonOffset(-8,-32);
  FX.ring.flush(gl); FX.plate.flush(gl); FX.line.flush(gl);
  gl.disable(gl.POLYGON_OFFSET_FILL);
  gl.enable(gl.DEPTH_TEST);
  gl.enable(gl.CULL_FACE);
  gl.depthMask(true);
  gl.disable(gl.BLEND);


  // ---------------- water ----------------
  /* Bloom is extracted first so the ocean is not a bright-pass source.

     Depth stays the opaque scene, so hulls still occlude the sheet. */
  if(typeof mfGfxScissor==='function') mfGfxScissor(false);
  if(aoActive&&typeof aoExtractBloom==='function') aoExtractBloom();
  if(waterIdxCount){
    if((tick&3)===0) animateWater(t);
    queueWaterFx();
    gl.enable(gl.BLEND);
    gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
    gl.depthMask(false);
    gl.disable(gl.CULL_FACE);
    drawWater();
    if(FX.wake||FX.ripple){
      gl.useProgram(progG);
      gl.uniformMatrix4fv(UG.uVP,false,matVP);
      gl.blendFunc(gl.SRC_ALPHA,gl.ONE);
      gl.enable(gl.POLYGON_OFFSET_FILL);
      gl.polygonOffset(-8,-32);
      if(FX.wake) FX.wake.flush(gl);
      if(FX.ripple) FX.ripple.flush(gl);
      gl.disable(gl.POLYGON_OFFSET_FILL);
    }
    gl.enable(gl.CULL_FACE);
    gl.depthMask(true);
    gl.disable(gl.BLEND);
  }

  // ================= ADDITIVE EFFECTS =================
  gl.useProgram(progG);
  gl.uniformMatrix4fv(UG.uVP,false,matVP);
  gl.enable(gl.BLEND);
  gl.blendFunc(gl.SRC_ALPHA,gl.ONE);
  gl.depthMask(false);
  gl.disable(gl.CULL_FACE);
  queueBattlefieldEdgeGrid(t,vis);
  /* Mosswatch arrivals are tears between planes, not ordinary spawn flashes.

     Keep a bounded billboard/beam scar alive long enough for a player who taps

     the warning to actually see it. Fog still owns disclosure: a wound beyond

     allied vision cannot leak the enemy's position. */
  if(typeof storyCampaignRuntime!=='undefined'&&storyCampaignRuntime&&storyCampaignRuntime.rifts){
    for(const Rf of storyCampaignRuntime.rifts){
      const age=Math.max(0,(stats.t||0)-(Rf.t||0));
      if(age>42||!vis(Rf.x,Rf.y,170)||!fogPointVisible(Rf.x,Rf.y))continue;
      const life=clamp(1-age/42,0,1),pulse=.72+.28*Math.sin(t*7+Rf.x*.013),H=gh(Rf.x,Rf.y);
      FX.ring.add(Rf.x,Rf.y,H+2,46+Math.sin(t*3)*8,t*.32,188,72,255,135*life);
      FX.ring.add(Rf.x,Rf.y,H+3,72+age*1.4,-t*.21,255,54,105,76*life);
      bbAdd.add(sprites.glow,Rf.x,Rf.y,H+52,94*pulse,0,168,54,255,92*life);
      bbAdd.add(sprites.glow,Rf.x,Rf.y,H+68,42*pulse,0,255,78,134,155*life);
      for(let q=0;q<3;q++){
        const sway=Math.sin(t*(4.8+q*.7)+q*2.1)*13,off=(q-1)*16;
        addBeam3D(FX.beam,Rf.x+off,H+4,Rf.y,Rf.x+sway+off*.35,H+125+q*22,Rf.y+Math.cos(t*3+q)*9,
          5.5-q*.8,q===1?255:176,q===1?82:60,255,life*(q===1?215:118));
      }
      if(age<8)bbAdd.add(sprites.warn,Rf.x,Rf.y,H+150,25+pulse*6,-t*.45,255,104,182,225*life);
    }
  }
  /* At the strategic overview, thousands of individually correct glows placed

     on regimented formation rows merge into solid stripes. Sample the effects

     there; the full billboard stack returns automatically as the player zooms

     to tactical range. */
  const overviewVfx=orthoSpan>(typeof mfLodSpan==='function'?mfLodSpan(2400):2400);

  /* Pickup identity is carried above the physical pod, so a Mass Cache, scan

     beacon and NOVA code cylinder do not become the same gold box at command

     zoom. One marker plus a bounded number of rarity pips keeps this readable

     without adding meshes or draw calls per pickup. */
  for(const Cc of crates){
    if(Cc.alt>0||!vis(Cc.x,Cc.y,80)||(!fogPointVisible(Cc.x,Cc.y)&&!Cc.seen)) continue;
    const k=Cc.kind||CRATE_KINDS[0],cc=k.col||[255,225,140],H=gh(Cc.x,Cc.y),bob=Math.sin(t*2.4+Cc.x)*1.8;
    const mark=sprites[k.spr]||sprites.crate;
    bbAdd.add(sprites.glow,Cc.x,Cc.y,H+18+bob,58+(k.rarity||0)*7,0,cc[0],cc[1],cc[2],78);
    bbAdd.add(mark,Cc.x,Cc.y,H+35+bob,17+(k.rarity||0)*1.5,-t*.65,cc[0],cc[1],cc[2],235);
    FX.ring.add(Cc.x,Cc.y,H+2,27+(k.rarity||0)*3,t*.55,cc[0],cc[1],cc[2],135);
    if(Cc.site) FX.ring.add(Cc.x,Cc.y,H+2,42+Math.sin(t*2.2)*4,-t*.28,105,235,170,105);
    for(let q=0;q<Math.min(4,k.rarity||0);q++){
      const a=t*1.1+q*TAU/Math.max(1,k.rarity);
      bbAdd.add(sprites.glow,Cc.x+Math.cos(a)*21,Cc.y+Math.sin(a)*21,H+13,3.4,0,cc[0],cc[1],cc[2],220);
    }
  }

  /* Fault shelves and impact cells are world-space telegraphs.  Dormant faults

     are intentionally subtle route-planning information; once armed they gain

     two independently pulsing rings and a warning glyph that stays legible at

     mobile command zoom. Hidden terrain never leaks a fault through fog. */
  if(typeof HAZ!=='undefined'){
    for(const F of HAZ.faults||[]){
      if(!vis(F.x,F.y,F.r+30)||!fogPointVisible(F.x,F.y)||F.state===2) continue;
      const armed=F.state===1,H=gh(F.x,F.y),p=.5+.5*Math.sin(t*(armed?7:2)+F.x*.01);
      /* FX.ring's authored mesh is roughly three world radii wide; feed it a

         third of the simulation radius so the art matches the actual danger

         footprint instead of warning about safe ground. */
      FX.ring.add(F.x,F.y,H+2,F.r*(armed?.38:.33),t*.12,armed?255:188,armed?102:154,armed?62:92,armed?120+90*p:42);
      if(armed){
        FX.ring.add(F.x,F.y,H+3,F.r*(.25+p*.08),-t*.7,255,194,92,125);
        bbAdd.add(sprites.warn,F.x,F.y,H+36,22+p*5,t*.45,255,194,92,230);
      }
    }
    if(HAZ.warn>0) for(const C of HAZ.cells||[]){
      if(!vis(C[0],C[1],C[2]+40)||!fogPointVisible(C[0],C[1])) continue;
      const H=gh(C[0],C[1]),q=.5+.5*Math.sin(t*9);
      FX.ring.add(C[0],C[1],H+4,C[2]*(.29+q*.08),t*.8,C[3][0],C[3][1],C[3][2],150);
      bbAdd.add(sprites.warn,C[0],C[1],H+42,24+q*7,-t*.5,C[3][0],C[3][1],C[3][2],245);
    }
  }

  // Projectiles are directed shots: a velocity-aligned tracer from behind the
  // round to its head, plus a small spark at the tip. Rings, faction orbs and
  // GPU ember sprays around the body made volleys read as orbiting sparks.
  let projectileDrawn=0;
  const projectileLimit=overviewVfx?520:1800;
  for(let i=0;i<pHigh;i++){
    if(!palive[i]) continue;
    /* Strategic zoom may sample common rifle pellets, but artillery, rockets,

       missiles, Commander shells and high-damage rounds are tactical events

       and must never disappear. The former 1-in-16 blanket sample combined

       with a 14 fps phone to make whole battles look completely inert. */
    const essential=pBarrage[i]||pCannon[i]||pdmg[i]>=28||ptype[i]===2||ptype[i]===3||ptype[i]===4||ptype[i]===7||ptype[i]===9;
    if(overviewVfx&&!essential&&(i&7)!==0) continue;
    if(projectileDrawn++>=projectileLimit&&!essential) continue;
    const X=px[i], Y=py[i];
    if(!vis(X,Y,60)) continue;
    if(!fogFxVisible(X,Y,pteam[i])) continue;
    const fac=typeof mfCombatFactionTeam==='function'?mfCombatFactionTeam(pteam[i]):(pteam[i]===2?'horde':pteam[i]===0?'nova':'legion');
    const c=TEAMB[pteam[i]], wk=pwk[i]||'p', bio=!!pBio[i], nova=fac==='nova'&&!pCannon[i]&&!pBarrage[i];
    const fp=typeof mfFactionFxPalette==='function'?mfFactionFxPalette(pteam[i]):{a:c,b:[255,250,240]};
    const ty=ptype[i], power=clamp(Math.sqrt(Math.max(1,pdmg[i]))/6,.7,2.45);
    const H=gh(X,Y)+ (ty===2? 16+Math.sin(pt[i]*Math.PI)*(pArc[i]||70) : ty===7? 20 : 12);
    const yaw=Math.atan2(pvy[i],pvx[i]);
    const vl=Math.hypot(pvx[i],pvy[i])||1, nx=pvx[i]/vl, ny=pvy[i]/vl;
    const age=Math.max(0,(pmax[i]||plife[i])-plife[i]);
    const vq=typeof mfVfxQ==='function'?mfVfxQ():1;
    const streakMul=vq>=1.2?1.78:vq>=0.95?1.48:vq>=0.65?1.16:0.86;
    const streak=clamp(vl*(wk==='g'?0.28:ty===1?0.23:0.18)*streakMul, 48*streakMul, (wk==='g'?198:ty===1?162:136)*streakMul);
    const bx=X-nx*streak, by=Y-ny*streak;
    const ballistic=ty===2||!!pBarrage[i];
    const young=ballistic?pt[i]<0.05:age<0.12;
    if(young){
      const ox=ballistic?psx[i]:X-pvx[i]*age, oy=ballistic?psy[i]:Y-pvy[i]*age;
      const mh=fxWeaponH(ox,oy,true);
      addMuzzleFlash(ox,oy,mh,nx,ny,(pCannon[i]||pBarrage[i]||ty===2||ty===9)?8.2:5.0*power,
        nova?110:255, nova?230:185, nova?255:80, 230*(ballistic?1-pt[i]/0.05:1-age/0.12));
    }
    if(pBarrage[i]){
      /* A slow, dark shell remains readable against its own hot fuse. The

         streak follows the TANGENT of the ballistic arc so the shot does not

         flatten into a map-space spark while the body is hundreds of metres up. */
      bbAlpha.add(sprites.debris||sprites.glow,X,Y,H,10.5*power,yaw+Math.PI/2,72,68,64,255);
      bbAdd.add(sprites.glow,X,Y,H,7.5*power,0,255,155,54,200);
      const q0=Math.max(0,pt[i]-.022),tx0=psx[i]+(pex[i]-psx[i])*q0,ty0=psy[i]+(pey[i]-psy[i])*q0;
      const h0=gh(tx0,ty0)+16+Math.sin(q0*Math.PI)*(pArc[i]||70);
      addBeam3D(FX.beam,tx0,h0,ty0,X,H,Y,1.55*power,255,132,42,210);
    } else if(bio){
      const pulse=.84+Math.sin(t*15+i*1.7)*.16;
      bbAdd.add(sprites.glow,X,Y,H,8.4*power*pulse,0,205,255,118,250);
      bbAdd.add(sprites.glow,X,Y,H,16*power,0,164,76,232,110);
      addBeam3D(FX.beam,bx,H,by,X,H,Y,.92*power,145,220,80,210);
    } else if(wk==='g'){
      /* Gauss is a hard white/cyan needle: origin behind the round, destination

         at the tip. No corona ring — that read as a spark circling the shot. */
      addBeam3D(FX.beam,bx,H,by,X,H,Y,1.18*power,fp.a[0],fp.a[1],fp.a[2],255);
      bbAdd.add(sprites.glow,X,Y,H,5.8*power,0,245,252,255,250);
    } else if(wk==='s'){
      const pulse=.86+Math.sin(t*18+i)*.14;
      bbAdd.add(sprites.glow,X,Y,H,8.4*power*pulse,0,225,245,255,240);
      addBeam3D(FX.beam,bx,H,by,X,H,Y,.92*power,fp.a[0],fp.a[1],fp.a[2],220);
    } else if(wk==='f'){
      bbAdd.add(sprites.flame||sprites.fireball||sprites.glow,X,Y,H,8*power,yaw+Math.PI/2,255,235,175,245);
      addBeam3D(FX.beam,bx,H,by,X,H,Y,1.22*power,255,105,24,210);
    } else if(wk==='i'||ty===6){
      /* Plasma orb: a slow glowing ball. A directed trail names the axis

         without turning the orb into a laser. */
      bbAdd.add(sprites.glow,X,Y,H,(9+Math.sin(t*13+i)*1.2)*power,0,235,252,255,255);
      bbAdd.add(sprites.glow,X,Y,H,(20+Math.sin(t*9+i)*2)*power,0,80,205,255,165);
      addBeam3D(FX.beam,bx,H,by,X,H,Y,1.22*power,fp.a[0],fp.a[1],fp.a[2],205);
    } else if(ty===4){
      bbAlpha.add(sprites.debris||sprites.glow,X,Y,H,7.5*power,yaw+Math.PI/2,nova?155:205,nova?225:210,nova?255:215,245);
      bbAdd.add(sprites.glow,bx,by,H,9*power,0,nova?100:255,nova?225:130,nova?255:45,180);
      addBeam3D(FX.beam,bx-nx*6,H,by-ny*6,X,H,Y,1.32*power,fp.a[0],fp.a[1],fp.a[2],200);
    } else if(ty===7){
      bbAlpha.add(sprites.debris||sprites.glow,X,Y,H,7.4*power,yaw+Math.PI/2,nova?160:220,nova?230:225,255,245);
      const ex=X-nx*7, ey=Y-ny*7;
      bbAdd.add(sprites.glow,ex,ey,H,(10+Math.sin(t*22+i)*2)*power,0,nova?105:255,nova?225:180,nova?255:90,200);
      addBeam3D(FX.beam,ex-nx*8,H,ey-ny*8,X,H,Y,1.38*power,fp.a[0],fp.a[1],fp.a[2],220);
    } else if(ty===8){
      addBeam3D(FX.beam,bx,H+14,by,X,H+14,Y,.88*power,255,220,140,250);
      bbAdd.add(sprites.glow,X,Y,H+14,5.2*power,0,255,235,190,245);
    } else if(ty===9){
      bbAlpha.add(sprites.debris||sprites.glow,X,Y,H+26,8.2*power,yaw+Math.PI/2,nova?145:205,nova?218:198,nova?255:188,245);
      addBeam3D(FX.beam,bx,H+24,by,X,H+26,Y,1.42*power,fp.a[0],fp.a[1],fp.a[2],200);
    } else if(ty===2){
      bbAlpha.add(sprites.debris||sprites.glow,X,Y,H,6.5*power,yaw+Math.PI/2,nova?110:95,nova?145:90,nova?175:86,255);
      bbAdd.add(sprites.glow,X,Y,H,5.2*power,0,nova?100:255,nova?220:170,nova?255:75,190);
      const q0=Math.max(0,pt[i]-.03),tx0=psx[i]+(pex[i]-psx[i])*q0,ty0=psy[i]+(pey[i]-psy[i])*q0;
      const h0=gh(tx0,ty0)+16+Math.sin(q0*Math.PI)*(pArc[i]||70);
      addBeam3D(FX.beam,tx0,h0,ty0,X,H,Y,1.28*power,255,150,60,205);
    } else if(ty===3||pCannon[i]){
      bbAlpha.add(sprites.debris||sprites.glow,X,Y,H,9.5*power,yaw+Math.PI/2,86,82,78,255);
      bbAdd.add(sprites.glow,X,Y,H,8*power,0,255,165,62,210);
      addBeam3D(FX.beam,bx,H,by,X,H,Y,1.55*power,255,135,45,225);
    } else {
      const cr=fp.a[0], cg=fp.a[1], cb=fp.a[2];
      addBeam3D(FX.beam,bx,H,by,X,H,Y,(ty===1?1.58:1.18)*power,cr,cg,cb,ty===1?255:245);
      bbAdd.add(sprites.glow,X,Y,H,(ty===1?6.8:5.4)*power,0,255,252,240,255);
    }
  }
  // Beams connect shooter to target. addBeam3D already supplies sheath + core,
  // so a second white pass (and helix on every style) turned the link into fog.
  let beamDrawn=0, fancyBeams=0;
  const beamLimit=overviewVfx?52:180;
  /* Hidden renderer lab for development captures and device QA. It never runs

     in ordinary play; `?beamshow=1` adds one stable example of each language

     over the live battlefield so camera rotation and mobile drivers can be

     checked without waiting for a 180 ms firing window. */
  let beamQueue=beams;
  if(demoMode&&location.search.indexOf('beamshow=1')>=0){
    const cx=cam.x, cy=cam.y, now=t%1;
    beamQueue=beams.concat([
      {x0:cx-430,y0:cy-250,x1:cx+300,y1:cy-250,w:2.8,r:255,g:80,b:105,t:0,max:1,seed:1,style:'laser'},
      {x0:cx-430,y0:cy-145,x1:cx+300,y1:cy-145,w:3.2,r:115,g:215,b:255,t:0,max:1,seed:2,style:'sniper'},
      {x0:cx-430,y0:cy-35,x1:cx+300,y1:cy-35,w:4.4,r:255,g:125,b:45,t:0,max:1,seed:3,style:'thermal'},
      {x0:cx-430,y0:cy+85,x1:cx+300,y1:cy+85,w:6.2,r:90,g:195,b:255,t:0,max:1,seed:4,style:'lance'},
      {x0:cx-430,y0:cy+205,x1:cx+300,y1:cy+205,w:3.5,r:105,g:255,b:165,t:0,max:1,seed:5+now,style:'repair'}
    ]);
  }
  for(const bm of beamQueue){
    const lf=1-bm.t/bm.max;
    const bmx=(bm.x0+bm.x1)/2,bmy=(bm.y0+bm.y1)/2;
    if(!vis(bmx,bmy,200)||!fogFxVisible(bm.x0,bm.y0,bm.team)||!fogFxVisible(bm.x1,bm.y1,bm.team)) continue;
    if(++beamDrawn>beamLimit) break;
    const sty=bm.style||'laser';
    if(sty==='orbital'||sty==='orbital_up'){
      const gx=sty==='orbital'?bm.x1:bm.x0, gy=sty==='orbital'?bm.y1:bm.y0;
      const h=gh(gx,gy)+8, sway=Math.sin(t*17+bm.seed)*5;
      addBeam3D(FX.beam,gx+sway,h+720,gy-sway*0.4,gx,h,gy,bm.w*2.4,bm.r,bm.g,bm.b,lf*90);
      addBeam3D(FX.beam,gx+sway*.3,h+720,gy,gx,h,gy,bm.w*.7,255,252,226,lf*245);
      addBeamBurst(gx,gy,h+8,bm.w*4.2,bm.r,bm.g,bm.b,lf*210);
      continue;
    }
    const h0=fxWeaponH(bm.x0,bm.y0,true), h1=fxWeaponH(bm.x1,bm.y1,false);
    const fpB=typeof mfFactionFxPalette==='function'?mfFactionFxPalette(bm.team):null;
    let br=bm.r, bgc=bm.g, bbc=bm.b;
    if(fpB&&(sty==='laser'||sty==='tracer'||sty==='sniper'||sty==='lance')){
      br=(br*0.42+fpB.a[0]*0.58)|0; bgc=(bgc*0.42+fpB.a[1]*0.58)|0; bbc=(bbc*0.42+fpB.a[2]*0.58)|0;
    }
    if(sty==='arc'){
      const dx=bm.x1-bm.x0, dy=bm.y1-bm.y0, dl=Math.hypot(dx,dy)||1;
      const ox=-dy/dl, oy=dx/dl, seg=5;
      let ax=bm.x0, ay=bm.y0, ah=h0;
      for(let k=1;k<=seg;k++){
        const q=k/seg, edge=(k===seg?0:Math.sin(q*Math.PI));
        const jitter=Math.sin(bm.seed*7+k*12.71+t*31)*bm.w*2.2*edge;
        const ex=bm.x0+dx*q+ox*jitter, ey=bm.y0+dy*q+oy*jitter;
        const eh=h0+(h1-h0)*q+Math.sin(q*Math.PI)*4;
        addBeam3D(FX.beam,ax,ah,ay,ex,eh,ey,bm.w*1.35,br,bgc,bbc,lf*220);
        ax=ex; ay=ey; ah=eh;
      }
      if(bm.t<0.11) addMuzzleFlash(bm.x0,bm.y0,h0,dx,dy,bm.w*2.4,br,bgc,bbc,(1-bm.t/0.11)*210);
      addBeamBurst(bm.x1,bm.y1,h1,bm.w*3.2,155,225,255,lf*220);
      continue;
    }
    const pulse=sty==='thermal'?(0.78+Math.sin(t*24+bm.seed)*0.22):1;
    const outer=sty==='lance'?2.85:sty==='thermal'?2.35:sty==='repair'?1.55:sty==='sniper'?1.48:sty==='tracer'?1.42:1.58;
    addBeam3D(FX.beam,bm.x0,h0,bm.y0,bm.x1,h1,bm.y1,bm.w*outer*pulse,br,bgc,bbc,lf*(sty==='tracer'?250:245));
    if(!overviewVfx&&perfScale>.44&&fancyBeams<8&&sty==='lance'){
      fancyBeams++;
      addBeamHelix(bm,h0,h1,bm.w*0.9,2.4,150,225,255,lf*130,t,false);
    }
    if(sty==='thermal'&&perfScale>.4){
      for(let k=1;k<3;k++){
        const q=(k/3+t*1.8+bm.seed)%1;
        bbAdd.add(sprites.glow,bm.x0+(bm.x1-bm.x0)*q,bm.y0+(bm.y1-bm.y0)*q,
          h0+(h1-h0)*q,bm.w*2.0,0,255,140,50,lf*85);
      }
    } else if(sty==='repair'&&perfScale>.4){
      for(let k=0;k<2;k++){
        const q=(k/2+t*2.2+bm.seed)%1;
        bbAdd.add(sprites.glow,bm.x0+(bm.x1-bm.x0)*q,bm.y0+(bm.y1-bm.y0)*q,
          h0+(h1-h0)*q,bm.w*1.7,0,145,255,185,lf*140);
      }
    }
    if(bm.t<0.11) addMuzzleFlash(bm.x0,bm.y0,h0,bm.x1-bm.x0,bm.y1-bm.y0,
      bm.w*(sty==='lance'?3.6:2.2),br,bgc,bbc,(1-bm.t/0.11)*225);
    const hitSize=bm.w*(sty==='lance'?4.2:sty==='thermal'?3.2:sty==='sniper'?2.8:sty==='repair'?2.2:2.0);
    if(sty!=='tracer') addBeamBurst(bm.x1,bm.y1,h1,hitSize,br,bgc,bbc,lf*220);
    else bbAdd.add(sprites.glow,bm.x1,bm.y1,h1,hitSize*1.15,0,br,bgc,bbc,lf*190);
  }
  /* ---- particles as sprite billboards --------------------------------

     These use the original procedural sprite art — soft smoke, layered

     fireballs, shock rings — which reads far better than any polygon shell,

     and costs one quad each instead of a hundred triangles. They still sit in

     the depth buffer, so a plume behind a ridge is occluded by the ridge. */
  const sGlowB=sprites.glow, sSmokeB=sprites.smoke||sprites.glow, sRingB=sprites.ring;
  const sFireB=sprites.flame||sprites.fireball||sprites.glow;
  /* Barrage smoke owns a true height sample, unlike the generic ground-space

     particles. Drawing it here lets the wake climb out of frame with the

     shell, then visibly descend/re-enter on the final third of flight. */
  for(let s=0;s<artShellSmoke.length;s++){
    const S=artShellSmoke[s];
    if(overviewVfx&&(s&1))continue;
    if(!vis(S.x,S.y,100)||!fogFxVisible(S.x,S.y,S.team))continue;
    const lf=S.life/S.max,age=1-lf,sz=S.size*(1.15+age*2.25),H=gh(S.x,S.y)+S.lift;
    const aSmoke=Math.min(205,175*lf);
    bbAlpha.add(sSmokeB,S.x,S.y,H,sz,S.rot+t*.16,74+age*16,70+age*14,67+age*12,aSmoke);
    if((typeof mfVfxQ==='function'?mfVfxQ():1)>=0.55)
      bbAlpha.add(sSmokeB,S.x+Math.sin(S.rot)*sz*.22,S.y+Math.cos(S.rot)*sz*.18,
        H+sz*.16,sz*.78,S.rot-t*.12,82+age*12,76+age*10,70+age*8,aSmoke*.7);
    if(S.hot&&age<.42)bbAdd.add(sGlowB,S.x,S.y,H,sz*.58,0,255,118,34,105*(1-age/.42));
  }
  let combatParticleDrawn=0;
  /* HIGH walks the whole ring. MEDIUM/LOW walk recent slots from fHead —

     dead-slot scan of 9000 was the leftover tax. Combat flashes are young

     and sit near the head; magnitudes are unchanged. */
  const gfxQ=typeof mfGfxKey==='function'?mfGfxKey():'high';
  const liveN=(typeof fCount==='number')?fCount:MAXPART;
  const midWalk=liveN>0&&(gfxQ==='medium'||gfxQ==='low');
  const partLook=liveN<=0?0:midWalk?Math.min(MAXPART,Math.max(liveN*(gfxQ==='low'?3:2),gfxQ==='low'?360:720)):MAXPART;
  for(let k=0;k<partLook;k++){
    const i=midWalk?((fHead-1-k+MAXPART)%MAXPART):k;
    if(flife[i]<=0) continue;
    /* Preserve combat punctuation at every zoom. Only long-lived atmosphere

       and smoke are sampled; flashes, rings, flames, fireballs and fragments

       remain visible even when the adaptive scaler has dropped below 30%. */
    const combatFx=ftype[i]===0||ftype[i]===2||ftype[i]===3||ftype[i]===4||ftype[i]===5||ftype[i]===6||ftype[i]===7;
    const movementFx=ftype[i]===10;
    if(overviewVfx&&!combatFx&&!movementFx&&((i+tick)&7)!==0) continue;
    if(overviewVfx&&movementFx&&((i+tick)&3)!==0) continue;
    if(combatFx)combatParticleDrawn++;
    const X=fx[i], Y=fy[i];
    if(!vis(X,Y,90)) continue;
    if(!fogPointVisible(X,Y)) continue;
    const lf=flife[i]/fmax[i], ty=ftype[i], H=gh(X,Y);
    /* Type 0 flashes are 2D (no height). Small ones are muzzle/hit sparks —

       lift to turret/hull. Large ones are crater detonations and stay on dirt. */
    const Hfx=ty===0&&fsize[i]<22?fxWeaponH(X,Y,fsize[i]<11):H;
    /* Skip additive flashes/flames on the hull. Dust (type 1/10) still draws. */
    if(!matchLive&&typeof carrier!=='undefined'&&carrier.active&&carrier.phase<2
       &&(ty===0||ty===2||ty===4)){
      const cdx=X-carrier.x,cdy=Y-carrier.y;
      if(cdx*cdx+cdy*cdy<100*100) continue;
    }
    if(ty===1){                               // drifting smoke — stacked lobes, not a flat disc
      const gsz=fsize[i]*(1.28+(1-lf)*1.85);
      const nearDrop=!matchLive&&typeof carrier!=='undefined'&&carrier.active&&carrier.phase<2
        &&(X-carrier.x)*(X-carrier.x)+(Y-carrier.y)*(Y-carrier.y)<100*100;
      const vq=typeof mfVfxQ==='function'?mfVfxQ():1;
      const lift=nearDrop?1.6:11+(1-lf)*34;
      const a0=nearDrop?120*lf:Math.min(215, (vq>=0.65?185:150)*lf);
      bbAlpha.add(sSmokeB,X,Y,H+lift,gsz,i*0.4+t*0.22, fcr[i],fcg[i],fcb[i], a0);
      if(!nearDrop&&vq>=0.45){
        bbAlpha.add(sSmokeB,X+Math.sin(i*2.1)*gsz*.30,Y+Math.cos(i*1.7)*gsz*.26,
          H+lift+gsz*.20,gsz*.84,-i*.28-t*.16,fcr[i]+10,fcg[i]+8,fcb[i]+6, a0*.74);
      }
      if(!nearDrop&&vq>=0.95){
        bbAlpha.add(sSmokeB,X+Math.cos(i*1.4)*gsz*.24,Y+Math.sin(i*2.3)*gsz*.22,
          H+lift+gsz*.42,gsz*.64,i*.51+t*.12,fcr[i]+6,fcg[i]+5,fcb[i]+4, a0*.5);
      }
    } else if(ty===10){                       // movement dust, kept near the tracks / boots
      const age=1-lf,gsz=fsize[i]*(.95+age*1.45);
      bbAlpha.add(sSmokeB,X,Y,H+1.4+age*4,gsz,i*.53+t*.18,fcr[i],fcg[i],fcb[i],140*lf);
    } else if(ty===8){                        // multi-lobed rising smoke plume
      const age=1-lf, gsz=fsize[i]*(1.18+age*2.05);
      const vq=typeof mfVfxQ==='function'?mfVfxQ():1;
      bbAlpha.add(sSmokeB,X,Y,H+10+age*38,gsz,i*0.4+t*0.25,fcr[i],fcg[i],fcb[i],Math.min(210,165*lf));
      if(vq>0.45) bbAlpha.add(sSmokeB,X+Math.sin(i*2.7)*gsz*.26,Y+Math.cos(i*1.9)*gsz*.22,
        H+20+age*52,gsz*.78,-i*.3-t*.18,fcr[i]+8,fcg[i]+7,fcb[i]+6,125*lf);
      if(vq>=0.95) bbAlpha.add(sSmokeB,X+Math.cos(i*1.8)*gsz*.20,Y+Math.sin(i*2.4)*gsz*.18,
        H+28+age*62,gsz*.58,i*.22+t*.14,fcr[i]+4,fcg[i]+3,fcb[i]+3,95*lf);
    } else if(ty===3){                        // shock ring — on the crater, not a spinning halo
      bbAdd.add(sRingB,X,Y,H+1.15,Math.min(18,fsize[i]*(0.55+(1-lf)*0.5)),0, fcr[i],fcg[i],fcb[i], 200*lf);
    } else if(ty===2||ty===5){                // hot sparks and fragments
      /* The debris atlas cell is a camera-facing quad. At phone size its soft

         alpha collapses into a bright white square—the exact blocks reported

         around explosions. A tiny lit shard has a real silhouette at every

         angle; the radial core supplies heat without exposing its rectangle.

         Hop used to launch sparks 20+ units off the crater; keep them in the

         bowl so a volley does not read as an orbiting swarm. */
      const age=1-lf,hop=(1.2+fsize[i]*.22)*lf*age,sz=Math.max(0.85,fsize[i]*(ty===5?.36:.22));
      FX.shard.add(X,Y,H+1.4+hop,sz,i*.83,fcr[i],fcg[i],fcb[i],lf<.18?lf*1300:235);
      if(ty===2) bbAdd.add(sGlowB,X,Y,H+1.4+hop,Math.max(1.0,sz*1.45),0,fcr[i],fcg[i],fcb[i],155*lf);
    } else if(ty===4){                        // licking flame — upright, base on the hit
      const sz=Math.min(14,fsize[i]);
      bbAdd.add(sFireB,X,Y,H+sz*0.38,sz,0,255,205,125,235*lf);
      bbAdd.add(sGlowB,X,Y,H+1.2,sz*0.85,0,fcr[i],fcg[i],fcb[i],58*lf);
    } else if(ty===6){                        // volumetric explosion fireball
      const age=1-lf, S=Math.min(16,fsize[i]);
      bbAdd.add(sprites.fireball||sFireB,X,Y,H+S*.12,S*(0.88+age*.10),0,255,255,255,245*lf);
      bbAdd.add(sGlowB,X,Y,H+1.4,S*0.95,0,255,135,55,52*lf);
    } else if(ty===7){                        // ballistic solid debris
      const age=1-lf, hop=fsize[i]*0.55*lf*age;
      FX.shard.add(X,Y,H+1.6+hop,Math.max(1.2,fsize[i]*.42),i*.7,fcr[i],fcg[i],fcb[i],lf<.22?lf*1100:240);
    } else if(ty===9){                        // ambience: snow, ash, drifting sand
      const age=1-lf;
      bbAlpha.add(sSmokeB,X,Y,H+3+age*2,fsize[i]*(0.85+Math.sin(t*2.5+i)*0.18),
        t*0.12+i, fcr[i],fcg[i],fcb[i], 150*lf);
    } else if(ty!==9){                        // flash
      bbAdd.add(sGlowB,X,Y,Hfx+1.4,Math.min(12,fsize[i]),0, fcr[i],fcg[i],fcb[i], 220*lf);
    }
  }
  // muzzle / engine / stance glows as small shells
  for(let i=0;i<unitHigh;i++){
    if(!ualive[i]) continue;
    const mo=umode[i];
    if(!mo||mo===4) continue;
    const X=ux[i], Y=uy[i];
    if(!vis(X,Y,40)) continue;
    if(!fogEntityVisible(uteam[i],X,Y)) continue;
    const T=TYPES[utype[i]], H=unitGroundY(T,X,Y);
    if(mo===3)      bbAdd.add(sprites.glow,X,Y,H+T.size*0.5,T.size*1.6,0,255,120,50,120+Math.sin(t*11+i)*50);
    else if(mo===2) bbAdd.add(sprites.glow,X,Y,H+T.size*0.5,T.size*2.0,0,130,190,255,80);
    else if(mo===1||mo===5){
      /* Siege/suppress rings on unselected mass at cap are the same fillrate

         trap as selection rings. Off-screen already skipped via vis(). */
      if(usel[i]||i===heroIdx){
        if(!(RING_STRATEGIC&&i!==heroIdx))
          FX.ring.add(X,Y,H+1.6,T.size*(mo===1?1.5:1.3),0,255,mo===1?200:190,110,mo===1?120:100);
      }
    }
  }
  /* Critical units advertise mechanical failure on the model itself. The sim

     emits persistent smoke and sparks; these attached flames keep the source

     readable while moving. Organic infestation units vent corrosive vapour

     instead of looking like burning machinery. */
  let damagedShown=0;
  for(let i=0;i<unitHigh&&damagedShown<220;i++){
    if(overviewVfx) break;
    if(!ualive[i]) continue;
    const X=ux[i], Y=uy[i];
    if(!vis(X,Y,60)||!fogEntityVisible(uteam[i],X,Y)) continue;
    const frac=uhp[i]/Math.max(1,uhpm[i]);
    if(frac>=.58) continue;
    damagedShown++;
    const T=TYPES[utype[i]], H=gh(X,Y), sev=clamp((.58-frac)/.58,0,1);
    if(unitIsBrood(i)){
      bbAdd.add(sprites.glow,X,Y,H+T.size*.55,T.size*(.7+sev*.7),0,105,255,110,55+sev*100);
      if(frac<.28) bbAlpha.add(sSmokeB,X,Y,H+T.size*.85,T.size*(.45+sev*.5),t*.2+i,80,150,75,70+sev*55);
    } else if(frac<.38){
      const sources=frac<.18?2:1;
      for(let k=0;k<sources;k++){
        const a=i*2.17+k*2.8, ox=Math.cos(a)*T.size*.14, oy=Math.sin(a)*T.size*.12;
        const flick=.86+Math.sin(t*13+i+k*4)*.14;
        const fsz=T.size*(.28+sev*.22)*flick;
        bbAdd.add(sFireB,X+ox,Y+oy,H+T.size*.22+fsz*.38,fsz,0,255,205,135,(120+sev*110)*flick);
      }
      bbAdd.add(sGlowB,X,Y,H+T.size*.22,T.size*(.55+sev*.4),0,255,105,35,32+sev*48);
    }
  }
  // building emissives and night work lights
  for(const Bd of blds){
    if(!Bd.alive||Bd.prog<1||!vis(Bd.x,Bd.y,120)) continue;
    if(!fogEntityVisible(Bd.team,Bd.x,Bd.y)) continue;
    const sz=BT[Bd.type].size, H=BT[Bd.type].placement==='water'?0:gh(Bd.x,Bd.y);
    if(Bd.type==='geo')  bbAdd.add(sprites.glow,Bd.x,Bd.y,H+sz*0.85,sz*0.55,0,80,220,255,170);
    if(Bd.type==='fab')  bbAdd.add(sprites.glow,Bd.x,Bd.y,H+sz*0.95,sz*0.5*(1+Math.abs(Math.sin(t*5))*0.35),0,255,170,70,230);
    if(Bd.type==='arc')  bbAdd.add(sprites.glow,Bd.x,Bd.y,H+sz*1.15,sz*0.42,0,150,230,255,210);
    if(Bd.type==='rail'){
      const charge=clamp(1-(Bd.cool||0)/Math.max(.1,RAIL.cool),0,1);
      bbAdd.add(sprites.glow,Bd.x,Bd.y,H+sz*.82,sz*(.28+charge*.18),0,125,220,255,105+charge*115);
    }
    if(Bd.type==='minelaser'){
      const charge=clamp(1-(Bd.cool||0)/Math.max(.1,MINELASER.cool),0,1);
      bbAdd.add(sprites.glow,Bd.x,Bd.y,H+sz*.72,sz*(.25+charge*.16),0,90,215,255,95+charge*120);
    }
    if(Bd.type==='plasma'){
      const charge=clamp(1-(Bd.cool||0)/Math.max(.1,PLASMA_CHARGER.cool),0,1);
      bbAdd.add(sprites.glow,Bd.x,Bd.y,H+sz*.76,sz*(.42+charge*.28),0,105,205,255,100+charge*115);
    }
    if(Bd.type==='nova'&&Bd.cool<=0) bbAdd.add(sprites.glow,Bd.x,Bd.y,H+sz*1.4,sz*0.6,0,255,210,90,220);
    if(Bd.type==='sgen'){
      bbAdd.add(sprites.glow,Bd.x,Bd.y,H+sz*0.7,sz*0.66,0,120,215,255,160);
      FX.ring.add(Bd.x,Bd.y,H+2,145+Math.max(0,(Bd.lvl||1)-1)*18,0,95,215,255,38);
    }
    if(Bd.type==='techlab'&&Bd.shieldMax>0&&Bd.shield>0){
      const sf=clamp(Bd.shield/Bd.shieldMax,0,1), pulse=.88+Math.sin(t*2.6+Bd.anim)*.08;
      bbAdd.add(sprites.glow,Bd.x,Bd.y,H+sz*.75,sz*(.62+.25*sf)*pulse,0,95,205,255,65+sf*80);
      if(Bd.dmgT>0||Bd.shield<Bd.shieldMax) FX.ring.add(Bd.x,Bd.y,H+3,sz*(.78+.08*pulse),0,100,220,255,75+sf*90);
    }
    if(Bd.type==='uplink'){
      // SQUARE, because the build zone it projects is square
      const ur=buildRadius(Bd);
      for(const [ex,ey,rot2] of [[0,-ur,0],[0,ur,0],[-ur,0,Math.PI/2],[ur,0,Math.PI/2]])
        FX.line.add(Bd.x+ex,Bd.y+ey,gh(Bd.x+ex,Bd.y+ey)+2,ur*2,rot2, 90,200,255,120, 3.0);
    }
    /* Night work-light pools used to stamp a warm orange billboard on

       every finished building after dusk — the orb this pass retired.

       Mesh windows, HQ_LAMP discs and towerCrumble fire already mark a

       powered or burning structure. Specialist type glows above stay. */
  }
  /* Mobile lights are intentionally budgeted. At command zoom, lighting every

     single tank in a 2,000-unit battle would become a white carpet. The

     commander, selected units and a sampled set of active machines always

     receive a small headlamp pool; biological units use a weaker cold glow so

     their silhouettes remain readable without pretending they carry lamps. */
  if(S_nA>0.10&&FX.wedge){
    const lv=clamp((S_nA-0.10)/0.75,0,1);
    const total=Math.max(1,teamCount[0]+teamCount[1]+teamCount[2]);
    const stride=Math.max(1,Math.ceil(total/260));
    let headlightN=0;
    for(let i=0;i<unitHigh;i++){
      if(!ualive[i]||(!usel[i]&&i!==heroIdx&&(i%stride)!==0)) continue;
      const X=ux[i],Y=uy[i]; if(!vis(X,Y,48)||!fogEntityVisible(uteam[i],X,Y)) continue;
      const T=TYPES[utype[i]], H=gh(X,Y), bio=unitIsBrood(i);
      const active=umov[i]||usel[i]||i===heroIdx;
      const c=bio?[138,104,255]:(TEAMB[uteam[i]]||[165,220,255]);
      const r=T.size*(bio?.82:1.05);
      bbAdd.add(sprites.glow,X,Y,H+1.45,r*(active?1.55:1.18),0,c[0],c[1],c[2],(bio?30:(active?52:32))*lv);
      if(!bio){
        /* Machine underglow — the hull stands in its own worklight, the way a

           service walker's belly lamps pool on the rock beneath it. Ground

           decal, not a camera-facing sprite, so it reads as lit floor. */
        FX.pool.add(X,Y,H+0.85,Math.min(r*1.6,42),0,255,238,198,(active?48:26)*lv);
        bbAdd.add(sprites.glow,X,Y,H+2.0,r*.62,0,255,244,208,(active?60:36)*lv);
        /* Directional flashlight. A wedge of lit ground widening from the

           lamp, ending in a bright splash — the area the unit FACES is the

           area you can see. The bounded count prevents a thousand-unit army

           turning night into a white carpet; the commander always carries the

           long throw. */
        if(headlightN<56&&!T.air&&!T.naval&&(active||(i%7)===0)){
          const cdr=i===heroIdx;
          /* Reach is CAPPED in absolute units. Scaling purely off hull size

             let the size-32 commander throw a 200-unit floodplain that read

             as fog; a lamp's throw does not grow linearly with the vehicle

             carrying it. */
          const a=uang[i]-Math.PI/2;
          const reach=Math.min(T.size*(cdr?3.6:(T.size<15?3.8:4.6)),cdr?118:64);
          const sx=X+Math.cos(a)*T.size*.42,sy=Y+Math.sin(a)*T.size*.42;
          const mx=sx+Math.cos(a)*reach*.55,my=sy+Math.sin(a)*reach*.55;
          const ex=sx+Math.cos(a)*reach,ey=sy+Math.sin(a)*reach;
          const hh=Math.max(H,gh(mx,my))+1.15;
          /* Two layers, like a real lamp: a wide soft skirt and a hot narrow

             core inside it. One wedge alone is either too dim to guide the eye

             or so bright its edges band. */
          FX.wedge.add(sx,sy,hh,reach,a,255,232,182,(cdr?165:105)*lv,reach*(cdr?.58:.54));
          FX.wedge.add(sx,sy,hh+0.12,reach*.86,a,255,244,210,(cdr?135:80)*lv,reach*(cdr?.30:.27));
          FX.pool.add(ex,ey,gh(ex,ey)+1.05,reach*(cdr?.34:.30),0,255,233,186,(cdr?130:78)*lv);
          FX.pool.add(ex,ey,gh(ex,ey)+1.15,reach*(cdr?.19:.17),0,255,246,214,(cdr?95:55)*lv);
          bbAdd.add(sprites.glow,sx,sy,H+2.3,Math.min(T.size*.5,12),0,255,242,204,(cdr?80:44)*lv);
          headlightN++;
        }
      }
    }
  }
  /* ---- live singularities --------------------------------------------

     A black hole cannot be drawn additively — additive can only brighten.

     The core is a deep-dark blob in the ALPHA pass, and everything luminous

     around it (accretion rings, einstein rim, polar shimmer) rides additive

     on top. The implosion phase collapses the ring radius toward the core. */
  if(typeof singularities!=='undefined') for(const Sg of singularities){
    if(!vis(Sg.x,Sg.y,300)) continue;
    const Rg=170*Math.sqrt(Sg.pow), H=gh(Sg.x,Sg.y)+16;
    const ph=Sg.phase, q=ph===0?Math.min(1,Sg.t/2.5):1;
    const coreR=(ph===2? Math.max(0,1-Sg.t/0.6) : (0.35+q*0.65))*Rg*0.22;
    if(coreR>1){
      bbAlpha.add(sprites.glow,Sg.x,Sg.y,H,coreR*2.6,0, 4,2,10, 244);
      bbAlpha.add(sprites.glow,Sg.x,Sg.y,H,coreR*1.4,0, 0,0,0, 252);
      bbAdd.add(sprites.ring,Sg.x,Sg.y,H,coreR*1.55,t*3.1, 205,170,255, 215);
      bbAdd.add(sprites.ring,Sg.x,Sg.y,H,coreR*2.1,-t*2.2, 140,100,240, 130);
      bbAdd.add(sprites.glow,Sg.x,Sg.y,H,coreR*3.4,0, 96,60,190, 60);
      FX.ring.add(Sg.x,Sg.y,H-8,(coreR*2.4)/3,t*4.2, 196,160,255, 180);
      /* infall shimmer: brief luminous streaks on the spiral */
      if(ph===0&&Math.random()<0.5){
        const a4=Math.random()*TAU, d5=coreR*2.2+Math.random()*Rg*0.8;
        bbAdd.add(sprites.glow,Sg.x+Math.cos(a4)*d5,Sg.y+Math.sin(a4)*d5,H+Math.random()*14,
          5+Math.random()*7,0, 210,180,255, 90);
      }
    }
  }
  /* ---- structures burning down --------------------------------------

     A building below a third health is visibly failing: fire licking out of

     the hull, a smoke column climbing off it, and sparks. This is the single

     clearest "your base is in trouble" signal there is, and it reads from

     right across the map without looking at a health bar. */
  for(const Bf of blds){
    if(!Bf.alive||Bf.prog<1||!vis(Bf.x,Bf.y,140)) continue;
    if(!fogEntityVisible(Bf.team,Bf.x,Bf.y)) continue;
    const frac=Bf.hp/Bf.hpm;
    if(frac>0.55) continue;
    const sz=BT[Bf.type].size, H=gh(Bf.x,Bf.y);
    const sev=clamp((0.55-frac)/0.55,0,1);       // 0 at 55% hp, 1 at destruction
    const fl=0.65+Math.abs(Math.sin(t*7.3+Bf.anim))*0.35;
    /* HQ is size 76. Scaling tongues off that diameter painted two orange

       lakes in empty pad space. Cap the fire footprint so a burning carrier

       still reads as hull fire, not a particle soup beside it. */
    const fBase=Math.min(sz,26);
    const fireCount=sev>.72?3:sev>.38?2:2;
    for(let k=0;k<fireCount;k++){
      const a=Bf.anim+k*2.094;
      const ox=Math.cos(a)*fBase*0.22, oy=Math.sin(a)*fBase*0.22;
      const flick=0.82+Math.abs(Math.sin(t*9.1+k+Bf.anim))*0.18;
      const fsz=fBase*(0.22+sev*0.16)*fl*flick;
      bbAdd.add(sFireB, Bf.x+ox, Bf.y+oy, H+6+fsz*0.36,
        fsz, 0, 255, 205-k*18, 120-k*16, (105+sev*135)*flick);
    }
    if(sev>0.45)
      bbAdd.add(sprites.glow, Bf.x, Bf.y, H+2.2, fBase*(0.32+sev*0.12)*fl, 0, 255,110,50, 32*sev);
    // smoke column: emitted, so it drifts and persists rather than pulsing
    if(perfScale>0.35 && (tick+(Bf.anim*97|0))%Math.max(3,10-(sev*7|0))===0){
      addParticle(1, Bf.x+rr(-sz*0.3,sz*0.3), Bf.y+rr(-sz*0.3,sz*0.3),
        rr(-6,6), rr(-28,-16), 3.2+sev*2.0, sz*(0.30+sev*0.36),
        40+sev*22, 38+sev*18, 36+sev*16);
    }
    if(sev>0.6 && (tick+(Bf.anim*31|0))%7===0)
      addParticle(2, Bf.x+rr(-sz*0.18,sz*0.18), Bf.y+rr(-sz*0.18,sz*0.18),
        rr(-8,8), rr(-10,-2), 0.35, 2.0, 255,190,90);
    if(sev>0.82 && perfScale>0.48 && (tick+(Bf.anim*43|0))%31===0){
      addParticle(6,Bf.x+rr(-sz*.28,sz*.28),Bf.y+rr(-sz*.28,sz*.28),0,0,.5,sz*.34,255,145,60);
      addParticle(3,Bf.x,Bf.y,0,0,.28,sz*.8,255,135,55);
    }
  }

  // burning ruins (still standing)
  for(const R of relics){
    if(!R.alive||!(R.burn>0.12)||!vis(R.x,R.y,120)) continue;
    const H=gh(R.x,R.y);
    bbAdd.add(sFireB,R.x,R.y,H+R.s*0.22,Math.min(22,R.s*.55)*(0.85+Math.sin(t*4+R.seed)*0.15),0,255,210,140,210*R.burn);
    bbAdd.add(sprites.glow,R.x,R.y,H+2,Math.min(28,R.s*.7),0,255,115,50,55*R.burn);
    if(S_nA>0.34) FX.cone.add(R.x,R.y,H+R.s*0.55,R.s*0.30,t*0.3,255,150,70,54*R.burn*S_nA);
  }
  /* Collapsed civic wreckage keeps fires until the ember field cools.

     The loop above skips dead blocks, which is why city destroy used to

     look like a quiet grey crater with no fire. */
  for(const R of relics){
    if(R.alive) continue;
    const age=stats.t-(R.fallT||0);
    if(age>52||!(R.burn>0.18)||!vis(R.x,R.y,140)) continue;
    const heat=clamp(1-age/52,0,1)*R.burn;
    const H=gh(R.x,R.y), fl=0.68+Math.abs(Math.sin(t*8.2+R.seed))*0.32;
    const n=heat>0.55?4:3;
    const fsz=Math.min(16, Math.max(8, R.s*0.12));
    for(let k=0;k<n;k++){
      const a=R.seed+k*2.094;
      const ox=Math.cos(a)*Math.min(R.s*0.16, 12), oy=Math.sin(a)*Math.min(R.s*0.16, 12);
      bbAdd.add(sFireB, R.x+ox, R.y+oy, H+2+fsz*0.40,
        fsz*(0.85+heat*0.25)*fl, 0, 255, 165-k*12, 55, (175+heat*60)*fl*heat);
    }
    bbAdd.add(sprites.glow, R.x, R.y, H+2, Math.min(22, R.s*0.28), 0, 255, 108, 38, 48*heat);
  }
  if(typeof groundBurns!=='undefined'){
    for(let i=0;i<groundBurns.length;i++){
      const G=groundBurns[i];
      if(G.kind!==1) continue;
      const civic=G.civic||(typeof cityGroundAt==='function'&&cityGroundAt(G.x,G.y)>=1);
      if(!civic||!vis(G.x,G.y,G.r+50)) continue;
      const cool=clamp((stats.t-G.t0)/(G.civic?90:70),0,1);
      if(cool>0.70) continue;
      const heat=1-cool, H=gh(G.x,G.y), n=heat>0.5?3:2;
      const fsz=Math.min(14, Math.max(8, G.r*0.08));
      for(let k=0;k<n;k++){
        const a=i*1.7+k*2.094, d=Math.min(G.r*0.14, 10)*(0.35+0.4*((k+1)/4));
        const flick=0.86+Math.sin(t*9.4+k+i)*0.14;
        bbAdd.add(sFireB, G.x+Math.cos(a)*d, G.y+Math.sin(a)*d, H+fsz*0.40,
          fsz*heat*flick, 0, 255, 155, 48, (150+heat*80)*heat);
      }
    }
  }
  for(const W of wrecks){
    if(W.kind!==2||!vis(W.x,W.y,50)) continue;
    const age=stats.t-(W.ts||0);
    if(age>38) continue;
    const heat=clamp(1-age/38,0,1);
    if(heat<0.12) continue;
    const H=gh(W.x,W.y), fl=0.75+Math.sin(t*7.4+W.x)*0.25;
    bbAdd.add(sFireB, W.x, W.y, H+4, Math.min(14,W.s*(0.28+heat*0.16))*fl, 0, 255, 195, 110, (110+heat*90)*heat);
  }
  // salvage pickup shimmer
  for(const W of wrecks){
    if(W.glow<=0||!vis(W.x,W.y,40)) continue;
    /* Reclaim glow follows the same language: green for alloy, amber for

       organic, so the feedback matches the resource it is paying. */
    const g = W.kind===5 ? [255,196,120] : [120,255,170];
    bbAdd.add(sprites.glow,W.x,W.y,gh(W.x,W.y)+6,26,0,g[0],g[1],g[2],220*Math.min(1,W.glow*2));
  }
  // meteor markers
  for(const M of meteors){
    if(!vis(M.x,M.y,200)) continue;
    const H=gh(M.x,M.y);
    FX.ring.add(M.x,M.y,H+2,72+Math.sin(t*8)*8,0,255,90,60,150);
    if(M.t<0.7) addBeam3D(FX.beam,M.x,H,M.y,M.x+50,H+900,M.y,7,255,190,110,200*(1-M.t/0.7));
  }
  /* ---- COMMANDER LOCATOR ----------------------------------------------

     This is navigation help, not part of the mech. Selection already provides

     an unambiguous ring, so stacking the old 9.5-unit crest over a selected

     Commander made it look like oversized rigid hardware. Hide it on selection

     and scale it gently with strategic zoom; close play gets a small beacon. */
  if(sprites.commanderFx&&heroIdx>=0&&ualive[heroIdx]&&!usel[heroIdx]&&vis(ux[heroIdx],uy[heroIdx],90)){
    const cx=ux[heroIdx],cy=uy[heroIdx];
    const q=clamp((orthoSpan-420)/900,0,1),ls=10+q*3,pulse=.92+Math.sin(t*3.2)*.08;
    const ch=gh(cx,cy)+TYPES[utype[heroIdx]].size*1.75+26+Math.sin(t*2.2)*1.4;
    bbAdd.add(sprites.glow,cx,cy,ch,ls*1.55*pulse,0,255,192,45,48);
    bbAdd.add(sprites.ring||sprites.glow,cx,cy,ch,ls*1.22*pulse,-t*.35,255,226,100,115);
    bbAdd.add(sprites.commanderFx,cx,cy,ch,ls*pulse,0,255,218,92,225);
  }
  /* ---- MODULE MARKS ----------------------------------------------------

     Drawn over the Commander and the HQ, one badge per fitted module, slowly

     turning and bobbing. Sourced live from the crafting layer, so a module

     that broke at the end of the last match simply has no mark this one. */
  if(typeof activeModuleMarks==='function' && sprites.ring){
    const marks=activeModuleMarks();
    if(marks.length){
      const carriers=[];
      /* Physical module hardware is readable at tactical zoom. Its duplicate

         floating badge only returns at strategic zoom, where that geometry is

         genuinely too small to identify. */
      if(heroIdx>=0&&ualive[heroIdx]&&orthoSpan>760)
        carriers.push([ux[heroIdx],uy[heroIdx],TYPES[utype[heroIdx]].size*1.5+22]);
      for(const B of bldLive) if(B.alive&&B.team===0&&B.type==='hq'){ carriers.push([B.x,B.y,BT.hq.size*0.9+22]); break; }
      for(const [cx,cy,ch] of carriers){
        if(!vis(cx,cy,80)) continue;
        const H=gh(cx,cy)+ch;
        marks.forEach((mk,k)=>{
          const a=t*0.7+k*(TAU/Math.max(1,marks.length));
          const rr2=marks.length>1?11:0;
          const mx=cx+Math.cos(a)*rr2,my=cy+Math.sin(a)*rr2,mh=H+Math.sin(t*1.6+k)*1.4;
          bbAdd.add(sprites.glow,mx,my,mh,7.4,0,mk.col[0],mk.col[1],mk.col[2],50);
          bbAdd.add(sprites.ring,mx,my,mh,5.2,t*1.1,mk.col[0],mk.col[1],mk.col[2],190);
        });
      }
    }
  }
  gl.enable(gl.POLYGON_OFFSET_FILL);
  gl.polygonOffset(-8,-32);
  FX.bolt.flush(gl); FX.shard.flush(gl); FX.beam.flush(gl);
  FX.cone.flush(gl); FX.shell.flush(gl);
  gl.disable(gl.DEPTH_TEST);
  FX.line.flush(gl); FX.ring.flush(gl); FX.disc.flush(gl);
  if(FX.wedge){ FX.wedge.flush(gl); FX.pool.flush(gl); }
  gl.enable(gl.DEPTH_TEST);
  gl.disable(gl.POLYGON_OFFSET_FILL);
  MF_COMBAT_VFX_TELEMETRY.projectiles=projectileDrawn;
  MF_COMBAT_VFX_TELEMETRY.beams=beamDrawn;
  MF_COMBAT_VFX_TELEMETRY.particles=combatParticleDrawn;
  MF_COMBAT_VFX_TELEMETRY.additive=bbAdd.n;
  MF_COMBAT_VFX_TELEMETRY.maxProjectiles=Math.max(MF_COMBAT_VFX_TELEMETRY.maxProjectiles,projectileDrawn);
  MF_COMBAT_VFX_TELEMETRY.maxBeams=Math.max(MF_COMBAT_VFX_TELEMETRY.maxBeams,beamDrawn);
  MF_COMBAT_VFX_TELEMETRY.maxParticles=Math.max(MF_COMBAT_VFX_TELEMETRY.maxParticles,combatParticleDrawn);
  if(projectileDrawn||beamDrawn||combatParticleDrawn)MF_COMBAT_VFX_TELEMETRY.framesWithCombat++;
  /* The WebView's isolated inspector cannot read page-world globals. The

     opt-in showcase exposes a tiny DOM snapshot so automated device QA can

     prove the real render queues were flushed; ordinary play pays no cost. */
  if(MF_COMBAT_VFX_DIAGNOSTIC&&(MF_COMBAT_VFX_TELEMETRY.framesWithCombat&7)===0)document.documentElement.dataset.mfVfx=[projectileDrawn,beamDrawn,combatParticleDrawn,MF_COMBAT_VFX_TELEMETRY.maxProjectiles,MF_COMBAT_VFX_TELEMETRY.maxBeams,MF_COMBAT_VFX_TELEMETRY.maxParticles,MF_COMBAT_VFX_TELEMETRY.framesWithCombat].join(',');

  /* ---- UNIVERSAL HEALTH BARS -------------------------------------------

     Health is tactical information, not merely a damage notification. Every

     visible structure, ground unit and aircraft gets a camera-facing bar.

     Both the dark track and coloured fill share bbAlpha, so even a large army

     remains one draw call instead of issuing UI geometry per entity. */
  /* ALLEGIANCE IS THE FIRST READ, damage the second. Every bar used to run

     the same green-amber-red damage ramp, so a brawl was a wall of identical

     green and you could not tell whose army was winning at a glance. Now the

     hue answers "whose?" - your bars keep the full damage ramp (their exact

     state is YOUR tactical information), enemy and wildlife bars live in the

     red family and darken as they fall. */
  /* Bars are screen-space billboards, so author their dimensions in phone

     pixels and convert once through the current world span. The previous hard

     world-unit minimum ballooned into a chunky rectangle while zoomed in and

     shrank into a mipmapped dash while zoomed out. */
  const hbPx=Math.max(.24,orthoSpan/Math.max(1,VH));
  const putHealthBar=(x,y,h,w,bh,frac,team)=>{
    frac=clamp(frac,0,1);
    let er=78,eg=224,eb=132;
    if(team===1){er=255;eg=76;eb=62;}else if(team===2){er=255;eg=144;eb=48;}
    /* Soft allegiance rim -> opaque frame -> fill -> one-pixel gloss. This is

       still one instanced batch; the added layers buy clarity without DOM,

       text, texture scaling or a draw call per entity. */
    bbAlpha.addRect(sprites.px,x,y,h,w+5*hbPx,bh+4*hbPx,er,eg,eb,66);
    bbAlpha.addRect(sprites.px,x,y,h,w+2*hbPx,bh+1.7*hbPx,4,9,15,242);
    if(frac<=0) return;
    const off=-w*(1-frac)*0.5;
    let r,g,b;
    if(team===1){ r=255; g=52+50*frac; b=44; }               // enemy army - hard red
    else if(team===2){ r=255; g=118+50*frac; b=34; }         // wildlife - hot ember
    else { r=frac>0.5?72:255; g=frac>0.5?235:frac>0.25?184:82; b=frac>0.5?112:62; }
    bbAlpha.addRect(sprites.px,
      x+matV[0]*off, y+matV[8]*off, h+matV[4]*off,
      w*frac,bh,r,g,b,255);
    const vo=bh*.26;
    bbAlpha.addRect(sprites.px,
      x+matV[0]*off+matV[1]*vo, y+matV[8]*off+matV[9]*vo, h+matV[4]*off+matV[5]*vo,
      w*frac,Math.max(.55*hbPx,bh*.18),Math.min(255,r+48),Math.min(255,g+48),Math.min(255,b+48),185);
  };
  const putShieldBar=(x,y,h,w,frac)=>{
    frac=clamp(frac,0,1);
    bbAlpha.addRect(sprites.px,x,y,h,w+2,3.2,5,22,34,220);
    if(frac<=0) return;
    const off=-w*(1-frac)*.5;
    bbAlpha.addRect(sprites.px,x+matV[0]*off,y+matV[8]*off,h+matV[4]*off,w*frac,1.8,85,215,255,255);
  };
  const hbMode=(META&&META.settings&&META.settings.healthBars)||'select';
  if(hbMode!=='off'){
    for(let bi=0;bi<blds.length;bi++){
      const Bd=blds[bi];
      if(!Bd.alive||!vis(Bd.x,Bd.y,150)) continue;
      if(hbMode==='select'&&openBld!==bi) continue;
      if(!fogEntityVisible(Bd.team,Bd.x,Bd.y)) continue;
      const T=BT[Bd.type], H=gh(Bd.x,Bd.y);
      const bw=clamp((52+Math.min(12,T.size*.14))*hbPx,30,74);
      const barH=clamp(5.0*hbPx,2.8,5.2), bh=H+T.size*1.34+4*hbPx;
      putHealthBar(Bd.x,Bd.y,bh,bw,barH,Bd.hp/Bd.hpm,Bd.team);
      if(Bd.shieldMax>0) putShieldBar(Bd.x,Bd.y,bh+7*hbPx,bw,Bd.shield/Bd.shieldMax);
    }
    /* Typed scratch, reused across frames. This loop used to push one object

       literal AND build one concatenated string key per visible unit, every

       frame: with health bars on and 300 units on screen that is ~36,000

       allocations a second feeding the collector, which on a mid-range Android

       is a visible hitch every few seconds rather than a lower average frame

       rate. Same results, no garbage. */
    if(_hbI.length<unitHigh){ _hbI=new Int32Array(unitHigh); _hbF=new Float32Array(unitHigh); }
    let hbN=0;
    for(let i=0;i<unitHigh;i++){
      if(!ualive[i]||!vis(ux[i],uy[i],90)) continue;
      if((hbMode==='select'||overviewVfx)&&!usel[i]) continue;
      if(!fogEntityVisible(uteam[i],ux[i],uy[i])) continue;
      if(uteam[i]===2&&step>1&&(i&1)) continue;
      if(i!==heroIdx&&typeof mfIconStackSkip==='function'&&mfIconStackSkip(i)) continue;
      _hbI[hbN]=i; _hbF[hbN]=uhp[i]/uhpm[i]; hbN++;
    }
    const putUnitBar=k=>{
      const i=_hbI[k], T=TYPES[utype[i]], H=gh(ux[i],uy[i])+(T.air?58:0);
      const vs=T.size*(T.vscale||1),bh=H+vs*(T.air?1.22:1.58)+3*hbPx;
      const bw=clamp((T.cat==='hero'?48:T.size>=24?43:36)*hbPx,20,T.cat==='hero'?60:48);
      const barH=clamp(4.2*hbPx,2.5,4.4);
      putHealthBar(ux[i],uy[i],bh,bw,barH,_hbF[k],uteam[i]);
      /* Secondary shielding is a projected buff (ushielded is a short window a

         shield field keeps refreshing). While it holds, a thin cyan strip

         rides above the health bar - the one defensive state in the game that

         previously had no readback on the unit itself. */
      if(ushielded[i]>0) putShieldBar(ux[i],uy[i],bh+6*hbPx,bw*0.72,clamp(ushielded[i]/0.7,0,1));
    };
    /* A type-select can contain hundreds of units in regular formation. One

       bar per chassis then touches its neighbours and becomes a solid stripe.

       Collapse dense selections/always-on views to the most damaged unit in

       each view-sized cell. Small squads still retain one bar per unit. */
    if(hbN>48){
      /* Numeric key, not 'x,y' — the string was the single biggest source of

         per-frame garbage here. Cells are at least 48 world units, so a map

         would have to be 8192 cells across to collide; MAP is far below that. */
      const cell=Math.max(48,orthoSpan/17);
      _hbCells.clear();
      for(let k=0;k<hbN;k++){
        const i=_hbI[k], key=((uy[i]/cell)|0)*8192+((ux[i]/cell)|0), old=_hbCells.get(key);
        if(old===undefined||_hbF[k]<_hbF[old]) _hbCells.set(key,k);
      }
      for(const k of _hbCells.values()) putUnitBar(k);
    } else for(let k=0;k<hbN;k++) putUnitBar(k);
  }

  /* ---- billboard pass -------------------------------------------------

     Sprites last: alpha-blended smoke first so it reads as volume against the

     world, then additive light on top of everything. */
  beginBB();
  gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
  bbAlpha.flush(gl);
  /* Additive glows are screen-aligned quads at a single depth. Depth-testing

     them against pavement kerbs punched C-shaped holes and 1px cyan edges

     through the stain — the other half of the daytime-fx flicker. Light is

     allowed to sit on the ground; smoke above still occludes. */
  gl.disable(gl.DEPTH_TEST);
  gl.blendFunc(gl.SRC_ALPHA,gl.ONE);
  bbAdd.flush(gl);
  gl.enable(gl.DEPTH_TEST);
  /* GPU particle pass: same additive state, one update + one draw. */
  if(typeof gpfxFrame==='function'){
    gl.depthMask(false);
    gpfxFrame((typeof dtDraw==='number'?dtDraw:0.016)||0.016,matVP,(typeof innerHeight!=='undefined')?innerHeight:900);
    gl.disable(gl.RASTERIZER_DISCARD);
    gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK,null);
    gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER,null);
    gl.enable(gl.BLEND);
    gl.blendFunc(gl.SRC_ALPHA,gl.ONE);
    gl.disable(gl.CULL_FACE);
    gl.enable(gl.DEPTH_TEST);
    gl.depthMask(false);
  }
  /* Tactical icons last, and deliberately without a depth test. The camera

     pitch band allows a ridge to stand in front of a unit, and a strategic

     symbol that disappears behind terrain defeats the purpose of zooming out.

     Disclosure is still owned by fog: nothing reaches this batch that

     fogEntityVisible() rejected. One extra draw call for the whole map. */
  if(typeof bbIcon!=='undefined'&&bbIcon&&bbIcon.n){
    /* Recorded before flush(), which zeroes the count — a harness sampling

       bbIcon.n after the frame would always read 0 and conclude the tier is

       dead. */
    mfIconLast=bbIcon.n;
    gl.depthMask(false);
    gl.disable(gl.DEPTH_TEST);
    beginBB(mfIcoTex);
    gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
    bbIcon.flush(gl);
    gl.enable(gl.DEPTH_TEST);
  } else if(typeof mfIconLast!=='undefined') mfIconLast=0;

  gl.depthMask(true);
  gl.disable(gl.BLEND);
  gl.enable(gl.CULL_FACE);
  if(aoActive) aoPresent();
  /* Present samples 5/6. Restore the model atlas so the next frame cannot

     start with a post texture on a material sampler. */
  begin3D(S_nA);
  gl.bindVertexArray(null);
}