;
;
/* ============================================================
   INPUT — touch camera, selection, orders (mobile-first)
   ============================================================ */
const ptrs=new Map();
let boxMode=false, boxStart=null, boxAdd=false, pinchD=0, pinchZ=1, tapT=0, pinchA=0, pinchYaw=0;
/* True from the moment a gesture has two fingers down until every finger has
   lifted. Pointer events are delivered one at a time, so when the second
   finger of a pinch is released ptrs.size is back to 0 and that release is
   indistinguishable from a deliberate one-finger tap. Two bugs came out of
   that: a two-finger tap issued a ground move order at the second finger's
   position, and a pinch begun during box-select committed a selection
   rectangle stretching to wherever the zoom happened to end. */
let multiTouch=false;
let pinchMY=0, pinchPitch=0.92;
let openBld=-1;             // building whose menu is open
let shake=0;

/* --------------------------------------------------------------------------
   UI ACTION SAFETY
   Benign navigation remains one tap. Disruptive gameplay actions wait for a
   completed, non-drag gesture; irreversible actions retain their existing
   confirmation and updater rollback gains one here. Capture phase is required:
   the legacy owners live in main.js and listen on both pointerdown and pointerup.
   -------------------------------------------------------------------------- */
const MF_UI_DESTRUCTIVE_IDS=new Set(['bp_sell','profReset','profDel','quitBtn','updRoll','saveFilePut']);
const MF_UI_DISRUPTIVE_IDS=new Set([
  'setupStart','weeklyGo','goContinueBtn','deployBtn','placeOk','upBtn','bp_up','bp_fire',
  'rallyBtn','queueBtn','patrolBtn','holdBtn','formBtn','moveBtn','stopBtn','modeBtn',
  'abOver','abHeal','abRage','abLance','abEmp','abJump','abClass','abBarrage'
]);
const MF_UI_EXISTING_CONFIRM=new Set(['bp_sell','profReset','profDel','quitBtn','saveFilePut']);
const MF_UI_CONFIRM_COPY={updRoll:'Revert to the packaged build? The installed update will be removed and the game will restart.'};
let mfUiReplay=false,mfUiLastTarget=null,mfUiLastAt=-1e9,mfUiPanelDismissedAt=-1e9;
const mfUiGestures=new Map(),mfUiBlockedPointers=new Set(),mfUiDownTargets=new Map();
const mfUiSafetyAudit={downs:0,guarded:0,bounceBlocks:0,panelBlocks:0,releases:0,replays:0};
function mfUiControlTarget(node){return node&&node.closest?node.closest('button,[role="button"],input,select,textarea,.bcard'):null;}
/* Only bypass the global release guard when the card proves that its own
   caller already commits on release. Standard production/build cards expose
   previewKind; extension cards opt in after binding mfBindTap. A bare bcard is
   deliberately unsafe — Field Study cards are legacy pointerdown callers. */
function mfUiLocallyReleaseGuarded(el){
  return !!(el&&el.matches('.bcard')&&(
    el.dataset.mfReleaseSafe==='1'||el.dataset.previewKind==='unit'||el.dataset.previewKind==='building'));
}
function mfUiRisk(el){
  if(!el)return 'benign';
  if(MF_UI_DESTRUCTIVE_IDS.has(el.id))return 'destructive';
  if(MF_UI_DISRUPTIVE_IDS.has(el.id)||el.matches('.abtn,.hotSlot,.hotUtility'))return 'disruptive';
  if(el.matches('.bcard')&&(el.closest('#prodGrid')||el.closest('#buildGrid')))return 'disruptive';
  return 'benign';
}
function mfUiMarkPanelDismiss(){mfUiPanelDismissedAt=performance.now();}
function mfUiReplayGesture(el,ev){
  if(!el||!el.isConnected)return;
  mfUiReplay=true;
  try{
    /* mfBindTap rejects explicitly non-primary contacts. Synthetic
       PointerEvents default isPrimary to false, so guarded controls bound via
       mfBindTap became inert when this replay omitted the real contact state. */
    const init={bubbles:true,cancelable:true,isPrimary:ev.isPrimary!==false,pointerId:ev.pointerId||1,pointerType:ev.pointerType||'touch',clientX:ev.clientX||0,clientY:ev.clientY||0,button:0,buttons:1};
    const PE=typeof PointerEvent==='function'?PointerEvent:Event;
    el.dispatchEvent(PE===Event?new Event('pointerdown',{bubbles:true,cancelable:true}):new PE('pointerdown',init));
    init.buttons=0;
    el.dispatchEvent(PE===Event?new Event('pointerup',{bubbles:true,cancelable:true}):new PE('pointerup',init));
  }finally{mfUiReplay=false;}
  mfUiLastTarget=el;mfUiLastAt=performance.now();
  mfUiSafetyAudit.replays++;
}
function mfUiControlInventory(root){
  root=root||document;
  const out={benign:[],disruptive:[],destructive:[]};
  root.querySelectorAll('button,[role="button"],input,select,textarea,.bcard').forEach(el=>{
    const risk=mfUiRisk(el),r=el.getBoundingClientRect(),localRelease=mfUiLocallyReleaseGuarded(el);
    el.dataset.mfRisk=risk;
    out[risk].push({id:el.id||'',className:String(el.className||''),label:(el.getAttribute('aria-label')||el.textContent||el.getAttribute('placeholder')||el.tagName).replace(/\s+/g,' ').trim().slice(0,100),visible:getComputedStyle(el).display!=='none'&&r.width>0&&r.height>0,protection:risk==='destructive'?(MF_UI_EXISTING_CONFIRM.has(el.id)?'existing-confirmation':'confirmation'):(risk==='disruptive'?(localRelease?'local-release-after-drag-threshold':'global-release-after-drag-threshold'):'one-tap')});
  });
  return out;
}
if(typeof window!=='undefined'){
  window.mfUiControlInventory=mfUiControlInventory;
  window.mfUiSafetyProbe=()=>({replay:mfUiReplay,lastTarget:mfUiLastTarget&&mfUiLastTarget.id||'',sinceLast:performance.now()-mfUiLastAt,sincePanelDismiss:performance.now()-mfUiPanelDismissedAt,pending:mfUiGestures.size,blocked:mfUiBlockedPointers.size,audit:{...mfUiSafetyAudit}});
}

/* Window capture is intentional. Several legacy panels own document-capture
   listeners and may stop propagation; a global cross-control/tap-through guard
   must observe the contact before any one panel can consume it. */
const mfUiEventRoot=typeof window!=='undefined'?window:document;
mfUiEventRoot.addEventListener('pointerdown',ev=>{
  if(mfUiReplay)return;
  mfUiSafetyAudit.downs++;
  const el=mfUiControlTarget(ev.target),now=performance.now(),pid=ev.pointerId||1;
  mfUiDownTargets.set(pid,el);
  if(!el)return;
  const risk=mfUiRisk(el);
  /* Destructive two-step actions still need two COMPLETED taps. A second
     pointerdown inside the hardware-bounce window is never confirmation, even
     on the same control; the normal 2.6-3s confirmation window remains intact. */
  /* Never spend a benign menu/navigation tap on the debounce window left by
     another control. That made a fast FEED-close → BUILD tap appear dead even
     though neither action could damage state. Risky actions still require a
     clean contact, and destructive confirmation can never be hardware bounce. */
  /* A benign navigation tap is allowed to reveal a risky control and be
     followed immediately by a deliberate press. In particular, ABILITIES then
     a hot-slot is one fluent thumb action; treating the tab's completed tap as
     hardware bounce silently discarded the power and let the next map tap
     become MOVE. Preserve bounce rejection only when the previous control was
     itself disruptive/destructive. */
  if(mfUiLastTarget&&now-mfUiLastAt<180&&risk!=='benign'&&mfUiRisk(mfUiLastTarget)!=='benign'){
    mfUiBlockedPointers.add(pid);mfUiSafetyAudit.bounceBlocks++;ev.preventDefault();ev.stopImmediatePropagation();return;
  }
  /* Production/build cards own a release/drag contract in hud.js (build cards
     through mfBindTap, production cards through their batch-aware handler). */
  const locallyGuarded=mfUiLocallyReleaseGuarded(el)&&(el.closest('#prodGrid')||el.closest('#buildGrid'));
  if(risk==='benign'||locallyGuarded||(risk==='destructive'&&MF_UI_EXISTING_CONFIRM.has(el.id))){
    mfUiLastTarget=el;mfUiLastAt=now;return;
  }
  if(risk==='disruptive'&&now-mfUiPanelDismissedAt<220){
    mfUiBlockedPointers.add(pid);mfUiSafetyAudit.panelBlocks++;ev.preventDefault();ev.stopImmediatePropagation();
    if(typeof toast==='function')toast('Panel closed — tap the action again to confirm');
    return;
  }
  mfUiGestures.set(pid,{el,x:ev.clientX,y:ev.clientY,t:now,moved:false,risk});
  mfUiSafetyAudit.guarded++;
  ev.preventDefault();ev.stopImmediatePropagation();
},true);
mfUiEventRoot.addEventListener('pointermove',ev=>{
  const g=mfUiGestures.get(ev.pointerId||1);if(!g)return;
  if(Math.hypot(ev.clientX-g.x,ev.clientY-g.y)>10)g.moved=true;
},true);
mfUiEventRoot.addEventListener('pointerup',ev=>{
  if(mfUiReplay)return;
  mfUiSafetyAudit.releases++;
  const pid=ev.pointerId||1,down=mfUiDownTargets.get(pid),up=mfUiControlTarget(ev.target);
  mfUiDownTargets.delete(pid);
  if(mfUiBlockedPointers.has(pid)){mfUiBlockedPointers.delete(pid);mfUiGestures.delete(pid);ev.preventDefault();ev.stopImmediatePropagation();return;}
  /* A panel disappearing under the finger must not turn that release into an
     ability activation on the newly exposed command bar. */
  if(up&&up!==down&&mfUiRisk(up)==='disruptive'){
    mfUiGestures.delete(pid);ev.preventDefault();ev.stopImmediatePropagation();return;
  }
  const g=mfUiGestures.get(pid);if(!g)return;
  mfUiGestures.delete(pid);ev.preventDefault();ev.stopImmediatePropagation();
  if(g.moved||performance.now()-g.t>900||!g.el.isConnected)return;
  const copy=MF_UI_CONFIRM_COPY[g.el.id];
  if(g.risk==='destructive'&&copy){
    const go=()=>mfUiReplayGesture(g.el,ev);
    if(typeof accConfirm==='function')accConfirm(copy,go);
    else if(window.confirm(copy))go();
    return;
  }
  mfUiReplayGesture(g.el,ev);
},true);
mfUiEventRoot.addEventListener('pointercancel',ev=>{
  const pid=ev.pointerId||1;mfUiGestures.delete(pid);mfUiBlockedPointers.delete(pid);mfUiDownTargets.delete(pid);
},true);

/* CAMERA AUTHORITY.
   Anything that moves the camera automatically has to yield to the player the
   moment they touch it. Without that, panning away to scout a landing site or
   to look at a fight fought the auto-follow every frame and the view was
   dragged straight back — which reads as the camera, the ship or the units
   snapping back. `camUser()` is called from every manual camera input and
   suspends automatic movement for a few seconds afterwards. */
let camUserT=0;
function camUser(){ camUserT=4.0; }
function zoomSpanMax(){ return typeof spanMaxNow==='function'?spanMaxNow():SPAN_MAX; }
function zoomSpanMin(){ return typeof spanMinNow==='function'?spanMinNow():200; }
function camAutoAllowed(){ return camUserT<=0; }
function camAuthTick(dt){ if(camUserT>0) camUserT-=dt; }
/* Tapping the ground while the dropship is still airborne orders it there and
   keeps the camera with it, so flying the ship never means losing sight of it —
   but only while the player is not driving the camera themselves. */
function carrierFollow(){
  if(!camAutoAllowed()) return;
  if(carrier.active&&carrier.phase<2){
    cam.x+=(carrier.x-cam.x)*0.22; cam.y+=(carrier.y-cam.y)*0.22;   // glide, never teleport
    clampCam(); camUpdateMatrices();
  }
}
function selCount(){ let n=0; for(let i=0;i<unitHigh;i++) if(ualive[i]&&usel[i]) n++; return n; }
function uiCommandAck(action,count,wx,wy){
  if(typeof radioAck==='function') return radioAck(action,count,wx,wy);
  sfx('radio',wx,wy,0.9); return true;
}
function clearSel(){
  usel.fill(0);activePlatoon=-1;armFormation=false;orderPreview=null;orderConfirm=null;
  /* STOP vs HOLD is HUD-only (both write uhold=1). Leaving the bits set meant
     a later select of a recycled slot, or a unit that had since been given a
     new order off-selection, still read STOP. */
  if(ustopDisp) ustopDisp.fill(0);
  if(armPatrol)cancelPatrolDraft(true);
  if(armQueue)cancelQueueDraft(true);
  const fb=document.getElementById('formBtn');if(fb)fb.classList.remove('on');
  updateGroupBadges();updateSelInfo();
}
function selectArmy(){
  clearSel(); let n=0;
  const localHero=typeof mfLocalCommander==='function'?mfLocalCommander():heroIdx;
  for(let i=0;i<unitHigh;i++) if(ualive[i]&&(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(i):uteam[i]===0)&&i!==localHero){ usel[i]=1; n++; }
  toast(n?('⚔ Army selected — '+n+' units'):'No army yet — build a Factory');
  updateSelInfo(); if(n)uiCommandAck('select',n);else sfx('ui');
}
/* The most frequent RTS question after a base expands is "where is my builder?"
   This selects idle Constructors only, recentres once, and does not steal a
   working engineer off a repair or construction order. */
