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];
let mfWaterAnimTick=-1;
const _tmpV=[0,0,0];
/* sprites.px names a padded atlas cell: only its central 160/244 sampled
   pixels are opaque. Work rails need their authored phone-pixel thickness,
   so retain one inner UV and rebuild it only when a restored GL context gives
   the atlas a new source array. Health bars keep their established sizing. */
let _mfBldWorkUVSource=null;
const _mfBldWorkUV=new Float32Array(4);
function mfBuildingWorkUV(){
  const uv=sprites.px;
  if(_mfBldWorkUVSource!==uv){
    const du=uv[2]-uv[0],dv=uv[3]-uv[1];
    _mfBldWorkUV[0]=uv[0]+du*.25;_mfBldWorkUV[1]=uv[1]+dv*.25;
    _mfBldWorkUV[2]=uv[2]-du*.25;_mfBldWorkUV[3]=uv[3]-dv*.25;
    _mfBldWorkUVSource=uv;
  }
  return _mfBldWorkUV;
}
/* 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 rk=0;rk<_mfRuN;rk++){
      const i=_mfRuI[rk];
      if(!mfRenderUnitFogVisible(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 csmDrawBuildingSet(set){
  if(!set)return;
  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 csmDrawBuildingCasters(){
  if(typeof BLD_MESH==='undefined') return;
  /* Do not materialise Object.values + a spread copy every CSM frame. The
     explicit base-then-faction walk preserves the old insertion order. */
  csmDrawBuildingSet(BLD_MESH);
  if(typeof BLD_FACTION_MESH!=='undefined') for(const fac in BLD_FACTION_MESH){
    if(!Object.prototype.hasOwnProperty.call(BLD_FACTION_MESH,fac))continue;
    csmDrawBuildingSet(BLD_FACTION_MESH[fac]);
  }
}
function flushBuildingSet(set){
  if(!set)return;
  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);}
  }
}
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;
  /* Player faction colour, resolved ONCE. It was resolved inside the loop
     through `playerFactionKey`, which is not defined anywhere in the tree — the
     typeof guard therefore always took the 'nova' branch, so a Legion or Horde
     player's commander and selected vehicles threw NOVA-BLUE local light while
     every billboard, headlamp sprite and structure beside them used the faction
     palette. playerKitKey() is the resolver the rest of the tree uses for the
     player's own team (see bldFactionKey's team-0 branch) and returns exactly
     the nova/legion/syndicate/horde keys sceneLightColor switches on. */
  const _playerLightC=_lin(sceneLightColor(
    typeof playerKitKey==='function'?playerKitKey():'nova'));
  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=_playerLightC;
    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;
/* Only the first begin3D in render() receives this contract. It immediately
   follows the explicit opaque-state setup below, so wrappers can avoid asking
   the driver to rediscover four values JavaScript just set. Other begin3D
   callers remain unknown and must retain their queried-state fallback. */
const MF_BEGIN3D_OPAQUE_STATE=Object.freeze({blend:false,cull:true,depth:true,depthMask:true});
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 addBeamPathFx(x0,h0,y0,x1,h1,y1,width,r,g,b,a){
  /* Deliberately empty. The old per-frame pearl necklace multiplied every
     beam into dozens of glow/smoke billboards and made a paused render grow
     visual clutter. The coherent shaft remains in addBeam3D(). */
}
/* Authored coherent shaft. The sheet's first eight cells are narrow vertical
   pulse phases; camera projection supplies the rectangle orientation. Queueing
   is render-only and fixed-size, so a paused render cannot emit or grow a sim/
   GPU pool. Long shafts retain the existing depth-correct segmentation. */
function addMacroEnergyRibbon(x0,h0,y0,x1,h1,y1,width,r,g,b,a,phaseSeed){
  if(typeof macroFxQueueRect!=='function')return false;
  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/210)));
  const simT=(typeof stats!=='undefined'&&Number.isFinite(stats.t))?stats.t:0;
  const tint=(Math.max(0,Math.min(255,r))<<16)|(Math.max(0,Math.min(255,g))<<8)|Math.max(0,Math.min(255,b));
  let ax=x0,ay=y0,ah=h0,ok=true;
  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),sx=s1[0]-s0[0],sy=s1[1]-s0[1];
    const screenLen=Math.hypot(sx,sy);
    if(screenLen>.2){
      /* Segments exist only for depth correctness. They are one logical shaft,
         so they must sample the SAME authored phase. Offsetting by segment
         produced the broken, dashed beam in the phone capture. Extra overlap
         closes the atlas' transparent mip gutter at oblique camera angles. */
      const worldLen=Math.max(width*2,screenLen*orthoSpan/Math.max(1,VH)*1.38);
      const rot=Math.atan2(-sx,-sy),phase=((simT*10+(phaseSeed||0)*.037)%1+1)%1;
      ok=macroFxQueueRect(typeof MF_MACROFX_ENERGY_RIBBON==='number'?MF_MACROFX_ENERGY_RIBBON:15,
        (ax+ex)*.5,(ay+ey)*.5,(ah+eh)*.5,width*2.72,worldLen,phase,a,tint,rot)&&ok;
    }
    ax=ex;ay=ey;ah=eh;
  }
  return ok;
}
function addBeam3D(mesh,x0,h0,y0,x1,h1,y1,rad,r,g,b,a,opt){
  const q=typeof mfVfxQ==='function'?mfVfxQ():1;
  a=Math.max(0,Math.min(255,a));
  const aBeam=Math.max(76,Math.min(150,a*.68));
  /* Projectile streaks stay on the shared atlas; actual energy beams use one
     authored shaft. This prevents missiles from inheriting the laser language. */
  if(opt&&opt.projectile){
    const pw=Math.max(0.88,rad*(q>=.95?0.93:.80));
    /* One soft faction sheath plus a narrow warm-white core makes ordinary
       rounds legible at phone overview zoom. A single dim atlas ribbon used to
       collapse below a pixel there, so impacts were the only visible proof of
       attacks. Width follows the current world-per-pixel scale, not gameplay. */
    const worldPerPixel=Math.max(0.01,orthoSpan/Math.max(1,VH));
    const sheathW=Math.max(pw*2.2,worldPerPixel*6.0);
    const coreW=Math.max(pw*1.05,worldPerPixel*2.4);
    addBeamRibbon(sprites.glow,x0,h0,y0,x1,h1,y1,sheathW,r,g,b,Math.min(175,aBeam*.9),190);
    addBeamRibbon(sprites.glow,x0,h0,y0,x1,h1,y1,coreW,255,246,220,Math.min(225,aBeam*1.25),210);
    if(opt.noMuzzle)return;
    bbAdd.add(sprites.glow,x0,y0,h0,pw*0.98,0,245,238,226,Math.min(78,aBeam*.44));
    return;
  }
  const width=Math.max(1.02,rad*(q>=1.25?.60:q>=.95?.54:q>=.65?.47:.43));
  const beamA=Math.min(102,aBeam*.58);
  if(!addMacroEnergyRibbon(x0,h0,y0,x1,h1,y1,width,r,g,b,beamA,opt&&opt.beamSeed))
    addBeamRibbon(sprites.glow,x0,h0,y0,x1,h1,y1,width*1.18,r,g,b,Math.min(84,aBeam*.42),190);
  /* Mid-flight tracers pass noMuzzle — a burst behind the round is the
     floating flash that made shots look disconnected from the barrel. */
  if(opt&&opt.noMuzzle) return;
    bbAdd.add(sprites.glow,x0,y0,h0,width*0.88,0,245,238,226,Math.min(58,aBeam*.34));
}
/* 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.glow,ax,ah,ay,ex,eh,ey,
        Math.max(1.55,bm.w*.92),r,g,b,a,220);
      addBeamRibbon(sprites.glow,ax,ah,ay,ex,eh,ey,
        Math.max(.72,bm.w*.28),245,252,255,a*.78,220);
      ax=ex; ay=ey; ah=eh;
    }
  }
}
function addBeamBurst(x,y,h,size,r,g,b,a){
  if(a<8||size<0.35) return;
  /* One cohesive authored terminus. The integrated rim lives in the same
     billboard, so three simultaneous beams cannot build white core+ring discs. */
  const s=Math.min(8.0,Math.max(1.7,size*.54));
  const simT=(typeof stats!=='undefined'&&Number.isFinite(stats.t))?stats.t:0;
  const phase=((simT*12+x*.013+y*.017)%1+1)%1;
  const tone=[Math.max(0,Math.min(255,r*0.82))|0,Math.max(0,Math.min(255,g*0.82))|0,Math.max(0,Math.min(255,b*0.84))|0];
  const tint=(tone[0]<<16)|(tone[1]<<8)|tone[2];
  if(typeof macroFxQueue==='function'&&macroFxQueue(
    typeof MF_MACROFX_ENERGY_HIT==='number'?MF_MACROFX_ENERGY_HIT:16,x,y,h,s,phase,
    Math.min(80,a*.40),tint,0))return;
  bbAdd.add(sprites.glow,x,y,h,s,0,tone[0],tone[1],tone[2],Math.min(58,a*.28));
}
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;
  size*=.72;a=Math.min(150,a*.62);
  const cone=Math.max(6.2,size*(q>=0.95?2.25:1.85));
  bbAdd.add(sprites.glow,x,y,h,size,0,255,248,228,a);
  addBeamRibbon(sprites.glow,x,h,y,x+nx*cone,h,y+ny*cone,
    Math.max(1.35,size*.68),255,248,228,a*.78,80);
}
function mfProjectileVisualAdmission(slot,essential,overview,drawn){
  /* A fixed slot sample permanently hid seven of eight recycled rifle slots.
     Always show the first 32 actually visible rounds in a small engagement;
     retain the old sparse sample only after the battlefield is already busy. */
  return !overview||essential||drawn<32||(slot&7)===0;
}
function mfCombatFlashSize(type,size){
  const authored=Math.min(12,size);
  /* Low's billboard gate rejects sub-3.4px quads. At maximum command zoom a
     12-world-unit rifle flash is only 1.5-3px, so the whole shot disappears.
     Type 0 is the primary flash; preserve a six-pixel read across orientation. */
  return type===0?Math.max(authored,orthoSpan/Math.max(1,VH)*6):authored;
}
function addWreckEmbers(x,y,h,size,heat,seed){
  /* Static coal bed + local flicker. Upright flame quads were the licking
     tongues the civic ground-burn pass already retired. */
  if(heat<0.08||size<0.8) return;
  /* `t` is render()'s block-scoped animation clock and is NOT visible here —
     there is no global `t` anywhere in the tree, so `typeof t` was always
     'undefined' and tt was pinned at 0. Math.sin(0*5.8+seed) is a per-position
     constant, which means the "local flicker" this function is named for never
     flickered: every burning wreck, ruin and destroyed structure sat under a
     dead-still ember glow. fxT is render3d's own seconds accumulator. */
  const tt=fxT;
  const flick=0.88+0.12*Math.abs(Math.sin(tt*5.8+seed));
  const a=heat*flick;
  const s=Math.max(2.2,size*0.78);
  bbAdd.add(sprites.glow,x,y,h+1.02,s*1.28,0,255,78,22,Math.min(64,36*a));
  bbAdd.add(sprites.glow,x,y,h+1.18,s*0.46,0,255,132,42,Math.min(130,82*a));
  if(FX.pool) FX.pool.add(x,y,h+0.80,s*1.15,0,255,92,28,Math.min(52,30*a));
}
function addWreckCoalBed(x,y,h,span,heat,seed,n){
  addWreckEmbers(x,y,h,span*0.55,heat,seed);
  const nn=n||3;
  for(let k=0;k<nn;k++){
    const a=seed+k*2.094;
    addWreckEmbers(x+Math.cos(a)*span*0.28,y+Math.sin(a)*span*0.24,h,
      span*0.32,heat*(0.72+((k*13)%7)*0.04),seed+k*3.1);
  }
  /* C&C wreck language: compact coals + a thin dark column, not licking tongues. */
  if(heat>0.22&&sprites.smoke)
    bbAlpha.add(sprites.smoke,x,y,h+span*0.55,span*0.85,seed, 38,36,34, Math.min(90,48*heat));
}
/* Damaged-building smoke and embers are persistent simulation-side particles,
   so a draw must never create them twice for the same simulation tick. Keep
   the watermark outside the building/save schema: WeakMap identity follows
   the live building object without becoming gameplay, replay or network data. */
const _damagedStructureParticleTick=new WeakMap();
function mfDamagedStructureParticleTickOnce(Bf,simTick){
  if(_damagedStructureParticleTick.get(Bf)===simTick)return false;
  _damagedStructureParticleTick.set(Bf,simTick);
  return true;
}
function emitDamagedStructureParticlesOnce(Bf,sz,sev){
  if(!mfDamagedStructureParticleTickOnce(Bf,tick))return;
  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);
  }
}
function stampCrystalVeins(D,H,col,pulse,fieldR,taken){
  /* Terrain paintResourceGroundNode owns the crack network. Additive
     glow ribbons + a centre sprite stacked with crystal pools into the
     white disc on every free node — the ore-refinery bloom in deploy. */
  return;
}

/* 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],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
let airPropulsionFxCount=0;
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);
}
/* Propulsion is presentation, not hull geometry. Fixed-step world history owns
   the emitted path; yaw is used only to transform the authored engine socket.
   The ordnance strip batch supplies two transparent depth-tested cross-sections
   and never creates an opaque core, cone, cylinder, billboard or glow card. */
/* Deprecated diagnostic name retained as an empty table for older evidence
   harnesses. Live aircraft never consult it; resolved mesh sockets are the
   sole propulsion authority. */
