vdd
/
OpenPuck
镜像自地址 https://github.com/safijari/OpenPuck


			
				
					
						
						
							12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237
							<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>OpenPuck Config</title>
<style>
  :root{ --bg:#11131a; --card:#1b1f2b; --fg:#e7ecf3; --mut:#8a93a6; --acc:#5bd6a0; --acc2:#5b9bd6; --bad:#d65b6e; --warn:#e3b341; }
  *{box-sizing:border-box}
  body{margin:0;font:14px/1.5 -apple-system,Segoe UI,Roboto,sans-serif;background:var(--bg);color:var(--fg)}
  h1{font-size:20px;margin:0 0 4px}
  .sub{color:var(--mut);margin:0 0 18px;font-size:13px}
  /* sticky top action bar: connection + device-maintenance actions */
  .topbar{position:sticky;top:0;z-index:20;display:flex;align-items:center;gap:10px;flex-wrap:wrap;
    padding:9px 18px;background:#151925;border-bottom:1px solid #272d3d}
  .topbar .brand{font-weight:700;font-size:15px;letter-spacing:.02em}
  .topbar .brand small{color:var(--mut);font-weight:400;font-size:11px;margin-left:6px}
  .topbar .spacer{flex:1 1 16px}
  .topbar button{padding:7px 12px}
  .wrap{max-width:980px;margin:0 auto;padding:20px}
  /* cards stack in one column; width comes from the wider wrap + grids/rows filling it horizontally */
  .card{background:var(--card);border:1px solid #272d3d;border-radius:12px;padding:16px 18px;margin:0 0 16px}
  /* ReversePuck dongle: hide every puck-only Controller card, keep just the paired-pucks card (this leaves
     the debugonly/lizard inline visibility rules untouched, so switching back to a puck restores them). */
  body.dongle #tabMain > .cards > .card:not(#pairedCard){display:none !important}
  .card h2{font-size:13px;text-transform:uppercase;letter-spacing:.06em;color:var(--mut);margin:0 0 14px}
  .row{display:flex;align-items:center;gap:14px;margin:12px 0;flex-wrap:wrap}
  .row label{flex:0 0 150px;color:var(--fg)}
  .row .val{flex:0 0 64px;text-align:right;color:var(--acc);font-variant-numeric:tabular-nums}
  input[type=range]{flex:1;min-width:120px;accent-color:var(--acc)}
  select{background:#0e1017;color:var(--fg);border:1px solid #313a4f;border-radius:8px;padding:6px 8px;flex:1;min-width:120px}
  button{background:#222a3a;color:var(--fg);border:1px solid #36405a;border-radius:8px;padding:9px 14px;cursor:pointer;font:inherit}
  button:hover{border-color:var(--acc2)}
  button.primary{background:var(--acc2);border-color:var(--acc2);color:#06121f;font-weight:600}
  button.active{background:var(--acc);border-color:var(--acc);color:#062018;font-weight:600}
  button.beta{background:#2d2613;border-color:#80651c;color:#ffd875;font-weight:600}
  button.beta.active{background:var(--warn);border-color:var(--warn);color:#1d1604}
  button.danger{background:#3a1420;border-color:#7a2233;color:#ff9bb0;font-weight:600}
  button.danger:hover{border-color:#ff9bb0}
  button:disabled{opacity:.4;cursor:default}
  .pill{display:inline-block;padding:2px 9px;border-radius:99px;font-size:12px;font-weight:600}
  .pill.up{background:#143626;color:var(--acc)} .pill.dn{background:#3a1822;color:var(--bad)}
  /* update-available notice (topbar): :not(.hide) so this ID rule can't out-rank .hide (see #updModal) */
  #updAvail:not(.hide){background:#14263a;color:var(--acc2);cursor:pointer;border:1px solid #2b4a6d}
  #updAvail:hover{text-decoration:underline}
  .statgrid{display:grid;grid-template-columns:repeat(auto-fill,minmax(155px,1fr));gap:10px}
  .stat{background:#0e1017;border:1px solid #232a3a;border-radius:8px;padding:10px}
  .stat .k{color:var(--mut);font-size:11px;text-transform:uppercase;letter-spacing:.05em}
  .stat .v{font-size:18px;margin-top:2px}
  .modes{display:flex;gap:10px;flex-wrap:wrap}
  /* back4 chords: face buttons in the left column, D-pad in the right; auto-fit collapses to one column on a
     narrow viewport, and also when the D-pad column is hidden on pre-v18 firmware (display:none drops the item) */
  .chord-cols{display:grid;grid-template-columns:repeat(auto-fit,minmax(290px,1fr));gap:0 24px}
  .chord-cols .row{margin:10px 0}
  .chord-cols .row label{flex:0 0 108px}
  .colhead{color:var(--mut);font-size:11px;text-transform:uppercase;letter-spacing:.06em;margin:2px 0 0}
  .note{color:var(--mut);font-size:12px;margin-top:10px}
  #log{font:12px ui-monospace,Menlo,monospace;color:var(--mut);white-space:pre-wrap;margin-top:8px;max-height:140px;overflow:auto}
  .hide{display:none}

  /* ---- controller slot tabs ---- */
  .slot-tabs{display:flex;gap:6px;margin:0 0 14px;flex-wrap:wrap}
  .slot-tab{display:flex;align-items:center;gap:7px;padding:5px 14px;border-radius:8px;font-size:12px;font-weight:600;background:#0e1017;border:1px solid #232a3a;color:var(--mut);cursor:pointer;transition:border-color .15s,color .15s,background .15s}
  .slot-tab:hover{border-color:var(--acc2);color:var(--fg)}
  .slot-tab.active{background:#111c2e;border-color:var(--acc2);color:var(--fg)}
  .slot-tab .dot{width:7px;height:7px;border-radius:50%;background:var(--bad);flex-shrink:0;transition:background .3s}
  .slot-tab .dot.up{background:var(--acc);animation:pulse-link 2.2s ease-in-out infinite}
  @keyframes pulse-link{
    0%,100%{box-shadow:0 0 0 0 rgba(91,214,160,.5)}
    55%{box-shadow:0 0 0 5px rgba(91,214,160,0)}
  }
  @media(prefers-reduced-motion:reduce){.slot-tab .dot.up{animation:none}}
  .per-slot-grid{margin-bottom:12px}

  /* ---- top-level tabs (Controller / Firmware update) ---- */
  #mainTabs{margin:0 0 16px}
  #mainTabs .slot-tab{font-size:13px;padding:7px 18px}
  #mainTabs .slot-tab.beta-gated{background:#31270e;border-color:#8a6b1e;color:#ffd875}
  #mainTabs .slot-tab.beta-gated:hover{border-color:var(--warn);color:#ffe7a0}

  /* ---- firmware update tab ---- */
  .dropzone{border:2px dashed #36405a;border-radius:12px;padding:26px 18px;text-align:center;cursor:pointer;
    color:var(--mut);transition:border-color .15s,background .15s;margin-bottom:14px}
  .dropzone:hover,.dropzone.drag{border-color:var(--acc);color:var(--fg);background:#151b28}
  .dropzone b{color:var(--fg)}
  .rel-row{display:flex;align-items:center;gap:14px;padding:10px 2px;border-top:1px solid #232a3a;flex-wrap:wrap}
  .rel-row:first-child{border-top:0}
  .rel-row .ver{font-weight:700;min-width:70px}
  .rel-row .date{color:var(--mut);font-size:12px;min-width:90px}
  .rel-row .grow{flex:1}
  .rel-row label{display:flex;align-items:center;gap:6px;color:var(--mut);font-size:12px;cursor:pointer}
  .rel-row input[type=checkbox]{accent-color:var(--bad)}
  /* firmware-tab gate: when the connected puck's firmware predates panel updates, both update cards go
     inert (pointer-events kills clicks, drops, and the file picker) and the banner explains why */
  .fwupcard.gated{opacity:.45;pointer-events:none;user-select:none}

  /* ---- blocking update modal ---- */
  /* :not(.hide) because this ID selector would otherwise out-rank .hide{display:none} and pin the modal open */
  #updModal:not(.hide){position:fixed;inset:0;z-index:100;background:rgba(8,10,16,.8);display:flex;align-items:center;justify-content:center}
  .updbox{background:var(--card);border:1px solid #36405a;border-radius:14px;padding:22px 26px;width:min(500px,92vw);box-shadow:0 18px 60px rgba(0,0,0,.5)}
  .updbox h3{margin:0 0 4px;font-size:16px}
  #updStage{color:var(--fg);margin:10px 0 0;font-size:14px}
  .updbar{height:10px;background:#0e1017;border:1px solid #232a3a;border-radius:99px;overflow:hidden;margin:10px 0 6px}
  #updFill{height:100%;width:0;background:var(--acc);transition:width .2s}
  #updFill.pulse{background:repeating-linear-gradient(45deg,var(--acc2),var(--acc2) 12px,#38618c 12px,#38618c 24px);animation:updslide 1s linear infinite}
  #updFill.bad{background:var(--bad)}
  @keyframes updslide{to{background-position:34px 0}}
  @media(prefers-reduced-motion:reduce){#updFill.pulse{animation:none}}
</style>
</head>
<body>
<div class="topbar">
  <span class="brand">OpenPuck <small>SC2 puck · WebUSB</small></span>
  <span id="connState" class="pill dn">disconnected</span>
  <button id="connectBtn" class="primary">Connect</button>
  <span id="updAvail" class="pill hide" title="A newer OpenPuck release is available — click to open the Firmware update tab">…</span>
  <span class="spacer"></span>
  <button id="betaBtn" class="beta" title="Show beta features warning and enable beta UI">Beta</button>
  <button id="debugCdc" title="Reboot ONCE with the CDC serial console enabled (WebUSB goes away for that boot); auto-reverts on the next boot">Debug CDC</button>
  <button id="dfuSerial" title="Reboot into serial DFU (adafruit-nrfutil), then replug">Serial DFU</button>
  <button id="dfuUf2" title="Reboot into the UF2 mass-storage bootloader; drop a .uf2 on the drive">UF2 DFU</button>
  <button id="factoryErase" class="danger" title="Wipe ALL bonds + settings and reboot to defaults. You must re-pair. Cannot be undone.">⚠ Factory erase</button>
  <button id="wipeBoard" class="danger debugonly" title="ERASE THE ENTIRE BOARD: firmware + all settings + bonds. The board reboots app-less and mounts as the UF2 drive on every boot until you re-flash OpenPuck. Debug only. Cannot be undone.">☢ Wipe board</button>
</div>
<div class="wrap">
  <p class="sub">First connect uses the Chrome/Edge device picker; reconnects are automatic. If the picker is empty, quit any app holding the device or replug.</p>

  <div id="panel" class="hide">
    <div class="slot-tabs" id="mainTabs">
      <span class="slot-tab active" data-tab="tabMain">Controller</span>
      <span class="slot-tab" data-tab="tabUpdate">Firmware update</span>
    </div>

    <div id="tabMain">
    <div class="cards">
    <div class="card wide" id="pairedCard" style="display:none">
      <h2>Paired pucks</h2>
      <div class="row" style="gap:10px;align-items:center;margin-bottom:4px">
        <span class="pill" id="pairedLink">—</span>
        <span class="note" id="pairedFwd" style="flex:1">—</span>
      </div>
      <div id="pairedList"><p class="note">Reading paired pucks…</p></div>
      <p class="note" style="margin-top:8px">This is a <strong>ReversePuck</strong> controller dongle (28DE:1302). It emulates a Steam Controller to whichever puck it's paired with. Pair new pucks with <code>scpair.py</code>; use the <em>Firmware update</em> tab to flash a new dongle build.</p>
    </div>
    <div class="card">
      <h2>Version</h2>
      <div class="statgrid">
        <div class="stat"><div class="k">Firmware build</div><div class="v" id="stVersionBuild">—</div></div>
        <div class="stat"><div class="k">Status protocol</div><div class="v" id="stVersionProto">—</div></div>
        <div class="stat"><div class="k">Panel update</div><div class="v" id="stVersionUpdate">—</div></div>
      </div>
      <p class="note">This section reflects the connected puck. Reconnect after flashing or changing modes to verify what is currently running.</p>
    </div>

    <div class="card">
      <h2>USB mode</h2>
      <div class="modes" style="flex-wrap:wrap">
        <button data-mode="0" class="modebtn">Steam (puck)</button>
        <button data-mode="1" class="modebtn">Xbox 360</button>
        <button data-mode="2" class="modebtn">Switch (HORIPAD)</button>
        <button data-mode="3" class="modebtn">Lizard (always)</button>
        <button data-mode="4" class="modebtn">Switch Pro + gyro</button>
        <button data-mode="5" class="modebtn">PS5 DualSense</button>
        <button data-mode="6" class="modebtn">HID gyro (DS4)</button>
        <button data-mode="9" class="modebtn">PS3 (DualShock 3)</button>
      </div>
      <p class="note">Switching reboots the copycat and re-enumerates USB (~2 s). WebUSB works in every mode, including Steam/Lizard with Steam running (Chrome claims the vendor interface; Steam keeps the HID slots). Switch HORIPAD + WebUSB is PC-only.</p>
      <div class="row"><label>Persist last mode</label>
        <button id="persistMode">off</button>
        <span class="note" style="flex:1">Off (default): every restart / fresh reconnect boots into Steam mode. On: remembers the last mode you selected.</span>
      </div>
    </div>

    <div class="card">
      <h2>Back4 chords (face + D-pad)</h2>
      <p class="note" style="margin-top:0">Hold all four back paddles (L4+R4+L5+R5) plus a face button or D-pad direction to switch mode without the WebUI. <strong>A is always Steam</strong> — that is the way back out of any mode. B / X / Y and all four D-pad directions are configurable below (defaults: B=Lizard, X=Xbox, Y=Switch Pro).</p>
      <div class="chord-cols">
        <div>
          <div class="colhead">Face buttons</div>
          <div class="row"><label>back4 + B</label><select class="chord" data-i="0"></select></div>
          <div class="row"><label>back4 + X</label><select class="chord" data-i="1"></select></div>
          <div class="row"><label>back4 + Y</label><select class="chord" data-i="2"></select></div>
        </div>
        <!-- D-pad chords (firmware >= v18). Unlike the face selects these offer the game/clean modes too: those
             modes have no WebUSB interface, so a chord is the only way IN, and back4+A is always the way out.
             Older firmware has no D-pad chords at all -> the whole column hides (see #dpadChords in applyBlob). -->
        <div id="dpadChords" class="hide">
          <div class="colhead">D-pad</div>
          <div class="row"><label>back4 + Left</label><select class="chordD" data-i="0"></select></div>
          <div class="row"><label>back4 + Up</label><select class="chordD" data-i="1"></select></div>
          <div class="row"><label>back4 + Right</label><select class="chordD" data-i="2"></select></div>
          <div class="row"><label>back4 + Down</label><select class="chordD" data-i="3"></select></div>
        </div>
      </div>
      <p id="dpadOld" class="note hide">This puck's firmware predates the D-pad chords — update it to configure them.</p>
    </div>

    <div class="card wide">
      <h2>Link status</h2>

      <!-- Per-controller tabs: visible only when 2+ controllers are bonded -->
      <div class="slot-tabs" id="slotTabs" style="display:none"></div>

      <!-- Per-slot: RF link / Battery / Signal / this controller's own link rates (blob v13) -->
      <div class="statgrid per-slot-grid">
        <div class="stat"><div class="k">RF link</div><div class="v" id="stLink">—</div></div>
        <div class="stat"><div class="k">Battery</div><div class="v" id="stBatt">—</div></div>
        <div class="stat"><div class="k">Signal</div><div class="v" id="stRssi">—</div></div>
        <div class="stat"><div class="k">Polls/s</div><div class="v" id="stSlotPolls">—</div></div>
        <div class="stat"><div class="k">Delivered</div><div class="v" id="stSlotF1">—</div></div>
        <div class="stat"><div class="k">Fails/s (crc·noRx·relay)</div><div class="v" id="stSlotFail">—</div></div>
      </div>

      <!-- Global stats (sums over ALL controllers; the per-slot grid above shows the selected controller's own rates) -->
      <div class="statgrid">
        <div class="stat"><div class="k">Delivered (all)</div><div class="v" id="stRate">—</div></div>
        <div class="stat"><div class="k">New reports (all)</div><div class="v" id="stNew">—</div></div>
        <div class="stat"><div class="k">Polls/s (all)</div><div class="v" id="stPolls">—</div></div>
        <div class="stat"><div class="k">Relay/s (all)</div><div class="v" id="stRelay">—</div></div>
        <div class="stat"><div class="k">RF fails/s (crc·noRx·heal)</div><div class="v" id="stRfFail">—</div></div>
        <div class="stat"><div class="k">Clock LF / HF</div><div class="v" id="stClock">—</div></div>
        <div class="stat"><div class="k">µs per ms (ideal 1000)</div><div class="v" id="stUsPerMs">—</div></div>
        <div class="stat"><div class="k">Loop</div><div class="v" id="stLoopState">—</div></div>
        <div class="stat"><div class="k">usbd stack free (words)</div><div class="v" id="stUsbdStack">—</div></div>
        <div class="stat logonly"><div class="k">Loop period</div><div class="v" id="stLoop">—</div></div>
        <div class="stat logonly"><div class="k">Slowest stage</div><div class="v" id="stWorst">—</div></div>
        <div class="stat logonly"><div class="k">Poll period act/want</div><div class="v" id="stPollPer">—</div></div>
        <div class="stat"><div class="k">Build</div><div class="v" id="stBuild">—</div></div>
        <div class="stat"><div class="k">Last reset</div><div class="v" id="stReset">—</div></div>
      </div>
      <p class="note" style="margin-top:6px"><strong>Reset detail:</strong> <span id="resetHist" style="font-family:ui-monospace,Menlo,monospace">—</span><br>
        <em>watchdog (hang)</em>/<em>CPU lockup</em>/<em>HARDFAULT</em> = a fault worth reporting (issue #72); <em>reboot</em> = an intentional reset (mode change / config); <em>power-on</em> &amp; <em>pin/replug</em> = normal plug-in.</p>
      <p class="note" style="margin-top:8px"><strong>IMU (raw):</strong> <span id="stImu" style="font-family:ui-monospace,Menlo,monospace">—</span><br>
        Raw SC2 accel (before scaling). This controller is a ±2 g sensor (~16384 = 1 g); the Switch report divides it by 4 to present the genuine ±8 g (4096 = 1 g) scale so the console's gravity-correction engages and the gyro stops drifting.</p>
      <p class="note logonly">Polls/s ≈ 250 expected; it's capped by Loop period (≈4000 µs needed). "Slowest stage" is the loop section eating the most time per iteration.</p>
      <div class="row debugonly" style="margin:14px 0 0;border-top:1px solid #272d3d;padding-top:14px"><button id="hapClear">Clear stuck buzz</button>
        <span class="note" style="flex:1">If the controller's haptics get stuck/buzzing, this re-inits them (same as pressing Steam).</span>
      </div>
      <div class="row" style="margin:10px 0 0"><button id="ctlrOff">Turn off controller</button>
        <span class="note" style="flex:1">Fires the controller power-off (0x9F "off!", x3) — the same path Steam's "turn off controller" and host-suspend use. Watch the link status to see it disconnect.</span>
      </div>
      <div class="row debugonly" style="margin:10px 0 0"><button id="landAll87">off</button>
        <span class="note" style="flex:1"><strong>Land all 0x87 (experiment).</strong> Relay Steam's full haptic/settings config to the controller verbatim (like the real puck) instead of discarding it. Testing whether the connect buzz is caused by the controller's haptic engine being left misconfigured. If the <em>gyro freezes</em> in Steam, turn this back off.</span>
      </div>
      <div class="row debugonly" style="margin:10px 0 0;border-top:1px solid #272d3d;padding-top:14px"><button id="stabBtn">Test stability</button>
        <span class="v" id="stabStatus" style="flex:0 0 auto;min-width:120px">—</span>
        <span class="note" style="flex:1">Buzzes the controllers every 10 s (keeps them awake) and times how long the puck stays up. On a reset it records the uptime and shows it by <em>Last reset</em>; it auto-resumes after the puck reconnects. The count is kept in this tab (a page refresh clears it).</span>
      </div>
    </div>

    <div class="card" id="mouseCard">
      <h2>Trackpad mouse (lizard + Xbox)</h2>
      <div class="row"><label>Sensitivity</label><input type="range" id="mDiv" min="4" max="200" step="1"><span class="val" id="mDivV"></span></div>
      <div class="row"><label>Glide / friction</label><input type="range" id="mFric" min="0" max="99" step="1"><span class="val" id="mFricV"></span></div>
      <p class="note">Right-pad cursor in Steam-mode lizard (Steam closed) and in Xbox mode. Sensitivity is a divisor — lower = faster pointer. Glide = how long the cursor coasts after a flick.</p>
    </div>

    <div class="card">
      <h2>Switch Pro motion</h2>
      <!-- Gyro mapping (firmware >= v19). Older firmware always uses the corrected mapping and has no field
           to set -> the whole block hides (see #swGyroMapBlock in applyBlob). -->
      <div id="swGyroMapBlock">
        <div class="row"><label>Gyro mapping</label><select id="swGyroMap"></select></div>
        <p class="note">Corrected (default) trims the gyro so Switch Pro mode matches a genuine Pro Controller and Steam mode (roll ×0.8, pitch/yaw ×0.9). Legacy sends the raw axes untrimmed — the pre-fix behavior, if you preferred the faster feel or tuned your in-game sensitivity around it.</p>
      </div>
      <p id="swGyroOld" class="note hide">This puck's firmware predates the gyro-mapping setting — update it to configure it.</p>
    </div>

    <div class="card wide">
      <h2>Button mapping</h2>
      <p class="note" style="margin-top:0">Separate mappings per emulated controller type — each only offers targets that exist on that controller. The type matching the current mode is highlighted. Steam &amp; Lizard are native puck modes (Steam does its own remapping) and aren't configured here.</p>
      <div id="typeCfgs"></div>
    </div>

    <div class="card" id="lizardCard" style="display:none">
      <h2>Lizard / desktop mapping</h2>
      <p class="note" style="margin-top:0">Keyboard, mouse &amp; media bindings for <strong>Lizard (always)</strong> mode — each row maps a controller input to a desktop action. (Steam-mode seamless lizard, when Steam is closed, keeps the built-in default behavior and is not affected by this map.) Edits apply after <strong>Save to device</strong>.</p>
      <div id="lizardList"></div>
      <div class="row" style="margin:12px 0 0;flex-wrap:wrap;gap:8px">
        <button id="lzAdd">+ Add binding</button>
        <button id="lzSave" class="primary">Save to device</button>
        <button id="lzReload">Reload</button>
        <button id="lzReset" style="margin-left:auto">Reset to defaults</button>
      </div>
      <p class="note" id="lzStatus" style="margin-top:8px">—</p>
    </div>

    <div class="card">
      <h2>Backup &amp; clone</h2>
      <p class="note" style="margin-top:0">Save this puck's controller pairings <em>and</em> every setting to a file, then restore them onto another puck. The other puck becomes a clone — any controller paired to this one connects to it with <strong>no re-pairing</strong>. (Also a plain backup: re-import after a factory erase to get everything back.)</p>
      <div class="row" style="margin:0;flex-wrap:wrap">
        <button id="backupExport" class="primary">Export to file…</button>
        <button id="backupImport">Import from file…</button>
        <input type="file" id="backupFile" accept="application/json,.json" style="display:none">
      </div>
      <p class="note">Import <strong>overwrites</strong> all pairings and settings on the connected puck, then reboots it (~2 s — reconnect after). Tip: pair every controller to one puck, export once, then import onto each spare.</p>
    </div>

    <div class="card wide debugonly">
      <h2>Hang log</h2>
      <p class="note" style="margin-top:0">One row per reset: uptime before it, reason, the stuck loop stage and captured PC (when the watchdog ISR could run), and usbd stack free. Accumulates across resets in this tab — a page refresh clears it. Pair with <em>Test stability</em> above for unattended runs.</p>
      <div class="row" style="margin:0 0 8px;flex-wrap:wrap">
        <span class="v" id="hangSummary" style="flex:1">no resets logged yet</span>
        <button id="hangCsv">Download CSV</button>
        <button id="hangClear">Clear</button>
      </div>
      <pre id="hangOut" style="font:12px ui-monospace,Menlo,monospace;color:var(--fg);background:#0e1017;border:1px solid #232a3a;border-radius:8px;padding:10px;margin:0;max-height:260px;overflow:auto;white-space:pre"></pre>
    </div>

    <div class="card wide debugonly">
      <h2>Loop-state trail</h2>
      <p class="note" style="margin-top:0">Every change of the <em>Loop</em> pill, timestamped — stall episodes, live wedge reports, heartbeat loss (hard wedge, USB silent), recoveries, disconnects and the reset cause on reconnect — so an unattended hang is recorded even if you weren't watching. Saved in this browser (localStorage): it <strong>survives page refreshes</strong> and device reboots, and clears only with the button.</p>
      <div class="row" style="margin:0 0 8px;flex-wrap:wrap">
        <span class="v" id="trailSummary" style="flex:1">no events yet</span>
        <button id="trailClear">Clear</button>
      </div>
      <pre id="trailOut" style="font:12px ui-monospace,Menlo,monospace;color:var(--fg);background:#0e1017;border:1px solid #232a3a;border-radius:8px;padding:10px;margin:0;max-height:260px;overflow:auto;white-space:pre-wrap">—</pre>
    </div>

    <div class="card wide debugonly">
      <h2>Flight recorder</h2>
      <p class="note" style="margin-top:0">The trail of events the firmware recorded in the seconds before its most recent <b>watchdog hang</b> — the ring survives the reset in <code>.noinit</code> RAM (like the hang PC), so it's the post-mortem of what wedged the board. Loads automatically after a hang reconnects; click to reload. Same data the console <code>FR</code> command prints. <span id="flightWedge" style="font-family:ui-monospace,Menlo,monospace"></span></p>
      <div class="row" style="margin:0 0 8px;flex-wrap:wrap">
        <span class="v" id="flightSummary" style="flex:1">no trail loaded</span>
        <button id="flightLoad">Load last-hang trail</button>
      </div>
      <pre id="flightOut" style="font:12px ui-monospace,Menlo,monospace;color:var(--fg);background:#0e1017;border:1px solid #232a3a;border-radius:8px;padding:10px;margin:0;max-height:320px;overflow:auto;white-space:pre">—</pre>
    </div>

    <div class="card wide logonly">
      <h2>Capture — host → controller commands</h2>
      <p class="note" style="margin-top:0">The firmware logs everything from boot into a big RAM ring: Steam's writes (<code>ifN</code>), the frames we transmit to the controller (<code>TX→ctlr</code>), and RF <code>LINK UP/DOWN</code> edges. For the reconnect buzz: trigger it (it appears moments after the puck boots / the controller reconnects), then connect here and click <b>Dump from boot</b> — the trigger is still in the ring. (Only present in a logging build, <code>-DOPK_LOG=1</code>.)</p>
      <div class="row" style="margin:0;flex-wrap:wrap">
        <button id="capStart" class="primary">Dump from boot</button>
        <button id="capStop" disabled>Stop</button>
        <button id="capDl">Download .txt</button>
      </div>
      <p class="note">Dump streams the whole ring (oldest→newest) and then keeps live-updating until you press Stop. <code>cmd</code> is the command/report byte, then the raw bytes.</p>
      <pre id="capOut" style="font:12px ui-monospace,Menlo,monospace;color:var(--fg);background:#0e1017;border:1px solid #232a3a;border-radius:8px;padding:10px;margin-top:10px;max-height:260px;overflow:auto;white-space:pre-wrap"></pre>
    </div>
    </div><!-- .cards -->
    </div><!-- #tabMain -->

    <div id="tabUpdate" class="hide">
      <div id="updGate" class="card hide" style="border-color:#7a2233">
        <h2 style="color:var(--bad)">Panel updates not supported by this firmware</h2>
        <p class="note" id="updGateMsg" style="margin:0"></p>
      </div>

      <div class="card fwupcard">
        <h2>Update from a local file</h2>
        <input id="uf2File" class="hide" type="file" accept=".uf2,application/octet-stream">
        <div id="uf2Drop" class="dropzone">
          <div><b>Drop a .uf2 file here</b> — or click to browse</div>
          <div class="note" id="uf2Sel" style="margin-top:6px">no file selected</div>
        </div>
        <div class="row" style="margin:0">
          <button id="uf2Flash" class="primary" disabled title="Pick a .uf2 file first">Flash firmware</button>
          <span class="note" style="flex:1;margin:0">The image is streamed over WebUSB into spare flash, verified <em>on the puck</em>, and applied on an automatic reboot. Nothing is armed until it verifies — a failed or interrupted transfer leaves the running firmware untouched, and even a power cut during the apply only leaves the puck in its UF2 bootloader for drag-and-drop recovery.</span>
        </div>
      </div>

      <div class="card fwupcard" id="relCard">
        <h2>Update from a release</h2>
        <div class="row" style="margin-top:0">
          <span class="note" style="flex:1;margin:0">Official builds from <a href="https://github.com/safijari/openpuck/releases" target="_blank" rel="noopener" style="color:var(--acc2)">github.com/safijari/openpuck/releases</a> &nbsp;·&nbsp; installed: <b id="updInstalled" style="color:var(--acc)">—</b></span>
          <button id="relRefresh">Refresh</button>
        </div>
        <div id="relList" class="note" style="margin:0">loading…</div>
        <p class="note"><b style="color:var(--bad)">Factory reset</b> flashes the <code>-factory-reset</code> build of that version: on its first boot it wipes ALL settings and the controller pairing (you must re-pair), then behaves like the standard build. Use it to recover from a bad config or stale bond.</p>
      </div>
    </div><!-- #tabUpdate -->

    <div id="log"></div>
  </div>
</div>

<!-- blocking modal: covers the whole page while an update is in flight so nothing else can be clicked -->
<div id="updModal" class="hide">
  <div class="updbox">
    <h3 id="updTitle">Firmware update</h3>
    <div id="updStage">…</div>
    <div class="updbar"><div id="updFill"></div></div>
    <div id="updPct" class="note" style="margin:0"></div>
    <div id="updDetail" class="note"></div>
    <div class="row" style="justify-content:flex-end;margin:14px 0 0"><button id="updClose" class="hide">Close</button></div>
  </div>
</div>

<script>
const MODE_NAMES = ["Steam (puck)","Xbox 360","Switch (HORIPAD)","Lizard (always)","Switch Pro + gyro","PS5 DualSense","HID gyro (DS4)","PS5 (game/clean)","DS4 (game/clean)","PS3 (DualShock 3)"];
const CHORD_FIELD = [17, 18, 19];          // back4 + B/X/Y
const CHORD_DPAD_FIELD = [34, 35, 36, 37]; // back4 + D-pad left/up/right/down (firmware protocol >= 18)
const CHORD_DPAD_DEF = [9, 8, 7, 2];       // firmware defaults: PS3, DS4 game, PS5 game, Switch HORIPAD
let dev=null, epIn=0, epOut=0, ifNum=0, polling=false, capturing=false, backupBusy=false;
// A ReversePuck CONTROLLER dongle (28DE:1302) speaks a REDUCED subset of this protocol: no status blob /
// lizard / config, just a paired-pucks list (0xAC) plus the identical firmware-update + DFU ops. When true,
// the panel shows the controller UI (manage paired pucks + flash) and skips every puck-only poll.
let isDongle=false;
let lastP=null; // most recent status-blob payload (config source for Export)
// Stability test: armed = active across reconnects; stabStart = ms of the current run; stabLastRun = last
// completed run {secs} (ended by a reset). Kept in-page so it survives the device reset (not a page refresh).
let stabArmed=false, stabStart=0, stabLastRun=null;
// Firmware update via the UF2 picker: selectedUf2 = {name, image} (image = the app binary extracted from the
// .uf2 at pick time, so a bad file is rejected before anything is sent). dfuBusy blocks re-entry while an
// update is in flight.
let selectedUf2=null, dfuBusy=false;
// Running hang log: one entry per reset (persists in-page across the device reset; a page refresh clears it).
// pendingHang is set at disconnect and enriched with reason/PC/stack from the first blob after reconnect.
let hangLog=[], pendingHang=null;
function renderHangLog(){
  const out=$("#hangOut"), sum=$("#hangSummary"); if(!out) return;
  if(!hangLog.length){ out.textContent=""; sum.textContent="no resets logged yet"; return; }
  const ups=hangLog.filter(e=>e.uptime!=null).map(e=>e.uptime);
  const avg=ups.length?Math.round(ups.reduce((a,b)=>a+b,0)/ups.length):null;
  sum.textContent = hangLog.length+" reset(s)"+(avg!=null?("  ·  avg uptime "+fmtDur(avg)):"");
  const pad=(s,n)=>String(s).padEnd(n);
  out.textContent = pad("time",11)+pad("uptime",9)+pad("reason",16)+pad("stage",10)+pad("PC",11)+"usbd\n"
    + hangLog.map(e=>pad(e.time,11)+pad(e.uptime!=null?fmtDur(e.uptime):"-",9)+pad(e.reason,16)+pad(e.stage||"-",10)+pad(e.pc||"-",11)+(e.usbd!=null?e.usbd:"-")).join("\n");
}
function fmtDur(s){ s=Math.round(s); return s>=60 ? (Math.floor(s/60)+"m "+(s%60)+"s") : (s+"s"); }
function updateUf2UI(){
  const sel=$("#uf2Sel"), flash=$("#uf2Flash");
  if(!sel || !flash) return;
  sel.textContent = selectedUf2
    ? selectedUf2.name+" — app image "+Math.round(selectedUf2.image.length/1024)+" KiB, parsed OK"
      +(selectedUf2.updatable ? "" : " — ⚠ no panel-update support in this image (flashing it = drag-and-drop only afterwards)")
    : "no file selected";
  flash.disabled = dfuBusy || !selectedUf2;
  flash.title = selectedUf2
    ? "Send " + selectedUf2.name + " to the puck over WebUSB, verify it, and apply it on reboot"
    : "Pick a .uf2 file first";
}
function updateStabUI(){
  const btn=$("#stabBtn"), st=$("#stabStatus");
  if(!btn) return;
  btn.textContent = stabArmed ? "Stop stability test" : "Test stability";
  btn.classList.toggle("active", stabArmed);
  let txt="";
  if(stabArmed && dev && stabStart) txt="up "+fmtDur((Date.now()-stabStart)/1000);
  else if(stabArmed && !dev) txt="reconnecting…";
  if(stabLastRun) txt += (txt?"  ·  ":"")+"last run: "+fmtDur(stabLastRun.secs);
  st.textContent = txt||"—";
}
setInterval(updateStabUI, 500);
const $ = s=>document.querySelector(s);
// Debug UI gate: developer/diagnostic controls (stability test, clear-stuck-buzz, land-all-0x87) and the
// forensic cards (Hang log, Loop-state trail, Flight recorder) only show with ?debug=true in the URL.
// Everything still RUNS regardless (the trail keeps recording to localStorage, stability auto-resume works)
// -- only the UI is hidden, so adding ?debug=true after an unattended incident still shows the history.
const DEBUG_UI = new URLSearchParams(location.search).get("debug")==="true";
if(!DEBUG_UI) for(const el of document.querySelectorAll(".debugonly")) el.style.display="none";
// Firmware-update tab gate: beta enables tested-but-not-yet-default surfaces.
const BETA_UI = new URLSearchParams(location.search).get("beta")==="true";
$("#betaBtn").textContent = BETA_UI ? "Beta on" : "Beta";
$("#betaBtn").classList.toggle("active", BETA_UI);
$("#betaBtn").title = BETA_UI
  ? "Show beta-disable confirmation and return to the standard UI"
  : "Show beta warning and enable beta UI";
$('#mainTabs .slot-tab[data-tab="tabUpdate"]').classList.toggle("beta-gated", !BETA_UI);
function escHtml(s){
  return String(s).replace(/[&<>"']/g, c=>({"&":"&amp;","<":"&lt;",">":"&gt;","\"":"&quot;","'":"&#39;"}[c]));
}
function betaPopup({title, body, okText="OK", cancelText="Cancel"}){
  return new Promise(resolve=>{
    let done=false;
    const shade=document.createElement("div");
    shade.style.cssText="position:fixed;inset:0;z-index:90;background:rgba(8,10,16,.55);display:flex;align-items:center;justify-content:center;padding:18px";
    shade.innerHTML = '<div style="background:var(--card);border:1px solid #80651c;border-radius:12px;padding:20px 22px;width:min(440px,94vw);box-shadow:0 18px 60px rgba(0,0,0,.45)">'
      +'<h3 style="margin:0 0 10px;font-size:16px">'+escHtml(title)+'</h3>'
      +body.map(p=>'<p class="note" style="margin:8px 0">'+escHtml(p)+'</p>').join("")
      +'<div class="row" style="justify-content:flex-end;margin:18px 0 0">'
      +'<button data-beta-cancel>'+escHtml(cancelText)+'</button>'
      +'<button class="beta active" data-beta-ok>'+escHtml(okText)+'</button>'
      +'</div></div>';
    const finish=ok=>{
      if(done) return;
      done=true;
      shade.remove();
      resolve(!!ok);
    };
    shade.querySelector("[data-beta-cancel]").onclick=()=>finish(false);
    shade.querySelector("[data-beta-ok]").onclick=()=>finish(true);
    shade.onclick=e=>{ if(e.target===shade) finish(false); };
    shade.onkeydown=e=>{ if(e.key==="Escape") finish(false); };
    document.body.appendChild(shade);
    shade.tabIndex=-1;
    shade.focus();
  });
}
$("#betaBtn").onclick=async()=>{
  const u=new URL(location.href);
  if(BETA_UI){
    const ok=await betaPopup({
      title:"Disable beta mode?",
      body:["Beta-only tabs and controls will be gated again after the page reloads.",
        "Let any firmware or config operation already in progress finish before leaving beta mode."],
      okText:"Disable beta"
    });
    if(!ok) return;
    u.searchParams.delete("beta");
    location.href=u.toString();
    return;
  }
  const ok=await betaPopup({
    title:"Enable beta mode?",
    body:["Beta features are still being tested.",
      "They may not work correctly, can disconnect the panel or puck, and may write invalid or difficult-to-recover configs.",
      "Export a backup first if the puck is already paired and configured."],
    okText:"Enable beta"
  });
  if(!ok) return;
  u.searchParams.set("beta","true");
  location.href=u.toString();
};
function log(m){ const l=$("#log"); l.textContent=(new Date().toLocaleTimeString()+"  "+m+"\n"+l.textContent).slice(0,2000); }

// ---- Loop-state trail (persistent) ----
// Every transition of the Loop pill lands here with a wall-clock timestamp, persisted in localStorage --
// unlike the pill (live-only) and the in-page logs (a refresh wipes them), this survives page refreshes and
// device reboots, so a hang that happened while nobody was watching is still on record. Newest first, capped;
// cleared only by the Clear button.
const TRAIL_KEY="opk_loop_trail", TRAIL_MAX=400;
let loopTrail=[]; try{ loopTrail=JSON.parse(localStorage.getItem(TRAIL_KEY))||[]; }catch(e){ loopTrail=[]; }
function trailAdd(m){
  loopTrail.unshift({t:Date.now(), m});
  if(loopTrail.length>TRAIL_MAX) loopTrail.length=TRAIL_MAX;
  try{ localStorage.setItem(TRAIL_KEY, JSON.stringify(loopTrail)); }catch(e){}
  renderTrail();
}
function renderTrail(){
  const out=$("#trailOut"), sum=$("#trailSummary"); if(!out) return;
  sum.textContent = loopTrail.length ? (loopTrail.length+" event(s) — newest first") : "no events yet";
  out.textContent = loopTrail.length
    ? loopTrail.map(e=>new Date(e.t).toLocaleString()+"  "+e.m).join("\n") : "—";
}
$("#trailClear").onclick=()=>{ loopTrail=[]; try{ localStorage.removeItem(TRAIL_KEY); }catch(e){} renderTrail(); log("loop-state trail cleared"); };
renderTrail();

// Per-emulated-type config (must match firmware ET_* order: Xbox=0, Switch=1, DS4=2, DS5=3). Each type lists
// only the remap targets that exist on that controller. Field id sent to firmware = 40 + et*9 + k
// (k: 0..3 back paddles, 4 QAM, 5 A/B-swap, 6 trackpad-haptics, 7 LED brightness, 8 rumble). Blob v17 reads them back at p[73 + et*9 + ...].
const DPAD = {12:"D-pad Up",13:"D-pad Down",14:"D-pad Left",15:"D-pad Right"};
const TYPE_DEFS = [
  {key:"XBOX", name:"Xbox", labels:{1:"A",2:"B",3:"X",4:"Y",5:"LB",6:"RB",7:"L3",8:"R3",9:"Back",10:"Start",11:"Guide",19:"LT",20:"RT",...DPAD}},
  {key:"SWITCH", name:"Switch", labels:{1:"A",2:"B",3:"X",4:"Y",5:"L",6:"R",7:"L-Stick",8:"R-Stick",9:"Minus",10:"Plus",11:"Home",19:"ZL",20:"ZR",...DPAD,18:"Capture / Screenshot"}},
  {key:"DS4", name:"DS4", labels:{1:"Cross",2:"Circle",3:"Square",4:"Triangle",5:"L1",6:"R1",7:"L3",8:"R3",9:"Create",10:"Options",11:"PS",19:"L2",20:"R2",...DPAD,16:"Touchpad Click"}},
  {key:"DS5", name:"DS5", labels:{1:"Cross",2:"Circle",3:"Square",4:"Triangle",5:"L1",6:"R1",7:"L3",8:"R3",9:"Create",10:"Options",11:"PS",19:"L2",20:"R2",...DPAD,16:"Touchpad Click",17:"Mute"}},
];
// Which emulated type a USB mode belongs to (mirror of firmware etypeForMode); -1 = puck mode (no type).
function etypeForMode(m){ switch(m){case 1:return 0; case 2:case 4:return 1; case 6:case 8:case 9:return 2; case 5:case 7:return 3; default:return -1;} }

// ===================== Lizard (desktop) binding map =====================
// Mirrors firmware lizard_map.h. A binding is {outType, od:[7], trig, hold}. Output types and the
// per-type payload (od[]) layout must match the constants in lizard_map.h exactly.
const LZ_MAX = 32;
const LZO = {NONE:0, KBD:1, MBTN:2, AXIS:3, SCROLL:4, CONSUMER:5};
const LZ_OUT_LABELS = {0:"(disabled)", 1:"Keyboard key", 2:"Mouse button", 3:"Mouse move", 4:"Scroll wheel", 5:"Media key"};
// Controller input bits (triton.h TB_* + virtual left-stick deflection bits). Single-bit triggers only.
const LZ_BTNS = [
  [0x1,"A"],[0x2,"B"],[0x4,"X"],[0x8,"Y"],
  [0x10,"QAM (• • •)"],[0x40,"View"],[0x4000,"Menu"],[0x10000,"Steam"],
  [0x20,"R3 (stick click)"],[0x8000,"L3 (stick click)"],
  [0x80,"R4 (back upper-right)"],[0x100,"R5 (back lower-right)"],
  [0x20000,"L4 (back upper-left)"],[0x40000,"L5 (back lower-left)"],
  [0x200,"RB (bumper)"],[0x80000,"LB (bumper)"],
  [0x800000,"R2 (trigger pull)"],[0x8000000,"L2 (trigger pull)"],
  [0x2000,"D-pad Up"],[0x400,"D-pad Down"],[0x1000,"D-pad Left"],[0x800,"D-pad Right"],
  [0x400000,"Right pad click"],[0x4000000,"Left pad click"],
  [0x200000,"Right pad touch"],[0x2000000,"Left pad touch"],
  [0x10000000,"L-stick → right"],[0x20000000,"L-stick → left"],[0x40000000,"L-stick → down"],[0x80000000,"L-stick → up"],
];
// Keyboard modifier bits (od[0] for KBD output).
const LZ_MODS = [[0x01,"Ctrl"],[0x02,"Shift"],[0x04,"Alt"],[0x08,"Win/⌘"]];
// Curated HID keycodes (od[1] for KBD output). Value 0 = no key (modifier-only).
const LZ_KEYS = [[0,"— none —"]];
"ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").forEach((c,i)=>LZ_KEYS.push([0x04+i,c]));
"1234567890".split("").forEach((c,i)=>LZ_KEYS.push([0x1e+i,c]));
[[0x28,"Enter"],[0x29,"Esc"],[0x2a,"Backspace"],[0x2b,"Tab"],[0x2c,"Space"],
 [0x4f,"Arrow Right"],[0x50,"Arrow Left"],[0x51,"Arrow Down"],[0x52,"Arrow Up"],
 [0x4a,"Home"],[0x4d,"End"],[0x4b,"Page Up"],[0x4e,"Page Down"],[0x49,"Insert"],[0x4c,"Delete"],
 [0x2d,"- _"],[0x2e,"= +"],[0x46,"Print Screen"]].forEach(k=>LZ_KEYS.push(k));
for(let i=0;i<12;i++) LZ_KEYS.push([0x3a+i,"F"+(i+1)]);
const LZ_MBTNS = [[1,"Left click"],[2,"Right click"],[4,"Middle click"]];
const LZ_AXIS_SRC = [[0,"Right trackpad"],[1,"Left stick"],[2,"Gyro"]];
const LZ_GYRO_ACT = [[0,"Always"],[1,"While right pad touched"],[2,"While left stick deflected"],[3,"While hold-button held"]];
const LZ_CONSUMER = [[1,"Volume +"],[2,"Volume −"]];

function lzBtnLabel(mask){ const m=LZ_BTNS.find(b=>b[0]===(mask>>>0)); return m?m[1]:(mask?("0x"+(mask>>>0).toString(16)):""); }
let lizardBindings = [];   // [{outType, od:[7], trig, hold}]
let lizardBusy = false;
let lizardLoaded = false;  // one-shot: the lizard map is fetched lazily, only once the connected puck proves it speaks v16+
const BACK_LABELS = ["L4 (back upper-left)","R4 (back upper-right)","L5 (back lower-left)","R5 (back lower-right)"];
const typeEls = []; // one entry per TYPE_DEFS: {sec, tab, activeDot, back[], qam, abSwap, pad, led, ledV, rumble, padStick[]}
// Trackpad -> joystick mapping (firmware PS_OFF/PS_LEFT/PS_RIGHT). Field id = PAD_STICK_FIELD0 + et*2 + pad
// (pad 0 = left trackpad, 1 = right). While mapped and touched the pad drives that stick; on release the
// stick re-centers, and an untouched mapped pad leaves the physical stick in control.
const PAD_STICK_FIELD0 = 80;
const PAD_STICK_OPTS = [[0,"Off (touchpad)"],[1,"Left stick"],[2,"Right stick"]];
const PAD_STICK_LABELS = ["Left trackpad \u2192 stick","Right trackpad \u2192 stick"];
function mkSelect(def, includeNone){
  const sel=document.createElement("select");
  if(includeNone){ const o=document.createElement("option"); o.value=0; o.textContent="— none —"; sel.appendChild(o); }
  else { const o=document.createElement("option"); o.value=0; o.textContent="Default (per-mode)"; sel.appendChild(o); }
  for(const c of Object.keys(def.labels).map(Number).sort((a,b)=>a-b)){
    const o=document.createElement("option"); o.value=c; o.textContent=def.labels[c]; sel.appendChild(o); }
  return sel;
}
let curTab=0, tabInited=false;
function setTab(et){
  curTab=et;
  typeEls.forEach((rec,i)=>{
    rec.sec.style.display = (i===et) ? "" : "none";
    rec.tab.classList.toggle("active", i===et);
  });
}
(function buildTypeCfgs(){
  const host=document.getElementById("typeCfgs");
  const bar=document.createElement("div"); bar.style.cssText="display:flex;gap:6px;flex-wrap:wrap;margin-bottom:12px";
  host.appendChild(bar);
  TYPE_DEFS.forEach((def,et)=>{
    // tab button
    const tab=document.createElement("button"); tab.className="slot-tab"; tab.style.cursor="pointer";
    tab.innerHTML='<span>'+def.name+'</span><span class="active-dot" style="display:none;font-size:11px;color:var(--acc)"> ●</span>';
    tab.onclick=()=>setTab(et); bar.appendChild(tab);
    // panel
    const sec=document.createElement("div"); sec.style.cssText="background:#0e1017;border:1px solid #232a3a;border-radius:8px;padding:12px 14px;display:none";
    const rec={sec,tab,activeDot:tab.querySelector(".active-dot"),back:[],qam:null,abSwap:null,pad:null,led:null,ledV:null,rumble:null,padStick:[]};
    // A/B swap + trackpad haptics + rumble toggles
    const tog=document.createElement("div"); tog.className="row";
    tog.innerHTML='<label>A/B + X/Y swap</label>';
    const ab=document.createElement("button"); ab.textContent="off"; tog.appendChild(ab);
    const padLbl=document.createElement("label"); padLbl.textContent="Trackpad haptics"; padLbl.style.marginLeft="14px"; tog.appendChild(padLbl);
    const pad=document.createElement("button"); pad.textContent="on"; tog.appendChild(pad);
    const rumbleLbl=document.createElement("label"); rumbleLbl.textContent="Rumble"; rumbleLbl.style.marginLeft="14px"; tog.appendChild(rumbleLbl);
    const rumble=document.createElement("button"); rumble.textContent="on"; tog.appendChild(rumble);
    sec.appendChild(tog);
    rec.abSwap=ab; rec.pad=pad; rec.rumble=rumble;
    ab.onclick=()=>{ const on=ab.classList.contains("active"); setField(40+et*9+5, on?0:1); };
    pad.onclick=()=>{ const on=pad.classList.contains("active"); setField(40+et*9+6, on?0:1); };
    rumble.onclick=()=>{ const on=rumble.classList.contains("active"); setField(40+et*9+8, on?0:1); };
    // back paddles
    for(let i=0;i<4;i++){
      const row=document.createElement("div"); row.className="row";
      const lab=document.createElement("label"); lab.textContent=BACK_LABELS[i]; row.appendChild(lab);
      const sel=mkSelect(def,true); row.appendChild(sel); sec.appendChild(row);
      sel.addEventListener("change",()=>setField(40+et*9+i, +sel.value));
      rec.back.push(sel);
    }
    // QAM
    { const row=document.createElement("div"); row.className="row";
      const lab=document.createElement("label"); lab.textContent="QAM (3 dots)"; row.appendChild(lab);
      const sel=mkSelect(def,false); row.appendChild(sel); sec.appendChild(row);
      sel.addEventListener("change",()=>setField(40+et*9+4, +sel.value));
      rec.qam=sel; }
    // LED brightness
    { const row=document.createElement("div"); row.className="row";
      const lab=document.createElement("label"); lab.textContent="LED brightness"; row.appendChild(lab);
      const sl=document.createElement("input"); sl.type="range"; sl.min=0; sl.max=100; sl.step=5; row.appendChild(sl);
      const vspan=document.createElement("span"); vspan.className="val"; row.appendChild(vspan);
      function fmtLed(v){ return (+v===0)?"Auto":v+"%"; }
      sl.addEventListener("input",()=>{ vspan.textContent=fmtLed(sl.value); });
      sl.addEventListener("change",()=>setField(40+et*9+7, +sl.value));
      sec.appendChild(row);
      rec.led=sl; rec.ledV=vspan; }
    // trackpad -> joystick mapping (one select per pad)
    for(let pad=0; pad<2; pad++){
      const row=document.createElement("div"); row.className="row";
      const lab=document.createElement("label"); lab.textContent=PAD_STICK_LABELS[pad]; row.appendChild(lab);
      const sel=document.createElement("select");
      for(const [v,lbl] of PAD_STICK_OPTS){ const o=document.createElement("option"); o.value=v; o.textContent=lbl; sel.appendChild(o); }
      row.appendChild(sel); sec.appendChild(row);
      sel.addEventListener("change",()=>setField(PAD_STICK_FIELD0+et*2+pad, +sel.value));
      rec.padStick.push(sel);
    }
    host.appendChild(sec); typeEls.push(rec);
  });
  setTab(0);
})();
for(const sel of document.querySelectorAll("select.chord")){
  MODE_NAMES.forEach((n,i)=>{ if(i===7||i===8) return;
    const o=document.createElement("option"); o.value=i; o.textContent=n; sel.appendChild(o); });
}
// D-pad chords offer EVERY mode, including the game/clean ones the face selects skip: those modes drop WebUSB,
// so a chord is the only way into them, and back4+A still gets you back to Steam.
for(const sel of document.querySelectorAll("select.chordD")){
  MODE_NAMES.forEach((n,i)=>{
    const o=document.createElement("option"); o.value=i; o.textContent=n; sel.appendChild(o); });
}
{ const sel=document.getElementById("swGyroMap");
  for(const [lbl,v] of [["Corrected (default)",0],["Legacy (untrimmed)",1]]){
    const o=document.createElement("option"); o.value=v; o.textContent=lbl; sel.appendChild(o); }
}

// ---- per-slot tab state ----
let g_activeSlot = 0;
let g_slotData = []; // [{up, battery, rssi}] indexed by slot 0..3, only set for bonded slots

function updateSlotDisplay(slotIdx) {
  const d = g_slotData[slotIdx];
  if (!d) { $("#stLink").innerHTML="—"; $("#stBatt").textContent="—"; $("#stRssi").textContent="—";
            $("#stSlotPolls").textContent="—"; $("#stSlotF1").textContent="—"; $("#stSlotFail").textContent="—"; return; }
  $("#stLink").innerHTML = d.up ? '<span class="pill up">up</span>' : '<span class="pill dn">down</span>';
  $("#stBatt").textContent = (d.up && d.battery) ? d.battery+"%" : "—";
  $("#stRssi").textContent = (d.up && d.rssi) ? ("-"+d.rssi+" dBm") : "—";
  // blob v13: this controller's OWN rates (the global grid's numbers are the sum over all controllers)
  if (d.stats) {
    $("#stSlotPolls").textContent = d.stats.polls+" /s";
    $("#stSlotF1").textContent = d.up ? (d.stats.f1+" /s ("+d.stats.newps+" new)") : "—";
    $("#stSlotFail").textContent = d.stats.crc+" · "+d.stats.norx+" · "+d.stats.relay;
  } else {
    $("#stSlotPolls").textContent="—"; $("#stSlotF1").textContent="—"; $("#stSlotFail").textContent="—";
  }
}

function renderSlotTabs(bondedCount) {
  const bar = $("#slotTabs");
  if (bondedCount <= 1) { bar.style.display="none"; updateSlotDisplay(g_activeSlot); return; }
  bar.style.display="flex";
  bar.innerHTML="";
  for (let s=0; s<4; s++) {
    const d = g_slotData[s];
    if (!d) continue;
    const btn = document.createElement("button");
    btn.className = "slot-tab" + (s===g_activeSlot ? " active" : "");
    const dot = document.createElement("span");
    dot.className = "dot" + (d.up ? " up" : "");
    btn.appendChild(dot);
    btn.appendChild(document.createTextNode("Controller "+(s+1)));
    btn.onclick = () => { g_activeSlot=s; renderSlotTabs(bondedCount); };
    bar.appendChild(btn);
  }
  updateSlotDisplay(g_activeSlot);
}

const USB_FILTERS=[{vendorId:0x28DE},{vendorId:0x045E},{vendorId:0x057E},{vendorId:0x0F0D},{vendorId:0x054C}];
// Acquire+set up an already-chosen USBDevice (shared by the manual picker and the no-picker auto-reconnect).
async function openDevice(d){
  try{
    dev=d;
    await dev.open();
    if(dev.configuration===null) await dev.selectConfiguration(1);
    let found=null;
    for(const itf of dev.configuration.interfaces){
      const a=itf.alternate;
      if(a.interfaceClass!==0xFF) continue;
      if(a.interfaceSubClass===0x5D) continue;
      let bin=0,bout=0;
      for(const e of a.endpoints){ if(e.type==="bulk"){ if(e.direction==="in")bin=e.endpointNumber; else bout=e.endpointNumber; } }
      if(bin&&bout){ found={ifNum:itf.interfaceNumber, epIn:bin, epOut:bout}; break; }
    }
    if(!found){ log("no WebUSB bulk vendor interface — reflash firmware with WebUSB enabled, or another app may be holding the device"); dev=null; return false; }
    ifNum=found.ifNum; epIn=found.epIn; epOut=found.epOut;
    await dev.claimInterface(ifNum);
    await dev.controlTransferOut({requestType:"class", recipient:"interface", request:0x22, value:0x01, index:ifNum});
    isDongle = (dev.productId === 0x1302); // ReversePuck controller dongle vs a puck (0x1304 / real)
    const kind = isDongle ? "ReversePuck" : "puck";
    $("#connState").textContent="connected"; $("#connState").className="pill up";
    $("#connState").title = dev.serialNumber ? (kind+" serial "+dev.serialNumber) : "";
    $("#connectBtn").textContent="Reconnect";
    $("#panel").classList.remove("hide");
    applyDeviceProfile(); // show the controller UI + hide puck-only cards (or vice-versa)
    log(`connected — ${kind} ${dev.serialNumber||"?"} (VID ${dev.vendorId.toString(16)} PID ${dev.productId.toString(16)} iface ${ifNum})`);
    // resume a stability test across the reset: re-arm the firmware buzz and start timing the next run
    // (puck-only: the dongle has no stability-test / haptic path)
    if(stabArmed && !isDongle){ await send([0x0F,1]); stabStart=Date.now(); log("stability test resumed — timing next run"); }
    updateStabUI();
    // The lizard-map dump (0x11 -> 0xAA) is loaded LAZILY, gated on the firmware advertising v16+ (see
    // applyBlob). Older firmware (every pre-lizard build, including the v15 updater builds) silently drops
    // 0x11, and readLizard()'s blocking transferIn would then hang forever -- wedging the status poll the
    // firmware-update gate depends on. So we never send 0x11 until a status blob proves the puck speaks v16.
    lizardLoaded=false;
    startPolling();
    // GitHub releases are PUCK firmware; skip the fetch for a dongle (it flashes via the local-file card).
    if(!isDongle) loadReleases(false); // background, cached: feeds the update-available notice + pre-warms the update tab
    return true;
  }catch(e){ log("connect failed: "+e.message); dev=null; return false; }
}
// Manual connect: shows the Chrome device picker (needed once, to authorize the device).
async function connect(){
  try{ const d = await navigator.usb.requestDevice({filters:USB_FILTERS}); await openDevice(d); }
  catch(e){ log("connect failed: "+e.message); }
}
// No-picker reconnect: reopen a device already authorized this browser. Returns true if it connected.
async function autoConnect(){
  if(dev) return true;
  try{
    const ds = await navigator.usb.getDevices();
    const d = ds.find(x=>USB_FILTERS.some(f=>f.vendorId===x.vendorId));
    if(d) return await openDevice(d);
  }catch(e){}
  return false;
}
function onGone(){
  // if a stability test is running, this disconnect is the reset that ended the run -- record its uptime
  // (kept in-page so it survives the reset + reconnect, shown next to Last reset).
  let up=null;
  if(stabArmed && stabStart){ up=(Date.now()-stabStart)/1000; stabLastRun={secs:up}; log("⏱ stability: stayed up "+fmtDur(up)+", then reset"); stabStart=0; }
  // if the PREVIOUS reset was never classified (no full blob landed between two resets), flush it as
  // "unclassified" instead of silently overwriting it -- every reset must leave a row.
  if(pendingHang){
    hangLog.unshift({ time:new Date(pendingHang.t).toLocaleTimeString(), uptime:pendingHang.uptimeSecs,
      reason:"unclassified", stage:"", pc:"", lr:"", usbd:null });
    renderHangLog();
    trailAdd("note: the previous reset was never classified — no full status blob arrived before this disconnect");
  }
  // queue a hang-log entry; the reason/PC/stack are filled from the first blob after reconnect
  pendingHang = { t: Date.now(), uptimeSecs: up };
  trailAdd("device disconnected"+(up!=null?(" after "+fmtDur(up)+" up"):"")+" — reset or replug; reason logged on reconnect");
  window._flightAuto=false; // re-arm the one-shot flight-trail auto-load for the next reconnect
  window._wedgeEp=false; window._wedgePeak=0; // re-arm the live wedge logger for the next wedge episode
  window._lastBlobTs=0; window._hbLostEp=false; // re-arm the heartbeat watchdog (don't fire on a stale pre-reset timestamp)
  polling=false; dev=null; tabInited=false; // re-default the config tab to the mode on next connect
  checkUpdateNotice(); // no device = no notice
  $("#connState").textContent="reconnecting…"; $("#connState").className="pill dn";
  $("#panel").classList.add("hide");
  log("device disconnected (mode-switch / watchdog reboot) — auto-reconnecting when it returns");
  // The puck re-enumerates after a reboot; retry without the picker. The "connect" event also triggers this,
  // but poll a few times in case the event is missed.
  let tries=0;
  const iv=setInterval(async()=>{ if(dev||tries++>40){ clearInterval(iv); return; } if(await autoConnect()) clearInterval(iv); }, 500);
}
// Auto-reconnect when an authorized puck (re)appears — no button, no picker.
navigator.usb && navigator.usb.addEventListener("connect", e=>{ if(!dev) autoConnect(); });
navigator.usb && navigator.usb.addEventListener("disconnect", e=>{ if(e.device===dev) onGone(); });
async function send(bytes){
  if(!dev) return;
  try{ await dev.transferOut(epOut, new Uint8Array(bytes)); }
  catch(e){ log("write err: "+e.message); }
}
// Read one framed reply and return its payload (with the 2-byte [marker][len] header stripped). The blob and
// the bond-export dump share the same framing, distinguished by the marker byte (0xA5 status, 0xA7 bonds).
async function readFrame(marker, minLen, readLen){
  try{
    // largest frame (status blob) spans multiple USB-FS packets; read generously to capture it in one call.
    // readLen is overridable: the dongle's 0xAC paired-pucks list reaches 213 B (8 pucks) and needs 256.
    const r = await dev.transferIn(epIn, readLen||256);
    if(r.status!=="ok"||r.data.byteLength<2) return null;
    const d=new Uint8Array(r.data.buffer);
    // Live wedge reporter (0xA9): emitted from the firmware's SOF callback (usbd task) while loop() is stalled --
    // the ONLY signal that survives a loop wedge on boards that wipe retained RAM across the reset. Scan for it
    // in every read so it surfaces regardless of which frame we were after. Payload: [stage][stallMs u16].
    for(let w=0; w+4<d.length; w++){
      if(d[w]===0xA9 && d[w+1]===3){ onWedge(d[w+2], d[w+3]|(d[w+4]<<8)); break; }
    }
    let i=0; while(i<d.length && d[i]!==marker) i++;
    if(i+2>d.length) return null;
    const len=d[i+1];
    // truncated read (transfer ended mid-frame): applying a half blob silently skips every late field --
    // reset cause, pendingHang classification, stack stats -- so drop the whole frame and retry next poll.
    if(i+2+len>d.length) return null;
    const p=d.slice(i+2, i+2+len);
    return p.length>=(minLen||0) ? p : null;
  }catch(e){ if(dev) log("read err: "+e.message); return null; }
}
async function readBlob(){ return readFrame(0xA5, 12); }
function applyBlob(p){
  lastP=p; // remember for Export (carries every config field the panel shows)
  window._lastBlobTs=Date.now(); // feeds the host-side heartbeat watchdog (hard-wedge detection)
  // Lazy, capability-gated lizard-map load: only after a blob proves the puck speaks v16+ (the op-0x11 dump).
  // On older firmware 0x11 is dropped silently and readLizard() would block the endpoint forever, so we must
  // NEVER send it blind at connect. One-shot per connection (reset in openDevice).
  if(!lizardLoaded && p[0]>=16){ lizardLoaded=true; loadLizard(); }
  const mode=p[1], mDiv=p[2], mFric=p[3]; // p[4..11] mirror the active type (per-type block below is authoritative)
  const slot=p[10], up=p[11], f1=(p[12]|(p[13]<<8));
  const newps=(p.length>16?(p[15]|(p[16]<<8)):0), persistMode=(p.length>22?p[22]:0);
  const chord=(p.length>25)?[p[23],p[24],p[25]]:[3,1,4];
  // D-pad chords land at the tail of the v18 payload (firmware p[182..185] = payload p[180..183]).
  const dpadCap=(p[0]>=18 && p.length>183);
  const chordD=dpadCap?[p[180],p[181],p[182],p[183]]:CHORD_DPAD_DEF;
  const polls=(p.length>27?(p[26]|(p[27]<<8)):0);
  const loopUs=(p.length>29?(p[28]|(p[29]<<8)):0);
  const worstIdx=(p.length>30?p[30]:0), worstUs=(p.length>32?(p[31]|(p[32]<<8)):0);
  const WORST=["webusb","ctrl.task","serial","rfdiag","rflink","haptic","led"];
  const pollUs=(p.length>34?(p[33]|(p[34]<<8)):0);
  const pollIntended=(p.length>14?p[14]*100:0);
  const logEnabled=(p.length>35?p[35]:0);
  for(const el of document.querySelectorAll(".logonly")) el.style.display = logEnabled ? "" : "none";
  for(const b of document.querySelectorAll(".modebtn")) b.classList.toggle("active", +b.dataset.mode===mode);
  $("#mouseCard").style.opacity = (mode===1||mode===3)?1:0.5;
  // The custom map applies ONLY to pure Lizard (always) mode. Steam-mode seamless lizard keeps
  // the built-in default behavior, so the editor is shown only when the device is in Lizard mode.
  $("#lizardCard").style.display = (mode===3 && p[0]>=16)?"":"none";
  const battery=(p.length>36?p[36]:0);
  // Switch Pro gyro mapping (protocol v19, firmware p[186] = payload p[184]). Older firmware has no such
  // setting at all -> the select hides (see #swGyroMap below). p[51..53] are the reserved bytes that used to
  // carry rumble strength / Switch report rate / Switch gyro scale, all removed settings.
  const gyroMapCap=(p[0]>=19 && p.length>184);
  const swGyroLegacy=gyroMapCap?p[184]:0;
  const rssi=(p.length>37?p[37]:0);

  // per-slot link status (protocol v8, p.length >= 73)
  const hasSlotsData = p.length >= 73;
  if (hasSlotsData) {
    const bondedN = p[60];
    g_slotData = [];
    for (let s=0; s<4; s++) {
      const base = 61 + s*3;
      if (p.length >= base+3) {
        // only include bonded slots (a slot with up=0 could be bonded but offline)
        // check if the slot appears at all in the bonded map by checking if bondedN covers it;
        // the firmware only sets non-zero battery/rssi for actually-bonded slots
        const slotUp = !!p[base];
        const slotBatt = p[base+1];
        const slotRssi = p[base+2];
        // slot is "bonded" if firmware included it in bondedN coverage
        // we populate slotData for all 4 and renderSlotTabs skips gaps
        g_slotData[s] = {up: slotUp, battery: slotBatt, rssi: slotRssi};
      }
    }
    // keep only bonded slots by cross-referencing bondedN
    // firmware sends bondedSlotCount but not a slot bitmask; use battery>0 || rssi>0 || up as presence hint
    // simpler: just count how many of the 4 slots have any non-zero data OR are marked up
    // Actually the firmware always writes all 4 slots; we filter by the bond system's "used" flag via presence.
    // For clean display: we'll show tabs only for slots that have ever had a reply OR are bonded (battery/rssi set).
    // The firmware sets g_battery[s]=0 and g_linkRssi[s]=0 for unused slots, so 0/0/0 = not bonded.
    // But a bonded offline slot also has 0/0/0 initially. We rely on bondedN for count and show the first bondedN slots
    // that have g_slot[s].used — but we can't easily know which slots are used from the blob.
    // Best heuristic: show all 4 slots if bondedN==4, otherwise use slot indices where battery or rssi != 0 OR up==1,
    // OR fall back to showing slots 0..bondedN-1 if none have data yet (device just booted).
    let bondedSlots = [];
    for (let s=0; s<4; s++) {
      if (g_slotData[s] && (g_slotData[s].up || g_slotData[s].battery || g_slotData[s].rssi)) bondedSlots.push(s);
    }
    // fallback: if no data yet (all offline, just booted), show slots 0..bondedN-1
    if (bondedSlots.length === 0 && bondedN > 0) {
      for (let s=0; s<bondedN; s++) bondedSlots.push(s);
    }
    // remove slotData for non-bonded slots so tabs don't appear for them
    const bondedSet = new Set(bondedSlots);
    for (let s=0; s<4; s++) { if (!bondedSet.has(s)) g_slotData[s] = null; }
    // clamp active slot to a valid bonded slot
    if (!g_slotData[g_activeSlot]) g_activeSlot = bondedSlots[0] || 0;
    // v13: per-slot link stats (fw p[145..180] -> js index 143..178): each controller's own
    // polls/delivered/new/crc/noRx/relay, so the tabs no longer show every controller merged into one number
    if (p.length >= 179) {
      for (let s=0; s<4; s++) {
        if (!g_slotData[s]) continue;
        const b = 143 + s*9;
        g_slotData[s].stats = { polls: p[b]|(p[b+1]<<8), f1: p[b+2]|(p[b+3]<<8),
                                newps: p[b+4]|(p[b+5]<<8), crc: p[b+6], norx: p[b+7], relay: p[b+8] };
      }
    }
    renderSlotTabs(bondedN);
  } else {
    // old firmware: single-slot display
    $("#slotTabs").style.display="none";
    $("#stLink").innerHTML = up? '<span class="pill up">up</span>' : '<span class="pill dn">down</span>';
    $("#stBatt").textContent = (up && battery)? battery+"%" : "—";
    $("#stRssi").textContent = (up && rssi)? ("-"+rssi+" dBm") : "—";
  }

  // global stats
  $("#stRate").textContent = up? f1+" /s" : "—";
  $("#stNew").textContent = up? newps+" /s" : "—";
  // Poll TX + RF-fail counts: shown ALWAYS (even when the link reads down) so a wedge is diagnosable --
  // polls>0 here while Delivered is "—" means the puck is still polling but getting no usable replies.
  $("#stPolls").textContent = polls+" /s";
  { const crc=(p.length>117?p[117]:0), norx=(p.length>118?p[118]:0), heal=(p.length>119?p[119]:0);
    const rf=(p.length>130?(p[129]|(p[130]<<8)):0);
    $("#stRfFail").innerHTML = crc+" · "+norx+" · "+heal + (rf?' · <span class="pill dn">ring '+rf+'</span>':"");
    // ring fault = we caught+recovered a relay-ring corruption that would otherwise be an invisible IRQ-off
    // watchdog hang. Log each new one (persists across the device reset + panel reconnect).
    if(rf>(window._ringFault||0)) log("⚠ RING FAULT #"+rf+" recovered — caught a relay-ring desync/corruption (would have hung loop with IRQs off)");
    window._ringFault=rf; }
  // v12: relay-frame rate + clock fingerprint (browser index = firmware index − 2)
  { const relay=(p.length>121?(p[120]|(p[121]<<8)):null);
    $("#stRelay").textContent = relay==null ? "—" : (relay+" /s"); }
  if(p.length>125){
    const LF=["stopped","RC","xtal","synth"], HF=["RC","?","xtal","?"];
    const lf=p[122], hf=p[123], upm=(p[124]|(p[125]<<8));
    const lfBad=(lf!==2), hfBad=(hf!==2), upmBad=(upm && (upm<985||upm>1015));
    const tag=(t,bad)=> bad ? '<span class="pill dn">'+t+'</span>' : t;
    $("#stClock").innerHTML = tag(LF[lf]||lf, lfBad)+" / "+tag(HF[hf]||hf, hfBad);
    $("#stUsPerMs").innerHTML = upm ? tag(""+upm, upmBad) : "—";
  }
  // v12: LIVE loop heartbeat — curStage (firmware p[129]) + ms-since-beat (p[130], 40ms units). Updates even
  // while loop() is wedged (blob is pushed from the SOF interrupt), so a hang shows "STALLED @ <stage>" live.
  if(p.length>128){
    const STAGE=["webusb","ctrl.task","serial","rfdiag","rflink","haptic","led","usbmount","usbtx"];
    const cur=p[127], stallMs=p[128]*40, name=(STAGE[cur]||("stage "+cur));
    if(stallMs>=200){
      $("#stLoopState").innerHTML='<span class="pill dn">STALLED @ '+name+' '+stallMs+'ms</span>';
      if(!window._stallEpisode) trailAdd("STALLED @ "+name+" ("+stallMs+"ms, soft wedge — usbd still alive)");
      // Latch+log the stall so it survives the imminent watchdog reset + panel reconnect (host-side log
      // persists). Log once per episode + keep escalating if it climbs toward the ~8s watchdog.
      if(!window._stallEpisode || stallMs>window._stallPeak+800){
        window._stallEpisode=true; window._stallPeak=stallMs;
        log("⚠ LOOP STALL @ "+name+" ("+stallMs+"ms) — watchdog reset imminent");
      }
    } else {
      if(window._stallEpisode) trailAdd("running again — stall recovered without a reset (peaked "+window._stallPeak+"ms)");
      window._stallEpisode=false; window._stallPeak=0;
      $("#stLoopState").innerHTML='<span class="pill up">running</span>';
    }
  }
  // v12: least-ever free stack on the usbd task (words). Low = overflow risk (multi-controller haptic-relay
  // hang hypothesis). Firmware p[141] -> browser p[139]. Red under 24 words (~96B), amber under 48.
  if(p.length>140){ const usbdW=(p[139]|(p[140]<<8));
    $("#stUsbdStack").innerHTML = usbdW<24 ? ('<span class="pill dn">'+usbdW+'</span>')
      : (usbdW<48 ? ('<span class="pill" style="background:#3a3216;color:#e5c76b">'+usbdW+'</span>') : (""+usbdW));
  }
  $("#stLoop").textContent = loopUs? loopUs+" µs" : "—";
  $("#stWorst").textContent = loopUs? (WORST[worstIdx]||worstIdx)+" "+worstUs+"µs" : "—";
  $("#stPollPer").textContent = up? (pollUs+" / "+pollIntended+" µs") : "—";
  // last-boot reset cause (protocol v11): a single classified code (firmware classifies it from RESETREAS +
  // a GPREGRET2 marker) plus the raw RESETREAS. Codes match RR_* in fault_diag.h. Earlier firmware (<v11)
  // didn't send this -> guard on length and leave the tile blank.
  const RR_NAMES = ["unknown","power-on","pin/replug","watchdog (hang)","CPU lockup",
                    "HARDFAULT","reboot","soft reset","wake-from-off"];
  const RR_FAULT = new Set([3,4,5]); // watchdog / lockup / hardfault = a real crash worth reporting (#72)
  if (p.length > 113) {
    const code = p[109];
    const raw = ((p[110]|(p[111]<<8)|(p[112]<<16)|(p[113]<<24))>>>0);
    const name = RR_NAMES[code] || ("code "+code);
    // v12: which loop stage was stuck when the last watchdog/lockup hang fired (0xFF = last boot wasn't a hang)
    const STAGE_NAMES = ["webusb","ctrl.task","serial","rfdiag","rflink","haptic","led","usbmount","usbtx"];
    const hangStage = (p.length>126 ? p[126] : 0xFF);
    let label = name;
    if (hangStage!==0xFF) label += " @ "+(STAGE_NAMES[hangStage]||("stage "+hangStage));
    $("#stReset").innerHTML = RR_FAULT.has(code) ? ('<span class="pill dn">'+label+'</span>') : label;
    // v12: PC/LR captured by the WDT pre-reset ISR (browser idx = firmware−2: hangPC@131, hangLR@135)
    const hpc=(p.length>134?((p[131]|(p[132]<<8)|(p[133]<<16)|(p[134]<<24))>>>0):0);
    const hlr=(p.length>138?((p[135]|(p[136]<<8)|(p[137]<<16)|(p[138]<<24))>>>0):0);
    const hx=v=>"0x"+v.toString(16).padStart(8,"0");
    const el = $("#resetHist");
    if (el) el.textContent = "RESETREAS=0x"+raw.toString(16).padStart(8,"0")
      + (hangStage!==0xFF ? "  hung in: "+(STAGE_NAMES[hangStage]||hangStage) : "")
      + (hpc ? "  hang PC="+hx(hpc)+" LR="+hx(hlr) : "")
      + (stabLastRun ? "  ·  stability: stayed up "+fmtDur(stabLastRun.secs)+" before this reset" : "");
    if (hpc && hpc!==window._hangPC){ window._hangPC=hpc; log("⚑ HANG PC="+hx(hpc)+" LR="+hx(hlr)+" — send me this; I'll map it to the stuck function"); }
    // append the queued reset to the running hang log, now that we have this boot's reason/PC/stack
    if (pendingHang){
      const usbdW2=(p.length>140?(p[139]|(p[140]<<8)):0);
      hangLog.unshift({ time:new Date(pendingHang.t).toLocaleTimeString(), uptime:pendingHang.uptimeSecs,
        reason:name, stage:(hangStage!==0xFF)?(STAGE_NAMES[hangStage]||("stage"+hangStage)):"",
        pc:hpc?hx(hpc):"", lr:hlr?hx(hlr):"", usbd:usbdW2 });
      trailAdd("reconnected — last reset: "+name
        +(hangStage!==0xFF?(" @ "+(STAGE_NAMES[hangStage]||("stage "+hangStage))):"")
        +(hpc?(" PC="+hx(hpc)):"")
        +(pendingHang.uptimeSecs!=null?("  (up "+fmtDur(pendingHang.uptimeSecs)+" before it)"):""));
      try{ localStorage.setItem("opk_trail_rrfp", code+"/"+raw.toString(16)+"/"+hangStage+"/"+hpc.toString(16)); }catch(e){}
      pendingHang=null; renderHangLog();
    }
    // Page wasn't open when it reset (refresh / closed browser): a fault-class boot still lands in the trail,
    // once per distinct reset -- fingerprinted + persisted so every later page load doesn't re-log the same one.
    else if (RR_FAULT.has(code)){
      const fp=code+"/"+raw.toString(16)+"/"+hangStage+"/"+hpc.toString(16);
      if(localStorage.getItem("opk_trail_rrfp")!==fp){
        try{ localStorage.setItem("opk_trail_rrfp", fp); }catch(e){}
        trailAdd("connected — last boot was a "+label+(hpc?(" PC="+hx(hpc)):"")+" (page wasn't open to catch it live)");
      }
    }
    // Auto-load the flight-recorder trail once per connection when the last boot was a real crash (watchdog/
    // lockup/hardfault) -- the trail is the post-mortem of what wedged the board. Deferred to the poll loop so
    // it doesn't nest transferIn inside this refresh.
    if (RR_FAULT.has(code) && !window._flightAuto){ window._flightAuto=true; window._autoFlight=true; }
  }

  // per-type trackpad->stick mapping (blob v20, firmware p[187..194] -> JS p[185..192])
  const padStickCap=(p[0]>=20 && p.length>192);
  const gitDirty=(p.length>38?p[38]:0); let buildId="";
  for(let i=39;i<51 && i<p.length && p[i];i++) buildId+=String.fromCharCode(p[i]);
  $("#stBuild").innerHTML = buildId
    ? (buildId + (gitDirty ? ' <span class="pill dn">dirty</span>' : ' <span class="pill up">clean</span>'))
    : "—";
  $("#updInstalled").textContent = buildId || "—"; // mirrored on the Firmware-update tab
  updateVersionUI();
  updateFwGate(); // (re)evaluate the firmware-tab gate on every blob — version is at p[0]
  checkUpdateNotice(); // needs BOTH the installed version (this blob) and relCache (fetched on connect)
  setSlider("mDiv",mDiv); setSlider("mFric",mFric);
  $("#persistMode").textContent = persistMode? "on":"off"; $("#persistMode").classList.toggle("active",!!persistMode);
  // land-all-0x87 experiment toggle (blob v14/v17, firmware p[181] -> JS p[179])
  { const la=(p.length>179?p[179]:0); $("#landAll87").textContent = la?"on":"off"; $("#landAll87").classList.toggle("active",!!la); }
  // per-type button config (blob v10/v17): 4 types x 9 bytes. readBlob() strips the 2-byte [0xA5][len] header, so
  // the firmware's buffer index 75 lands at JS index 73 here.
  if(p.length>=73+TYPE_DEFS.length*9){
    const activeEt=etypeForMode(mode);
    typeEls.forEach((rec,et)=>{
      const q=73+et*9;
      const back=[p[q],p[q+1],p[q+2],p[q+3]], qam=p[q+4], ab=p[q+5], pad=p[q+6], led=p[q+7], rum=p[q+8];
      rec.back.forEach((sel,i)=>{ if(document.activeElement!==sel) sel.value=back[i]; });
      if(document.activeElement!==rec.qam) rec.qam.value=qam;
      rec.abSwap.textContent=ab?"on":"off"; rec.abSwap.classList.toggle("active",!!ab);
      rec.pad.textContent=pad?"on":"off"; rec.pad.classList.toggle("active",!!pad);
      rec.rumble.textContent=rum?"on":"off"; rec.rumble.classList.toggle("active",!!rum);
      if(document.activeElement!==rec.led){ rec.led.value=led; rec.ledV.textContent=(led===0)?"Auto":led+"%"; }
      rec.padStick.forEach((sel,pad)=>{
        // hidden entirely on firmware too old to speak the mapping, so the panel never shows a dead control
        sel.parentNode.classList.toggle("hide", !padStickCap);
        if(padStickCap && document.activeElement!==sel) sel.value=p[185+et*2+pad];
      });
      // dot marks the type matching the current puck mode
      rec.activeDot.style.display = (et===activeEt) ? "" : "none";
    });
    // open the tab for the current mode's type on first load (then leave the user's choice alone)
    if(!tabInited){ tabInited=true; setTab(activeEt>=0?activeEt:0); }
  }
  if(p.length>=60){ const s16=(o)=>{ let v=p[o]|(p[o+1]<<8); return v>32767?v-65536:v; };
    const ax=s16(54),ay=s16(56),az=s16(58);
    const amag=Math.round(Math.sqrt(ax*ax+ay*ay+az*az));
    $("#stImu").textContent = `a=(${ax}, ${ay}, ${az})  |a|=${amag}`;
  }
  { const sel=$("#swGyroMap");
    $("#swGyroMapBlock").classList.toggle("hide", !gyroMapCap);
    $("#swGyroOld").classList.toggle("hide", gyroMapCap);
    if(gyroMapCap && document.activeElement!==sel) sel.value=swGyroLegacy; }
  for(const sel of document.querySelectorAll("select.chord")){ if(document.activeElement!==sel) sel.value=chord[+sel.dataset.i]; }
  $("#dpadChords").classList.toggle("hide", !dpadCap);
  $("#dpadOld").classList.toggle("hide", dpadCap);
  if(dpadCap) for(const sel of document.querySelectorAll("select.chordD")){ if(document.activeElement!==sel) sel.value=chordD[+sel.dataset.i]; }
}
function fmtSlider(id,v){ return id==="hapBlockS" ? v+" s" : ""+v; }
function setSlider(id,v){ const el=$("#"+id); if(document.activeElement!==el){ el.value=v; } $("#"+id+"V").textContent=fmtSlider(id,el.value); }

let inflight=false;
async function refresh(){
  if(!dev||inflight||capturing||backupBusy||flightBusy||lizardBusy) return; inflight=true;
  // try/finally: an exception anywhere in here (applyBlob included) must never leave inflight latched true --
  // that would silently kill all future polls and read as a fake "heartbeat lost".
  try{
    if(isDongle){ await send([0x01]); const p=await readFrame(0xAC, 3, 256); if(p) applyDongleStatus(p); }
    else { await send([0x01]); const p=await readBlob(); if(p) applyBlob(p); }
  }
  catch(e){ log("refresh err: "+e.message); }
  finally{ inflight=false; }
}

// ---- ReversePuck controller dongle: paired-pucks list (0xAC frame) ----
// Payload (readFrame strips the [0xAC][len] header): [ver][flags][count] + per bond 26B:
//   [slot][alive][puuid4][iuuid4][serial16]. flags bit0=forwarding a Deck, bit1=an RF link is up.
function applyDongleStatus(p){
  window._lastBlobTs=Date.now(); // heartbeat + waitReconnect success signal (mirrors applyBlob)
  if(pendingHang){ // a reconnect after a reboot: close out the hang-log row we opened on disconnect
    pendingHang=null;
  }
  const flags=p[1], count=p[2], bonds=[];
  for(let i=0;i<count;i++){
    const q=3+i*26; if(q+26>p.length) break;
    const dec=new TextDecoder("latin1");
    let serial=dec.decode(new Uint8Array(p.slice(q+10,q+26)));
    const z=serial.indexOf("�"); if(z>=0) serial=serial.slice(0,z);
    serial=serial.replace(/[^\x20-\x7e]/g,"").trim(); // strip NUL padding / stray non-printables
    bonds.push({slot:p[q], alive:!!p[q+1],
      puuid:p.slice(q+2,q+6), iuuid:p.slice(q+6,q+10), serial});
  }
  renderPaired(bonds, flags);
}
function renderPaired(bonds, flags){
  const list=$("#pairedList"); if(!list) return;
  $("#pairedFwd").textContent = (flags&1) ? "forwarding a Steam Deck" : "idle";
  $("#pairedLink").textContent = (flags&2) ? "RF link up" : "no RF link";
  $("#pairedLink").className = "pill "+((flags&2)?"up":"dn");
  if(!bonds.length){ list.innerHTML='<p class="note">No pucks paired yet. Pair one with <code>scpair.py</code> (see ReversePuck/README.md), then it appears here.</p>'; return; }
  const hex=a=>[...a].map(x=>x.toString(16).padStart(2,"0")).join("");
  list.innerHTML="";
  for(const b of bonds){
    const row=document.createElement("div"); row.className="row"; row.style.cssText="align-items:center;gap:10px;margin:6px 0";
    const badge=b.alive?'<span class="pill up" style="flex:0 0 auto">live</span>':'<span class="pill" style="flex:0 0 auto">offline</span>';
    row.innerHTML=`${badge}<div style="flex:1"><div style="font-weight:600">${b.serial||"(unnamed puck)"}</div>`
      +`<div class="note" style="font-family:ui-monospace,Menlo,monospace">slot ${b.slot} · puuid ${hex(b.puuid)} · iuuid ${hex(b.iuuid)}</div></div>`;
    const rm=document.createElement("button"); rm.textContent="Remove"; rm.className="danger"; rm.style.flex="0 0 auto";
    rm.title="Un-bond this puck from the ReversePuck. You'll need to re-pair to use it again.";
    rm.onclick=async()=>{
      if(!confirm(`Remove paired puck "${b.serial||"slot "+b.slot}"?\n\nThe ReversePuck forgets this pairing; re-pair with scpair.py to use it again.`)) return;
      await send([0x30, b.slot & 0xff]); log("removed paired puck slot "+b.slot);
      // the firmware replies with a fresh 0xAC after the remove; the next poll (or this read) refreshes the list
    };
    row.appendChild(rm); list.appendChild(row);
  }
}

// Toggle the UI between the full puck panel and the reduced ReversePuck (controller dongle) panel. Called on
// every (re)connect so switching a puck<->dongle in one session lands on the right layout.
function applyDeviceProfile(){
  const d=isDongle;
  // body.dongle drives the CSS that hides the puck-only Controller cards; toggling the class back on a puck
  // reconnect restores them without clobbering the debugonly/lizard inline visibility rules.
  document.body.classList.toggle("dongle", d);
  const paired=$("#pairedCard"); if(paired) paired.style.display = d ? "" : "none";
  // top-bar buttons: factory-erase is a puck-only op (0x0A); the dongle keeps DFU + (debug) wipe-board
  const fe=$("#factoryErase"); if(fe) fe.style.display = d ? "none" : "";
  // the GitHub "Update from a release" list is puck firmware; a dongle flashes via the local-file drop card
  const rc=$("#relCard"); if(rc) rc.style.display = d ? "none" : "";
  const ua=$("#updAvail"); if(ua && d) ua.classList.add("hide");
  // flashing the dongle is a primary use, so reveal the Firmware-update tab for it even without ?beta=true
  // (which otherwise gates the tab for pucks).
  if(d){ const ut=$('#mainTabs .slot-tab[data-tab="tabUpdate"]'); if(ut) ut.style.display=""; }
  updateFwGate(); // the dongle always supports panel updates
}

// ---- Backup / clone ----
// A backup file is { magic, version, bonds[4], config{} }. bonds come from the 0x09 export (0xA7 frame); the
// config fields come from the status blob the panel already reads. Restoring replays every setting via the
// normal 0x02 setters, then sends the 0x0D bond-import which writes the pairings, applies the mode and reboots.
function hexEnc(arr){ return [...arr].map(x=>x.toString(16).padStart(2,"0")).join(""); }
function hexDec(h){ const a=[]; if(!h) return a; for(let i=0;i+1<h.length;i+=2) a.push(parseInt(h.substr(i,2),16)); return a; }
function buildBackup(p, bp){
  const mask=bp[1], bonds=[];
  for(let s=0;s<4;s++){ const rec=bp.slice(2+s*24, 2+s*24+24);
    bonds.push({slot:s, used:!!((mask>>s)&1), rec:hexEnc(rec)}); }
  const types=[];
  for(let et=0; et<TYPE_DEFS.length; et++){ const q=73+et*9;
    const t={back:[p[q],p[q+1],p[q+2],p[q+3]], qam:p[q+4], abSwap:p[q+5], pad:p[q+6], led:p[q+7], rumble:p[q+8]};
    // pad->stick mapping only exists from protocol v20; omit on older pucks so a restore can't replay defaults
    if(p[0]>=21 && p.length>192) t.padStick=[p[185+et*2],p[186+et*2]];
    types.push(t); }
  const cfg={ mode:p[1], mDiv:p[2], mFric:p[3], persistMode:p[22], chord:[p[23],p[24],p[25]], types };
  // D-pad chords only exist from protocol v18, the Switch gyro mapping from v19; omit the keys entirely on
  // older pucks so a restore doesn't replay defaults over a newer puck's real settings. (Backups from before
  // those settings existed carry rumble/swProRate/swGyro10 keys instead — now-removed settings, ignored.)
  if(p[0]>=18 && p.length>183) cfg.chordD=[p[180],p[181],p[182],p[183]];
  if(p[0]>=19 && p.length>184) cfg.swGyroLegacy=p[184];
  // version 2: include the lizard map so it survives a backup/restore cycle.
  // Guard on !lizardBusy to avoid a race with the one-shot lazy load (lizardExchange sets
  // lizardBusy while the initial 0x11 fetch is in flight); if the load is still pending the
  // map snapshot would be empty, which would incorrectly clear bindings on restore.
  if(lizardLoaded && lizardCapable() && !lizardBusy)
    cfg.lizardMap=lizardBindings.map(b=>({outType:b.outType,od:b.od.slice(),trig:b.trig>>>0,hold:b.hold>>>0}));
  return { magic:"openpuck-backup", version:(cfg.lizardMap?2:1), bonds, config:cfg };
}
function downloadBackup(obj){
  const ts=new Date().toISOString().slice(0,19).replace(/[:T]/g,"-");
  const a=document.createElement("a");
  a.href=URL.createObjectURL(new Blob([JSON.stringify(obj,null,2)],{type:"application/json"}));
  a.download="openpuck-backup-"+ts+".json"; a.click();
}
// let any in-flight poll read settle before we drive the shared endpoints ourselves
async function waitIdle(){ for(let i=0;i<60 && inflight;i++) await new Promise(r=>setTimeout(r,5)); }
async function exportBackup(){
  if(!dev){ log("not connected"); return; }
  backupBusy=true; await waitIdle();
  try{
    // grab a fresh config snapshot, then the bond dump
    await send([0x01]); const cfg=await readBlob(); if(cfg) lastP=cfg;
    if(!lastP){ log("export: no config snapshot yet — wait a second and retry"); return; }
    await send([0x09]);
    let bp=null;
    for(let t=0; t<8 && !bp; t++) bp=await readFrame(0xA7, 2+4*24);
    if(!bp){ log("export: no bond data (firmware too old for 0x09 export — reflash)"); return; }
    const backup=buildBackup(lastP, bp);
    downloadBackup(backup);
    const n=backup.bonds.filter(b=>b.used).length;
    log("exported backup — "+n+" bonded controller slot(s) + all settings");
  } finally { backupBusy=false; }
}
async function importBackup(file){
  if(!dev){ log("not connected"); return; }
  let obj; try{ obj=JSON.parse(await file.text()); }
  catch(e){ log("import: not valid JSON"); return; }
  if(obj.magic!=="openpuck-backup" || !obj.bonds || !obj.config){ log("import: unrecognized backup file"); return; }
  const bondedN=obj.bonds.filter(b=>b.used).length;
  if(!confirm("Restore this backup onto the CONNECTED puck (serial "+(dev.serialNumber||"?")+")?\n\nMake sure this is the TARGET puck, not the one you exported from — the panel only talks to the puck you last connected.\n\nThis OVERWRITES its "+bondedN+" controller pairing(s) and ALL settings, then reboots it.\n\nResult: any controller paired to the original puck will connect to this one with no re-pairing.")) return;
  log("importing onto puck "+(dev.serialNumber||"?"));
  backupBusy=true; await waitIdle();
  // Blocking progress modal (same surface the firmware updater uses): covers the page so nothing else can be
  // driven while the import replays every setting onto the puck, then closes on Done / on error.
  modalOpen("Restore backup");
  const c=obj.config;
  // Pre-count every write so the bar tracks real progress: settings (6 base fields, + 4 D-pad chords and the
  // Switch gyro mapping when the backup carries them), per-type config (9 each), the lizard bindings, 4 bond
  // slots, and the final commit.
  const typeN=Array.isArray(c.types)?Math.min(c.types.length,4):0;
  const lizardN=(Array.isArray(c.lizardMap) && lizardCapable())?Math.min(c.lizardMap.length,LZ_MAX):0;
  const baseN=6 + (Array.isArray(c.chordD)?4:0) + (c.swGyroLegacy!==undefined?1:0);
  const padStickN=Array.isArray(c.types)?c.types.slice(0,typeN).filter(t=>Array.isArray(t.padStick)).length*2:0;
  const total=baseN + typeN*9 + padStickN + lizardN + 4 + 1;
  let step=0, stage="";
  const tick=()=>modalStage(stage, Math.min(99,Math.floor(step*100/total)));
  try{
    // Capability probe: the connected puck MUST run firmware new enough to answer 0x09 with a 0xA7 frame,
    // otherwise it will silently ignore the 0x0D bond-import below. This is the #1 import failure: the panel
    // is connected to a puck still on old firmware. Catch it loudly instead of "nothing happened".
    modalStage("Checking puck firmware", null);
    await send([0x09]);
    let probe=null; for(let t=0;t<8 && !probe;t++) probe=await readFrame(0xA7, 2+4*24);
    if(!probe){
      log("import ABORTED — the connected puck does not support import (old firmware).");
      modalDone(false, "This puck's firmware is too old to import a backup. Flash it with the latest "
        +"OpenPuck build (the same one that produced the export), reconnect, then import again.", "Import failed");
      return;
    }
    // Every step is a write-then-read transaction (same shape as the proven 0x02 sliders): the firmware acks
    // each with a status blob, which we read back to keep the OUT pipe flowing and naturally pace the writes.
    const w=async(bytes)=>{ await send(bytes); await readBlob(); step++; tick(); };
    const sf=async(f,v)=>{ await w([0x02, f, (v|0)&0xff]); };
    // replay every setting (each persists; none reboot). mode is applied by the 0x0E commit below.
    stage="Restoring settings"; tick();
    await sf(1,c.mDiv); await sf(2,c.mFric); await sf(16,c.persistMode?1:0);
    await sf(17,c.chord[0]); await sf(18,c.chord[1]); await sf(19,c.chord[2]);
    // absent in backups taken before the D-pad chords existed (or from a pre-v18 puck) -- skip, don't default
    if(Array.isArray(c.chordD)) for(let i=0;i<4;i++) await sf(CHORD_DPAD_FIELD[i], c.chordD[i]);
    // Switch Pro gyro mapping (v19+ backups only). Backups also carry rumble/swProRate/swGyro10 from the
    // removed settings; those fields no longer exist on the puck, so they are not replayed.
    if(c.swGyroLegacy!==undefined) await sf(38, c.swGyroLegacy?1:0);
    // c.types is absent in some very old backups created before per-type paddle/haptic config
    // was added to the panel export; guard so a missing field never crashes the import mid-flight.
    if(typeN){
      for(let et=0; et<typeN; et++){ const t=c.types[et];
        for(let k=0;k<4;k++) await sf(40+et*9+k, t.back[k]);
        await sf(40+et*9+4, t.qam); await sf(40+et*9+5, t.abSwap?1:0);
        await sf(40+et*9+6, t.pad?1:0); await sf(40+et*9+7, t.led);
        await sf(40+et*9+8, t.rumble!==undefined?t.rumble:1);
        if(Array.isArray(t.padStick)){ await sf(PAD_STICK_FIELD0+et*2, t.padStick[0]); await sf(PAD_STICK_FIELD0+et*2+1, t.padStick[1]); } }
      log("settings replayed ("+(baseN+typeN*9)+" fields)");
    } else { log("settings replayed ("+baseN+" fields — no per-type config in this backup)"); }
    // restore the lizard map if the backup includes it (version 2+) and the puck speaks v16+.
    // pre-lizard-map backups simply lack c.lizardMap; skip silently so they still import cleanly.
    if(lizardN){
      stage="Restoring button map"; tick();
      const map=c.lizardMap.slice(0,LZ_MAX);
      await send([0x13, map.length&0xff]); // begin edit (set count)
      for(let i=0;i<map.length;i++){
        const b=map[i], od=(b.od||[]).slice(0,7); while(od.length<7) od.push(0);
        const t=(b.trig||0)>>>0, h=(b.hold||0)>>>0;
        await send([0x12, i, (b.outType||0)&0xff, ...od.map(x=>(x||0)&0xff),
          t&0xff,(t>>>8)&0xff,(t>>>16)&0xff,(t>>>24)&0xff,
          h&0xff,(h>>>8)&0xff,(h>>>16)&0xff,(h>>>24)&0xff]);
        step++; tick();
      }
      await send([0x14]); // commit + persist to flash
      await readLizard(); // drain the 0xAA echo so the pipe is clean for bond writes
      log("lizard map restored — "+map.length+" bindings");
    }
    // write each bond slot with its own small command [0x0D][slot][used][24-byte rec]
    stage="Restoring controller pairings"; tick();
    let n=0;
    for(let s=0;s<4;s++){
      const b=obj.bonds.find(x=>x.slot===s) || {used:false, rec:""};
      const rec=hexDec(b.rec), r24=new Array(24).fill(0);
      for(let i=0;i<24 && i<rec.length;i++) r24[i]=rec[i];
      const used=(b.used && rec.length===24)?1:0; if(used) n++;
      await w([0x0D, s, used, ...r24]);
    }
    log("wrote "+n+" bond slot(s) — committing + rebooting");
    // commit: persist bonds, apply mode, reboot (no ack — the device reboots)
    stage="Committing + rebooting"; step++; tick();
    await send([0x0E, (c.mode!==undefined?c.mode:0xFF)&0xff]);
    log("import sent — puck is cloning and rebooting. Reconnect after it returns.");
    modalDone(true, "Backup restored — the puck is cloning and rebooting. Reconnect after it returns.");
  } catch(e){
    log("import FAILED — "+e.message);
    modalDone(false, e.message+" — the import stopped partway; reconnect and retry.", "Import failed");
  } finally { backupBusy=false; }
}
async function setField(field,value){
  await send([0x02, field, value&0xff]); const p=await readBlob(); if(p) applyBlob(p);
}
function fmtCapEntry(e,maxMs){
  const hex=e.bytes.map(x=>x.toString(16).padStart(2,"0")).join(" ");
  const t = `-${String(maxMs-e.ms).padStart(6," ")}ms  `;
  if(e.slot===0xFD){ const k=e.bytes[0]; return `${t}════════ ${k===2?"RECONNECT (block+reinit armed)":k===1?"RF LINK UP":"RF LINK DOWN"} ════════`; }
  if(e.slot===0xFC){ return `${t}GET←host rid=${e.rid.toString(16).padStart(2,"0")}  n=${e.nb}:  ${hex}`; } // host feature GET (battery poll lives here)
  if(e.slot===0xFB){ return `${t}→host    rid=${e.rid.toString(16).padStart(2,"0")}  n=${e.nb}:  ${hex}`; } // pushed device→host status (0x43 battery / 0x7B / 0x79)
  const who = (e.slot===0xFE) ? "TX→ctlr " : `if${e.slot}     `;
  return `${t}${who} cmd=${e.rid.toString(16).padStart(2,"0")}  n=${e.nb}:  ${hex}`;
}
function downloadCap(){
  const t=window._lastCap||$("#capOut").textContent||"";
  const a=document.createElement("a");
  a.href=URL.createObjectURL(new Blob([t],{type:"text/plain"}));
  a.download="puck-capture.txt"; a.click();
}
let liveTimer=null, draining=false, capLines=[];
function renderCap(){
  if(!capLines.length){ $("#capOut").textContent="(nothing captured yet)"; window._lastCap=""; return; }
  const maxMs=capLines[capLines.length-1].ms;
  const t=capLines.map(e=>fmtCapEntry(e,maxMs)).join("\n");
  $("#capOut").textContent=t; window._lastCap=t;
}
async function drainTick(){
  if(!dev||draining) return; draining=true;
  let acc=new Uint8Array(0);
  try{
    await send([0x06]);
    let done=false, guard=0;
    while(!done && guard++<400){
      const r=await dev.transferIn(epIn,64);
      if(r.status!=="ok") break;
      const d=new Uint8Array(r.data.buffer);
      const m=new Uint8Array(acc.length+d.length); m.set(acc); m.set(d,acc.length); acc=m;
      let i=0;
      while(i<acc.length){
        if(acc[i]!==0xA6){ i++; continue; }
        if(i+2>acc.length) break;
        const L=acc[i+1]; if(i+2+L>acc.length) break;
        const f=acc.slice(i+2,i+2+L); i+=2+L;
        if(f[0]===0){ done=true; break; }
        if(f[0]===1 && L>=8){
          const ms=((f[1])|(f[2]<<8)|(f[3]<<16)|(f[4]<<24))>>>0;
          capLines.push({ms, slot:f[5], rid:f[6], nb:f[7], bytes:[...f.slice(8,8+f[7])]});
        }
      }
      acc=acc.slice(i);
    }
  }catch(e){ log("drain err: "+e.message); }
  draining=false;
  if(liveTimer){ const el=$("#capOut"); const atBottom=el.scrollTop+el.clientHeight>=el.scrollHeight-4; renderCap(); if(atBottom) el.scrollTop=el.scrollHeight; }
}
// ---- Live wedge reporter (0xA9) ----
// The firmware's SOF callback streams this while loop() is stuck. On boards that wipe retained RAM across the
// watchdog reset (so the flight recorder / hang stage come back blank), this is the only way to see WHERE it
// hung -- captured live, over the panel, in the ~8s before the watchdog fires. Log once per wedge episode.
const WEDGE_STAGE=["webusb","ctrl.task","serial","rfdiag","rflink","haptic","led","usbmount","usbtx"];
function onWedge(stage, stallMs){
  const name=WEDGE_STAGE[stage]||("stage "+stage);
  if(!window._wedgeEp) trailAdd("WEDGED @ "+name+" ("+stallMs+"ms — live 0xA9 report; watchdog reset imminent)");
  if(!window._wedgeEp || stallMs > (window._wedgePeak||0)+500){
    window._wedgeEp=true; window._wedgePeak=stallMs;
    log("🛑 LOOP WEDGED @ "+name+" (stuck "+stallMs+"ms) — this is where it hangs; watchdog reset imminent");
    const el=$("#flightWedge"); if(el) el.innerHTML=' &nbsp;<span class="pill dn">last wedge: '+name+' ('+stallMs+'ms)</span>';
  }
}
// ---- Host-side heartbeat watchdog (hard-wedge detection) ----
// The STALLED pill and the 0xA9 reporter both rely on the puck still SENDING while loop() is wedged -- which
// only holds for soft wedges where the usbd task + SOF IRQ stay alive. The LOCKUP/hardfault-class hangs (#72)
// kill the whole MCU: USB goes silent, transferIn just pends, and the panel would freeze forever showing the
// last state it rendered ("running"). Only the host can see that class of hang, so detect it here: connected
// but no status blob for >2.5s (poll cadence is 600ms) => flip the pill and log the episode. The capture /
// backup / flight paths pause the blob poll legitimately, so they're excluded.
setInterval(()=>{
  if(!dev || !window._lastBlobTs || capturing || backupBusy || flightBusy) return;
  const age=Date.now()-window._lastBlobTs;
  if(age>2500){
    const secs=Math.round(age/1000);
    $("#stLoopState").innerHTML='<span class="pill dn">NO HEARTBEAT '+secs+'s — hard wedge</span>';
    if(!window._hbLostEp){ window._hbLostEp=true;
      log("🛑 heartbeat lost — no status blob for "+secs+"s: hard wedge (USB stack dead too, so the live wedge reporter can't run) — check the flight trail after the reset");
      trailAdd("HEARTBEAT LOST — no status for "+secs+"s (hard wedge: USB silent, whole MCU likely stopped)");
      const el=$("#flightWedge"); if(el) el.innerHTML=' &nbsp;<span class="pill dn">last wedge: hard (no heartbeat)</span>';
    }
  } else if(window._hbLostEp){ window._hbLostEp=false;
    trailAdd("heartbeat back — status blobs resumed without a reset");
  }
}, 1000);
// ---- Flight recorder (0xA8 stream) ----
// The firmware keeps a .noinit ring of the last high-level events (usbd SET/GET, relays, RF up/down, radio
// self-heal, USB mount/suspend, bond flash writes, per-250ms heartbeats) that survives a watchdog reset. On
// 0x10 it streams them: one header (T=2, vitals@wedge + counts), then entries (T=1), then an end (T=0). We
// pump 0x10 (restart) then 0x10 (continue) until the end frame, accumulating across FIFO-sized batches.
let flightBusy=false, flightHdr=null, flightEvents=[];
const FR_EVT=["none","beat","SET","GET","relay","rf-up","rf-DN","HEAL!","mount","SUSPEND","resume","OFF","RINGF","save"];
function frEvtName(e){ return FR_EVT[e]!==undefined?FR_EVT[e]:("evt"+e); }
async function loadFlightTrail(){
  if(!dev||flightBusy) return; flightBusy=true;
  $("#flightSummary").textContent="loading…";
  flightHdr=null; flightEvents=[];
  const STAGE_NAMES=["webusb","ctrl.task","serial","rfdiag","rflink","haptic","led","usbmount","usbtx"];
  try{
    let restart=true, done=false, guard=0, acc=new Uint8Array(0);
    while(!done && guard++<600){
      await send([0x10, restart?1:0]); restart=false;
      const r=await dev.transferIn(epIn,192);
      if(r.status!=="ok") break;
      const d=new Uint8Array(r.data.buffer);
      const m=new Uint8Array(acc.length+d.length); m.set(acc); m.set(d,acc.length); acc=m;
      let i=0;
      while(i<acc.length){
        if(acc[i]!==0xA8){ i++; continue; }
        if(i+2>acc.length) break;
        const L=acc[i+1]; if(i+2+L>acc.length) break;
        const f=acc.slice(i+2,i+2+L); i+=2+L;
        const T=f[0];
        if(T===0){ done=true; break; }
        else if(T===2 && L>=27){
          flightHdr={ count:f[1]|(f[2]<<8), total:f[3]|(f[4]<<8),
            loopPerSec:f[5]|(f[6]<<8), stallMs:f[7], stage:f[8],
            usbdStk:f[9]|(f[10]<<8), loopStk:f[11]|(f[12]<<8),
            heap:((f[13]|(f[14]<<8)|(f[15]<<16)|(f[16]<<24))>>>0),
            pollsps:f[17]|(f[18]<<8), relayps:f[19]|(f[20]<<8),
            crc:f[21], norx:f[22], heal:f[23]|(f[24]<<8), ringF:f[25]|(f[26]<<8) };
        } else if(T===1 && L>=9){
          const dt=((f[1]|(f[2]<<8)|(f[3]<<16)|(f[4]<<24))>>>0);
          flightEvents.push({dt, evt:f[5], stage:f[6], arg:f[7]|(f[8]<<8)});
        }
      }
      acc=acc.slice(i);
    }
  }catch(e){ log("flight err: "+e.message); }
  flightBusy=false;
  renderFlight(STAGE_NAMES);
}
function renderFlight(STAGE_NAMES){
  const h=flightHdr, out=$("#flightOut"), sum=$("#flightSummary"), wedge=$("#flightWedge");
  const stage=s=>(STAGE_NAMES[s]||("st"+s));
  if(!h || (h.count===0 && flightEvents.length===0)){
    sum.textContent="no trail — last boot wasn't a hang, or the recorder didn't survive this board's reset";
    wedge.textContent=""; out.textContent="—"; return;
  }
  const hx=v=>"0x"+v.toString(16).padStart(4,"0");
  sum.textContent="showing "+flightEvents.length+" of "+h.total+" events before the last hang";
  // usbd stack free trending to 0 is the leading overflow suspect -> flag it inline.
  const usbdFlag=(h.usbdStk>0 && h.usbdStk<16)?" ⚠LOW":"";
  wedge.innerHTML=" &nbsp;<b>@wedge:</b> stuck in "+stage(h.stage)+", stall "+h.stallMs+"ms, loop "+h.loopPerSec+"/s"
    +" · usbdStk "+h.usbdStk+"w"+usbdFlag+" · loopStk "+h.loopStk+"w · heap "+h.heap+"B"
    +" · poll "+h.pollsps+" relay "+h.relayps+" crc "+h.crc+" norx "+h.norx+" heal "+h.heal+" ringF "+h.ringF;
  const pad=(s,n)=>(""+s).padEnd(n);
  out.textContent =
    pad("Δms",8)+pad("event",9)+pad("stage",10)+"arg\n"
    +"".padEnd(30,"─")+"\n"
    + flightEvents.map(e=>pad("-"+e.dt,8)+pad(frEvtName(e.evt),9)+pad(stage(e.stage),10)+hx(e.arg)).join("\n");
}
async function startCapture(){
  if(!dev||capturing) return;
  capturing=true; capLines=[];
  $("#capOut").textContent="(dumping ring from boot, then live — press Stop when done)";
  $("#capStart").disabled=true; $("#capStop").disabled=false;
  await send([0x05,1]);
  liveTimer=setInterval(drainTick,100);
}
async function stopCapture(){
  if(liveTimer){ clearInterval(liveTimer); liveTimer=null; }
  await drainTick();
  try{ await send([0x05,0]); }catch(e){}
  capturing=false;
  $("#capStart").disabled=false; $("#capStop").disabled=true;
  renderCap(); log(`capture stopped — ${capLines.length} entries`);
}
async function startPolling(){
  polling=true; await refresh();
  while(polling && dev){
    await new Promise(r=>setTimeout(r,600)); await refresh();
    if(window._autoFlight){ window._autoFlight=false; await loadFlightTrail(); }
  }
}

// ---- lizard map transfers ----
// The status-blob poll and these map transfers share one bulk pipe, so we pause polling
// (lizardBusy) and wait out any in-flight refresh before sending a 0x11/0x14/0x15 that
// expects a 0xAA reply. (Opcodes/frame renumbered from 0x0D../0xA7 on the merge with main,
// which claimed 0x0D-0x10 for bond-import/stability/flight, 0xA7 for bond export and
// 0xA8 for the flight recorder -- 0xAA is the free device->host marker.)
async function lizardExchange(fn){
  lizardBusy=true;
  for(let i=0;i<25 && inflight;i++) await new Promise(r=>setTimeout(r,20));
  try{ return await fn(); }
  catch(e){ log("lizard err: "+e.message); return null; }
  finally{ lizardBusy=false; }
}
// Read one [0xAA][count][count*16] frame, accumulating transferIn packets until complete.
async function readLizard(){
  let acc=new Uint8Array(0);
  for(let guard=0; guard<64; guard++){
    const r=await dev.transferIn(epIn,128);
    if(r.status!=="ok") break;
    const d=new Uint8Array(r.data.buffer);
    const m=new Uint8Array(acc.length+d.length); m.set(acc); m.set(d,acc.length); acc=m;
    let i=0; while(i<acc.length && acc[i]!==0xAA) i++;
    if(i>0) acc=acc.slice(i);
    if(acc.length<2) continue;
    const count=acc[1], total=2+count*16;
    if(acc.length>=total){
      const out=[];
      for(let b=0;b<count;b++){
        const q=2+b*16;
        out.push({
          outType:acc[q],
          od:[...acc.slice(q+1,q+8)],
          trig:((acc[q+8])|(acc[q+9]<<8)|(acc[q+10]<<16)|(acc[q+11]<<24))>>>0,
          hold:((acc[q+12])|(acc[q+13]<<8)|(acc[q+14]<<16)|(acc[q+15]<<24))>>>0,
        });
      }
      return out;
    }
  }
  return null;
}
// Every lizard op sends 0x11..0x15 and then does a BLOCKING readLizard(). If the firmware doesn't implement
// the op (any pre-v16 build) it drops the byte and never replies, and the read hangs the shared endpoint. So
// every entry point bails unless a status blob has proven the puck speaks v16+.
function lizardCapable(){ return !!(lastP && lastP[0]>=16); }
async function loadLizard(){
  if(!lizardCapable()) return;
  await lizardExchange(async()=>{
    await send([0x11]); // dump map
    const b=await readLizard();
    if(b){ lizardBindings=b; renderLizard(); log(`lizard map loaded — ${b.length} bindings`); }
  });
}
async function saveLizard(){
  if(!dev || !lizardCapable()) return;
  // A digital binding (keyboard/mouse/media) with neither a trigger nor a hold fires
  // unconditionally in the firmware (the trigMask==0 guard is skipped) -- it would type/click
  // forever. Drop those rows so a half-finished binding can't brick desktop input.
  const digital=b=>b.outType===LZO.KBD||b.outType===LZO.MBTN||b.outType===LZO.CONSUMER;
  const valid=lizardBindings.filter(b=> b.outType!==LZO.NONE && (!digital(b) || (b.trig>>>0)||(b.hold>>>0)) );
  const dropped=lizardBindings.length-valid.length;
  await lizardExchange(async()=>{
    await send([0x13, valid.length&0xff]); // begin edit (set count)
    for(let i=0;i<valid.length;i++){
      const b=valid[i];
      const od=(b.od||[]).slice(0,7); while(od.length<7) od.push(0);
      const t=b.trig>>>0, h=b.hold>>>0;
      await send([0x12, i, b.outType, ...od.map(x=>x&0xff), // set one binding
        t&0xff,(t>>>8)&0xff,(t>>>16)&0xff,(t>>>24)&0xff,
        h&0xff,(h>>>8)&0xff,(h>>>16)&0xff,(h>>>24)&0xff]);
    }
    await send([0x14]); // commit + persist to flash
    const b=await readLizard(); if(b){ lizardBindings=b; renderLizard(); }
    log(`lizard map saved — ${valid.length} bindings`+(dropped?` (skipped ${dropped} incomplete: no trigger/hold)`:""));
  });
}
async function resetLizard(){
  if(!dev || !lizardCapable()) return;
  if(!confirm("Reset the lizard map to the built-in defaults? Unsaved edits are lost.")) return;
  await lizardExchange(async()=>{
    await send([0x15]); // reset to defaults
    const b=await readLizard(); if(b){ lizardBindings=b; renderLizard(); }
    log("lizard map reset to defaults");
  });
}

// ---- lizard map UI ----
function mkSel(opts, val, onchange){
  const s=document.createElement("select"); s.style.flex="0 1 auto"; s.style.minWidth="0";
  for(const [v,l] of opts){ const o=document.createElement("option"); o.value=v; o.textContent=l; s.appendChild(o); }
  s.value=val; s.addEventListener("change",()=>onchange(+s.value));
  return s;
}
function renderLizard(){
  const host=$("#lizardList"); host.innerHTML="";
  lizardBindings.forEach((b,idx)=>host.appendChild(buildLizardRow(b,idx)));
  $("#lzStatus").textContent = `${lizardBindings.length} / ${LZ_MAX} bindings`;
  $("#lzAdd").disabled = lizardBindings.length>=LZ_MAX;
}
function buildLizardRow(b, idx){
  const row=document.createElement("div");
  row.style.cssText="display:flex;align-items:center;gap:8px;flex-wrap:wrap;background:#0e1017;border:1px solid #232a3a;border-radius:8px;padding:8px 10px;margin:8px 0";
  const analog = (b.outType===LZO.AXIS || b.outType===LZO.SCROLL);

  // Trigger (When) + Hold — meaningful only for digital outputs
  if(!analog){
    const when=document.createElement("span"); when.className="note"; when.textContent="When"; when.style.flex="0 0 auto"; row.appendChild(when);
    row.appendChild(mkSel([[0,"— pick input —"],...LZ_BTNS], b.trig, v=>{ b.trig=v>>>0; }));
    const plus=document.createElement("span"); plus.className="note"; plus.textContent="+ hold"; plus.style.flex="0 0 auto"; row.appendChild(plus);
    row.appendChild(mkSel([[0,"(none)"],...LZ_BTNS], b.hold, v=>{ b.hold=v>>>0; }));
  } else {
    const lab=document.createElement("span"); lab.className="note"; lab.textContent="Analog source"; lab.style.flex="0 0 auto"; row.appendChild(lab);
  }

  // Arrow + output type
  const arrow=document.createElement("span"); arrow.textContent="→"; arrow.style.color="var(--mut)"; row.appendChild(arrow);
  row.appendChild(mkSel(Object.entries(LZ_OUT_LABELS).map(([v,l])=>[+v,l]), b.outType, v=>{
    b.outType=v;
    // reset payload to sane defaults for the new type
    if(v===LZO.AXIS){ b.od=[0,0,0,0,0,0,0]; }
    else if(v===LZO.SCROLL){ b.od=[0,0,0,0,0,0,0]; }
    else if(v===LZO.MBTN){ b.od=[1,0,0,0,0,0,0]; }
    else if(v===LZO.CONSUMER){ b.od=[1,0,0,0,0,0,0]; }
    else if(v===LZO.KBD){ b.od=[0,0,0,0,0,0,0]; }
    renderLizard();
  }));

  // Output-specific controls
  if(b.outType===LZO.KBD){
    for(const [bit,name] of LZ_MODS){
      const w=document.createElement("label"); w.style.cssText="flex:0 0 auto;display:flex;align-items:center;gap:3px;color:var(--fg)";
      const cb=document.createElement("input"); cb.type="checkbox"; cb.checked=!!(b.od[0]&bit);
      cb.addEventListener("change",()=>{ b.od[0]=cb.checked?(b.od[0]|bit):(b.od[0]&~bit); });
      w.appendChild(cb); w.appendChild(document.createTextNode(name)); row.appendChild(w);
    }
    row.appendChild(mkSel(LZ_KEYS, b.od[1]||0, v=>{ b.od[1]=v; for(let k=2;k<7;k++) b.od[k]=0; }));
  } else if(b.outType===LZO.MBTN){
    row.appendChild(mkSel(LZ_MBTNS, b.od[0]||1, v=>{ b.od[0]=v; }));
  } else if(b.outType===LZO.AXIS){
    row.appendChild(mkSel(LZ_AXIS_SRC, b.od[0]||0, v=>{ b.od[0]=v; renderLizard(); }));
    if((b.od[0]||0)===2){ // gyro: activation selector
      const g=document.createElement("span"); g.className="note"; g.textContent="when"; g.style.flex="0 0 auto"; row.appendChild(g);
      row.appendChild(mkSel(LZ_GYRO_ACT, b.od[1]||0, v=>{ b.od[1]=v; }));
    }
  } else if(b.outType===LZO.SCROLL){
    const s=document.createElement("span"); s.className="note"; s.textContent="Left trackpad → scroll"; row.appendChild(s);
  } else if(b.outType===LZO.CONSUMER){
    row.appendChild(mkSel(LZ_CONSUMER, b.od[0]||1, v=>{ b.od[0]=v; }));
  }

  // delete
  const del=document.createElement("button"); del.textContent="✕"; del.title="Delete binding";
  del.style.cssText="margin-left:auto;flex:0 0 auto;padding:4px 10px";
  del.onclick=()=>{ lizardBindings.splice(idx,1); renderLizard(); };
  row.appendChild(del);
  return row;
}

// UI wiring
$("#connectBtn").onclick=connect;
// ---- Firmware update: UF2 file -> staged flash over WebUSB, applied on reboot ----
// Flow: parse the .uf2 into the raw app image, stream it over THIS WebUSB connection (ops 0x20/0x21/0x22,
// strict ping-pong on the firmware's 0xAB acks) into spare flash high in the puck's app region, let the
// firmware CRC32-verify what actually landed and commit the one-page "apply on reboot" record, then send a
// plain reboot (0x23) — the puck copies staged->app from RAM on the way up and re-enumerates on the new
// firmware, where this panel auto-reconnects. Corruption safety (matches fw_update.h in the firmware):
//   - nothing is armed until the staged bytes verify IN FLASH, so any failure/disconnect/power-cut during
//     the transfer leaves the current firmware completely untouched;
//   - the boot-time apply orders its writes so an interruption leaves the board app-less (UF2 bootloader
//     mass-storage recovery), never a crash-looping half image.
const UF2_MAGIC0=0x0A324655, UF2_MAGIC1=0x9E5D5157, UF2_MAGIC_END=0x0AB16F30, UF2_FAMILY=0xADA52840;
const APP_BASE=0x26000, FWUP_MAX_IMG=0x60000; // nRF52840 app base; staging cap (fw_update.h FWUP_MAX_IMG)
// Extract the contiguous application image from a .uf2 (gaps filled with 0xFF, length padded to a word).
// Throws on anything that is not an nRF52840 app-region UF2 — the firmware re-checks everything, but a bad
// file should fail at pick time, not after a reboot.
function uf2ToImage(buf){
  if(!buf.byteLength || buf.byteLength%512) throw new Error("not a UF2 (size is not a multiple of 512)");
  const dv=new DataView(buf), blocks=[]; let lo=Infinity, hi=0;
  for(let off=0; off<buf.byteLength; off+=512){
    if(dv.getUint32(off,true)!==UF2_MAGIC0 || dv.getUint32(off+4,true)!==UF2_MAGIC1 || dv.getUint32(off+508,true)!==UF2_MAGIC_END)
      throw new Error("bad UF2 block magic at offset "+off);
    const flags=dv.getUint32(off+8,true), addr=dv.getUint32(off+12,true), len=dv.getUint32(off+16,true);
    if(flags&0x00000001) continue; // NOT_MAIN_FLASH
    if((flags&0x00002000) && dv.getUint32(off+28,true)!==UF2_FAMILY)
      throw new Error("UF2 family 0x"+dv.getUint32(off+28,true).toString(16)+" is not nRF52840 (0xada52840)");
    if(len<1 || len>476) throw new Error("bad UF2 payload size "+len);
    blocks.push({addr,len,off}); lo=Math.min(lo,addr); hi=Math.max(hi,addr+len);
  }
  if(!blocks.length) throw new Error("UF2 contains no flash data");
  if(lo!==APP_BASE) throw new Error("image base 0x"+lo.toString(16)+" is not the app region (0x26000) — not an OpenPuck app UF2");
  if(hi-lo>FWUP_MAX_IMG) throw new Error("image is "+Math.round((hi-lo)/1024)+" KiB — over the 384 KiB staged-update cap; flash it via UF2 DFU + drag-and-drop");
  const img=new Uint8Array((hi-lo+3)&~3).fill(0xFF); // firmware stages whole words
  for(const b of blocks) img.set(new Uint8Array(buf,b.off+32,b.len), b.addr-lo);
  return img;
}
// CRC32 (IEEE, reflected, init/xorout 0xFFFFFFFF) — must match crc32Step/crc32Flash in fw_update.cpp
function crc32(u8){
  let c=0xFFFFFFFF;
  for(let i=0;i<u8.length;i++){
    c^=u8[i];
    for(let k=0;k<8;k++) c=(c>>>1)^(0xEDB88320&-(c&1));
  }
  return (~c)>>>0;
}
const u32le=v=>[v&0xFF,(v>>>8)&0xFF,(v>>>16)&0xFF,(v>>>24)&0xFF];
const dfuSleep=ms=>new Promise(r=>setTimeout(r,ms));
// Firmware built from this branch onward embeds this tag (fw_update.cpp FWUP_TAG). An image WITHOUT it
// still flashes fine — but the puck it leaves behind can't do panel updates, so we warn before the
// lock-yourself-out-to-drag-and-drop move (all releases up to 0.9.6 predate panel updates).
function imagePanelUpdatable(image){
  return new TextDecoder("latin1").decode(image).includes("OPK-FWUP-v1");
}
const FWUP_ERR=["ok","command out of sequence","image too big for this puck's free flash","offset resync",
  "staged bytes failed CRC verify","staged image has no valid vector table"];
// Ack reader ([0xAB][5][status][nextOff u32 LE]). One persistent transferIn at a time: a wait that times out
// leaves its read PENDING for the next wait — issuing a second concurrent read would silently eat the data
// the first one eventually resolves with. If one read carries several acks (a retried command double-acks),
// only the LAST — the firmware's newest state — is returned, so stale acks collapse instead of accumulating.
let fwupRead=null;
async function fwupAckWait(timeoutMs){
  const deadline=Date.now()+timeoutMs;
  for(;;){
    const remain=deadline-Date.now();
    if(remain<=0) return null;
    if(!fwupRead) fwupRead=dev.transferIn(epIn, 64);
    const r=await Promise.race([fwupRead, dfuSleep(remain).then(()=>"timeout")]);
    if(r==="timeout") return null;
    fwupRead=null;
    if(r.status!=="ok") continue;
    const d=new Uint8Array(r.data.buffer, r.data.byteOffset, r.data.byteLength);
    let ack=null;
    for(let i=0;i+6<d.length;i++)
      if(d[i]===0xAB && d[i+1]===5)
        ack={status:d[i+2], off:(d[i+3]|(d[i+4]<<8)|(d[i+5]<<16)|(d[i+6]<<24))>>>0};
    if(ack) return ack;
  }
}
const fwupSend=cmd=>dev.transferOut(epOut, new Uint8Array(cmd));
// send a control op (begin/end/abort — all idempotent on the firmware side) and wait; resend on timeout
async function fwupCtl(cmd, timeoutMs, label){
  for(let t=0;t<3;t++){
    await fwupSend(cmd);
    const a=await fwupAckWait(timeoutMs);
    if(a) return a;
  }
  throw new Error("no response to "+label);
}
async function fwupRun(image){
  const kb=Math.round(image.length/1024);
  fwupRead=null; // never reuse a read pending against a previous session/device
  // drain anything stale on the IN pipe (leftover ack from an aborted run, a late status blob)
  while(await fwupAckWait(400)!==null){}
  log("firmware update: staging "+kb+" KiB into the puck's spare flash — input may stutter briefly during page erases");
  let a=await fwupCtl([0x20,...u32le(image.length),...u32le(crc32(image))],4000,"begin");
  if(a.status) throw new Error("begin rejected: "+(FWUP_ERR[a.status]||("code "+a.status)));
  // Chunk loop: send one chunk, then read acks until one shows progress. A TIMEOUT resends (covers a truly
  // lost command); a stale no-progress ack (the surplus twin of a resent chunk) is read past WITHOUT
  // resending, so retries can't snowball. The ack's nextOff is authoritative — the firmware skips duplicate
  // chunks and re-acks, flash words are never written twice — so every path resynchronizes here.
  let off=0, sends=0, lastShown=-1;
  const maxSends=Math.ceil(image.length/128)*2+64;
  while(off<image.length){
    const len=Math.min(128,image.length-off);
    await fwupSend([0x21,...u32le(off),len,...image.subarray(off,off+len)]);
    if(++sends>maxSends) throw new Error("transfer not converging at offset "+off);
    for(let reads=0;reads<8;reads++){
      a=await fwupAckWait(2500);
      if(a===null) break; // timeout: resend this chunk
      if(a.status===3){ off=a.off; break; } // firmware says where it wants us — resend from there
      if(a.status!==0) throw new Error("chunk rejected at offset "+off+": "+(FWUP_ERR[a.status]||("code "+a.status)));
      if(a.off>off){ off=a.off; break; } // progress
      // else: stale ack — keep reading, the real one is behind it
    }
    const pct=Math.floor(off*50/image.length)*2;
    if(pct!==lastShown){ lastShown=pct; modalStage("Sending to the puck", pct); }
  }
  modalStage("Verifying on the puck", null); // firmware CRC32s the staged flash, then commits the record
  a=await fwupCtl([0x22],8000,"verify+commit");
  if(a.status) throw new Error("verify+commit rejected: "+(FWUP_ERR[a.status]||("code "+a.status)));
  log("image staged + CRC-verified on the puck — update armed");
  modalStage("Rebooting", null);
  try{ await fwupSend([0x23]); }catch(e){} // device drops mid-call; that's the point
  log("rebooting to apply: the puck goes dark ~5 s while the new firmware is written, then re-enumerates — the panel reconnects itself");
}
// ---- blocking modal: the ONLY interactive surface while an update runs (it covers everything else) ----
function modalStage(txt,pct){
  const f=$("#updFill"), p=$("#updPct");
  $("#updStage").textContent=txt;
  f.classList.remove("bad");
  if(pct==null){ f.classList.add("pulse"); f.style.width="100%"; p.textContent=""; }
  else{ f.classList.remove("pulse"); f.style.width=pct+"%"; p.textContent=pct+"%"; }
}
function modalOpen(title){
  $("#updTitle").textContent=title;
  $("#updDetail").textContent="";
  $("#updClose").classList.add("hide"); // no way out mid-update: closing wouldn't stop the puck anyway
  $("#updModal").classList.remove("hide");
  modalStage("Preparing…",null);
}
function modalDone(ok,msg,failTitle){
  const f=$("#updFill");
  f.classList.remove("pulse");
  f.style.width="100%";
  f.classList.toggle("bad",!ok);
  $("#updStage").textContent = ok ? "Done" : (failTitle||"Update failed");
  $("#updPct").textContent="";
  $("#updDetail").textContent=msg;
  $("#updClose").classList.remove("hide");
}
$("#updClose").onclick=()=>$("#updModal").classList.add("hide");

function blobBuildId(p){
  if(!p) return "";
  let s=""; for(let i=39;i<51 && i<p.length && p[i];i++) s+=String.fromCharCode(p[i]);
  return s;
}
// Update-available notice (topbar): shown when the connected puck reports a release-shaped build (x.y.z)
// older than the newest non-prerelease on GitHub. Dev builds report a git hash, which doesn't parse — no
// nagging about "updates" for firmware newer than any release. Click = jump to the Firmware update tab.
function verTriple(s){
  const m=/^(\d+)\.(\d+)\.(\d+)/.exec(s||"");
  return m ? [+m[1],+m[2],+m[3]] : null;
}
function checkUpdateNotice(){
  const el=$("#updAvail");
  if(!BETA_UI){ el.classList.add("hide"); return; }
  const inst=verTriple(blobBuildId(lastP));
  const rel=(relCache||[]).find(r=>!r.prerelease && relAsset(r,false));
  const latest=rel ? verTriple(rel.tag_name) : null;
  const newer = !!(dev && inst && latest &&
    (latest[0]>inst[0] || (latest[0]===inst[0] &&
     (latest[1]>inst[1] || (latest[1]===inst[1] && latest[2]>inst[2])))));
  el.classList.toggle("hide", !newer);
  if(newer) el.textContent="⬆ update "+rel.tag_name+" available";
}
$("#updAvail").onclick=()=>{ document.querySelector('#mainTabs .slot-tab[data-tab="tabUpdate"]').click(); };

// Firmware-tab gate: the connected puck must speak status v15+ (the 0x20..0x24 update ops) for ANY of the
// update tab to be usable. Too old => banner explains + both cards go inert until a capable build is flashed
// the manual way once.
function updateFwGate(){
  const ok = isDongle || !!(lastP && lastP[0]>=15);
  $("#updGate").classList.toggle("hide", ok);
  if(!ok) $("#updGateMsg").textContent =
    "This puck is running "+(blobBuildId(lastP)||"an unknown build")+" (status v"+(lastP?lastP[0]:"?")
    +"), which predates panel updates (needs v15+), so updating from this page is disabled. One manual flash "
    +"gets you back: click “UF2 DFU” in the top bar, then drag a panel-update-capable .uf2 onto the UF2BOOT "
    +"drive it mounts. Every update after that happens right here.";
  for(const c of document.querySelectorAll(".fwupcard")) c.classList.toggle("gated", !ok);
}
function updateVersionUI(){
  const build=blobBuildId(lastP), proto=lastP ? lastP[0] : 0;
  const dirty=lastP && lastP.length>38 ? lastP[38] : 0;
  $("#stVersionBuild").innerHTML = build
    ? (build + (dirty ? ' <span class="pill dn">dirty</span>' : ' <span class="pill up">clean</span>'))
    : "—";
  $("#stVersionProto").textContent = proto ? ("v"+proto) : "—";
  $("#stVersionUpdate").textContent = proto >= 15 ? "supported" : (proto ? "manual UF2 only" : "—");
}
// after the apply-reboot: resolved once the puck is back.
// Returns true if the panel auto-reconnected and received a fresh status blob (desktop), "appeared"
// if the puck is visible in getDevices() but openDevice() couldn't be called without a user gesture
// (Android Chrome), or false on timeout.
async function waitReconnect(t0,ms){
  const deadline=Date.now()+ms;
  // seenGone: the puck must disconnect before we can declare it "back".  It is often already gone
  // by the time this runs (fwupRun sent the reboot command and returned), so initialise from dev.
  let seenGone=!dev;
  while(Date.now()<deadline){
    if(dev && window._lastBlobTs>t0) return true;
    if(!dev) seenGone=true;
    if(seenGone && !dev){
      try{
        const ds=await navigator.usb.getDevices();
        if(ds.some(x=>USB_FILTERS.some(f=>f.vendorId===x.vendorId))) return "appeared";
      }catch(_e){}
    }
    await dfuSleep(400);
  }
  return false;
}
// One update end-to-end: pre-flight checks, confirm, modal up, image acquired (may download), streamed,
// applied, reconnect observed. getImage runs INSIDE the modal so release downloads show progress there.
async function runUpdate(title, confirmText, getImage){
  if(dfuBusy) return;
  if(!dev){ log("connect to the device first — the update travels over this WebUSB connection"); return; }
  // The dongle always speaks the update ops; only gate a PUCK on its status-blob version.
  if(!isDongle && (!lastP || lastP[0]<15)){
    log("this puck's firmware ("+(blobBuildId(lastP)||"?")+", status v"+(lastP?lastP[0]:"?")+") predates panel updates (needs v15+) — flash a panel-update-capable build once via UF2 DFU + drag-and-drop, then this works");
    return;
  }
  if(!confirm(confirmText)) return;
  dfuBusy=true; updateUf2UI(); modalOpen(title);
  polling=false;        // the IN pipe belongs to the update acks now
  await dfuSleep(800);  // let an in-flight status poll finish its read first
  const t0=Date.now(), oldBuild=blobBuildId(lastP);
  try{
    const image=await getImage();
    if(!imagePanelUpdatable(image) &&
       !confirm("⚠ DOWNGRADE WARNING\n\nThis image predates panel updates (releases up to 0.9.6 do). It will "
        +"flash fine, but the puck it leaves behind CANNOT be updated from this panel — getting off it again "
        +"means UF2 DFU + drag-and-drop.\n\nFlash it anyway?"))
      throw new Error("cancelled — the selected image doesn't support panel updates");
    await fwupRun(image);
    modalStage("Applying on the puck",null);
    $("#updDetail").textContent="the puck goes dark ~5 s while the new firmware is written, then re-enumerates";
    const result=await waitReconnect(t0,40000);
    if(result===true){
      const nb=blobBuildId(lastP);
      modalDone(true,"Update applied — the puck is back and running build "+(nb||"?")+(oldBuild&&nb!==oldBuild?" (was "+oldBuild+")":""));
    }else if(result==="appeared"){
      // The puck re-enumerated but the browser couldn't auto-open it (requires a user gesture on
      // Android Chrome).  The update landed — the user just needs to tap Connect.
      modalDone(true,"Update applied — the puck is back. Tap Connect to reconnect.");
    }else{
      modalDone(false,"The update was sent and armed, but the puck didn't reconnect within 40 s. Unplug/replug it. "
        +"If it mounts as a UF2BOOT drive, drag the .uf2 onto the drive to recover — the bootloader is intact.");
    }
  }catch(e){
    log("firmware update FAILED: "+e.message);
    modalDone(false,e.message+" — nothing was applied; the running firmware is untouched.");
    try{ await fwupSend([0x24]); }catch(_e){} // best-effort disarm
    if(dev) startPolling();
  }finally{
    dfuBusy=false; updateUf2UI();
  }
}

// ---- local-file source: drag-and-drop or file picker ----
async function pickUf2(f){
  try{
    const image=uf2ToImage(await f.arrayBuffer());
    selectedUf2={name:f.name, image, updatable:imagePanelUpdatable(image)};
    log("UF2 ready: "+f.name+" — app image "+Math.round(image.length/1024)+" KiB, CRC32 0x"+crc32(image).toString(16).padStart(8,"0"));
  }catch(err){
    selectedUf2=null;
    log("UF2 rejected: "+err.message);
  }
  updateUf2UI();
}
$("#uf2File").onchange=async(e)=>{
  const f=e.target.files && e.target.files[0];
  e.target.value=""; // allow re-picking the same filename after a rebuild
  if(f) await pickUf2(f);
};
// a file dropped anywhere the dropzone isn't listening (e.g. while gated) must not navigate the page to it
window.addEventListener("dragover",e=>e.preventDefault());
window.addEventListener("drop",e=>e.preventDefault());
{
  const dz=$("#uf2Drop");
  dz.onclick=()=>$("#uf2File").click();
  dz.ondragover=e=>{ e.preventDefault(); dz.classList.add("drag"); };
  dz.ondragleave=()=>dz.classList.remove("drag");
  dz.ondrop=async e=>{
    e.preventDefault(); dz.classList.remove("drag");
    const f=e.dataTransfer.files && e.dataTransfer.files[0];
    if(f) await pickUf2(f);
  };
}
$("#uf2Flash").onclick=()=>{
  if(!selectedUf2) return;
  runUpdate("Flashing "+selectedUf2.name,
    "Flash "+selectedUf2.name+" ("+Math.round(selectedUf2.image.length/1024)+" KiB)?\n\n"
    +"The image is sent over WebUSB into spare flash (~15 s), verified on the puck, and applied on an automatic "
    +"reboot (~5 s dark). Nothing is armed until it verifies, so a failed or interrupted transfer leaves the "
    +"current firmware untouched. Worst case (power cut during the apply itself) the puck comes back as the "
    +"UF2BOOT drive for drag-and-drop recovery — it cannot end up half-flashed.",
    async()=>selectedUf2.image);
};

// ---- release source: list from the GitHub API, binaries from the CORS-reachable firmware mirror ----
// api.github.com sends Access-Control-Allow-Origin:* but release-asset downloads redirect to a CDN that does
// NOT, so the release workflow mirrors every OpenPuck .uf2 onto the repo's orphan `firmware` branch and the
// panel fetches it from raw.githubusercontent.com (which is CORS-clean). Fallbacks: the API asset endpoint
// (in case GitHub ever fixes its CDN), then a plain new-tab download + the local-file card.
const REL_REPO="safijari/openpuck";
let relCache=null;
// firmware-mirror manifest: asset name -> {panelUpdate}. Written by the release workflow, which scans each
// .uf2 for the FWUP_TAG capability string. null = manifest unreachable (then releases just go unbadged; the
// byte-scan warning at flash time still catches an unsupported image).
let relManifest=null;
// tri-state: true = a puck running this release can be panel-updated, false = it cannot (drag-and-drop only
// to get off it), null = unknown (no manifest)
function relPanelUpdatable(rel){
  if(!relManifest) return null;
  const known=[relAsset(rel,false),relAsset(rel,true)].filter(a=>a && relManifest[a.name]);
  if(!known.length) return null; // not mirrored (yet) — unknown, don't badge (mirror step lags a fresh release by ~a minute)
  return known.some(a=>relManifest[a.name].panelUpdate);
}
async function downloadAsset(asset){
  modalStage("Downloading "+asset.name,0);
  let resp=null;
  try{
    const r=await fetch("https://raw.githubusercontent.com/"+REL_REPO+"/firmware/"+asset.name,{cache:"no-store"});
    if(r.ok) resp=r;
  }catch(e){}
  if(!resp){
    try{
      const r=await fetch(asset.url,{headers:{Accept:"application/octet-stream"}});
      if(r.ok) resp=r;
    }catch(e){}
  }
  if(!resp){
    window.open(asset.browser_download_url,"_blank","noopener");
    throw new Error(asset.name+" isn't on the firmware mirror yet and GitHub's asset CDN blocks in-page downloads. "
      +"It's downloading in a new tab instead — drop the file on the local-file card above.");
  }
  const total=+resp.headers.get("content-length") || asset.size || 0;
  const reader=resp.body.getReader(), parts=[]; let got=0;
  for(;;){
    const {done,value}=await reader.read();
    if(done) break;
    parts.push(value); got+=value.length;
    if(total) modalStage("Downloading "+asset.name, Math.min(99,Math.floor(got*100/total)));
  }
  const buf=new Uint8Array(got); let o=0;
  for(const p of parts){ buf.set(p,o); o+=p.length; }
  return uf2ToImage(buf.buffer);
}
function relAsset(rel,factory){
  const suffix=factory ? "factory-reset" : "standard";
  return rel.assets.find(a=>a.name==="OpenPuck-"+rel.tag_name+"-"+suffix+".uf2")
      || rel.assets.find(a=>new RegExp("^OpenPuck-.*-"+suffix+"\\.uf2$").test(a.name)) || null;
}
function flashRelease(rel,factory){
  const asset=relAsset(rel,factory);
  if(!asset){ log("release "+rel.tag_name+" has no "+(factory?"factory-reset":"standard")+" .uf2 asset"); return; }
  const kb=Math.round((asset.size||0)/1024);
  runUpdate("Updating to "+rel.tag_name+(factory?" (factory reset)":""),
    "Update the puck to "+rel.tag_name+(factory
      ? " using the FACTORY RESET build?\n\nOn its first boot it wipes ALL settings and the controller pairing — you must re-pair the controller afterwards."
      : "?")
    +"\n\n"+asset.name+" ("+kb+" KiB) is downloaded, sent over WebUSB, verified on the puck, and applied on an "
    +"automatic reboot. A failed or interrupted transfer leaves the current firmware untouched.",
    ()=>downloadAsset(asset));
}
function renderReleases(){
  const list=$("#relList");
  list.textContent="";
  let shown=0;
  for(const rel of relCache){
    const std=relAsset(rel,false), fac=relAsset(rel,true);
    if(!std && !fac) continue;
    shown++;
    const row=document.createElement("div"); row.className="rel-row";
    const ver=document.createElement("span"); ver.className="ver"; ver.textContent=rel.tag_name;
    const date=document.createElement("span"); date.className="date";
    date.textContent=(rel.published_at||"").slice(0,10)+(rel.prerelease?" · pre":"");
    const name=document.createElement("span"); name.className="grow note"; name.style.margin="0";
    name.textContent=rel.name && rel.name!==rel.tag_name ? rel.name : "";
    const lab=document.createElement("label");
    const cb=document.createElement("input"); cb.type="checkbox"; cb.disabled=!fac;
    lab.appendChild(cb); lab.appendChild(document.createTextNode("factory reset"));
    lab.title=fac ? "Flash the -factory-reset build: wipes settings + pairing once on first boot"
                  : "this release has no factory-reset build";
    const btn=document.createElement("button"); btn.textContent="Flash "+rel.tag_name;
    btn.onclick=()=>flashRelease(rel,cb.checked);
    row.append(ver,date,name);
    if(relPanelUpdatable(rel)===false){
      const pill=document.createElement("span"); pill.className="pill dn";
      pill.textContent="no panel updates";
      pill.title="This build predates panel-update support: it flashes fine from here, but a puck running it "
        +"can only be updated again via UF2 DFU + drag-and-drop.";
      row.appendChild(pill);
    }
    row.append(lab,btn);
    list.appendChild(row);
  }
  if(!shown) list.textContent="no releases with OpenPuck .uf2 assets found";
}
async function loadReleases(force){
  if(relCache && !force) return;
  const list=$("#relList");
  list.textContent="loading…";
  try{
    const [r,mr]=await Promise.all([
      fetch("https://api.github.com/repos/"+REL_REPO+"/releases?per_page=15",
            {headers:{Accept:"application/vnd.github+json"}}),
      fetch("https://raw.githubusercontent.com/"+REL_REPO+"/firmware/manifest.json",{cache:"no-store"})
        .catch(()=>null),
    ]);
    if(!r.ok) throw new Error("GitHub API "+r.status);
    try{ relManifest=(mr && mr.ok) ? await mr.json() : null; }catch(e){ relManifest=null; }
    relCache=(await r.json()).filter(x=>!x.draft);
    renderReleases();
    checkUpdateNotice(); // the connect-time blob usually lands before this fetch does
  }catch(e){
    list.innerHTML='could not load releases ('+e.message.replace(/</g,"&lt;")
      +') — <a href="https://github.com/'+REL_REPO+'/releases" target="_blank" rel="noopener" style="color:var(--acc2)">open the releases page</a> and use the local-file card';
    relCache=null;
  }
}
$("#relRefresh").onclick=()=>loadReleases(true);

// ---- top-level tabs ----
for(const t of document.querySelectorAll("#mainTabs .slot-tab")){
  t.onclick=async()=>{
    if(t.dataset.tab==="tabUpdate" && !BETA_UI){
      const ok=await betaPopup({
        title:"Firmware update is beta",
        body:["Firmware update is still being tested and may not work correctly.",
          "A bad image or interrupted recovery path can leave you needing UF2 DFU to recover.",
          "Enable beta mode before using this feature."],
        okText:"Enable beta"
      });
      if(ok){
        const u=new URL(location.href);
        u.searchParams.set("beta","true");
        location.href=u.toString();
      }
      return;
    }
    for(const x of document.querySelectorAll("#mainTabs .slot-tab")) x.classList.toggle("active",x===t);
    $("#tabMain").classList.toggle("hide", t.dataset.tab!=="tabMain");
    $("#tabUpdate").classList.toggle("hide", t.dataset.tab!=="tabUpdate");
    if(t.dataset.tab==="tabUpdate") loadReleases(false); // lazy: first visit fetches the list
  };
}
$("#backupExport").onclick=exportBackup;
$("#backupImport").onclick=()=>$("#backupFile").click();
$("#backupFile").onchange=async(e)=>{ const f=e.target.files[0]; if(f) await importBackup(f); e.target.value=""; };
$("#capDl").onclick=downloadCap;
$("#capStart").onclick=startCapture;
$("#capStop").onclick=stopCapture;
$("#lzAdd").onclick=()=>{ if(lizardBindings.length<LZ_MAX){ lizardBindings.push({outType:LZO.KBD,od:[0,0,0,0,0,0,0],trig:0,hold:0}); renderLizard(); } };
$("#lzSave").onclick=saveLizard;
$("#lzReload").onclick=loadLizard;
$("#lzReset").onclick=resetLizard;
$("#stabBtn").onclick=async()=>{
  if(!dev){ log("connect first"); return; }
  stabArmed=!stabArmed;
  if(stabArmed){ await send([0x0F,1]); stabStart=Date.now(); stabLastRun=null; log("stability test STARTED — buzzing every 10s, timing uptime until reset"); trailAdd("stability test started (buzz every 10s)"); }
  else { await send([0x0F,0]); stabStart=0; log("stability test stopped"); trailAdd("stability test stopped"); }
  updateStabUI();
};
$("#hangClear").onclick=()=>{ hangLog=[]; renderHangLog(); };
$("#flightLoad").onclick=loadFlightTrail;
$("#hangCsv").onclick=()=>{
  const rows=[["time","uptime_s","reason","stage","pc","lr","usbd_free_words"]].concat(
    hangLog.map(e=>[e.time, e.uptime!=null?Math.round(e.uptime):"", e.reason, e.stage, e.pc, e.lr, e.usbd]));
  const csv=rows.map(r=>r.map(x=>'"'+String(x).replace(/"/g,'""')+'"').join(",")).join("\n");
  const a=document.createElement("a"); a.href=URL.createObjectURL(new Blob([csv],{type:"text/csv"}));
  a.download="openpuck-hanglog.csv"; a.click();
};
$("#hapClear").onclick=async()=>{ if(dev){ await send([0x07]); log("haptic re-init sent (clear stuck buzz)"); } };
$("#ctlrOff").onclick=async()=>{ if(dev){ await send([0x08]); log("controller power-off attempt sent — watch link status");
  trailAdd("power-off sent to controller (panel button) — stress action, correlate with what follows"); } };
$("#debugCdc").onclick=async()=>{
  if(!dev){ log("not connected"); return; }
  if(!confirm("Reboot with the CDC serial console enabled?\n\nThe puck reboots and comes back with a serial port (115200 baud) instead of WebUSB — this panel will disconnect and NOT reconnect until the next reboot.\n\nConnect a serial monitor to capture logs, then replug (or reboot) to return to normal WebUSB mode. The debug console auto-reverts after one boot.")) return;
  await send([0x02,20,1]); log("debug-CDC reboot sent — device disconnecting; reconnect a serial monitor at 115200 baud");
};
$("#dfuSerial").onclick=async()=>{
  if(!dev){ log("not connected"); return; }
  if(!confirm("Reboot into serial DFU?\n\nThe puck will disconnect immediately. Flash with adafruit-nrfutil, then replug.")) return;
  await send([0x0B]); log("serial DFU reboot sent — device disconnecting");
};
$("#dfuUf2").onclick=async()=>{
  if(!dev){ log("not connected"); return; }
  if(!confirm("Reboot into UF2 bootloader?\n\nThe puck will disconnect and mount as a USB drive. Drag the .uf2 file onto it to flash.")) return;
  await send([0x0C]); log("UF2 bootloader reboot sent — device disconnecting");
};
$("#factoryErase").onclick=async()=>{
  if(!dev){ log("not connected"); return; }
  if(!confirm("Factory erase?\n\nThis wipes ALL persistent storage on the copycat:\n  • the paired-controller bond (you'll have to re-pair)\n  • every saved setting (mode, chords, back paddles, sensitivity)\n\nThe copycat reboots to factory defaults. This CANNOT be undone.")) return;
  if(!confirm("Are you absolutely sure?\n\nThere is no recovery. The controller bond and all settings will be gone.")) return;
  const typed=prompt('Final confirmation — type  ERASE  (all caps) to wipe everything:');
  if(typed!=="ERASE"){ log("factory erase cancelled (confirmation text did not match)"); return; }
  await send([0x0A,0x45,0x52,0x53]);
  log("FACTORY ERASE sent — copycat is reformatting and rebooting to defaults. Re-pair the controller, then reconnect.");
};
// Debug-only: full board wipe. Erases the firmware itself (not just settings), leaving the board app-less so
// it mounts as the UF2 bootloader drive on every boot until OpenPuck is flashed again. Sends 0x25 + "WIPE".
$("#wipeBoard").onclick=async()=>{
  if(!dev){ log("not connected"); return; }
  if(!confirm("WIPE THE ENTIRE BOARD?\n\nThis is NOT a factory reset. It erases:\n  • the OpenPuck FIRMWARE itself\n  • every setting (mode, chords, back paddles, sensitivity)\n  • the paired-controller bond\n\nThe board reboots with NO firmware and mounts as the UF2 bootloader drive. It will do so on EVERY boot until you flash OpenPuck (a .uf2) back onto it. This panel will disconnect and NOT reconnect until then.\n\nThis CANNOT be undone from software.")) return;
  if(!confirm("Are you absolutely sure?\n\nThe board will be blank. The ONLY way back is to drag a .uf2 firmware file onto the UF2 drive it mounts as.")) return;
  const typed=prompt('Final confirmation — type  WIPE  (all caps) to erase the whole board:');
  if(typed!=="WIPE"){ log("board wipe cancelled (confirmation text did not match)"); return; }
  await send([0x25,0x57,0x49,0x50,0x45]);
  log("FULL BOARD WIPE sent — the board is erasing firmware + all data (~15–20 s), then reboots as a blank UF2 drive. Flash OpenPuck (.uf2) to restore it.");
};
$("#persistMode").onclick=()=>{ const on=$("#persistMode").classList.contains("active"); setField(16, on?0:1); };
$("#landAll87").onclick=async()=>{ const on=$("#landAll87").classList.contains("active"); await setField(29, on?0:1); log("land-all-0x87 "+(on?"disabled":"enabled")); };
// Connection tuning: post-connect haptic block on (field 27) + seconds (field 28). (poll RX window is fixed.)
for(const id of ["mDiv","mFric"]){
  const field={mDiv:1,mFric:2}[id];
  $("#"+id).addEventListener("input", ()=>{ $("#"+id+"V").textContent=fmtSlider(id,$("#"+id).value); });
  $("#"+id).addEventListener("change", ()=>setField(field, +$("#"+id).value));
}
// per-type back/QAM/A-B-swap/haptics handlers are wired in buildTypeCfgs()
$("#swGyroMap").addEventListener("change", ()=>setField(38, +$("#swGyroMap").value));
for(const sel of document.querySelectorAll("select.chord")){
  sel.addEventListener("change", ()=>setField(CHORD_FIELD[+sel.dataset.i], +sel.value));
}
for(const sel of document.querySelectorAll("select.chordD")){
  sel.addEventListener("change", ()=>setField(CHORD_DPAD_FIELD[+sel.dataset.i], +sel.value));
}
for(const b of document.querySelectorAll(".modebtn")){
  b.onclick=()=>{ const m=+b.dataset.mode;
    const clean=(m===7||m===8||m===9);
    const msg="Switch to "+MODE_NAMES[m]+"? The copycat will reboot."+(clean?"\n\nNOTE: the game/clean PlayStation modes (and PS3) drop WebUSB + host-wake, so THIS PANEL WILL DISCONNECT and can't reach the device while it's in this mode. To get back, chord on the controller: hold all four back paddles (L4+R4+L5+R5) + A to return to Steam mode. The back4+D-pad chords are how you get back INTO these modes without the panel — check their assignments in the chords card first.":"");
    if(confirm(msg)){ send([0x03, m]); log("mode switch requested — device will reboot"); } };
}
updateUf2UI();
updateFwGate(); // start gated: stays inert until the first status blob proves the firmware speaks v15+
if(!("usb" in navigator)) $("#connectBtn").outerHTML='<b style="color:var(--bad)">WebUSB not supported — use Chrome or Edge.</b>';
else autoConnect(); // reopen an already-authorized puck on load, no picker (first-ever connect still needs the button)
</script>
</body>
</html>