CI: WASM smoke test with post-link.mjs runtime verification

Replace the compilation-only WASM smoke test with a full runtime test
using GHC's post-link.mjs tool and Node.js WASI support.

GHC WASM executables contain ghc_wasm_jsffi custom sections (transitively
from ghc-internal via base/Prelude) requiring JavaScript FFI glue at
instantiation time. The post-link.mjs tool — an official part of GHC's
WASM backend (utils/jsffi/post-link.mjs) — parses these sections and
generates JavaScript providing the ghc_wasm_jsffi imports.

The smoke test now follows the documented workflow from
docs/users_guide/wasm.rst: compile → post-link → instantiate with
JSFFI + WASI imports → run main.

Author: angerman

.github/workflows/nix-ci.yml

@@ -829,14 +829,53 @@ jobs:
         export PATH=$PATH:$HOME/.ghc-wasm/wasi-sdk/bin
         echo 'main = putStrLn "Hello from WASM backend"' > /tmp/hello.hs
         _build/dist/bin/wasm32-unknown-wasi-ghc /tmp/hello.hs -o /tmp/hello.wasm
-        # Verify the .wasm binary was produced. Runtime execution requires
-        # JavaScript FFI glue (ghc_wasm_jsffi imports from ghc-internal),
-        # so plain wasmtime can't run it — would need Node.js + GHC WASM
-        # runtime shim. Compilation + linking is sufficient to validate
-        # the cross-build.
+
+        # Verify the .wasm binary was produced
         ls -lh /tmp/hello.wasm
         file /tmp/hello.wasm
 
+        # Runtime smoke test via post-link.mjs + Node.js
+        #
+        # GHC WASM executables contain ghc_wasm_jsffi custom sections
+        # (transitively from ghc-internal via base/Prelude). These require
+        # JavaScript FFI glue at instantiation time, so plain wasmtime
+        # can't run them. The post-link.mjs tool — an official part of
+        # GHC's WASM backend (installed in libdir, maintained upstream at
+        # utils/jsffi/post-link.mjs) — parses these custom sections and
+        # generates a JavaScript ESM module providing the ghc_wasm_jsffi
+        # imports.
+        #
+        # Workflow (from docs/users_guide/wasm.rst §"JSFFI"):
+        #   1. Compile:     wasm32-wasi-ghc hello.hs -o hello.wasm
+        #   2. Post-link:   $(ghc --print-libdir)/post-link.mjs -i hello.wasm -o hello.mjs
+        #   3. Run:         node runner.mjs  (instantiate WASM with JSFFI + WASI imports)
+        #
+        # See also: utils/jsffi/test-runner.mjs for the reference implementation.
+        WASM_LIBDIR=_build/dist/lib/targets/wasm32-unknown-wasi/lib
+
+        # Generate JavaScript FFI glue from WASM custom sections
+        node "$WASM_LIBDIR/post-link.mjs" -i /tmp/hello.wasm -o /tmp/hello.mjs
+
+        # Instantiate WASM module with JSFFI + WASI imports, then run main.
+        # This mirrors the knot-tying pattern from docs/users_guide/wasm.rst:
+        # __exports starts empty, WASM is instantiated with JSFFI imports
+        # (which capture __exports by reference), then instance exports are
+        # assigned back into __exports before calling wasi.start().
+        node --input-type=module -e '
+        import { readFile } from "node:fs/promises";
+        import { WASI } from "node:wasi";
+        const mod = await WebAssembly.compile(await readFile("/tmp/hello.wasm"));
+        const jsffi = (await import("/tmp/hello.mjs")).default;
+        const wasi = new WASI({ version: "preview1", args: ["hello.wasm"] });
+        let __exports = {};
+        const { instance } = await WebAssembly.instantiate(mod, {
+          ghc_wasm_jsffi: jsffi(__exports),
+          wasi_snapshot_preview1: wasi.wasiImport,
+        });
+        Object.assign(__exports, instance.exports);
+        wasi.start(instance);
+        '
+
     - name: Upload WASM cross artifacts
       uses: actions/upload-artifact@v4
       if: ${{ !cancelled() }}