function selectIdleBuilders(){
  clearSel(); let n=0,fx=0,fy=0;
  for(let i=0;i<unitHigh;i++) if(ualive[i]&&(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(i):uteam[i]===0)&&TYPES[utype[i]].builder&&ustate[i]===0){
    usel[i]=1; n++; fx+=ux[i]; fy+=uy[i];
  }
  if(!n){ toast('No idle Constructors — build one or finish current orders'); sfx('reject'); return; }
  cam.x=fx/n; cam.y=fy/n; clampCam(); camUpdateMatrices();
  updateSelInfo(); toast('🔧 '+n+' idle Constructor'+(n===1?'':'s')+' selected'); uiCommandAck('select',n,cam.x,cam.y);
}
function selectHero(){
  const h=typeof mfLocalCommander==='function'?mfLocalCommander():heroIdx;
  if(h<0){ toast('Commander is down'); return; }
  clearSel(); usel[h]=1;
  cam.x=ux[h]; cam.y=uy[h]; clampCam();
  updateSelInfo(); uiCommandAck('select',1,ux[h],uy[h]);
}
/* HUD-only: Stop and Hold both write uhold=1 (idle must not chase). The
   selection line still has to say STOP vs HOLD. Lives here — next to the
   orders — because a `let` bit in hudflow.js is declared AFTER hud.js, so
   updateSelInfo's lookup never saw it on packed boot (separate classic
   scripts). */
var ustopDisp=null;
function markStopDisp(on){
  if(!ustopDisp&&typeof MAXU==='number') ustopDisp=new Uint8Array(MAXU);
  if(!ustopDisp) return;
  for(let i=0;i<unitHigh;i++) if(ualive[i]&&usel[i]) ustopDisp[i]=on?1:0;
}
function stopSelected(){
  let n=0;
  for(let i=0;i<unitHigh;i++) if(ualive[i]&&usel[i]){
    /* Stop is a freeze, not idle. Idle acquisition uses aggro range and then
       walks (the chase that made Stop feel like a delayed Attack). Hold already
       acquires at weapon range and refuses wantMove — Stop writes that stance
       so a new lock can still be shot if it is already in range. */
    ustate[i]=0;utgt[i]=-1;utgtg[i]=-1;uhold[i]=1;umarch[i]=0;
    utx[i]=ux[i];uty[i]=uy[i];uPatrolRoute[i]=-1;uMoveCohort[i]=-1;
    /* Stop means stop. A surviving waypoint chain or escort anchor would walk
       the unit off again on the next tick, which is exactly the "Stop did
       nothing" complaint this function already exists to answer. */
    queueClear(i);uGuard[i]=-1;
    n++;
  }
  markStopDisp(true);
  if(n){ uiCommandAck('stop',n); updateSelInfo(); }
  else sfx('reject');
}
/* ---------- formations ---------- */
const FORMS=[
 {id:'spread', em:'⋯', nm:'Spread'},
 {id:'line',   em:'☰', nm:'Battle Line'},
 {id:'wedge',  em:'⌃', nm:'Wedge'},
 {id:'box',    em:'▦', nm:'Box'},
 {id:'column', em:'⋮', nm:'Column'},
 {id:'arc',    em:'⌒', nm:'Arc'},
];
let selFormation=0, armFormation=false, orderPreview=null, orderConfirm=null;
let patrolDraft=null;
function formationMembers(){
  const out=[];
  for(let i=0;i<unitHigh;i++) if(ualive[i]&&usel[i]) out.push(i);
  /* Put tough short-range chassis in front and support/air frames in depth.
     Stable slot order keeps a platoon from shuffling after every command. */
  out.sort((a,b)=>{
    const A=TYPES[utype[a]],B=TYPES[utype[b]];
    const ar=(A.air?900:0)+(A.naval?500:0)+(utype[a]===19?700:0)+(A.rng||0)-A.size*3;
    const br=(B.air?900:0)+(B.naval?500:0)+(utype[b]===19?700:0)+(B.rng||0)-B.size*3;
    return ar-br||a-b;
  });
  return out;
}
/* FORMATION TIGHTENING. Spacing is decided per order; if the platoon forms up
   with the enemy already inside `FORM_TIGHT_R`, the spread shrinks so the whole
   line reaches the fight at once instead of trickling in single-file. It is a
   cluster, not a stack: unitSeparation in sim.js still enforces physical
   separation, so the tighter goals just make the wall denser on contact. */
const FORM_TIGHT_R=170, FORM_TIGHT_MUL=0.72;
function formationSpacing(sel){
  let sp=31,cx2=0,cy2=0;
  for(const i of sel){
    const T=TYPES[utype[i]];
    /* The baked 3D card is rendered at 2.05x logical `size`. Collision radii
       alone therefore produce legal but visibly interpenetrating formations.
       This clearance tracks the opaque silhouette while retaining a bounded
       footprint for mixed or Titan platoons. */
    sp=Math.max(sp,Math.max(T.r*2+7,T.size*1.8+8));
    cx2+=ux[i];cy2+=uy[i];
  }
  if(sel.length){ cx2/=sel.length; cy2/=sel.length; }
  let near=false;
  const localTeam=typeof mfLocalTeam==='function'?mfLocalTeam():0;
  forUnitsIn(cx2,cy2,FORM_TIGHT_R,j=>{ if(!near&&ualive[j]&&uteam[j]!==localTeam) near=true; });
  if(near) sp*=FORM_TIGHT_MUL;
  return clamp(sp,near?24:31,92);
}
function formationOffsets(n,form,spacing){
  const out=[];
  const sp=spacing||31;
  if(form==='line'){
    const perRow=Math.max(2,Math.min(18,Math.ceil(n/2)));
    for(let k=0;k<n;k++){
      const r2=(k/perRow)|0, f=k%perRow;
      out.push([(f-(Math.min(perRow,n-r2*perRow)-1)/2)*sp, r2*sp*1.10]);
    }
  } else if(form==='wedge'){
    let k=0,r2=0;
    while(k<n){
      const inRow=r2+1;
      for(let f=0;f<inRow&&k<n;f++,k++) out.push([(f-r2/2)*sp, r2*sp*.94]);
      r2++;
    }
  } else if(form==='box'){
    const perRow=Math.max(2,Math.ceil(Math.sqrt(n)));
    for(let k=0;k<n;k++){
      const r2=(k/perRow)|0, f=k%perRow;
      out.push([(f-(perRow-1)/2)*sp, r2*sp]);
    }
  } else if(form==='column'){
    const perRow=Math.min(3,Math.max(1,n));
    for(let k=0;k<n;k++){
      const r2=(k/perRow)|0, f=k%perRow, here=Math.min(perRow,n-r2*perRow);
      out.push([(f-(here-1)/2)*sp,r2*sp*1.12]);
    }
  } else if(form==='arc'){
    const perRow=Math.max(3,Math.ceil(n/2));
    for(let k=0;k<n;k++){
      const r2=(k/perRow)|0, f=k%perRow, here=Math.min(perRow,n-r2*perRow);
      const q=here<=1?0:(f/(here-1)-0.5)*2, rad=sp*2+here*sp*.16+r2*sp*1.12;
      out.push([Math.sin(q*.92)*rad,(1-Math.cos(q*.92))*rad+r2*sp*1.08]);
    }
  } else {
    const spread=Math.max(sp*.66,Math.sqrt(n)*sp*.42);
    for(let k=0;k<n;k++){
      const a=k*2.399963, d=spread*Math.sqrt((k+.5)/Math.max(1,n));
      out.push([Math.cos(a)*d,Math.sin(a)*d]);
    }
  }
  return out;
}
/* THE PREVIEW IS DRAWN EVERY FRAME; THE ASSIGNMENT IS NOT.
   render3d.js called formationTargets() straight from the draw for as long as
   the formation preview was on screen — a full offset build, sort and map per
   frame for the whole selection. That kind of cost never LOOKS wrong: main.js
   absorbs it by sliding simDt, so the match just runs slow and nothing on
   screen admits why. The solve belongs to the pointer event that moved the
   target, so memoise it on the preview object and let the draw read the answer.
   It lives here, beside the solver it caches, so the renderer holds no path to
   the expensive call at all. */
function formationPreviewSlots(o,members,form){
  if(!o||!members||!members.length) return [];
  /* Ghosts only. orderMove still solves the full selection. Patrol already
     keeps 36 route stands; 1000 hologram rings is the same fillrate trap as
     per-unit selection rings. Sample members so this never walks the army. */
  const n=members.length, stride=Math.max(1,Math.ceil(n/36));
  const key=Math.round(o.x)+','+Math.round(o.y)+','+form+','+n+','+stride
    +','+(members[0]|0)+','+(members[n-1]|0);
  if(o._slotKey===key) return o._slots||[];
  o._slotKey=key;
  let sampled=members;
  if(stride>1){
    sampled=[];
    for(let k=0;k<n;k+=stride) sampled.push(members[k]);
    if(sampled[sampled.length-1]!==members[n-1]) sampled.push(members[n-1]);
  }
  o._slots=formationTargets(sampled,o.x,o.y,form);
  return o._slots;
}
function formationTargets(sel,wx,wy,form,angle){
  if(!sel.length) return [];
  if(angle==null){
    let cx2=0,cy2=0; for(const i of sel){cx2+=ux[i];cy2+=uy[i];}
    angle=Math.atan2(wy-cy2/sel.length,wx-cx2/sel.length);
  }
  const ct=Math.cos(angle),st=Math.sin(angle),offs=formationOffsets(sel.length,form,formationSpacing(sel));
  return offs.map(o=>{
    let x=clamp(wx-o[1]*ct-o[0]*st,15,MAP-15),y=clamp(wy-o[1]*st+o[0]*ct,15,MAP-15);
    if(typeof battlefieldClampPoint==='function'){const p=battlefieldClampPoint(x,y,15);x=p[0];y=p[1];}
    return {x,y};
  });
}
function setFormation(n,quiet){
  selFormation=((n%FORMS.length)+FORMS.length)%FORMS.length;
  const F=FORMS[selFormation], b=document.getElementById('formBtn');
  if(b){b.querySelector('.em').textContent=F.em;b.querySelector('span:nth-child(2)').textContent=F.nm;}
  if(!quiet) toast(F.em+' '+F.nm+' armed — drag the hologram and release to place '+selCount()+' units');
}
/* ARMING ANY MAP-TAP MODE DISARMS THE RALLY FLAG.
   onTap tests `armRally>=0` before selection, before the queue planner and
   before patrol, so an armed rally silently EATS the next map tap no matter
   what the player armed after it. Sequence that reproduces it: open a Factory,
   tap SET RALLY, change your mind and tap PATROL (or QUEUE, or FORM) — the
   planner toasts "tap waypoints", the first tap plants a rally flag there
   instead and the planner is still sitting at zero waypoints. Nothing else
   cancels a rally arm: closeMenus() does not, and resetInputState() — whose
   own comment promises "input starts from a genuinely idle state" — did not
   list it either. Last instruction wins. */
function disarmRally(){ armRally=-1; }
function armFormationOrder(){
  if(!selCount()){toast('Select units first');return;}
  disarmRally();
  setFormation(selFormation+1,false);armFormation=true;
  const b=document.getElementById('formBtn');if(b)b.classList.add('on');
  sfx('ui');
}
/* ATTACK-MOVE vs MOVE.
   Every order used to be attack-move: `ustate=2`, acquire anything on the way.
   The simulation has always supported a plain reposition state (`ustate===1`,
   which suppresses acquisition and drops back to idle on arrival) — it was
   simply never written by anything. Without it there is no retreat, no
   repositioning under fire and no walking past a fight, which is the highest
   frequency tactical decision in the genre. `moveMode` is the player's toggle;
   double-tap/click on empty ground forces a one-shot retreat without flipping
   it. `orderMove` honours both. */