const AIR_PROPULSION_PROFILE=Object.freeze({});
const airPropulsionHistoryPath=new Float32Array(24*3);
function queueAirPropulsionFx(unitIndex,x,y,h,yaw,scale,wide,team,profile,throttle,simT,lod,override){
  if(throttle<=.025||typeof mfOrdnanceTrailQueuePath!=='function')return false;
  if(typeof team==='number'&&typeof fogFxVisible==='function'&&!fogFxVisible(x,y,team))return false;
  const P=override||profile;
  if(!P||P.mode==='organic-none')return false;
  /* Legacy special-aircraft callers are normalized once at this boundary. All
     unit meshes use explicit model-owned sockets. */
  const sockets=P.sockets||(P.z||[]).map(z=>({p:[P.x,P.y||0,z],axis:[-1,0,0],diameter:P.w,effect:'trail'}));
  if(!sockets.length)return false;
  /* Budget whole aircraft atomically: never fabricate one centreline emitter
     from a twin/multi-engine model at far LOD. */
  if(airPropulsionFxCount+sockets.length>128&&lod<2)return false;
  airPropulsionFxCount+=sockets.length;
  const pal=typeof mfFactionFxPalette==='function'?mfFactionFxPalette(team):null;
  const col=P.color||(pal&&pal.a)||[118,218,255];
  const flick=.84+.16*Math.sin((simT||0)*17.0+x*.031+y*.019);
  const power=clamp(throttle*flick,.05,1);
  const far=lod<2||orthoSpan>1650;
  let emitted=false;
  for(let k=0;k<sockets.length;k++){
    const S=sockets[k],p=S.p||[0,0,0],axis=S.axis||[-1,0,0],path=airPropulsionHistoryPath;
    const diameter=Math.max(.08,S.diameter||P.w||.5),lift=S.effect==='lift'||axis[1]<-.5;
    const lineLen=diameter*(lift?(far?1.15:1.75):(far?2.4:4.8))*(.55+power*.45);
    let n=0;
    if(Number.isInteger(unitIndex)){
      if(lift&&typeof mfAirPropulsionCurrentLine==='function')
        n=mfAirPropulsionCurrentLine(unitIndex,p[0],p[1],p[2],axis[0],axis[1],axis[2],lineLen,scale,wide||scale,path);
      else if(typeof mfAirPropulsionHistoryRead==='function')
        n=mfAirPropulsionHistoryRead(unitIndex,p[0],p[1],p[2],scale,wide||scale,path);
    }else{
      const ca=Math.cos(yaw),sa=Math.sin(yaw),px=x+p[0]*scale*ca-p[2]*(wide||scale)*sa;
      const py=h+p[1]*scale,pz=y+p[0]*scale*sa+p[2]*(wide||scale)*ca;
      const ax=axis[0]*scale*ca-axis[2]*(wide||scale)*sa;
      const ay=axis[1]*scale,az=axis[0]*scale*sa+axis[2]*(wide||scale)*ca;
      path[0]=px+ax*lineLen;path[1]=py+ay*lineLen;path[2]=pz+az*lineLen;
      path[3]=px;path[4]=py;path[5]=pz;n=2;
    }
    if(n<2)continue;
    /* The strip shader's width is in framebuffer pixels, while the authored
       nozzle is in world units. Converting here keeps the trail mouth the same
       apparent diameter as its engine at every zoom instead of collapsing the
       0.5-world-unit bore into a one-pixel wire. */
    const worldToPx=(typeof VH==='number'&&typeof orthoSpan==='number'&&orthoSpan>0)?VH/orthoSpan:1;
    const boreDpx=diameter*scale*worldToPx*(far?1.12:1);
    /* A simple luminous line: the transparent sheath is only slightly wider
       than the authored bore, while the inner filament remains translucent.
       Width follows each actual thruster instead of an aircraft-class value. */
    /* mfOrdnanceTrailQueuePath receives HALF-widths. A 0.58D sheath renders
       1.16x the modeled bore diameter; the filament is 0.46D. The pixel floor
       keeps distant aircraft legible without making tactical tails uniform. */
    const outerHalf=Math.max(far?.55:.75,boreDpx*.58);
    const innerHalf=Math.max(far?.28:.38,boreDpx*.23);
    const socketCol=S.color||col;
    emitted=mfOrdnanceTrailQueuePath(path,n,outerHalf,innerHalf,socketCol,.14+power*.13)||emitted;
  }
  return emitted;
}
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); }
  if(P.eng&&thrust>0){
    const pts=P.eng.map(v=>v[1]);
    queueAirPropulsionFx(-1,x,y,alt,ang,P.scale||1,P.scale||1,fac,null,thrust,t,2,
      {x:P.eng[0][0],y:3.5,z:pts,len:12,w:1.15,color:P.glow});
  }
}
/* 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;

/* One read-only presentation cull per frame. A large battle previously walked
   unitHigh independently for shadows, tactical icons, meshes, water wakes,
   stance lights, damage, health and rank. Worse, most of those walks repeated
   the same fog query and several repeated terrainH's nine-sample filter. This
   cache owns no gameplay state: it only remembers alive camera candidates,
   their current fog result, and optional visual height for this render call. */
let _mfRuI=new Int32Array(4096), _mfRuFog=new Uint32Array(4096),
    _mfRuH=new Float64Array(4096), _mfRuHMark=new Uint32Array(4096);
let _mfRuN=0, _mfRuSerial=1;
const MF_RENDER_UNIT_CACHE_TELEMETRY={
  frame:0,alive:0,candidates:0,visible:0,fogQueries:0,
  heightQueries:0,heightHits:0,totalHeightQueries:0,totalHeightHits:0
};
if(typeof window!=='undefined') window.MFRenderUnitCacheTelemetry=MF_RENDER_UNIT_CACHE_TELEMETRY;
function mfRenderUnitCacheGrow(n){
  if(_mfRuI.length>=n)return;
  let cap=_mfRuI.length;while(cap<n)cap*=2;
  const ni=new Int32Array(cap),nf=new Uint32Array(cap),nh=new Float64Array(cap),nm=new Uint32Array(cap);
  ni.set(_mfRuI);nf.set(_mfRuFog);nh.set(_mfRuH);nm.set(_mfRuHMark);
  _mfRuI=ni;_mfRuFog=nf;_mfRuH=nh;_mfRuHMark=nm;
}
function mfRenderUnitCacheBegin(vis,pad){
  const n=typeof unitHigh==='number'?unitHigh:0;
  mfRenderUnitCacheGrow(n);
  _mfRuN=0;_mfRuSerial=(_mfRuSerial+1)>>>0;
  if(!_mfRuSerial){_mfRuFog.fill(0);_mfRuHMark.fill(0);_mfRuSerial=1;}
  /* uActive is the simulation-owned dense list of live slot IDs. Reading it
     here changes no authority and avoids revisiting dead high-water slots
     after a long battle. Keep the unitHigh path as the recovery fallback for
     legacy / partial boots where the dense index does not exist yet. */
  const dense=typeof uActiveCount==='number'&&typeof uActive!=='undefined'&&
    uActiveCount>=0&&uActiveCount<=uActive.length;
  const scanN=dense?uActiveCount:n;
  let alive=0,visible=0,fogQueries=0,selected=0;
  for(let rk=0;rk<scanN;rk++){
    const i=dense?uActive[rk]:rk;
    if(!ualive[i])continue;
    alive++;
    const X=ux[i],Y=uy[i];
    if(!vis(X,Y,pad))continue;
    _mfRuI[_mfRuN++]=i;
    /* Selection rings intentionally do not consult fog; count before its gate
       to preserve the existing selected-army collapse behaviour exactly. */
    if(usel[i]&&vis(X,Y,40))selected++;
    fogQueries++;
    if(fogEntityVisible(uteam[i],X,Y)){_mfRuFog[i]=_mfRuSerial;visible++;}
  }
  const M=MF_RENDER_UNIT_CACHE_TELEMETRY;
  M.frame++;M.alive=alive;M.candidates=_mfRuN;M.visible=visible;M.fogQueries=fogQueries;
  M.slotsVisited=scanN;M.slotHighWater=n;M.denseSource=dense;
  M.heightQueries=0;M.heightHits=0;
  return selected;
}
function mfRenderUnitFogVisible(i){return _mfRuFog[i]===_mfRuSerial;}
function mfRenderUnitHeight(i,T,x,y){
  const M=MF_RENDER_UNIT_CACHE_TELEMETRY;
  if(_mfRuHMark[i]===_mfRuSerial){M.heightHits++;M.totalHeightHits++;return _mfRuH[i];}
  const h=unitGroundY(T,x,y,i);
  _mfRuH[i]=h;_mfRuHMark[i]=_mfRuSerial;M.heightQueries++;M.totalHeightQueries++;
  return h;
}

/* Dense presentation index for the legacy CPU particle ring. The simulation
   owns flife/fCount and still ages every slot; this cache only decides which
   live slots the renderer visits. New ring writes are discovered from fHead,
   expired entries are compacted, and fCount is an exact reconciliation guard:
   any missed transition falls back to one full rebuild rather than hiding FX.
   Thus HIGH keeps every authored particle while quiet frames stop testing all
   9000 addresses. */
let _mfFpI=new Int32Array(MAXPART),_mfFpPos=new Int32Array(MAXPART),
    _mfFpBits=new Uint32Array((MAXPART+31)>>5),
    _mfFpN=0,_mfFpHead=-1,_mfFpReady=false;
_mfFpPos.fill(-1);
const MF_RENDER_PARTICLE_CACHE_TELEMETRY={
  frames:0,live:0,candidates:0,lastSlotsTested:0,totalSlotsTested:0,
  lastOrderWords:0,totalOrderWords:0,fullScans:0,reconciles:0,headWrites:0
};
if(typeof window!=='undefined')window.MFRenderParticleCacheTelemetry=MF_RENDER_PARTICLE_CACHE_TELEMETRY;
function mfRenderParticleBitSet(i){_mfFpBits[i>>>5]|=1<<(i&31);}
function mfRenderParticleBitClear(i){_mfFpBits[i>>>5]&=~(1<<(i&31));}
function mfRenderParticleBitHas(i){return !!(_mfFpBits[i>>>5]&(1<<(i&31)));}
function mfRenderParticleCacheClear(){
  for(let k=0;k<_mfFpN;k++)_mfFpPos[_mfFpI[k]]=-1;
  _mfFpBits.fill(0);_mfFpN=0;
}
function mfRenderParticleCacheRebuild(reconcile){
  mfRenderParticleCacheClear();
  for(let i=0;i<MAXPART;i++)if(flife[i]>0){
    mfRenderParticleBitSet(i);_mfFpPos[i]=_mfFpN;_mfFpI[_mfFpN++]=i;
  }
  _mfFpHead=fHead;_mfFpReady=true;
  MF_RENDER_PARTICLE_CACHE_TELEMETRY.fullScans++;
  if(reconcile)MF_RENDER_PARTICLE_CACHE_TELEMETRY.reconciles++;
  return MAXPART;
}
/* Legacy HIGH visited slot 0..8999, which is also alpha-blend order for smoke.
   Stable append order diverges after fHead wraps. Enumerate a 282-word live
   bitset to restore that exact numeric order without testing 9000 flife slots. */
function mfRenderParticleCacheOrder(){
  let n=0;
  for(let w=0;w<_mfFpBits.length;w++){
    let bits=_mfFpBits[w]>>>0;
    while(bits){
      const one=bits&-bits,bit=31-Math.clz32(one),i=(w<<5)+bit;
      if(i<MAXPART){_mfFpI[n]=i;_mfFpPos[i]=n++;}
      bits=(bits&(bits-1))>>>0;
    }
  }
  _mfFpN=n;
  return _mfFpBits.length;
}
function mfRenderParticleCacheInvalidate(){_mfFpReady=false;}
function mfRenderParticleCacheBegin(){
  const M=MF_RENDER_PARTICLE_CACHE_TELEMETRY,live=Math.max(0,Math.min(MAXPART,fCount|0));
  M.frames++;M.live=live;
  if(!live){
    mfRenderParticleCacheClear();_mfFpHead=fHead;_mfFpReady=true;
    M.candidates=0;M.lastSlotsTested=0;M.lastOrderWords=0;return 0;
  }
  let tested=0,orderWords=0,rebuild=false;
  if(!_mfFpReady||_mfFpHead<0||_mfFpHead>=MAXPART)tested=mfRenderParticleCacheRebuild(false);
  else{
    /* Stable compaction keeps membership dense until the bitset restores the
       legacy numeric presentation order below. */
    let w=0;
    for(let k=0;k<_mfFpN;k++){
      const i=_mfFpI[k];tested++;
      if(flife[i]>0){_mfFpI[w]=i;_mfFpPos[i]=w++;}
      else{_mfFpPos[i]=-1;mfRenderParticleBitClear(i);}
    }
    _mfFpN=w;
    let i=_mfFpHead,writes=0;
    while(i!==fHead&&writes<MAXPART){
      tested++;writes++;
      if(flife[i]>0&&!mfRenderParticleBitHas(i)){
        mfRenderParticleBitSet(i);_mfFpPos[i]=_mfFpN;_mfFpI[_mfFpN++]=i;
      }
      i=(i+1)%MAXPART;
    }
    _mfFpHead=fHead;M.headWrites+=writes;
    /* fCount is maintained at the same spawn/expiry sites as flife. A count
       mismatch proves the incremental view missed something (reset, wrap, or
       recovery), so correctness wins and the bounded full scan repairs it. */
    if(_mfFpN!==live){tested+=mfRenderParticleCacheRebuild(true);rebuild=true;}
    if(!rebuild)orderWords=mfRenderParticleCacheOrder();
  }
  M.candidates=_mfFpN;M.lastSlotsTested=tested;M.totalSlotsTested+=tested;
  M.lastOrderWords=orderWords;M.totalOrderWords+=orderWords;
  return _mfFpN;
}

