mapspinner 0.1.1

package/scripts/backend-ab.mjs

@@ -0,0 +1,88 @@
+// backend-ab.mjs -- the "is this GPU/backend-keyed?" one-command answer (2026-06-12 tooling; the
+// question that cost a full day on the FXC per-callsite hunt). Launches TWO Chromes against the
+// live server -- default ANGLE (d3d11 on Windows) and vulkan -- parks BOTH at the same pose, and
+// prints renderer string + luminance stats + a verdict, saving side-by-side screenshots to .gm/.
+//
+//   node scripts/backend-ab.mjs                      # deterministic lowland pose
+//   node scripts/backend-ab.mjs 0.21 0.43 0.87 5     # camDir x y z + altKm
+//
+// Needs: server.js on :8080, Chrome installed. Cold d3d11 compile is ONCE per profile (cached after).
+import { spawn } from 'child_process';
+import fs from 'fs';
+
+const CHROME = ['C:/Program Files/Google/Chrome/Application/chrome.exe',
+                'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'].find(p => fs.existsSync(p));
+const [dx, dy, dz, altKm] = process.argv.slice(2).map(Number);
+const havePose = [dx, dy, dz].every(Number.isFinite);
+
+const CFG = [
+  { name: 'd3d11',  port: 9231, args: [] },
+  { name: 'vulkan', port: 9232, args: ['--use-angle=vulkan'] },
+];
+
+async function cdp(port) {
+  const ver = await (await fetch(`http://localhost:${port}/json/version`)).json();
+  const list = await (await fetch(`http://localhost:${port}/json`)).json();
+  const pg = list.find(t => t.type === 'page' && t.url.includes('localhost:8080'));
+  const ws = new WebSocket(ver.webSocketDebuggerUrl);
+  await new Promise((res, rej) => { ws.onopen = res; ws.onerror = rej; });
+  let seq = 0; const pending = new Map();
+  ws.onmessage = (ev) => { const m = JSON.parse(ev.data);
+    if (m.id && pending.has(m.id)) { const { res, rej } = pending.get(m.id); pending.delete(m.id);
+      m.error ? rej(new Error(m.error.message)) : res(m.result); } };
+  const send = (method, params = {}, sessionId) => new Promise((res, rej) => {
+    const id = ++seq; pending.set(id, { res, rej });
+    ws.send(JSON.stringify(sessionId ? { id, method, params, sessionId } : { id, method, params })); });
+  const { sessionId } = await send('Target.attachToTarget', { targetId: pg.id, flatten: true });
+  await send('Runtime.enable', {}, sessionId);
+  // foreground so the compile poll runs at full rate (background rAF throttling)
+  await fetch(`http://localhost:${port}/json/activate/${pg.id}`).catch(() => {});
+  const evalIn = async (expression) => {
+    const r = await send('Runtime.evaluate', { expression, awaitPromise: true, returnByValue: true }, sessionId);
+    if (r.exceptionDetails) throw new Error((r.exceptionDetails.exception?.description || r.exceptionDetails.text).slice(0, 300));
+    return r.result.value; };
+  return { evalIn, send, sessionId, ws };
+}
+
+const POSE = havePose
+  ? `const u0=[${dx},${dy},${dz}];const l0=Math.hypot(...u0);const land={u:[u0[0]/l0,u0[1]/l0,u0[2]/l0]};`
+  : `let land=null;for(let i=0;i<3000&&!land;i++){const y=1-2*(i+0.5)/3000,rr=Math.sqrt(Math.max(0,1-y*y)),t=i*2.399963229;
+       const u=[Math.cos(t)*rr,y,Math.sin(t)*rr];const h=sg(u);if(h>200&&h<900&&Math.abs(y)<0.5)land={u,h};}`;
+
+async function measure(name, port) {
+  const c = await cdp(port);
+  for (;;) { const st = await c.evalIn(`window.__planetOrchStatus||'init'`).catch(() => 'nav');
+    if (st === 'ready') break; await new Promise(r => setTimeout(r, 5000)); }
+  const out = await c.evalIn(`(async()=>{
+    const d=window.__diag; await d.probeWarm();
+    const sg=window.__planetOrch.render.sampleGroundM;
+    ${POSE}
+    const camC=window.__dbg.cam,latC=Math.asin(land.u[1]),lonC=Math.atan2(land.u[0],land.u[2]);
+    camC.sunLatBase=Math.max(-1.4,latC-0.5);camC.sunLonBase=lonC;camC.sunLonAccum=0;camC.timeScale=0;
+    await d.aimDir(land.u, ${Number.isFinite(altKm) ? altKm : 2}, 50);
+    const A=d._read(); let n=0,s=0,s2=0,grey=0;
+    for(let i=0;i<A.px.length;i+=28){const r0=A.px[i],g0=A.px[i+1],b0=A.px[i+2];
+      const lum=0.2126*r0+0.7152*g0+0.0722*b0;n++;s+=lum;s2+=lum*lum;
+      const mx=Math.max(r0,g0,b0),mn=Math.min(r0,g0,b0);if(mx>30&&(mx-mn)<18)grey++;}
+    const mean=s/n,sd=Math.sqrt(Math.max(0,s2/n-mean*mean));
+    return {gpu:(window.__gpuRenderer||'').slice(0,70),lumMean:+mean.toFixed(1),lumSD:+sd.toFixed(2),greyFrac:+(grey/n).toFixed(3)};
+  })()`);
+  const shot = await c.send('Page.captureScreenshot', { format: 'png' }, c.sessionId);
+  fs.writeFileSync(`.gm/ab-${name}.png`, Buffer.from(shot.data, 'base64'));
+  c.ws.close();
+  return out;
+}
+
+for (const cfg of CFG) {
+  spawn(CHROME, [`--user-data-dir=C:/dev/tv8/.gm/tmp/ab-${cfg.name}`, `--remote-debugging-port=${cfg.port}`,
+    '--no-first-run', '--no-default-browser-check', ...cfg.args, 'http://localhost:8080/planet.html'],
+    { detached: true, stdio: 'ignore' }).unref();
+}
+await new Promise(r => setTimeout(r, 8000));
+const results = {};
+for (const cfg of CFG) results[cfg.name] = await measure(cfg.name, cfg.port);
+const dSD = Math.abs(results.d3d11.lumSD - results.vulkan.lumSD);
+const dGrey = Math.abs(results.d3d11.greyFrac - results.vulkan.greyFrac);
+console.log(JSON.stringify({ ...results,
+  verdict: (dSD > 5 || dGrey > 0.15) ? 'BACKEND-DIVERGENT (suspect FXC translation -- see AGENTS.md FXC section)' : 'backends agree',
+  screenshots: ['.gm/ab-d3d11.png', '.gm/ab-vulkan.png'] }, null, 1));