let moveMode=0;                                  // 0 = attack-move, 1 = move only
function toggleMoveMode(){
  moveMode=moveMode?0:1;
  const b=document.getElementById('moveBtn');
  if(b){ b.classList.toggle('on',!!moveMode);
         const l=b.querySelector('.lbl'); if(l) l.textContent=moveMode?'MOVE':'A-MOVE'; }
  toast(moveMode?'➤ MOVE — units reposition without stopping to fight'
                :'⚔ ATTACK-MOVE — units engage what they meet');
  sfx('ui');
}
function orderMove(wx,wy,patrol,retreat){
  const sel=formationMembers();
  if(!sel.length) return false;
  if(typeof battlefieldClampPoint==='function'){const p=battlefieldClampPoint(wx,wy,24);wx=p[0];wy=p[1];}
  const form=FORMS[selFormation].id;
  const targets=formationTargets(sel,wx,wy,form);
  const cohort=patrol?-1:allocMoveCohort(sel,targets,selFormation);
  /* Retreat/move-only is ustate 1: sim skips acquisition and will not chase a
     leftover lock. Attack-move stays ustate 2. Double-tap ground passes
     `retreat` so the A-MOVE toggle is not required to break contact. */
  const moveOnly=!patrol&&(retreat||moveMode),routeFields={};let routeField=-1;
  for(let k=0;k<sel.length;k++){
    const i=sel[k],T=TYPES[utype[i]],rawx=targets[k].x,rawy=targets[k].y;
    const legal=T.naval?(findWater(rawx,rawy)||[ux[i],uy[i]]):T.air?[rawx,rawy]:findLand(rawx,rawy);
    const tx=legal[0],ty=legal[1];
    ustate[i]=patrol?5:(moveOnly?1:2);
    utgt[i]=-1; utgtg[i]=-1;
    /* A-MOVE/patrol keep the click as hull goal while shooting. Retreat/MOVE
       must not: umarch is fire-on-the-move, the opposite of breaking contact. */
    umarch[i]=moveOnly?0:1;
    /* One strategic route per movement/clearance cohort. Exact formation
       slots stay in utx/uty and take over only for the measured final approach.
       Deferred creation makes pointer release acknowledgement independent of
       the 15-25ms full-grid flood measured on target hardware. */
    const clear=mfNavUnitClearance(T),routeKey=(T.naval?'w':'g')+clear;
    if(!T.air&&routeFields[routeKey]==null){
      const strategic=T.naval?(findWater(wx,wy)||legal):findLand(wx,wy);
      routeFields[routeKey]=requestField(strategic[0],strategic[1],!!T.naval,clear,true);
    }
    ufield[i]=T.air?-1:routeFields[routeKey]; uhold[i]=0;
    if(routeField<0&&ufield[i]>=0)routeField=ufield[i];
    uPatrolRoute[i]=-1;uPatrolStep[i]=0;
    /* A direct order replaces the plan, it does not append to it. Appending is
       the queue planner's job and it has its own commit. */
    queueClear(i);uGuard[i]=-1;
    uMoveCohort[i]=cohort;
    if(patrol){ upx1[i]=ux[i]; upy1[i]=uy[i]; upx2[i]=clamp(tx,15,MAP-15); upy2[i]=clamp(ty,15,MAP-15); }
    utx[i]=clamp(tx,15,MAP-15);
    uty[i]=clamp(ty,15,MAP-15);
    if(T.air&&typeof mfAirIssueMission==='function'){
      /* Air attack-move/patrol is CAP over the ordered area; MOVE is a direct
         relocation. Both enter the fixed-step air authority immediately so
         the generic state cannot be overwritten by its previous orbit. */
      mfAirIssueMission(i,(patrol||!moveOnly)?'cap':'none',{x:utx[i],y:uty[i]});
    }
  }
  addParticle(3,wx,wy,0,0,.5,26, patrol?120:65, patrol?255:200, patrol?170:255);
  if(!patrol){
    /* The route the field will actually walk, drawn at the moment of the
       order (src/ui/orderfx.js) - amber for attack-move, cyan for move. */
    if(typeof moveFxOrder==='function') moveFxOrder(sel,wx,wy,routeField,moveOnly?1:0);
    /* And the formation footprint. This reuses the confirm hologram that
       formation drags always had, so a plain tap now shows where each unit
       will STAND, not just where the tap landed. `noLine` suppresses the
       straight centroid->destination beam - the traced route above replaces
       it, and drawing both would show two contradictory paths whenever the
       field bends around water. */
    orderConfirm={x:wx,y:wy,members:sel.slice(),form:selFormation,
                  until:performance.now()+950,noLine:1};
  }
  markStopDisp(false);
  if(retreat) toast('➤ RETREAT — dropping combat');
  uiCommandAck(patrol?'patrol':(retreat?'retreat':'move'),sel.length,wx,wy);
  updateSelInfo();
  return true;
}
function patrolButtonState(){
  const b=document.getElementById('patrolBtn');if(!b)return;
  b.classList.toggle('on',!!armPatrol);
  const l=b.querySelector('span:nth-child(2)');
  if(l)l.textContent=armPatrol&&patrolDraft&&patrolDraft.pts.length>1?'START':'PATROL';
}
function mfNetworkPlanBlocked(label){
  const C=window.MFMatchCommandConsumer;
  if(!C||!C.requiresLockstep())return false;
  toast(label+' UNAVAILABLE IN NETWORK MATCH — multi-step orders are not synchronized yet');
  sfx('reject');return true;
}
function beginPatrolDraft(){
  const sel=formationMembers();
  if(!sel.length){toast('Select units first');return false;}
  let x=0,y=0;for(const i of sel){x+=ux[i];y+=uy[i];}
  patrolDraft={members:sel.map(i=>[i,ugen[i]]),pts:[{x:x/sel.length,y:y/sel.length}],form:selFormation};
  disarmRally();
  armPatrol=true;armFormation=false;orderPreview=null;orderConfirm=null;patrolButtonState();
  toast('PATROL PLAN — tap up to 5 waypoints, then tap START');sfx('ui');return true;
}
function addPatrolWaypoint(wx,wy){
  if(!patrolDraft)return;
  let px=clamp(wx,20,MAP-20),py=clamp(wy,20,MAP-20);
  if(typeof battlefieldClampPoint==='function'){const q=battlefieldClampPoint(px,py,24);px=q[0];py=q[1];}
  const p={x:px,y:py};
  const last=patrolDraft.pts[patrolDraft.pts.length-1];
  if(Math.hypot(p.x-last.x,p.y-last.y)<35){toast('Place the next waypoint farther along the route');return;}
  if(patrolDraft.pts.length>=6){toast('Route has 5 waypoints — tap START');return;}
  patrolDraft.pts.push(p);patrolButtonState();
  addParticle(3,p.x,p.y,0,0,.55,28,120,255,190);
  toast('Waypoint '+(patrolDraft.pts.length-1)+' placed — add another or tap START');sfx('confirm');
}
function cancelPatrolDraft(quiet){
  armPatrol=false;patrolDraft=null;patrolButtonState();
  if(!quiet){toast('Patrol plan cancelled');sfx('reject');}
}
function patrolTargetRows(sel,pts,formId){
  const form=FORMS[formId].id,targets=[];
  for(let j=0;j<pts.length;j++){
    const prev=pts[(j-1+pts.length)%pts.length],next=pts[(j+1)%pts.length];
    targets.push(formationTargets(sel,pts[j].x,pts[j].y,form,Math.atan2(next.y-prev.y,next.x-prev.x)));
  }
  return targets;
}
function domainOrderPoint(i,P,strategic,routeFields){
  const T=TYPES[utype[i]];
  if(T.air)return {x:P.x,y:P.y,field:-1};
  const L=T.naval?(findWater(P.x,P.y)||[ux[i],uy[i]]):findLand(P.x,P.y);
  const clear=mfNavUnitClearance(T);
  let field=-1;
  if(routeFields){
    const key=(T.naval?'w':'g')+clear;
    if(routeFields[key]==null){
      const S=strategic||P,SL=T.naval?(findWater(S.x,S.y)||L):findLand(S.x,S.y);
      routeFields[key]=requestField(SL[0],SL[1],!!T.naval,clear,true);
    }
    field=routeFields[key];
  }else field=requestField(L[0],L[1],!!T.naval,clear);
  return {x:L[0],y:L[1],field};
}
/* Prune generation-stale handles and compact the remaining slots. Leaving a
   dead unit's hole in every waypoint gradually turns a damaged platoon into a
   sparse, lopsided route; adopting a recycled slot is worse. */
function refreshPatrolRoute(ri,force){
  const R=patrolRoutes[ri];if(!R)return false;
  const live=(R.members||[]).filter(e=>ualive[e[0]]&&ugen[e[0]]===e[1]&&(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(e[0]):uteam[e[0]]===0)&&uPatrolRoute[e[0]]===ri);
  if(!live.length){patrolRoutes[ri]=null;return false;}
  if(force||live.length!==R.members.length){
    const sel=live.map(e=>e[0]);R.members=live;R.targets=patrolTargetRows(sel,R.pts,R.form);
    const step=R.step==null?1:R.step,routeFields={};
    for(let k=0;k<sel.length;k++){
      const i=sel[k],P=domainOrderPoint(i,R.targets[step][k],R.pts[step],routeFields);uPatrolSlot[i]=k;uPatrolStep[i]=step;
      utx[i]=P.x;uty[i]=P.y;ufield[i]=P.field;
    }
  }
  return true;
}
/* A patrol corner is a platoon decision, not a per-unit trigger. The previous
   implementation let the first fast vehicle turn alone, while every slower
   hull remained on the old leg. A shared step waits for the formation, with a
   bounded quorum escape for a genuinely blocked straggler. */
function tickPatrolRoutes(dt){
  /* sim.js already calls this once per simulation tick; the queue planner and
     guard read-out ride it rather than adding a second clock. */
  tickOrderPlanning(dt);
  for(let ri=0;ri<patrolRoutes.length;ri++){
    const R=patrolRoutes[ri];if(!R)continue;
    R.gcT=(R.gcT||0)-dt;
    if(R.gcT<=0){R.gcT=.45;if(!refreshPatrolRoute(ri,false))continue;}
    const step=R.step==null?1:R.step,row=R.targets&&R.targets[step];if(!row)continue;
    let live=0,arrived=0,far=0;
    for(const e of R.members){
      const i=e[0];if(!ualive[i]||ugen[i]!==e[1]||uPatrolRoute[i]!==ri)continue;
      const P=row[uPatrolSlot[i]];if(!P)continue;
      const d=Math.hypot(ux[i]-P.x,uy[i]-P.y);far=Math.max(far,d);live++;
      if(d<=Math.max(15,TYPES[utype[i]].size*.58))arrived++;
    }
    if(!live)continue;
    for(const e of R.members){
      const i=e[0];if(!ualive[i]||ugen[i]!==e[1]||uPatrolRoute[i]!==ri)continue;
      const P=row[uPatrolSlot[i]],d=Math.hypot(ux[i]-P.x,uy[i]-P.y),lead=far-d;
      uCohesion[i]=d<=15&&far>38?.16:lead>150?.50:lead>78?.74:1;
    }
    R.legT=(R.legT||0)+dt;
    const need=live<=6?live:Math.ceil(live*.84);
    R.waitT=arrived>=need?(R.waitT||0)+dt:0;
    if(arrived===live||R.waitT>=1.1||(R.legT>22&&arrived>=Math.ceil(live*.6))){
      R.step=(step+1)%R.targets.length;R.legT=0;R.waitT=0;
      const next=R.targets[R.step],routeFields={};
      for(const e of R.members){
        const i=e[0];if(!ualive[i]||ugen[i]!==e[1]||uPatrolRoute[i]!==ri)continue;
        const raw=next[uPatrolSlot[i]];if(!raw)continue;
        const P=domainOrderPoint(i,raw,R.pts[R.step],routeFields);
        uPatrolStep[i]=R.step;utx[i]=P.x;uty[i]=P.y;ufield[i]=P.field;
      }
      R.pulse=performance.now()+1100;
    }
  }
}
function commitPatrolDraft(){
  if(mfNetworkPlanBlocked('PATROL')){cancelPatrolDraft(true);return false;}
  if(!patrolDraft||patrolDraft.pts.length<2){cancelPatrolDraft(false);return false;}
  const sel=[],refs=[];
  for(const e of patrolDraft.members){
    if(ualive[e[0]]&&ugen[e[0]]===e[1]&&(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(e[0]):uteam[e[0]]===0)){sel.push(e[0]);refs.push(e);}
  }
  if(!sel.length){cancelPatrolDraft(false);return false;}
  const pts=patrolDraft.pts.slice(),targets=patrolTargetRows(sel,pts,patrolDraft.form);
  const ri=patrolRoutes.length;
  patrolRoutes.push({pts,targets,form:patrolDraft.form,members:refs,step:1,legT:0,waitT:0,gcT:.45,created:performance.now()});
  const routeFields={};
  for(let k=0;k<sel.length;k++){
    const i=sel[k],P=domainOrderPoint(i,targets[1][k],pts[1],routeFields);
    uPatrolRoute[i]=ri;uPatrolStep[i]=1;uPatrolSlot[i]=k;uMoveCohort[i]=-1;
    queueClear(i);uGuard[i]=-1;
    ustate[i]=5;utgt[i]=-1;utgtg[i]=-1;uhold[i]=0;umarch[i]=1;ufield[i]=P.field;utx[i]=P.x;uty[i]=P.y;
    upx1[i]=targets[0][k].x;upy1[i]=targets[0][k].y;upx2[i]=P.x;upy2[i]=P.y;
  }
  const count=sel.length,nodes=pts.length-1;
  cancelPatrolDraft(true);uiCommandAck('patrol',count,pts[1].x,pts[1].y);
  toast('⟳ '+count+' units patrolling a '+nodes+'-waypoint formation loop');
  return true;
}
function togglePatrolPlanner(){
  if(mfNetworkPlanBlocked('PATROL')){if(armPatrol)cancelPatrolDraft(true);return;}
  if(!armPatrol){beginPatrolDraft();return;}
  if(patrolDraft&&patrolDraft.pts.length>1)commitPatrolDraft();else cancelPatrolDraft(false);
}
/* ---------- control groups (save with long-press, recall with tap) ---------- */
/* Groups store the slot AND its generation. Storing the bare index meant that
   when a member died and its slot was refilled, the group silently adopted the
   stranger that replaced it. */
