Phase B / B5.7a: register v3 circuits in WASM prover bundle

cmd/prover-wasm now dispatches voteCastHomomorphic_8 and
tallyDecrypt_8 through circuitByName, so the browser-side
workerProve('voteCastHomomorphic_8', ...) call lands at the right
gnark struct. Without this, the next slice (voter-flow v3 branch in
poll.js) would fail at the WASM boundary with "unknown circuit".

Bundles a fast Node smoke test that loads public/prover.wasm and
verifies both new names dispatch through to VK deserialization
(rather than getting rejected at the dispatch step), wired into
`go test ./cmd/prover-wasm/...` so any drift between the wasm switch
and the JS dispatch surfaces in CI before reaching a browser.

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

Author: stackdump

cmd/prover-wasm/main.go

@@ -295,6 +295,14 @@ func circuitByName(name string) frontend.Circuit {
 		return &circuits.TallyProofCircuit64{}
 	case "tallyProof_256":
 		return &circuits.TallyProofCircuit256{}
+	case "voteCastHomomorphic_8":
+		// Phase B / vote schema v3 — per-voter homomorphic ballot. ~70k
+		// constraints; first call in a session pays the compile cost.
+		return &circuits.VoteCastHomomorphicCircuit_8{}
+	case "tallyDecrypt_8":
+		// Phase B / vote schema v3 — creator's decrypt proof at close. ~40k
+		// constraints; lazy-compiled like tallyProof_256.
+		return &circuits.TallyDecryptCircuit_8{}
 	default:
 		return nil
 	}

cmd/prover-wasm/wasm_smoke_test.go

@@ -0,0 +1,54 @@
+//go:build !js && !wasm
+
+// This test runs on the *host* toolchain (not the wasm one) and shells
+// out to `node` to load public/prover.wasm and verify that the v3
+// circuits — voteCastHomomorphic_8 and tallyDecrypt_8 — are registered
+// in circuitByName. A divergence between cmd/prover-wasm/main.go's
+// switch and the JS-side dispatch surfaces as a test failure here
+// before reaching a browser.
+
+package main_test
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestProverWasmCircuitsSmoke(t *testing.T) {
+	if _, err := exec.LookPath("node"); err != nil {
+		t.Skip("node not installed; skipping wasm smoke test")
+	}
+	root := repoRoot(t)
+	wasmPath := filepath.Join(root, "public", "prover.wasm")
+	if _, err := os.Stat(wasmPath); err != nil {
+		t.Skipf("public/prover.wasm not built yet (run `make wasm`): %v", err)
+	}
+
+	cmd := exec.Command("node", "public/prover_wasm_circuits_smoke.mjs")
+	cmd.Dir = root
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("smoke test failed:\n%s\n%v", out, err)
+	}
+	if !strings.Contains(string(out), "All prover.wasm circuit dispatches OK") {
+		t.Fatalf("smoke test output unexpected:\n%s", out)
+	}
+}
+
+func repoRoot(t *testing.T) string {
+	t.Helper()
+	dir, _ := os.Getwd()
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
+			return dir
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			t.Fatal("could not find repo root (no go.mod ancestor)")
+		}
+		dir = parent
+	}
+}

public/prover_wasm_circuits_smoke.mjs

@@ -0,0 +1,61 @@
+// Cheap smoke test: load public/prover.wasm in Node and confirm the
+// new v3 circuit names route through circuitByName. We invoke
+// loadVerifyOnly with throwaway VK bytes — the deserializer will
+// always fail, but the "unknown circuit: X" branch fires *before*
+// deserialization, so a circuit that's not registered surfaces as a
+// distinguishable error.
+//
+// Run: node public/prover_wasm_circuits_smoke.mjs
+
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+// Load wasm_exec.js into the global scope (it expects classic-script
+// globals like `globalThis.Go`).
+const execText = readFileSync(join(here, 'wasm_exec.js'), 'utf8');
+new Function(execText)();
+
+const go = new globalThis.Go();
+const wasmBytes = readFileSync(join(here, 'prover.wasm'));
+const { instance } = await WebAssembly.instantiate(wasmBytes, go.importObject);
+go.run(instance); // fires-and-forgets; the bitwrapProver global is set synchronously during run
+
+// Wait one tick so the global gets set (Go's main writes it during init).
+await new Promise((r) => setImmediate(r));
+
+const api = globalThis.bitwrapProver;
+if (!api) {
+    console.error('bitwrapProver not exported from wasm');
+    process.exit(1);
+}
+
+let failures = 0;
+function check(name) {
+    const r = api.loadVerifyOnly(name, new Uint8Array([0, 0]));
+    const errStr = r && r.error ? String(r.error) : '';
+    if (errStr.includes('unknown circuit')) {
+        console.error(`FAIL: ${name} not registered (error: ${errStr})`);
+        failures++;
+        return;
+    }
+    // Any other error is fine — it means the dispatch reached the
+    // VK-deserialization step, proving the name was recognized.
+    console.log(`OK:   ${name} dispatches (${errStr || 'no error?'})`);
+}
+
+check('voteCastHomomorphic_8');
+check('tallyDecrypt_8');
+
+// Sanity: pre-existing names still dispatch.
+check('voteCast');
+check('tallyProof_16');
+
+if (failures > 0) {
+    console.error(`\n${failures} smoke check(s) FAILED`);
+    process.exit(1);
+}
+console.log('\nAll prover.wasm circuit dispatches OK.');
+process.exit(0);