feat(bb): BrowserStack-driven MSM-webgpu bench harness

Adds a remote-device bench loop for the MSM-webgpu dev pages so the
tree-reduce work can validate against real WebGPU hardware (Apple M2,
Snapdragon 8 Elite, Tensor G4) from a workstation without a local GPU.

- vite.config.ts: results/progress POST endpoints write JSONL to files
  named by MSM_WEBGPU_RESULTS_FILE / MSM_WEBGPU_PROGRESS_FILE; allow
  .trycloudflare.com so the dev server is reachable via Cloudflare
  Quick Tunnel.
- results_post.ts: tiny in-page client used by bench/sanity pages to
  POST progress + final-state payloads (no keepalive — the page is
  alive when the bench completes).
- bench-batch-affine.ts: post per-batch progress and a terminal
  done/error row.
- scripts/run-browserstack.mjs: spawn vite + cloudflared, drive a BS
  worker through the REST API, watchdog-tail the JSONL with
  first-progress / stall / deadline budgets.
- scripts/bs-targets.mjs: macOS Sequoia Chrome, S25 Ultra, Pixel 9
  Pro XL presets (WebGPU stable). iPhone 15 Pro listed but flagged
  as needs-iOS-26-or-newer.

Validated against macOS Sequoia Chrome 148 (Apple M2, hc=8) on
?total=8192&sizes=64,256,1024:
  B=64  ns/pair=305.2  median=2.500ms
  B=256 ns/pair=146.5  median=1.200ms
  B=1024 ns/pair=219.7 median=1.800ms

Author: AztecBot

barretenberg/ts/dev/msm-webgpu/bench-batch-affine.ts

@@ -13,6 +13,7 @@ import { BN254_CURVE_CONFIG } from '../../src/msm_webgpu/cuzk/curve_config.js';
 import { get_device } from '../../src/msm_webgpu/cuzk/gpu.js';
 import { compute_misc_params } from '../../src/msm_webgpu/cuzk/utils.js';
 import { BN254_BASE_FIELD } from '../../src/msm_webgpu/cuzk/bn254.js';
+import { makeResultsClient } from './results_post.js';
 
 // TOTAL_PAIRS defaults to 65536 (2^16). Overridable via ?total=N for
 // smoke-tests on small slices (NOT used in the headline sweep, but
@@ -117,6 +118,21 @@ const benchState: BenchState = {
 };
 (window as unknown as { __bench: BenchState }).__bench = benchState;
 