function unitGroundY(T,x,y,i){
  if(T.air){
    const alt=(i!=null&&typeof unitAirAlt==='function')?unitAirAlt(i):58;
    return terrainH(x,y)+alt;
  }
  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;
    /* 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 rk=0;rk<_mfRuN;rk++){
    const i=_mfRuI[rk];if(mfRenderUnitFogVisible(i)&&(usel[i]||i===heroIdx))push(i);
  }
  for(let rk=0;rk<_mfRuN;rk++){
    const i=_mfRuI[rk];if(mfRenderUnitFogVisible(i)&&!usel[i]&&i!==heroIdx)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){
  /* One delayed timer-query scope captures the actual battle renderer without
     synchronizing the driver. It is dormant outside ?mfperf=1 and gives the
     governor a GPU signal distinct from JavaScript submission time. */
  if(typeof mfPerfBegin==='function'){ mfPerfBegin('render');mfPerfGpuBegin('render'); }
  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');
  /* Pin while placing too. startPlacing() hides #buildMenu, so without this the
     overlay would fade out over ~2s exactly as the player starts aiming — the
     same failure the removed `&&!placing` guard caused, just slower. */
  if(buildCatalogueOpen||placing) 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;
  airPropulsionFxCount=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);
  /* COLOR_ATTACHMENT1 is the optional R8 authored-window mask. gl.clear above
     necessarily used the scene fog colour for every active MRT; zero it before
     the first opaque draw so only window shader outputs can opt into the halo. */
  if(aoActive&&typeof aoWindowMaskClear==='function') aoWindowMaskClear();
  /* Portrait takeover in main.js disables this — AABB scissor left fog strips. */
  if(typeof mfGfxScissor==='function') mfGfxScissor(true);

  begin3D(S_nA,MF_BEGIN3D_OPAQUE_STATE);

  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. */
  if(typeof mfPerfBegin==='function')mfPerfBegin('renderCull');
  /* 220 wu is a conservative superset for every unit presentation pass,
     including long cast shadows. Individual passes retain their tighter
     bounds; the cache only prevents off-camera armies being reconsidered. */
  const selOnCam=mfRenderUnitCacheBegin(vis,220);
  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,_mfRuI,_mfRuN,mfRenderUnitFogVisible);
  if(typeof mfPerfEnd==='function')mfPerfEnd('renderCull');

  /* ---------------- 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 mfPerfBegin==='function')mfPerfBegin('renderTerrain');
  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;
  const _rn=(typeof terrGroundNrm!=='undefined')&&terrGroundNrm&&terrSoilNrm&&terrPaveNrm&&terrGrassNrm;
  /* Albedo and packed normal/roughness commit as one material set. Sampling a
     model-atlas normal for even one staggered decode frame was the chaotic
     terrain flash reported on mobile. */
  const _ready=typeof mfTerrainMaterialsReady==='function'?mfTerrainMaterialsReady():!!(_rt&&_rn);
  const _neutral=(typeof mfTerrainNeutralNormal==='function'&&mfTerrainNeutralNormal())||matNrmTex;
  gl.activeTexture(gl.TEXTURE8); gl.bindTexture(gl.TEXTURE_2D,_ready?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,_ready?terrSoilTex:matTex);
  gl.activeTexture(gl.TEXTURE12); gl.bindTexture(gl.TEXTURE_2D,_ready?terrPaveTex:matTex);
  gl.activeTexture(gl.TEXTURE13); gl.bindTexture(gl.TEXTURE_2D,_ready?terrGrassTex:matTex);
  gl.activeTexture(gl.TEXTURE2); gl.bindTexture(gl.TEXTURE_2D,_ready?terrGroundNrm:_neutral);
  gl.activeTexture(gl.TEXTURE3); gl.bindTexture(gl.TEXTURE_2D,_ready?terrSoilNrm:_neutral);
  gl.activeTexture(gl.TEXTURE14); gl.bindTexture(gl.TEXTURE_2D,_ready?terrPaveNrm:_neutral);
  gl.activeTexture(gl.TEXTURE15); gl.bindTexture(gl.TEXTURE_2D,_ready?terrGrassNrm:_neutral);
  gl.activeTexture(gl.TEXTURE0);
  gl.uniform1f(UT.uRealTex,_ready?1:0);
  if(UT.uGroundQ){
    const q=typeof mfGfxKey==='function'?mfGfxKey():(typeof qualityKey==='function'?qualityKey():'high');
    const gq=(typeof GFX!=='undefined'&&GFX&&Number.isFinite(+GFX.groundQ))?+GFX.groundQ:
      (q==='low'?0:q==='medium'?1:q==='cinematic'?3:2);
    gl.uniform1f(UT.uGroundQ,gq);
  }
  if(typeof mfTerrainThemeTints==='function'){
    const tt=mfTerrainThemeTints();
    if(UT.uGroundTint)gl.uniform3fv(UT.uGroundTint,tt.ground);
    if(UT.uSoilTint)gl.uniform3fv(UT.uSoilTint,tt.soil);
    if(UT.uPaveTint)gl.uniform3fv(UT.uPaveTint,tt.pave);
    if(UT.uGrassTint)gl.uniform3fv(UT.uGrassTint,tt.grass);
  }
  if(typeof mfTerrainLocationProfile==='function'){
    const lp=mfTerrainLocationProfile();
    if(UT.uGroundProfile)gl.uniform1f(UT.uGroundProfile,lp.id);
    if(UT.uLocationTint)gl.uniform3fv(UT.uLocationTint,lp.tint);
  }
  {
    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 mfPerfEnd==='function')mfPerfEnd('renderTerrain');
  if(typeof mfPerfBegin==='function')mfPerfBegin('renderWorld');
  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;
  const floraSprite=k=>(typeof sprites!=='undefined'&&(k==='pine'?sprites.treePine:k==='palm'?sprites.treePalm:
    k==='dead'?sprites.treeDead:k==='spore'?sprites.treeSpore:sprites.tree))||(typeof sprites!=='undefined'&&sprites.tree)||null;
  const rockSprite=k=>(typeof sprites!=='undefined'&&(k==='ice'?sprites.rockIce:k==='slag'?sprites.rockSlag:sprites.rock))||(typeof sprites!=='undefined'&&sprites.rock)||null;

  const ROCK_BB_D=typeof mfLodSpan==='function'?mfLodSpan(650):650;
  const rockBBd2=ROCK_BB_D*ROCK_BB_D;
  for(let ri=0;ri<rocks.length;ri++){
    const r=rocks[ri];
    if(!vis(r.x,r.y,40)||!fogPointVisible(r.x,r.y)) continue;
    const dx2=r.x-cam.x, dy2=r.y-cam.y;
    const farRock=(dx2*dx2+dy2*dy2)>rockBBd2;
    const sprR=rockSprite(r.k);
    if(farRock&&sprR){
      const sz=r.s*0.85;
      bbAlpha.add(sprR,r.x,r.y,gh(r.x,r.y)+sz*0.35,sz,r.a,rockTint[0],rockTint[1],rockTint[2],255);
    } else {
      if(sceneryStep>1&&(ri%sceneryStep)) 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];
  /* TREE LOD — impostor billboards past a distance band.
     Every tree was an instanced 3D mesh at every range. Distant trees draw as
     ONE camera-facing quad from the species billboard atlas cell. */
  const TREE_BB_D=typeof mfLodSpan==='function'?mfLodSpan(760):760;
  const treeBBd2=TREE_BB_D*TREE_BB_D;
  for(let ti=0;ti<trees.length;ti++){
    const tr=trees[ti];
    if(!vis(tr.x,tr.y,50)||!fogPointVisible(tr.x,tr.y)) continue;
    const dx2=tr.x-cam.x, dy2=tr.y-cam.y;
    const far=(dx2*dx2+dy2*dy2)>treeBBd2;
    const spr=floraSprite(tr.k);
    if(far&&spr){
      /* Quad is sized to match 3D mesh silhouette. Lifted half its height so
         the quad sits on ground rather than through it. */
      const hgt=tr.s*0.92;
      bbAlpha.add(spr,tr.x,tr.y,gh(tr.x,tr.y)+hgt*0.5,hgt,tr.a,tt[0],tt[1],tt[2],255);
    } else {
      if(sceneryStep>1&&(ti%sceneryStep)) 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);
    }
  }
  const BUSH_BB_D=typeof mfLodSpan==='function'?mfLodSpan(520):520;
  const bushBBd2=BUSH_BB_D*BUSH_BB_D;
  const bbBush=(typeof sprites!=='undefined'&&sprites.bush)||null;
  if(typeof cover!=='undefined'&&FX.bush) for(let ci=0;ci<cover.length;ci++){
    const b=cover[ci];
    if(!vis(b.x,b.y,36)||!fogPointVisible(b.x,b.y)) continue;
    const dx2=b.x-cam.x, dy2=b.y-cam.y;
    const farBush=(dx2*dx2+dy2*dy2)>bushBBd2;
    if(farBush&&bbBush){
      const hgt=b.s*0.75;
      bbAlpha.add(bbBush,b.x,b.y,gh(b.x,b.y)+hgt*0.35,hgt,b.a,ct[0],ct[1],ct[2],255);
    } else {
      if(sceneryStep>1&&(ci%sceneryStep)) 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,140))continue;
    /* Occupied pad: the extractor owns the node. Drawing the shard cluster
       plus additive glows under a mex stacked into the white bloom discs. */
    if(D.taken)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?.090:.074)*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 only. Standing glow pools under every shard — and a
       deploy floor of 0.9 while matchLive is false — were the white disc
       on DEPLOY BASE. The CRYST mesh plus terrain cracks carry identity. */
    const glowQ=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, 70*f*glowQ);
      }
    }
  }
  /* Mass nodes are the glowing shard cluster, tinted by depletion band.
     Brown habit tints turned the bed into dirt plates and fought the CRYST
     spikes. Kit energy habit still owns geysers. */
  const enHabit=(BK&&BK.energy)||'vent';
  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,180)||!fogPointVisible(D.x,D.y)) continue;
    /* stampCrystalVeins() was reduced to `return;` when the free-node vein
       ribbons turned into the white bloom disc, but its four arguments were
       still built here every frame for every visible node: a fresh colour
       array, a sin(), a terrainH() sample and a radius, all discarded on the
       callee's first line. Deleted — nothing here painted a pixel.
       depositTier(D) STAYS: despite the name it writes D.tier and D.depleted
       (sim.js:1971), so it is not a pure read and this loop is the refresh for
       every node the camera can see. */
    depositTier(D);
  }
  for(const G of geysers){ if(!vis(G.x,G.y,180)||!fogPointVisible(G.x,G.y)) continue;
    const tier=typeof geyserTier==='function'?geyserTier(G):(G.taken?2:3);
    const pc=tier?enCol:[83,82,78];
    /* Mesh stays rock. Cyan habit on the whole instance made the cairn a
       painted metal hatch. Steam billboard carries the energy colour. */
    const rock=enHabit==='frost'?[168,176,184]:enHabit==='heat'?[118,88,72]:
      enHabit==='spore'?[96,78,82]:[112,104,92];
    const pulse=.72+.28*Math.sin(t*2.6+(G.pulse||G.x*.01)),H=gh(G.x,G.y);
    if(FX.geyser) FX.geyser.add(G.x,G.y,H,1.48+tier*.10,0,rock[0],rock[1],rock[2],tier?(G.taken?205:255):145);
    if(tier&&qDraw!=='low'){
      bbAdd.add(sprites.glow,G.x,G.y,H+28,(16+tier*3)*pulse,0,pc[0],pc[1],pc[2],G.taken?22:36);
    }
  }
  // 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));
    /* A falling aircraft keeps its normal reclaimable scrap record, but the
       stock wreck mesh has a pale rectangular cap that read as a spawned cube
       beside the crash. One dark faceted slab is static aftermath—not a fourth
       transient layer—and preserves the same salvage position, value and fog. */
    const crashSlab=W.style==='aircrash'&&FX.shard;
    const c = crashSlab ? [46,48,50]           // charred aircraft skin
            : W.kind===5 ? [206,190,150]       // biomass — bone-pale carcass
            : W.kind===2 ? [172,166,158]       // city ruin — dusty concrete
            : [72,82,94];                      // scrap — cold, dark oxidised alloy
    const mesh=crashSlab?FX.shard:FX.wreck;
    const scale=crashSlab?W.s*.40*f:W.s*.045*f*(W.kind===5?0.8:1);
    mesh.add(W.x,W.y,gh(W.x,W.y),scale,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. */
    /* terrainH is a deterministic presentation sample within this frame.
       Relics used to repeat its nine-sample filter three or four times. */
    const relicH=gh(R.x,R.y);
    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,relicH,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,relicH,rLod))
      mesh.add(R.x,R.y,relicH,sc*(R.kind===0?0.9:1),wreckYaw,tint,tint-6,tint-16,255);
    if(FX.decal) FX.decal.add(R.x,R.y,relicH+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,relicH+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);
    const workProfile=typeof mfBuildingWorkProfile==='function'?mfBuildingWorkProfile(Bd):null;
    /* 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);
    /* Work motion follows simulation time. Ambient faction motion may continue
       while paused, but construction/production/upgrade progress never does. */
    const workClock=typeof stats!=='undefined'&&Number.isFinite(stats.t)?stats.t:t;
    const workAn=workClock*(workProfile&&workProfile.pulseSpeed>0?workProfile.pulseSpeed: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&&!Bd.prodStalled){ bob=Math.sin(workAn*3.6)*0.8; em=0.03+Math.abs(Math.sin(workAn*4))*0.04; } break;
      case 'fab':  em=0.08+Math.abs(Math.sin(an*5.2))*0.10; break;
      case 'techlab': em=Bd.res>=0&&!Bd.researchStalled?0.04+Math.abs(Math.sin(workAn*2.2))*0.07:0.015; 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;
      if(Bd.type!=='mex') 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;
      if(Bd.type!=='mex') em+=0.025+Math.abs(Math.sin(an*2.8))*0.035;
    }
    /* Construction replaces ambient motion with one restrained paid-work
       pulse; a stalled site stays still. Completed upgrades add a smaller
       sim-clock pulse without inventing particles or changing geometry. */
    if(Bd.prog<1){bob=0;sq=1;em=Bd.buildStalled?0:0.035+Math.abs(Math.sin(workAn*3.1))*0.055;}
    else if(Bd.upT>0){bob+=Math.sin(workAn*2.8)*0.18;em+=0.055+Math.abs(Math.sin(workAn*3.7))*0.085;}
    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. */
    /* Brood foundations already own an irregular living contact edge in the
       terrain's organic mask. The shared square spoil berm is engineered
       hardscape language; drawing it here boxed the creep back into a pad. */
    if(FX.skirt&&fac!=='horde'&&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,Bd.gunPitch||0);
    }
    /* Charge readability is world-space and state-driven. It does not advance
       here: paused rendering can redraw these meshes forever without changing
       chargeProgress. The two restrained rings expose containment/load state
       from tactical altitude without turning every powerful gun into a spray. */
    if(!wreck&&Bd.prog>=1&&Bd.chargeState&&Bd.chargeState!=='idle'&&Bd.chargeState!=='cooldown'){
      const q=clamp(Bd.chargeProgress||0,0,1),interrupted=Bd.chargeState==='interrupted';
      const cc=interrupted?[255,72,58]:Bd.type==='stormcaller'?[255,188,66]:[92,218,255];
      const pulse=.82+.18*Math.sin(t*(interrupted?11:5.5)+(Bd.anim||0));
      FX.ring.add(Bd.x,Bd.y,H+2,(Bd.r||20)*(1.05+q*.34),t*(.42+q*.48),cc[0],cc[1],cc[2],(80+125*q)*pulse);
      FX.ring.add(Bd.x,Bd.y,H+3,(Bd.r||20)*(.55+q*.22),-t*(.72+q*.65),255,235,190,(48+105*q)*pulse);
      if(Bd.chargeState==='committed')
        FX.cone.add(Bd.x,Bd.y,H+(M.turH||14)*grow*.72,6+q*8,t*.7,cc[0],cc[1],cc[2],72*pulse);
    }
    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);
  /* MEDIUM has no CSM restore. Icon-ensure / doodad uploads can steal
     unit 0 mid-loop; structures sample uMat there. Always re-bind the
     model atlas before the world flush. */
  begin3D(S_nA);
  flushBuildingSet(BLD_MESH);
  if(typeof BLD_FACTION_MESH!=='undefined') for(const fac in BLD_FACTION_MESH){
    if(!Object.prototype.hasOwnProperty.call(BLD_FACTION_MESH,fac))continue;
    flushBuildingSet(BLD_FACTION_MESH[fac]);
  }
  /* 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);
    }
  }

  if(typeof mfPerfEnd==='function')mfPerfEnd('renderWorld');
  // ---------------- units ----------------
  if(typeof mfOrdnanceTrailResetTelemetry==='function')mfOrdnanceTrailResetTelemetry();
  if(typeof mfPerfBegin==='function')mfPerfBegin('renderUnits');
  if(typeof mfPerfBegin==='function')mfPerfBegin('renderUnitPrepare');
  if(typeof mfBroodCrowdBeginFrame==='function')
    mfBroodCrowdBeginFrame(t,orthoSpan,perfScale,typeof diffLvl==='function'?diffLvl():1);
  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():[];
  const ownFac=(typeof playerFaction!=='undefined'&&playerFaction)||'nova';
  const ownKit=(typeof playerKitKey==='function')?playerKitKey():
    ((typeof FACTIONS!=='undefined'&&FACTIONS[ownFac]&&FACTIONS[ownFac].kit)||'nova');
  const enemyKit=(typeof AI!=='undefined'&&AI.fac&&typeof FACTIONS!=='undefined'&&FACTIONS[AI.fac])?FACTIONS[AI.fac].kit:null;
  for(let rk=0;rk<_mfRuN;rk++){
    const i=_mfRuI[rk];
    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(!mfRenderUnitFogVisible(i)) 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 unitKit=uteam[i]===0?ownKit:uteam[i]===2?'horde':
      (uteam[i]===1?enemyKit: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;
    /* Cosmetic Brood density is anchored only after camera + fog approval and
       after the faction kit resolves. It is not a unit and receives no sim,
       selection, targeting, pathing, save or network identity. Cache height
       only for an eligible Brood anchor; ordinary strategic icons retain the
       old zero-height-query fast path. */
    let broodCrowdH;
    if(unitKit==='horde'&&typeof mfBroodCrowdQueue==='function'){
      broodCrowdH=mfRenderUnitHeight(i,T,X,Y);
      mfBroodCrowdQueue(i,utype[i],X,Y,broodCrowdH,uang[i]-Math.PI/2,T,
        TEAMC[uteam[i]],uLod,uIcon,!!umov[i],true);
    }
    /* 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=(broodCrowdH===undefined?mfRenderUnitHeight(i,T,X,Y):broodCrowdH)+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);
      }
      /* Audit fix #9 — unit ambience at zoom. A full-icon army is static rows
         of plates; a slow shared-breath shimmer (one clock, no per-unit state,
         ±6% alpha around the ramp value) reads as a living force from orbit
         while costing zero extra instances. Idles only: a marching army
         already has motion, and shimmering it would read as flicker. */
      if(!umov[i]){
        const simT=(typeof stats!=='undefined'&&Number.isFinite(stats.t))?stats.t:0;
        const breath=Math.sin(simT*1.7+(i%16)*0.42)*0.5+0.5;
        ia=(255*(uMark*(0.94+0.12*breath)))|0;
      }
      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=broodCrowdH===undefined?mfRenderUnitHeight(i,T,X,Y):broodCrowdH;
    /* 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 crashing=T.air&&typeof uCrash!=='undefined'&&uCrash[i];
    /* Attitude is presentation only. Sim owns uAirBank/uAirPitch and crash
       uCroll/uCpitch. Folding bank into yaw was a decorative sine wobble
       that also flattened crash pitch into heading; do not add either to yaw. */
    const hullYaw=uang[i]-Math.PI/2;
    const airPitch=T.air?(crashing?(typeof uCpitch!=='undefined'?uCpitch[i]:0)
      :(typeof uAirPitch!=='undefined'?uAirPitch[i]:0)):0;
    const airRoll=T.air?(crashing?(typeof uCroll!=='undefined'?uCroll[i]:0)
      :(typeof uAirBank!=='undefined'?uAirBank[i]:0)):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 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. */
    /* Mechanical aircraft reserve profile 4. The shared material shader uses
       it only to expose critical panel soot and hot fracture lines; geometry,
       team paint and healthy aircraft remain unchanged. */
    const surfaceState=(heroUnit?2:(T.air&&!organic?8:0))+damageState;
    M.hull.add(X,Y,H,ss,hullYaw,tc[0],tc[1],tc[2],a,wide,anim,surfaceState,airPitch,airRoll);
    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,ugunPitch[i]||0);
    if(T.air){
      let thrust=crashing?.10:(umov[i]?.82:.26);
      if(damageState>.65)thrust*=.72;
      if(damageState>.82)thrust*=.35+.35*(.5+.5*Math.sin(t*23+i*2.17));
      queueAirPropulsionFx(i,X,Y,H,hullYaw,ss,wide,uteam[i],M.propulsion,thrust,t,uLod);
    }
    csmMarkUnitSkin(M,T,heroUnit,X,Y);
    if(doctrine) doctrine.add(X,Y,H,ss,hullYaw,tc[0],tc[1],tc[2],a,wide,undefined,surfaceState,airPitch,airRoll);
    /* 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+(mountH+K.h)*ss,gearScale,hullYaw,
               K.col[0],K.col[1],K.col[2],a,heroUnit?gearScale:wide,anim,0,airPitch,airRoll);
      }
    }
  }
  if(typeof mfIconStackDraw==='function') mfIconStackDraw(gh);
  if(typeof mfPerfEnd==='function')mfPerfEnd('renderUnitPrepare');
  if(typeof mfPerfBegin==='function')mfPerfBegin('renderUnitSubmit');
  if(typeof csmBegin==='function'&&typeof csmActive==='function'&&csmActive()&&csmBegin(false)){
    csmDrawUnitCasters();
    csmDrawModuleCasters();
    csmEnd(S_nA);
  }
  begin3D(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 mfBroodCrowdFlush==='function') mfBroodCrowdFlush();
  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);
  }
  if(typeof mfPerfEnd==='function')mfPerfEnd('renderUnitSubmit');
  if(typeof mfPerfEnd==='function')mfPerfEnd('renderUnits');
  if(typeof mfPerfBegin==='function')mfPerfBegin('renderGroundOverlays');
  /* Opaque depth is now complete. Freeze the selective window mask before
     decals, shields, volumes and water so none of those layers can enter it. */
  if(aoActive&&typeof aoWindowMaskSeal==='function') aoWindowMaskSeal();

  /* ---------------- 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);
  }
  /* Window colour is captured from the resolved opaque scene. Waiting for the
     ordinary bright-pass would let a shield or explosion crossing a pane tint
     the authored window halo, even though those effects never wrote its mask. */
  if(aoActive&&typeof aoExtractWindowBloom==='function') aoExtractWindowBloom();

  // ---------------- 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 rk=0;rk<_mfRuN;rk++){
        const i=_mfRuI[rk];
        if(!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 rk=0;rk<_mfRuN;rk++){
        const i=_mfRuI[rk];
        if(!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 rk=0;rk<_mfRuN;rk++){
        const i=_mfRuI[rk];
        if(!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 rk=0;rk<_mfRuN;rk++){
        const i=_mfRuI[rk];
        if(!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));
          /* Chevrons, not rings. A ring travelling down a line tells you the
             route is live but not which way the column is going; on a closed
             patrol loop that is the only question worth answering. Two short
             arms swept back from a moving tip read as an arrowhead at command
             zoom without needing a sprite or a glyph atlas. */
          const ang=Math.atan2(dy,dx);
          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))continue;
            const ph=gh(px3,py3)+3.7,arm=active?5.4:3.9,aw=active?2.6:1.9;
            const aa=active?215:145;
            for(const sgn of [1,-1]){
              const a2=ang+sgn*2.44;                     // ~140 deg swept back
              const ex=px3+Math.cos(a2)*arm, ey=py3+Math.sin(a2)*arm;
              FX.line.add((px3+ex)*.5,(py3+ey)*.5,ph,arm,a2,col[0],col[1],col[2],aa,aw);
            }
          }
        }
      }
      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);
    }
    /* RALLY FLAGS. The sprite path drew these (hud.js:900) but that whole
       renderer is dead code, so a rally point was invisible in every shipped
       build even though the panel button reported "RALLY SET — TAP TO MOVE".
       Ground decals, so they inherit depth and survive camera tilt. */
    for(const Bd of blds){
      if(!Bd.alive||!(typeof mfLocalOwnsBuilding==='function'?mfLocalOwnsBuilding(Bd):Bd.team===0)||!Bd.rally)continue;
      const R2=Bd.rally;
      if(!vis(R2.x,R2.y,40))continue;
      const rh=gh(R2.x,R2.y),rp=0.55+0.45*Math.sin(t*3.1+R2.x*0.01);
      FX.ring.add(R2.x,R2.y,rh+3.4,7.4+rp*1.6,t*0.5,120,255,170,195);
      FX.ring.add(R2.x,R2.y,rh+3.0,12.6,-t*0.28,120,255,170,80);
      bbAdd.add(sprites.glow,R2.x,R2.y,rh+7,7+rp*2,0,120,255,170,62);
      /* Line back to its factory only while that factory's panel is open —
         the same rule the sprite path used, so ten factories do not draw ten
         permanent leashes across the base. */
      if(openBld>=0&&blds[openBld]===Bd){
        const mx=(Bd.x+R2.x)*.5,my=(Bd.y+R2.y)*.5;
        const rl=Math.hypot(R2.x-Bd.x,R2.y-Bd.y);
        if(rl>6)FX.line.add(mx,my,gh(mx,my)+3.0,rl,Math.atan2(R2.y-Bd.y,R2.x-Bd.x),120,255,170,72,2.2);
      }
    }
    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);
  }
  /* Techlab guard/shield feedback is owned by shieldfx.js. Keeping the two
     legacy rings here would turn one field source into three presentations. */
  /* 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. */
  /* The `&&!placing` that used to be here hid the whole territory overlay the
     instant the player picked up a ghost — i.e. exactly when "where may I
     build?" is the only question being asked. The comment justifying it said
     the placement UI already draws the local grid and invalid cells "in
     hud.js"; that code lives inside renderLegacySprites, which is called from
     nowhere (only a test touches it via .toString()). So the justification was
     void and the player got only the ghost outline. Keep the zone up while
     placing — it is the whole point of it. */
  if(bzShow>0){
    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];
    /* The outline is the player's reservation contract. Alternate-faction
       families can grow beyond Nova's base footprint, so draw the same
       max-tier envelope placementValid() and addBld() reserve. */
    const f=typeof mfReservedPlacementFoot==='function'?mfReservedPlacementFoot(placing.type)
      :bldFoot(placing.type,typeof playerKitKey==='function'?playerKitKey():'nova');
    const ok=placementValid(), 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);


  if(typeof mfPerfEnd==='function')mfPerfEnd('renderGroundOverlays');
  // ---------------- 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);
  /* One instanced shield surface per source plus bounded contact ripples.
     This sits after opaque depth is complete and before bloom extraction, so
     fields intersect terrain/buildings correctly and retain their bright rim. */
  if(typeof mfPerfBegin==='function') mfPerfBegin('shieldsShockwaves');
  if(typeof shieldFxTick==='function') shieldFxTick(dtDraw);
  if(typeof shieldFxDraw==='function') shieldFxDraw(S_nA,t);
  if(typeof mfShockwaveDraw==='function') mfShockwaveDraw(S_nA,vis);
  if(typeof mfPerfEnd==='function') mfPerfEnd('shieldsShockwaves');
  /* VOLUMETRICS. This is the LAST point in the frame where a pass can still
     reach the bright pass: aoExtractBloom() is the very next line, and
     everything after it (water, the additive block, billboards, gpufx) is
     invisible to bloom — the same reasoning already recorded further down
     this file. A fireball with no bloom in an RGBA8 buffer is a flat orange
     blob, so the raymarch composites HERE. Depth is complete (opaques, CSM,
     units and modules all flushed; the decals above write no depth), AO is
     already resolved, and the scissor rect is off as of the line above.
     volFxDraw restores blend-off / depth-on / depthMask-true / cull-on and
     leaves aoFB2 + aoDepth bound at aoW x aoH exactly as it found them.
     Inert unless GFX volSteps>0 and the offscreen path is up; the sprite
     smoke path is the fallback and is untouched. */
  /* CALLED EVERY FRAME, INCLUDING FRAMES THAT CANNOT COMPOSITE. aoActive is
     passed as the can-present flag instead of gating the call, because
     volFxDraw owns the presentation bits that suppress the armed flipbook: if
     it is skipped entirely on an aoBeginScene()==false frame, the bits from
     the last composited frame survive and suppress the fallback too, so the
     detonation renders as NOTHING. The maintenance path clears them and
     returns before touching any GL state. */
  if(typeof mfPerfBegin==='function') mfPerfBegin('volumes');
  if(typeof volFxDraw==='function') volFxDraw(dtDraw,Sun,!!aoActive);
  if(typeof mfPerfEnd==='function') mfPerfEnd('volumes');
  if(aoActive&&typeof aoExtractBloom==='function'){
    if(typeof mfPerfBegin==='function') mfPerfBegin('bloomExtract');
    aoExtractBloom();
    if(typeof mfPerfEnd==='function') mfPerfEnd('bloomExtract');
  }
  if(waterIdxCount){
    if(typeof mfPerfBegin==='function') mfPerfBegin('water');
    /* A low-FPS render may observe the same divisible-by-four sim tick for
       several frames. Animate the water mesh once for that tick, not once per
       render, or its full vertex upload repeats until authority advances. */
    if((tick&3)===0&&mfWaterAnimTick!==tick){mfWaterAnimTick=tick;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);
    if(typeof mfPerfEnd==='function') mfPerfEnd('water');
  }

  // ================= ADDITIVE EFFECTS =================
  if(typeof mfPerfBegin==='function')mfPerfBegin('renderAdditiveEffects');
  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.  These are collectibles, never impacts: the opaque FX.crate mesh
     above remains the pickup itself.  This pass is deliberately limited to
     one small elevated badge and one compact cool locator ring.  The former
     ground glow plus one/two large flat rings read as a black-hot blast crater
     in the top-down camera (and a site cache made that silhouette even
     larger).  Do not substitute a damage FX, crater, burn, shockwave, or
     resource-node sprite here. */
  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 rarity=clamp(k.rarity||0,0,4);
    /* `depR` and `glow` are large radial field art.  They are
       appropriate for deposits/abilities but not for a crate badge, where
       their soft black centres visually fuse with the terrain into a crater.
       A small crate glyph says “collect” at normal zoom; top rarities use a
       crystal only to distinguish value, not to add an effect layer. */
    const mark=rarity>=3&&sprites.crystal?sprites.crystal:sprites.crate;
    bbAdd.add(mark,Cc.x,Cc.y,H+38+bob*.55,10.5+rarity*1.05,-t*.34,
      cc[0],cc[1],cc[2],215);
    /* The crate mesh is 21.6×21 world units.  Keep this non-animated locator
       only 27% outside that footprint; it is a cool cyan collect prompt, not
       an expanding pressure wave.  One ring applies to every landed cache,
       including site caches—never a second site halo or a warm rarity tint. */
    const locatorRadius=10.8*(1+rarity*.08)*1.27;
    FX.ring.add(Cc.x,Cc.y,H+1.45,locatorRadius,0,92,230,255,118);
  }

  /* 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;
  if(typeof mfIconFireCueBegin==='function')mfIconFireCueBegin();
  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;
    const X=px[i], Y=py[i];
    if(!vis(X,Y,60)) continue;
    if(!fogFxVisible(X,Y,pteam[i])) continue;
    if(!mfProjectileVisualAdmission(i,essential,overviewVfx,projectileDrawn)) continue;
    if(projectileDrawn>=projectileLimit&&!essential) continue;
    projectileDrawn++;
    /* Tactical icons intentionally render after ordinary additive fire. Only
       a genuine live shot from a still-live shooter earns a top-layer cue; a
       recycled projectile slot cannot light the wrong unit or reveal fog. */
    const shooter=pSrcUnit[i];
    if(overviewVfx&&shooter>=0&&ualive[shooter]&&ugen[shooter]===pSrcGen[i]&&
       vis(ux[shooter],uy[shooter],50)&&mfRenderUnitFogVisible(shooter)&&
       typeof mfIconFireCueUnit==='function')mfIconFireCueUnit(shooter);
    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 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 ballistic=ty===2||ty===9||!!pBarrage[i];
    const ox=ballistic?psx[i]:X-pvx[i]*age, oy=ballistic?psy[i]:Y-pvy[i]*age;
    const hMuz=fxWeaponH(ox,oy,true);
    /* Stay on the bore. gh()+12 dropped every tracer onto the dirt while
       turrets sit at M.turH — the floating-behind-the-round look. */
    /* pz is a real trajectory between muzzle and impact ground heights, built
       in projTick. The old expression re-derived height from the ground under
       the shell's CURRENT xy, so a round crossing a ridge rose with it. Falls
       back to the old form for any shell that predates pz. */
    const H=ballistic?(pz[i]||gh(X,Y)+16+Math.sin(pt[i]*Math.PI)*(pArc[i]||70))
      :(pz[i]||(ty===7?hMuz+8:ty===9?hMuz+10:hMuz));
    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 young=ballistic?pt[i]<0.08:age<0.22;
    const fromMuz=young||ballistic;
    const bx=fromMuz?ox:X-nx*Math.min(streak,48), by=fromMuz?oy:Y-ny*Math.min(streak,48);
    const bH=fromMuz?hMuz:H;
    const beamOpt={projectile:1,noMuzzle:!fromMuz};
    if(young){
      addMuzzleFlash(ox,oy,hMuz,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.08:1-age/0.22));
    }
    const trailVolume=!bio&&typeof mfOrdnanceTrailVolActive==='function'&&mfOrdnanceTrailVolActive(i);
    const ordTrail=(!bio&&typeof mfDrawOrdnanceTrail==='function'&&
      (trailVolume||(ballistic&&(ty===2||ty===9))))
      ?mfDrawOrdnanceTrail(i,X,Y,H,power,fac,beamOpt):0;
    if(trailVolume&&(ordTrail===MF_ORD_TRAIL_SHELL||ordTrail===MF_ORD_TRAIL_ENERGY)){
      /* Dedicated trajectory-ribbon system owns the complete in-flight
         presentation. Its terminal ellipsoid is the projectile head, so the
         old flat smoke cards and short beam streak cannot double-render over
         missiles, plasma, shells or artillery. */
    } else 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;
      /* Same fix for the trail: sample the trajectory at q0 rather than the
         terrain under the sample, or the smoke ribbon hugs the ground. */
      const h0=(pz0[i]||pz1[i])?(pz0[i]+(pz1[i]-pz0[i])*q0+16+Math.sin(q0*Math.PI)*(pArc[i]||70))
                               :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,beamOpt);
    } 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,bH,by,X,H,Y,.92*power,145,220,80,210,beamOpt);
    } else if(wk==='g'){
      /* Gauss needle: muzzle→tip while young, then a short same-height streak. */
      addBeam3D(FX.beam,bx,bH,by,X,H,Y,1.18*power,fp.a[0],fp.a[1],fp.a[2],255,beamOpt);
      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,bH,by,X,H,Y,.92*power,fp.a[0],fp.a[1],fp.a[2],220,beamOpt);
    } 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,bH,by,X,H,Y,1.22*power,255,105,24,210,beamOpt);
    } 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,bH,by,X,H,Y,1.22*power,fp.a[0],fp.a[1],fp.a[2],205,beamOpt);
    } 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,bH,9*power,0,nova?100:255,nova?225:130,nova?255:45,180);
      addBeam3D(FX.beam,bx,bH,by,X,H,Y,1.32*power,fp.a[0],fp.a[1],fp.a[2],200,beamOpt);
    } 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);
      bbAdd.add(sprites.glow,X,Y,H,(10+Math.sin(t*22+i)*2)*power,0,nova?105:255,nova?225:180,nova?255:90,200);
      addBeam3D(FX.beam,bx,bH,by,X,H,Y,1.38*power,fp.a[0],fp.a[1],fp.a[2],220,beamOpt);
    } else if(ty===8){
      addBeam3D(FX.beam,bx,bH,by,X,H,Y,.88*power,255,220,140,250,beamOpt);
      bbAdd.add(sprites.glow,X,Y,H,5.2*power,0,255,235,190,245);
    } else if(ty===9){
      bbAlpha.add(sprites.debris||sprites.glow,X,Y,H,8.2*power,yaw+Math.PI/2,nova?145:205,nova?218:198,nova?255:188,245);
      addBeam3D(FX.beam,bx,bH,by,X,H,Y,1.42*power,fp.a[0],fp.a[1],fp.a[2],200,beamOpt);
    } else if(ty===2&&(ordTrail===MF_ORD_TRAIL_SHELL||ordTrail===MF_ORD_TRAIL_ENERGY)){
      /* Same bounded system for ordinary artillery shells. */
    } 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;
      /* Same fix for the trail: sample the trajectory at q0 rather than the
         terrain under the sample, or the smoke ribbon hugs the ground. */
      const h0=(pz0[i]||pz1[i])?(pz0[i]+(pz1[i]-pz0[i])*q0+16+Math.sin(q0*Math.PI)*(pArc[i]||70))
                               :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,beamOpt);
    } 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,bH,by,X,H,Y,1.55*power,255,135,45,225,beamOpt);
    } else {
      const cr=fp.a[0], cg=fp.a[1], cb=fp.a[2];
      addBeam3D(FX.beam,bx,bH,by,X,H,Y,(ty===1?1.72:1.32)*power,cr,cg,cb,ty===1?255:245,beamOpt);
      bbAdd.add(sprites.glow,X,Y,H,(ty===1?8.4:6.8)*power,0,255,252,240,255);
      bbAdd.add(sprites.glow,X,Y,H,(ty===1?3.6:2.8)*power,0,255,255,248,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){
    let lf=bm.held?clamp(bm.level,0,1):1-bm.t/bm.max;
    /* Pulsed channels animate emission itself. Their clock advances only in
       beamTick(), so repainting a paused frame cannot move, spawn or re-phase
       the beam. Soft edges avoid the digital on/off look of a hard duty gate. */
    if(bm.held&&bm.pulseHz>0){
      const ph=((bm.phase%1)+1)%1,duty=clamp(bm.pulseDuty||.62,.08,1);
      if(ph>=duty)lf=0;
      else{
        const edge=Math.max(.001,Math.min(.12,duty*.34));
        lf*=clamp(Math.min(ph/edge,(duty-ph)/edge),0,1);
      }
    }
    if(lf<=.002)continue;
    const beamAnimT=bm.held?bm.age:t;
    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)+6, sway=Math.sin(beamAnimT*14+bm.seed)*4;
      const bw=Math.max(6.0,bm.w*2.8);
      // Searing celestial column: outer glowing aura + inner incandescent core
      addBeamRibbon(sprites.glow,gx+sway,h+1100,gy-sway*0.3,gx,h,gy,bw*4.2,bm.r,bm.g,bm.b,lf*135,220);
      addBeamRibbon(sprites.glow,gx+sway*0.3,h+1100,gy,gx,h,gy,bw*1.6,255,252,230,lf*250,220);
      // Helical containment filament
      addBeamHelix({x0:gx+sway,y0:gy,x1:gx,y1:gy,seed:bm.seed,w:bw},h+1100,h,bw*2.2,5.5,255,210,120,lf*175,beamAnimT,false);
      // Radiant ground impact corona & blast flash
      bbAdd.add(sprites.glow,gx,gy,h+4,bw*6.8,0,bm.r,bm.g,bm.b,lf*200);
      bbAdd.add(sprites.glow,gx,gy,h+6,bw*3.2,0,255,250,220,lf*240);
      addBeamBurst(gx,gy,h+8,bw*2.8,bm.r,bm.g,bm.b,lf*220);
      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+beamAnimT*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);
      if(bm.endCap!=='none')addBeamBurst(bm.x1,bm.y1,h1,bm.w*3.2,155,225,255,lf*220);
      continue;
    }
    if(sty==='mining'){
      /* THE WHITE DISC. Extraction (TITHE) and build-assist (LABOUR) clamp a
         beam on ONE fixed point for as long as they work, so every frame
         repaints the same texels. The weapon path is built for a transient,
         moving terminus: addBeamBurst lays 8 additive sprites there including
         a 255,253,244 core at full alpha, and addBeam3D rescales rad to
         max(4.80,rad*5.85) then draws ribbons at width*5.10 — ~116 world
         units — the innermost white at a*1.40, plus addBeamPathFx knots and a
         muzzle burst. One beam landed several times over the 0.936 bright-pass
         and bloom spread it into the disc that swallowed the extractor and the
         node under it. Verified by suppressing addBeam at the node: disc gone;
         suppressing the particles changed nothing.
         Two thin ribbons in the tier colour and a soft terminus. No white
         core, no knots, no burst, and do NOT route this through addBeam3D. */
      addBeamRibbon(sprites.glow,bm.x0,h0,bm.y0,bm.x1,h1,bm.y1,bm.w*2.2,br,bgc,bbc,lf*70,150);
      addBeamRibbon(sprites.glow,bm.x0,h0,bm.y0,bm.x1,h1,bm.y1,bm.w*0.9,br,bgc,bbc,lf*95,150);
      bbAdd.add(sprites.glow,bm.x1,bm.y1,h1,bm.w*1.5,0,br,bgc,bbc,lf*48);
      continue;
    }
    if(sty==='repair'){
      /* The un-fixed twin of the mining disc. A constructor holds this on ONE
         target for the whole repair/salvage, so the weapon terminus repaints
         the same texels every frame: addBeam3D rescales bm.w*1.55 to width ~20
         and lays ribbons at width*5.10 (~101 world units) with a white inner at
         a*1.40, then addBeamBurst adds 8 more additive sprites on the target.
         life 0.5 overlaps MORE than the 0.11 mining beam did.
         Keep the travelling green pulses — they are what makes repair read as
         repair — and drop the shaft rescale and the burst. */
      addBeamRibbon(sprites.glow,bm.x0,h0,bm.y0,bm.x1,h1,bm.y1,bm.w*2.0,br,bgc,bbc,lf*64,150);
      addBeamRibbon(sprites.glow,bm.x0,h0,bm.y0,bm.x1,h1,bm.y1,bm.w*0.85,br,bgc,bbc,lf*90,150);
      if(perfScale>.4) for(let k=0;k<2;k++){
        const q=(k/2+beamAnimT*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.4,0,145,255,185,lf*95);
      }
      bbAdd.add(sprites.glow,bm.x1,bm.y1,h1,bm.w*1.4,0,br,bgc,bbc,lf*44);
      continue;
    }
    const pulse=sty==='thermal'?(0.78+Math.sin(beamAnimT*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),{beamSeed:bm.seed});
    /* The authored shaft already carries its pulse. Helices and thermal knots
       were additional transient layers and the source of saturated columns. */
    if(sty==='repair'&&perfScale>.4){
      for(let k=0;k<2;k++){
        const q=(k/2+beamAnimT*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(bm.endCap!=='none')addBeamBurst(bm.x1,bm.y1,h1,hitSize*(sty==='tracer'?0.82:1),br,bgc,bbc,lf*(sty==='tracer'?200:220));
  }
  /* ---- 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. */
  const ordnanceOwnsSmoke=typeof mfOrdnanceTrailQueueSmoke==='function'&&mfOrdnanceTrailQueueSmoke(artShellSmoke);
  for(let s=0;!ordnanceOwnsSmoke&&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');
  if(midWalk)mfRenderParticleCacheInvalidate();
  const partLook=liveN<=0?(midWalk?0:mfRenderParticleCacheBegin()):midWalk?
    Math.min(MAXPART,Math.max(liveN*(gfxQ==='low'?3:2),gfxQ==='low'?360:720)):
    mfRenderParticleCacheBegin();
  for(let k=0;k<partLook;k++){
    const i=midWalk?((fHead-1-k+MAXPART)%MAXPART):_mfFpI[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||
      ftype[i]===11||ftype[i]===12||ftype[i]===13||ftype[i]===14||ftype[i]===18||ftype[i]===19;
    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);
    /* The mesh annulus is the High/Cinematic presentation. Its legacy ring is
       still aged in the sim as an atomic fallback and is revealed whenever
       shader/init/draw/fog presentation did not complete this frame. */
    if(ty===3&&typeof mfShockwavePresentedAt==='function'&&
       mfShockwavePresentedAt(X,Y,fsize[i])) continue;
    /* Macro cards are much larger than their origin point. Hide the complete
       footprint at a fog boundary so an armed fallback cannot leak across FOW
       when its matching volume was correctly culled. */
    if((ty===11||ty===12||ty===13||ty===18||ty===19)&&
       typeof fogFxFootprintVisible==='function'&&
       !fogFxFootprintVisible(X,Y,Math.max(8,fsize[i]*(ty===12?1.25:1.05)))) continue;
    /* Type 0 flashes are 2D (no height). Commander/heavy muzzle stamps are
       size 21–27 — the old <22 cutoff left those on the dirt. Type 2 sparks
       from projectileFireFX are sub-0.5 and belong on the bore too. */
    /* Fixed-step building work motes carry an explicit rooftop height in fzh.
       Legacy sparks leave it at zero and retain the weapon/terrain fallback. */
    const explicitWorkH=(ty===0||ty===2)&&typeof fzh!=='undefined'&&fzh[i]>.5?fzh[i]:0;
    const Hfx=explicitWorkH>0?explicitWorkH:
      ((ty===0&&fsize[i]<36)||(ty===2&&fsize[i]<0.5)?fxWeaponH(X,Y,true):H);
    if(ty===19){
      /* Direct impacts are VOL_IMPACT on High/Cinematic. This single compact
         card is only the atomic Low/Medium or failed-pass fallback; exact-kind
         presentation prevents a nearby blast from hiding it by accident. */
      if(typeof volFxPresentedAt==='function'&&
         volFxPresentedAt(typeof VOL_IMPACT!=='undefined'?VOL_IMPACT:4,X,Y))continue;
      const age=1-lf,sz=fsize[i]*(.58+age*.86);
      const impactH=typeof fzh!=='undefined'&&fzh[i]>.5?fzh[i]:H;
      bbAdd.add(sprites.fireball||sFireB||sGlowB,X,Y,impactH+Math.max(.8,sz*.18),sz,
        i*.731+age*.8,fcr[i],fcg[i],fcb[i],Math.min(190,170*lf));
      continue;
    }
    if(ty===11||ty===12||ty===13||ty===14||ty===18){
      /* volFxDraw already ran. Suppress an armed fallback only when the
         MATCHING blast/dust proxy survived culling and completed the composite
         this frame. Shader/depth/RT failure leaves no presented bit, so v2 is
         revealed atomically; an unrelated dust volume cannot hide a blast. */
      if((ty===11||ty===12||ty===18)&&typeof volFxPresentedAt==='function'){
        const vk=ty===12?(typeof VOL_DUST!=='undefined'?VOL_DUST:2):
          (typeof VOL_BLAST!=='undefined'?VOL_BLAST:0);
        if(volFxPresentedAt(vk,X,Y))continue;
      }
      if(typeof macroFxQueue==='function'){
          const s=fsize[i],age=1-lf,macroH=typeof fzh!=='undefined'&&fzh[i]>.5?fzh[i]:H;
        if(ty===14){
          const baseH=typeof fzh!=='undefined'&&fzh[i]>.5?fzh[i]:H+12;
          const p0=w2s(X,Y,baseH),p1=w2s(X+fvx[i],Y+fvy[i],baseH);
          const sx=p1[0]-p0[0],sy=p1[1]-p0[1],rot=Math.atan2(-sx,-sy);
          const bio=fcg[i]>fcr[i]+25,tint=(((bio?166:210)<<16)|((bio?218:205)<<8)|(bio?142:198));
          const vlen=Math.max(1,Math.hypot(fvx[i],fvy[i]));
          const smokeW=Math.max(0.95,s*0.95);
          const smokeH=Math.max(4.0,Math.max(s*5.2,s*3.2*(vlen*0.09+0.6)));
          const aTrail=Math.max(84,Math.min(120,108*lf));
          const trailOk=(typeof macroFxQueueRect==='function')
            ?macroFxQueueRect(ty,X,Y,baseH+1.5,smokeW,smokeH,age,aTrail,tint,rot)
            :macroFxQueue(ty,X,Y,baseH+1.5,smokeH,age,aTrail,tint,rot);
          /* Same rule as the blast cards: a refused trail shows one plain
             smoke billboard rather than leaving the aircraft trailing nothing. */
          if(trailOk===false)
            bbAlpha.add(sSmokeB,X,Y,baseH+1.5,Math.max(1,smokeW*.9),rot,
              fcr[i],fcg[i],fcb[i],Math.max(60,Math.min(150,aTrail)));
        }else{
          /* The first authored blast cells intentionally contain a compact
             white-hot seed. Expand that seed relative to the annulus, then
             converge to the normal scale before the turbulent body fills its
             cell. This changes one core silhouette, not the layer count. */
          /* The v2 atlas already carries a white-hot expanding ignition cell.
             A 1.82 multiplier enlarged that cell into a flat screen-facing
             card before its turbulent silhouette appeared. Keep a brief,
             restrained punch and let the authored evolution provide scale. */
          const igniteBoost=ty===11?1.34-0.34*clamp(age/.12,0,1):1;
          const scale=s*(ty===12?2.35:ty===13?2.15:ty===18?1.30:2.20)*igniteBoost;
          /* Anchor from the DRAWN quad, not the logical recipe radius. The
             former s*.50 lift paired with a 2.20s blast card put ~27% of the
             authored frame below terrain and produced a hard horizontal cut.
             Dust deliberately hugs the surface; fire/smoke keeps its full
             transparent gutter above it. */
          const lift=ty===18?(scale*1.84)*.49:scale*.49;
          const tint=(fcr[i]<<16)|(fcg[i]<<8)|fcb[i];
          /* An airborne wreck opens upward into a soot column. Drawing its
             authored cloud as a randomly rotated square made the source's
             broad lobes read as a translucent polygon/flower around impact.
             A single upright rectangle is still one core layer and preserves
             the atlas animation, while giving aircraft destruction a distinct
             vertical silhouette from a ground shell. */
          /* QUEUE REJECTION IS NOT SILENT. macroFxQueue/Rect return false when
             the macro batch is at capacity or the geometry is not finite, and
             that return used to be discarded — so in exactly the busy moment
             when the batch fills, a detonation whose card was refused rendered
             as nothing at all (its volume is either absent on this tier or
             already suppressed). One bounded basic card is revealed instead:
             a single billboard, no new emitter, no second explosion. */
          let mfxOk=true;
          if(ty===18&&typeof macroFxQueueRect==='function')
            mfxOk=macroFxQueueRect(ty,X,Y,macroH+lift,scale*.58,scale*1.84,age,
              Math.max(112,165-lf*30),tint,
              Math.atan2(-fvy[i],-fvx[i]));
          /* Blast, collapse dust and wreck fire are authored against a shared
             ground baseline. Random screen-plane rotation turned that baseline
             sideways, so a correctly split frame still looked guillotined by
             terrain. Variation belongs in the density/shape art, not by
             rotating a grounded plume like a playing card. */
          else mfxOk=macroFxQueue(ty,X,Y,macroH+lift,scale,age,255,tint,0);
          if(mfxOk===false){
            const fbA=Math.max(70,Math.min(210,190*lf));
            if(ty===12) bbAlpha.add(sSmokeB,X,Y,macroH+lift,scale*.52,i*.37+age*.6,
              fcr[i],fcg[i],fcb[i],fbA);
            else bbAdd.add(sprites.fireball||sFireB||sGlowB,X,Y,macroH+lift,scale*.46,
              i*.731+age*.8,fcr[i],fcg[i],fcb[i],fbA);
          }
        }
      }
      continue;
    }
    /* 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===20){                              // paid building-work mote: one moving point, one glow
      const workH=typeof fzh!=='undefined'&&fzh[i]>.5?fzh[i]:H;
      bbAdd.add(sGlowB,X,Y,workH,Math.max(.8,fsize[i]),0,fcr[i],fcg[i],fcb[i],150*lf);
      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 airH=typeof fzh!=='undefined'&&fzh[i]>0.5?fzh[i]:0;
      const lift=airH?2+(1-lf)*10:(nearDrop?1.6:11+(1-lf)*34);
      const baseH=airH||H;
      const a0=nearDrop?120*lf:Math.min(215, (vq>=0.65?185:150)*lf);
      bbAlpha.add(sSmokeB,X,Y,baseH+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,
          baseH+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,
          baseH+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){                        // one depth-tested shock annulus
      const strategicRing=fsize[i]>100;
      const rs=strategicRing
        ?fsize[i]*(0.22+(1-lf)*0.78)
        :fsize[i]*(0.35+(1-lf)*0.65);
      const ringAlpha=Math.min(240,(strategicRing?210:175)*lf);
      if(FX&&FX.ring){
        FX.ring.add(X,Y,H+1.18,rs,0,Math.min(255,fcr[i]+35),Math.min(255,fcg[i]+25),Math.min(255,fcb[i]+15),ringAlpha);
      } else {
        bbAdd.add(sRingB,X,Y,H+1.15,rs,0,fcr[i],fcg[i],fcb[i],ringAlpha);
      }
    } 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));
      const sparkH=Hfx+1.4+hop;
      FX.shard.add(X,Y,sparkH,sz,i*.83,fcr[i],fcg[i],fcb[i],lf<.18?lf*1300:235);
      if(ty===2) bbAdd.add(sGlowB,X,Y,sparkH,Math.max(1.0,sz*1.45),0,fcr[i],fcg[i],fcb[i],155*lf);
    } else if(ty===4){                        // ember coal — not an upright licking flame
      const sz=Math.min(10,fsize[i]*0.72);
      const flick=0.86+0.14*lf;
      bbAdd.add(sGlowB,X,Y,H+1.15,sz*1.55,0,fcr[i],Math.max(32,(fcg[i]*0.55)|0),Math.max(20,(fcb[i]*0.35)|0),Math.min(80,52*lf*flick));
      bbAdd.add(sGlowB,X,Y,H+1.35,sz*0.62,0,Math.min(255,fcr[i]+20),Math.min(255,fcg[i]+30),Math.min(255,fcb[i]+20),Math.min(170,120*lf*flick));
    } else if(ty===6){                        // volumetric explosion fireball
      const age=1-lf, S=Math.min(40,fsize[i]);
      /* Draw at the puff's OWN height. fpz is world z in terrainH's frame,
         exactly as type 7 uses it, so a cluster occupies a volume instead of
         every quad sitting on the ground plane. */
      const pz=(typeof fpz!=='undefined'&&fpz[i]>0)?fpz[i]:H;
      const yaw=(i*0.7)+age*0.6;
      /* Hot early, smoke late. Fire is additive because it emits light; smoke
         is alpha because it OCCLUDES - and that hand-over is most of why a
         real blast reads as mass rather than as a glow. */
      /* A dark puff is SMOKE and never lights anything: it exists to occlude
         and to give the blast an outline. A bright puff is the core. */
      const lum=fcr[i]+fcg[i]+fcb[i];
      const isSmoke=lum<330.0;
      const airFlameOnly=typeof fowner!=='undefined'&&fowner[i]<0;
      const hot=isSmoke?0.0:Math.max(0.0,1.0-age*2.0);
      if(hot>0.04){
        if(airFlameOnly)
          bbAdd.add(sFireB||sGlowB,X,Y,pz+S*.08,S*(.24+age*.18),yaw,
            255,72+(36*hot)|0,12,(150*lf*hot)|0);
        else
          bbAdd.add(sprites.fireball||sFireB,X,Y,pz+S*.12,S*(0.55+age*0.85),yaw,
            255,(120+130*hot)|0,(35+150*hot*hot)|0,(235*lf*hot+38*lf)|0);
      }
      const smoke=airFlameOnly?0.0:(isSmoke?Math.min(1.0,0.35+age*0.9):Math.min(1.0,age*1.45));
      if(smoke>0.05)
        bbAlpha.add(sSmokeB,X,Y,pz+S*.16,S*(0.70+age*1.10),yaw*0.6,
          isSmoke?(38+18*age)|0:92, isSmoke?(33+16*age)|0:84, isSmoke?(31+15*age)|0:78,
          (( isSmoke?190:150 )*lf*smoke)|0);
      if(hot>0.15&&!airFlameOnly)
        bbAdd.add(sGlowB,X,Y,pz+1.4,S*0.95,0,255,135,55,(52*lf*hot)|0);
    } else if(ty===7){                        // ballistic solid debris
      /* No hop cheat. The sim owns this fragment's altitude now — fpz is world
         z in terrainH's frame, and gh() here IS terrainH — so the arc you see
         is the arc that was integrated, including the bounce and the settle
         onto whatever ground ended up underneath it. The only render-side term
         is half the shard's own thickness, so a settled fragment rests ON the
         surface instead of half-buried in it. */
      /* Macro recipes emit only 1–3 pieces, so each must read as a slab rather
         than a spark. Their sim radius is already bounded; this presentation
         scale gives the group a clear silhouette without restoring a spray. */
      /* Ballistic shrapnel fragments tumbling in 3D arc, proportioned cleanly
         so they don't dominate the volumetric core with flat cards. */
      /* One to three pieces must carry the debris read by themselves. The old
         0.32 scale reduced ordinary fragments to ~1 world unit—sub-pixel at
         tactical zoom—so the telemetry said debris while the frame showed
         nothing. The closed faceted shard stays bounded but now occupies a
         believable 2.5–12 wu range beside its source structure. */
      const dsz=Math.max(2.5,Math.min(12,fsize[i]*.72));
      const dz=(typeof fpz!=='undefined'?fpz[i]:H)+dsz*0.34;
      const spin=i*.7+(1-lf)*(7.0+(i%3)*2.1);
      FX.shard.add(X,Y,dz,dsz,spin,fcr[i],fcg[i],fcb[i],lf<.22?lf*1100:200);
    } 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,mfCombatFlashSize(ty,fsize[i]),0,
        fcr[i],fcg[i],fcb[i],220*lf);
    }
  }
  // muzzle / engine / stance glows as small shells
  for(let rk=0;rk<_mfRuN;rk++){
    const i=_mfRuI[rk];
    const mo=umode[i];
    if(!mo||mo===4) continue;
    const X=ux[i], Y=uy[i];
    if(!vis(X,Y,40)) continue;
    if(!mfRenderUnitFogVisible(i)) continue;
    const T=TYPES[utype[i]], H=mfRenderUnitHeight(i,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 rk=0;rk<_mfRuN&&damagedShown<220;rk++){
    const i=_mfRuI[rk];
    if(overviewVfx) break;
    const X=ux[i], Y=uy[i];
    if(!vis(X,Y,60)||!mfRenderUnitFogVisible(i)) 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);
    /* Air damage already emits the velocity-aligned type-14 trail at the
       aircraft's true altitude. A second generic coal/smoke sprite here used
       ground height, so perspective displaced it into an obvious black square
       above the aircraft. Keep this ground-attached language on ground units. */
    if(T.air) continue;
    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){
      addWreckCoalBed(X,Y,H,T.size*(.55+sev*.35),0.40+sev*0.55,i*1.7,frac<.18?3:2);
    }
  }
  // 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==='mex'){
      /* Extraction glow, deliberately SLIGHT. 1.33.42 stripped the node halo,
         the ring, the vein ribbons and the standing crystal pools in one pass
         to kill the white disc — which left a finished extractor with no
         readback at all. What bloomed was the STACK: five additive sprites at
         alpha 140-255 over the same texels, which saturates before bloom even
         samples it. One sprite in the 40s does not. Do not add a second.
         Tier only shifts hue: a rich node should be legible without being
         brighter, or the disc comes back on exactly the pads that had it. */
      const mD=(Bd.dep>=0&&deposits[Bd.dep])||null;
      const mTier=mD?depositTier(mD):1;
      const mc=mTier===3?[206,150,255]:mTier===2?[120,232,188]:[120,214,255];
      const mPulse=0.88+Math.sin(t*2.2+(Bd.anim||0))*0.12;
      bbAdd.add(sprites.glow,Bd.x,Bd.y,H+sz*0.55,sz*0.34*mPulse,0,mc[0],mc[1],mc[2],46);
    }
    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);
    /* Aegis and Techlab surfaces are one instanced shield each. Their former
       additive glows/rings are intentionally absent from this generic pass. */
    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.

       REVIVAL EVALUATED AND REJECTED, 2026-08. The proposal was to bring the
       feature back as real light SHAFTS — a cone of lit air over each powered
       building, plus the authored sweep and approach-lamp motifs — on top of
       the existing FX.cone primitive. Three fatals, all measured, all in the
       geometry and the pass order rather than in taste:

       1. FX.cone CANNOT BE A SHAFT. mdlCone (models.js:3777) is
          cyl(r0=1, r1=0.06, h=1) — base radius and height are both 1 — and the
          instanced vertex shader (mesh.js:1591) transforms it as
            sp = vec3(aPos.x*aInst.w, aPos.y*aInst.w, aPos.z*aWide)
          so the SINGLE instance scale aInst.w multiplies height AND base radius
          together. Raising the cone always widens it by the same factor: the
          aspect is locked at 1:1, i.e. a squat 45-degree bowl. aWide stretches
          only the z half-axis, which makes the bowl elliptical, not tall. No
          instance parameter in this layout produces a shaft.
       2. YAW IS A NO-OP HERE. The same shader rotates about Y
          (sp.x*c - sp.z*s, sp.y, sp.x*s + sp.z*c), and the cone is a solid of
          revolution about Y drawn UNLIT (flat vCol, no normal term). Rotating
          it changes nothing on screen, so the sweep and approach-lamp motifs —
          which are entirely yaw animation — are unreachable with this mesh.
       3. THE BLOOM ARGUMENT WAS AIMED AT THE WRONG PASS. The standing objection
          was "shafts would blow the bright-pass budget". Bloom is extracted
          BEFORE any of this draws: aoExtractBloom() runs at render3d.js:2040,
          and the ADDITIVE EFFECTS pass — where FX.cone would flush — does not
          begin until :2064. Additive shafts can never reach the bright pass at
          all. The real risk is the opposite end: aoColB is RGBA8
          (mesh.js:2369), so stacked SRC_ALPHA/ONE cones saturate it to flat
          white and the scene loses contrast with no bloom involved.

       REVIVAL REQUIRES a NEW pre-stretched primitive — a cone authored tall, or
       a separate height scale added to the instance layout — with its own
       flush, budgeted against aoColB saturation measured as peak channel value
       in the additive pass, NOT as bright-pass cost. Do not re-open this
       against FX.cone. */
  }
  /* 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 rk=0;rk<_mfRuN;rk++){
      const i=_mfRuI[rk];
      if(!usel[i]&&i!==heroIdx&&(i%stride)!==0) continue;
      const X=ux[i],Y=uy[i]; if(!vis(X,Y,48)||!mfRenderUnitFogVisible(i)) 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 half health is visibly failing: coal beds on the hull,
     a smoke column, sparks. Upright flame quads were licking tongues. */
  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 fBase=Math.min(sz,26);
    addWreckCoalBed(Bf.x,Bf.y,H,fBase*(0.55+sev*0.22),0.42+sev*0.55,Bf.anim,sev>.72?4:3);
    // One simulation-tick emission; paused or recovery re-renders are inert.
    emitDamagedStructureParticlesOnce(Bf,sz,sev);
  }

  // burning ruins (still standing) — coals, not licking flame quads
  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);
    addWreckCoalBed(R.x,R.y,H,Math.min(22,R.s*.42),R.burn,R.seed,3);
    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 coals 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);
    addWreckCoalBed(R.x,R.y,H,Math.min(20,Math.max(8,R.s*0.16)),heat,R.seed,heat>0.55?4:3);
  }
  /* Civic groundBurns and wreckage share the same language: terrain coals
     plus a low glow. No upright flame stamps. */
  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;
    addWreckEmbers(W.x,W.y,gh(W.x,W.y),Math.min(12,W.s*(0.26+heat*0.14)),heat,W.x*0.07);
  }
  // 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);
    const teamIdC=typeof mfTeamIdEnabled==='function'&&mfTeamIdEnabled()?mfTeamIdColor(team,false):null;
    let er=teamIdC?teamIdC[0]:78,eg=teamIdC?teamIdC[1]:224,eb=teamIdC?teamIdC[2]:132;
    if(!teamIdC&&team===1){er=255;eg=76;eb=62;}else if(!teamIdC&&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(teamIdC){ r=teamIdC[0]; g=teamIdC[1]; b=teamIdC[2]; } // damage stays encoded by length
    else 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 rk=0;rk<_mfRuN;rk++){
      const i=_mfRuI[rk];
      if(!vis(ux[i],uy[i],90)) continue;
      if((hbMode==='select'||overviewVfx)&&!usel[i]) continue;
      if(!mfRenderUnitFogVisible(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=mfRenderUnitHeight(i,T,ux[i],uy[i]);
      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));
    };
    /* One bar per eligible unit. Cell-collapse (most-damaged per view cell
       once hbN>48) changed the approved select/always-on language without
       a go-ahead — bars vanished inside any real formation. */
    for(let k=0;k<hbN;k++) putUnitBar(k);
  }

  /* ---- STRUCTURE WORK RAILS ------------------------------------------
     Health and work answer different questions. Construction, production,
     research and upgrades remain readable even when health bars are disabled;
     exact queue state is restricted to the local command seat and stays behind
     the same visibility/fog gates as the structure mesh. One billboard batch
     carries every rail, with a hard density cap while the selected structure
     is always retained. */
  const workVfxQ=typeof mfGfxKey==='function'?mfGfxKey():'high';
  const workVfxCap=workVfxQ==='low'?6:workVfxQ==='medium'?12:20;
  const workVfxEmitters=(workVfxQ==='high'||workVfxQ==='cinematic')&&perfScale>.52?2:1;
  const workVfxNear=orthoSpan<1500;
  let workVfxN=0;
  /* Faction work motes extend the existing emissive mesh language rather than
     spawning render-frame particles. They share the additive billboard batch,
     consume the simulation-owned work profile, and stop at a deterministic
     fault light whenever paid progress stalls. */
  const putBuildingWorkVfx=(Bd,bi,A,selected,H)=>{
    const kind=A.kind||'idle';
    if(!workVfxNear||workVfxN>=workVfxCap||(kind!=='constructing'&&kind!=='producing')||
       (perfScale<.28&&!selected)||typeof mfBuildingWorkProfile!=='function')return;
    const T=BT[Bd.type],foot=Math.max(1,Bd.r||1);
    /* Own structures normally bypass fogEntityVisible. Work state is private
       tactical information, so bright motes require the complete footprint to
       be visible exactly like the fixed-step emitter in sim.js. */
    if(typeof fogPointVisible!=='function'||!fogPointVisible(Bd.x,Bd.y)||
       !fogPointVisible(Bd.x-foot,Bd.y)||!fogPointVisible(Bd.x+foot,Bd.y)||
       !fogPointVisible(Bd.x,Bd.y-foot)||!fogPointVisible(Bd.x,Bd.y+foot))return;
    const P=mfBuildingWorkProfile(Bd);if(!P||!P.color||!P.accent)return;
    const stalled=A.state==='stalled'||A.stalled,fac=P.faction||bldFactionKey(Bd);
    const simClock=typeof stats!=='undefined'&&Number.isFinite(stats.t)?stats.t:0;
    const rate=P.pulseSpeed>0?P.pulseSpeed:1,phase=stalled?.5:(simClock*rate*(kind==='constructing'?.58:1)+bi*.173)%1;
    const base=Math.max(3,Math.min(9,Number(P.size)||T.size*.13)),count=stalled?1:workVfxEmitters;
    const rot=Bd.rot||0,fx=Math.cos(rot),fy=Math.sin(rot),sx=-fy,sy=fx;
    for(let k=0;k<count;k++){
      const side=count===1?0:(k?1:-1),q=(phase+(k*.5))%1,pulse=stalled?.58:.72+.28*Math.sin(q*TAU);
      /* The four factory meshes peak at roughly 22--36 world units (Brood
         birth-maw through Nova's tower).  The old .38*size anchor was 18.2
         for a size-48 factory, so every service light was submitted inside
         its hull and depth-tested away.  Track the same construction grow as
         the mesh, then sit just above the tallest authored roof without
         turning the cue into a floating beacon. */
      const workGrow=kind==='constructing'?.30+.70*clamp(Number(A.progress)||0,0,1):1;
      let x=Bd.x,y=Bd.y,z=H+Math.max(6,T.size*.78)*workGrow,sz=base*(selected?1.12:1)*pulse;
      if(fac==='legion'){
        x+=fx*T.size*.18+sx*side*T.size*.28;y+=fy*T.size*.18+sy*side*T.size*.28;
        sz*=.92+q*.26;
      }else if(fac==='syndicate'){
        const a=q*TAU;
        x+=fx*Math.cos(a)*T.size*.28+sx*Math.sin(a)*T.size*.18;
        y+=fy*Math.cos(a)*T.size*.28+sy*Math.sin(a)*T.size*.18;z+=Math.sin(a)*T.size*.07;
      }else if(fac==='horde'){
        const breathe=stalled?0:Math.sin(q*TAU)*T.size*.07;
        x+=fx*(side*T.size*.16+breathe)+sx*(side?side*T.size*.24:T.size*.08);
        y+=fy*(side*T.size*.16+breathe)+sy*(side?side*T.size*.24:T.size*.08);sz*=1.08;
      }else{
        const scan=(q-.5)*T.size*.72;
        x+=fx*scan+sx*side*T.size*.20;y+=fy*scan+sy*side*T.size*.20;sz*=.78;
      }
      const C=stalled?null:(k?P.accent:P.color);
      bbAdd.add(sprites.glow,x,y,z,sz,0,stalled?255:C[0],stalled?76:C[1],stalled?46:C[2],stalled?118:122+42*pulse);
    }
    workVfxN++;
  };
  const putBuildingActivity=(Bd,bi,A,selected)=>{
    const T=BT[Bd.type],kind=A.kind||'idle',stalled=A.state==='stalled'||A.stalled;
    let r=112,g=141,b=155;
    if(stalled){r=255;g=88;b=66;}
    else if(kind==='constructing'){r=241;g=183;b=58;}
    else if(kind==='producing'){r=54;g=204;b=239;}
    else if(kind==='upgrading'){r=177;g=111;b=238;}
    else if(kind==='researching'){r=77;g=219;b=132;}
    const healthShown=hbMode!=='off'&&(hbMode!=='select'||selected);
    /* Unlike the legacy health clamp, these stay the authored CSS-pixel size
       in short landscape and at strategic zoom. Fixed world maxima collapsed
       the selected rail to 11x0.6px at span 2600 / VH 360. */
    const workPx=Math.max(.001,orthoSpan/Math.max(1,VH)),H=gh(Bd.x,Bd.y),workUV=mfBuildingWorkUV();
    const w=(selected?62:48)*workPx,bh=(selected?5:4)*workPx;
    const rankShown=orthoSpan<1700&&Bd.prog>=1;
    let lift=healthShown?(Bd.shieldMax>0?19:12):4;if(rankShown)lift=Math.max(lift,31);
    const z=H+T.size*1.34+lift*workPx;
    const frac=kind==='idle'?1:clamp(Number(A.progress)||0,0,1);
    bbAlpha.addRect(workUV,Bd.x,Bd.y,z,w+4*workPx,bh+3*workPx,r,g,b,selected?145:108);
    bbAlpha.addRect(workUV,Bd.x,Bd.y,z,w+1.5*workPx,bh+1.2*workPx,3,9,14,228);
    if(frac>0){
      const off=-w*(1-frac)*.5,fx=Bd.x+matV[0]*off,fy=Bd.y+matV[8]*off,fz=z+matV[4]*off;
      bbAlpha.addRect(workUV,fx,fy,fz,w*frac,bh,r,g,b,kind==='idle'?175:255);
      /* Use simulation time so pause freezes the work sweep. This strip is a
         presentation cue only; it never advances authoritative progress. */
      if(kind!=='idle'&&!stalled&&frac>.08){
        const fw=w*frac,band=Math.min(7*workPx,fw*.34),clock=typeof stats!=='undefined'?stats.t:0;
        const phase=(clock*.72+bi*.173)%1,along=-fw*.5+band*.5+phase*Math.max(0,fw-band);
        bbAlpha.addRect(workUV,fx+matV[0]*along,fy+matV[8]*along,fz+matV[4]*along,
          band,Math.max(.7*workPx,bh*.34),Math.min(255,r+70),Math.min(255,g+70),Math.min(255,b+70),205);
      }
    }
    putBuildingWorkVfx(Bd,bi,A,selected,H);
  };
  if(typeof mfBuildingActivity==='function'){
    /* Resolve network/local authority once, then keep exact queue information
       private to this command seat (co-op allies may share a team but not a
       production bank). */
    const authority=typeof mfBuildingUpgradeAuthority==='function'?mfBuildingUpgradeAuthority():null;
    const owns=authority&&typeof commanderSlotForBuilding==='function'
      ?B=>B.team===authority.team&&commanderSlotForBuilding(B)===authority.slot:null;
    const selected=openBld>=0&&blds[openBld],showWide=orthoSpan<2600;
    if(owns&&selected&&selected.alive&&owns(selected)&&vis(selected.x,selected.y,150)&&
       fogEntityVisible(selected.team,selected.x,selected.y))
      putBuildingActivity(selected,openBld,mfBuildingActivity(selected),true);
    if(owns&&showWide){
      let activeRails=0;
      for(let bi=0;bi<blds.length&&activeRails<48;bi++){
        if(bi===openBld)continue;
        const Bd=blds[bi];
        if(!Bd||!Bd.alive||!owns(Bd)||!vis(Bd.x,Bd.y,150)||!fogEntityVisible(Bd.team,Bd.x,Bd.y))continue;
        const A=mfBuildingActivity(Bd);if(!A||A.kind==='idle')continue;
        putBuildingActivity(Bd,bi,A,false);activeRails++;
      }
    }
  }

  /* ---- OFF-SCREEN THREAT ARROW (harvested from the dead sprite renderer) --
     showAlert() sets alertPos and clears it on a timer, so the alert system is
     live and the banner does appear — but renderOffscreenArrows() (hud.js:1665)
     was only ever called from renderLegacySprites, which runs nowhere. The
     result: the player is told they are under attack and never told WHERE.
     Ported to world-space decals; the original already computed the edge
     intersection in world units, so no projection change is needed. */
  if(typeof alertPos!=='undefined'&&alertPos){
    const ab=camBounds();
    const inView=alertPos[0]>=ab.x0&&alertPos[0]<=ab.x1&&alertPos[1]>=ab.y0&&alertPos[1]<=ab.y1;
    if(!inView){
      const adx=alertPos[0]-cam.x, ady=alertPos[1]-cam.y;
      const aang=Math.atan2(ady,adx), ac=Math.cos(aang), as=Math.sin(aang);
      const hw=(ab.x1-ab.x0)*0.5, hh=(ab.y1-ab.y0)*0.5;
      const tEdge=Math.min(Math.abs(hw/Math.max(0.001,Math.abs(ac))),
                           Math.abs(hh/Math.max(0.001,Math.abs(as))))*0.88;
      const axp=cam.x+ac*tEdge, ayp=cam.y+as*tEdge, ah=gh(axp,ayp);
      const apulse=0.6+0.4*Math.sin(t*4);
      bbAdd.add(sprites.glow,axp,ayp,ah+3,30,0,255,50,30,apulse*150);
      /* Chevron rather than the original thin beam: the mining-beam lesson is
         that a static clamped marker must not stack additive sprites, and two
         short arms read as a pointer at any zoom. */
      const arm=Math.max(9,orthoSpan*0.016);
      for(const sg of [1,-1]){
        const a2=aang+sg*2.44;
        const ex=axp+Math.cos(a2)*arm, ey=ayp+Math.sin(a2)*arm;
        FX.line.add((axp+ex)*.5,(ayp+ey)*.5,ah+3.4,arm,a2,255,80,55,apulse*230,3.0);
      }
    }
  }

  /* ---- AMBIENT SKY LIFE (harvested from the dead sprite renderer) --------
     Cloud shadows and bird flocks were both fully implemented in
     renderLegacySprites (hud.js:351 and :1379) — a function called from
     nowhere. The bird SIMULATION has been running live the whole time
     (sim.js:2314 spawns, moves and despawns flocks every tick); nothing drew
     the result. Ported here as alpha billboards: at this camera pitch
     (1.05–1.50 rad) a camera-facing sprite at ground height reads as a
     ground shadow, which is exactly how the 2D version read. */
  let mfCloudPostArmed=false;
  if(typeof mfCloudFxEmit==='function'){
    const cloudDef=typeof MAPDEFS!=='undefined'&&MAPDEFS&&MAPDEFS[curMap];
    const cloudQ=typeof qualityKey==='function'?qualityKey():'high';
    const cloudCtx={
      time:stats.t,
      paused:typeof paused!=='undefined'&&paused,
      quality:cloudQ,
      perfScale:perfScale,
      mapSize:MAP,
      mapId:curMap,
      seed:cloudDef&&cloudDef.seed,
      daylight:1-Math.min(1,S_nA*1.6),
      ground:gh,
      focusX:cam.x,
      focusY:cam.y,
      viewSpan:typeof orthoSpan==='number'?orthoSpan:1500,
      /* High/Cinematic post needs the recipe even when the body is just off
         the tight vis AABB. Camera-lane pick already keeps nearby systems;
         frustum culling here emptied the sky over a start-zone HQ. */
      visible:(cloudQ==='high'||cloudQ==='cinematic')?null:vis
    };
  /* HIGH/CINEMATIC post clouds do not sample sprites.cloud; only the legacy
     billboard fallback needs the atlas cell. Do not gate the whole weather
     path on the sprite existing — that silently killed post clouds on builds
     where the atlas was late or the cell was missing. */
    const cloudSpr=sprites&&(sprites.cloud||sprites.smoke||sprites.glow);
    const cloudFallback=cloudSpr?L=>bbAlpha.add(cloudSpr,L.x,L.y,L.z,L.size,L.rotation,L.r,L.g,L.b,L.a):null;
    if(typeof mfCloudPostQueue==='function')
      mfCloudPostArmed=!!mfCloudPostQueue(cloudCtx,!!aoActive,cloudFallback,orthoSpan);
    else if(cloudFallback) mfCloudFxEmit(cloudCtx,cloudFallback);
  }
  if(perfScale>0.4){
    if(sprites.bird&&S_nA<0.75) for(const F of birds){
      const rot=Math.atan2(F.vy,F.vx)+Math.PI/2;
      for(let k2=0;k2<F.n;k2++){
        const bx2=F.x-F.vx*k2*0.55+Math.sin(F.ph+k2*1.7)*13;
        const by2=F.y-F.vy*k2*0.55+Math.cos(F.ph*0.7+k2*2.1)*10;
        if(!vis(bx2,by2,20)) continue;
        const bh2=gh(bx2,by2), flap=0.45+Math.abs(Math.sin(F.ph*2.2+k2))*0.75;
        /* Shadow on the ground, bird well above it — the height gap is what
           says "flying" from a top-down camera. */
        bbAlpha.add(sprites.glow,bx2+6,by2+10,bh2+1.2,7,0,0,0,0,42);
        bbAlpha.add(sprites.bird,bx2,by2,bh2+64,10*flap,rot,26,30,38,225);
      }
    }
  }

  /* Per-unit veterancy and per-structure Mk/tech pips. Not an army rank —
     ukills/uvet and B.lvl stay on the entity. Screen-space sizing matches
     the health bars so a chevron stays readable at tactical zoom. */
  const rkPx=Math.max(.24,orthoSpan/Math.max(1,VH));
  const putRankMark=(x,y,h,n)=>{
    n=Math.min(3,n|0); if(n<=0||!sprites||!sprites.px) return;
    const s=clamp(7.2*rkPx,5.4,10.5);
    const lift=h+11*rkPx;
    for(let k=0;k<n;k++){
      const yo=k*s*0.62;
      bbAlpha.addOrientedRect(sprites.px,x,y,lift+yo,s*1.15,s*0.28,-0.64,168,196,214,150);
      bbAlpha.addOrientedRect(sprites.px,x,y,lift+yo,s*1.15,s*0.28,0.64,168,196,214,150);
    }
  };
  if(orthoSpan<1700){
    for(let bi=0;bi<blds.length;bi++){
      const Bd=blds[bi];
      if(!Bd.alive||Bd.prog<1||!vis(Bd.x,Bd.y,150)) continue;
      if(!fogEntityVisible(Bd.team,Bd.x,Bd.y)) continue;
      const T=BT[Bd.type], H=gh(Bd.x,Bd.y);
      const lv=typeof bldDisplayLevel==='function'?bldDisplayLevel(Bd):(Bd.type==='fac'?(Bd.tier===2?2:1):(Bd.lvl||1));
      putRankMark(Bd.x,Bd.y,H+T.size*1.34+10*rkPx,lv);
    }
    for(let rk=0;rk<_mfRuN;rk++){
      const i=_mfRuI[rk];
      if(!uvet[i]||!vis(ux[i],uy[i],90)) continue;
      if(!mfRenderUnitFogVisible(i)) continue;
      if(typeof mfIconStackSkip==='function'&&mfIconStackSkip(i)) continue;
      const T=TYPES[utype[i]], H=mfRenderUnitHeight(i,T,ux[i],uy[i]);
      const vs=T.size*(T.vscale||1);
      putRankMark(ux[i],uy[i],H+vs*(T.air?1.22:1.58)+10*rkPx,uvet[i]);
    }
  }

  if(typeof mfPerfEnd==='function')mfPerfEnd('renderAdditiveEffects');
  /* ---- billboard pass -------------------------------------------------
     Sprites last: alpha-blended smoke first so it reads as volume against the
     world, then additive light on top of everything. */
  if(typeof mfPerfBegin==='function') mfPerfBegin('billboards');
  beginBB();
  gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
  bbAlpha.flush(gl);
  /* One custom mesh batch for every visible artillery trajectory. This pass
     keeps real depth while the later legacy glows intentionally do not. */
  if(typeof mfOrdnanceTrailFlush==='function')mfOrdnanceTrailFlush(matVP,t);
  /* 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,
      (gl&&gl.drawingBufferHeight)||((typeof VH==='number'&&typeof DPR==='number')?VH*DPR: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);
  }
  /* High/Cinematic cloud recipes are marched after ordinary alpha and GPU
     effects, but before tactical icons. The queue retained the exact recipe
     descriptors: if any post dependency fails, replay those descriptors into
     this same frame's legacy alpha batch. That keeps one presentation owner,
     never a persistent suppress bit, and never an invisible weather frame. */
  if(mfCloudPostArmed){
    let cloudPostPresented=false;
    try{if(typeof mfCloudPostDrawPending==='function')cloudPostPresented=!!mfCloudPostDrawPending(Sun);}catch(e){cloudPostPresented=false;}
    if(!cloudPostPresented&&typeof mfCloudPostEmitFallback==='function'&&(sprites.cloud||sprites.smoke||sprites.glow)){
      const cloudSpr=sprites.cloud||sprites.smoke||sprites.glow;
      const fallbackN=mfCloudPostEmitFallback(L=>bbAlpha.add(cloudSpr,L.x,L.y,L.z,L.size,L.rotation,L.r,L.g,L.b,L.a));
      if(fallbackN>0){
        gl.enable(gl.BLEND);gl.enable(gl.DEPTH_TEST);gl.depthMask(false);gl.disable(gl.CULL_FACE);
        beginBB();gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);bbAlpha.flush(gl);
      }
    }
  }
  /* 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;
  /* Icon sheet is still on unit 0. Present samples 5/6 — do not begin3D
     (that rebinds 4/5/6 to matTex). Restore 0 only. */
  if(typeof endBB==='function') endBB();
  else { gl.activeTexture(gl.TEXTURE0); if(typeof matTex!=='undefined'&&matTex) gl.bindTexture(gl.TEXTURE_2D,matTex); }

  /* Authored macro layers use their own atlas binding and standard alpha.
     Drawing after the legacy batch keeps exactly one billboard per queued
     event and lets the pass restore the expected 3D program/samplers. */
  if(typeof macroFxDraw==='function') macroFxDraw(S_nA);
  if(typeof mfPerfEnd==='function') mfPerfEnd('billboards');

  gl.depthMask(true);
  gl.disable(gl.BLEND);
  gl.enable(gl.CULL_FACE);
  if(aoActive){
    if(typeof mfPerfBegin==='function') mfPerfBegin('present');
    aoPresent();
    if(typeof mfPerfEnd==='function') mfPerfEnd('present');
  }
  /* 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);
  if(typeof mfPerfEnd==='function'){
    mfPerfGpuEnd();mfPerfEnd('render');
    mfPerfCount('drawCalls',drawCalls);mfPerfCount('triangles',triCount);
  }
}