package/scripts/dev-chrome.cmd

@@ -0,0 +1,22 @@
+@echo off
+rem TV8 dev Chrome launcher -- kills the 150s cold shader compile (measured 2026-06-10).
+rem
+rem The ~150s cold compile of terrain.glsl is the ANGLE D3D11 backend's FXC
+rem HLSL-optimize pass (default Chrome on Windows). Switching the ANGLE backend
+rem removes FXC entirely; same shader source, measured cold shaderCompileMs:
+rem   d3d11 (default) : 152379 ms
+rem   opengl          :   4653 ms cold / 96 ms warm (NVIDIA GL driver cache)
+rem   vulkan          :    140 ms
+rem Every shader EDIT recompiles cold, so on vulkan the edit loop is ~0.1s not 150s.
+rem
+rem Usage: scripts\dev-chrome.cmd [gl|d3d11]   (default: vulkan)
+rem A persistent profile keeps driver/browser caches warm across runs.
+
+set BACKEND=vulkan
+if /i "%1"=="gl"    set BACKEND=gl
+if /i "%1"=="d3d11" set BACKEND=d3d11
+
+set CHROME="C:\Program Files\Google\Chrome\Application\chrome.exe"
+if not exist %CHROME% set CHROME="C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"
+
+%CHROME% --user-data-dir="%~dp0..\.gm\tmp\chrome-dev-%BACKEND%" --use-angle=%BACKEND% --remote-debugging-port=9222 --no-first-run --no-default-browser-check http://localhost:8080/

package/scripts/verify.mjs