+const resultsClient = makeResultsClient({ page: 'bench-batch-affine' });
+(window as unknown as { __runId: string }).__runId = resultsClient.runId;
+
+async function postFinal(): Promise<void> {
+  await resultsClient.postResults({
+    state: benchState.state,
+    params: benchState.params,
+    results: benchState.results,
+    error: benchState.error,
+    log: benchState.log,
+    userAgent: navigator.userAgent,
+    hardwareConcurrency: navigator.hardwareConcurrency,
+  });
+}
+
 const $log = document.getElementById('log') as HTMLDivElement;
 function log(level: 'info' | 'ok' | 'err' | 'warn', msg: string) {
   const cls = level === 'ok' ? 'ok' : level === 'err' ? 'err' : level === 'warn' ? 'warn' : '';
@@ -396,6 +412,7 @@ async function main() {
       try {
         const r = await runOne(device, sm, B, params.reps, R, p);
         benchState.results.push(r);
+        resultsClient.postProgress({ kind: 'batch_done', batch_size: B, median_ms: r.median_ms, ns_per_pair: r.ns_per_pair });
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
         log('err', `B=${B} failed: ${msg} — STOPPING sweep at first failure`);
@@ -415,9 +432,13 @@ async function main() {
   }
 }
 
-main().catch(e => {
-  const msg = e instanceof Error ? e.message : String(e);
-  log('err', `unhandled: ${msg}`);
-  benchState.state = 'error';
-  benchState.error = msg;
-});
+main()
+  .catch(e => {
+    const msg = e instanceof Error ? e.message : String(e);
+    log('err', `unhandled: ${msg}`);
+    benchState.state = 'error';
+    benchState.error = msg;
+  })
+  .finally(() => {
+    postFinal().catch(() => {});
+  });

barretenberg/ts/dev/msm-webgpu/results_post.ts

@@ -0,0 +1,65 @@
+// Helper used by the dev pages to POST progress and final-result
+// payloads back to the local dev server's `/progress` and `/results`
+// endpoints (see `vite.config.ts`). The BrowserStack runner tails the
+// resulting JSONL to apply stall/deadline watchdogs without polling
+// `window.__bench` / `window.__sanity` from outside the browser.
+//
+// The page can run untouched (no harness) — every call is fire-and-forget
+// and swallows errors so a missing endpoint never blocks the bench loop.
+
+export interface ResultsClientConfig {
+  // Page identifier — e.g. `bench-batch-affine`, `sanity`. Becomes the
+  // `page` field on every JSONL row.
+  page: string;
+  // Optional run id. Defaults to a random hex string per page load.
+  runId?: string;
+}
+
+function makeRunId(): string {
+  return Array.from(crypto.getRandomValues(new Uint8Array(8)))
+    .map(b => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+export function makeResultsClient(cfg: ResultsClientConfig): {
+  postProgress(event: Record<string, unknown>): void;
+  postResults(payload: Record<string, unknown>): Promise<void>;
+  readonly runId: string;
+} {
+  const runId = cfg.runId ?? makeRunId();
+  const base = `${window.location.origin}`;
+
+  function tryPost(path: string, payload: unknown): Promise<Response> | null {
+    try {
+      return fetch(base + path, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ page: cfg.page, runId, ...((payload as object) ?? {}) }),
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  return {
+    runId,
+    postProgress(event) {
+      const p = tryPost("/progress", { event });
+      if (p) p.catch(() => {});
+    },
+    async postResults(payload) {
+      console.log(`[results_post] POST /results runId=${runId} bytes≈${JSON.stringify(payload).length}`);
+      const p = tryPost("/results", payload);
+      if (p) {
+        try {
+          const r = await p;
+          console.log(`[results_post] /results -> HTTP ${r.status}`);
+        } catch (e) {
+          console.log(`[results_post] /results threw: ${(e as Error).message}`);
+        }
+      } else {
+        console.log(`[results_post] /results: tryPost returned null`);
+      }
+    },
+  };
+}

barretenberg/ts/dev/msm-webgpu/scripts/bs-targets.mjs

@@ -0,0 +1,96 @@
+// BrowserStack capability presets for WebGPU MSM bench runs. Mirrors the
+// shape used by `barretenberg/wasm-bench/scripts/run-browserstack.mjs` so
+// the two harnesses share a target vocabulary (`--target macos`,
+// `--target s25-ultra`, …).
+//
+// WebGPU support matrix (as of 2026-05-17):
+// - macOS Sequoia · Chrome 148: WebGPU GA since Chrome 113.
+// - Android Chrome (S25 Ultra, Pixel 9 Pro XL): WebGPU shipped in stable
+//   Chrome on Android in 2024. Latest = "for_real" newest on the device.
+// - iOS Safari 26+ on iPhone 15 Pro: WebGPU shipped in Safari 26.0. iOS 17
+//   Safari does NOT expose `navigator.gpu` — BrowserStack must have a 26+
+//   image for that target to be usable. We expose the preset but flag it.
+
+export const TARGETS = {
+  macos: {
+    label: "macOS Sequoia · Chrome 148",
+    worker: {
+      browser: "chrome",
+      browser_version: "148.0",
+      os: "OS X",
+      os_version: "Sequoia",
+      resolution: "1920x1080",
+    },
+    webgpu: "supported",
+    firstProgressMs: 90_000,
+    notes: "Reference desktop. Apple M2 base.",
+  },
+  "s25-ultra": {
+    label: "Galaxy S25 Ultra · Android 15 · Chrome",
+    worker: {
+      browser: "android",
+      browserName: "chrome",
+      os: "android",
+      os_version: "15.0",
+      device: "Samsung Galaxy S25 Ultra",
+      real_mobile: "true",
+    },
+    webgpu: "supported",
+    firstProgressMs: 150_000,
+    notes: "Snapdragon 8 Elite.",
+  },
+  "pixel-9-pro-xl": {
+    label: "Pixel 9 Pro XL · Android 15 · Chrome",
+    worker: {
+      browser: "android",
+      browserName: "chrome",
+      os: "android",
+      os_version: "15.0",
+      device: "Google Pixel 9 Pro XL",
+      real_mobile: "true",
+    },
+    webgpu: "supported",
+    firstProgressMs: 150_000,
+    notes: "Tensor G4.",
+  },
+  "iphone-15-pro": {
+    label: "iPhone 15 Pro · iOS 26 · Safari",
+    worker: {
+      browser: "iphone",
+      browserName: "safari",
+      os: "ios",
+      os_version: "26",
+      device: "iPhone 15 Pro",
+      real_mobile: "true",
+    },
+    webgpu: "needs-ios-26-or-newer",
+    firstProgressMs: 180_000,
+    notes:
+      "Requires iOS 26+ Safari for WebGPU. BS may not have a 26 image yet.",
+  },
+};
+
+export function listTargets() {
+  return Object.entries(TARGETS).map(([k, v]) => ({
+    key: k,
+    label: v.label,
+    webgpu: v.webgpu,
+    notes: v.notes ?? "",
+  }));
+}
+
+export function buildWorkerBody(targetKey, url, { name, build, timeoutSec }) {
+  const t = TARGETS[targetKey];
+  if (!t) {
+    throw new Error(
+      `unknown --target ${targetKey}. Known: ${Object.keys(TARGETS).join(", ")}`,
+    );
+  }
+  return {
+    ...t.worker,
+    url,
+    timeout: timeoutSec,
+    name,
+    build,
+  };
+}