const ctrlGroups=[[],[],[],[]],groupForms=[0,0,0,0];
let activePlatoon=-1;
const groupLive=g=>g.filter(e=>ualive[e[0]]&&ugen[e[0]]===e[1]&&(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(e[0]):uteam[e[0]]===0));
function saveGroup(n){
  const g=[];
  for(let i=0;i<unitHigh;i++) if(ualive[i]&&usel[i]) g.push([i,ugen[i]]);
    if(!g.length){toast('Select units first, then tap P'+(n+1)+' to assign'); return;}
  ctrlGroups[n]=g;groupForms[n]=selFormation;activePlatoon=n;
  updateGroupBadges();
  toast('PLATOON P'+(n+1)+' saved — '+g.length+' units · '+FORMS[selFormation].nm);sfx('level');
}
function recallGroup(n,focus){
  const g=groupLive(ctrlGroups[n]);
  ctrlGroups[n]=g;
  updateGroupBadges();
  if(!g.length){
    if(selCount()){ saveGroup(n); return; }
    toast('P'+(n+1)+' is empty — select units, then tap P'+(n+1)+' to assign');
    return;
  }
  clearSel();
  let cx2=0,cy2=0;
  for(const [i] of g){ usel[i]=1; cx2+=ux[i]; cy2+=uy[i]; }
  activePlatoon=n;setFormation(groupForms[n]||0,true);
  if(focus){cam.x=cx2/g.length;cam.y=cy2/g.length;clampCam();camUpdateMatrices();}
  toast('P'+(n+1)+' selected — '+g.length+' units · '+FORMS[selFormation].nm+(focus?' · camera focused':''));
  updateSelInfo(); uiCommandAck('select',g.length,cx2/g.length,cy2/g.length);
}
function updateGroupBadges(){
  for(let n=0;n<4;n++){
    const live=groupLive(ctrlGroups[n]);ctrlGroups[n]=live;
    /* These run on every selection change and sit inside the watched command
       dock. textContent and classList.toggle mutate even when the value is
       unchanged, so four idle platoon slots kept waking the HUD observers. */
    const b=document.getElementById('grp'+(n+1)+'N');
    const badge=String(live.length||'—');
    if(b&&b.textContent!==badge)b.textContent=badge;
    const btn=document.getElementById('grpBtn'+(n+1));
    if(btn){
      const saved=!!live.length,active=activePlatoon===n&&!!live.length;
      if(btn.classList.contains('saved')!==saved)btn.classList.toggle('saved',saved);
      if(btn.classList.contains('active')!==active)btn.classList.toggle('active',active);
    }
  }
}
function orderHold(){
  let n=0;
  for(let i=0;i<unitHigh;i++) if(ualive[i]&&usel[i]){
    uhold[i]=1;ustate[i]=0;utgt[i]=-1;utgtg[i]=-1;umarch[i]=0;
    utx[i]=ux[i];uty[i]=uy[i];uPatrolRoute[i]=-1;uMoveCohort[i]=-1;
    queueClear(i);uGuard[i]=-1;n++;
    if(TYPES[utype[i]].air&&typeof mfAirIssueMission==='function')
      mfAirIssueMission(i,'none',{x:ux[i],y:uy[i]});
  }
  markStopDisp(false);
  if(n){ toast('⛊ '+n+' units holding position — they fire but never chase'); uiCommandAck('hold',n); updateSelInfo(); }
  return n;
}
function orderAttack(target){   // target: unit idx or -2-b
  let any=false;
  let ex,ey;
  if(target>=0){ ex=ux[target]; ey=uy[target]; }
  else { const B=blds[-2-target]; ex=B.x; ey=B.y; }
  for(let i=0;i<unitHigh;i++) if(ualive[i]&&usel[i]){
    ustate[i]=2; utgt[i]=target; utgtg[i]=target>=0?ugen[target]:-1;
    /* Explicit attack is chase, not attack-move. A leftover march flag would
       keep walking the old ground click while the order said "that unit". */
    utx[i]=ex;uty[i]=ey;uhold[i]=0;umarch[i]=0;uPatrolRoute[i]=-1;uMoveCohort[i]=-1;
    queueClear(i);uGuard[i]=-1;any=true;
    if(TYPES[utype[i]].air&&typeof mfAirIssueMission==='function')
      mfAirIssueMission(i,(target>=0&&TYPES[utype[target]].air)?'intercept':'strike',
        {x:ex,y:ey,target,generation:target>=0?ugen[target]:-1});
  }
  if(any){
    markStopDisp(false);
    addParticle(3,ex,ey,0,0,.5,30, 255,90,70); uiCommandAck('attack',selCount(),ex,ey);
    updateSelInfo();
  }
  return any;
}
/* ============================================================================
   GUARD (escort) + QUEUED WAYPOINTS — both touch-first.
   ----------------------------------------------------------------------------
   Neither order gets a desktop-only affordance. Shift-click exists here only as
   an accelerator on top of the touch path, never as the way in.

   WHY THE ORDERS DECK ONLY GAINS ONE BUTTON. #tacRow is five controls wide and
   #primaryRow already proves six is the ceiling inside the phone dock's
   minimap-bay padding at 412px (6*46 + 5*3 = 291px of 292px available). A
   seventh control would push PATROL under the minimap. So the queue planner —
   which genuinely needs a persistent, stateful control, because it is a mode
   with a commit — takes the one remaining slot, and GUARD rides the long press,
   the only touch gesture that can name a FRIENDLY target without also
   re-selecting it.

   WHY THE BUTTON IS BUILT HERE AND NOT IN index.html / ui.css. The in-match HUD
   markup and stylesheet have another owner mid-pass. Creating the control at
   load and appending it to #tacRow is the same trick main.js's ensureCamControl
   already uses for OTA shells that predate a button: it inherits the row's
   deck visibility, safe-area padding and .cbtn styling for free, and the HUD
   owner can move or restyle it later without touching orders code.
   ============================================================================ */
function guardLabel(h){
  if(h>=0) return TYPES[utype[h]].name;
  const B=blds[-2-h];
  return (B&&BT[B.type]&&BT[B.type].name)||'structure';
}
function orderGuard(h,quiet){
  if(!guardEntityLive(h,h>=0?ugen[h]:-1)) return false;
  const P=guardEntityPos(h);let n=0;
  for(let i=0;i<unitHigh;i++) if(ualive[i]&&usel[i]&&i!==h){
    queueClear(i);
    ustate[i]=7; uGuard[i]=h; uGuardG[i]=h>=0?ugen[h]:-1;
    utgt[i]=-1; utgtg[i]=-1; uhold[i]=0; umarch[i]=0;
    uPatrolRoute[i]=-1; uMoveCohort[i]=-1; ufield[i]=-1;
    if(TYPES[utype[i]].air&&typeof mfAirIssueMission==='function')
      mfAirIssueMission(i,'escort',{x:P[0],y:P[1],escort:h,escortGeneration:h>=0?ugen[h]:-1});
    n++;
  }
  if(!n) return false;
  addParticle(3,P[0],P[1],0,0,.6,Math.max(34,P[2]*2.4), 120,255,190);
  if(!quiet) toast('⛨ GUARD — '+n+' unit'+(n===1?'':'s')+' escorting '+guardLabel(h));
  markStopDisp(false);
  uiCommandAck('guard',n,P[0],P[1]);
  updateSelInfo();
  return true;
}

let armQueue=false, queueDraft=null, guardFxT=0;
function queueButtonState(){
  const b=ensureQueueBtn(); if(!b) return;
  const n=queueDraft?queueDraft.steps.length:0;
  b.classList.toggle('on',!!armQueue);
  const l=b.querySelector('.lbl');
  if(l) l.textContent=armQueue?(n?'GO '+n:'TAP…'):'QUEUE';
}
function ensureQueueBtn(){
  let b=document.getElementById('queueBtn');
  if(b) return b;
  const row=document.getElementById('tacRow');
  if(!row) return null;
  b=document.createElement('button');
  b.type='button'; b.id='queueBtn'; b.className='cbtn';
  b.setAttribute('aria-label','Chain waypoints for the selected units');
  b.innerHTML='<span class="em">⇢</span><span class="lbl">QUEUE</span>';
  /* Before CLEAR so cancelling the selection stays the last thing in the row. */
  row.insertBefore(b,document.getElementById('clearBtn')||null);
  mfBindNativePress(b,ev=>{ ev.preventDefault(); toggleQueuePlanner(); });
  return b;
}
function beginQueueDraft(){
  const sel=formationMembers();
  if(!sel.length){ toast('Select units first'); sfx('reject'); return false; }
  if(armPatrol) cancelPatrolDraft(true);
  disarmRally();
  armFormation=false; orderPreview=null; orderConfirm=null;
  const fb=document.getElementById('formBtn'); if(fb) fb.classList.remove('on');
  queueDraft={members:sel.map(i=>[i,ugen[i]]),steps:[],form:selFormation,fx:null,fxT:0};
  armQueue=true; queueButtonState();
  toast('⇢ ORDER QUEUE — tap ground, an enemy, or one of your own, or drag a path, up to '
        +QUEUE_MAX+' orders, then tap GO');
  sfx('ui'); return true;
}
function cancelQueueDraft(quiet){
  if(queueDraft) queueFxDrop(queueDraft);
  armQueue=false; queueDraft=null; queueButtonState();
  if(!quiet){ toast('Order queue cancelled'); sfx('reject'); }
}
/* A queued chain has to stay on the ground BETWEEN taps, and both route
   renderers only know how to draw `patrolDraft`. Rather than reach into files
   the HUD and graphics owners hold, the chain is published as an order-FX
   polyline — src/ui/orderfx.js already draws those as marching chevrons — with
   a lifetime the planner keeps refreshing. Straight legs are honest here: the
   player placed the nodes, and each leg's real flow route is only solved when
   that node becomes the live order. */
function queueFxPush(sx,sy,steps,until){
  if(typeof moveFxList==='undefined'||!steps.length) return null;
  const pts=[{x:sx,y:sy}];
  for(const s of steps) pts.push({x:s.x,y:s.y});
  let len=0; const arc=[0];
  for(let k=1;k<pts.length;k++){
    len+=Math.hypot(pts[k].x-pts[k-1].x,pts[k].y-pts[k-1].y); arc.push(len);
  }
  if(len<24) return null;
  const fx={pts,arc,len,kind:0,born:performance.now(),until};
  moveFxList.push(fx);
  while(moveFxList.length>MOVE_FX_MAX) moveFxList.shift();
  return fx;
}
function queueFxDrop(D){
  if(!D||!D.fx||typeof moveFxList==='undefined') return;
  const k=moveFxList.indexOf(D.fx); if(k>=0) moveFxList.splice(k,1);
  D.fx=null;
}
function queueAddStep(wx,wy,pk,quiet){
  const D=queueDraft; if(!D) return;
  const last=D.steps[D.steps.length-1];
  if(last&&last.t===2){ if(!quiet){ toast('GUARD ends the chain — tap GO'); sfx('reject'); } return; }
  if(D.steps.length>=QUEUE_MAX){ if(!quiet){ toast('Queue is full — tap GO to execute'); sfx('reject'); } return; }
  let px=clamp(wx,20,MAP-20),py=clamp(wy,20,MAP-20);
  if(typeof battlefieldClampPoint==='function'){ const q=battlefieldClampPoint(px,py,24); px=q[0]; py=q[1]; }
  let step,what;
  const inDraft=h=>{ for(const e of D.members) if(e[0]===h) return true; return false; };
  const b=pickBld(wx,wy);
  if(pk&&pk.enemy>=0){
    step={t:1,x:ux[pk.enemy],y:uy[pk.enemy],h:pk.enemy,g:ugen[pk.enemy],mv:0};
    what='ATTACK '+TYPES[utype[pk.enemy]].name;
  } else if(pk&&pk.own>=0&&!inDraft(pk.own)){
    step={t:2,x:ux[pk.own],y:uy[pk.own],h:pk.own,g:ugen[pk.own],mv:0};
    what='GUARD '+TYPES[utype[pk.own]].name;
  } else if(b>=0&&blds[b].team!==(typeof mfLocalTeam==='function'?mfLocalTeam():0)){
    const B=blds[b]; step={t:1,x:B.x,y:B.y,h:-2-b,g:-1,mv:0};
    what='ATTACK '+guardLabel(-2-b);
  } else if(b>=0&&!quiet){
    /* Drag-path samples skip friendly structures: a stroke across your own
       yard must not turn into a GUARD of the HQ. A deliberate TAP still can. */
    const B=blds[b]; step={t:2,x:B.x,y:B.y,h:-2-b,g:-1,mv:0};
    what='GUARD '+guardLabel(-2-b);
  } else {
    step={t:0,x:px,y:py,h:-1,g:-1,mv:moveMode?1:0};
    what=moveMode?'MOVE':'ATTACK-MOVE';
  }
  D.steps.push(step);
  queueFxDrop(D); D.fxT=0;                        // polyline changed: rebuild next tick
  addParticle(3,step.x,step.y,0,0,.55,30, 150,220,255);
  queueButtonState();
  if(quiet) return;
  toast('⇢ '+D.steps.length+'. '+what+(step.t===2?' — final step':'')+' · add more or tap GO');
  sfx('confirm');
}
function commitQueueDraft(){
  if(mfNetworkPlanBlocked('ORDER QUEUE')){cancelQueueDraft(true);return false;}
  const D=queueDraft;
  if(!D||!D.steps.length){ cancelQueueDraft(false); return false; }
  const sel=[];
  for(const e of D.members) if(ualive[e[0]]&&ugen[e[0]]===e[1]&&(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(e[0]):uteam[e[0]]===0)) sel.push(e[0]);
  if(!sel.length){ cancelQueueDraft(false); return false; }
  let cx=0,cy=0;
  for(const i of sel){ cx+=ux[i]; cy+=uy[i]; }
  cx/=sel.length; cy/=sel.length;
  /* One formation row per ground node, headed along the leg — the same solve
     patrol legs use — so a queued route arrives in formation at every waypoint
     instead of piling the whole force onto the pixel that was tapped. */
  const form=FORMS[D.form].id, rows=[];
  let px=cx,py=cy;
  for(const s of D.steps){
    rows.push(s.t===0?formationTargets(sel,s.x,s.y,form,Math.atan2(s.y-py,s.x-px)):null);
    px=s.x; py=s.y;
  }
  for(let k=0;k<sel.length;k++){
    const i=sel[k];
    uQueue[i]=D.steps.map((s,q)=>rows[q]
      ?{t:0,x:rows[q][k].x,y:rows[q][k].y,h:-1,g:-1,mv:s.mv}
      :{t:s.t,x:s.x,y:s.y,h:s.h,g:s.g,mv:s.mv});
    uhold[i]=0; uPatrolRoute[i]=-1; uMoveCohort[i]=-1; utgt[i]=-1; utgtg[i]=-1;
    /* Start node one immediately. queueTick would otherwise wait for the unit
       to "arrive" at whatever its previous order was still pointing at. */
    queueNext(i);
  }
  const n=sel.length, nodes=D.steps.length, fx0=D.steps[0];
  queueFxDrop(D);
  queueFxPush(cx,cy,D.steps,performance.now()+MOVE_FX_LIFE*1.8);
  armQueue=false; queueDraft=null; queueButtonState();
  toast('⇢ '+n+' unit'+(n===1?'':'s')+' executing a '+nodes+'-step order queue');
  uiCommandAck('patrol',n,fx0.x,fx0.y);           // "Route uploaded"
  return true;
}
function toggleQueuePlanner(){
  if(mfNetworkPlanBlocked('ORDER QUEUE')){if(armQueue)cancelQueueDraft(true);return;}
  if(!armQueue){ beginQueueDraft(); return; }
  if(queueDraft&&queueDraft.steps.length) commitQueueDraft(); else cancelQueueDraft(false);
}
/* Draft upkeep and the guard read-out. Rides tickPatrolRoutes (below) because
   sim.js already calls that once per simulation tick and neither of these
   deserves a second timer. */
