jspi cleanup: remove the asyncify-era residue — dead code, conditionals, pipeline scaffolding, stale prose

The runtime is JSPI-only; this removes everything that still pretended
otherwise. Three exhaustive sweeps (C++/JS+build+CI/tests+docs) drove
the inventory; every deletion verified by grep closure + full gates.

Broken-right-now fixes:
- deploy-staging.yml passed the retired opt_level input — the workflow
  could not even start. Removed.
- env.sh carried dead exports with a live -sASYNCIFY=1 inside
  (WASM_LDFLAGS/PTHREAD_LDFLAGS, zero consumers). Removed; the
  WASM_LEGACY_EXCEPTIONS rationale rewritten to the real reason.
- docker/build.sh exported PCBJAM_ASYNC_BACKEND (read nowhere). Gone.

Dead weight removed:
- binaryen submodule (nothing builds or invokes it), wasm-opt-bench
  workflow + scripts/bench/, get-wasm-opt.sh, diagnostics.js (242 lines
  of Asyncify-API-only code), the KICAD_PIPELINE background-postprocess
  scaffolding (existed to parallelize the deleted wasm-opt phase; the
  postprocess is a seconds-long node script and now runs inline),
  build-monitor's dead asyncify rows, sched-context orphan build
  output, dead .gitignore entries, the .jspi-assets spike dir (the two
  wf-result research JSONs moved to docs/features/async/migration-evidence/).
- bindings: fiber_park.h + its 12 embind registrations (broken-if-
  called under JSPI), the kicadOpenFileStart/OPEN_JOB starter route,
  main_stack_runner.h + 5 includes, the always-null context-sleep weak
  hook in nanosleep_yield.c.
- shim: the backend field (installed-flag idempotency instead),
  noteContextWait (dead both sides), the __wxAsyncifyDump alias (+ the
  WasmTool fallback and string-dump normalize branch).
- web: the emscripten-6-ignored mainScriptUrlOrBlob option in boot.ts
  (gerber-demo keeps it: it loads the deployed CDN release, which
  predates emscripten 6 — noted inline).

