feat(wasm-eh): migrate the WASM build to native wasm exceptions (+ 3D viewer default-on)

Replace the legacy Emscripten JS-exceptions model with native wasm-EH (legacy
encoding) across the whole build, keeping Asyncify coroutines working via a
from-source Binaryen --hoist-cpp-catches pre-pass. Net result: native-EH is the
only build mode, the 3D viewer is on by default, and pcbnew shrinks substantially.

Highlights:
- Binaryen submodule everywhere + --hoist-cpp-catches integration in apply-asyncify;
  post-link Asyncify covers every app wasm (not just standalone test wasm).
- Build deps (incl. OpenCASCADE without OCC_CONVERT_SIGNALS) and all KiCad apps
  with -fwasm-exceptions; emscripten_sleep added to the post-link asyncify-imports.
- libcontext fiber entry wired under native exceptions; while-loop main loop +
  currData shim injected into all wx apps.
- Native-EH collab apply fixed: DEBUG-define the embind TU + match all out-of-CMake
  C++ TUs' ABI flags to the core, fixing the vtable-layout skew / mis-dispatch.
- 3D viewer enabled by default (real raytracer linked, not the stub).
- Retire the EH-spike scaffolding; flip the asyncify-races ablation pins to
  shim-redundancy pins (native-EH stays clean with the legacy shims ablated).
- Fix the asyncify-races quiescence check to not require Asyncify.currData==0:
  under the native-EH per-frame-yield top loop the main stack is asyncify-suspended
  every frame, so currData legitimately churns (a freed-but-not-yet-nulled buffer,
  not a leak). Refresh the pcbnew toolbar screenshot baseline for the new kicad.