function tickOrderPlanning(dt){
  if(armQueue&&queueDraft){
    const D=queueDraft;
    let cx=0,cy=0,n=0;
    for(const e of D.members) if(ualive[e[0]]&&ugen[e[0]]===e[1]){ cx+=ux[e[0]]; cy+=uy[e[0]]; n++; }
    /* Every drafted unit is gone — including the resetWorld case, where the
       whole army dies at once. Cancelling here is why the planner needs no
       hook in main.js's reset. */
    if(!n) cancelQueueDraft(true);
    else {
      D.fxT-=dt;
      if(D.fxT<=0){
        D.fxT=.5;
        if(D.fx&&moveFxList.indexOf(D.fx)<0) D.fx=null;   // newer orders shifted it out
        if(!D.fx) D.fx=queueFxPush(cx/n,cy/n,D.steps,performance.now()+6e5);
        else D.fx.until=performance.now()+6e5;
        for(const s of D.steps) addParticle(3,s.x,s.y,0,0,.5,26, 150,220,255);
      }
    }
  }
  guardFxT-=dt;
  if(guardFxT>0) return;
  guardFxT=1.4;
  /* One soft ring per guarded thing, so an escort order stays legible on the
     ground after its confirmation particle has gone. Deliberately slow and
     capped: this is a read-out, not a per-unit effect. */
  const seen=[];
  for(let i=0;i<unitHigh&&seen.length<6;i++){
    if(!ualive[i]||!(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(i):uteam[i]===0)||ustate[i]!==7) continue;
    const h=uGuard[i];
    if(h===-1||seen.indexOf(h)>=0||!guardEntityLive(h,uGuardG[i])) continue;
    seen.push(h);
    const P=guardEntityPos(h);
    addParticle(3,P[0],P[1],0,0,.75,Math.max(30,P[2]*2.2), 110,235,190);
  }
}
function mfLocalStackMember(lead){
  if(lead<0) return -1;
  const members=typeof mfIconStackMembers==='function'?mfIconStackMembers(lead):[lead];
  for(const i of members) if(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(i):uteam[i]===0) return i;
  return -1;
}
function pickUnit(wx,wy){
  const localTeam=typeof mfLocalTeam==='function'?mfLocalTeam():0;
  const pickR=Math.max(16,orthoSpan*0.012,
    (typeof mfIconStackOn==='function'&&mfIconStackOn()&&typeof mfIconStackCell==='function')
      ?mfIconStackCell()*0.55:0);
  let best=-1,bd=pickR*pickR, bestEnemy=-1,bde=pickR*pickR;
  forUnitsIn(wx,wy,pickR,j=>{
    const d=dist2(wx,wy,ux[j],uy[j]);
    if(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(j):uteam[j]===0){ if(d<bd){bd=d;best=j;} }
    else if(uteam[j]!==localTeam&&fogEntityVisible(uteam[j],ux[j],uy[j])){ if(d<bde){bde=d;bestEnemy=j;} }
  });
  if(typeof mfIconStackPick==='function'){
    const ownSt=mfLocalStackMember(mfIconStackPick(wx,wy,localTeam));
    if(ownSt>=0) best=ownSt;
    const enSt=mfIconStackPick(wx,wy,localTeam===1?0:1);
    if(enSt>=0&&bestEnemy<0&&fogEntityVisible(uteam[enSt],ux[enSt],uy[enSt])) bestEnemy=enSt;
  }
  return {own:best, enemy:bestEnemy};
}
/* Pointer selection is a screen-space question. The world-radius picker above
   remains the right API for scripts/orders that already have a world point,
   but at command zoom its expanding radius could select a unit whose drawn
   hull did not overlap the finger at all. Keep forUnitsIn as the broad phase,
   then require the pointer to touch a projected, facing-aware hull (or the
   tactical icon that replaced it). The only forgiveness is a bounded CSS-px
   allowance: precise mouse, slightly wider pen, full fingertip for touch. */
function mfPointerPickAllowance(pointerType){
  return pointerType==='mouse'?6:pointerType==='pen'?8:10;
}
let mfPointerMaxSpanValue=48,mfPointerMaxSpanTypes=-1;
const mfPickerPerf={calls:0,lastMs:0,maxMs:0,totalMs:0,buildingCandidates:0};
function mfPointerMaxSpan(){
  if(mfPointerMaxSpanTypes===TYPES.length)return mfPointerMaxSpanValue;
  let span=48;
  for(let k=0;k<TYPES.length;k++)if(TYPES[k])span=Math.max(span,TYPES[k].size*(TYPES[k].vscale||1)*3.4);
  mfPointerMaxSpanTypes=TYPES.length;mfPointerMaxSpanValue=span;return span;
}
function mfPickerDiagnostics(){
  return {...mfPickerPerf,averageMs:mfPickerPerf.calls?mfPickerPerf.totalMs/mfPickerPerf.calls:0};
}
function mfPointerSegDist2(px,py,ax,ay,bx,by){
  const dx=bx-ax,dy=by-ay,dd=dx*dx+dy*dy;
  const t=dd>1e-8?clamp(((px-ax)*dx+(py-ay)*dy)/dd,0,1):0;
  const x=ax+dx*t,y=ay+dy*t;
  return dist2(px,py,x,y);
}
function mfPointerHull(points){
  if(points.length<=2) return points.slice();
  const p=points.slice().sort((a,b)=>a[0]-b[0]||a[1]-b[1]);
  const lo=[],hi=[];
  const cross=(a,b,c)=>(b[0]-a[0])*(c[1]-a[1])-(b[1]-a[1])*(c[0]-a[0]);
  for(const q of p){ while(lo.length>1&&cross(lo[lo.length-2],lo[lo.length-1],q)<=0)lo.pop(); lo.push(q); }
  for(let k=p.length-1;k>=0;k--){ const q=p[k]; while(hi.length>1&&cross(hi[hi.length-2],hi[hi.length-1],q)<=0)hi.pop(); hi.push(q); }
  lo.pop();hi.pop();return lo.concat(hi);
}
function mfPointerHullHit(sx,sy,hull,allow){
  if(!hull.length) return false;
  let inside=false;
  for(let i=0,j=hull.length-1;i<hull.length;j=i++){
    const a=hull[i],b=hull[j];
    if(((a[1]>sy)!==(b[1]>sy))&&sx<(b[0]-a[0])*(sy-a[1])/((b[1]-a[1])||1e-9)+a[0]) inside=!inside;
    if(mfPointerSegDist2(sx,sy,a[0],a[1],b[0],b[1])<=allow*allow) return true;
  }
  return inside;
}
function mfPointerUnitGround(T,i){
  if(typeof unitGroundY==='function') return unitGroundY(T,ux[i],uy[i],i);
  if(T.air) return terrainH(ux[i],uy[i])+(typeof unitAirAlt==='function'?unitAirAlt(i):58);
  if(T.naval) return (typeof waterSurfaceY==='function'?waterSurfaceY(ux[i],uy[i]):0)+.95;
  return terrainH(ux[i],uy[i]);
}
function mfPointerUnitMetric(i,sx,sy,allow){
  const T=TYPES[utype[i]]; if(!T) return Infinity;
  const vs=Math.max(4,T.size*(T.vscale||1)),ang=(uang[i]||0)-Math.PI*.5;
  const ca=Math.cos(ang),sa=Math.sin(ang),rx=-sa,ry=ca;
  const hf=vs*(T.naval?1.72:T.air?1.42:T.legs ? .92:1.28);
  const hw=vs*(T.naval ? .62:T.air ? .78:T.legs ? .66:.82);
  const ht=vs*(T.air ? .92:T.naval ? .72:T.legs?1.62:1.12);
  const h0=mfPointerUnitGround(T,i),pts=[];
  for(const z of [0,ht]) for(const f of [-hf,hf]) for(const w of [-hw,hw])
    pts.push(w2s(ux[i]+ca*f+rx*w,uy[i]+sa*f+ry*w,h0+z));
  const hull=mfPointerHull(pts),bodyHit=mfPointerHullHit(sx,sy,hull,allow);
  const mid=w2s(ux[i],uy[i],h0+ht*.5),wp=Math.max(.01,orthoSpan/Math.max(1,VH));
  let metric=bodyHit?dist2(sx,sy,mid[0],mid[1])/Math.max(16,(vs/wp)*(vs/wp)):Infinity;
  /* A tactical icon is presentation, not decoration: once it fades over or
     replaces a mesh, its visible plate is the selectable silhouette. */
  const iconQ=Math.max(
    typeof mfIconQ==='function'&&typeof mfUnitSpan==='function'?mfIconQ(mfUnitSpan(T)):0,
    typeof mfCmdIconQ==='function'?mfCmdIconQ(T):0);
  if(iconQ>0){
    const c=w2s(ux[i],uy[i],h0+2),d=typeof mfIconDpx==='function'?mfIconDpx(T):clamp(18+vs*.36,22,40)*wp;
    const r=d/wp*.5+allow,dm=dist2(sx,sy,c[0],c[1]);
    if(dm<=r*r) metric=Math.min(metric,dm/Math.max(16,r*r));
  }
  return metric;
}
function mfPointerStackMetric(lead,sx,sy,allow){
  if(lead<0||!ualive[lead]||!fogEntityVisible(uteam[lead],ux[lead],uy[lead])) return Infinity;
  const T=TYPES[utype[lead]],C=typeof mfIconStackCentroid==='function'?mfIconStackCentroid(lead):[ux[lead],uy[lead],1];
  const x=C[0],y=C[1],n=C[2]||1,wp=Math.max(.01,orthoSpan/Math.max(1,VH));
  const h=T.naval?1.5:mfPointerUnitGround(T,lead)+2,c=w2s(x,y,h);
  const d=(typeof mfIconDpx==='function'?mfIconDpx(T):clamp(18+T.size*.36,22,40)*wp)
    *(1+Math.min(.35,Math.log(n)*.12));
  const r=d/wp*.5+allow,dm=dist2(sx,sy,c[0],c[1]);
  return dm<=r*r?dm/Math.max(16,r*r):Infinity;
}
function pickUnitPointer(wx,wy,sx,sy,pointerType){
  const allow=mfPointerPickAllowance(pointerType),wp=Math.max(.01,orthoSpan/Math.max(1,VH));
  /* Broad only: the result cannot be accepted until its projected hull hits. */
  const broad=mfPointerMaxSpan()+allow*wp+48;
  let own=-1,enemy=-1,om=Infinity,em=Infinity,ownStack=false;
  const localTeam=typeof mfLocalTeam==='function'?mfLocalTeam():0,stackTeams=[localTeam];
  /* viaStack records HOW the winning own-pick was made. A finite metric from
     the unit loop means the pointer landed inside that unit's projected hull
     or its icon plate -- it is on the thing. A metric from the stack loop is a
     strategic plate standing in for several units, which is a much looser
     claim on the pixel. Structure arbitration below needs to tell them apart:
     a plate must not outrank the building under it, and a direct hit must not
     be thrown away by one. */
  const take=(j,m,viaStack)=>{
    if(!isFinite(m)) return;
    if(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(j):uteam[j]===0){
      if(m<om-1e-9||(Math.abs(m-om)<=1e-9&&(own<0||j<own))){om=m;own=j;ownStack=!!viaStack;}
    }
    else if(uteam[j]!==localTeam&&fogEntityVisible(uteam[j],ux[j],uy[j])&&(m<em-1e-9||(Math.abs(m-em)<=1e-9&&(enemy<0||j<enemy)))){em=m;enemy=j;}
  };
  forUnitsIn(wx,wy,broad,j=>{
    if(stackTeams.indexOf(uteam[j])<0)stackTeams.push(uteam[j]);
    if(!(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(j):uteam[j]===0)&&!fogEntityVisible(uteam[j],ux[j],uy[j])) return;
    if(typeof mfIconStackSkip==='function'&&mfIconStackSkip(j)) return;
    take(j,mfPointerUnitMetric(j,sx,sy,allow));
  });
  if(typeof mfIconStackPick==='function'){
    for(const team of stackTeams){
      const lead=mfIconStackPick(wx,wy,team);
      if(lead>=0)take(team===localTeam?mfLocalStackMember(lead):lead,
        mfPointerStackMetric(lead,sx,sy,allow),true);
    }
  }
  return {own:own,enemy:enemy,ownStack:ownStack,ownDirect:own>=0&&!ownStack};
}
/* One pointer read owns unit + structure arbitration. Friendly structures keep
   their established precedence over parked friendly units; a visible enemy
   unit remains attackable over a structure when a force is selected. */
