e2e/CI: dual-engine suites, per-engine screenshots, SwiftShader retired, prod web suite, CI-coverage gate

Squash of experiment/ff-big-modules vs main.

Big-module routing removed: native-EH shrank kicad_editor below
SpiderMonkey's x86-64 code budget (runs 29355049705/29356152413 green on
stock Firefox), so BIG_MODULE_SPECS routing and the baseline-only-JIT
crutch are gone — kicad-firefox and kicad-chromium both run the full
suite, with the module compiled the way real users' browsers compile it.

Per-engine screenshots end to end: stableShot/shotPath write
test-results/<engine>/<name>.png; baselines move to
baseline-screenshots/{chromium,firefox}/ and the whole tools/screenshots
pipeline (compare/promote/manifest/spec-map/changelog/Discord) keys on
<engine>/<name>. Previously Firefox and Chromium renders of one spec
overwrote each other and Firefox renders were never actually gated.
Seeded from CI run 29421380806 (92 new firefox baselines, +24 chromium
web-suite shots); manifest generated from the baseline tree.

One merged playwright.config.ts (kicad/asyncify/coroutine/perf as
projects); ~25 dead npm scripts dropped. The web suite is gated in CI for
the first time ever (4 rotted specs fixed, 5 broken lib-bridge specs
triaged as fixme in docs/features/web-e2e-rot/); cheap lint step after
npm ci; last 26 blind-sleep violations fixed.

SwiftShader retired: CI Chromium renders WebGL on ANGLE → Mesa llvmpipe
(--use-gl=angle --use-angle=gl --ignore-gpu-blocklist; the blocklist flag
is mandatory — llvmpipe is blocklisted and WebGL is silently unavailable
without it) in BOTH configs. Under WORKERS=4 congestion SwiftShader
transiently failed the first post-board-load draw and the recovery
cascade ended in a silent permanent Cairo fallback — that engine flip was
the "~1.2% changedRatio both directions" occ-export baseline flake.
Validated 160/160 across two 80-repeat rigs; full analysis in
docs/features/wx-parity-bugs/occ-export-context-eviction.md. Chromium
baselines shift slightly on llvmpipe — promote once from the first green
run. Deflakes the new coverage exposed: presence baselines settle before
capture; presence fixtures declare current file formats; perf gets its
own outputDir so CI evidence survives; occ-export settles the board paint
before the export dialog; menu-item waits (waitForRenderedByLabel before
clickMenuItem) in 4 specs + the TESTING.md rule.

Web suite runs the PROD build, in parallel: webServer becomes backend
`start` + the standalone's e2e:preview (build-preview.mjs: link-wasm →
stash the public/wasm symlink aside during vite build, build-demo.mjs's
move — then vite preview as the persistent server). The wasm middleware
serves /wasm/* in preview and emits COOP/COEP/CORP itself (a pthread
worker script's own response must carry COEP or Chrome kills it with
ERR_BLOCKED_BY_RESPONSE). VITE_* flags bake at build time;
VITE_ALLOW_USER_OVERRIDE joins turbo globalEnv. fullyParallel + default
workers: 5.2m → 1.4m. Determinism fixes the parallel run exposed:
shared-page specs become serial groups; locks.spec grabs alice's exact
item via the new kicadCollabTestSelectByUuid hook (cross-tab "first
footprint" order is not a ysync invariant); quit specs poll page.url()
(quit supersedes its own navigation — NS_BINDING_ABORTED on Firefox).
Suite: 51 passed / 12 skipped / 0 failed in 1.6m.

CI-coverage gate (lint:ci-coverage): every tests/**/*.spec.ts must be
reachable from the npm scripts the workflows invoke — scraped from
.github/workflows/, resolved through package.json, coverage asked from
playwright --list itself. Rules: uncovered-spec + orphan-project (with a
documented LOCAL_ONLY_PROJECTS allowlist). Gating next to
lint:determinism; 138 spec files / 13 projects accounted for.

Product fixes kept from the investigations (reachable on real GPUs too):
wx 7799fd1be5 — paint flags clear before dispatch + Invalidate always
propagates; kicad 3dcfea5e45 — SwiftShader pass-boundary flush +
per-instance font texture + first-frame GL-error drain (GAL recovery
recovers instead of falling back to Cairo) + the user-facing eeschema
switch navigates again under __EMSCRIPTEN__ (project-sync's
FaceRegistered gate had rerouted it into the hidden sync player; caught
by the newly-gated web suite).

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

wasm/bindings/eeschema_embind.cpp

@@ -1648,6 +1648,34 @@ std::string schCollabTestSelectComponent()
     return toUtf8( target->m_Uuid.AsString() );
 }
 
+// Test helper (0007): select a SPECIFIC item by uuid — see pcbnew_embind.cpp
+// for why the tiebreak specs must not rely on cross-tab iteration order.
+bool schCollabTestSelectByUuid( std::string aUuid )
+{
+    SCH_EDIT_FRAME* fr = schFrame();
+
+    if( !fr )
+        return false;
+
+    SCH_SCREEN* screen = currentScreen( fr );
+
+    if( !screen )
+        return false;
+
+    const wxString want = wxString::FromUTF8( aUuid.c_str() );
+
+    for( SCH_ITEM* item : screen->Items() )
+    {
+        if( item->m_Uuid.AsString() == want )
+        {
+            presenceCore().selectItem( item );
+            return true;
+        }
+    }
+
+    return false;
+}
+
 // JS → C++ (0007): tiebreak release — see pcbnew_embind.cpp for the design
 // (cancel-interactive-if-a-tool-holds-them → selective unselect → infobar →
 // forced re-emit).
