test(wasm-worker): TS worker true-parallelism proof (peakConcurrency=4)

test-ts-worker.mjs: scan ts_probe (maxWorkers=4) once under threads=4 — one scan fans out
across N worker: connections => N slots => N dedicated SLOT sub-Workers, each CPU-busy-
looping under a shared concurrency guard — then read ts_peek. Assert peak >= 2 (observed
4). Since a busy loop blocks a single async event loop (peak would be 1), this proves the
TS SAB worker serves N slots on real parallel threads, matching the Rust worker.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S2jkoYMNsNYkcpSh6Fwk2c

Author: rustyconover

test/support/wasm-worker/browser-e2e/README.md

@@ -145,11 +145,12 @@ mbedtls, but the disk tier is off on WASM — no persistent FS.)
 The `worker:` transport is worker-language-agnostic. `test-ts-worker.mjs` proves a
 **TypeScript** worker (vgi-typescript) serves over the same SAB channel at parity with
 the Rust `sabtable` worker: a direct `vgi_table_function('worker:ts-worker-boot.js',
-'ts_count', [5])` (producer mode), `ATTACH` + discovery + `tcat.main.ts_count(3)`, and a
-`ts_double` scalar (exchange mode). The worker is
-`vgi-typescript/examples/sab-worker/boot.ts` — it multiplexes all SAB slots on one Web
-Worker's event loop via `Atomics.waitAsync` (vs. the Rust worker's emscripten
-thread-per-slot) and drives vgi-rpc's `serveStream` over a new browser `ByteSink` writer.
+'ts_count', [5])` (producer mode), `ATTACH` + discovery + `tcat.main.ts_count(3)`, a
+`ts_double` scalar (exchange mode), and a **true-parallelism** proof (`peakConcurrency=4`
+— `ts_probe`/`ts_peek`). The worker is `vgi-typescript/examples/sab-worker/boot.ts` — it
+drives vgi-rpc's `serveStream` over a browser `ByteSink` writer and is **truly parallel**:
+one dedicated sub-Worker per SAB slot (real threads sharing the SAB), matching the Rust
+worker's emscripten thread-per-slot.
 
 ```bash
 # build the TS worker bundle (from vgi-typescript), copy to ts-worker-mod.js here:

test/support/wasm-worker/browser-e2e/test-ts-worker.mjs

@@ -54,8 +54,21 @@ const to = (ms, t) => new Promise((_, rej) => setTimeout(() => rej(new Error('__
       log('ts_count(3)=' + JSON.stringify(cv) + ' ok=' + R.attachTableOk + '; ts_double=' + JSON.stringify(sv) + ' ok=' + R.scalarOk);
     } catch (e) { R.attachTableOk = false; R.scalarOk = false; R.attachErr = String(e.message || e).slice(0, 160); log('attach ERR ' + R.attachErr); }
 
+    // 3. TRUE PARALLELISM proof. ts_probe (maxWorkers=4) fans ONE scan across DuckDB scan
+    // threads => N worker: connections => N slots => N dedicated SLOT sub-Workers, each
+    // CPU-busy-looping under a shared concurrency guard. On a single async event loop the
+    // busy loop blocks => peak concurrency 1; N real sub-Worker threads => peak >= 2.
+    try {
+      await q('SET threads=4');
+      await q(`SELECT count(*)::INT FROM vgi_table_function(${W}, 'ts_probe', [200])`, 30000);
+      const rp = await q(`SELECT * FROM vgi_table_function(${W}, 'ts_peek', [])`);
+      R.peakConcurrency = Number(rp.getChildAt(0).get(0));
+      R.parallelOk = R.peakConcurrency >= 2;
+      log('peakConcurrency=' + R.peakConcurrency + ' parallelOk=' + R.parallelOk);
+    } catch (e) { R.parallelOk = false; R.parallelErr = String(e.message || e).slice(0, 160); log('parallel ERR ' + R.parallelErr); }
+
     await conn.close(); await db.terminate();
-    R.pass = R.loaded && R.directOk && R.attachTableOk && R.scalarOk;
+    R.pass = R.loaded && R.directOk && R.attachTableOk && R.scalarOk && R.parallelOk;
     log('PASS=' + R.pass);
   } catch (e) {
     R.error = String(e && e.stack ? e.stack : e); log('ERROR: ' + R.error);