function pickPointerEntities(wx,wy,sx,sy,pointerType){
  const t0=typeof performance!=='undefined'&&performance.now?performance.now():0;
  const pk=pickUnitPointer(wx,wy,sx,sy,pointerType),b=pickBld(wx,wy,sx,sy);
  /* A friendly structure outranks a strategic STACK PLATE drawn over it --
     that is what made a factory unreachable when constructors were parked on
     it. It must NOT outrank a unit the player actually hit: tapping the
     Commander standing on your own pad opened the pad instead, which is the
     opposite of obvious intent. Keep a direct hull/icon hit; drop a plate. */
  if(b>=0&&blds[b]&&(typeof mfLocalOwnsBuilding==='function'?mfLocalOwnsBuilding(blds[b]):blds[b].team===0)&&!pk.ownDirect) pk.own=-1;
  pk.bld=b;
  if(t0){const ms=performance.now()-t0;mfPickerPerf.calls++;mfPickerPerf.lastMs=ms;
    mfPickerPerf.totalMs+=ms;mfPickerPerf.maxMs=Math.max(mfPickerPerf.maxMs,ms);}
  return pk;
}
/* Structure placement is rectangle/rotation aware, but selection used the
   legacy circular `B.r` radius. A Factory corner or the upper, projected half
   of a tall structure could therefore ray-pick as empty ground; if workers
   were parked there, their strategic stack consumed the tap and produced a
   notice instead of opening production. Keep the forgiving touch pad, but
   test the real reserved footprint first. */
function bldPickFoot(B){
  if(!B||typeof bldFoot!=='function') return null;
  try{
    const f=bldFoot(B);
    return f&&isFinite(f[0])&&isFinite(f[1])?[Math.max(1,f[0]),Math.max(1,f[1])]:null;
  }catch(_){ return null; }
}
function bldWorldPick(B,wx,wy,pad){
  const f=bldPickFoot(B);
  if(f){
    const a=B.rot||0,dx=wx-B.x,dy=wy-B.y,c=Math.cos(a),s=Math.sin(a);
    const lx=dx*c+dy*s,ly=-dx*s+dy*c;
    return Math.abs(lx)<=f[0]*.5+pad&&Math.abs(ly)<=f[1]*.5+pad;
  }
  const r=(B.r||12)+pad;
  return dist2(wx,wy,B.x,B.y)<=r*r;
}
function screenQuadHit(sx,sy,q){
  let sign=0;
  for(let i=0;i<4;i++){
    const a=q[i],b=q[(i+1)&3],cross=(sx-a[0])*(b[1]-a[1])-(sy-a[1])*(b[0]-a[0]);
    if(Math.abs(cross)<.5) continue;
    if(sign&&cross*sign<0) return false;
    sign=cross;
  }
  return !!sign;
}
/* `s2w()` deliberately hits terrain, not a model mesh. For a tall structure
   this means a tap on the roof maps to ground behind its footprint. Test the
   projected rectangular prism only as a fallback after an exact ground-foot
   hit; that makes the visible model tappable without letting it steal a closer
   ground target. */
function bldScreenPick(B,sx,sy){
  const f=bldPickFoot(B);
  if(!f||typeof w2s!=='function'||!isFinite(sx)||!isFinite(sy)) return false;
  const a=B.rot||0,c=Math.cos(a),s=Math.sin(a),hx=f[0]*.5,hy=f[1]*.5;
  const T=typeof BT!=='undefined'&&BT[B.type],lift=Math.max(8,Math.min(130,((T&&T.size)||B.r*2||24)*1.35));
  const base=[],top=[];
  for(const p of [[-hx,-hy],[hx,-hy],[hx,hy],[-hx,hy]]){
    const x=B.x+p[0]*c-p[1]*s,y=B.y+p[0]*s+p[1]*c;
    const h=typeof terrainH==='function'?terrainH(x,y):0;
    base.push(w2s(x,y,h)); top.push(w2s(x,y,h+lift));
  }
  if(screenQuadHit(sx,sy,base)||screenQuadHit(sx,sy,top)) return true;
  for(let i=0;i<4;i++) if(screenQuadHit(sx,sy,[base[i],base[(i+1)&3],top[(i+1)&3],top[i]])) return true;
  return false;
}
let mfBldPickMarks=new Uint32Array(0),mfBldPickSerial=0;
function mfForBldsNear(x,y,rad,fn){
  if(typeof bGrid==='undefined'||typeof BCS!=='number'||typeof BGW!=='number'||!bGrid){
    for(let b=0;b<blds.length;b++)fn(b);return;
  }
  if(mfBldPickMarks.length<blds.length)mfBldPickMarks=new Uint32Array(Math.max(64,blds.length*2));
  mfBldPickSerial=(mfBldPickSerial+1)>>>0;
  if(!mfBldPickSerial){mfBldPickMarks.fill(0);mfBldPickSerial=1;}
  const x0=clamp((x-rad)/BCS|0,0,BGW-1),x1=clamp((x+rad)/BCS|0,0,BGW-1),
    y0=clamp((y-rad)/BCS|0,0,BGW-1),y1=clamp((y+rad)/BCS|0,0,BGW-1);
  for(let gy=y0;gy<=y1;gy++)for(let gx=x0;gx<=x1;gx++){
    const cell=bGrid[gy*BGW+gx];if(!cell)continue;
    for(const b of cell)if(b>=0&&b<blds.length&&mfBldPickMarks[b]!==mfBldPickSerial){
      mfBldPickMarks[b]=mfBldPickSerial;mfPickerPerf.buildingCandidates++;fn(b);
    }
  }
}
function pickBld(wx,wy,sx,sy){
  const pad=clamp((orthoSpan||800)*.01,10,22);
  let world=-1,worldD=Infinity,screen=-1,screenD=Infinity;
  const broad=pad+Math.max(260,(orthoSpan||800)*.04);
  mfForBldsNear(wx,wy,broad,b=>{
    const B=blds[b];
    if(!B||!B.alive||!fogEntityVisible(B.team,B.x,B.y)) return;
    const d=dist2(wx,wy,B.x,B.y);
    if(bldWorldPick(B,wx,wy,pad)){
      if(d<worldD){ world=b; worldD=d; }
      return;
    }
    if(sx!=null&&sy!=null&&bldScreenPick(B,sx,sy)){
      const P=w2s(B.x,B.y,(typeof terrainH==='function'?terrainH(B.x,B.y):0)+((BT[B.type]||{}).size||B.r*2||24)*.68);
      const sd=dist2(sx,sy,P[0],P[1]);
      if(sd<screenD){ screen=b; screenD=sd; }
    }
  });
  return world>=0?world:screen;
}

let armRally=-1, armPatrol=false, lastSelT=0, lastSelType=-1, lastTapShift=false;
let lastGroundT=0, lastGroundX=0, lastGroundY=0;
/* 500ms / 80px is the C&C3 / SupCom2 double-tap window, in SCREEN pixels so
   a command-camera pan between contacts does not break it. lastGroundT>0
   rejects the page-load false positive (tnow-0<500 during the first half
   second of a reload). */
const GROUND_DBL_MS=500, GROUND_DBL_PX=80;
function groundDoubleTap(sx,sy){
  return lastGroundT>0 && performance.now()-lastGroundT<GROUND_DBL_MS
    && Math.hypot(sx-lastGroundX,sy-lastGroundY)<GROUND_DBL_PX;
}
function stampGroundTap(sx,sy,consumed){
  lastGroundT=consumed?0:performance.now();
  lastGroundX=sx; lastGroundY=sy;
}
let novaSrc=-1;
function onTap(sx,sy,pointerType){
  const [wx,wy]=s2w(sx,sy);
  if(aiming===5){
    const picked=pickUnitPointer(wx,wy,sx,sy,pointerType||'touch'),target=picked.enemy;
    beginArtilleryBarrage(wx,wy,target>=0?target:undefined,target>=0?ugen[target]:undefined);
    return;
  }
  if(aiming===6){ fireCommanderActive(wx,wy); return; }
  if(aiming===7){ fireCommanderWeapon(0,wx,wy); return; }
  if(aiming===8){ fireCommanderWeapon(1,wx,wy); return; }
  if(aiming===4){ fireCommanderJump(wx,wy); return; }
  if(aiming===0){ fireBlast(wx,wy); return; }
  if(aiming===3){ fireLance(wx,wy); return; }
  /* WHY: Skycrane UNLOAD and Massflesh BIRTH are map-aim modes. Dispatch them
     here (not only via airlift.js's onTap wrap) so a later input rewrite cannot
     leave those orders as toasts with no confirm. */
  if(aiming===9&&typeof mfAirliftConfirmAim==='function'){ mfAirliftConfirmAim(wx,wy); return; }
  if(aiming===10&&typeof mfMassConfirmAim==='function'){ mfMassConfirmAim(wx,wy); return; }
  if(aiming===2){                               // NOVA strike targeting
    aiming=-1;
    const b3=novaSrc; novaSrc=-1;
    const C=window.MFMatchCommandConsumer;
    if(C&&C.requiresLockstep()){
      toast('NETWORK NOVA STRIKE UNAVAILABLE — this order is not synchronized yet');
      return;
    }
    if(!novaFire(b3,wx,wy)) toast('NOVA is not ready');
    return;
  }
  // rally flag placement (armed from a factory menu; armRally = building index)
  if(armRally>=0){
    const bi2=armRally; armRally=-1;
    const B=blds[bi2];
    if(B&&B.alive&&(typeof mfLocalOwnsBuilding==='function'?mfLocalOwnsBuilding(B):B.team===0)&&Array.isArray(B.queue)){
      const C=window.MFMatchCommandConsumer;
      if(C&&C.requiresLockstep()){
        if(C.submitRally(bi2,wx,wy)){
          addParticle(3,wx,wy,0,0,.5,30,120,255,170);
          toast('⚑ Rally point queued for the shared match tick');sfx('ui');
        }else toast(C.lastFailure()||'Rally order could not be sent');
        return;
      }
      let rx=clamp(wx,20,MAP-20),ry=clamp(wy,20,MAP-20);
      if(typeof battlefieldClampPoint==='function'){const p=battlefieldClampPoint(rx,ry,24);rx=p[0];ry=p[1];}
      B.rally={x:rx,y:ry};
      addParticle(3,wx,wy,0,0,.5,30, 120,255,170);
      toast('⚑ Rally point set — new units will gather there');
      sfx('ui');
    }
    return;
  }
  // pre-deployment: taps steer the carrier to your chosen landing ground
  if(carrier.active&&carrier.phase===1){
    let cx=clamp(wx,60,MAP-60),cy=clamp(wy,60,MAP-60);
    if(typeof battlefieldClampPoint==='function'){const p=battlefieldClampPoint(cx,cy,80);cx=p[0];cy=p[1];}
    carrier.tx=cx; carrier.ty=cy;
    addParticle(3,carrier.tx,carrier.ty,0,0,.5,32, 120,220,255);
    uiCommandAck('deploy',1,carrier.tx,carrier.ty);
    return;
  }
  if(carrier.active) return;                    // still falling — ignore taps
  /* Only real pointer gestures take the silhouette path. A legacy/programmatic
     onTap call with no pointer type retains the historical world picker. */
  const pp=pointerType?pickPointerEntities(wx,wy,sx,sy,pointerType):null;
  const pk=pp||pickUnit(wx,wy);
  const b=pp?pp.bld:pickBld(wx,wy,sx,sy);
  const haveSel=selCount()>0;
  /* Queue planning owns every map tap while it is armed — including taps on
     units and structures, which is what makes "chain an attack then an escort"
     reachable with one thumb. It is checked before selection so a tap on a
     friendly appends a GUARD step instead of throwing the draft's roster away. */
  if(armQueue && queueDraft){ queueAddStep(wx,wy,pk); return; }
  /* DESKTOP ACCELERATOR, NOT THE WAY IN. Shift-click arms the same planner and
     appends to it, and releasing Shift commits (see the keyup below). It is a
     shortcut onto the touch machinery — there is deliberately no order here
     that a phone cannot reach. */
  if(lastTapShift && haveSel && !armPatrol && !placing && beginQueueDraft()){
    queueDraft.viaShift=true;
    queueAddStep(wx,wy,pk);
    return;
  }
  // patrol order (armed from the tactics bar)
  if(armPatrol && haveSel){
    addPatrolWaypoint(wx,wy);
    return;
  }
  if(armPatrol)cancelPatrolDraft(true);
  // A visible enemy still owns the tap, even when standing over one of our
  // structure footprints. This preserves the direct attack gesture while the
  // building-first rule below only resolves friendly stack/building overlap.
  if(pk.enemy>=0 && haveSel){ lastGroundT=0; orderAttack(pk.enemy); return; }
  /* A structure footprint is a more precise target than the strategic unit
     stack plate drawn above it. Resolving the plate first made constructors
     parked at a factory select as a STACK, close every sheet and emit notices;
     the production building directly under the finger was unreachable. Armed
     queue/patrol modes still own the tap above, while an ordinary direct hit on
     one of our structures now opens its real menu. */
  /* ...but a unit the player actually HIT still outranks the footprint under
     it. pk.ownDirect means the pointer landed inside that unit's projected
     hull or its icon plate, not on a strategic plate standing in for it, so
     tapping the Commander parked on your own pad selects the Commander. The
     picker already drops a mere plate here (pickPointerEntities), and without
     this the plate rule was enforced twice: once by dropping the pick, and
     again by this branch returning before the unit branch could run. */
  if(b>=0&&(typeof mfLocalOwnsBuilding==='function'?mfLocalOwnsBuilding(blds[b]):blds[b].team===0)&&!(pk.own>=0&&pk.ownDirect)){
    lastGroundT=0;
    clearSel();openBldMenu(b);return;
  }
  /* WHY: pickUnit's radius at command camera is often larger than the empty
     ground between selected hulls. A double-tap meant as retreat hit an own
     unit, reset lastGroundT, and became select-all. If the first tap was a
     ground order, the second contact at the same screen point is retreat —
     even when a friendly silhouette is inside the pick disc. Enemy / building
     taps still win so this cannot steal attack or a factory menu. */
  if(haveSel && groundDoubleTap(sx,sy) && pk.enemy<0 && b<0){
    stampGroundTap(sx,sy,true);
    orderMove(wx,wy,false,true);
    return;
  }
  // own unit tapped → select (double-tap = select all of that type on screen)
  if(pk.own>=0){
    lastGroundT=0;
    const tnow=performance.now();
    if(tnow-lastSelT<430 && utype[pk.own]===lastSelType){
      const b2=camBounds(); let n2=0;
      clearSel();
      for(let i=0;i<unitHigh;i++)
        if(ualive[i]&&(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(i):uteam[i]===0)&&utype[i]===lastSelType
           &&ux[i]>=b2.x0&&ux[i]<=b2.x1&&uy[i]>=b2.y0&&uy[i]<=b2.y1){ usel[i]=1; n2++; }
      toast('⚔ '+n2+'× '+TYPES[lastSelType].name+' selected — camera locked on');
      lastSelT=0;
      camFollow=pk.own; camFollowT=2.4;            // glide in and track it
      distTarget=clamp(Math.max(orthoSpan*0.5,zoomSpanMin()),zoomSpanMin(),zoomSpanMax());   // close on the unit, into tactical mesh
      updateSelInfo(); uiCommandAck('select',n2,ux[pk.own],uy[pk.own]); closeMenus(); return;
    }
    lastSelT=tnow; lastSelType=utype[pk.own];
    if(typeof mfIconStackSkip==='function'&&mfIconStackSkip(pk.own)
       &&typeof mfIconStackSelect==='function'&&mfIconStackSelect(pk.own)){
      uiCommandAck('select',selCount(),ux[pk.own],uy[pk.own]); closeMenus(); return;
    }
    clearSel(); usel[pk.own]=1; updateSelInfo(); uiCommandAck('select',1,ux[pk.own],uy[pk.own]);
    closeMenus(); return;
  }
  // building tapped
  if(b>=0){
    lastGroundT=0;
    const B=blds[b];
    if(typeof mfLocalOwnsBuilding==='function'?mfLocalOwnsBuilding(B):B.team===0){ clearSel(); openBldMenu(b); return; }
    else if(haveSel){ orderAttack(-2-b); return; }
  }
  // ground → move/attack-move; double-tap empty ground = retreat (C&C3 / SupCom2)
  if(haveSel){
    const retreat=groundDoubleTap(sx,sy);
    stampGroundTap(sx,sy,retreat);
    orderMove(wx,wy,false,retreat);
    return;
  }
  closeMenus();
}