@@ -1769,6 +1797,7 @@ EMSCRIPTEN_BINDINGS(eeschema) {
     function("kicadCollabTestGetLocked", &schCollabTestGetLocked);
     function("kicadCollabTestSelectFirst", &schCollabTestSelectFirst);
     function("kicadCollabTestSelectComponent", &schCollabTestSelectComponent);
+    function("kicadCollabTestSelectByUuid", &schCollabTestSelectByUuid);
     function("kicadCollabTestClearSelection", &schCollabTestClearSelection);
     // Library reload after a remote (synced) lib edit — r2-idb-sync realtime.
     function("kicadLibsReload", &pcbjam_libs::reloadLibrary);

wasm/bindings/kicad_editor_embind.cpp

@@ -73,6 +73,7 @@ std::string pcbCollabGetSelection();
 std::string pcbCollabGetSelectionFull();
 std::string pcbCollabTestGetCrossMapped();
 std::string pcbCollabTestSelectComponent();
+bool        pcbCollabTestSelectByUuid( std::string aUuid );
 // Selection soft-locks (collab-presence 0007).
 void        pcbCollabReleaseSelection( std::string aUuidsJson, std::string aHolder );
 std::string pcbCollabTestGetLocked();
@@ -108,6 +109,7 @@ std::string schCollabGetSelection();
 std::string schCollabGetSelectionFull();
 std::string schCollabTestGetCrossMapped();
 std::string schCollabTestSelectComponent();
+bool        schCollabTestSelectByUuid( std::string aUuid );
 // Selection soft-locks (collab-presence 0007).
 void        schCollabReleaseSelection( std::string aUuidsJson, std::string aHolder );
 std::string schCollabTestGetLocked();
@@ -421,6 +423,12 @@ static std::string collabTestSelectComponent()
     return pcbEditorActive() ? pcbCollabTestSelectComponent() : schCollabTestSelectComponent();
 }
 
+static bool collabTestSelectByUuid( std::string aUuid )
+{
+    return pcbEditorActive() ? pcbCollabTestSelectByUuid( aUuid )
+                             : schCollabTestSelectByUuid( aUuid );
+}
+
 static void collabReleaseSelection( std::string aUuidsJson, std::string aHolder )
 {
     pcbEditorActive() ? pcbCollabReleaseSelection( aUuidsJson, aHolder )
@@ -484,6 +492,7 @@ EMSCRIPTEN_BINDINGS(kicad_editor) {
     function("kicadCollabGetSelectionFull", &collabGetSelectionFull);
     function("kicadCollabTestGetCrossMapped", &collabTestGetCrossMapped);
     function("kicadCollabTestSelectComponent", &collabTestSelectComponent);
+    function("kicadCollabTestSelectByUuid", &collabTestSelectByUuid);
     // Selection soft-locks (collab-presence 0007).
     function("kicadCollabReleaseSelection", &collabReleaseSelection);
     function("kicadCollabTestGetLocked", &collabTestGetLocked);

wasm/bindings/pcbnew_embind.cpp

@@ -1739,6 +1739,28 @@ std::string pcbCollabTestSelectComponent()
     return toUtf8( target->m_Uuid.AsString() );
 }
 
+// Test helper (0007): select a SPECIFIC item by uuid through the selection
+// tool. The tiebreak specs need both tabs holding the SAME item, and
+// cross-tab "first footprint" iteration order is not guaranteed — a
+// ysync-materialized board need not match the seeding tab's parse order.
+bool pcbCollabTestSelectByUuid( std::string aUuid )
+{
+    PCB_EDIT_FRAME* fr = pcbFrame();
+
+    if( !fr )
+        return false;
+
+    BOARD_ITEM* item = fr->GetBoard()->ResolveItem(
+            KIID( wxString::FromUTF8( aUuid.c_str() ) ), /*allowNull*/ true );
+
+    if( !item )
+        return false;
+
+    presenceCore().selectItem( item );
+
+    return true;
+}
+
 // JS → C++ (0007): the local client LOST the selection tiebreak — release the
 // contested items (only those) from the live selection. If an interactive
 // tool (move/drag) holds them, cancel it first (ESC semantics — the preview
@@ -2036,6 +2058,7 @@ EMSCRIPTEN_BINDINGS(pcbnew) {
     function("kicadCollabTestGetLocked", &pcbCollabTestGetLocked);
     function("kicadCollabTestSelectFirst", &pcbCollabTestSelectFirst);
     function("kicadCollabTestSelectComponent", &pcbCollabTestSelectComponent);
+    function("kicadCollabTestSelectByUuid", &pcbCollabTestSelectByUuid);
     function("kicadCollabTestClearSelection", &pcbCollabTestClearSelection);
     // Library reload after a remote (synced) lib edit — r2-idb-sync realtime.
     function("kicadLibsReload", &pcbjam_libs::reloadLibrary);