@@ -0,0 +1,69 @@
+// verify.mjs -- TV8 permanent make-sure-it-works runner (2026-06-11 policy: every render/shader
+// fix is verified against the LIVE page before commit; compile-clean alone never ships).
+//
+// Drives the in-page witness suite (window.__diag.verifyAll / coastWitness / materialWitness /
+// shadeKeyWitness / limbScan / hazeProbe ... in planet.html) over RAW CDP using Node's built-in
+// WebSocket -- no relay, no per-call execution cap, no session recycling, zero dependencies.
+//
+// Usage:
+//   node scripts/verify.mjs                  # full suite (__diag.verifyAll)
+//   node scripts/verify.mjs materialWitness  # one probe
+//   node scripts/verify.mjs "expr"           # any expression on the planet page (await'ed)
+// Needs: dev server on :8080 and a chrome with --remote-debugging-port=9222 (headless ok):
+//   chrome --headless=new --remote-debugging-port=9222 --user-data-dir=.gm/.cdp-profile about:blank
+// Exit code 0 = pass, 1 = fail/error. Prints the JSON verdict.
+
+const CDP_HTTP = process.env.CDP_URL || 'http://localhost:9222';
+const PAGE_URL = process.env.PAGE_URL || 'http://localhost:8080/planet.html';
+const probe = process.argv[2] || 'verifyAll';
+
+const ver = await (await fetch(CDP_HTTP + '/json/version')).json();
+const ws = new WebSocket(ver.webSocketDebuggerUrl);
+await new Promise((res, rej) => { ws.onopen = res; ws.onerror = rej; });
+
+let seq = 0; const pending = new Map();
+ws.onmessage = (ev) => {
+  const m = JSON.parse(ev.data);
+  if (m.id && pending.has(m.id)) { const { res, rej } = pending.get(m.id); pending.delete(m.id);
+    m.error ? rej(new Error(m.error.message)) : res(m.result); }
+};
+const send = (method, params = {}, sessionId) => new Promise((res, rej) => {
+  const id = ++seq; pending.set(id, { res, rej });
+  ws.send(JSON.stringify(sessionId ? { id, method, params, sessionId } : { id, method, params }));
+});
+
+const { targetId } = await send('Target.createTarget', { url: PAGE_URL });
+const { sessionId } = await send('Target.attachToTarget', { targetId, flatten: true });
+await send('Runtime.enable', {}, sessionId);
+
+const evalIn = async (expression, awaitPromise = true) => {
+  const r = await send('Runtime.evaluate', { expression, awaitPromise, returnByValue: true }, sessionId);
+  if (r.exceptionDetails) throw new Error(r.exceptionDetails.text + ' ' + (r.exceptionDetails.exception?.description || '').slice(0, 300));
+  return r.result.value;
+};
+
+// wait for the orchestrator (cold shader compile can take minutes on SwiftShader)
+const deadline = Date.now() + 8 * 60 * 1000;
+// Close the created page on EVERY exit path (perf sweep follow-up 2026-06-11: early-exit/killed runs
+// leaked one headless planet.html per run; leaked pages poll /cmd and steal live-tab diagnostics).
+const closeTarget = () => send('Target.closeTarget', { targetId }).catch(() => {});
+process.on('SIGINT', async () => { await closeTarget(); process.exit(130); });
+process.on('SIGTERM', async () => { await closeTarget(); process.exit(143); });
+for (;;) {
+  const st = await evalIn('window.__planetOrchStatus || "init"', false).catch(() => 'navigating');
+  if (st === 'ready') break;
+  if (st === 'error') { console.log(JSON.stringify({ pass: false, err: 'orch-error' })); await closeTarget(); process.exit(1); }
+  if (Date.now() > deadline) { console.log(JSON.stringify({ pass: false, err: 'ready-timeout' })); await closeTarget(); process.exit(1); }
+  await new Promise(r => setTimeout(r, 4000));
+}
+
+const expr = /^[A-Za-z]\w*$/.test(probe)
+  ? `window.__diag.${probe}()`
+  : probe;
+let verdict;
+try { verdict = await evalIn(`(async()=>{ const r = await (${expr}); return r; })()`); }
+catch (e) { verdict = { pass: false, err: String(e.message || e).slice(0, 500) }; }
+
+await closeTarget();
+console.log(JSON.stringify(verdict, null, 1));
+process.exit(verdict && (verdict.pass || verdict.ok) ? 0 : 1);

package/server.js