let dragGhost=false, holdTimer=0;
/* One threshold for tap vs intel-card hold. A press that lasted 400–520 ms
   used to do nothing: onTap required <400 while the card armed at 520, so a
   careful aim in a crowd produced no order and no card. Shorter than this
   is a tap; reaching it is the hold. Keep 520 so expert long-press feel is
   unchanged — only the dead zone closes. */
const HOLD_MS=520;
/* Thumb contact jitter. 9px `moved` is below a real finger; 220ms is a tap. */
const TAP_JITTER_MS=220, TAP_JITTER_PX=28;
cv.addEventListener('pointerdown',e=>{
  try{ cv.setPointerCapture(e.pointerId); }catch(_){}
  const rec={x:e.clientX,y:e.clientY,sx:e.clientX,sy:e.clientY,moved:false,held:false,
             shift:!!e.shiftKey,pointerType:e.pointerType||'touch',t:performance.now(),
             eventT:isFinite(e.timeStamp)?e.timeStamp:performance.now()};
  ptrs.set(e.pointerId,rec);
  if(aiming===5&&ptrs.size===1){
    const [bwx,bwy]=s2w(e.clientX,e.clientY);setArtBarragePreview(bwx,bwy);
    clearTimeout(holdTimer);return;
  }
  /* Double-tap retreat is decided on pointerdown, not pointerup.
     WHY the previous path never fired on packed 8901:
     1. Formation preview stole the second contact and called orderMove
        without `retreat`, and never wrote lastGroundT.
     2. pickUnit at command camera treated "empty" ground next to the army
        as a unit tap and reset lastGroundT (select-all, not retreat).
     3. A 9px jitter marked the first contact `moved`, so onTap never ran
        and lastGroundT was never written — the second tap was a single
        attack-move.
     The 260ms radio gate is audio-only (audio.js already exempts retreat)
     and was not the order failure. War Table leftovers are display:none
     during a match and do not receive canvas pointers.
     Queue / patrol keep the tap: those modes own the map. */
  if(ptrs.size===1 && !placing && !boxMode && running && selCount()
     && !armQueue && !armPatrol && aiming<0 && groundDoubleTap(e.clientX,e.clientY)){
    const [wx,wy]=s2w(e.clientX,e.clientY);
    const pp=pickPointerEntities(wx,wy,e.clientX,e.clientY,e.pointerType||'touch');
    if(pp.enemy<0 && pp.bld<0){
      rec.held=true; rec.retreat=1;
      armFormation=false; orderPreview=null;
      const fb=document.getElementById('formBtn'); if(fb) fb.classList.remove('on');
      stampGroundTap(e.clientX,e.clientY,true);
      orderMove(wx,wy,false,true);
      clearTimeout(holdTimer);
      return;
    }
  }
  if(ptrs.size===1&&armFormation&&!placing&&!boxMode&&running&&selCount()){
    const [wx,wy]=s2w(e.clientX,e.clientY);
    const pp=typeof battlefieldClampPoint==='function'?battlefieldClampPoint(wx,wy,24):[clamp(wx,15,MAP-15),clamp(wy,15,MAP-15)];
    orderConfirm=null;
    orderPreview={pid:e.pointerId,x:pp[0],y:pp[1],
                  members:formationMembers(),form:selFormation};
    clearTimeout(holdTimer);return;
  }
  // long-press on a unit/building → intel card
  clearTimeout(holdTimer);
  if(ptrs.size===1 && !placing && !boxMode && running){
    const [hwx,hwy]=s2w(e.clientX,e.clientY);
    holdTimer=setTimeout(()=>{
      const p=ptrs.get(e.pointerId);
      if(!p||p.moved||p.held||ptrs.size!==1) return;
      const pp2=pickPointerEntities(hwx,hwy,e.clientX,e.clientY,e.pointerType||'touch');
      const pk2=pp2;
      const ui2=pk2.own>=0?pk2.own:pk2.enemy;
      const bi2=ui2<0?pp2.bld:-1;
      /* GUARD rides the long press (see the orders block above for why it gets
         no dock button). It only fires on a FRIENDLY that is not already part
         of the selection, so the intel card keeps every other long press:
         nothing selected, an enemy, neutral ground, or a unit you already hold.
         "Press something of mine while holding a force" has no other meaning. */
      const ownBld=bi2>=0&&blds[bi2]&&(typeof mfLocalOwnsBuilding==='function'?mfLocalOwnsBuilding(blds[bi2]):blds[bi2].team===0);
      const ownUnit=pk2.own>=0&&!usel[pk2.own];
      if(selCount()&&(ownUnit||ownBld)&&!armQueue&&!armPatrol&&!placing){
        p.held=true;
        if(orderGuard(ownUnit?pk2.own:-2-bi2)){ if(typeof buzz==='function') buzz(12); return; }
      }
      if(ui2>=0||bi2>=0){ p.held=true; showUnitCard(ui2,bi2); sfx('ui'); }
    },HOLD_MS);
  }
  if(placing&&ptrs.size===1){
    // drag near the ghost moves it; anywhere else pans the camera
    const [gx2,gy2]=w2s(placing.x,placing.y);
    dragGhost=Math.hypot(e.clientX-gx2,e.clientY-gy2)<90;
  }
  if(ptrs.size>=2) multiTouch=true;
  if(ptrs.size===2){
    const a=[...ptrs.values()];
    pinchD=Math.hypot(a[0].x-a[1].x,a[0].y-a[1].y); pinchZ=orthoSpan;
    pinchMY=(a[0].y+a[1].y)/2; pinchPitch=pitchTarget;
    pinchA=Math.atan2(a[1].y-a[0].y,a[1].x-a[0].x); pinchYaw=yawTarget;
    /* A second finger turns this into a camera gesture. Abandon any box in
       progress and hide it, or the release below would select everything
       between the box origin and wherever the pinch ended. */
    if(boxStart){
      boxStart=null; boxAdd=false;
      const bx=document.getElementById('selbox'); if(bx) bx.style.display='none';
      if(boxMode){ boxMode=false; const bb=document.getElementById('boxBtn'); if(bb) bb.classList.remove('on'); }
    }
  }
  /* Box select used to require arming #boxBtn first, so on desktop the
     universal RTS gesture — shift+drag — did nothing and a bare drag panned.
     Touch keeps the button (a bare one-finger drag MUST stay camera pan on a
     phone; there is no spare gesture), but a mouse gets shift+drag directly.
     Shift also makes the box ADDITIVE instead of replacing the selection,
     which is what shift means everywhere else in the genre. */
  if(ptrs.size===1 && !placing && (boxMode || (e.pointerType==='mouse' && e.shiftKey))){
    boxStart=[e.clientX,e.clientY];
    boxAdd=!!e.shiftKey;
  }
});
cv.addEventListener('pointermove',e=>{
  const p=ptrs.get(e.pointerId); if(!p) return;
  if(p.retreat) return;
  const dx=e.clientX-p.x, dy=e.clientY-p.y;
  p.x=e.clientX; p.y=e.clientY;
  if(Math.hypot(e.clientX-p.sx,e.clientY-p.sy)>9) p.moved=true;
  if(aiming===5&&ptrs.size===1){
    const [bwx,bwy]=s2w(e.clientX,e.clientY);setArtBarragePreview(bwx,bwy);return;
  }
  if(orderPreview&&orderPreview.pid===e.pointerId){
    const [wx,wy]=s2w(e.clientX,e.clientY);
    const pp=typeof battlefieldClampPoint==='function'?battlefieldClampPoint(wx,wy,24):[clamp(wx,15,MAP-15),clamp(wy,15,MAP-15)];
    orderPreview.x=pp[0];orderPreview.y=pp[1];return;
  }
  if(armQueue&&queueDraft&&ptrs.size===1&&!placing&&!boxStart){
    /* Drag-path while QUEUE is armed. Camera pan is the default one-finger
       stroke; stealing it here is the point — a queued route that still
       panned the map could not be drawn with a thumb. Sub-28px motion is
       still a tap (onTap needs !moved), so a careful waypoint does not
       become a pan. Samples are ground waypoints only. */
    if(Math.hypot(e.clientX-p.sx,e.clientY-p.sy)>28) p.qDrag=true;
    if(!p.qDrag){ p.moved=false; return; }
    p.moved=true;
    const [wx,wy]=s2w(e.clientX,e.clientY);
    const last=queueDraft.steps[queueDraft.steps.length-1];
    if(!last||dist2(wx,wy,last.x,last.y)>=110*110) queueAddStep(wx,wy,null,true);
    return;
  }
  if(ptrs.size===1){
    if(placing&&dragGhost){
      /* Drag the ghost by ray-picking the ground under the finger, so it
         tracks the pointer exactly regardless of camera angle or tilt. */
      const [gwx,gwy]=s2w(e.clientX,e.clientY);
      placing.rx=clamp(gwx,40,MAP-40); placing.ry=clamp(gwy,40,MAP-40);
      snapPlace();
    } else if(placing){
      const [pw0,ph0]=s2w(e.clientX-dx,e.clientY-dy), [pw1,ph1]=s2w(e.clientX,e.clientY);
      cam.x-=pw1-pw0; cam.y-=ph1-ph0; clampCam(); camUpdateMatrices();
    } else if(boxStart){
      const bx=document.getElementById('selbox');
      const x0=Math.min(boxStart[0],e.clientX), y0=Math.min(boxStart[1],e.clientY);
      bx.style.display='block';
      bx.style.left=x0+'px'; bx.style.top=y0+'px';
      bx.style.width=Math.abs(e.clientX-boxStart[0])+'px';
      bx.style.height=Math.abs(e.clientY-boxStart[1])+'px';
    } else {
      /* Ground-anchored pan: the world point under your finger stays under
         your finger. With a perspective camera a fixed pixels-per-unit pan
         drifts badly when the ground is far away or steeply tilted. */
      const [pw0,ph0]=s2w(e.clientX-dx,e.clientY-dy), [pw1,ph1]=s2w(e.clientX,e.clientY);
      cam.x-=pw1-pw0; cam.y-=ph1-ph0;
      camFollow=-1; camUser(); clampCam(); camUpdateMatrices();
    }
  } else if(ptrs.size===2){
    const a=[...ptrs.values()];
    const d=Math.hypot(a[0].x-a[1].x,a[0].y-a[1].y);
    if(pinchD>0){
      const mx=(a[0].x+a[1].x)/2, my=(a[0].y+a[1].y)/2;
      const [wx0,wy0]=s2w(mx,my);
      // pinch = dolly the eye in and out along its own view ray
      camFollow=-1; camUser();
      orthoSpan=clamp(pinchZ*pinchD/Math.max(1,d),zoomSpanMin(),zoomSpanMax()); distTarget=orthoSpan;
      // twist the same two fingers to orbit — 0.12 rad so a zoom pinch does not spin
      const ang=Math.atan2(a[1].y-a[0].y,a[1].x-a[0].x);
      let da=ang-pinchA;
      while(da>Math.PI)da-=TAU; while(da<-Math.PI)da+=TAU;
      if(Math.abs(da)>0.12){ yawTarget=pinchYaw-da; camYaw=yawTarget; }
      // slide both fingers up/down together to raise or drop the eye
      const dyc=my-pinchMY;
      if(Math.abs(dyc)>14){ pitchTarget=clamp(pinchPitch+dyc*0.0022,PITCH_MIN,PITCH_MAX); camPitch=pitchTarget; }
      clampCam(); camUpdateMatrices();
      const [wx1,wy1]=s2w(mx,my);
      cam.x+=wx0-wx1; cam.y+=wy0-wy1; clampCam(); camUpdateMatrices();
    }
  }
});
function endPtr(e){
  clearTimeout(holdTimer);
  const p=ptrs.get(e.pointerId);
  ptrs.delete(e.pointerId);
  /* Read before the early returns below, clear as soon as the last finger is
     off the glass. wasMulti gates the tap commit further down. */
  const wasMulti=multiTouch;
  if(ptrs.size===0) multiTouch=false;
  if(!p) return;
  if(aiming===5&&ptrs.size===0){
    /* Zooming to line up the shot ended it. The release that finishes a pinch
       reached onTap and fired the barrage wherever the second finger happened
       to be. Swallow it and leave the aim ARMED rather than cancelling, so
       framing the target costs the player nothing. */
    if(wasMulti) return;
    if(e.type==='pointercancel')cancelArtilleryBarrageAim(true);else onTap(p.x,p.y,p.pointerType);
    return;
  }
  if(orderPreview&&orderPreview.pid===e.pointerId){
    /* THE PINCH CASE THE FORMATION PREVIEW NEVER GOT.
       multiTouch already stops the last finger of a pinch from becoming a
       phantom ground tap (endPtr's tap gate) and from firing an armed
       artillery barrage (the aiming===5 branch above). This branch had
       neither test, and it runs BEFORE both — so with FORM armed the very
       first contact of ANY two-finger gesture builds an orderPreview, and
       releasing that finger committed a full formation move order to
       wherever it happened to be. Net effect: while FORM is lit the player
       cannot pinch to frame the destination without ordering the platoon to
       a spot they never chose. Swallow the release and leave FORM armed —
       the same contract the barrage aim uses, so re-framing costs nothing. */
    if(multiTouch||wasMulti){ orderPreview=null; return; }
    const P=orderPreview;orderPreview=null;armFormation=false;
    const fb=document.getElementById('formBtn');if(fb)fb.classList.remove('on');
    if(e.type!=='pointercancel'){
      orderMove(P.x,P.y,false);
      /* Stamp the release as a ground tap so a quick second tap still
         retreats. Formation preview never went through onTap, which is
         how an armed FORM button swallowed double-tap retreat. */
      stampGroundTap(p.x,p.y,false);
      /* Keep the exact count-based placement visible briefly after release.
         On touch screens the finger otherwise covered the only preview frame,
         making a valid formation order appear to have no visual response.
         noLine is NOT optional here. orderMove already published a confirm
         carrying it, precisely so the straight centroid->destination beam does
         not fight the traced route orderfx just drew; replacing that object
         without the flag put BOTH on the ground, which is the doubled order
         line players see on every formation drag. */
      orderConfirm={x:P.x,y:P.y,members:P.members.slice(),form:P.form,
                    until:performance.now()+950,noLine:1};
    }
    return;
  }
  if(boxStart && ptrs.size===0){
    // finish box select
    const bx=document.getElementById('selbox'); bx.style.display='none';
    const boxStartX=boxStart[0], boxStartY=boxStart[1];
    boxStart=null;
    /* One-shot only for the button — its toast promises a single drag, and a
       sticky box mode would strand a phone player with no way to pan. A
       shift-drag never armed the button, so it must not clear it either. */
    if(boxMode){ boxMode=false; const bb=document.getElementById('boxBtn'); if(bb) bb.classList.remove('on'); }
    /* pointercancel is teardown, never a command. WebView can cancel a contact
       for an app interruption or lost capture; treating that coordinate as the
       corner of a completed box selected units the player never released on. */
    if(e.type==='pointercancel'){ boxAdd=false; return; }
    const sx0=Math.min(boxStartX,p.x), sx1=Math.max(boxStartX,p.x);
    const sy0=Math.min(boxStartY,p.y), sy1=Math.max(boxStartY,p.y);
    if(sx1-sx0>10||sy1-sy0>10){
      const additive=boxAdd; boxAdd=false;
      if(!additive) clearSel();
      let n=0;
      /* Query the unit grid with a conservative world circle, then keep the
         exact screen rectangle as the final authority. Full-screen drags may
         still visit the army; ordinary boxes no longer scan 2,500 slots. */
      const wc=[s2w(sx0,sy0),s2w(sx1,sy0),s2w(sx1,sy1),s2w(sx0,sy1)];
      let minx=Infinity,maxx=-Infinity,miny=Infinity,maxy=-Infinity;
      for(const q of wc){minx=Math.min(minx,q[0]);maxx=Math.max(maxx,q[0]);miny=Math.min(miny,q[1]);maxy=Math.max(maxy,q[1]);}
      const qx=(minx+maxx)*.5,qy=(miny+maxy)*.5,qr=Math.hypot(maxx-minx,maxy-miny)*.5+mfPointerMaxSpan();
      forUnitsIn(qx,qy,qr,i=>{
        if(!ualive[i]||!(typeof mfLocalOwnsUnit==='function'?mfLocalOwnsUnit(i):uteam[i]===0)) return;
        const sp=w2s(ux[i],uy[i],terrainH(ux[i],uy[i])+TYPES[utype[i]].size*0.5);
        if(sp[0]>=sx0&&sp[0]<=sx1&&sp[1]>=sy0&&sp[1]<=sy1){ if(!usel[i]) n++; usel[i]=1; }
      });
      if(n) uiCommandAck('select',n);
      updateSelInfo();
      return;
    }
  }
  /* WHY: 9px `moved` is below thumb jitter. The first contact of a double-tap
     was classified as a pan, lastGroundT was never written, and the second
     tap could only ever be a single attack-move. A short press that drifted
     less than a fingertip is still a tap. Real pans are longer strokes.
     `performance.now()-p.t<HOLD_MS` stays the tap/hold gate (tools/test-input-hold-ms.mjs). */
  const dt=isFinite(e.timeStamp)&&isFinite(p.eventT)?Math.max(0,e.timeStamp-p.eventT):performance.now()-p.t;
  const withinHold=dt<HOLD_MS;
  const slop=Math.hypot(p.x-p.sx,p.y-p.sy);
  if(e.type!=='pointercancel' && !wasMulti && !p.held && withinHold && ptrs.size===0 && (!p.moved || (dt<TAP_JITTER_MS && slop<TAP_JITTER_PX))){
    if(placing){
      // tap anywhere to move the ghost there (then confirm with ✓)
      const [wx,wy]=s2w(p.x,p.y);
      placing.rx=clamp(wx,40,MAP-40); placing.ry=clamp(wy,40,MAP-40);
      snapPlace();
    } else { lastTapShift=!!p.shift; onTap(p.x,p.y,p.pointerType); lastTapShift=false; }
  }
}
cv.addEventListener('pointerup',endPtr);
cv.addEventListener('pointercancel',endPtr);
/* Desktop accelerator. Touch already retreated on the second pointerdown.
   dblclick only fires if lastGroundT is still live — i.e. the second
   pointerup never reached onTap (swallowed as a pan). */
