A fun Tool i made that can’t get blocked terminal is like ms-dos
data:text/html;base64,<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Data OS</title>
<style>
html,body{margin:0;padding:0;height:100%;background:#000;color:#0f0;font-family:monospace;overflow:hidden;}
iframe{position:fixed!important;inset:0!important;width:100vw!important;height:100vh!important;border:none!important;z-index:1;}
textarea{position:fixed;inset:0;width:100vw;height:100vh;border:none;background:#111;color:#0f0;padding:20px;box-sizing:border-box;font-family:monospace;font-size:14px;z-index:1;}
.ascii-input-wrap textarea,.b64-ta{position:static!important;inset:auto!important;width:100%!important;height:100%!important;z-index:auto!important;}
.toolbar{position:fixed;top:10px;right:10px;z-index:10;}
button{padding:8px 14px;margin-left:5px;font-size:14px;cursor:pointer;background:rgba(0,0,0,0.2);color:#0f0;border:1px solid rgba(0,255,0,0.3);font-family:monospace;}
button:hover{background:rgba(0,255,0,0.15);border-color:#0f0;}
.menu-page{position:fixed;inset:0;display:flex;flex-direction:column;justify-content:center;align-items:center;background:#000;z-index:5;}
.menu-page h1{color:#0f0;margin-bottom:30px;font-size:28px;}
.menu-page .menu-grid{display:grid;grid-template-columns:1fr 1fr;gap:8px;width:500px;}
.menu-page button{background:#000;color:#0f0;border:2px solid #0f0;padding:12px 30px;margin:0;font-size:16px;font-family:monospace;cursor:pointer;width:100%;}
.menu-page button:hover{background:#0f0;color:#000;}
.stress-page{position:fixed;inset:0;display:flex;flex-direction:column;justify-content:center;align-items:center;background:#000;z-index:5;}
.stress-page h2,.stress-page p{color:#0f0;font-family:monospace;}
.topbar{position:fixed;top:-70px;left:50%;transform:translateX(-50%);background:#111;padding:8px 12px;display:flex;gap:6px;transition:top 0.3s ease;z-index:999;align-items:center;}
.topbar.visible{top:5px;}
.topbar input{width:320px;padding:6px;background:#222;color:#0f0;border:1px solid #0f0;font-family:monospace;}
.hover-zone{position:fixed;top:0;left:0;width:100%;height:25px;z-index:998;}
.url-page{position:fixed;inset:0;display:flex;flex-direction:column;background:#000;z-index:5;}
.url-page-header{padding:20px 30px 0;display:flex;gap:8px;align-items:center;flex-wrap:wrap;justify-content:center;}
.url-page-header input{flex:1;min-width:200px;padding:8px;background:#111;color:#0f0;border:1px solid #0f0;font-family:monospace;font-size:14px;}
.b64-wrap{position:fixed;inset:0;z-index:1;}
.b64-ta{position:absolute;inset:0;width:100%;height:100%;border:none;background:#111;color:#0f0;padding:20px;box-sizing:border-box;font-family:monospace;font-size:14px;resize:none;}
.b64-ta.drag-over{background:#0b1a0b;box-shadow:inset 0 0 0 3px #0f0;}
.copyright{position:fixed;bottom:10px;left:50%;transform:translateX(-50%);color:rgba(0,255,0,0.35);font-size:11px;z-index:20;pointer-events:none;white-space:nowrap;letter-spacing:1px;user-select:none;-webkit-user-select:none;}

/* Startup screen */
.startup-page{position:fixed;inset:0;display:flex;flex-direction:column;justify-content:center;align-items:center;background:#000;z-index:100;gap:40px;}
.startup-title{color:#0f0;font-family:monospace;font-size:48px;letter-spacing:8px;}
.startup-subtitle{color:#0a0;font-family:monospace;font-size:13px;letter-spacing:4px;}
.startup-buttons{display:flex;gap:20px;}
.startup-btn{background:#000;color:#0f0;border:2px solid #0f0;padding:16px 48px;font-family:monospace;font-size:18px;cursor:pointer;letter-spacing:3px;transition:background 0.15s,color 0.15s;}
.startup-btn:hover{background:#0f0;color:#000;}

/* URL Loader quick-links dropdown */
.ql-wrap{position:relative;display:inline-block;}
.ql-btn{padding:8px 14px;font-size:14px;cursor:pointer;background:rgba(0,0,0,0.2);color:#0f0;border:1px solid rgba(0,255,0,0.3);font-family:monospace;margin-left:0;}
.ql-btn:hover{background:rgba(0,255,0,0.15);border-color:#0f0;}
.ql-dropdown{display:none;position:absolute;top:100%;left:50%;transform:translateX(-50%);background:#0a0a0a;border:1px solid #0f0;min-width:260px;z-index:200;box-shadow:0 4px 20px rgba(0,255,0,0.2);margin-top:4px;}
.ql-dropdown.open{display:block;}
.ql-item{display:block;width:100%;padding:10px 16px;background:transparent;color:#0f0;border:none;border-bottom:1px solid rgba(0,255,0,0.1);font-family:monospace;font-size:13px;cursor:pointer;text-align:left;box-sizing:border-box;margin:0;}
.ql-item:last-child{border-bottom:none;}
.ql-item:hover{background:rgba(0,255,0,0.12);color:#fff;}
.ql-header{padding:6px 16px;color:#0a0;font-size:11px;letter-spacing:2px;border-bottom:1px solid rgba(0,255,0,0.2);}

/* Draw canvas */
.draw-page{position:fixed;inset:0;background:#000;z-index:5;display:flex;flex-direction:column;}
.draw-toolbar{display:flex;gap:6px;padding:8px;background:#111;border-bottom:1px solid #0f0;flex-wrap:wrap;align-items:center;}
.draw-toolbar input[type=color]{width:36px;height:30px;padding:0;border:1px solid #0f0;background:#000;cursor:pointer;}
.draw-toolbar input[type=range]{width:80px;accent-color:#0f0;}
.draw-toolbar select{background:#000;color:#0f0;border:1px solid #0f0;font-family:monospace;padding:4px;}
.draw-toolbar label{color:#0f0;font-size:12px;}
#drawCanvas{flex:1;cursor:crosshair;display:block;}

/* Pixel art editor */
.pixel-page{position:fixed;inset:0;background:#000;z-index:5;display:flex;flex-direction:column;}
.pixel-toolbar{display:flex;gap:6px;padding:8px;background:#111;border-bottom:1px solid #0f0;flex-wrap:wrap;align-items:center;}
.pixel-toolbar input[type=color]{width:36px;height:30px;padding:0;border:1px solid #0f0;background:#000;cursor:pointer;}
.pixel-toolbar label{color:#0f0;font-size:12px;}
.pixel-toolbar select{background:#000;color:#0f0;border:1px solid #0f0;font-family:monospace;padding:4px;}
.pixel-canvas-wrap{flex:1;display:flex;justify-content:center;align-items:center;overflow:hidden;}
#pixelGrid{display:grid;border:1px solid #0f0;cursor:crosshair;}
.px-cell{width:16px;height:16px;box-sizing:border-box;border:1px solid #0a0a0a;}

/* ASCII art */
.ascii-page{position:fixed;inset:0;background:#000;z-index:5;display:flex;flex-direction:column;}
.ascii-toolbar{display:flex;gap:6px;padding:8px;background:#111;border-bottom:1px solid #0f0;flex-wrap:wrap;align-items:center;}
.ascii-toolbar label{color:#0f0;font-size:12px;}
.ascii-toolbar select{background:#000;color:#0f0;border:1px solid #0f0;font-family:monospace;padding:4px;}
.ascii-toolbar input[type=range]{width:80px;accent-color:#0f0;}
.ascii-split{flex:1;display:flex;overflow:hidden;}
.ascii-input-wrap{flex:1;display:flex;flex-direction:column;border-right:1px solid #0f0;}
.ascii-input-wrap textarea{flex:1;background:#111;color:#0f0;border:none;padding:10px;font-family:monospace;font-size:13px;resize:none;outline:none;}
.ascii-output{flex:1;overflow:auto;padding:10px;font-size:10px;line-height:1.1;white-space:pre;color:#0f0;font-family:monospace;}
.ascii-drop-hint{color:#0f0;opacity:0.5;text-align:center;padding:20px;font-size:12px;}

/* Hacker typer */
.hacker-page{position:fixed;inset:0;background:#000;z-index:5;display:flex;flex-direction:column;}
.hacker-display{flex:1;padding:20px;font-family:monospace;font-size:14px;color:#0f0;white-space:pre-wrap;word-break:break-all;overflow:auto;line-height:1.5;}
.hacker-status{padding:6px 12px;background:#111;border-top:1px solid #0f0;font-size:12px;color:#0a0;display:flex;gap:20px;}

/* Terminal */
.term-page{position:fixed;inset:0;background:#0a0a0a;z-index:5;display:flex;flex-direction:column;}
.term-output{flex:1;padding:14px;font-family:monospace;font-size:14px;color:#0f0;white-space:pre-wrap;overflow-y:auto;line-height:1.6;}
.term-input-row{display:flex;align-items:center;padding:6px 14px;border-top:1px solid #0f0;background:#000;}
.term-prompt{color:#0f0;font-family:monospace;font-size:14px;margin-right:6px;white-space:nowrap;}
.term-input{flex:1;background:transparent;border:none;color:#0f0;font-family:monospace;font-size:14px;outline:none;}

/* Inspect menu */
.inspect-page{position:fixed;inset:0;background:#0a0a0a;z-index:5;display:flex;flex-direction:column;}
.inspect-tabs{display:flex;background:#111;border-bottom:1px solid #0f0;}
.inspect-tab{padding:8px 18px;cursor:pointer;font-family:monospace;font-size:13px;color:#0a0;border-right:1px solid #0f0;border-bottom:2px solid transparent;user-select:none;}
.inspect-tab:hover{color:#0f0;background:rgba(0,255,0,0.05);}
.inspect-tab.active{color:#0f0;border-bottom:2px solid #0f0;background:rgba(0,255,0,0.08);}
.inspect-body{flex:1;display:flex;overflow:hidden;}
.inspect-panel{display:none;flex:1;overflow:auto;padding:12px;font-family:monospace;font-size:13px;color:#0f0;line-height:1.6;}
.inspect-panel.active{display:flex;flex-direction:column;gap:6px;}
.inspect-section{border:1px solid rgba(0,255,0,0.2);padding:8px 12px;background:rgba(0,255,0,0.03);}
.inspect-section h3{margin:0 0 6px;color:#0f0;font-size:13px;border-bottom:1px solid rgba(0,255,0,0.2);padding-bottom:4px;}
.inspect-row{display:flex;gap:8px;padding:2px 0;border-bottom:1px solid rgba(0,255,0,0.07);}
.inspect-key{color:#0a0;min-width:200px;flex-shrink:0;}
.inspect-val{color:#0f0;word-break:break-all;}
.inspect-console-out{flex:1;overflow-y:auto;font-family:monospace;font-size:13px;line-height:1.6;white-space:pre-wrap;}
.inspect-console-row{display:flex;gap:10px;padding:3px 0;border-bottom:1px solid rgba(0,255,0,0.06);}
.inspect-console-row.error .inspect-console-msg{color:#f55;}
.inspect-console-row.warn .inspect-console-msg{color:#fa0;}
.inspect-console-row.info .inspect-console-msg{color:#4af;}
.inspect-console-level{min-width:40px;color:#0a0;font-size:11px;padding-top:2px;}
.inspect-console-msg{color:#0f0;word-break:break-all;}
.inspect-console-input-row{display:flex;gap:6px;padding:6px 0;border-top:1px solid #0f0;margin-top:4px;}
.inspect-console-input{flex:1;background:#111;color:#0f0;border:1px solid #0f0;font-family:monospace;font-size:13px;padding:4px 8px;outline:none;}
.inspect-net-row{display:flex;gap:0;border-bottom:1px solid rgba(0,255,0,0.1);padding:4px 0;font-size:12px;}
.inspect-net-row:hover{background:rgba(0,255,0,0.04);}
.inspect-net-status{min-width:40px;text-align:center;}
.inspect-net-method{min-width:55px;color:#4af;}
.inspect-net-url{flex:1;color:#0f0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}
.inspect-net-type{min-width:70px;color:#0a0;}
.inspect-net-size{min-width:60px;color:#0a0;text-align:right;}
.inspect-net-time{min-width:60px;color:#0a0;text-align:right;padding-right:6px;}
.inspect-el-tree{font-family:monospace;font-size:12px;line-height:1.8;}
.inspect-el-tag{color:#4af;cursor:pointer;}
.inspect-el-tag:hover{text-decoration:underline;}
.inspect-el-attr{color:#fa0;}
.inspect-el-text{color:#0a0;}
.inspect-el-indent{display:inline-block;width:16px;}
.status-dot{display:inline-block;width:8px;height:8px;border-radius:50%;margin-right:6px;}
.status-dot.green{background:#0f0;box-shadow:0 0 6px #0f0;}
.status-dot.red{background:#f55;box-shadow:0 0 6px #f55;}
.status-dot.yellow{background:#fa0;box-shadow:0 0 6px #fa0;}

/* Hide scrollbars globally */
*{scrollbar-width:none;}
*::-webkit-scrollbar{display:none;}

/* App overlay (notepad, calc, explorer) */
.app-overlay{position:fixed;inset:0;background:rgba(0,0,0,0.85);z-index:50;display:flex;justify-content:center;align-items:center;}
.app-window{background:#111;border:2px solid #0f0;font-family:monospace;display:flex;flex-direction:column;box-shadow:0 0 30px rgba(0,255,0,0.3);}
.app-titlebar{background:#0f0;color:#000;padding:4px 10px;font-size:13px;font-weight:bold;display:flex;justify-content:space-between;align-items:center;user-select:none;}
.app-close{background:transparent;border:none;color:#000;font-size:16px;cursor:pointer;font-family:monospace;padding:0 4px;font-weight:bold;margin:0;}
.app-close:hover{background:#000;color:#0f0;border:none;}
.app-menubar{background:#1a1a1a;border-bottom:1px solid #0f0;display:flex;gap:0;}
.app-menubar button{background:transparent;color:#0f0;border:none;border-right:1px solid rgba(0,255,0,0.2);padding:4px 12px;font-family:monospace;font-size:12px;cursor:pointer;margin:0;}
.app-menubar button:hover{background:rgba(0,255,0,0.1);}

/* Notepad */
.notepad-window{width:660px;height:420px;}
.notepad-ta{flex:1;background:#0a0a0a;color:#0f0;border:none;padding:10px;font-family:monospace;font-size:13px;resize:none;outline:none;line-height:1.6;}
.notepad-statusbar{padding:3px 8px;background:#1a1a1a;border-top:1px solid #0f0;font-size:11px;color:#0a0;display:flex;gap:20px;}

/* Calculator */
.calc-window{width:280px;}
.calc-display{background:#000;color:#0f0;font-size:22px;text-align:right;padding:10px 14px;border-bottom:1px solid #0f0;min-height:36px;font-family:monospace;letter-spacing:2px;text-shadow:0 0 8px #0f0;}
.calc-expr{background:#000;color:#0a0;font-size:12px;text-align:right;padding:2px 14px 4px;border-bottom:1px solid rgba(0,255,0,0.15);min-height:16px;font-family:monospace;}
.calc-grid{display:grid;grid-template-columns:repeat(4,1fr);gap:1px;background:rgba(0,255,0,0.2);border-top:1px solid #0f0;}
.calc-btn{background:#000;color:#0f0;border:none;padding:14px 0;font-family:monospace;font-size:15px;cursor:pointer;margin:0;transition:background 0.1s;}
.calc-btn:hover{background:#0f0;color:#000;}
.calc-btn.op{color:#0f0;background:#001a00;}
.calc-btn.op:hover{background:#0f0;color:#000;}
.calc-btn.eq{background:#003300;color:#0f0;text-shadow:0 0 6px #0f0;}
.calc-btn.eq:hover{background:#0f0;color:#000;}
.calc-btn.wide{grid-column:span 2;}
.calc-btn.clear{color:#f55;}
.calc-btn.clear:hover{background:#f55;color:#000;}

/* Explorer */
.explorer-window{width:700px;height:440px;display:flex;flex-direction:column;}
.explorer-toolbar-row{display:flex;align-items:center;gap:6px;padding:5px 8px;background:#1a1a1a;border-bottom:1px solid rgba(0,255,0,0.2);}
.explorer-addr{flex:1;background:#0a0a0a;color:#0f0;border:1px solid rgba(0,255,0,0.4);padding:4px 8px;font-family:monospace;font-size:12px;outline:none;}
.explorer-body{flex:1;display:flex;overflow:hidden;}
.explorer-tree{width:170px;border-right:1px solid #0f0;overflow-y:auto;padding:6px 0;font-size:12px;}
.explorer-tree-item{padding:4px 10px;cursor:pointer;color:#0a0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}
.explorer-tree-item:hover{background:rgba(0,255,0,0.07);color:#0f0;}
.explorer-tree-item.selected{background:rgba(0,255,0,0.15);color:#0f0;}
.explorer-main{flex:1;overflow-y:auto;padding:8px;}
.explorer-items{display:flex;flex-wrap:wrap;gap:6px;align-content:flex-start;}
.explorer-item{width:80px;display:flex;flex-direction:column;align-items:center;gap:4px;padding:6px 4px;cursor:pointer;border:1px solid transparent;}
.explorer-item:hover{background:rgba(0,255,0,0.07);border-color:rgba(0,255,0,0.3);}
.explorer-item.selected{background:rgba(0,255,0,0.15);border-color:#0f0;}
.explorer-icon{font-size:22px;line-height:1;}
.explorer-label{font-size:11px;color:#0f0;text-align:center;word-break:break-word;line-height:1.3;}
.explorer-statusbar{padding:3px 10px;background:#1a1a1a;border-top:1px solid #0f0;font-size:11px;color:#0a0;}

/* Games */
.game-window{position:fixed;inset:0;background:#000;z-index:60;display:flex;flex-direction:column;}
.game-inner{flex:1;display:flex;flex-direction:column;width:100%;height:100%;min-height:0;}
.game-canvas-wrap{flex:1;position:relative;background:#000;overflow:hidden;display:flex;justify-content:center;align-items:center;}
.game-canvas-wrap canvas{display:block;image-rendering:pixelated;image-rendering:crisp-edges;height:100%;width:auto;}
.game-info{padding:5px 14px;background:#111;border-top:1px solid #0f0;font-size:12px;color:#0a0;display:flex;gap:20px;align-items:center;flex-shrink:0;}
.game-info span{color:#0f0;}
.game-exit-btn{position:absolute;top:8px;right:8px;z-index:5;background:rgba(0,0,0,0.7);color:#0f0;border:1px solid rgba(0,255,0,0.4);font-family:monospace;font-size:12px;padding:4px 10px;cursor:pointer;}
.game-exit-btn:hover{background:rgba(0,255,0,0.15);border-color:#0f0;}

</style>
</head>
<body>
<script>
/* ── helpers ── */
function normalizeURL(url){url=url.trim();if(!url)return"";if(/^https?:\/\//i.test(url))return url;return"https://"+url;}
function clearBody(){document.body.innerHTML="";}
function makeBtn(label,fn){const b=document.createElement("button");b.textContent=label;b.onclick=fn;return b;}
function addCopyright(){const c=document.createElement("div");c.className="copyright";c.innerHTML="&copy; 2026 &mdash; Jon Stearns";document.body.appendChild(c);}
  document.addEventListener("keydown",function(e){
    if((e.ctrlKey||e.metaKey)&&e.key==="a"){
      const t=document.activeElement;
      const ok=t&&(t.tagName==="TEXTAREA"||(t.tagName==="INPUT"&&t.type!=="button"&&t.type!=="checkbox"&&t.type!=="radio"));
      if(!ok)e.preventDefault();
    }
  },true);
/* Wire ESC to goBack when launched from terminal. Returns true if terminal-launched (skip Back button). */
function bindEscIfTerminal(goBack){
  if(goBack!==showTerminal)return false;
  function onEsc(e){if(e.key==="Escape"){document.removeEventListener("keydown",onEsc);goBack();}}
  document.addEventListener("keydown",onEsc);
  return true;
}

/* ══════════════════ STARTUP SCREEN ══════════════════ */
function showStartup(){
  clearBody();
  const page=document.createElement("div");page.className="startup-page";
  const title=document.createElement("div");title.className="startup-title";title.textContent="DATA OS";
  const sub=document.createElement("div");sub.className="startup-subtitle";sub.textContent="v8.0.0-final";
  const btns=document.createElement("div");btns.className="startup-buttons";
  const ezBtn=document.createElement("button");ezBtn.className="startup-btn";ezBtn.textContent="EZ-MODE";
  ezBtn.onclick=showMenu;
  const termBtn=document.createElement("button");termBtn.className="startup-btn";termBtn.textContent="TERMINAL";
  termBtn.onclick=()=>showTerminal(null);
  btns.appendChild(ezBtn);btns.appendChild(termBtn);
  [title,sub,btns].forEach(el=>page.appendChild(el));
  document.body.appendChild(page);
  addCopyright();
}

/* ══════════════════ IFRAME-BASED GAME LAUNCHERS ══════════════════ */
function showIframeGame(srcdoc,goBack,showBack){
  clearBody();
  const iframe=document.createElement("iframe");
  iframe.style.cssText="position:fixed;inset:0;width:100vw;height:100vh;border:none;z-index:1;background:#000;";
  iframe.srcdoc=srcdoc;

  document.body.appendChild(iframe);

  if(showBack&&goBack){
    const backBtn=document.createElement("button");
    backBtn.textContent="← Back";
    backBtn.style.cssText="position:fixed;top:10px;right:10px;z-index:10;padding:6px 14px;font-size:13px;cursor:pointer;background:rgba(0,0,0,0.7);color:#0f0;border:1px solid rgba(0,255,0,0.4);font-family:monospace;";
    backBtn.onmouseenter=()=>{backBtn.style.background="rgba(0,255,0,0.15)";backBtn.style.borderColor="#0f0";};
    backBtn.onmouseleave=()=>{backBtn.style.background="rgba(0,0,0,0.7)";backBtn.style.borderColor="rgba(0,255,0,0.4)";};
    backBtn.onclick=()=>{if(goBack)goBack();};
    document.body.appendChild(backBtn);
  }

  addCopyright();
}

function showIframeGameWithExceptionBack(srcdoc,goBack){
  clearBody();
  const iframe=document.createElement("iframe");
  iframe.style.cssText="position:fixed;inset:0;width:100vw;height:100vh;border:none;z-index:1;background:#000;";

  // Inject a postMessage hook into srcdoc so the iframe can signal us on exception
  const injected=srcdoc.replace(
    "window.onerror=()=>{",
    "window.onerror=()=>{try{window.parent.postMessage('game-exception','*');}catch(e){}"
  );
  iframe.srcdoc=injected;

  window.addEventListener("message",function onMsg(e){
    if(e.data==="game-exception"){
      window.removeEventListener("message",onMsg);
      if(goBack)goBack();
    }
  });

  document.body.appendChild(iframe);
  addCopyright();
}

function showDoom(goBack){
  const srcdoc=`<!DOCTYPE html><html><head>
<base href="https://cdn.jsdelivr.net/gh/Stinkalistic/UGS@main/MISC/doom/">
<title>DOOM</title><meta charset="utf-8">
<meta name="viewport" content="width=device-width,height=device-height,initial-scale=1.0,maximum-scale=1.0,user-scalable=0.0,viewport-fit=cover">
<style>
html{height:100vh;}body{color:#ccc;font-family:Monospace;font-size:16px;background-color:black;margin:0;display:flex;justify-content:center;}
canvas{overflow:auto;width:100vw;}
@media screen and (min-width:576px){canvas{height:100vh;height:100dvh;}}
@keyframes page-loader{0%{transform:rotate(0deg);}100%{transform:rotate(360deg);}}
.info-overlay{text-align:center;position:absolute;top:0;bottom:0;left:0;right:0;margin:auto;width:200px;height:200px;display:none;}
#spinner{content:"";border-radius:50%;width:48px;height:48px;position:absolute;margin:auto;top:0;bottom:0;left:0;right:0;border-top:2px solid #222;border-right:2px solid #222;border-bottom:2px solid #222;border-left:2px solid #867ae0;transform:translateZ(0);animation:page-loader 1.1s infinite linear;}
a{color:#867ae0;text-decoration:none;}a:hover{text-decoration:underline;}
</style></head><body>
<canvas id="canvas" oncontextmenu="event.preventDefault()"></canvas>
<div class="info-overlay" id="loading"><div id="spinner"></div><div id="status">Downloading...</div><div><progress value="0" max="100" id="progress" hidden=1></progress></div></div>
<div class="info-overlay" id="select-version"><a href="#" id="load">Load</a><br/>~11mb</div>
<script>
var loadScript=(ev,src)=>{ev.preventDefault();document.getElementById('select-version').style.display='none';document.getElementById('loading').style.display='block';var s=document.createElement('script');s.setAttribute('src',src);document.head.appendChild(s);};
document.getElementById('select-version').style.display='block';
document.getElementById('load').addEventListener('click',(ev)=>loadScript(ev,'index.js'));
var statusElement=document.getElementById('status');
var progressElement=document.getElementById('progress');
var spinnerElement=document.getElementById('spinner');
var Module={preRun:[],postRun:[],print:function(text){if(arguments.length>1)text=Array.prototype.slice.call(arguments).join(' ');console.log(text);},canvas:document.getElementById('canvas'),setStatus:(text)=>{if(!Module.setStatus.last){Module.setStatus.last={time:Date.now(),text:''};} if(text===Module.setStatus.last.text){return;} var m=text.match(/([^(]+)\\((\\d+(\\.\\d+)?)\\/(\\/d+)\\)/);var now=Date.now();if(m&&now-Module.setStatus.last.time<30){return;} Module.setStatus.last.time=now;Module.setStatus.last.text=text;if(m){text=m[1];progressElement.value=parseInt(m[2])*100;progressElement.max=parseInt(m[4])*100;progressElement.hidden=false;spinnerElement.hidden=false;}else{progressElement.value=null;progressElement.max=null;progressElement.hidden=true;if(!text){spinnerElement.hidden=true;document.getElementById('loading').style.display='none';}} statusElement.innerHTML=text;},totalDependencies:0,monitorRunDependencies:(left)=>{Module.totalDependencies=Math.max(Module.totalDependencies,left);Module.setStatus(left?'preparing... ('+(Module.totalDependencies-left)+'/'+Module.totalDependencies+')':'all downloads complete.');}};
Module.setStatus('downloading...');
window.onerror=()=>{Module.setStatus('Exception thrown, see JavaScript console');document.getElementById('loading').style.display='block';spinnerElement.style.display='none';Module.setStatus=(text)=>{if(text){console.error('[post-exception status] '+text);}};};
<\/script></body></html>`;
  showIframeGameWithExceptionBack(srcdoc,goBack);
}

function showWolf3D(goBack){
  const srcdoc=`<!DOCTYPE html><html><head>
<base href="https://cdn.jsdelivr.net/gh/Stinkalistic/UGS@main/MISC/wolfenstein/">
<title>Wolfenstein 3D</title><meta charset="utf-8">
<meta name="viewport" content="width=device-width,height=device-height,initial-scale=1.0,maximum-scale=1.0,user-scalable=0.0,viewport-fit=cover">
<style>
html{height:100vh;}body{color:#ccc;font-family:Monospace;font-size:16px;background-color:black;margin:0;display:flex;justify-content:center;}
canvas{overflow:auto;width:100vw;}
@media screen and (min-width:576px){canvas{height:100vh;height:100dvh;}}
@keyframes page-loader{0%{transform:rotate(0deg);}100%{transform:rotate(360deg);}}
.info-overlay{text-align:center;position:absolute;top:0;bottom:0;left:0;right:0;margin:auto;width:200px;height:200px;display:none;}
#spinner{content:"";border-radius:50%;width:48px;height:48px;position:absolute;margin:auto;top:0;bottom:0;left:0;right:0;border-top:2px solid #222;border-right:2px solid #222;border-bottom:2px solid #222;border-left:2px solid #867ae0;transform:translateZ(0);animation:page-loader 1.1s infinite linear;}
a{color:#867ae0;text-decoration:none;}a:hover{text-decoration:underline;}
</style></head><body>
<canvas id="canvas" oncontextmenu="event.preventDefault()"></canvas>
<div class="info-overlay" id="loading"><div id="spinner"></div><div id="status">Downloading...</div><div><progress value="0" max="100" id="progress" hidden=1></progress></div></div>
<div class="info-overlay" id="select-version"><a href="#" id="load">Load</a><br/>~2mb</div>
<script>
var loadScript=(ev,src)=>{ev.preventDefault();document.getElementById('select-version').style.display='none';document.getElementById('loading').style.display='block';var s=document.createElement('script');s.setAttribute('src',src);document.head.appendChild(s);};
document.getElementById('select-version').style.display='block';
document.getElementById('load').addEventListener('click',(ev)=>loadScript(ev,'index.js'));
var statusElement=document.getElementById('status');
var progressElement=document.getElementById('progress');
var spinnerElement=document.getElementById('spinner');
var Module={preRun:[],postRun:[],print:function(text){if(arguments.length>1)text=Array.prototype.slice.call(arguments).join(' ');console.log(text);},canvas:document.getElementById('canvas'),setStatus:(text)=>{if(!Module.setStatus.last){Module.setStatus.last={time:Date.now(),text:''};} if(text===Module.setStatus.last.text){return;} var m=text.match(/([^(]+)\\((\\d+(\\.\\d+)?)\\/(\\/d+)\\)/);var now=Date.now();if(m&&now-Module.setStatus.last.time<30){return;} Module.setStatus.last.time=now;Module.setStatus.last.text=text;if(m){text=m[1];progressElement.value=parseInt(m[2])*100;progressElement.max=parseInt(m[4])*100;progressElement.hidden=false;spinnerElement.hidden=false;}else{progressElement.value=null;progressElement.max=null;progressElement.hidden=true;if(!text){spinnerElement.hidden=true;document.getElementById('loading').style.display='none';}} statusElement.innerHTML=text;},totalDependencies:0,monitorRunDependencies:(left)=>{Module.totalDependencies=Math.max(Module.totalDependencies,left);Module.setStatus(left?'preparing... ('+(Module.totalDependencies-left)+'/'+Module.totalDependencies+')':'all downloads complete.');}};
Module.setStatus('downloading...');
window.onerror=()=>{Module.setStatus('Exception thrown, see JavaScript console');document.getElementById('loading').style.display='block';spinnerElement.style.display='none';Module.setStatus=(text)=>{if(text){console.error('[post-exception status] '+text);}};};
<\/script></body></html>`;
  showIframeGameWithExceptionBack(srcdoc,goBack);
}

/* ══════════════════ MENU ══════════════════ */
function showMenu(){
  clearBody();
  const page=document.createElement("div");page.className="menu-page";
  const h1=document.createElement("h1");h1.textContent="EZ-Mode";
  page.appendChild(h1);

  const grid=document.createElement("div");grid.className="menu-grid";

  const apps=[
    ["HTML Editor",   ()=>showEditor("",showMenu)],
    ["URL Loader",    ()=>showURLPage(showMenu)],
    ["Base64 Tool",   ()=>showBase64(showMenu)],
    ["CPU Stress",    ()=>showStress(showMenu)],
    ["Draw / Paint",  ()=>showDraw(showMenu)],
    ["Pixel Art",     ()=>showPixelArt(showMenu)],
    ["ASCII Art",     ()=>showASCII(showMenu)],
    ["Hacker Typer",  ()=>showHackerTyper(showMenu)],
    ["Terminal",      ()=>showTerminal(showMenu)],
    ["Inspect",       showInspect],
    ["Notepad",       ()=>launchNotepad(null,"",showMenu)],
    ["Calculator",    ()=>launchCalculator(showMenu)],
    ["File Explorer", ()=>launchExplorer("C:\\Users\\anonymous",showMenu)],
  ];

  apps.forEach(([l,f])=>{
    const b=document.createElement("button");b.textContent=l;b.onclick=f;grid.appendChild(b);
  });

  const gamesBtn=document.createElement("button");
  gamesBtn.textContent="Games";
  gamesBtn.onclick=showGames;
  grid.appendChild(gamesBtn);

  page.appendChild(grid);
  document.body.appendChild(page);
  addCopyright();
}

function showGames(){
  clearBody();
  const page=document.createElement("div");page.className="menu-page";
  const h1=document.createElement("h1");h1.textContent="Games";
  page.appendChild(h1);

  const grid=document.createElement("div");grid.className="menu-grid";

  const games=[
    ["Pong",        ()=>launchPong(showGames)],
    ["Tetris",      ()=>launchTetris(showGames)],
    ["Minesweeper", ()=>launchMinesweeper(showGames)],
    ["Snake",       ()=>launchSnake(showGames)],
    ["Breakout",    ()=>launchBreakout(showGames)],
    ["2048",        ()=>launch2048(showGames)],
    ["DOOM",        ()=>showDoom(showGames)],
    ["Wolfenstein 3D", ()=>showWolf3D(showGames)],
  ];

  games.forEach(([l,f])=>{
    const b=document.createElement("button");b.textContent=l;b.onclick=f;grid.appendChild(b);
  });

  const backBtn=document.createElement("button");
  backBtn.textContent="← Back";
  backBtn.style.gridColumn="span 2";
  backBtn.onclick=showMenu;
  grid.appendChild(backBtn);

  page.appendChild(grid);
  document.body.appendChild(page);
  addCopyright();
}

/* ══════════════════ ORIGINAL PAGES ══════════════════ */
function showEditor(existingHTML, goBack){
  if(!goBack)goBack=showMenu;
  clearBody();
  const ta=document.createElement("textarea");
  ta.value=(typeof existingHTML==="string")?existingHTML:"";
  ta.placeholder="Write or paste HTML here...";
  const tb=document.createElement("div");tb.className="toolbar";
  const renderBtn=makeBtn("Render",()=>{
    const html=ta.value;clearBody();
    const iframe=document.createElement("iframe");iframe.srcdoc=html;
    const tb2=document.createElement("div");tb2.className="toolbar";
    tb2.appendChild(makeBtn("Back to Editor",()=>showEditor(html,goBack)));
    document.body.appendChild(iframe);document.body.appendChild(tb2);
    addCopyright();
  });
  const dlBtn=makeBtn("Download",()=>{const blob=new Blob([ta.value],{type:"text/html"});const a=document.createElement("a");a.href=URL.createObjectURL(blob);a.download="index.html";a.click();});
  const ulBtn=makeBtn("Upload",()=>{const input=document.createElement("input");input.type="file";input.accept=".html,.htm";input.onchange=e=>{const r=new FileReader();r.onload=()=>ta.value=r.result;r.readAsText(e.target.files[0]);};input.click();});
  const btns=bindEscIfTerminal(goBack)?[renderBtn,dlBtn,ulBtn]:[makeBtn("Back",goBack),renderBtn,dlBtn,ulBtn];
  btns.forEach(b=>tb.appendChild(b));
  document.body.appendChild(ta);document.body.appendChild(tb);
  addCopyright();
}

function showURLPage(goBack){
  if(!goBack)goBack=showMenu;
  clearBody();
  const page=document.createElement("div");page.className="url-page";
  const hdr=document.createElement("div");hdr.className="url-page-header";
  const addrInput=document.createElement("input");addrInput.type="text";addrInput.placeholder="https://...";
  const goBtn=makeBtn("Go",()=>{const u=normalizeURL(addrInput.value);if(u)showURLMode(u,goBack);});
  addrInput.onkeydown=e=>{if(e.key==="Enter")goBtn.click();};

  // ── Quick-links dropdown ──
  const qlLinks=[
    {label:"Slope Online",      url:"https://slopeonline.online",       srcdoc:null},
    {label:"Gitlab Games",      url:"https://gitlabgames.gitlab.io/game/", srcdoc:null},
    {label:"GamesLOL",      url:"https://en.gameslol.net/", srcdoc:null},
    {label:"GX-Client (MC 1.8.8)", url:"https://gx-client.surge.sh/GX-Client%20WASM.html", srcdoc:null},
  ];
  const qlWrap=document.createElement("div");qlWrap.className="ql-wrap";
  const qlBtn=document.createElement("button");qlBtn.className="ql-btn";qlBtn.textContent="⬇ Quick Links";
  const qlDrop=document.createElement("div");qlDrop.className="ql-dropdown";
  const qlHead=document.createElement("div");qlHead.className="ql-header";qlHead.textContent="QUICK LINKS";
  qlDrop.appendChild(qlHead);
  qlLinks.forEach(({label,url,srcdoc})=>{
    const item=document.createElement("button");item.className="ql-item";item.textContent=label;
    item.onclick=()=>{
      qlDrop.classList.remove("open");
      if(srcdoc){showIframeGame(srcdoc,goBack,true);}
      else{showURLMode(url,goBack);}
    };
    qlDrop.appendChild(item);
  });
  qlBtn.onclick=(e)=>{e.stopPropagation();qlDrop.classList.toggle("open");};
  document.addEventListener("click",()=>qlDrop.classList.remove("open"));
  qlWrap.appendChild(qlBtn);qlWrap.appendChild(qlDrop);

  const urlBtns=bindEscIfTerminal(goBack)?[addrInput,goBtn]:[makeBtn("Back",goBack),addrInput,goBtn];
  urlBtns.forEach(el=>hdr.appendChild(el));
  page.appendChild(hdr);

  const qlRow=document.createElement("div");
  qlRow.style.cssText="display:flex;justify-content:center;padding:10px 0 0;";
  qlRow.appendChild(qlWrap);
  page.appendChild(qlRow);

  document.body.appendChild(page);
  addCopyright();
}

function showURLMode(initialURL,goBack){
  if(!goBack)goBack=showMenu;
  clearBody();
  const iframe=document.createElement("iframe");iframe.src=initialURL;
  const hoverZone=document.createElement("div");hoverZone.className="hover-zone";
  const topbar=document.createElement("div");topbar.className="topbar";
  const addressBar=document.createElement("input");addressBar.type="text";addressBar.value=initialURL;
  const goBtn=makeBtn("Go",()=>{const u=normalizeURL(addressBar.value);if(u)iframe.src=u;});
  addressBar.onkeydown=e=>{if(e.key==="Enter")goBtn.click();};
  const backBtn=makeBtn("Back",()=>{try{iframe.contentWindow.history.back();}catch{alert("Cross-origin restriction.");}});
  [makeBtn("⬅ Loader",()=>showURLPage(goBack)),backBtn,addressBar,goBtn].forEach(el=>topbar.appendChild(el));
  let hT,hT2;
  hoverZone.addEventListener("mouseenter",()=>hT=setTimeout(()=>topbar.classList.add("visible"),600));
  hoverZone.addEventListener("mouseleave",()=>clearTimeout(hT));
  topbar.addEventListener("mouseenter",()=>clearTimeout(hT2));
  topbar.addEventListener("mouseleave",()=>hT2=setTimeout(()=>topbar.classList.remove("visible"),300));
  document.body.appendChild(iframe);document.body.appendChild(hoverZone);document.body.appendChild(topbar);
  addCopyright();
}

function showBase64(goBack){
  if(!goBack)goBack=showMenu;
  clearBody();
  const wrap=document.createElement("div");wrap.className="b64-wrap";
  const ta=document.createElement("textarea");ta.className="b64-ta";
  ta.placeholder="Paste text / HTML / Base64 here — or drag & drop any file to encode it...";
  function encodeFile(file){const r=new FileReader();r.onload=()=>{ta.value=r.result.split(",")[1];};r.readAsDataURL(file);}
  ta.addEventListener("dragover",e=>{e.preventDefault();ta.classList.add("drag-over");});
  ta.addEventListener("dragleave",()=>ta.classList.remove("drag-over"));
  ta.addEventListener("drop",e=>{e.preventDefault();ta.classList.remove("drag-over");const f=e.dataTransfer.files[0];if(f)encodeFile(f);});
  wrap.appendChild(ta);
  document.body.appendChild(wrap);
  const tb=document.createElement("div");tb.className="toolbar";
  const encBtn=makeBtn("Encode",()=>{try{ta.value=btoa(unescape(encodeURIComponent(ta.value)));}catch(e){alert("Encode failed: "+e.message);}});
  const decBtn=makeBtn("Decode",()=>{try{ta.value=decodeURIComponent(escape(atob(ta.value)));}catch(e){alert("Decode failed: "+e.message);}});
  const uriBtn=makeBtn("URI",()=>{try{ta.value="data:text/html;base64,"+btoa(unescape(encodeURIComponent(ta.value)));}catch(e){alert("URI encode failed: "+e.message);}});
  const copyBtn=makeBtn("Copy",()=>{navigator.clipboard.writeText(ta.value).then(()=>{copyBtn.textContent="Copied!";setTimeout(()=>copyBtn.textContent="Copy",1500);}).catch(()=>alert("Copy failed."));});
  const ulBtn=makeBtn("Upload",()=>{const input=document.createElement("input");input.type="file";input.onchange=e=>{const f=e.target.files[0];if(f)encodeFile(f);};input.click();});
  const dlBtn=makeBtn("Download",()=>{
    const content=ta.value;
    if(!content){alert("Nothing to download.");return;}
    const blob=new Blob([content],{type:"text/plain"});
    const a=document.createElement("a");a.href=URL.createObjectURL(blob);a.download="base64_output.txt";a.click();
  });
  const b64btns=bindEscIfTerminal(goBack)?[encBtn,decBtn,uriBtn,copyBtn,ulBtn,dlBtn]:[makeBtn("Back",goBack),encBtn,decBtn,uriBtn,copyBtn,ulBtn,dlBtn];
  b64btns.forEach(b=>tb.appendChild(b));
  document.body.appendChild(tb);
  addCopyright();
}

let stressWorkers=[],stressRunning=false,totalOps=0;
function showStress(goBack){
  if(!goBack)goBack=showMenu;
  stopTest();clearBody();
  const page=document.createElement("div");page.className="stress-page";
  const h2=document.createElement("h2");h2.textContent="CPU Stress Test";
  const tP=document.createElement("p");tP.textContent="Logical Threads Detected: "+navigator.hardwareConcurrency;
  const oP=document.createElement("p");oP.innerHTML="Total Operations: <span id='ops'>0</span>";
  const startBtn=makeBtn("Start Test",startTest);
  const stopBtn=makeBtn("Stop Test",stopTest);
  const tb=document.createElement("div");tb.className="toolbar";
  if(!bindEscIfTerminal(goBack))tb.appendChild(makeBtn("Back",()=>{stopTest();goBack();}));
  [h2,tP,oP,startBtn,stopBtn].forEach(el=>page.appendChild(el));
  document.body.appendChild(page);document.body.appendChild(tb);
  addCopyright();
}
function startTest(){if(stressRunning)return;stressRunning=true;totalOps=0;const el=document.getElementById("ops");if(el)el.textContent="0";for(let i=0;i<navigator.hardwareConcurrency;i++){const w=new Worker(URL.createObjectURL(new Blob([`let ops=0;function heavyCompute(){while(true){for(let i=0;i<1e6;i++){ops+=Math.sqrt(i)*Math.random();}postMessage(ops);}}heavyCompute();`],{type:'application/javascript'})));w.onmessage=()=>{totalOps+=1;const el=document.getElementById("ops");if(el)el.textContent=totalOps;};stressWorkers.push(w);}}
function stopTest(){stressRunning=false;stressWorkers.forEach(w=>w.terminate());stressWorkers=[];}

/* ══════════════════ DRAW / PAINT ══════════════════ */
function showDraw(goBack){
  if(!goBack)goBack=showMenu;
  clearBody();
  const page=document.createElement("div");page.className="draw-page";

  const tb=document.createElement("div");tb.className="draw-toolbar";

  const menuBtn=bindEscIfTerminal(goBack)?null:makeBtn("Back",goBack);

  const colorPick=document.createElement("input");colorPick.type="color";colorPick.value="#00ff00";
  const colorLabel=document.createElement("label");colorLabel.textContent=" Color ";

  const sizeLabel=document.createElement("label");sizeLabel.textContent=" Size ";
  const sizeRange=document.createElement("input");sizeRange.type="range";sizeRange.min=1;sizeRange.max=60;sizeRange.value=8;
  const sizeVal=document.createElement("label");sizeVal.textContent="8";
  sizeRange.oninput=()=>sizeVal.textContent=sizeRange.value;

  const toolLabel=document.createElement("label");toolLabel.textContent=" Tool ";
  const toolSel=document.createElement("select");
  ["Pen","Eraser","Line","Rect","Circle","Fill"].forEach(t=>{const o=document.createElement("option");o.value=t.toLowerCase();o.textContent=t;toolSel.appendChild(o);});

  const clearBtn=makeBtn("Clear",()=>{ctx.fillStyle="#000";ctx.fillRect(0,0,canvas.width,canvas.height);});
  const dlBtn=makeBtn("Download",()=>{const a=document.createElement("a");a.download="drawing.png";a.href=canvas.toDataURL();a.click();});

  [menuBtn,colorLabel,colorPick,sizeLabel,sizeRange,sizeVal,toolLabel,toolSel,clearBtn,dlBtn].filter(Boolean).forEach(el=>tb.appendChild(el));

  const canvas=document.createElement("canvas");canvas.id="drawCanvas";
  page.appendChild(tb);page.appendChild(canvas);
  document.body.appendChild(page);
  addCopyright();

  function resize(){canvas.width=canvas.offsetWidth;canvas.height=canvas.offsetHeight;ctx.fillStyle="#000";ctx.fillRect(0,0,canvas.width,canvas.height);}
  const ctx=canvas.getContext("2d");
  resize();
  window.addEventListener("resize",resize);

  let drawing=false,startX=0,startY=0,snapshot=null;

  function getPos(e){
    const r=canvas.getBoundingClientRect();
    const src=e.touches?e.touches[0]:e;
    return[src.clientX-r.left,src.clientY-r.top];
  }

  function floodFill(x,y,fillColor){
    x=Math.round(x);y=Math.round(y);
    const imgData=ctx.getImageData(0,0,canvas.width,canvas.height);
    const data=imgData.data;
    const idx=(y*canvas.width+x)*4;
    const targR=data[idx],targG=data[idx+1],targB=data[idx+2],targA=data[idx+3];
    const fc=fillColor.match(/\w\w/g).map(h=>parseInt(h,16));
    if(fc[0]===targR&&fc[1]===targG&&fc[2]===targB)return;
    const stack=[[x,y]];
    while(stack.length){
      const[cx,cy]=stack.pop();
      const i=(cy*canvas.width+cx)*4;
      if(cx<0||cx>=canvas.width||cy<0||cy>=canvas.height)continue;
      if(data[i]!==targR||data[i+1]!==targG||data[i+2]!==targB||data[i+3]!==targA)continue;
      data[i]=fc[0];data[i+1]=fc[1];data[i+2]=fc[2];data[i+3]=255;
      stack.push([cx+1,cy],[cx-1,cy],[cx,cy+1],[cx,cy-1]);
    }
    ctx.putImageData(imgData,0,0);
  }

  function down(e){
    e.preventDefault();
    const[x,y]=getPos(e);
    if(toolSel.value==="fill"){floodFill(x,y,colorPick.value.replace("#",""));return;}
    drawing=true;startX=x;startY=y;
    snapshot=ctx.getImageData(0,0,canvas.width,canvas.height);
    ctx.beginPath();ctx.moveTo(x,y);
  }
  function move(e){
    if(!drawing)return;e.preventDefault();
    const[x,y]=getPos(e);
    const tool=toolSel.value;
    const size=parseInt(sizeRange.value);
    ctx.strokeStyle=tool==="eraser"?"#000":colorPick.value;
    ctx.fillStyle=colorPick.value;
    ctx.lineWidth=size;ctx.lineCap="round";ctx.lineJoin="round";
    if(tool==="pen"||tool==="eraser"){ctx.lineTo(x,y);ctx.stroke();ctx.beginPath();ctx.moveTo(x,y);}
    else{
      ctx.putImageData(snapshot,0,0);
      ctx.beginPath();
      if(tool==="line"){ctx.moveTo(startX,startY);ctx.lineTo(x,y);ctx.stroke();}
      else if(tool==="rect"){ctx.strokeRect(startX,startY,x-startX,y-startY);}
      else if(tool==="circle"){const rx=(x-startX)/2,ry=(y-startY)/2;ctx.ellipse(startX+rx,startY+ry,Math.abs(rx),Math.abs(ry),0,0,Math.PI*2);ctx.stroke();}
    }
  }
  function up(e){e.preventDefault();drawing=false;}
  canvas.addEventListener("mousedown",down);canvas.addEventListener("mousemove",move);canvas.addEventListener("mouseup",up);
  canvas.addEventListener("touchstart",down,{passive:false});canvas.addEventListener("touchmove",move,{passive:false});canvas.addEventListener("touchend",up,{passive:false});
}

/* ══════════════════ PIXEL ART EDITOR ══════════════════ */
function showPixelArt(goBack){
  if(!goBack)goBack=showMenu;
  clearBody();
  const page=document.createElement("div");page.className="pixel-page";
  const tb=document.createElement("div");tb.className="pixel-toolbar";

  const colorPick=document.createElement("input");colorPick.type="color";colorPick.value="#00ff00";
  const colorLabel=document.createElement("label");colorLabel.textContent=" Color ";

  const toolLabel=document.createElement("label");toolLabel.textContent=" Tool ";
  const toolSel=document.createElement("select");
  ["Draw","Eraser","Fill"].forEach(t=>{const o=document.createElement("option");o.value=t.toLowerCase();o.textContent=t;toolSel.appendChild(o);});

  const sizeLabel=document.createElement("label");sizeLabel.textContent=" Grid ";
  const sizeSel=document.createElement("select");
  [8,16,24,32,48,64].forEach(s=>{const o=document.createElement("option");o.value=s;o.textContent=s+"x"+s;if(s===16)o.selected=true;sizeSel.appendChild(o);});

  const clearBtn=makeBtn("Clear",()=>buildGrid());
  const dlBtn=makeBtn("Download",()=>{
    const tempCanvas=document.createElement("canvas");
    tempCanvas.width=gridSize;tempCanvas.height=gridSize;
    const tc=tempCanvas.getContext("2d");
    cells.forEach((cell,i)=>{
      const x=i%gridSize,y=Math.floor(i/gridSize);
      tc.fillStyle=cell.style.backgroundColor||"#000000";
      tc.fillRect(x,y,1,1);
    });
    const scale=512/gridSize;
    const out=document.createElement("canvas");out.width=512;out.height=512;
    const oc=out.getContext("2d");oc.imageSmoothingEnabled=false;
    oc.drawImage(tempCanvas,0,0,512,512);
    const a=document.createElement("a");a.download="pixel_art.png";a.href=out.toDataURL();a.click();
  });

  [bindEscIfTerminal(goBack)?null:makeBtn("Back",goBack),colorLabel,colorPick,toolLabel,toolSel,sizeLabel,sizeSel,clearBtn,dlBtn].filter(Boolean).forEach(el=>tb.appendChild(el));

  const wrap=document.createElement("div");wrap.className="pixel-canvas-wrap";
  const grid=document.createElement("div");grid.id="pixelGrid";
  wrap.appendChild(grid);

  page.appendChild(tb);page.appendChild(wrap);
  document.body.appendChild(page);
  addCopyright();

  let gridSize=16,cells=[],painting=false,erasing=false;

  function fillCell(cell){
    if(toolSel.value==="draw")cell.style.backgroundColor=colorPick.value;
    else if(toolSel.value==="eraser")cell.style.backgroundColor="#000000";
  }

  function floodFill(startIdx,targetColor,fillColor){
    if(targetColor===fillColor)return;
    const stack=[startIdx];
    while(stack.length){
      const idx=stack.pop();
      if(idx<0||idx>=cells.length)continue;
      const bg=cells[idx].style.backgroundColor;
      const hex=bg?rgbToHex(bg):"#000000";
      if(hex.toLowerCase()!==targetColor.toLowerCase())continue;
      cells[idx].style.backgroundColor=fillColor;
      const x=idx%gridSize,y=Math.floor(idx/gridSize);
      if(x>0)stack.push(idx-1);if(x<gridSize-1)stack.push(idx+1);
      if(y>0)stack.push(idx-gridSize);if(y<gridSize-1)stack.push(idx+gridSize);
    }
  }

  function rgbToHex(rgb){
    const m=rgb.match(/\d+/g);if(!m)return"#000000";
    return"#"+m.slice(0,3).map(n=>parseInt(n).toString(16).padStart(2,"0")).join("");
  }

  function buildGrid(){
    gridSize=parseInt(sizeSel.value);
    const cellPx=Math.min(16,Math.floor(Math.min(wrap.clientWidth,wrap.clientHeight)*0.95/gridSize));
    grid.style.gridTemplateColumns=`repeat(${gridSize},${cellPx}px)`;
    grid.innerHTML="";cells=[];
    for(let i=0;i<gridSize*gridSize;i++){
      const c=document.createElement("div");c.className="px-cell";
      c.style.width=cellPx+"px";c.style.height=cellPx+"px";
      c.style.backgroundColor="#000000";
      c.addEventListener("mousedown",e=>{
        e.preventDefault();painting=true;
        if(toolSel.value==="fill"){
          const idx=cells.indexOf(c);
          const bg=c.style.backgroundColor;
          const hex=bg?rgbToHex(bg):"#000000";
          floodFill(idx,hex,colorPick.value);
        }else fillCell(c);
      });
      c.addEventListener("mouseenter",()=>{if(painting)fillCell(c);});
      grid.appendChild(c);cells.push(c);
    }
  }

  document.addEventListener("mouseup",()=>painting=false);
  sizeSel.onchange=buildGrid;
  buildGrid();
}

/* ══════════════════ ASCII ART MAKER ══════════════════ */
function showASCII(goBack){
  if(!goBack)goBack=showMenu;
  clearBody();
  const page=document.createElement("div");page.className="ascii-page";
  const tb=document.createElement("div");tb.className="ascii-toolbar";

  const charsetLabel=document.createElement("label");charsetLabel.textContent=" Charset ";
  const charsetSel=document.createElement("select");
  [["Standard","@%#*+=-:. "],["Blocks","█▓▒░ "],["Simple","#. "],["Binary","01 "]].forEach(([n,v])=>{
    const o=document.createElement("option");o.value=v;o.textContent=n;charsetSel.appendChild(o);
  });

  const widthLabel=document.createElement("label");widthLabel.textContent=" Width ";
  const widthRange=document.createElement("input");widthRange.type="range";widthRange.min=20;widthRange.max=200;widthRange.value=80;
  const widthVal=document.createElement("label");widthVal.textContent="80";
  widthRange.oninput=()=>{widthVal.textContent=widthRange.value;if(lastImg)renderImage(lastImg);};

  const invertChk=document.createElement("input");invertChk.type="checkbox";
  const invertLabel=document.createElement("label");invertLabel.textContent=" Invert ";

  const dlBtn=makeBtn("Download",()=>{
    const blob=new Blob([outputDiv.textContent],{type:"text/plain"});
    const a=document.createElement("a");a.href=URL.createObjectURL(blob);a.download="ascii_art.txt";a.click();
  });

  [bindEscIfTerminal(goBack)?null:makeBtn("Back",goBack),charsetLabel,charsetSel,widthLabel,widthRange,widthVal,invertChk,invertLabel,dlBtn].filter(Boolean).forEach(el=>tb.appendChild(el));

  const split=document.createElement("div");split.className="ascii-split";

  const inputWrap=document.createElement("div");inputWrap.className="ascii-input-wrap";
  const ta=document.createElement("textarea");ta.placeholder="Type text here for text-to-ASCII...\n\nOr drop an image onto this panel.";

  const hint=document.createElement("div");hint.className="ascii-drop-hint";hint.textContent="⬆ Type text above  |  Drop an image anywhere to convert it";

  inputWrap.appendChild(ta);inputWrap.appendChild(hint);

  const outputDiv=document.createElement("div");outputDiv.className="ascii-output";

  split.appendChild(inputWrap);split.appendChild(outputDiv);
  page.appendChild(tb);page.appendChild(split);
  document.body.appendChild(page);
  addCopyright();

  const FONT=[
    [' ',"     "],['A',"01110 10001 11111 10001 10001"],['B',"11110 10001 11110 10001 11110"],
    ['C',"01111 10000 10000 10000 01111"],['D',"11110 10001 10001 10001 11110"],
    ['E',"11111 10000 11110 10000 11111"],['F',"11111 10000 11110 10000 10000"],
    ['G',"01111 10000 10011 10001 01111"],['H',"10001 10001 11111 10001 10001"],
    ['I',"11111 00100 00100 00100 11111"],['J',"11111 00010 00010 10010 01100"],
    ['K',"10001 10010 11100 10010 10001"],['L',"10000 10000 10000 10000 11111"],
    ['M',"10001 11011 10101 10001 10001"],['N',"10001 11001 10101 10011 10001"],
    ['O',"01110 10001 10001 10001 01110"],['P',"11110 10001 11110 10000 10000"],
    ['Q',"01110 10001 10001 10011 01111"],['R',"11110 10001 11110 10010 10001"],
    ['S',"01111 10000 01110 00001 11110"],['T',"11111 00100 00100 00100 00100"],
    ['U',"10001 10001 10001 10001 01110"],['V',"10001 10001 10001 01010 00100"],
    ['W',"10001 10001 10101 11011 10001"],['X',"10001 01010 00100 01010 10001"],
    ['Y',"10001 01010 00100 00100 00100"],['Z',"11111 00010 00100 01000 11111"],
    ['0',"01110 10011 10101 11001 01110"],['1',"00100 01100 00100 00100 01110"],
    ['2',"01110 10001 00110 01000 11111"],['3',"11110 00001 00110 00001 11110"],
    ['4',"00010 00110 01010 11111 00010"],['5',"11111 10000 11110 00001 11110"],
    ['6',"01110 10000 11110 10001 01110"],['7',"11111 00001 00010 00100 00100"],
    ['8',"01110 10001 01110 10001 01110"],['9',"01110 10001 01111 00001 01110"],
    ['!',"00100 00100 00100 00000 00100"],['.',"00000 00000 00000 00000 00100"],
    [',',"00000 00000 00000 00100 01000"],['?',"01110 10001 00110 00000 00100"],
  ];
  const fontMap=new Map(FONT);

  function textToASCII(text){
    const chars=text.toUpperCase().split("");
    const rows=["","","","",""];
    chars.forEach(ch=>{
      const pattern=fontMap.get(ch)||fontMap.get(' ')||["     ","     ","     ","     ","     "];
      const lines=(typeof pattern==="string")?pattern.split(" "):["     ","     ","     ","     ","     "];
      for(let r=0;r<5;r++){
        const line=(lines[r]||"     ").replace(/0/g,"█").replace(/1/g,"█").replace(/0/g," ");
        const raw=lines[r]||"     ";
        rows[r]+=raw.replace(/1/g,"█").replace(/0/g," ")+"  ";
      }
    });
    return rows.join("\n");
  }

  let lastImg=null;
  function renderImage(img){
    lastImg=img;
    const charset=charsetSel.value;
    const chars=invertChk.checked?[...charset].reverse():[...charset];
    const width=parseInt(widthRange.value);
    const ratio=img.height/img.width;
    const height=Math.round(width*ratio*0.45);
    const tempC=document.createElement("canvas");tempC.width=width;tempC.height=height;
    const tc=tempC.getContext("2d");tc.drawImage(img,0,0,width,height);
    const d=tc.getImageData(0,0,width,height).data;
    let out="";
    for(let y=0;y<height;y++){
      for(let x=0;x<width;x++){
        const i=(y*width+x)*4;
        const bright=(d[i]*0.299+d[i+1]*0.587+d[i+2]*0.114)/255;
        const idx=Math.floor(bright*(chars.length-1));
        out+=chars[idx];
      }
      out+="\n";
    }
    outputDiv.textContent=out;
  }

  ta.oninput=()=>{if(ta.value.trim()){lastImg=null;outputDiv.textContent=textToASCII(ta.value.trim());}else outputDiv.textContent="";};
  charsetSel.onchange=()=>{if(lastImg)renderImage(lastImg);};
  invertChk.onchange=()=>{if(lastImg)renderImage(lastImg);};

  function handleImageFile(file){
    if(!file||!file.type.startsWith("image/"))return;
    const r=new FileReader();
    r.onload=e=>{const img=new Image();img.onload=()=>{ta.value="";renderImage(img);};img.src=e.target.result;};
    r.readAsDataURL(file);
  }

  page.addEventListener("dragover",e=>e.preventDefault());
  page.addEventListener("drop",e=>{e.preventDefault();handleImageFile(e.dataTransfer.files[0]);});
}

/* ══════════════════ HACKER TYPER ══════════════════ */
function showHackerTyper(goBack){
  if(!goBack)goBack=showMenu;
  clearBody();
  const page=document.createElement("div");page.className="hacker-page";
  const tb=document.createElement("div");tb.className="toolbar";

  const fromTerminal=goBack===showTerminal;
  function hackerKey(e){
    if(e.key==="Escape"){document.removeEventListener("keydown",hackerKey);if(fromTerminal)goBack();return;}
    if(e.ctrlKey||e.metaKey)return;
    e.preventDefault();
    keyCount++;
    for(let i=0;i<charsPerKey;i++){
      if(charIdx>=corpus.length)charIdx=0;
      display.textContent+=corpus[charIdx++];
    }
    display.scrollTop=display.scrollHeight;
    if(keyCount%20===0){modeI=(modeI+1)%modes.length;modeSpan.textContent="MODE: "+modes[modeI];}
    updateStatus();
  }

  if(!fromTerminal)tb.appendChild(makeBtn("Back",()=>{document.removeEventListener("keydown",hackerKey);goBack();}));
  tb.appendChild(makeBtn("Clear",()=>{display.textContent="";charIdx=0;keyCount=0;updateStatus();}));

  const display=document.createElement("div");display.className="hacker-display";
  display.textContent="// START TYPING TO BEGIN...\n";

  const status=document.createElement("div");status.className="hacker-status";
  const ksSpan=document.createElement("span");ksSpan.textContent="KEYSTROKES: 0";
  const lcSpan=document.createElement("span");lcSpan.textContent="LINES: 1";
  const modeSpan=document.createElement("span");modeSpan.textContent="MODE: NORMAL";
  [ksSpan,lcSpan,modeSpan].forEach(s=>status.appendChild(s));

  page.appendChild(display);page.appendChild(status);
  document.body.appendChild(page);document.body.appendChild(tb);
  addCopyright();

  const corpus=`#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define BUFFER_SIZE 4096
#define MAX_CONN 128
typedef struct { int fd; char buf[BUFFER_SIZE]; size_t len; } conn_t;
static conn_t pool[MAX_CONN];
static int pool_sz = 0;
void init_pool() { memset(pool, 0, sizeof(pool)); }
int add_conn(int fd) { if (pool_sz >= MAX_CONN) return -1; pool[pool_sz].fd = fd; pool_sz++; return 0; }
void remove_conn(int i) { pool[i] = pool[--pool_sz]; }
int main(int argc, char **argv) {
  int srv = socket(AF_INET, SOCK_STREAM, 0);
  struct sockaddr_in addr = {0};
  addr.sin_family = AF_INET; addr.sin_port = htons(8080); addr.sin_addr.s_addr = INADDR_ANY;
  bind(srv, (struct sockaddr *)&addr, sizeof(addr));
  listen(srv, 10); init_pool();
  printf("Server listening on port 8080\\n");
  while (1) {
    fd_set fds; FD_ZERO(&fds); FD_SET(srv, &fds);
    int maxfd = srv;
    for (int i = 0; i < pool_sz; i++) { FD_SET(pool[i].fd, &fds); if (pool[i].fd > maxfd) maxfd = pool[i].fd; }
    select(maxfd + 1, &fds, NULL, NULL, NULL);
    if (FD_ISSET(srv, &fds)) { int cli = accept(srv, NULL, NULL); add_conn(cli); }
    for (int i = 0; i < pool_sz; i++) {
      if (FD_ISSET(pool[i].fd, &fds)) {
        ssize_t n = read(pool[i].fd, pool[i].buf, BUFFER_SIZE);
        if (n <= 0) { close(pool[i].fd); remove_conn(i--); }
        else { write(pool[i].fd, pool[i].buf, n); }
      }
    }
  }
  return 0;
}

import subprocess, os, sys, hashlib, base64, json, time, threading
from pathlib import Path
from typing import Optional, List, Dict
class Orchestrator:
    def __init__(self, config_path: str):
        self.config = json.loads(Path(config_path).read_text())
        self.workers: List[threading.Thread] = []
        self._lock = threading.Lock()
        self._results: Dict[str, bytes] = {}
    def spawn(self, target, *args):
        t = threading.Thread(target=self._wrap, args=(target, args), daemon=True)
        self.workers.append(t); t.start()
    def _wrap(self, fn, args):
        key = hashlib.sha256(str(args).encode()).hexdigest()[:8]
        result = fn(*args)
        with self._lock: self._results[key] = result
    def join_all(self, timeout=30):
        for w in self.workers: w.join(timeout=timeout)
    def results(self): return dict(self._results)
def encode_payload(data: bytes) -> str: return base64.b64encode(data).decode()
def decode_payload(s: str) -> bytes: return base64.b64decode(s.encode())
def run_cmd(cmd: str) -> bytes:
    p = subprocess.run(cmd, shell=True, capture_output=True)
    return p.stdout + p.stderr
if __name__ == "__main__":
    orch = Orchestrator(sys.argv[1] if len(sys.argv)>1 else "config.json")
    cmds = ["uname -a", "df -h", "ps aux", "netstat -an", "ls /proc"]
    for c in cmds: orch.spawn(run_cmd, c)
    orch.join_all()
    for k,v in orch.results().items(): print(f"[{k}] {v[:120]}")

function decrypt(ciphertext, key) {
  const keyBytes = new TextEncoder().encode(key);
  const data = Uint8Array.from(atob(ciphertext), c => c.charCodeAt(0));
  return crypto.subtle.importKey('raw', keyBytes, {name:'AES-GCM'}, false, ['decrypt'])
    .then(k => crypto.subtle.decrypt({name:'AES-GCM', iv: data.slice(0,12)}, k, data.slice(12)))
    .then(buf => new TextDecoder().decode(buf));
}
async function fetchAndDecrypt(url, key) {
  const resp = await fetch(url, {headers:{'X-Auth': btoa(key)}});
  const ct = await resp.text();
  return await decrypt(ct, key);
}
class EventBus {
  #handlers = new Map();
  on(ev, fn) { (this.#handlers.get(ev) ?? this.#handlers.set(ev,[]).get(ev)).push(fn); return this; }
  emit(ev, ...args) { (this.#handlers.get(ev)||[]).forEach(fn=>fn(...args)); }
  off(ev, fn) { this.#handlers.set(ev,(this.#handlers.get(ev)||[]).filter(h=>h!==fn)); }
}
`;

  let charIdx=0,keyCount=0;
  const charsPerKey=3;

  function updateStatus(){
    ksSpan.textContent="KEYSTROKES: "+keyCount;
    lcSpan.textContent="LINES: "+display.textContent.split("\n").length;
  }

  let modeTimer;
  const modes=["NORMAL","SUDO","ROOT","KERNEL","MATRIX","BYPASS"];
  let modeI=0;

  document.addEventListener("keydown",hackerKey);
}

/* ══════════════════ FAKE TERMINAL (Windows CMD) ══════════════════ */
function makeGameWindow(title,w,h,buildFn,goBack){
  const overlay=document.createElement("div");overlay.className="game-window";
  const inner=document.createElement("div");inner.className="game-inner";
  let cleanup=null;
  const cleanupFn=buildFn(inner,overlay);
  if(cleanupFn)cleanup=cleanupFn;
  overlay.appendChild(inner);
  function closeGame(){
    if(cleanup)cleanup();
    document.body.removeChild(overlay);
    document.removeEventListener("keydown",onEsc,true);
    if(typeof inp!=="undefined"&&inp&&document.body.contains(inp))inp.focus();
  }
  if(goBack){
    const exitBtn=document.createElement("button");exitBtn.className="game-exit-btn";exitBtn.textContent="✕ Exit";
    exitBtn.onclick=closeGame;
    overlay.appendChild(exitBtn);
  }
  function onEsc(e){
    if(e.key==="Escape"){
      e.stopImmediatePropagation();
      closeGame();
    }
  }
  document.addEventListener("keydown",onEsc,true);
  document.body.appendChild(overlay);
}

function launchPong(goBack){
  if(typeof print==="function")print("Opening Pong... W/S to move. SPACE to start. ESC to exit. First to 11 wins.");
  makeGameWindow("PONG",null,null,(win)=>{
    const PW=14,BALL=10,SPD=4;
    const infoBar=document.createElement("div");infoBar.className="game-info";
    infoBar.innerHTML="<span>W/S</span> P1 &nbsp; <span id='pg-p2hint'><span>AI</span></span> P2 &nbsp; <span>SPACE</span> start/pause &nbsp; Score: <span id='pg-score'>0 - 0</span> &nbsp; <span id='pg-status'>Press SPACE</span>";
    const wrap=document.createElement("div");wrap.className="game-canvas-wrap";
    const cv=document.createElement("canvas");
    wrap.appendChild(cv);win.appendChild(wrap);win.appendChild(infoBar);
    const g=cv.getContext("2d");
    const W=800,H=500;
    let PH=80;
    cv.width=W;cv.height=H;
    let p1y=H/2-PH/2,p2y=H/2-PH/2;
    let bx=W/2,by=H/2,bdx=SPD,bdy=SPD*(Math.random()>0.5?1:-1);
    let s1=0,s2=0,running=false,raf=null,twoPlayer=false,gameOver=false,winner=0;
    const keys={};
    const P2KEYS=["ArrowUp","ArrowDown"];
    const P1KEYS=["w","W","s","S"];

    function checkTwoPlayer(){
      const p2active=P2KEYS.some(k=>keys[k]);
      const p1active=P1KEYS.some(k=>keys[k]);
      if(!twoPlayer&&p2active&&p1active){
        twoPlayer=true;
        const h=document.getElementById("pg-p2hint");if(h)h.innerHTML="<span>↑↓</span>";
      }
    }

    function draw(){
      g.fillStyle="#000";g.fillRect(0,0,W,H);
      g.setLineDash([12,12]);g.strokeStyle="rgba(0,255,0,0.2)";g.lineWidth=2;g.beginPath();g.moveTo(W/2,0);g.lineTo(W/2,H);g.stroke();g.setLineDash([]);
      g.fillStyle="#0f0";
      g.fillRect(16,p1y,PW,PH);g.fillRect(W-16-PW,p2y,PW,PH);
      g.beginPath();g.arc(bx,by,BALL/2,0,Math.PI*2);g.fill();
      g.font=`bold ${Math.floor(H*0.09)}px monospace`;g.textAlign="center";g.fillStyle="rgba(0,255,0,0.15)";
      g.fillText(s1,W/2-W*0.1,H*0.12);g.fillText(s2,W/2+W*0.1,H*0.12);
      if(gameOver){
        g.fillStyle="rgba(0,0,0,0.75)";g.fillRect(0,H/2-H*0.1,W,H*0.2);
        g.fillStyle="#0f0";g.font=`bold ${Math.floor(H*0.055)}px monospace`;g.textAlign="center";
        g.fillText((winner===1?"PLAYER 1":"PLAYER 2")+" WINS!",W/2,H/2+H*0.01);
        g.font=`${Math.floor(H*0.027)}px monospace`;
        g.fillText("Press R to play again",W/2,H/2+H*0.07);
      }
    }

    function update(){
      if(gameOver)return;
      checkTwoPlayer();
      if(keys["w"]||keys["W"])p1y=Math.max(0,p1y-7);
      if(keys["s"]||keys["S"])p1y=Math.min(H-PH,p1y+7);
      if(twoPlayer){
        if(keys["ArrowUp"])p2y=Math.max(0,p2y-7);
        if(keys["ArrowDown"])p2y=Math.min(H-PH,p2y+7);
      } else {
        const center=p2y+PH/2;
        if(center<by-4)p2y=Math.min(H-PH,p2y+5);else if(center>by+4)p2y=Math.max(0,p2y-5);
      }
      bx+=bdx;by+=bdy;
      if(by<=BALL/2||by>=H-BALL/2)bdy*=-1;
      if(bx-BALL/2<=30&&by>=p1y&&by<=p1y+PH){bdx=Math.abs(bdx);bdy+=(by-(p1y+PH/2))*0.1;}
      if(bx+BALL/2>=W-30-PW&&by>=p2y&&by<=p2y+PH){bdx=-Math.abs(bdx);bdy+=(by-(p2y+PH/2))*0.1;}
      const sp=Math.sqrt(bdx*bdx+bdy*bdy);if(sp>10){bdx=bdx/sp*10;bdy=bdy/sp*10;}
      if(bx<0){s2++;checkWin(2);}
      if(bx>W){s1++;checkWin(1);}
      const sc=document.getElementById("pg-score");if(sc)sc.textContent=s1+" - "+s2;
    }

    function checkWin(player){
      if((player===1&&s1>=11)||(player===2&&s2>=11)){
        gameOver=true;winner=player;running=false;
        const st=document.getElementById("pg-status");if(st)st.textContent="";
      } else {
        reset();
      }
    }

    function reset(){bx=W/2;by=H/2;bdx=SPD*(Math.random()>0.5?1:-1);bdy=SPD*(Math.random()>0.5?1:-1);running=false;const st=document.getElementById("pg-status");if(st)st.textContent="Press SPACE";}

    function loop(){draw();if(running)update();raf=requestAnimationFrame(loop);}
    loop();

    function onKey(e){
      keys[e.key]=e.type==="keydown";
      if(e.type==="keydown"){
        if(e.key===" "){e.preventDefault();if(!gameOver){running=!running;const st=document.getElementById("pg-status");if(st)st.textContent=running?"":"";};}
        if((e.key==="r"||e.key==="R")&&gameOver){s1=0;s2=0;gameOver=false;winner=0;twoPlayer=false;const h=document.getElementById("pg-p2hint");if(h)h.innerHTML="<span>AI</span>";reset();}
      }
      if([...P1KEYS,...P2KEYS," "].includes(e.key))e.preventDefault();
    }
    document.addEventListener("keydown",onKey);document.addEventListener("keyup",onKey);
    return()=>{cancelAnimationFrame(raf);document.removeEventListener("keydown",onKey);document.removeEventListener("keyup",onKey);};
  },goBack);
}

function launchTetris(goBack){
  if(typeof print==="function")print("Opening Tetris... Arrow keys to move, Up to rotate, Space to drop. ESC to exit.");
  makeGameWindow("TETRIS",null,null,(win)=>{
    const COLS=10,ROWS=20,SZ=30;
    const infoBar=document.createElement("div");infoBar.className="game-info";
    infoBar.innerHTML="<span>←→</span> move &nbsp; <span>↑</span> rotate &nbsp; <span>↓</span> soft drop &nbsp; <span>SPACE</span> hard drop &nbsp; Score: <span id='tet-score'>0</span> &nbsp; Level: <span id='tet-level'>1</span>";
    const wrap=document.createElement("div");wrap.className="game-canvas-wrap";
    const cv=document.createElement("canvas");
    cv.width=(COLS+5)*SZ;cv.height=ROWS*SZ;
    wrap.appendChild(cv);win.appendChild(wrap);win.appendChild(infoBar);
    const g=cv.getContext("2d");

    const PIECES=[
      {s:[[1,1,1,1]],c:"#0ff"},{s:[[1,0],[1,0],[1,1]],c:"#fa0"},{s:[[0,1],[0,1],[1,1]],c:"#00f"},
      {s:[[1,1],[1,1]],c:"#ff0"},{s:[[0,1,1],[1,1,0]],c:"#0f0"},{s:[[1,1,1],[0,1,0]],c:"#a0f"},
      {s:[[1,1,0],[0,1,1]],c:"#f00"},
    ];
    function rotate(s){return s[0].map((_,i)=>s.map(r=>r[i]).reverse());}
    let board=Array.from({length:ROWS},()=>Array(COLS).fill(null));
    let cur=null,curX=0,curY=0,next=null,score=0,level=1,lines=0,gameOver=false,paused=false,dropTimer=0,dropInterval=500;
    function randPiece(){return JSON.parse(JSON.stringify(PIECES[Math.floor(Math.random()*PIECES.length)]));}
    function spawn(){
      cur=next||randPiece();next=randPiece();
      curX=Math.floor(COLS/2)-Math.floor(cur.s[0].length/2);curY=0;
      if(!canPlace(cur.s,curX,curY))gameOver=true;
    }
    function canPlace(s,x,y){
      for(let r=0;r<s.length;r++)for(let c=0;c<s[r].length;c++){
        if(s[r][c]){const nx=x+c,ny=y+r;if(nx<0||nx>=COLS||ny>=ROWS)return false;if(ny>=0&&board[ny][nx])return false;}
      }return true;
    }
    function lock(){
      cur.s.forEach((r,ri)=>r.forEach((v,ci)=>{if(v&&curY+ri>=0)board[curY+ri][curX+ci]=cur.c;}));
      board=board.filter(r=>!r.every(c=>c));
      const cleared=ROWS-board.length;
      while(board.length<ROWS)board.unshift(Array(COLS).fill(null));
      lines+=cleared;score+=[0,100,300,500,800][cleared]*level;
      level=Math.floor(lines/10)+1;dropInterval=Math.max(80,500-level*40);
      const sc=document.getElementById("tet-score");if(sc)sc.textContent=score;
      const lv=document.getElementById("tet-level");if(lv)lv.textContent=level;
      spawn();
    }
    function drawBoard(){
      const W=cv.width,H=cv.height,PANEL=5*SZ,BW=COLS*SZ;
      g.fillStyle="#000";g.fillRect(0,0,W,H);
      g.strokeStyle="rgba(0,255,0,0.06)";g.lineWidth=1;
      for(let r=0;r<ROWS;r++)for(let c=0;c<COLS;c++)g.strokeRect(c*SZ,r*SZ,SZ,SZ);
      g.strokeStyle="rgba(0,255,0,0.3)";g.beginPath();g.moveTo(BW,0);g.lineTo(BW,H);g.stroke();
      board.forEach((row,r)=>row.forEach((col,c)=>{if(col){g.fillStyle=col;g.fillRect(c*SZ+1,r*SZ+1,SZ-2,SZ-2);}}));
      if(cur&&!gameOver){let gy=curY;while(canPlace(cur.s,curX,gy+1))gy++;
        cur.s.forEach((r,ri)=>r.forEach((v,ci)=>{if(v){g.fillStyle="rgba(255,255,255,0.08)";g.fillRect((curX+ci)*SZ+1,(gy+ri)*SZ+1,SZ-2,SZ-2);}}));}
      if(cur)cur.s.forEach((r,ri)=>r.forEach((v,ci)=>{if(v){g.fillStyle=cur.c;g.fillRect((curX+ci)*SZ+1,(curY+ri)*SZ+1,SZ-2,SZ-2);}}));
      g.fillStyle="#0a0a0a";g.fillRect(BW+1,0,PANEL-1,H);
      const px=BW+PANEL/2,fs=Math.max(9,Math.floor(SZ*0.38));
      g.fillStyle="#0a0";g.font=`${fs}px monospace`;g.textAlign="center";g.fillText("NEXT",px,SZ*0.8);
      if(next){const ox=BW+Math.floor((PANEL-next.s[0].length*SZ)/2),oy=Math.floor(SZ*1.2);
        next.s.forEach((r,ri)=>r.forEach((v,ci)=>{if(v){g.fillStyle=next.c;g.fillRect(ox+ci*SZ+1,oy+ri*SZ+1,SZ-2,SZ-2);}}));}
      g.fillStyle="#0a0";g.font=`${fs}px monospace`;g.fillText("SCORE",px,H-SZ*2.4);
      g.fillStyle="#0f0";g.font=`bold ${Math.floor(fs*1.2)}px monospace`;g.fillText(score,px,H-SZ*1.8);
      g.fillStyle="#0a0";g.font=`${fs}px monospace`;g.fillText("LEVEL",px,H-SZ*1.1);
      g.fillStyle="#0f0";g.font=`bold ${Math.floor(fs*1.2)}px monospace`;g.fillText(level,px,H-SZ*0.5);
      if(gameOver){g.fillStyle="rgba(0,0,0,0.75)";g.fillRect(0,H/2-SZ*1.2,BW,SZ*2.4);
        g.fillStyle="#0f0";g.font=`bold ${Math.floor(SZ*0.8)}px monospace`;g.textAlign="center";
        g.fillText("GAME OVER",BW/2,H/2-SZ*0.2);g.font=`${Math.floor(SZ*0.5)}px monospace`;g.fillText("Press R to restart",BW/2,H/2+SZ*0.8);}
    }
    let lastT=0,raf=null;
    function loop(t){
      raf=requestAnimationFrame(loop);
      if(!paused&&!gameOver){dropTimer+=t-lastT;if(dropTimer>=dropInterval){dropTimer=0;if(canPlace(cur.s,curX,curY+1))curY++;else lock();}}
      lastT=t;drawBoard();
    }
    spawn();raf=requestAnimationFrame(loop);
    function onKey(e){
      if(!document.body.contains(cv)){document.removeEventListener("keydown",onKey);return;}
      if(e.key==="r"||e.key==="R"){board=Array.from({length:ROWS},()=>Array(COLS).fill(null));score=0;level=1;lines=0;gameOver=false;dropInterval=500;cur=null;next=null;spawn();return;}
      if(gameOver||paused)return;
      if(e.key==="ArrowLeft"){if(canPlace(cur.s,curX-1,curY))curX--;}
      else if(e.key==="ArrowRight"){if(canPlace(cur.s,curX+1,curY))curX++;}
      else if(e.key==="ArrowDown"){if(canPlace(cur.s,curX,curY+1)){curY++;score++;}}
      else if(e.key==="ArrowUp"){const r=rotate(cur.s);if(canPlace(r,curX,curY))cur.s=r;}
      else if(e.key===" "){let dy=0;while(canPlace(cur.s,curX,curY+dy+1))dy++;curY+=dy;score+=dy*2;lock();}
      else if(e.key==="p"||e.key==="P"){paused=!paused;}
      if(["ArrowLeft","ArrowRight","ArrowDown","ArrowUp"," "].includes(e.key))e.preventDefault();
    }
    document.addEventListener("keydown",onKey);
    return()=>{cancelAnimationFrame(raf);document.removeEventListener("keydown",onKey);};
  },goBack);
}

function launchMinesweeper(goBack){
  if(typeof print==="function")print("Opening Minesweeper... Left-click to reveal, Right-click to flag. ESC to exit.");
  makeGameWindow("MINESWEEPER",null,null,(win)=>{
    const COLS=20,ROWS=16,MINES=50,SZ=30;
    const infoBar=document.createElement("div");infoBar.className="game-info";
    infoBar.innerHTML="Left-click: reveal &nbsp; Right-click: flag &nbsp; Mines: <span id='ms-mines'>50</span> &nbsp; Time: <span id='ms-time'>0</span>s &nbsp; <span id='ms-status'>Good luck!</span>";
    const wrap=document.createElement("div");wrap.className="game-canvas-wrap";
    const cv=document.createElement("canvas");cv.style.cursor="pointer";
    cv.width=COLS*SZ;cv.height=ROWS*SZ;
    wrap.appendChild(cv);win.appendChild(wrap);win.appendChild(infoBar);
    const g=cv.getContext("2d");
    let board=[],revealed=[],flagged=[],firstClick=true,gameOver=false,won=false,timer=0,timerIv=null;
    function init(){
      board=Array.from({length:ROWS},()=>Array(COLS).fill(0));
      revealed=Array.from({length:ROWS},()=>Array(COLS).fill(false));
      flagged=Array.from({length:ROWS},()=>Array(COLS).fill(false));
      firstClick=true;gameOver=false;won=false;timer=0;clearInterval(timerIv);
      const tm=document.getElementById("ms-time");if(tm)tm.textContent="0";
      const ms=document.getElementById("ms-mines");if(ms)ms.textContent=MINES;
      const st=document.getElementById("ms-status");if(st)st.textContent="Good luck!";
      draw();
    }
    function plantMines(avoidR,avoidC){
      let placed=0;
      while(placed<MINES){const r=Math.floor(Math.random()*ROWS),c=Math.floor(Math.random()*COLS);
        if((Math.abs(r-avoidR)>1||Math.abs(c-avoidC)>1)&&board[r][c]!==-1){board[r][c]=-1;placed++;}}
      for(let r=0;r<ROWS;r++)for(let c=0;c<COLS;c++){
        if(board[r][c]===-1)continue;let n=0;
        for(let dr=-1;dr<=1;dr++)for(let dc=-1;dc<=1;dc++){const nr=r+dr,nc=c+dc;if(nr>=0&&nr<ROWS&&nc>=0&&nc<COLS&&board[nr][nc]===-1)n++;}
        board[r][c]=n;}
    }
    function reveal(r,c){
      if(r<0||r>=ROWS||c<0||c>=COLS||revealed[r][c]||flagged[r][c])return;
      revealed[r][c]=true;
      if(board[r][c]===0)for(let dr=-1;dr<=1;dr++)for(let dc=-1;dc<=1;dc++)reveal(r+dr,c+dc);
    }
    function checkWin(){let n=0;for(let r=0;r<ROWS;r++)for(let c=0;c<COLS;c++)if(!revealed[r][c])n++;return n===MINES;}
    const COLORS=["","#4af","#0f0","#f55","#44f","#f44","#0ff","#aaa","#888"];
    function draw(){
      const W=cv.width,H=cv.height;
      g.fillStyle="#0a0a0a";g.fillRect(0,0,W,H);
      for(let r=0;r<ROWS;r++)for(let c=0;c<COLS;c++){
        const x=c*SZ,y=r*SZ,fs=Math.max(8,SZ-8);
        if(revealed[r][c]){
          g.fillStyle=board[r][c]===-1?"#300":"#111";g.fillRect(x+1,y+1,SZ-2,SZ-2);
          if(board[r][c]===-1){g.font=`${fs}px monospace`;g.textAlign="center";g.textBaseline="middle";g.fillText("💣",x+SZ/2,y+SZ/2+1);}
          else if(board[r][c]>0){g.fillStyle=COLORS[board[r][c]]||"#0f0";g.font=`bold ${fs}px monospace`;g.textAlign="center";g.textBaseline="middle";g.fillText(board[r][c],x+SZ/2,y+SZ/2);}
        } else {
          g.fillStyle=gameOver&&board[r][c]===-1?"#300":"#1a1a1a";g.fillRect(x+1,y+1,SZ-2,SZ-2);
          g.strokeStyle="rgba(0,255,0,0.2)";g.strokeRect(x+1,y+1,SZ-2,SZ-2);
          if(flagged[r][c]){g.font=`${fs}px monospace`;g.textAlign="center";g.textBaseline="middle";g.fillText("🚩",x+SZ/2,y+SZ/2+1);}
          else if(gameOver&&board[r][c]===-1){g.font=`${fs}px monospace`;g.textAlign="center";g.textBaseline="middle";g.fillText("💣",x+SZ/2,y+SZ/2+1);}
        }
        g.strokeStyle="rgba(0,255,0,0.07)";g.strokeRect(x,y,SZ,SZ);
      }
    }
    function getCell(e){
      const rect=cv.getBoundingClientRect();
      const scaleX=cv.width/rect.width,scaleY=cv.height/rect.height;
      const c=Math.floor((e.clientX-rect.left)*scaleX/SZ),r=Math.floor((e.clientY-rect.top)*scaleY/SZ);
      return{r,c};
    }
    cv.addEventListener("click",e=>{
      if(gameOver||won)return;
      const{r,c}=getCell(e);if(r<0||r>=ROWS||c<0||c>=COLS||flagged[r][c])return;
      if(firstClick){firstClick=false;plantMines(r,c);timerIv=setInterval(()=>{timer++;const tm=document.getElementById("ms-time");if(tm)tm.textContent=timer;},1000);}
      if(board[r][c]===-1){revealed[r][c]=true;gameOver=true;clearInterval(timerIv);draw();const st=document.getElementById("ms-status");if(st)st.textContent="💥 BOOM! Double-click to restart.";}
      else{reveal(r,c);draw();if(checkWin()){won=true;clearInterval(timerIv);const st=document.getElementById("ms-status");if(st)st.textContent="🎉 You win! Time: "+timer+"s";}}
    });
    cv.addEventListener("contextmenu",e=>{
      e.preventDefault();if(gameOver||won)return;
      const{r,c}=getCell(e);if(r<0||r>=ROWS||c<0||c>=COLS||revealed[r][c])return;
      flagged[r][c]=!flagged[r][c];
      const ms=document.getElementById("ms-mines");if(ms)ms.textContent=MINES-flagged.flat().filter(Boolean).length;
      draw();
    });
    cv.addEventListener("dblclick",e=>{if(gameOver||won)init();});
    init();
    return()=>{clearInterval(timerIv);};
  },goBack);
}

function launchSnake(goBack){
  if(typeof print==="function")print("Opening Snake... Arrow keys to move. SPACE to start. ESC to exit.");
  makeGameWindow("SNAKE",null,null,(win)=>{
    const COLS=30,ROWS=22,SZ=20,W=COLS*SZ,H=ROWS*SZ;
    const infoBar=document.createElement("div");infoBar.className="game-info";
    infoBar.innerHTML="<span>Arrow keys</span> steer &nbsp; <span>SPACE</span> start/pause &nbsp; Score: <span id='sn-score'>0</span> &nbsp; <span id='sn-status'>Press SPACE to start</span>";
    const wrap=document.createElement("div");wrap.className="game-canvas-wrap";
    const cv=document.createElement("canvas");cv.width=W;cv.height=H;
    wrap.appendChild(cv);win.appendChild(wrap);win.appendChild(infoBar);
    const g=cv.getContext("2d");
    let snake,dir,nextDir,food,score,running,gameOver,raf,lastT=0,interval=120;
    function rand(n){return Math.floor(Math.random()*n);}
    function placeFood(){do{food={x:rand(COLS),y:rand(ROWS)};}while(snake.some(s=>s.x===food.x&&s.y===food.y));}
    function init(){
      snake=[{x:15,y:11},{x:14,y:11},{x:13,y:11}];dir={x:1,y:0};nextDir={x:1,y:0};
      score=0;running=false;gameOver=false;interval=120;placeFood();draw();
      const sc=document.getElementById("sn-score");if(sc)sc.textContent=0;
      const st=document.getElementById("sn-status");if(st)st.textContent="Press SPACE to start";
    }
    function draw(){
      g.fillStyle="#000";g.fillRect(0,0,W,H);
      g.strokeStyle="rgba(0,255,0,0.05)";
      for(let r=0;r<ROWS;r++)for(let c=0;c<COLS;c++)g.strokeRect(c*SZ,r*SZ,SZ,SZ);
      g.fillStyle="#f55";g.beginPath();g.arc(food.x*SZ+SZ/2,food.y*SZ+SZ/2,SZ/2-1,0,Math.PI*2);g.fill();
      snake.forEach((s,i)=>{const bright=i===0?255:Math.max(60,220-i*6);g.fillStyle=`rgb(0,${bright},0)`;g.fillRect(s.x*SZ+1,s.y*SZ+1,SZ-2,SZ-2);});
      if(gameOver){
        g.fillStyle="rgba(0,0,0,0.75)";g.fillRect(0,H/2-SZ*1.6,W,SZ*3.2);
        g.fillStyle="#0f0";g.font=`bold ${SZ}px monospace`;g.textAlign="center";
        g.fillText("GAME OVER",W/2,H/2-SZ*0.4);
        g.font=`${Math.floor(SZ*0.6)}px monospace`;g.fillText("Score: "+score+"   Press R to restart",W/2,H/2+SZ*0.9);
      }
    }
    function step(){
      dir=nextDir;const head={x:snake[0].x+dir.x,y:snake[0].y+dir.y};
      if(head.x<0||head.x>=COLS||head.y<0||head.y>=ROWS||snake.some(s=>s.x===head.x&&s.y===head.y)){
        gameOver=true;running=false;draw();const st=document.getElementById("sn-status");if(st)st.textContent="Game over! Press R";return;
      }
      snake.unshift(head);
      if(head.x===food.x&&head.y===food.y){score++;interval=Math.max(60,interval-2);placeFood();const sc=document.getElementById("sn-score");if(sc)sc.textContent=score;}
      else snake.pop();
      draw();
    }
    let accum=0;
    function loop(t){raf=requestAnimationFrame(loop);accum+=t-lastT;lastT=t;if(running&&accum>=interval){accum=0;step();}else if(!gameOver)draw();}
    init();raf=requestAnimationFrame(loop);
    function onKey(e){
      if(!document.body.contains(cv)){document.removeEventListener("keydown",onKey);return;}
      if(e.key==="r"||e.key==="R"){init();return;}
      if(e.key===" "){e.preventDefault();if(!gameOver){running=!running;const st=document.getElementById("sn-status");if(st)st.textContent=running?"":"Paused";}}
      const map={"ArrowUp":{x:0,y:-1},"ArrowDown":{x:0,y:1},"ArrowLeft":{x:-1,y:0},"ArrowRight":{x:1,y:0}};
      if(map[e.key]){e.preventDefault();const nd=map[e.key];if(dir.x+nd.x!==0||dir.y+nd.y!==0)nextDir=nd;}
    }
    document.addEventListener("keydown",onKey);
    return()=>{cancelAnimationFrame(raf);document.removeEventListener("keydown",onKey);};
  },goBack);
}

function launchBreakout(goBack){
  if(typeof print==="function")print("Opening Breakout... Mouse or arrow keys to move paddle. SPACE to launch.");
  makeGameWindow("BREAKOUT",null,null,(win)=>{
    const ROWS_B=5,COLS_B=10;
    const BCOLORS=["#f55","#fa0","#ff0","#0f0","#0cf"];
    const infoBar=document.createElement("div");infoBar.className="game-info";
    infoBar.innerHTML="Mouse / <span>←→</span> move paddle &nbsp; <span>SPACE</span> launch &nbsp; Score: <span id='bk-score'>0</span> &nbsp; Lives: <span id='bk-lives'>3</span> &nbsp; <span id='bk-status'>Press SPACE</span>";
    const wrap=document.createElement("div");wrap.className="game-canvas-wrap";
    const cv=document.createElement("canvas");
    const W=800,H=560;
    cv.width=W;cv.height=H;
    wrap.appendChild(cv);win.appendChild(wrap);win.appendChild(infoBar);
    const g=cv.getContext("2d");
    const PW=Math.floor(W*0.12),PH=Math.floor(H*0.022),BALL=Math.floor(H*0.016);
    const BPAD=Math.floor(W*0.006),BW=Math.floor((W-BPAD*(COLS_B+1))/COLS_B),BH=Math.floor(H*0.04);
    const keys={};
    let px,py,bx,by,bdx,bdy,launched,bricks,score,lives,gameOver,won;
    function initBricks(){
      bricks=[];
      for(let r=0;r<ROWS_B;r++)for(let c=0;c<COLS_B;c++)
        bricks.push({x:c*(BW+BPAD)+BPAD,y:r*(BH+BPAD)+BPAD+Math.floor(H*0.08),w:BW,h:BH,alive:true,c:BCOLORS[r],row:r});
    }
    function init(){
      px=W/2-PW/2;py=H-Math.floor(H*0.05);bx=W/2;by=py-BALL-2;
      bdx=Math.floor(W*0.004)*(Math.random()>0.5?1:-1);bdy=-Math.floor(H*0.006);
      launched=false;score=0;lives=3;gameOver=false;won=false;
      initBricks();update_info();draw();
    }
    function update_info(){
      const sc=document.getElementById("bk-score");if(sc)sc.textContent=score;
      const lv=document.getElementById("bk-lives");if(lv)lv.textContent=lives;
    }
    function draw(){
      g.fillStyle="#000";g.fillRect(0,0,W,H);
      bricks.forEach(b=>{if(!b.alive)return;g.fillStyle=b.c;g.fillRect(b.x,b.y,b.w,b.h);g.strokeStyle="rgba(0,0,0,0.3)";g.strokeRect(b.x,b.y,b.w,b.h);});
      g.fillStyle="#0f0";g.fillRect(px,py,PW,PH);
      g.beginPath();g.arc(bx,by,BALL,0,Math.PI*2);g.fill();
      if(!launched){g.fillStyle="rgba(0,255,0,0.5)";g.font=`${Math.floor(H*0.025)}px monospace`;g.textAlign="center";g.fillText("SPACE to launch",W/2,H-Math.floor(H*0.08));}
      if(gameOver){g.fillStyle="rgba(0,0,0,0.75)";g.fillRect(0,H/2-H*0.08,W,H*0.16);g.fillStyle="#f55";g.font=`bold ${Math.floor(H*0.055)}px monospace`;g.textAlign="center";g.fillText("GAME OVER",W/2,H/2-H*0.01);g.font=`${Math.floor(H*0.03)}px monospace`;g.fillStyle="#0f0";g.fillText("Press R to restart",W/2,H/2+H*0.06);}
      if(won){g.fillStyle="rgba(0,0,0,0.75)";g.fillRect(0,H/2-H*0.08,W,H*0.16);g.fillStyle="#0f0";g.font=`bold ${Math.floor(H*0.045)}px monospace`;g.textAlign="center";g.fillText("YOU WIN!  Score: "+score,W/2,H/2-H*0.01);g.font=`${Math.floor(H*0.03)}px monospace`;g.fillText("Press R to restart",W/2,H/2+H*0.06);}
    }
    function update(){
      if(keys["ArrowLeft"])px=Math.max(0,px-Math.floor(W*0.009));
      if(keys["ArrowRight"])px=Math.min(W-PW,px+Math.floor(W*0.009));
      if(!launched){bx=px+PW/2;return;}
      bx+=bdx;by+=bdy;
      if(bx<=BALL||bx>=W-BALL)bdx*=-1;
      if(by<=BALL)bdy=Math.abs(bdy);
      if(by+BALL>=py&&by+BALL<=py+PH&&bx>=px&&bx<=px+PW){bdy=-Math.abs(bdy);bdx+=(bx-(px+PW/2))*0.05;}
      for(const b of bricks){
        if(!b.alive)continue;
        if(bx+BALL>b.x&&bx-BALL<b.x+b.w&&by+BALL>b.y&&by-BALL<b.y+b.h){
          b.alive=false;score+=10;
          const ox=Math.min(bx+BALL-b.x,b.x+b.w-(bx-BALL)),oy=Math.min(by+BALL-b.y,b.y+b.h-(by-BALL));
          if(ox<oy)bdx*=-1;else bdy*=-1;
          // Row 0 = furthest back = biggest boost; row 4 = front = no boost
          const boost=1+((ROWS_B-1-b.row)/(ROWS_B-1))*0.5;
          const sp=Math.sqrt(bdx*bdx+bdy*bdy);
          bdx=bdx/sp*sp*boost;bdy=bdy/sp*sp*boost;
          update_info();break;
        }
      }
      if(!bricks.some(b=>b.alive)){won=true;return;}
      if(by>H+BALL){lives--;update_info();if(lives<=0){gameOver=true;}else{bx=px+PW/2;by=py-BALL-2;launched=false;}}
      const sp=Math.sqrt(bdx*bdx+bdy*bdy),maxSp=Math.floor(H*0.022);if(sp>maxSp){bdx=bdx/sp*maxSp;bdy=bdy/sp*maxSp;}
    }
    let raf2=null;
    function loop(){raf2=requestAnimationFrame(loop);if(!gameOver&&!won)update();draw();}
    cv.addEventListener("mousemove",e=>{
      const r=cv.getBoundingClientRect();
      const scaleX=W/r.width;
      px=Math.max(0,Math.min(W-PW,(e.clientX-r.left)*scaleX-PW/2));
    });
    init();loop();
    function onKey(e){
      if(!document.body.contains(cv)){document.removeEventListener("keydown",onKey);document.removeEventListener("keyup",onKey);return;}
      keys[e.key]=e.type==="keydown";
      if(e.type==="keydown"){
        if(e.key==="r"||e.key==="R")init();
        if(e.key===" "&&!launched&&!gameOver&&!won){e.preventDefault();launched=true;}
        if(["ArrowLeft","ArrowRight"," "].includes(e.key))e.preventDefault();
      }
    }
    document.addEventListener("keydown",onKey);document.addEventListener("keyup",onKey);
    return()=>{cancelAnimationFrame(raf2);document.removeEventListener("keydown",onKey);document.removeEventListener("keyup",onKey);};
  },goBack);
}

function launch2048(goBack){
  if(typeof print==="function")print("Opening 2048... Arrow keys to slide tiles. Reach 2048!");
  makeGameWindow("2048",null,null,(win)=>{
    const SZ=90,GAP=8,N=4,W=N*SZ+(N+1)*GAP;
    const infoBar=document.createElement("div");infoBar.className="game-info";
    infoBar.innerHTML="<span>Arrow keys</span> to slide &nbsp; Score: <span id='g2-score'>0</span> &nbsp; Best: <span id='g2-best'>0</span> &nbsp; <span id='g2-status'></span>";
    const wrap=document.createElement("div");wrap.className="game-canvas-wrap";
    const cv=document.createElement("canvas");cv.width=W;cv.height=W;
    wrap.appendChild(cv);win.appendChild(wrap);win.appendChild(infoBar);
    const g=cv.getContext("2d");
    const TILE_COLORS={0:"#111",2:"#1a2a1a",4:"#1a3a1a",8:"#2a4a1a",16:"#3a5a1a",32:"#0a4a0a",64:"#0a6a0a",128:"#0a5a3a",256:"#0a4a5a",512:"#0a3a6a",1024:"#1a1a8a",2048:"#4a0a8a"};
    let board,score,best=0,gameOver,won;
    function newBoard(){return Array.from({length:N},()=>Array(N).fill(0));}
    function addRandom(b){const emp=[];for(let r=0;r<N;r++)for(let c=0;c<N;c++)if(!b[r][c])emp.push([r,c]);if(!emp.length)return;const[r,c]=emp[Math.floor(Math.random()*emp.length)];b[r][c]=Math.random()<0.9?2:4;}
    function init(){board=newBoard();addRandom(board);addRandom(board);score=0;gameOver=false;won=false;update_info();draw();}
    function update_info(){const sc=document.getElementById("g2-score");if(sc)sc.textContent=score;const be=document.getElementById("g2-best");if(be)be.textContent=best;const st=document.getElementById("g2-status");if(st)st.textContent=gameOver?"Game Over — R to restart":won?"You reached 2048!":"";}
    function slide(row){const a=row.filter(v=>v);for(let i=0;i<a.length-1;i++){if(a[i]===a[i+1]){a[i]*=2;score+=a[i];if(a[i]>=2048)won=true;a.splice(i+1,1);i++;}}while(a.length<N)a.push(0);return a;}
    function move(dir){
      let moved=false;const prev=board.map(r=>[...r]);
      if(dir==="ArrowLeft"){board=board.map(r=>slide(r));}
      else if(dir==="ArrowRight"){board=board.map(r=>slide([...r].reverse()).reverse());}
      else if(dir==="ArrowUp"){for(let c=0;c<N;c++){let col=board.map(r=>r[c]);col=slide(col);board.forEach((r,i)=>r[c]=col[i]);}}
      else if(dir==="ArrowDown"){for(let c=0;c<N;c++){let col=board.map(r=>r[c]).reverse();col=slide(col).reverse();board.forEach((r,i)=>r[c]=col[i]);}}
      moved=JSON.stringify(board)!==JSON.stringify(prev);
      if(moved){addRandom(board);if(score>best)best=score;}
      if(!board.flat().includes(0)){let canMove=false;for(let r=0;r<N;r++)for(let c=0;c<N;c++){if(r<N-1&&board[r][c]===board[r+1][c])canMove=true;if(c<N-1&&board[r][c]===board[r][c+1])canMove=true;}if(!canMove)gameOver=true;}
      update_info();draw();
    }
    function draw(){
      g.fillStyle="#0a0a0a";g.fillRect(0,0,W,W);
      for(let r=0;r<N;r++)for(let c=0;c<N;c++){
        const x=c*(SZ+GAP)+GAP,y=r*(SZ+GAP)+GAP,v=board[r][c];
        g.fillStyle=TILE_COLORS[Math.min(v,2048)]||"#6a0aaa";
        g.fillRect(x,y,SZ,SZ);
        if(v>0){
          g.fillStyle=v<=4?"#0a0":v<=64?"#0f0":"#fff";
          const fs=v<100?26:v<1000?20:16;
          g.font=`bold ${fs}px monospace`;g.textAlign="center";g.textBaseline="middle";
          g.fillText(v,x+SZ/2,y+SZ/2);
        }
      }
      if(gameOver||won){g.fillStyle="rgba(0,0,0,0.65)";g.fillRect(0,W/2-40,W,80);g.fillStyle=won?"#0f0":"#f55";g.font="bold 22px monospace";g.textAlign="center";g.fillText(won?"YOU WIN!":"GAME OVER",W/2,W/2-10);g.font="13px monospace";g.fillStyle="#0f0";g.fillText("Press R to restart",W/2,W/2+18);}
    }
    init();
    function onKey(e){
      if(!document.body.contains(cv)){document.removeEventListener("keydown",onKey);return;}
      if(e.key==="r"||e.key==="R"){init();return;}
      if(["ArrowLeft","ArrowRight","ArrowUp","ArrowDown"].includes(e.key)){e.preventDefault();if(!gameOver)move(e.key);}
    }
    document.addEventListener("keydown",onKey);
    return()=>document.removeEventListener("keydown",onKey);
  },goBack);
}

function makeAppOverlay(title,width,height,buildFn){
  const overlay=document.createElement("div");overlay.className="app-overlay";
  const win=document.createElement("div");win.className="app-window";
  win.style.width=width;win.style.height=height;
  const tb=document.createElement("div");tb.className="app-titlebar";
  const titleSpan=document.createElement("span");titleSpan.textContent=title;
  const closeBtn=document.createElement("button");closeBtn.className="app-close";closeBtn.textContent="✕";
  function closeApp(){document.body.removeChild(overlay);document.removeEventListener("keydown",onEsc,true);if(typeof inp!=="undefined"&&inp&&document.body.contains(inp))inp.focus();}
  closeBtn.onclick=closeApp;
  function onEsc(e){if(e.key==="Escape"){e.stopImmediatePropagation();closeApp();}}
  document.addEventListener("keydown",onEsc,true);
  tb.appendChild(titleSpan);tb.appendChild(closeBtn);
  win.appendChild(tb);
  buildFn(win,overlay);
  overlay.appendChild(win);
  overlay.addEventListener("mousedown",e=>{if(e.target===overlay)closeApp();});
  document.body.appendChild(overlay);
}

function launchNotepad(initialPath,initialContent,goBack){
  if(typeof print==="function")print("Opening Notepad... ESC to exit.");
  let currentPath=initialPath||null;
  let content=initialContent||"";
  makeGameWindow("Notepad",null,null,(win)=>{
    const menubar=document.createElement("div");menubar.className="app-menubar";
    const ta=document.createElement("textarea");ta.className="notepad-ta";ta.value=content;ta.spellcheck=false;
    const statusbar=document.createElement("div");statusbar.className="notepad-statusbar";
    const posSpan=document.createElement("span");posSpan.textContent="Ln 1, Col 1";
    const lenSpan=document.createElement("span");lenSpan.textContent="Length: 0";
    const encSpan=document.createElement("span");encSpan.textContent="UTF-8";
    [posSpan,lenSpan,encSpan].forEach(s=>statusbar.appendChild(s));
    const newBtn=document.createElement("button");newBtn.textContent="New";
    newBtn.onclick=()=>{if(ta.value&&!confirm("Discard unsaved changes?"))return;ta.value="";currentPath=null;updateStatus();};
    const openBtn=document.createElement("button");openBtn.textContent="Open...";
    openBtn.onclick=()=>{const pick=document.createElement("input");pick.type="file";pick.accept=".txt,.html,.js,.css,.md";pick.onchange=e=>{const f=e.target.files[0];if(!f)return;const r=new FileReader();r.onload=()=>{ta.value=r.result;currentPath=f.name;updateStatus();};r.readAsText(f);};pick.click();};
    const saveBtn=document.createElement("button");saveBtn.textContent="Save";
    saveBtn.onclick=()=>{const fname=currentPath||prompt("Save as:","untitled.txt");if(!fname)return;currentPath=fname;const blob=new Blob([ta.value],{type:"text/plain"});const a=document.createElement("a");a.href=URL.createObjectURL(blob);a.download=fname;a.click();};
    let ww=true;
    const wordWrapBtn=document.createElement("button");wordWrapBtn.textContent="Word Wrap: ON";
    wordWrapBtn.onclick=()=>{ww=!ww;ta.style.whiteSpace=ww?"pre-wrap":"pre";ta.style.overflowX=ww?"hidden":"auto";wordWrapBtn.textContent="Word Wrap: "+(ww?"ON":"OFF");};
    const btns=[newBtn,openBtn,saveBtn,wordWrapBtn];
    if(goBack){const backBtn=document.createElement("button");backBtn.textContent="← Back";backBtn.onclick=goBack;btns.unshift(backBtn);}
    btns.forEach(b=>menubar.appendChild(b));
    function updateStatus(){const lines=ta.value.substring(0,ta.selectionStart).split("\n");posSpan.textContent=`Ln ${lines.length}, Col ${lines[lines.length-1].length+1}`;lenSpan.textContent="Length: "+ta.value.length;}
    ta.oninput=updateStatus;ta.onkeyup=updateStatus;ta.onclick=updateStatus;
    win.appendChild(menubar);win.appendChild(ta);win.appendChild(statusbar);
    updateStatus();setTimeout(()=>ta.focus(),50);
  });
}

function launchCalculator(goBack){
  if(typeof print==="function")print("Opening Calculator... ESC to exit.");
  makeGameWindow("Calculator",null,null,(win)=>{
    win.style.display="flex";win.style.flexDirection="column";
    if(goBack){const mb=document.createElement("div");mb.className="app-menubar";const backBtn=document.createElement("button");backBtn.textContent="← Back";backBtn.onclick=goBack;mb.appendChild(backBtn);win.appendChild(mb);}
    const inner=document.createElement("div");
    inner.style.cssText="flex:1;display:flex;flex-direction:column;justify-content:center;align-items:center;";
    const calcWrap=document.createElement("div");
    calcWrap.style.cssText="display:flex;flex-direction:column;width:320px;background:#0a0a0a;border:1px solid #0f0;";
    let display="0",expr="",justEvaled=false;
    const exprDiv=document.createElement("div");exprDiv.className="calc-expr";exprDiv.textContent=" ";
    const dispDiv=document.createElement("div");dispDiv.className="calc-display";dispDiv.textContent="0";
    calcWrap.appendChild(exprDiv);calcWrap.appendChild(dispDiv);
    function refreshDisplay(){dispDiv.textContent=display;exprDiv.textContent=expr||" ";}
    function calcInput(val){
      if(justEvaled&&!isNaN(val)){display="0";expr="";justEvaled=false;}
      if(justEvaled&&isNaN(val)&&val!=="="){justEvaled=false;}
      if(val==="C"){display="0";expr="";justEvaled=false;}
      else if(val==="CE"){display="0";}
      else if(val==="⌫"){display=display.length>1?display.slice(0,-1):"0";}
      else if(val==="+/-"){display=display.startsWith("-")?display.slice(1):"-"+display;}
      else if(val==="%"){display=String(parseFloat(display)/100);}
      else if(val==="="){
        try{const full=expr+display;exprDiv.textContent=full+" =";const res=Function('"use strict";return('+full+')')();display=String(parseFloat(res.toFixed(10)));expr="";justEvaled=true;}
        catch{display="Error";}
      }
      else if(["+","-","×","÷"].includes(val)){const op=val==="×"?"*":val==="÷"?"/":val;expr+=display+op;display="0";}
      else if(val==="."){if(!display.includes("."))display+=".";}
      else{if(display==="0"||justEvaled){display=val;justEvaled=false;}else display+=val;if(display.length>12)display=display.slice(0,12);}
      refreshDisplay();
    }
    const grid=document.createElement("div");grid.className="calc-grid";
    [["C","CE","⌫","+/-"],["7","8","9","÷"],["4","5","6","×"],["1","2","3","-"],["0",".","%","+"],["="]].forEach(row=>row.forEach(k=>{
      const b=document.createElement("button");b.className="calc-btn";b.textContent=k;
      if(["+","-","×","÷"].includes(k))b.classList.add("op");
      if(k==="="){b.classList.add("eq");b.classList.add("wide");b.style.gridColumn="span 4";}
      if(k==="C"||k==="CE")b.classList.add("clear");
      b.onclick=()=>calcInput(k);
      grid.appendChild(b);
    }));
    calcWrap.appendChild(grid);inner.appendChild(calcWrap);win.appendChild(inner);
    function calcKey(e){
      if(!document.body.contains(calcWrap)){document.removeEventListener("keydown",calcKey);return;}
      if(e.key==="Escape")return;
      const map={"Enter":"=","Backspace":"⌫","*":"×","/":"÷"};
      const k=map[e.key]||e.key;
      if("0123456789.+-×÷CE=⌫C".includes(k)||k==="+/-"||k==="%"){e.preventDefault();calcInput(k);}
    }
    document.addEventListener("keydown",calcKey);
    refreshDisplay();
    return()=>document.removeEventListener("keydown",calcKey);
  });
}

function launchExplorer(startPath,goBack){
  if(typeof print==="function")print("Opening File Explorer... ESC to exit.");
  const startDir=startPath||"C:\\Users\\anonymous";
  let selectedPath=null;
  makeGameWindow("File Explorer",null,null,(win)=>{
    const toolRow=document.createElement("div");toolRow.className="explorer-toolbar-row";
    const bStyle="background:transparent;border:1px solid #0f0;color:#0f0;font-family:monospace;padding:3px 8px;cursor:pointer;font-size:12px;";
    const backBtn=document.createElement("button");backBtn.style.cssText=bStyle;backBtn.textContent="◀";
    const upBtn=document.createElement("button");upBtn.style.cssText=bStyle;upBtn.textContent="▲";
    const addrInput=document.createElement("input");addrInput.className="explorer-addr";addrInput.value=startDir;
    const goBtn=document.createElement("button");goBtn.style.cssText=bStyle;goBtn.textContent="Go";
    const rowBtns=[backBtn,upBtn,addrInput,goBtn];
    if(goBack){const menuBackBtn=document.createElement("button");menuBackBtn.style.cssText=bStyle;menuBackBtn.textContent="← Back";menuBackBtn.onclick=goBack;rowBtns.unshift(menuBackBtn);}
    rowBtns.forEach(el=>toolRow.appendChild(el));
    win.appendChild(toolRow);
    const body=document.createElement("div");body.className="explorer-body";
    const tree=document.createElement("div");tree.className="explorer-tree";
    const main=document.createElement("div");main.className="explorer-main";
    const itemsDiv=document.createElement("div");itemsDiv.className="explorer-items";
    main.appendChild(itemsDiv);body.appendChild(tree);body.appendChild(main);
    win.appendChild(body);
    const statusbar=document.createElement("div");statusbar.className="explorer-statusbar";
    win.appendChild(statusbar);
    let history=[],histIdx=-1;
    function getIcon(name,isDir){
      if(isDir)return"📁";
      if(name.endsWith(".exe"))return"⚙️";
      if(name.endsWith(".txt"))return"📄";
      if(name.endsWith(".html")||name.endsWith(".htm"))return"🌐";
      return"📄";
    }
    function navigate(path){
      const node=getEntry(path);
      if(node===null||typeof node!=="object"){statusbar.textContent="Cannot access: "+path;return;}
      if(histIdx<0||history[histIdx]!==path){history=history.slice(0,histIdx+1);history.push(path);histIdx++;}
      addrInput.value=path;
      tree.innerHTML="";
      ["C:\\","C:\\Users","C:\\Users\\anonymous","C:\\Users\\anonymous\\Apps","C:\\Users\\anonymous\\Games","C:\\Program Files"].forEach(p=>{
        const item=document.createElement("div");item.className="explorer-tree-item";
        if(p===path)item.classList.add("selected");
        const icons={"C:\\":  "💾","C:\\Users":"👥","C:\\Users\\anonymous":"👤","C:\\Users\\anonymous\\Apps":"🛠️","C:\\Users\\anonymous\\Games":"🎮","C:\\Program Files":"📦"};
        item.textContent=(icons[p]||"📁")+" "+p.split("\\").pop();
        item.onclick=()=>navigate(p);tree.appendChild(item);
      });
      itemsDiv.innerHTML="";selectedPath=null;
      const entries=Object.entries(node);
      if(entries.length===0){const empty=document.createElement("div");empty.style.cssText="color:#0a0;font-size:12px;padding:10px;";empty.textContent="(This folder is empty)";itemsDiv.appendChild(empty);}
      entries.forEach(([name,val])=>{
        const isDir=typeof val==="object";
        const item=document.createElement("div");item.className="explorer-item";
        const icon=document.createElement("div");icon.className="explorer-icon";icon.textContent=getIcon(name,isDir);
        const label=document.createElement("div");label.className="explorer-label";label.textContent=name;
        item.appendChild(icon);item.appendChild(label);
        item.onclick=()=>{itemsDiv.querySelectorAll(".explorer-item").forEach(i=>i.classList.remove("selected"));item.classList.add("selected");selectedPath=path+"\\"+name;statusbar.textContent=isDir?`1 folder selected: ${name}`:`1 file selected: ${name}`;};
        item.ondblclick=()=>{
          if(isDir){navigate(path+"\\"+name);}
          else{
            const fullPath=path+"\\"+name;const nodeVal=getEntry(fullPath)||val;
            if(name.endsWith(".txt")||name.endsWith(".html")||name.endsWith(".htm")||name.endsWith(".js")||name.endsWith(".css")){
              setTimeout(()=>launchNotepad(name,typeof nodeVal==="string"&&nodeVal!=="(executable)"?nodeVal:""),100);
            } else if(name.endsWith(".exe")){
              const exeMatch=Object.keys(executables).find(k=>k.toLowerCase()===name.toLowerCase());
              if(exeMatch)setTimeout(()=>executables[exeMatch](),100);
            }
          }
        };
        itemsDiv.appendChild(item);
      });
      statusbar.textContent=`${entries.length} item(s)`;
    }
    backBtn.onclick=()=>{if(histIdx>0){histIdx--;navigate(history[histIdx]);history.pop();histIdx=Math.max(0,histIdx);}};
    upBtn.onclick=()=>{const parts=addrInput.value.split("\\").filter(Boolean);if(parts.length>1){parts.pop();navigate(parts.join("\\"));}};
    goBtn.onclick=()=>navigate(addrInput.value.trim());
    addrInput.onkeydown=e=>{if(e.key==="Enter")navigate(addrInput.value.trim());};
    navigate(startDir);
  });
}

function showTerminal(goBack){
  clearBody();
  const page=document.createElement("div");page.className="term-page";
  const out=document.createElement("div");out.className="term-output";

  const inputRow=document.createElement("div");inputRow.className="term-input-row";
  const prompt=document.createElement("span");prompt.className="term-prompt";
  const inp=document.createElement("input");inp.className="term-input";inp.autocomplete="off";inp.spellcheck=false;

  inputRow.appendChild(prompt);inputRow.appendChild(inp);
  page.appendChild(out);page.appendChild(inputRow);

  if(goBack){
    const backBtn=document.createElement("button");
    backBtn.textContent="← EZ-Mode";
    backBtn.style.cssText="position:fixed;top:10px;right:10px;z-index:10;padding:6px 14px;font-size:13px;cursor:pointer;background:rgba(0,0,0,0.2);color:#0f0;border:1px solid rgba(0,255,0,0.3);font-family:monospace;";
    backBtn.onmouseenter=()=>{backBtn.style.background="rgba(0,255,0,0.15)";backBtn.style.borderColor="#0f0";};
    backBtn.onmouseleave=()=>{backBtn.style.background="rgba(0,0,0,0.2)";backBtn.style.borderColor="rgba(0,255,0,0.3)";};
    backBtn.onclick=goBack;
    document.body.appendChild(backBtn);
  }

  document.body.appendChild(page);
  addCopyright();

  const fs={
    "C:\\":{
      "Users":{},
      "Windows":{},
      "Program Files":{},
      "Program Files (x86)":{},
      "ProgramData":{},
      "Temp":{}
    },
    "C:\\Users":{
      "anonymous":{}
    },
    "C:\\Users\\anonymous":{
      "Desktop":{},
      "Documents":{},
      "Downloads":{},
      "Games":{},
      "Apps":{},
      "notepad.exe":"(executable)",
      "explorer.exe":"(executable)",
      "taskmgr.exe":"(executable)",
      "readme.txt":"Data OS 8.0.0-final - System Guide\r\n================================\r\n\r\nWELCOME\r\n-------\r\nData OS is a browser-based terminal environment with apps, games,\r\nand a full virtual filesystem. Type commands in the terminal to\r\nnavigate and launch programs.\r\n\r\n\r\nTERMINAL COMMANDS\r\n-----------------\r\ncls          - Clear the screen\r\ndir          - List files in current directory\r\ncd [folder]  - Change directory (case-insensitive)\r\nmd [name]    - Make a new folder\r\nrd [name]    - Remove a folder\r\ndel [file]   - Delete a file\r\ntype [file]  - Print a file's contents\r\ncopy [a] [b] - Copy a file\r\nmove [a] [b] - Move a file\r\nren [a] [b]  - Rename a file\r\necho [text]  - Print text to screen\r\nver          - Show OS version\r\ndate / time  - Show current date or time\r\nwhoami       - Show current user\r\nhostname     - Show computer name\r\nsysteminfo   - Show system information\r\ntasklist     - List running processes\r\nipconfig     - Show network configuration\r\nping [host]  - Ping a host\r\nset          - Show environment variables\r\nhelp [cmd]   - Get help on any command\r\nez-mode      - Open EZ-Mode\r\n\r\n\r\nAPPS\r\n----\r\nnotepad.exe  - Text editor (ESC to close)\r\nexplorer.exe - File Explorer (ESC to close)\r\ntaskmgr.exe  - Task Manager\r\n\r\nSmall apps are in C:\\Users\\anonymous\\Apps\r\ncd Apps, then type the name to launch:\r\n\r\n  calc.exe       - Calculator\r\n  htmleditor.exe - HTML Editor with live preview\r\n  urlloader.exe  - Load any URL in a frame\r\n  base64.exe     - Base64 encoder/decoder\r\n  stress.exe     - CPU Stress Test\r\n  paint.exe      - Freehand drawing canvas\r\n  pixelart.exe   - Pixel art editor\r\n  ascii.exe      - Image to ASCII art converter\r\n  hacker.exe     - Hacker Typer\r\n\r\n\r\nGAMES\r\n-----\r\nGames are in C:\\Users\\anonymous\\Games\r\n  cd Games, then type the name:\r\n\r\n  pong         - W/S to move, SPACE to start\r\n  tetris       - Arrow keys, SPACE to hard drop\r\n  minesweeper  - Left-click reveal, right-click flag\r\n  snake        - Arrow keys, SPACE to start\r\n  breakout     - Mouse or arrow keys, SPACE to launch\r\n  2048         - Arrow keys to slide tiles\r\n\r\nAll games: ESC to exit, R to restart.\r\n\r\n\r\nFILESYSTEM LAYOUT\r\n-----------------\r\nC:\\\r\n  Users\\\r\n    anonymous\\       <- Your home folder\r\n      Desktop\\\r\n      Documents\\\r\n      Downloads\\\r\n      Apps\\          <- Small apps\r\n      Games\\         <- Games\r\n  Program Files\\\r\n    Google\\\r\n      Chrome\\\r\n\r\nTip: cd is case-insensitive, so 'cd apps' works fine.\r\n",
    },
    "C:\\Users\\anonymous\\Desktop":{
      "EZ-Mode.html":"(this file)",
      "shortcut.txt":"This is a shortcut.\r\n"
    },
    "C:\\Users\\anonymous\\Documents":{
      "homework.txt":"Math: pg 34 ex 1-10\r\nEnglish: read chapter 5\r\n",
      "essay.txt":"My essay goes here.\r\n"
    },
    "C:\\Users\\anonymous\\Downloads":{},
    "C:\\Users\\anonymous\\Games":{
      "pong.exe":"(executable)",
      "tetris.exe":"(executable)",
      "minesweeper.exe":"(executable)",
      "snake.exe":"(executable)",
      "breakout.exe":"(executable)",
      "2048.exe":"(executable)",
      "doom.exe":"(executable)",
      "wolf3d.exe":"(executable)"
    },
    "C:\\Users\\anonymous\\Apps":{
      "calc.exe":"(executable)",
      "htmleditor.exe":"(executable)",
      "urlloader.exe":"(executable)",
      "base64.exe":"(executable)",
      "stress.exe":"(executable)",
      "paint.exe":"(executable)",
      "pixelart.exe":"(executable)",
      "ascii.exe":"(executable)",
      "hacker.exe":"(executable)"
    },
    "C:\\Program Files":{
      "Google":{},
      "Internet Explorer":{}
    },
    "C:\\Program Files\\Google":{
      "Chrome":{}
    },
    "C:\\Program Files\\Google\\Chrome":{
      "chrome.exe":"(executable)"
    },
    "C:\\Temp":{},
    "C:\\ProgramData":{}
  };


  const executables={
    "calc.exe":()=>launchCalculator(),
    "notepad.exe":()=>launchNotepad(null,""),
    "mspaint.exe":()=>{print("Opening Paint...");setTimeout(()=>showDraw(showTerminal),100);},
    "paint.exe":()=>{print("Opening Paint...");setTimeout(()=>showDraw(showTerminal),100);},
    "explorer.exe":()=>launchExplorer("C:\\Users\\anonymous"),
    "chrome.exe":()=>{print("Google Chrome is already running.");},
    "cmd.exe":()=>{print("Microsoft Windows [Version 10.0.19045.4894]");print("(C) Microsoft Corporation. All rights reserved.");print("");print("You are already in cmd.exe.");},
    "taskmgr.exe":()=>{
      print("Windows Task Manager");print("");
      print("Image Name                     PID  CPU   Mem Usage");
      print("========================= ======== ====  ============");
      [["System Idle Process","0","99","24 K"],["System","4","0","2,048 K"],
       ["svchost.exe","812","0","18,432 K"],["explorer.exe","2048","0","54,320 K"],
       ["chrome.exe","3120","1","210,840 K"],["cmd.exe","4200","0","3,120 K"]]
      .forEach(([n,p,c,m])=>print(`${n.padEnd(26)}${p.padStart(8)}  ${c.padStart(3)}%  ${m.padStart(12)}`));
    },
    "htmleditor.exe":()=>{print("Opening HTML Editor...");setTimeout(()=>showEditor("",showTerminal),100);},
    "urlloader.exe":()=>{print("Opening URL Loader...");setTimeout(()=>showURLPage(showTerminal),100);},
    "base64.exe":()=>{print("Opening Base64 Tool...");setTimeout(()=>showBase64(showTerminal),100);},
    "stress.exe":()=>{print("Opening CPU Stress Test...");setTimeout(()=>showStress(showTerminal),100);},
    "pixelart.exe":()=>{print("Opening Pixel Art Editor...");setTimeout(()=>showPixelArt(showTerminal),100);},
    "ascii.exe":()=>{print("Opening ASCII Art Maker...");setTimeout(()=>showASCII(showTerminal),100);},
    "hacker.exe":()=>{print("Opening Hacker Typer...");setTimeout(()=>showHackerTyper(showTerminal),100);},
    "pong.exe":()=>launchPong(),
    "tetris.exe":()=>launchTetris(),
    "minesweeper.exe":()=>launchMinesweeper(),
    "snake.exe":()=>launchSnake(),
    "breakout.exe":()=>launchBreakout(),
    "2048.exe":()=>launch2048(),
    "doom.exe":()=>{print("Loading DOOM...");setTimeout(()=>showDoom(showTerminal),100);},
    "wolf3d.exe":()=>{print("Loading Wolfenstein 3D...");setTimeout(()=>showWolf3D(showTerminal),100);},
    "EZ-Mode.html":()=>{print("Launching EZ-Mode...");setTimeout(()=>showMenu(),300);},
  };

  let user="anonymous";
  let cwd="C:\\Users\\anonymous";
  let history=[],histIdx=-1;

  function normPath(p){
    const parts=p.replace(/\//g,"\\").split("\\").filter((x,i)=>x||i===0);
    const out=[];
    for(const part of parts){
      if(part===".")continue;
      if(part===".."){if(out.length>1)out.pop();}
      else out.push(part);
    }
    return out.join("\\");
  }

  function resolvePath(p){
    if(!p)return cwd;
    p=p.trim().replace(/\//g,"\\");
    if(/^[A-Za-z]:\\/.test(p))return canonicalizePath(normPath(p));
    return canonicalizePath(normPath(cwd+"\\"+p));
  }

  function getEntry(path){
    if(path in fs)return fs[path];
    const lower=path.toLowerCase();
    const key=Object.keys(fs).find(k=>k.toLowerCase()===lower);
    return key!==undefined?fs[key]:null;
  }

  function canonicalizePath(path){
    if(path in fs)return path;
    const lower=path.toLowerCase();
    const key=Object.keys(fs).find(k=>k.toLowerCase()===lower);
    return key!==undefined?key:path;
  }

  function getParentContent(path){
    const parts=path.split("\\");
    const name=parts[parts.length-1];
    const parent=parts.slice(0,-1).join("\\");
    const parentObj=getEntry(parent);
    if(!parentObj)return null;
    const actualName=Object.keys(parentObj).find(k=>k.toLowerCase()===name.toLowerCase())||name;
    return{parent:parentObj,name:actualName,parentPath:parent};
  }

  function print(text,color=""){
    const lines=(text||"").split("\n");
    lines.forEach(l=>{
      const line=document.createElement("div");
      if(color)line.style.color=color;
      line.textContent=l;
      out.appendChild(line);
    });
    out.scrollTop=out.scrollHeight;
  }

  function updatePrompt(){prompt.textContent=cwd+">";}
  updatePrompt();

  function formatDirEntry(name,val){
    const now=new Date();
    const date=now.toLocaleDateString("en-US",{month:"2-digit",day:"2-digit",year:"numeric"});
    const time=now.toLocaleTimeString("en-US",{hour:"2-digit",minute:"2-digit",hour12:true});
    const isDir=typeof val==="object";
    if(isDir) return`${date}  ${time}    <DIR>          ${name}`;
    const size=String(typeof val==="string"?val.length:0).padStart(14);
    return`${date}  ${time}   ${size} ${name}`;
  }

  function runCmd(raw){
    const trimmed=raw.trim();
    if(!trimmed){print(cwd+">");return;}
    history.unshift(trimmed);histIdx=-1;
    print(cwd+">"+trimmed);

    const tokens=trimmed.match(/(?:[^\s"]+|"[^"]*")+/g)||[];
    const cmd=tokens[0].toLowerCase();
    const args=tokens.slice(1).map(a=>a.replace(/^"|"$/g,""));
    const argStr=args.join(" ");

    switch(cmd){
      case"cls":
        out.innerHTML="";
        break;

      case"dir":{
        const target=args[0]?resolvePath(args[0]):cwd;
        const node=getEntry(target);
        if(node===null){print(` Volume in drive C has no label.`);print(` File Not Found`,"#f55");break;}
        if(typeof node==="string"){print(` Volume in drive C has no label.`);print(` Directory of ${target}`);print("");print(formatDirEntry(target.split("\\").pop(),node));break;}
        const entries=Object.entries(node);
        print(` Volume in drive C has no label.`);
        print(` Volume Serial Number is 8A3F-1B2C`);
        print("");
        print(` Directory of ${target}`);
        print("");
        const now=new Date();
        const d=now.toLocaleDateString("en-US",{month:"2-digit",day:"2-digit",year:"numeric"});
        const t=now.toLocaleTimeString("en-US",{hour:"2-digit",minute:"2-digit",hour12:true});
        print(`${d}  ${t}    <DIR>          .`);
        print(`${d}  ${t}    <DIR>          ..`);
        entries.forEach(([name,val])=>print(formatDirEntry(name,val)));
        const dirs=entries.filter(([,v])=>typeof v==="object").length;
        const files=entries.filter(([,v])=>typeof v==="string").length;
        print("");
        print(`               ${files} File(s)`);
        print(`               ${dirs+2} Dir(s)   18,432,000,000 bytes free`);
        break;}

      case"cd":
      case"chdir":{
        if(!args[0]){print(cwd);break;}
        if(args[0]==="\\"){cwd="C:\\";updatePrompt();break;}
        const target=resolvePath(args[0]);
        const node=getEntry(target);
        if(node===null||typeof node!=="object"){
          print(`The system cannot find the path specified.`,"#f55");
        }else{cwd=target;updatePrompt();}
        break;}

      case"md":
      case"mkdir":{
        if(!args[0]){print("The syntax of the command is incorrect.","#f55");break;}
        const np=resolvePath(args[0]);
        if(getEntry(np)!==null){print(`A subdirectory or file ${args[0]} already exists.`,"#f55");break;}
        const info=getParentContent(np);
        if(!info){print("The system cannot find the path specified.","#f55");break;}
        info.parent[info.name]={};
        fs[np]={};
        break;}

      case"rd":
      case"rmdir":{
        if(!args[0]){print("The syntax of the command is incorrect.","#f55");break;}
        const np=resolvePath(args[0]);
        const node=getEntry(np);
        if(node===null){print("The system cannot find the file specified.","#f55");break;}
        if(typeof node!=="object"){print("The directory name is invalid.","#f55");break;}
        const info=getParentContent(np);
        if(info)delete info.parent[info.name];
        delete fs[np];
        break;}

      case"del":
      case"erase":{
        if(!args[0]){print("The syntax of the command is incorrect.","#f55");break;}
        const np=resolvePath(args[0]);
        const node=getEntry(np);
        const info=getParentContent(np);
        if(node===null||!info){print("Could Not Find "+args[0],"#f55");break;}
        if(typeof node==="object"){print("Access is denied.","#f55");break;}
        delete info.parent[info.name];
        break;}

      case"type":{
        if(!args[0]){print("The syntax of the command is incorrect.","#f55");break;}
        const np=resolvePath(args[0]);
        const node=getEntry(np);
        const info=getParentContent(np);
        const parentNode=getEntry(cwd);
        const fileContent=(parentNode&&typeof parentNode==="object")?parentNode[args[0]]:undefined;
        const content=node!==null?node:fileContent??null;
        if(content===null){print(`The system cannot find the file specified.`,"#f55");break;}
        if(typeof content==="object"){print("Access is denied.","#f55");break;}
        print(content==="(executable)"?"This is a binary file.":content||"");
        break;}

      case"echo":{
        if(!argStr){print("ECHO is on.");break;}
        print(argStr);
        break;}

      case"copy":{
        if(args.length<2){print("The syntax of the command is incorrect.","#f55");break;}
        const src=resolvePath(args[0]);
        const dst=resolvePath(args[1]);
        const srcNode=getEntry(src);
        const srcParent=getParentContent(src);
        const dstParent=getParentContent(dst);
        if(srcNode===null||!srcParent){print("The system cannot find the file specified.","#f55");break;}
        if(typeof srcNode==="object"){print("Access is denied.","#f55");break;}
        if(!dstParent){print("The system cannot find the path specified.","#f55");break;}
        dstParent.parent[dstParent.name]=srcNode;
        print("        1 file(s) copied.");
        break;}

      case"move":{
        if(args.length<2){print("The syntax of the command is incorrect.","#f55");break;}
        const src=resolvePath(args[0]);
        const dst=resolvePath(args[1]);
        const srcNode=getEntry(src);
        const srcInfo=getParentContent(src);
        const dstParent=getParentContent(dst);
        if(srcNode===null||!srcInfo){print("The system cannot find the file specified.","#f55");break;}
        if(!dstParent){print("The system cannot find the path specified.","#f55");break;}
        dstParent.parent[dstParent.name]=srcNode;
        delete srcInfo.parent[srcInfo.name];
        if(typeof srcNode==="object"){fs[dst]=srcNode;delete fs[src];}
        print("        1 file(s) moved.");
        break;}

      case"ren":
      case"rename":{
        if(args.length<2){print("The syntax of the command is incorrect.","#f55");break;}
        const src=resolvePath(args[0]);
        const srcInfo=getParentContent(src);
        const srcNode=getEntry(src);
        if(!srcInfo||srcNode===null){print("The system cannot find the file specified.","#f55");break;}
        srcInfo.parent[args[1]]=srcNode;
        delete srcInfo.parent[srcInfo.name];
        if(typeof srcNode==="object"){
          const newPath=srcInfo.parentPath+"\\"+args[1];
          fs[newPath]=srcNode;delete fs[src];
        }
        break;}

      case"run":
      case"start":{
        const target=args[0]||"";
        const exeName=target.split("\\").pop().toLowerCase();
        const match=Object.keys(executables).find(k=>k.toLowerCase()===exeName||k.toLowerCase()===target.toLowerCase());
        if(match){executables[match]();break;}
        const parentNode=getEntry(cwd);
        if(parentNode&&typeof parentNode==="object"&&parentNode[target]){
          const exeMatch=Object.keys(executables).find(k=>k.toLowerCase()===target.toLowerCase());
          if(exeMatch){executables[exeMatch]();break;}
          print(`'${target}' is not recognized as an executable.`,"#f55");
        }else{
          if(!target){print("The syntax of the command is incorrect.","#f55");break;}
          print(`'${target}': The system cannot find the file specified.`,"#f55");
        }
        break;}

      case"ver":
        print("");
        print("Data OS Terminal [Version 8.0.0-final]");
        print("");
        break;

      case"date":
        print(`The current date is: ${new Date().toLocaleDateString("en-US",{weekday:"short",month:"2-digit",day:"2-digit",year:"numeric"})}`);
        break;

      case"time":
        print(`The current time is: ${new Date().toLocaleTimeString("en-US",{hour:"2-digit",minute:"2-digit",second:"2-digit",hour12:false})}`);
        break;

      case"whoami":
        print(`SCHOOL-PC\\anonymous`);
        break;

      case"hostname":
        print("SCHOOL-PC");
        break;

      case"systeminfo":
        print("Host Name:                 SCHOOL-PC");
        print("OS Name:                   Data OS");
        print("OS Version:                8.0.0-final Build 19045");
        print("System Manufacturer:       Google");
        print("System Model:              Chromebook");
        print("System Type:               x64-based PC");
        print("Processor(s):              Intel(R) Celeron(R) N4020 @ 1.10GHz");
        print("Total Physical Memory:     4,096 MB");
        print("Available Physical Memory: 1,842 MB");
        print("Virtual Memory: Max Size:  5,120 MB");
        break;

      case"tasklist":{
        print("Image Name                     PID Session Name        Session#    Mem Usage");
        print("========================= ======== ================ =========== ============");
        [["System Idle Process","0","Services","0","24 K"],
         ["System","4","Services","0","2,048 K"],
         ["svchost.exe","812","Services","0","18,432 K"],
         ["explorer.exe","2048","Console","1","54,320 K"],
         ["chrome.exe","3120","Console","1","210,840 K"],
         ["audiodg.exe","3200","Services","0","14,228 K"],
         ["cmd.exe","4200","Console","1","3,120 K"]]
        .forEach(([n,p,s,sn,m])=>{
          print(`${n.padEnd(25)} ${p.padStart(8)} ${s.padEnd(16)} ${sn.padStart(11)} ${m.padStart(12)}`);
        });
        break;}

      case"ipconfig":{
        print("Windows IP Configuration");print("");
        print("Ethernet adapter Ethernet:");print("");
        print("   Connection-specific DNS Suffix  . : school.local");
        print("   IPv4 Address. . . . . . . . . . . : 192.168.1."+Math.floor(Math.random()*200+50));
        print("   Subnet Mask . . . . . . . . . . . : 255.255.255.0");
        print("   Default Gateway . . . . . . . . . : 192.168.1.1");
        break;}

      case"ping":{
        const h=args[0]||"localhost";
        print(`\nPinging ${h} with 32 bytes of data:`);
        const times=[12,14,11,13];
        let i=0;
        const iv=setInterval(()=>{
          if(!document.body.contains(out)){clearInterval(iv);return;}
          print(`Reply from ${h}: bytes=32 time=${times[i]}ms TTL=128`);
          i++;if(i>=4){
            clearInterval(iv);
            print(`\nPing statistics for ${h}:`);
            print(`    Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),`);
            print(`Approximate round trip times in milli-seconds:`);
            print(`    Minimum = 11ms, Maximum = 14ms, Average = 12ms`);
          }
        },500);
        break;}

      case"set":{
        if(!args[0]){
          ["COMPUTERNAME=SCHOOL-PC","OS=Windows_NT","PATH=C:\\Windows\\System32;C:\\Windows",
           "PATHEXT=.COM;.EXE;.BAT;.CMD","PROCESSOR_ARCHITECTURE=AMD64",
           "SystemDrive=C:","SystemRoot=C:\\Windows","TEMP=C:\\Temp","TMP=C:\\Temp",
           "USERDOMAIN=SCHOOL-PC","USERNAME=anonymous","USERPROFILE=C:\\Users\\anonymous",
           "WINDIR=C:\\Windows"].forEach(l=>print(l));
        } else {
          print(args[0]+"="+args.slice(1).join(" "));
        }
        break;}

      case"path":
        print("PATH=C:\\Windows\\System32;C:\\Windows;C:\\Program Files\\Google\\Chrome");
        break;

      case"help":{
        const helpDocs={
          "cls":      "CLS\n\nClears the terminal screen.\n\nUsage: cls",
          "dir":      "DIR [path]\n\nLists the contents of a directory.\n\nUsage: dir\n       dir Documents",
          "cd":       "CD [path]\n\nChanges the current directory.\n\nUsage: cd Documents\n       cd ..\n       cd C:\\Users\\anonymous",
          "md":       "MD [name]\n\nCreates a new directory.\n\nUsage: md myfolder",
          "rd":       "RD [name]\n\nRemoves an empty directory.\n\nUsage: rd myfolder",
          "del":      "DEL [file]\n\nDeletes a file.\n\nUsage: del notes.txt",
          "type":     "TYPE [file]\n\nDisplays the contents of a text file.\n\nUsage: type notes.txt",
          "copy":     "COPY [source] [destination]\n\nCopies a file.\n\nUsage: copy notes.txt backup.txt",
          "move":     "MOVE [source] [destination]\n\nMoves a file.\n\nUsage: move notes.txt Documents\\notes.txt",
          "ren":      "REN [oldname] [newname]\n\nRenames a file.\n\nUsage: ren notes.txt mynotes.txt",
          "echo":     "ECHO [text]\n\nPrints text to the screen.\n\nUsage: echo Hello World",
          "run":      "RUN [program]\n\nRuns an executable.\n\nUsage: run calc.exe",
          "ver":      "VER\n\nDisplays the terminal version.",
          "date":     "DATE\n\nDisplays the current date.",
          "time":     "TIME\n\nDisplays the current time.",
          "whoami":   "WHOAMI\n\nDisplays the current user.",
          "hostname": "HOSTNAME\n\nDisplays the computer name.",
          "systeminfo":"SYSTEMINFO\n\nDisplays system information.",
          "tasklist": "TASKLIST\n\nLists running processes.",
          "ipconfig": "IPCONFIG\n\nDisplays network configuration.",
          "ping":     "PING [host]\n\nPings a host.\n\nUsage: ping google.com",
          "set":      "SET\n\nDisplays environment variables.",
          "help":     "HELP [command]\n\nDisplays help.\n\nUsage: help dir",
          "ez-mode":  "EZ-MODE\n\nOpens EZ-Mode.",
        };
        if(args[0]){
          const key=args[0].toLowerCase().replace(/\.exe$/,"");
          if(helpDocs[key]){print(helpDocs[key]);}
          else{print(`This command is not supported by the help utility.`,"#f55");}
        } else {
          print("For more information on a specific command, type HELP command-name");
          print("");
          const cols=["CLS","CD / CHDIR","COPY","DATE","DEL / ERASE","DIR",
                      "ECHO","HELP","HOSTNAME","IPCONFIG","MD / MKDIR","EZ-MODE",
                      "MOVE","PATH","PING","RD / RMDIR","REN / RENAME","RUN / START",
                      "SET","SYSTEMINFO","TASKLIST","TIME","TYPE","VER","WHOAMI"];
          cols.forEach(c=>print("  "+c));
        }
        break;}

      case"ez-mode":
      case"ezmode":
      case"ez mode":
        showMenu();
        break;

      default:
        {
          const exeMatch=Object.keys(executables).find(k=>k.toLowerCase()===cmd||k.toLowerCase()===cmd+".exe");
          if(exeMatch){executables[exeMatch]();break;}
          const gameNames=["pong","tetris","minesweeper","snake","breakout","2048","doom","wolf3d"];
          if(gameNames.includes(cmd)){
            print(`'${tokens[0]}' is not in your PATH.`,"#f55");
            print(`Hint: cd C:\\Users\\anonymous\\Games  then type ${cmd}`);
            break;
          }
          const txtName=cmd.endsWith(".txt")||cmd.endsWith(".html")||cmd.endsWith(".htm")?cmd:null;
          if(txtName){
            const filePath=resolvePath(txtName);
            const fileNode=getEntry(filePath);
            const parentNode=getEntry(cwd);
            const content=fileNode!==null?fileNode:(parentNode&&typeof parentNode==="object"?parentNode[txtName]:null);
            if(content!==null&&typeof content==="string"){launchNotepad(txtName,content);break;}
          }
          print(`'${tokens[0]}' is not recognized as an internal or external command,`);
          print(`operable program or batch file.`,"#f55");
        }
    }

    print("");
  }

  print(`DATA OS 8.0.0-final`);
  print(`Type 'help' for a list of available commands.`);
  print(`Type 'ez-mode' to open EZ-Mode.`);
  print(``);
  updatePrompt();
  inp.focus();

  document.addEventListener("keydown",function termKey(e){
    if(e.key==="ArrowUp"){e.preventDefault();if(histIdx<history.length-1){histIdx++;inp.value=history[histIdx]||"";}}
    else if(e.key==="ArrowDown"){e.preventDefault();histIdx=Math.max(-1,histIdx-1);inp.value=histIdx>=0?history[histIdx]:"";}
  });

  inp.addEventListener("keydown",e=>{
    if(e.key==="Enter"){runCmd(inp.value);inp.value="";}
  });

  window._launchPong=launchPong;
  window._launchTetris=launchTetris;
  window._launchMinesweeper=launchMinesweeper;
  window._launchSnake=launchSnake;
  window._launchBreakout=launchBreakout;
  window._launch2048=launch2048;
  window._launchNotepad=launchNotepad;
  window._launchCalculator=launchCalculator;
  window._launchExplorer=launchExplorer;
}


/* ══════════════════ INSPECT MENU ══════════════════ */
function showInspect(){
  clearBody();
  const page=document.createElement("div");page.className="inspect-page";

  const tabBar=document.createElement("div");tabBar.className="inspect-tabs";

  const TABS=["Elements","Console","Network","Performance","Storage","Info"];
  const panels={};
  const tabEls={};

  TABS.forEach(name=>{
    const t=document.createElement("div");t.className="inspect-tab";t.textContent=name;
    const p=document.createElement("div");p.className="inspect-panel";
    tabEls[name]=t;panels[name]=p;
    tabBar.appendChild(t);
    t.onclick=()=>switchTab(name);
  });

  const menuTabBtn=document.createElement("div");
  menuTabBtn.className="inspect-tab";
  menuTabBtn.textContent="⬅ EZ-Mode";
  menuTabBtn.style.marginLeft="auto";
  menuTabBtn.style.color="#0f0";
  menuTabBtn.onclick=showMenu;
  tabBar.appendChild(menuTabBtn);

  function switchTab(name){
    Object.values(tabEls).forEach(t=>t.classList.remove("active"));
    Object.values(panels).forEach(p=>p.classList.remove("active"));
    tabEls[name].classList.add("active");
    panels[name].classList.add("active");
  }

  const body=document.createElement("div");body.className="inspect-body";
  TABS.forEach(n=>body.appendChild(panels[n]));
  page.appendChild(tabBar);page.appendChild(body);
  document.body.appendChild(page);
  addCopyright();

  function buildElements(){
    const p=panels["Elements"];
    p.innerHTML="";
    const tree=document.createElement("div");tree.className="inspect-el-tree";

    const fakeDOM=[
      {indent:0,html:'<span class="inspect-el-tag">&lt;html&gt;</span>'},
      {indent:1,html:'<span class="inspect-el-tag">&lt;head&gt;</span>'},
      {indent:2,html:'<span class="inspect-el-tag">&lt;meta</span> <span class="inspect-el-attr">charset=<span style="color:#0f0">"utf-8"</span></span><span class="inspect-el-tag">&gt;</span>'},
      {indent:2,html:'<span class="inspect-el-tag">&lt;title&gt;</span><span class="inspect-el-text">Data OS</span><span class="inspect-el-tag">&lt;/title&gt;</span>'},
      {indent:2,html:'<span class="inspect-el-tag">&lt;style&gt;</span><span class="inspect-el-text"> ... </span><span class="inspect-el-tag">&lt;/style&gt;</span>'},
      {indent:1,html:'<span class="inspect-el-tag">&lt;/head&gt;</span>'},
      {indent:1,html:'<span class="inspect-el-tag">&lt;body&gt;</span>'},
      {indent:2,html:'<span class="inspect-el-tag">&lt;div</span> <span class="inspect-el-attr">class=<span style="color:#0f0">"inspect-page"</span></span><span class="inspect-el-tag">&gt;</span>'},
      {indent:3,html:'<span class="inspect-el-tag">&lt;div</span> <span class="inspect-el-attr">class=<span style="color:#0f0">"inspect-tabs"</span></span><span class="inspect-el-tag">&gt;</span>'},
      {indent:4,html:'<span class="inspect-el-tag">&lt;div</span> <span class="inspect-el-attr">class=<span style="color:#0f0">"inspect-tab active"</span></span><span class="inspect-el-tag">&gt;</span><span class="inspect-el-text">Elements</span><span class="inspect-el-tag">&lt;/div&gt;</span>'},
      {indent:3,html:'<span class="inspect-el-tag">&lt;/div&gt;</span>'},
      {indent:2,html:'<span class="inspect-el-tag">&lt;/div&gt;</span>'},
      {indent:1,html:'<span class="inspect-el-tag">&lt;/body&gt;</span>'},
      {indent:0,html:'<span class="inspect-el-tag">&lt;/html&gt;</span>'},
    ];

    fakeDOM.forEach(({indent,html})=>{
      const row=document.createElement("div");
      let s="";for(let i=0;i<indent;i++)s+='<span class="inspect-el-indent"></span>';
      row.innerHTML=s+html;
      row.style.paddingLeft=(indent*4)+"px";
      tree.appendChild(row);
    });

    const styles=document.createElement("div");
    styles.style.cssText="border-top:1px solid rgba(0,255,0,0.2);margin-top:10px;padding-top:8px;color:#0a0;font-size:12px;";
    styles.innerHTML=`<div style="color:#0f0;margin-bottom:4px;">Computed Styles — .inspect-page</div>
<div>position: fixed</div><div>inset: 0</div><div>background: #0a0a0a</div>
<div>z-index: 5</div><div>display: flex</div><div>flex-direction: column</div>`;
    p.appendChild(tree);p.appendChild(styles);
  }

  const consoleLogs=[];
  function buildConsole(){
    const p=panels["Console"];p.innerHTML="";

    const out=document.createElement("div");out.className="inspect-console-out";

    function addLog(level,msg){
      consoleLogs.push({level,msg,time:new Date().toLocaleTimeString()});
      const row=document.createElement("div");row.className=`inspect-console-row ${level}`;
      const lvl=document.createElement("div");lvl.className="inspect-console-level";lvl.textContent=level.toUpperCase();
      const m=document.createElement("div");m.className="inspect-console-msg";m.textContent=msg;
      row.appendChild(lvl);row.appendChild(m);
      out.appendChild(row);out.scrollTop=out.scrollHeight;
    }

    const seed=[
      ["log","Data OS initialized"],["info","DOM content loaded in 12ms"],
      ["log","showMenu() called"],["warn","localStorage not available in this context"],
      ["log","Canvas context acquired"],["info","Worker pool ready: "+navigator.hardwareConcurrency+" threads"],
      ["log","Event listeners attached"],["info","Viewport: "+window.innerWidth+"x"+window.innerHeight],
    ];
    seed.forEach(([l,m])=>addLog(l,m));

    const inputRow=document.createElement("div");inputRow.className="inspect-console-input-row";
    const chevron=document.createElement("span");chevron.textContent="›";chevron.style.cssText="color:#0f0;font-size:18px;line-height:1;padding:0 6px;";
    const cinput=document.createElement("input");cinput.className="inspect-console-input";cinput.placeholder="Enter JS expression...";

    cinput.addEventListener("keydown",e=>{
      if(e.key!=="Enter")return;
      const expr=cinput.value.trim();if(!expr)return;
      addLog("log","› "+expr);
      try{
        const result=eval(expr);
        addLog("log",String(result)===undefined?"undefined":JSON.stringify(result)??String(result));
      }catch(err){addLog("error",err.message);}
      cinput.value="";
    });

    inputRow.appendChild(chevron);inputRow.appendChild(cinput);
    p.appendChild(out);p.appendChild(inputRow);

    const liveMessages=[
      ["log","Repaint triggered"],["info","requestAnimationFrame callback"],
      ["log","GC minor collection"],["log","Event: mousemove"],
      ["warn","Slow script detected (>16ms)"],["log","Storage quota checked"],
      ["info","Navigation entry updated"],["log","Web Worker heartbeat"],
    ];
    let li=0;
    const ticker=setInterval(()=>{
      if(!document.body.contains(out)){clearInterval(ticker);return;}
      addLog(liveMessages[li%liveMessages.length][0],liveMessages[li%liveMessages.length][1]);
      li++;
    },3500);
  }

  function buildNetwork(){
    const p=panels["Network"];p.innerHTML="";

    const header=document.createElement("div");
    header.style.cssText="display:flex;gap:0;border-bottom:1px solid #0f0;padding:4px 0;font-size:11px;color:#0a0;margin-bottom:4px;";
    header.innerHTML='<div style="min-width:40px">Status</div><div style="min-width:55px">Method</div><div style="flex:1">URL</div><div style="min-width:70px">Type</div><div style="min-width:60px;text-align:right">Size</div><div style="min-width:60px;text-align:right;padding-right:6px">Time</div>';
    p.appendChild(header);

    const requests=[
      {status:200,method:"GET",url:"https://data-os.local/",type:"document",size:"14.2 kB",time:"42 ms"},
      {status:200,method:"GET",url:"https://data-os.local/favicon.ico",type:"image",size:"1.1 kB",time:"8 ms"},
      {status:304,method:"GET",url:"https://fonts.googleapis.com/css2",type:"stylesheet",size:"0 B",time:"31 ms"},
      {status:200,method:"GET",url:"https://cdn.jsdelivr.net/npm/monospace@1.0/index.js",type:"script",size:"22.8 kB",time:"87 ms"},
      {status:200,method:"POST",url:"https://data-os.local/api/log",type:"fetch",size:"128 B",time:"19 ms"},
      {status:404,method:"GET",url:"https://data-os.local/manifest.json",type:"fetch",size:"0 B",time:"11 ms"},
      {status:200,method:"GET",url:"https://data-os.local/worker.js",type:"script",size:"3.4 kB",time:"14 ms"},
      {status:206,method:"GET",url:"https://data-os.local/assets/bg.webp",type:"image",size:"58.3 kB",time:"134 ms"},
      {status:200,method:"OPTIONS",url:"https://data-os.local/api/ping",type:"preflight",size:"0 B",time:"6 ms"},
      {status:200,method:"GET",url:"https://data-os.local/api/ping",type:"fetch",size:"44 B",time:"22 ms"},
    ];

    requests.forEach(r=>{
      const row=document.createElement("div");row.className="inspect-net-row";
      const sc=r.status<300?"#0f0":r.status<400?"#fa0":"#f55";
      row.innerHTML=`<div class="inspect-net-status" style="color:${sc}">${r.status}</div><div class="inspect-net-method">${r.method}</div><div class="inspect-net-url">${r.url}</div><div class="inspect-net-type">${r.type}</div><div class="inspect-net-size">${r.size}</div><div class="inspect-net-time">${r.time}</div>`;
      p.appendChild(row);
    });

    const summary=document.createElement("div");
    summary.style.cssText="margin-top:10px;padding-top:8px;border-top:1px solid rgba(0,255,0,0.2);font-size:12px;color:#0a0;";
    summary.textContent=`${requests.length} requests | 100.2 kB transferred | Finish: 134 ms | DOMContentLoaded: 48 ms | Load: 141 ms`;
    p.appendChild(summary);
  }

  function buildPerformance(){
    const p=panels["Performance"];p.innerHTML="";

    const metrics=[
      ["FCP (First Contentful Paint)","38 ms","#0f0"],
      ["LCP (Largest Contentful Paint)","94 ms","#0f0"],
      ["TTI (Time to Interactive)","121 ms","#0f0"],
      ["TBT (Total Blocking Time)","0 ms","#0f0"],
      ["CLS (Cumulative Layout Shift)","0.00","#0f0"],
      ["FID (First Input Delay)","< 1 ms","#0f0"],
      ["Script Evaluation","14 ms","#0f0"],
      ["Style Recalculation","3 ms","#0f0"],
      ["Layout","2 ms","#0f0"],
      ["Paint","1 ms","#0f0"],
      ["Composite Layers","1 ms","#0f0"],
    ];

    const sec=document.createElement("div");sec.className="inspect-section";
    const h=document.createElement("h3");h.textContent="Core Web Vitals";sec.appendChild(h);
    metrics.forEach(([k,v,c])=>{
      const row=document.createElement("div");row.className="inspect-row";
      row.innerHTML=`<span class="inspect-key">${k}</span><span class="inspect-val" style="color:${c}">${v}</span>`;
      sec.appendChild(row);
    });
    p.appendChild(sec);

    const fpsSec=document.createElement("div");fpsSec.className="inspect-section";
    const fpsH=document.createElement("h3");fpsH.textContent="Live Frame Rate";fpsSec.appendChild(fpsH);
    const fpsRow=document.createElement("div");fpsRow.className="inspect-row";
    const fpsKey=document.createElement("span");fpsKey.className="inspect-key";fpsKey.textContent="FPS";
    const fpsVal=document.createElement("span");fpsVal.className="inspect-val";fpsVal.textContent="--";
    fpsRow.appendChild(fpsKey);fpsRow.appendChild(fpsVal);
    fpsSec.appendChild(fpsRow);

    const memRow=document.createElement("div");memRow.className="inspect-row";
    const memKey=document.createElement("span");memKey.className="inspect-key";memKey.textContent="JS Heap";
    const memVal=document.createElement("span");memVal.className="inspect-val";
    memVal.textContent=performance.memory?`${(performance.memory.usedJSHeapSize/1048576).toFixed(1)} MB / ${(performance.memory.jsHeapSizeLimit/1048576).toFixed(1)} MB`:"N/A";
    memRow.appendChild(memKey);memRow.appendChild(memVal);
    fpsSec.appendChild(memRow);

    p.appendChild(fpsSec);

    let lastT=performance.now(),frames=0;
    function tick(t){
      if(!document.body.contains(fpsVal))return;
      frames++;
      if(t-lastT>=1000){fpsVal.textContent=frames+" fps";frames=0;lastT=t;}
      requestAnimationFrame(tick);
    }
    requestAnimationFrame(tick);
  }

  function buildStorage(){
    const p=panels["Storage"];p.innerHTML="";

    const cookiesSec=document.createElement("div");cookiesSec.className="inspect-section";
    const ch=document.createElement("h3");ch.textContent="Cookies";cookiesSec.appendChild(ch);
    const fakeCookies=[
      ["session_id","a3f92b1c8d44e7f0","session","data-os.local","/"],
      ["theme","dark","persistent","data-os.local","/"],
      ["user_pref","monospace%3A1","persistent","data-os.local","/"],
    ];
    const cHeader=document.createElement("div");cHeader.style.cssText="display:flex;gap:8px;font-size:11px;color:#0a0;border-bottom:1px solid rgba(0,255,0,0.2);padding-bottom:4px;margin-bottom:4px;";
    cHeader.innerHTML="<span style='flex:1'>Name</span><span style='flex:1'>Value</span><span style='min-width:80px'>Type</span><span style='flex:1'>Domain</span><span style='min-width:40px'>Path</span>";
    cookiesSec.appendChild(cHeader);
    fakeCookies.forEach(([n,v,t,d,pa])=>{
      const row=document.createElement("div");row.style.cssText="display:flex;gap:8px;font-size:12px;border-bottom:1px solid rgba(0,255,0,0.06);padding:2px 0;";
      row.innerHTML=`<span style='flex:1;color:#4af'>${n}</span><span style='flex:1'>${v}</span><span style='min-width:80px;color:#fa0'>${t}</span><span style='flex:1'>${d}</span><span style='min-width:40px'>${pa}</span>`;
      cookiesSec.appendChild(row);
    });
    p.appendChild(cookiesSec);

    const lsSec=document.createElement("div");lsSec.className="inspect-section";
    const lsH=document.createElement("h3");lsH.textContent="localStorage";lsSec.appendChild(lsH);
    try{
      const keys=Object.keys(localStorage);
      if(keys.length===0){const e=document.createElement("div");e.style.color="#0a0";e.textContent="(empty)";lsSec.appendChild(e);}
      else keys.forEach(k=>{
        const row=document.createElement("div");row.className="inspect-row";
        row.innerHTML=`<span class="inspect-key">${k}</span><span class="inspect-val">${localStorage.getItem(k)}</span>`;
        lsSec.appendChild(row);
      });
    }catch(e){const d=document.createElement("div");d.style.color="#f55";d.textContent="localStorage unavailable: "+e.message;lsSec.appendChild(d);}
    p.appendChild(lsSec);

    const ssSec=document.createElement("div");ssSec.className="inspect-section";
    const ssH=document.createElement("h3");ssH.textContent="sessionStorage";ssSec.appendChild(ssH);
    try{
      const keys=Object.keys(sessionStorage);
      if(keys.length===0){const e=document.createElement("div");e.style.color="#0a0";e.textContent="(empty)";ssSec.appendChild(e);}
      else keys.forEach(k=>{
        const row=document.createElement("div");row.className="inspect-row";
        row.innerHTML=`<span class="inspect-key">${k}</span><span class="inspect-val">${sessionStorage.getItem(k)}</span>`;
        ssSec.appendChild(row);
      });
    }catch(e){const d=document.createElement("div");d.style.color="#f55";d.textContent="sessionStorage unavailable: "+e.message;ssSec.appendChild(d);}
    p.appendChild(ssSec);
  }

  function buildInfo(){
    const p=panels["Info"];p.innerHTML="";

    const nav=navigator;const scr=screen;

    const sections=[
      ["Browser",[
        ["User Agent",nav.userAgent],
        ["Platform",nav.platform],
        ["Language",nav.language],
        ["Languages",nav.languages?.join(", ")||"N/A"],
        ["Online",nav.onLine?"✓ Yes":"✗ No"],
        ["Cookie Enabled",nav.cookieEnabled?"✓ Yes":"✗ No"],
        ["Do Not Track",nav.doNotTrack||"N/A"],
        ["Hardware Concurrency",nav.hardwareConcurrency+" cores"],
        ["Device Memory",(nav.deviceMemory||"N/A")+" GB"],
      ]],
      ["Screen",[
        ["Resolution",scr.width+"×"+scr.height],
        ["Available",scr.availWidth+"×"+scr.availHeight],
        ["Color Depth",scr.colorDepth+" bit"],
        ["Pixel Ratio",window.devicePixelRatio+"x"],
        ["Orientation",scr.orientation?.type||"N/A"],
      ]],
      ["Window",[
        ["Inner Size",window.innerWidth+"×"+window.innerHeight],
        ["Outer Size",window.outerWidth+"×"+window.outerHeight],
        ["Scroll X",window.scrollX],
        ["Scroll Y",window.scrollY],
        ["Location",location.href],
        ["Protocol",location.protocol],
      ]],
      ["Performance",[
        ["Navigation Start",new Date(performance.timeOrigin).toLocaleString()],
        ["Page Load Time",(performance.now()).toFixed(1)+" ms"],
        ["JS Heap Used",performance.memory?(performance.memory.usedJSHeapSize/1048576).toFixed(2)+" MB":"N/A"],
        ["JS Heap Total",performance.memory?(performance.memory.totalJSHeapSize/1048576).toFixed(2)+" MB":"N/A"],
        ["JS Heap Limit",performance.memory?(performance.memory.jsHeapSizeLimit/1048576).toFixed(2)+" MB":"N/A"],
      ]],
    ];

    sections.forEach(([title,rows])=>{
      const sec=document.createElement("div");sec.className="inspect-section";
      const h=document.createElement("h3");h.textContent=title;sec.appendChild(h);
      rows.forEach(([k,v])=>{
        const row=document.createElement("div");row.className="inspect-row";
        row.innerHTML=`<span class="inspect-key">${k}</span><span class="inspect-val">${v}</span>`;
        sec.appendChild(row);
      });
      p.appendChild(sec);
    });
  }

  buildElements();buildConsole();buildNetwork();buildPerformance();buildStorage();buildInfo();
  switchTab("Elements");
}

// Boot into startup screen
showStartup();
</script>
</body>
</html>