@@ -0,0 +1,127 @@
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const PORT = process.env.PORT ? parseInt(process.env.PORT) : 8080;
+// Static file server for the GPU one-fractal planet (planet.html + src/*.js + shaders/*.glsl).
+// No C++/wasm binary, no capture/diag sinks (the old GPU-capture pipeline is deleted).
+const MIME_TYPES = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.mjs': 'text/javascript; charset=utf-8',   // ES module imports require a JS MIME (browser rejects octet-stream)
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.css': 'text/css',
+  '.glsl': 'text/plain; charset=utf-8',
+};
+
+const server = http.createServer((req, res) => {
+  // Set COOP/COEP headers for SharedArrayBuffer support
+  res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
+  res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');
+  res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+  // Disable caching so iterative dev edits show up on reload
+  res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0');
+  res.setHeader('Pragma', 'no-cache');
+  res.setHeader('Expires', '0');
+
+  const urlPath = req.url.split('?')[0];
+
+  // DIAG SINK (re-hosted 2026-06-07, user: 'it wants to contact /diag, we're missing diagnostic info by
+  // not hosting that'). planet.html postDiag() POSTs a per-frame JSON line; without a handler it 404s and
+  // the live diagnostic stream is lost. The last 200 lines are kept in an in-memory ring so a headless
+  // agent can GET /diag/tail and read the live render state (face/alt/quads/glError/height) WITHOUT a
+  // browser tool. (The old capture/diag.ndjson file append was a dead ENOENT no-op after capture/ was
+  // deleted in c131284 -- removed 2026-06-11; the ring is the only consumer anyone reads.)
+  if (urlPath === '/diag' && req.method === 'POST') {
+    let body = '';
+    req.on('data', c => { body += c; if (body.length > 1e6) req.destroy(); });
+    req.on('end', () => {
+      try {
+        const line = body.trim();
+        if (line) {
+          server._diagRing = server._diagRing || [];
+          server._diagRing.push(line);
+          if (server._diagRing.length > 200) server._diagRing.shift();
+        }
+      } catch (_) {}
+      res.writeHead(204); res.end();
+    });
+    return;
+  }
+  if (urlPath === '/diag/tail') {
+    const ring = server._diagRing || [];
+    const n = Math.min(ring.length, parseInt((req.url.split('?')[1] || '').replace(/^n=/, '')) || 30);
+    res.writeHead(200, { 'Content-Type': 'application/x-ndjson; charset=utf-8' });
+    res.end(ring.slice(-n).join('\n') + '\n');
+    return;
+  }
+  if (urlPath === '/diag/clear') { server._diagRing = []; res.writeHead(204); res.end(); return; }
+
+  // AGENT COMMAND CHANNEL (2026-06-07, user: 'maximize live code execution + hot reloading'). Lets a
+  // headless agent drive the warm tab WITHOUT a reload or browser tool: POST /cmd {js} enqueues a JS
+  // snippet; the page polls GET /cmd/next, runs it, and POSTs the result to /diag (kind:'cmd-result').
+  // So toggling the atlas, hot-reloading the shader (window.__diag.recompile), and probing live state
+  // are all one curl away -- the simplest possible iterate loop given the cold compile blocks the tool.
+  if (urlPath === '/cmd' && req.method === 'POST') {
+    let body = '';
+    req.on('data', c => { body += c; if (body.length > 2e6) req.destroy(); });
+    req.on('end', () => {
+      try { const o = JSON.parse(body); server._cmdQ = server._cmdQ || []; server._cmdQ.push({ id: (server._cmdId = (server._cmdId || 0) + 1), js: o.js }); res.writeHead(200, {'Content-Type':'application/json'}); res.end(JSON.stringify({ queued: server._cmdId })); }
+      catch (e) { res.writeHead(400); res.end(String(e)); }
+    });
+    return;
+  }
+  if (urlPath === '/cmd/next') {
+    const q = server._cmdQ || [];
+    const cmd = q.shift() || null;
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(cmd));
+    return;
+  }
+  // Root IS the GPU planet (planet.html): one-fractal terrain on WebGL, no wasm. /rewrite.html
+  // kept as an alias. Everything else falls through to a static file (src/, shaders, etc.).
+  let filepath;
+  if (urlPath === '/' || urlPath === '/index.html' || urlPath === '/rewrite.html' || urlPath === '/rewrite') {
+    filepath = path.join(__dirname, 'planet.html');
+  } else {
+    filepath = path.join(__dirname, urlPath);
+  }
+
+  // Prevent directory traversal
+  if (!filepath.startsWith(__dirname)) {
+    res.writeHead(403);
+    res.end('Forbidden');
+    return;
+  }
+
+  fs.stat(filepath, (err, stats) => {
+    if (err) {
+      res.writeHead(404);
+      res.end('Not Found');
+      return;
+    }
+
+    if (stats.isDirectory()) {
+      filepath = path.join(filepath, 'index.html');
+    }
+
+    const ext = path.extname(filepath);
+    const mimeType = MIME_TYPES[ext] || 'application/octet-stream';
+
+    fs.readFile(filepath, (err, content) => {
+      if (err) {
+        res.writeHead(500);
+        res.end('Server Error');
+        return;
+      }
+
+      res.writeHead(200, { 'Content-Type': mimeType });
+      res.end(content);
+    });
+  });
+});
+
+server.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+});