cv.addEventListener('dblclick',e=>{
  if(!running||placing||boxMode||!selCount()||armQueue||armPatrol||aiming>=0) return;
  e.preventDefault();
  if(!groundDoubleTap(e.clientX,e.clientY)) return;
  const [wx,wy]=s2w(e.clientX,e.clientY);
  const pp=pickPointerEntities(wx,wy,e.clientX,e.clientY,'mouse');
  if(pp.enemy>=0||pp.bld>=0) return;
  stampGroundTap(e.clientX,e.clientY,true);
  orderMove(wx,wy,false,true);
});
cv.addEventListener('wheel',e=>{
  e.preventDefault();
  const [wx0,wy0]=s2w(e.clientX,e.clientY);
  camFollow=-1; camUser();
  orthoSpan=clamp(orthoSpan*(e.deltaY<0?0.87:1.15),zoomSpanMin(),zoomSpanMax()); distTarget=orthoSpan;
  clampCam(); camUpdateMatrices();
  const [wx1,wy1]=s2w(e.clientX,e.clientY);
  cam.x+=wx0-wx1; cam.y+=wy0-wy1; clampCam(); camUpdateMatrices();
},{passive:false});

/* Browser page-zoom (Ctrl+wheel, pinch on HUD, Ctrl+/-) scales the DOM
   instead of the ortho camera. The canvas handler above only covers #gl;
   overlays used to let pinch through. Kill page-zoom; game zoom stays on #gl. */
addEventListener('wheel',e=>{ if(e.ctrlKey||e.metaKey) e.preventDefault(); },{passive:false,capture:true});
addEventListener('gesturestart',e=>e.preventDefault(),{passive:false});
addEventListener('gesturechange',e=>e.preventDefault(),{passive:false});
addEventListener('keydown',e=>{
  if(!(e.ctrlKey||e.metaKey)) return;
  const k=e.key, c=e.code;
  if(k==='+'||k==='-'||k==='='||k==='0'||c==='NumpadAdd'||c==='NumpadSubtract') e.preventDefault();
},true);

/* A match can end while a finger is still captured by the battlefield canvas.
   Android then keeps that pointer sequence alive across the menu transition;
   the next apparent tap completes the old gesture instead of activating a menu
   button. Every route back to the front end calls this before rebuilding the
   attract scene, so input starts from a genuinely idle state. */
function resetInputState(){
  boxAdd=false;
  clearTimeout(holdTimer);
  for(const id of ptrs.keys()){
    try{ if(cv.hasPointerCapture(id)) cv.releasePointerCapture(id); }catch(e){}
  }
  ptrs.clear();
  boxMode=false; boxStart=null; pinchD=0; dragGhost=false; multiTouch=false;
  armFormation=false; orderPreview=null; orderConfirm=null;
  if(typeof aiming!=='undefined'&&aiming>=0){
    if(aiming===5&&typeof cancelArtilleryBarrageAim==='function')cancelArtilleryBarrageAim(true);
    else aiming=-1;
  }
  if(armPatrol) cancelPatrolDraft(true);
  if(armQueue) cancelQueueDraft(true);
  /* An armed rally survived every route back to the front end. It is cleared
     by resetWorld at the START of the next match, so the leak only shows on
     paths that re-enter a live match without a world reset — but this function
     is the one that claims a genuinely idle input state, so it owns the bit. */
  disarmRally();
  lastGroundT=0;
  const sb=document.getElementById('selbox'); if(sb) sb.style.display='none';
  const bb=document.getElementById('boxBtn'); if(bb) bb.classList.remove('on');
  const fb=document.getElementById('formBtn'); if(fb) fb.classList.remove('on');
}

addEventListener('keydown',e=>{
  if(e.key!=='Tab'||!running||typeof recallGroup!=='function') return;
  const t=e.target, tag=t&&t.tagName;
  if(tag==='INPUT'||tag==='TEXTAREA'||(t&&t.isContentEditable)) return;
  e.preventDefault();
  let start=activePlatoon<0?0:activePlatoon+1;
  for(let k=0;k<4;k++){
    const n=(start+k)%4;
    if(groupLive(ctrlGroups[n]).length){ recallGroup(n,!!e.shiftKey); return; }
  }
});

/* Releasing Shift executes a chain that Shift started, which is the behaviour a
   desktop RTS player already has in their hands. A chain armed from the QUEUE
   button is untouched: it waits for GO, because a touch player has no Shift to
   release. */
addEventListener('keyup',e=>{
  if(e.key!=='Shift'||!armQueue||!queueDraft||!queueDraft.viaShift) return;
  if(queueDraft.steps.length) commitQueueDraft(); else cancelQueueDraft(true);
});

/* Build the control now rather than on first use: the orders row is hidden until
   something is selected, and a button that only appears after its first press
   cannot be discovered. */
ensureQueueBtn(); queueButtonState();

// ---------- minimap ----------
const mmc=document.getElementById('minimap');
mmc.setAttribute('role','application');mmc.tabIndex=0;
mmc.setAttribute('aria-label','Tactical minimap. Use arrow keys to pan the camera and Home to center the map');
mmc.setAttribute('aria-keyshortcuts','ArrowUp ArrowDown ArrowLeft ArrowRight Home');
function mmNav(e){
  const r=mmc.getBoundingClientRect();
  cam.x=(e.clientX-r.left)/r.width*MAP;
  cam.y=(e.clientY-r.top)/r.height*MAP;
  camFollow=-1; camUser(); clampCam(); camUpdateMatrices();
}
mmc.addEventListener('pointerdown',e=>{ e.stopPropagation(); mmNav(e); mmc.setPointerCapture(e.pointerId); });
mmc.addEventListener('pointermove',e=>{ if(e.buttons) mmNav(e); });
mmc.addEventListener('keydown',e=>{
  const arrows=['ArrowLeft','ArrowRight','ArrowUp','ArrowDown'];
  if(!arrows.includes(e.key)&&e.key!=='Home')return;
  e.preventDefault();e.stopPropagation();
  if(e.key==='Home'){cam.x=MAP*.5;cam.y=MAP*.5;}
  else {
    const step=Math.max(18,(typeof orthoSpan==='number'?orthoSpan:80)*.28)*(e.shiftKey?3:1);
    if(e.key==='ArrowLeft')cam.x-=step;if(e.key==='ArrowRight')cam.x+=step;
    if(e.key==='ArrowUp')cam.y-=step;if(e.key==='ArrowDown')cam.y+=step;
  }
  camFollow=-1;camUser();clampCam();camUpdateMatrices();
});