Conditionals: all 'backend === jspi' checks reduced to scheduler-
presence checks; races_quiescent re-keyed from Asyncify.state (vacuous)
to real backlog quiescence (resumeReady/mutatorQueue — NOT _windowLive,
which is the probing activation's own window by definition).

Renames (identifiers only, no file renames): ASYNC_LINK_FLAGS→
JSPI_LINK_FLAGS and Makefile ASYNC_LDFLAGS→JSPI_LDFLAGS,
kicadCollabFiberBusy→kicadCollabBusy (embind + web + tests),
collab_common.h fiber*→apply*/coroutine naming, asyncifySignatures→
wasmTrapSignatures (lists byte-identical).

Tests: the two remaining vacuous [wx-asyncify]/fiber-resume-refused
asserts re-keyed to live JSPI beacons; eeschema-load's failure message
no longer sends the developer to a deleted script; wait-beacons' dead
families/parser deleted; lane-0 legacy-glue guards removed (lane 0 is
unconstructible); the embind test.fail re-gated with the JSPI reason
(plain embind invokers cannot suspend — verified still failing);
lint-determinism now scans tests/jspi (166 files clean);
eeschema-collab local-move gated to chromium (~50% flaky on FF even
solo; pcbnew twin covers both engines).

Docs: DEBUG.md rewritten as the JSPI debugging guide; build.md
describes the single-phase build; docs/features/async/README.md
banner-marked historical and repointed at the NEW
23-jspi-runtime.md (current architecture: export census, turnstile,
libcontext ownership + refusal contract, embind call shapes, the
em-pthread service-wrapper trick, exception policy, known gaps).

Gates on the cleaned tree: test:e2e 725 passed / 0 failed (after the
quiescence-probe fix; the 3 other reds were verified contention flakes
solo-green or the documented FF gate), web 76/0, jspi 18/18 both
engines, vitest 295/295 + 17/17, all lints green, live-app census
clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016X9eh1s5sTx1o9Em9KBuwR

tests/e2e/coroutine-async-preload.spec.ts

@@ -5,8 +5,8 @@ import { test, expect } from './utils/fixtures';
 // KiCad-10 PCBJAM preload shape, with NO KiCad source. Proves native wasm-EH makes the worker-side
 // parse-throw safe, and that the proxy round-trip / lazy join / modal-reentrancy all work.
 //
-// Named coroutine-* so playwright-coroutine.config.ts runs it in real Chrome + Firefox.
-// WebKit skipped for pthread apps (COEP).
+// Named coroutine-*: the merged config's coroutine-* projects select by testMatch
+// /coroutine.*\.spec\.ts$/ — keep these filenames. WebKit skipped for pthread apps (COEP).
 
 const APP = '/standalone/async-preload/async_preload_test.html';
 
@@ -22,7 +22,7 @@ async function waitForLog( testLogger: { consoleLogs: string[] }, needle: string
   await expect.poll( () => testLogger.consoleLogs.some( l => l.includes( needle ) ), { timeout } ).toBe( true );
 }
 
-// Fatal native-EH / Asyncify failures we must NOT see.
+// Fatal native-EH / suspension-runtime failures we must NOT see.
 function fatal( testLogger: { errors: string[] } ) {
   return testLogger.errors.filter( e => !e.includes( 'favicon' )
     && /invalid state|table index out of bounds|aborted|unreachable|func is not a function/i.test( e ) );

tests/e2e/coroutine-nested.spec.ts

@@ -71,7 +71,7 @@ test.describe('Nested Coroutine+Modal Tests', () => {
     expect(failLogs).toHaveLength(0);
     expect(passLogs).toHaveLength(EXPECTED_CASES.length);
 
-    // Critical: catch the nested-asyncify crash
+    // Critical: catch the historic nested-suspension crash signature
     const indexOobErrors = testLogger.errors.filter((e) =>
       e.toLowerCase().includes('index out of bounds')
     );

tests/e2e/coroutine-pthread-ondemand.spec.ts

@@ -6,9 +6,10 @@ import { test, expect } from './utils/fixtures';
 // consumes ALL the pre-warmed Workers at construction; raw fly-threads beyond that count
 // must then be created ON DEMAND, whose 'loaded'->'run' handshake needs the main event loop.
 // The fix is wasm/shims/nanosleep_yield.c (a strong nanosleep override): the main-thread sleep_for
-// join Asyncify-yields so the loop services the handshake and the on-demand Workers boot.
+// join suspends to the browser loop so it services the handshake and the on-demand Workers boot.
 //
-// Named coroutine-* so playwright-coroutine.config.ts runs it in real Chrome + Firefox.
+// Named coroutine-*: the merged config's coroutine-* projects select by testMatch
+// /coroutine.*\.spec\.ts$/ — keep these filenames.
 // WebKit is skipped for pthread apps (COEP worker-load limitation; doc 10 §2a).
 
 const APP = '/standalone/pthread-ondemand/pthread_ondemand_test.html';

tests/e2e/coroutine-pthread.spec.ts

@@ -12,7 +12,7 @@ test.describe('Coroutine pthread main() reproduction', () => {
     await expect
       .poll(() => testLogger.consoleLogs.some((l) => l.includes('[REPRO] DONE')), {
         timeout: 30000,
-        message: 'should reach [REPRO] DONE (i.e. the main-context rewind survived)',
+        message: 'should reach [REPRO] DONE (i.e. the main-context suspension chain survived)',
       })
       .toBe(true);
 
@@ -31,7 +31,7 @@ test.describe('Coroutine pthread main() reproduction', () => {
     await expect
       .poll(() => testLogger.consoleLogs.some((l) => l.includes('[REPRO] DONE')), {
         timeout: 30000,
-        message: 'should reach [REPRO] DONE (main rewind through the dynCall chain survived)',
+        message: 'should reach [REPRO] DONE (the suspension chain through the dynCall boundaries survived)',
       })
       .toBe(true);
 
@@ -60,9 +60,13 @@ test.describe('Coroutine pthread main() reproduction', () => {
   });
 
   // Probe #4: coroutine activated via an embind (--bind) call.
-  // Known crash repro: the embind-dispatched fiber currently crashes the renderer
-  // before reaching DONE. Marked as an expected failure until the coroutine/asyncify
-  // rewind through the embind dispatch is fixed.
+  // Still an expected failure, for the JSPI-era reason (re-probed 2026-08-14):
+  // a PLAIN embind invoker is not a promising entry, so the coroutine's first
+  // suspension inside it cannot suspend the activation — the page never
+  // reaches DONE. The shipped app never uses this shape: suspending embind
+  // entries are either emscripten::async() + parker-wrapped (kicadOpenFile)
+  // or raw KEEPALIVE promising exports. Un-fail only if embind ever grows a
+  // true one-shot promising registration.
   test.fail('embind-activated fiber reaches DONE without renderer crash', async ({ page, testLogger }) => {
     await page.goto('/standalone/coroutine-pthread/embind_repro.html');
     await tryLoadApp(page, 20000).catch(() => {});  // eslint-disable-line -- best-effort load in a pthread/coroutine runtime probe
@@ -70,7 +74,7 @@ test.describe('Coroutine pthread main() reproduction', () => {
     await expect
       .poll(() => testLogger.consoleLogs.some((l) => l.includes('[REPRO] DONE')), {
         timeout: 30000,
-        message: 'should reach [REPRO] DONE (rewind through the embind dispatch survived)',
+        message: 'should reach [REPRO] DONE (the suspension chain through the embind dispatch survived)',
       })
       .toBe(true);
 
@@ -89,7 +93,7 @@ test.describe('Coroutine pthread main() reproduction', () => {
     await expect
       .poll(() => testLogger.consoleLogs.some((l) => l.includes('[REPRO] DONE')), {
         timeout: 30000,
-        message: 'should reach [REPRO] DONE (rewind through the main-loop dynCall_v survived)',
+        message: 'should reach [REPRO] DONE (the suspension chain through the main-loop dynCall_v survived)',
       })
       .toBe(true);
 
@@ -107,7 +111,7 @@ test.describe('Coroutine pthread main() reproduction', () => {
     await expect
       .poll(() => testLogger.consoleLogs.some((l) => l.includes('[REPRO] DONE')), {
         timeout: 30000,
-        message: 'should reach [REPRO] DONE (rewind of a mid-GL-frame survived)',
+        message: 'should reach [REPRO] DONE (the mid-GL-frame suspension chain survived)',
       })
       .toBe(true);
 
@@ -125,7 +129,7 @@ test.describe('Coroutine pthread main() reproduction', () => {
     await expect
       .poll(() => testLogger.consoleLogs.some((l) => l.includes('[REPRO] DONE')), {
         timeout: 30000,
-        message: 'should reach [REPRO] DONE (GL + pthreads mid-frame rewind survived)',
+        message: 'should reach [REPRO] DONE (GL + pthreads mid-frame suspension chain survived)',
       })
       .toBe(true);
   });

tests/e2e/coroutine-raytrace-modal.spec.ts

@@ -2,13 +2,13 @@ import { test, expect } from './utils/fixtures';
 
 // A raytracer-style worker-join run inside a wx modal pump. A pass is dispatched from a wxTimer that
 // fires while a ShowModal() dialog is open; the modal pump runs ProcessEvents via ccall(async:true),
-// so the work runs in a fresh managed Asyncify context at state == Normal. Both join styles complete
-// multi-core there:
+// so the work runs in a fresh suspendable entry (its own suspender, clean state). Both join styles
+// complete multi-core there:
 //   m=0 busywait : sleep_for join; the pre-warmed pool completes it.
 //   m=1 yield    : emscripten_sleep join; legal at state == Normal, so it suspends and resumes.
 //
-// Named coroutine-* so playwright-coroutine.config.ts runs it in real Chrome + Firefox. WebKit
-// skipped for pthread apps (COEP).
+// Named coroutine-*: the merged config's coroutine-* projects select by testMatch
+// /coroutine.*\.spec\.ts$/ — keep these filenames. WebKit skipped for pthread apps (COEP).
 
 const APP = '/standalone/raytrace-modal/raytrace_modal_test.html';
 
@@ -32,7 +32,7 @@ test.describe( 'Raytracer worker-join inside a wx modal pump', () => {
     await page.goto( `${APP}#m=0` );
     await waitForLog( testLogger, '[RTPOOL] SUCCESS mode=0' );
     expect( workersRan( testLogger.consoleLogs ), 'multi-core inside the modal' ).toBeGreaterThan( 1 );
-    expect( abortErrors( testLogger ), 'no Asyncify abort' ).toHaveLength( 0 );
+    expect( abortErrors( testLogger ), 'no wasm abort' ).toHaveLength( 0 );
   } );
 
   // The in-modal work runs in a fresh ProcessEvents entry, so an emscripten_sleep join is a
@@ -46,6 +46,6 @@ test.describe( 'Raytracer worker-join inside a wx modal pump', () => {
               /\[wx-scheduler\] (force-clearing stuck window|job tick error)|\[libctx-jspi\] ghost\/refused/.test( l ) ),
             'no scheduler anomaly during the in-modal join' ).toHaveLength( 0 );
     expect( workersRan( testLogger.consoleLogs ), 'the yield-join completes → multi-core' ).toBeGreaterThan( 1 );
-    expect( abortErrors( testLogger ), 'no Asyncify abort' ).toHaveLength( 0 );
+    expect( abortErrors( testLogger ), 'no wasm abort' ).toHaveLength( 0 );
   } );
 } );

tests/e2e/coroutine-raytrace.spec.ts

@@ -22,18 +22,19 @@ import { test, expect } from './utils/fixtures';
 // itself and has NO connection to KiCad's render_3d_raytrace_base.cpp. It validates the
 // threading MECHANISM in seconds (not the ~12-min KiCad build), not the shipped viewer.
 //
-// TODO(asyncify-nesting): the real KiCad 3D viewer currently ships SERIAL (single-core).
-// The emscripten_sleep variants (B1/B2/m4) pass HERE but ABORT the real viewer with
-// `Aborted(invalid state: 1)`: the viewer renders inside the wx modal/event-pump, which is
-// already mid-Asyncify-unwind, and emscripten_sleep can't nest on that context. This
-// harness runs from a clean OnInit, so it never hits that nesting — a reminder that an
-// isolated repro can be faithful to the *threading* yet miss the *Asyncify context*.
-// The B3/persistent-pool design (m=5) avoids emscripten_sleep entirely and was the one
-// ported into KiCad — but it's currently PARKED (`git -C kicad stash`) pending research
-// into whether a nestable yield (fibers / emscripten_fiber_swap / JSPI) is possible.
+// TODO(raytrace-multicore): the real KiCad 3D viewer still ships SERIAL (single-core) —
+// its engine toggle is inert. The old blocker was asyncify's nesting limit: the viewer
+// renders inside the wx modal/event-pump and an emscripten_sleep join could not nest on
+// that context (`Aborted(invalid state: 1)`) — which this clean-OnInit harness never hit,
+// a reminder that an isolated repro can be faithful to the *threading* yet miss the
+// *suspension context*. JSPI answered that blocking question (nested suspension is legal),
+// so porting the B3/persistent-pool design (m=5, proven below) into the viewer is now a
+// concrete work item rather than research. (An earlier KiCad-side port sits in a local
+// `git -C kicad stash`.)
 //
-// Named coroutine-* so playwright-coroutine.config.ts runs it in real Chrome + Firefox
-// (same engines as the KiCad app), and the default config runs it in bundled Chromium.
+// Named coroutine-*: the merged config's coroutine-* projects select by testMatch
+// /coroutine.*\.spec\.ts$/ (real Chrome + Firefox, same engines as the KiCad app;
+// the wx-chromium project also runs it in bundled Chromium) — keep these filenames.
 
 const APP = '/standalone/raytrace-threads/raytrace_threads_test.html';
 // Modest, fixed work so each pass is ~1-2s serial (enough to show a clear speedup).
@@ -77,7 +78,7 @@ test.describe( 'Raytracer threading (render_3d_raytrace_base.cpp) — must run m
               `pass ${p} should complete (pool reused)` ).toBe( true );
   } );
 
-  test( 'B1-local: stack-local atomics (mirrors raytracer) survive Asyncify yields', async ( { page, testLogger } ) => {
+  test( 'B1-local: stack-local atomics (mirrors raytracer) survive suspension yields', async ( { page, testLogger } ) => {
     // The real raytracer shares stack-local atomics (threadsFinished/nextBlock) with
     // its workers. This proves emscripten_sleep's unwind/rewind doesn't lose the
     // workers' concurrent writes to those C-stack locals (which would hang forever).
@@ -89,7 +90,8 @@ test.describe( 'Raytracer threading (render_3d_raytrace_base.cpp) — must run m
 
   test( 'B3: persistent pool + sleep_for busy-wait (real raytracer mechanism) → multi-core', async ( { page, testLogger } ) => {
     // This is the exact mechanism ported into the raytracer: pre-alive workers, NO
-    // emscripten_sleep (so no Asyncify nesting), main-thread busy-wait that still
+    // emscripten_sleep (so no suspension nesting — the asyncify-era constraint
+    // that shaped it), main-thread busy-wait that still
     // completes because the workers run on their own cores.
     await page.goto( `${APP}#m=5&passes=3&${WORK}` );
     await waitForLog( testLogger, '[RTPOOL] SUCCESS mode=5' );

tests/e2e/coroutine-threadpool-real.spec.ts

@@ -9,12 +9,13 @@ import { test, expect } from './utils/fixtures';
 // pool's persistent pthread workers.
 //
 // The real pool is mode-a/b-safe by construction (persistent workers -> no on-demand spawn;
-// futex busy-wait join -> no Asyncify nesting). The only native-EH risk is mode-c: a task
-// that THROWS on a worker (caught by submit_task's promise wrapper ON the worker drives
-// Asyncify under -fexceptions). So mode 6 is the decisive native-EH proof; modes 0-5 prove
+// futex busy-wait join -> no suspension nesting). The only native-EH risk was mode-c: a task
+// that THROWS on a worker (caught by submit_task's promise wrapper ON the worker, which
+// drove asyncify under -fexceptions). So mode 6 is the decisive native-EH proof; modes 0-5 prove
 // real multi-core (workersRan>1) across the API surface. Green => we can drop the shim.
 //
-// Named coroutine-* so playwright-coroutine.config.ts runs it in real Chrome + Firefox.
+// Named coroutine-*: the merged config's coroutine-* projects select by testMatch
+// /coroutine.*\.spec\.ts$/ — keep these filenames.
 // WebKit is skipped for pthread apps (COEP worker-load limitation; doc 10 §2a).
 
 const APP = '/standalone/threadpool-real/threadpool_real_test.html';
@@ -53,9 +54,10 @@ test.describe( 'Real BS::thread_pool (GetKiCadThreadPool) — multi-core under n
   }
 
   // mode-c: a task throws ON a worker; submit_task's promise wrapper catches it on the
-  // worker (drives Asyncify under -fexceptions -> "func is not a function" crash) and
-  // rethrows on main. Native wasm-EH decouples exceptions from Asyncify, so this must
-  // complete cleanly. (Red under JS-EH, green under native-EH — the contrast IS the proof.)
+  // worker (under -fexceptions this drove asyncify -> "func is not a function" crash) and
+  // rethrows on main. Native wasm-EH decouples exceptions from the suspension machinery,
+  // so this must complete cleanly. (Red under JS-EH, green under native-EH — the contrast
+  // IS the proof.)
   test( 'mode 6: throw on a worker is safe under native-EH and rethrows on main', async ( { page, testLogger } ) => {
     await page.goto( `${APP}#m=6` );
     // A worker throw is a mode-c crash under JS-EH and only safe under native wasm-EH, so this

tests/e2e/modal.spec.ts

@@ -246,7 +246,7 @@ test.describe('Modal dialog border + drag (pcbjam #22)', () => {
 
     // Grab the bottom-right corner and grow the dialog in small steps, sampling the
     // modal canvas immediately after each move. A resize legitimately reassigns
-    // canvas.width/height (clears it); inside the modal's Asyncify pump the repaint
+    // canvas.width/height (clears it); inside the modal's suspended pump the repaint
     // that should refill it is deferred until the next input event, so with the bug
     // the canvas stays transparent and the black .window div shows through.
     const startX = hbox!.x + hbox!.width / 2;

tests/e2e/utils/element-tracker.ts

@@ -1841,7 +1841,7 @@ const SHOT_OPTS = { scale: 'css', animations: 'disabled', caret: 'hide' } as con
  *   1. Fast rAF convergence — hash every animation frame until `stableFrames` are identical (~48ms):
  *      cheap, catches high-frequency motion (animations).
  *   2. Wide confirmation — then re-hash `confirmFrames` times, each `interval` ms apart (~500ms), so a
- *      SLOW async repaint (e.g. a file list arriving after an asyncify readdir) that a few 16ms frames
+ *      SLOW async repaint (e.g. a file list arriving after a suspended readdir) that a few 16ms frames
  *      would sail past forces a reset back to phase 1.
  * Resolves once both phases pass, or when `timeout` elapses — genuinely-animating states (timers,
  * mid-slide) never converge and are captured at the deadline, exactly as the old raw screenshots did.