- CI: drop the obsolete binaryen_version input/env (the build uses the binaryen
  submodule fork's wasm-opt, not a version download); key the wasm-output cache on
  the binaryen submodule SHA instead.

Bumps the wxwidgets + binaryen submodules to their squashed feature commits.

Validated green: all 7 apps native-EH (real 3D in pcbnew); KiCad e2e 63/63
Firefox + Chromium (3D viewer renders); wx 336; coroutine 34/34 both engines;
asyncify 7/7 both engines.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

scripts/binaryen-hoist-pass/tests/asyncify-harness.js

@@ -0,0 +1,36 @@
+// Minimal Asyncify harness: drive one unwind/rewind through $vt and check it yields 50.
+const fs = require('fs');
+const path = process.argv[2];
+const BUF = 16, STACK = 1024, STACK_END = 16384;
+let inst, rewinding = false, pending = 0;
+
+const imports = {
+  env: {
+    sleep: (ms) => {
+      if (!rewinding) {
+        inst.exports.asyncify_start_unwind(BUF);
+        pending = ms;
+        return 0; // dummy; value is discarded as we unwind
+      } else {
+        inst.exports.asyncify_stop_rewind();
+        rewinding = false;
+        return pending; // real value supplied on rewind
+      }
+    },
+  },
+};
+
+const mod = new WebAssembly.Module(fs.readFileSync(path));
+inst = new WebAssembly.Instance(mod, imports);
+// asyncify buffer struct: [current, end]
+const mem = new Int32Array(inst.exports.memory.buffer);
+mem[BUF >> 2] = STACK;
+mem[(BUF + 4) >> 2] = STACK_END;
+
+inst.exports.vt(); // runs, throws, catch calls sleep -> starts unwind, returns
+inst.exports.asyncify_stop_unwind();
+inst.exports.asyncify_start_rewind(BUF);
+rewinding = true;
+const r = inst.exports.vt(); // rewinds into the catch handler; sleep returns 50; vt completes
+console.log('vt result =', r);
+process.exit(r === 50 ? 0 : 1);

scripts/binaryen-hoist-pass/tests/delegate-orphan-suspend.wat

@@ -0,0 +1,32 @@
+;; The DuplicateSymbol delegate-orphan shape, but the hoisted cpp arm SUSPENDS (calls an async import)
+;; before its __cxa_end_catch cleanup (try (do ..) (delegate $M)). Drives a real Asyncify unwind/rewind
+;; through the hoisted arm AND its retargeted delegate ($M -> caller), proving the fix doesn't break
+;; the suspend/rewind the hoist exists for. Same harness contract as the other -suspend tests: $vt
+;; yields 50.
+(module
+ (import "env" "sleep" (func $sleep (param i32) (result i32)))
+ (memory (export "memory") 1)
+ (tag $cpp (param i32))
+ (func $vt (export "vt") (result i32)
+  (local $r i32)
+  (try $A
+   (do
+    (throw $cpp (i32.const 0)))
+   (catch_all
+    (try $M
+     (do
+      (try $inner
+       (do
+        (rethrow $A))
+       (catch $cpp
+        (drop (pop i32))
+        (local.set $r (call $sleep (i32.const 50)))
+        (try
+         (do (nop))
+         (delegate $M)))
+       (catch_all
+        (rethrow $A))))
+     (catch_all
+      (rethrow $A)))))
+  (local.get $r))
+)

scripts/binaryen-hoist-pass/tests/delegate-orphan.wat

@@ -0,0 +1,60 @@
+;; Regression repro of SYMBOL_EDIT_FRAME::DuplicateSymbol (KiCad eeschema). A cpp catch arm that is
+;; hoisted PAST an ancestor catch_all (the case-6 deferral) carries a nested __cxa_end_catch cleanup
+;; (try (do ..) (delegate $M)) whose delegate target $M is a mid try sitting INSIDE that ancestor
+;; catch_all. Hoisting the arm out (into the dispatch section, outside every try) orphaned the
+;; delegate -> wasm-validator "all delegate targets must be valid, on (delegate $M)". The fix
+;; retargets it to DELEGATE_CALLER_TARGET (a delegate can only target a try or the caller, not the
+;; $done block); re-throwing a cleanup exception to the caller is the C++ throw-during-cleanup
+;; (std::terminate) path, never taken in normal flow. cpp tag = single i32.
+(module
+ (tag $cpp (param i32))
+
+ ;; Exception path: $A throws cpp(1); its catch_all (re)throws into $inner whose cpp arm sets r:=42,
+ ;; its __cxa_end_catch cleanup delegates to the enclosing $M.  expect 42.
+ (func $caught (export "caught") (result i32)
+  (local $r i32)
+  (try $A
+   (do
+    (throw $cpp (i32.const 1)))
+   (catch_all
+    (try $M
+     (do
+      (try $inner
+       (do
+        (rethrow $A))
+       (catch $cpp
+        (drop (pop i32))
+        (local.set $r (i32.const 42))
+        (try
+         (do (nop))
+         (delegate $M)))
+       (catch_all
+        (rethrow $A))))
+     (catch_all
+      (rethrow $A)))))
+  (local.get $r))
+
+ ;; No-exception path: $A body falls through with r:=7.  expect 7.
+ (func $normal (export "normal") (result i32)
+  (local $r i32)
+  (try $A
+   (do
+    (local.set $r (i32.const 7)))
+   (catch_all
+    (try $M
+     (do
+      (try $inner
+       (do
+        (rethrow $A))
+       (catch $cpp
+        (drop (pop i32))
+        (local.set $r (i32.const 42))
+        (try
+         (do (nop))
+         (delegate $M)))
+       (catch_all
+        (rethrow $A))))
+     (catch_all
+      (rethrow $A)))))
+  (local.get $r))
+)

scripts/binaryen-hoist-pass/tests/nested-catchall-exit-block.wat

@@ -0,0 +1,49 @@
+;; Regression repro of PGM_BASE::HandleException (KiCad) — the case-6 shape (a cpp catch nested in an
+;; outer try's catch_all cleanup pad) WITH an intervening block in that cleanup that the cpp arm
+;; br's to. LLVM emits this for `try{} catch(A&) catch(B&) catch(...)`: the outer try has only a
+;; catch_all (destructor cleanup), inside which it (rethrow)s into a nested try whose cpp catch does
+;; the __cxa type dispatch and, when done, (br)s OUT to a block ($blk) sitting between the escape
+;; target and the arm. Hoisting that arm to the dispatch section orphaned the br — "all break targets
+;; must be valid, on (br $blk)". cpp tag = single i32.
+(module
+ (tag $cpp (param i32))
+
+ ;; Exception path: outer body throws cpp(1); the catch_all reclassifies via (rethrow $outer) inside
+ ;; (block $blk); the nested cpp arm handles it (r := 42) then (br $blk) to finish.  expect 42.
+ (func $caught (export "caught") (result i32)
+  (local $r i32)
+  (try $outer
+   (do
+    (throw $cpp (i32.const 1)))
+   (catch_all
+    (block $blk
+     (try
+      (do
+       (rethrow $outer))
+      (catch $cpp
+       (drop (pop i32))
+       (local.set $r (i32.const 42))
+       (br $blk))
+      (catch_all
+       (rethrow $outer))))))
+  (local.get $r))
+
+ ;; No-exception path: body falls through with r := 7, neither catch runs.  expect 7.
+ (func $normal (export "normal") (result i32)
+  (local $r i32)
+  (try $outer
+   (do
+    (local.set $r (i32.const 7)))
+   (catch_all
+    (block $blk
+     (try
+      (do
+       (rethrow $outer))
+      (catch $cpp
+       (drop (pop i32))
+       (local.set $r (i32.const 42))
+       (br $blk))
+      (catch_all
+       (rethrow $outer))))))
+  (local.get $r))
+)

scripts/binaryen-hoist-pass/tests/nested-catchall-suspend.wat

@@ -0,0 +1,26 @@
+;; The HandleException nested-catchall-exit-block shape, but the nested cpp arm SUSPENDS (calls an
+;; async import) before it br's the intervening block. This drives a real Asyncify unwind/rewind
+;; through the hoisted arm AND its retargeted br ($blk -> $done), proving the fix doesn't break the
+;; suspend/rewind the hoist exists for. Same harness contract as value-typed-suspend.wat: $vt yields 50.
+(module
+ (import "env" "sleep" (func $sleep (param i32) (result i32)))
+ (memory (export "memory") 1)
+ (tag $cpp (param i32))
+ (func $vt (export "vt") (result i32)
+  (local $r i32)
+  (try $outer
+   (do
+    (throw $cpp (i32.const 0)))
+   (catch_all
+    (block $blk
+     (try
+      (do
+       (rethrow $outer))
+      (catch $cpp
+       (drop (pop i32))
+       (local.set $r (call $sleep (i32.const 50)))
+       (br $blk))
+      (catch_all
+       (rethrow $outer))))))
+  (local.get $r))
+)

scripts/binaryen-hoist-pass/tests/run.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# Regression test for the value-typed (concrete-result) path of --hoist-cpp-catches.
+#
+# Value-typed cpp-catch tries do not arise from normal C++ EH lowering (LLVM keeps catch values in
+# locals → void/unreachable tries), so this case can't live in a C++ EH toy. These
+# hand-written modules exercise it directly:
+#   (1) fuzz-exec — the pass must preserve the result value of value-typed cpp-catch tries
+#       (exception path, no-exception path, and exception-payload routing).
+#   (2) a real asyncify unwind/rewind through a value-typed catch that SUSPENDS (must yield 50).
+#
+# Requires wasm-opt built from the binaryen submodule (scripts/binaryen-hoist-pass/build-wasm-opt.sh);
+# that one binary (version_130 + our hoist pass) does both --hoist-cpp-catches and --asyncify. Run from anywhere.
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+DIR="$ROOT/scripts/binaryen-hoist-pass/tests"
+WASMOPT="$ROOT/build-wasm/tools/binaryen-hoist-build/bin/wasm-opt"
+V130="$WASMOPT"   # the submodule fork IS version_130 (asyncify unchanged), so it does --asyncify too
+[ -x "$WASMOPT" ] || { echo "build wasm-opt first: scripts/binaryen-hoist-pass/build-wasm-opt.sh"; exit 1; }
+
+echo "== (1) value semantics preserved (fuzz-exec) =="
+"$WASMOPT" --hoist-cpp-catches -all -all --fuzz-exec "$DIR/value-typed-cpp-catch.wat" -o /dev/null 2>&1 \
+  | grep -E 'comparing|=>'
+
+echo "== (2) asyncify unwind/rewind through a value-typed suspending catch =="
+"$WASMOPT" --hoist-cpp-catches -all -all "$DIR/value-typed-suspend.wat" -o /tmp/vt_s.hoisted.wasm
+"$V130" --asyncify -all --pass-arg=asyncify-imports@env.sleep /tmp/vt_s.hoisted.wasm -o /tmp/vt_s.async.wasm
+node "$DIR/asyncify-harness.js" /tmp/vt_s.async.wasm
+echo "OK — value-typed path verified"
+
+# Regression for the PGM_BASE::HandleException shape: a cpp catch nested in an outer try's catch_all
+# cleanup pad whose arm br's to an intervening block ($blk). Before the fix the hoisted arm's br was
+# orphaned -> "all break targets must be valid". (3) validates + checks value semantics; (4) drives a
+# real unwind/rewind through the hoisted arm with the retargeted br.
+echo "== (3) nested-catchall exit-block hoists + validates (fuzz-exec: caught=>42, normal=>7) =="
+"$WASMOPT" --hoist-cpp-catches -all -all --fuzz-exec "$DIR/nested-catchall-exit-block.wat" -o /dev/null 2>&1 \
+  | grep -E 'comparing|=>'
+
+echo "== (4) asyncify unwind/rewind through a suspending nested-catchall arm =="
+"$WASMOPT" --hoist-cpp-catches -all -all "$DIR/nested-catchall-suspend.wat" -o /tmp/ncb_s.hoisted.wasm
+"$V130" --asyncify -all --pass-arg=asyncify-imports@env.sleep /tmp/ncb_s.hoisted.wasm -o /tmp/ncb_s.async.wasm
+node "$DIR/asyncify-harness.js" /tmp/ncb_s.async.wasm
+echo "OK — nested-catchall path verified"
+
+# Regression for the SYMBOL_EDIT_FRAME::DuplicateSymbol shape: a cpp catch arm hoisted PAST an ancestor
+# catch_all carries a nested __cxa_end_catch cleanup (try (do ..) (delegate $M)) whose delegate target
+# sits inside that catch_all -> orphaned by hoisting ("all delegate targets must be valid"). The fix
+# retargets it to DELEGATE_CALLER_TARGET. (5) validates + checks value semantics; (6) drives a real
+# unwind/rewind through the hoisted arm with the retargeted delegate.
+echo "== (5) delegate-orphan hoists + validates (fuzz-exec: caught=>42, normal=>7) =="
+"$WASMOPT" --hoist-cpp-catches -all -all --fuzz-exec "$DIR/delegate-orphan.wat" -o /dev/null 2>&1 \
+  | grep -E 'comparing|=>'
+
+echo "== (6) asyncify unwind/rewind through a suspending delegate-orphan arm =="
+"$WASMOPT" --hoist-cpp-catches -all -all "$DIR/delegate-orphan-suspend.wat" -o /tmp/dlg_s.hoisted.wasm
+"$V130" --asyncify -all --pass-arg=asyncify-imports@env.sleep /tmp/dlg_s.hoisted.wasm -o /tmp/dlg_s.async.wasm
+node "$DIR/asyncify-harness.js" /tmp/dlg_s.async.wasm
+echo "OK — delegate-orphan path verified"

scripts/binaryen-hoist-pass/tests/value-typed-cpp-catch.wat

@@ -0,0 +1,20 @@
+;; Hand-written value-typed cpp-catch tries to exercise the $result routing in --hoist-cpp-catches.
+;; cpp tag = single i32 param. Each function returns an i32 via a (try (result i32) ...).
+(module
+ (tag $cpp (param i32))
+ ;; exception path: body throws, catch yields 42  -> expect 42
+ (func $vt_throw (export "vt_throw") (result i32)
+  (try (result i32)
+   (do (throw $cpp (i32.const 99)))
+   (catch $cpp (drop (pop i32)) (i32.const 42))))
+ ;; normal path: body yields 7, catch never runs   -> expect 7
+ (func $vt_normal (export "vt_normal") (result i32)
+  (try (result i32)
+   (do (i32.const 7))
+   (catch $cpp (drop (pop i32)) (i32.const 42))))
+ ;; payload routing: catch returns the exception payload it caught (123) -> expect 123
+ (func $vt_payload (export "vt_payload") (result i32)
+  (try (result i32)
+   (do (throw $cpp (i32.const 123)))
+   (catch $cpp (pop i32))))
+)

scripts/binaryen-hoist-pass/tests/value-typed-suspend.wat

@@ -0,0 +1,10 @@
+;; Value-typed try whose catch SUSPENDS: the catch calls an async import and yields its result.
+;; Drives the $result routing across a real asyncify unwind/rewind.
+(module
+ (import "env" "sleep" (func $sleep (param i32) (result i32)))
+ (memory (export "memory") 1)
+ (tag $cpp (param i32))
+ (func $vt (export "vt") (result i32)
+  (try (result i32)
+   (do (throw $cpp (i32.const 0)))
+   (catch $cpp (drop (pop i32)) (call $sleep (i32.const 50))))))