diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index efd9972d..86a44f46 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -18,8 +18,83 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  # The make test suite: every top-level test of every package runs in
+  # exactly one shard, packed by recorded duration (scripts/test_shards.py).
+  # macOS: four shards plus checks fit GitHub's five concurrent macOS jobs.
   test:
-    name: test (${{ matrix.platform }})
+    name: test (${{ matrix.platform }}, ${{ matrix.shard }}/${{ matrix.shards }})
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {os: ubuntu-24.04, platform: linux-amd64, shards: 6, shard: 1}
+          - {os: ubuntu-24.04, platform: linux-amd64, shards: 6, shard: 2}
+          - {os: ubuntu-24.04, platform: linux-amd64, shards: 6, shard: 3}
+          - {os: ubuntu-24.04, platform: linux-amd64, shards: 6, shard: 4}
+          - {os: ubuntu-24.04, platform: linux-amd64, shards: 6, shard: 5}
+          - {os: ubuntu-24.04, platform: linux-amd64, shards: 6, shard: 6}
+          - {os: macos-14, platform: darwin-arm64, shards: 4, shard: 1}
+          - {os: macos-14, platform: darwin-arm64, shards: 4, shard: 2}
+          - {os: macos-14, platform: darwin-arm64, shards: 4, shard: 3}
+          - {os: macos-14, platform: darwin-arm64, shards: 4, shard: 4}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Cache locations
+        run: |
+          echo "GOSVM_CACHE=$RUNNER_TEMP/gosvm-cache" >> "$GITHUB_ENV"
+          echo "GOCACHE=$RUNNER_TEMP/go-build" >> "$GITHUB_ENV"
+          echo "GOMODCACHE=$RUNNER_TEMP/go-mod" >> "$GITHUB_ENV"
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.22.0'
+          cache: false
+
+      # Module and build caches under one key per commit's Go sources, so a
+      # run restores the latest earlier build of the same platform.
+      - name: Go caches
+        uses: actions/cache@v4
+        with:
+          path: |
+            ${{ runner.temp }}/go-build
+            ${{ runner.temp }}/go-mod
+          key: go-${{ matrix.platform }}-${{ hashFiles('go.mod', '**/go.sum', '**/*.go') }}
+          restore-keys: go-${{ matrix.platform }}-
+
+      # The official archive is 430-530 MB; only the extracted Clang/LLD are
+      # cached, keyed by the files that pin them.
+      - name: Cache platform-tools backend
+        uses: actions/cache@v4
+        with:
+          path: ${{ runner.temp }}/gosvm-cache/toolchains
+          key: platform-tools-v1.57-${{ matrix.platform }}-${{ hashFiles('internal/toolchain/archives.go', 'internal/targets/profile.go') }}
+
+      - name: Build CLI and install backend and runners
+        run: |
+          bash scripts/build-cli.sh build/gosvm
+          build/gosvm toolchain install -runners=false
+          # Runner releases exist only after the maintainer publishes them;
+          # until then the SBF executions in the tests skip, saying so.
+          if ! build/gosvm runner install; then
+            echo "::warning::SVM runners not installed for ${{ matrix.platform }}; SBF executions will be skipped"
+          fi
+
+      # -count=1: with the build cache restored, `go test` would otherwise
+      # report cached results instead of running the tests.
+      - name: Root tests
+        env:
+          GOFLAGS: -count=1
+        run: |
+          # The real-libraries tests read these modules from the module cache.
+          (cd examples/real-libraries && go mod download)
+          python3 scripts/test_shards.py --shard ${{ matrix.shard }}/${{ matrix.shards }}
+
+  # Everything else, alongside the test shards.
+  checks:
+    name: checks (${{ matrix.platform }})
     strategy:
       fail-fast: false
       matrix:
@@ -29,23 +104,31 @@ jobs:
           - os: macos-14
             platform: darwin-arm64
     runs-on: ${{ matrix.os }}
-    timeout-minutes: 90
+    timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
 
+      - name: Cache locations
+        run: |
+          echo "GOSVM_CACHE=$RUNNER_TEMP/gosvm-cache" >> "$GITHUB_ENV"
+          echo "GOCACHE=$RUNNER_TEMP/go-build" >> "$GITHUB_ENV"
+          echo "GOMODCACHE=$RUNNER_TEMP/go-mod" >> "$GITHUB_ENV"
+
       - uses: actions/setup-go@v5
         with:
           go-version: '1.22.0'
-          cache: true
-
-      - name: Isolated gosvm cache
-        run: echo "GOSVM_CACHE=$RUNNER_TEMP/gosvm-cache" >> "$GITHUB_ENV"
-
-      - name: Build CLI
-        run: bash scripts/build-cli.sh build/gosvm
+          cache: false
 
-      - name: Vet
-        run: go vet ./...
+      # Module and build caches under one key per commit's Go sources, so a
+      # run restores the latest earlier build of the same platform.
+      - name: Go caches
+        uses: actions/cache@v4
+        with:
+          path: |
+            ${{ runner.temp }}/go-build
+            ${{ runner.temp }}/go-mod
+          key: go-${{ matrix.platform }}-${{ hashFiles('go.mod', '**/go.sum', '**/*.go') }}
+          restore-keys: go-${{ matrix.platform }}-
 
       # The official archive is 430-530 MB; only the extracted Clang/LLD are
       # cached, keyed by the files that pin them.
@@ -55,28 +138,25 @@ jobs:
           path: ${{ runner.temp }}/gosvm-cache/toolchains
           key: platform-tools-v1.57-${{ matrix.platform }}-${{ hashFiles('internal/toolchain/archives.go', 'internal/targets/profile.go') }}
 
-      - name: Install backend
-        run: build/gosvm toolchain install -runners=false
-
-      # Runner releases exist only after the maintainer publishes them (and
-      # Linux pins only after the first runner release); until then the SBF
-      # executions in the tests skip, saying so.
-      - name: Install SVM runners
+      - name: Build CLI and install backend and runners
         run: |
+          bash scripts/build-cli.sh build/gosvm
+          build/gosvm toolchain install -runners=false
+          # Runner releases exist only after the maintainer publishes them;
+          # until then the SBF executions in the tests skip, saying so.
           if ! build/gosvm runner install; then
             echo "::warning::SVM runners not installed for ${{ matrix.platform }}; SBF executions will be skipped"
           fi
 
+      - name: Vet
+        run: go vet ./...
+
       - name: Doctor
         run: build/gosvm doctor
 
-      - name: Root tests
-        run: |
-          # The real-libraries tests read these modules from the module cache.
-          (cd examples/real-libraries && go mod download)
-          make test
-
       - name: Example and benchmark module tests
+        env:
+          GOFLAGS: -count=1
         run: |
           flags=""
           if [ "$(uname -s)" = Darwin ]; then flags="-ldflags=-linkmode=external"; fi
@@ -143,6 +223,18 @@ jobs:
           bash -n scripts/install.sh scripts/build-cli.sh scripts/build_runner_linux.sh
           sh -n scripts/install-release.sh
       - name: Python syntax
-        run: python3 -m py_compile scripts/package_runner_release.py scripts/update_runner_pins.py scripts/package_cli_release.py scripts/check_rebuild_reference.py
+        run: python3 -m py_compile scripts/package_runner_release.py scripts/update_runner_pins.py scripts/package_cli_release.py scripts/check_rebuild_reference.py scripts/test_shards.py
       - name: Committed release pins are well formed
         run: python3 -c "import json,glob; [json.load(open(p)) for p in glob.glob('internal/runner/pins/**/*.json', recursive=True)]"
+
+  # The single required check for branch protection.
+  ci-ok:
+    name: ci-ok
+    if: always()
+    needs: [test, checks, scripts]
+    runs-on: ubuntu-24.04
+    steps:
+      - name: All jobs passed
+        run: |
+          echo '${{ toJSON(needs) }}'
+          [ "${{ needs.test.result }}" = success ] && [ "${{ needs.checks.result }}" = success ] && [ "${{ needs.scripts.result }}" = success ]
diff --git a/internal/compiler/accounts64_sbf_test.go b/internal/compiler/accounts64_sbf_test.go
index e932a34c..97c2f192 100644
--- a/internal/compiler/accounts64_sbf_test.go
+++ b/internal/compiler/accounts64_sbf_test.go
@@ -221,6 +221,7 @@ func TestAccounts64SBF(t *testing.T) {
 // 3,584-byte table overflows 4 KiB in the tutorial (4,224 bytes) and escrow
 // (4,672); with -max-accounts 64 both build for both targets.
 func TestAccounts64Frames(t *testing.T) {
+	t.Parallel()
 	llvm := compiler.ModernLLVMForTest()
 	if llvm == "" {
 		t.Skip("pinned platform-tools v1.57 backend required")
diff --git a/internal/compiler/accounts_test.go b/internal/compiler/accounts_test.go
index fdf7da6e..7fe1dc31 100644
--- a/internal/compiler/accounts_test.go
+++ b/internal/compiler/accounts_test.go
@@ -14,6 +14,7 @@ import (
 // directly. Duplicate descriptors must retain data/flags/key aliasing across
 // both the old boundary and the new final slot.
 func TestSDKAccountDecoderCapacityAndAliases(t *testing.T) {
+	t.Parallel()
 	source := `package app;import "gosvm/solana"
 func Process(c solana.Context)uint64 {
  d:=solana.Instruction(c)
@@ -144,6 +145,7 @@ while(scanf("%llu %u %u %u",&n,&pattern,&bad,&strict)==4){
 // Only programs that opt in to 64 accounts get the wide table and Process's
 // own frame; SDK 1 and other limits are rejected.
 func TestMaxAccountsOptIn(t *testing.T) {
+	t.Parallel()
 	source := `package app;import "gosvm/solana";func Process(c solana.Context)uint64{return solana.Count(c)}`
 	for _, tc := range []struct {
 		sdk, max   int
diff --git a/internal/compiler/alloc_growth_test.go b/internal/compiler/alloc_growth_test.go
index f8c25ff6..486571e3 100644
--- a/internal/compiler/alloc_growth_test.go
+++ b/internal/compiler/alloc_growth_test.go
@@ -90,6 +90,7 @@ func hasPointers(t reflect.Type) bool {
 // growthTypes and append sequences of 1, 2, 3, 7 and 100 elements, until the
 // backing array exceeds 300 KiB.
 func TestGrowthModelMatchesGoRuntime(t *testing.T) {
+	t.Parallel()
 	if v := strings.TrimPrefix(runtime.Version(), "go"); !strings.HasPrefix(v, "1.22") {
 		t.Skipf("the oracle is Go 1.22's runtime; running %s", v)
 	}
@@ -127,6 +128,7 @@ func TestGrowthModelMatchesGoRuntime(t *testing.T) {
 // the host over a grid of lengths, capacities, counts, sizes and both
 // pointer modes, and compares every resulting capacity with the model.
 func TestGrowthRuntimeMatchesModel(t *testing.T) {
+	t.Parallel()
 	cc, err := exec.LookPath("clang")
 	if err != nil {
 		t.Skip("host Clang is needed")
@@ -202,6 +204,7 @@ while(scanf("%llu %llu %llu %llu %llu",&l,&c,&n,&s,&scan)==5){
 // TestGrowthModelMatchesCompiledAppend checks the model against append on
 // concrete compiled types (no reflect), which is what native fixtures run.
 func TestGrowthModelMatchesCompiledAppend(t *testing.T) {
+	t.Parallel()
 	type big struct {
 		P *uint64
 		A [64]uint64
diff --git a/internal/compiler/alloc_moves_test.go b/internal/compiler/alloc_moves_test.go
index 2208540c..ac4e4c66 100644
--- a/internal/compiler/alloc_moves_test.go
+++ b/internal/compiler/alloc_moves_test.go
@@ -10,6 +10,7 @@ import (
 // lifetime tables): each now compiles, moves the escaping local to the heap
 // and returns the value native Go would.
 func TestFormerEscapesMoveToHeap(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct {
 		source string
 		want   string
diff --git a/internal/compiler/alloc_sbf_test.go b/internal/compiler/alloc_sbf_test.go
index ae91a607..86b31fea 100644
--- a/internal/compiler/alloc_sbf_test.go
+++ b/internal/compiler/alloc_sbf_test.go
@@ -160,6 +160,7 @@ func allocLargeHeapCases() []allocCase {
 // runners. Skips without the v1.57 backend or a runner (make test).
 // GOSVM_ALLOC_RESULTS=<dir> keeps fixtures, ELFs, reports and a summary.
 func TestAllocationSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/alloc_test.go b/internal/compiler/alloc_test.go
index 006e364c..d3764d2a 100644
--- a/internal/compiler/alloc_test.go
+++ b/internal/compiler/alloc_test.go
@@ -71,6 +71,7 @@ func Process(s, i []byte) uint64 {
 `
 
 func TestAllocationAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"new scalar":           `p := new(uint64); *p = 1; s[0] = byte(*p)`,
 		"new struct":           `v := new(V); v.N = 2; s[0] = byte(v.N)`,
@@ -123,6 +124,7 @@ func TestAllocationAcceptedForms(t *testing.T) {
 }
 
 func TestAllocationRejections(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ body, want string }{
 		"make channel":        {`ch := make(chan uint64); _ = ch`, "make supports only slices and maps"},
 		"new int":             {`p := new(int); _ = p`, ""},
@@ -179,6 +181,7 @@ func TestAllocationRejections(t *testing.T) {
 // Heap moves and parameter escapes are part of the checked program, so a
 // backend allocates exactly the same storage.
 func TestHeapMovesExported(t *testing.T) {
+	t.Parallel()
 	checked, err := Check(&Program{Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "alloc.go", Data: []byte(`package p
 type N struct{ Next *N; V uint64 }
 func keep(h *N, n *N) { h.Next = n }
@@ -229,6 +232,7 @@ func Process(s, i []byte) uint64 {
 // Programs that do not allocate keep their exact C; the runtime and the
 // configured budget appear only when used.
 func TestAllocationRuntimeOnlyWhenUsed(t *testing.T) {
+	t.Parallel()
 	without, err := Compile("a.go", []byte("package p\ntype B struct{ K [4]byte }\nfunc Process(s, i []byte) uint64 { var b B; v := b.K[:]; return uint64(len(v)) }\n"))
 	if err != nil {
 		t.Fatal(err)
@@ -339,6 +343,7 @@ func AllocVectorsForTest() [][]byte { return allocVectors(20261015, 3, 3000, 150
 // for 18 element kinds, make/new zero values and make traps, copy overlap,
 // slicing bounds, linked structures, escaping locals, literals and aliasing.
 func TestAllocationDifferential(t *testing.T) {
+	t.Parallel()
 	source, err := os.ReadFile("../../examples/alloc-values/program.go")
 	if err != nil {
 		t.Fatal(err)
@@ -411,6 +416,7 @@ func runOOM(t *testing.T, bin string, n uint64) string {
 // first allocation that does not fit aborts. Native Go never runs out of
 // memory at these sizes, so the expectations are computed, not observed.
 func TestOutOfMemoryBoundaries(t *testing.T) {
+	t.Parallel()
 	build := func(heap int, body string) string {
 		source := "package p\nfunc load(i []byte) uint64 { n := uint64(0); for j := uint64(0); j < 8; j++ { n = n | uint64(i[j])<<(8*j) }; return n }\nfunc save(s []byte, v uint64) { for j := uint64(0); j < 8; j++ { s[j] = byte(v >> (8 * j)) } }\nfunc Process(s, i []byte) uint64 {\nn := load(i)\n" + body + "\n}\n"
 		c, err := CompileProgram(&Program{Entry: "program", HeapBytes: heap, Packages: []PackageSources{{"program", []Source{{Name: "oom.go", Data: []byte(source)}}}}})
diff --git a/internal/compiler/arrays_test.go b/internal/compiler/arrays_test.go
index b407e5fc..cc78f68c 100644
--- a/internal/compiler/arrays_test.go
+++ b/internal/compiler/arrays_test.go
@@ -43,6 +43,7 @@ while(scanf("%32s %48s",ih,sh)==2){
 }return 0;}`
 
 func TestScalarArraysDifferential(t *testing.T) {
+	t.Parallel()
 	source, err := os.ReadFile("../../examples/array-values/program.go")
 	if err != nil {
 		t.Fatal(err)
@@ -96,6 +97,7 @@ func TestScalarArraysDifferential(t *testing.T) {
 }
 
 func TestArrayDeclarationOrder(t *testing.T) {
+	t.Parallel()
 	sources := []Source{
 		{"a.go", []byte(`package p; type Box struct { K Key };func Process(s,i []byte)uint64 {b:=Box{K:Key{1}};return uint64(b.K[0])}`)},
 		{"b.go", []byte(`package p;type Key [32]byte;func echo(k [32]byte)[32]byte{return k}`)},
@@ -115,6 +117,7 @@ func TestArrayDeclarationOrder(t *testing.T) {
 }
 
 func TestArrayRejections(t *testing.T) {
+	t.Parallel()
 	for name, source := range map[string]string{
 		"oversize byte": `type K [1025]byte;func Process(s,i []byte)uint64{return 0}`,
 		"oversize word": `type K [129]uint64;func Process(s,i []byte)uint64{return 0}`,
@@ -139,6 +142,7 @@ func TestArrayRejections(t *testing.T) {
 }
 
 func TestArrayStorageLimit(t *testing.T) {
+	t.Parallel()
 	for _, typ := range []string{"[1024]byte", "[128]uint64", "[256]uint32", "[1024]bool", "[0]byte"} {
 		_, err := Compile("limit.go", []byte("package p;type K "+typ+`;func Process(s,i []byte)uint64{var a K;return uint64(len(a))}`))
 		if err != nil {
@@ -148,6 +152,7 @@ func TestArrayStorageLimit(t *testing.T) {
 }
 
 func TestArrayCapacityMemory(t *testing.T) {
+	t.Parallel()
 	source, err := os.ReadFile("../../examples/array-capacity/program.go")
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/compiler/bits_diff_test.go b/internal/compiler/bits_diff_test.go
index c1890793..4402612c 100644
--- a/internal/compiler/bits_diff_test.go
+++ b/internal/compiler/bits_diff_test.go
@@ -238,6 +238,7 @@ func bitsEdges(width int) []uint64 {
 }
 
 func TestBitsDifferentialAgainstGo(t *testing.T) {
+	t.Parallel()
 	ops := bitsOps()
 	program := bitsDifferentialProgram(ops)
 	bin := hostProgram(t, program, bitsHostDriver)
diff --git a/internal/compiler/bits_sbf_test.go b/internal/compiler/bits_sbf_test.go
index 92882a3b..84dee4e2 100644
--- a/internal/compiler/bits_sbf_test.go
+++ b/internal/compiler/bits_sbf_test.go
@@ -298,6 +298,7 @@ func bitsProbeCases() (probe, cu []probeCase) {
 // backend or a runner. GOSVM_BITS_RESULTS=<dir> keeps the fixtures, ELFs,
 // runner reports and a summary per target.
 func TestBitsSBF(t *testing.T) {
+	t.Parallel()
 	llvm := modernLLVM()
 	if llvm == "" {
 		t.Skip("pinned platform-tools v1.57 backend required")
diff --git a/internal/compiler/bits_test.go b/internal/compiler/bits_test.go
index 35b6ca88..a6ace81b 100644
--- a/internal/compiler/bits_test.go
+++ b/internal/compiler/bits_test.go
@@ -18,6 +18,7 @@ import (
 // exported API: the same names, the same signatures (including parameter and
 // result names) and the same constant values.
 func TestBitsDeclarationsMatchStandardLibrary(t *testing.T) {
+	t.Parallel()
 	std, err := importer.ForCompiler(token.NewFileSet(), "source", nil).Import(bitsPath)
 	if err != nil {
 		t.Skipf("standard library source unavailable: %v", err)
@@ -117,6 +118,7 @@ func Process(s, i []byte) uint64 {
 `
 
 func TestBitsCheckAcceptsSupportedFunctions(t *testing.T) {
+	t.Parallel()
 	checked := checkSource(t, bitsAllSource)
 	if len(checked.Functions) != 3 || len(checked.Functions[2].Callees) != 2 {
 		t.Fatalf("math/bits calls must not be program callees: %+v", checked.Functions)
@@ -136,6 +138,7 @@ func TestBitsCheckAcceptsSupportedFunctions(t *testing.T) {
 }
 
 func TestBitsCheckRejections(t *testing.T) {
+	t.Parallel()
 	for name, tc := range map[string]struct{ body, want string }{
 		"function value": {`f := bits.Len64; return uint64(f(1))`, "math/bits functions cannot be used as values; call them in a function literal"},
 		"method value":   {`f := bits.RotateLeft; return uint64(f(1, 2))`, "math/bits functions cannot be used as values; call them in a function literal"},
@@ -165,6 +168,7 @@ func TestBitsCheckRejections(t *testing.T) {
 // RotateLeft counts that are not constants are ordinary Check-accepted code.
 // Their results are compared with Go in TestBitsDifferentialAgainstGo.
 func TestBitsCheckAcceptsUintAndIntValues(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"uint Add":       `sum, carry := bits.Add(1, 2, 0); return uint64(sum + carry)`,
 		"uint Mul":       `h, l := bits.Mul(1, 2); return uint64(h ^ l)`,
@@ -196,6 +200,7 @@ func TestBitsCheckAcceptsUintAndIntValues(t *testing.T) {
 // A single file needs no module for math/bits, and module programs may use it
 // from shared user packages.
 func TestBitsImportForms(t *testing.T) {
+	t.Parallel()
 	dir := t.TempDir()
 	writePackageFile(t, dir, "single/program.go", "package main\nimport \"math/bits\"\nfunc Process(s, i []byte) uint64 { h, _ := bits.Mul64(uint64(len(i)), 1<<63); return h }\n")
 	p, err := ReadProgram(filepath.Join(dir, "single", "program.go"))
@@ -230,6 +235,7 @@ func TestBitsImportForms(t *testing.T) {
 // Programs that do not call math/bits emit exactly the C they always have
 // (the frozen corpus checks hashes); the runtime appears only when used.
 func TestBitsRuntimeOnlyWhenUsed(t *testing.T) {
+	t.Parallel()
 	plain := "package main\nfunc Process(s, i []byte) uint64 { return uint64(len(s)) }\n"
 	c, err := CompileSources([]Source{{"p.go", []byte(plain)}})
 	if err != nil {
diff --git a/internal/compiler/builtins_test.go b/internal/compiler/builtins_test.go
index e817dcfe..1eddb6e5 100644
--- a/internal/compiler/builtins_test.go
+++ b/internal/compiler/builtins_test.go
@@ -12,6 +12,7 @@ import (
 )
 
 func TestMultiplyBuiltinNativeDifferential(t *testing.T) {
+	t.Parallel()
 	cc, err := exec.LookPath("clang")
 	if err != nil {
 		t.Skip("host Clang required")
@@ -72,6 +73,7 @@ while(scanf("%llu %llu %llu %llu",&al,&ah,&bl,&bh)==4){
 }
 
 func TestSBFUnresolvedSymbolGuard(t *testing.T) {
+	t.Parallel()
 	llvm := filepath.Join(os.Getenv("HOME"), ".cache/solana/v1.51/platform-tools/llvm/bin")
 	if _, err := os.Stat(filepath.Join(llvm, "clang")); err != nil {
 		t.Skip("pinned SBF LLVM required")
diff --git a/internal/compiler/byval_test.go b/internal/compiler/byval_test.go
index 53e89667..ac831688 100644
--- a/internal/compiler/byval_test.go
+++ b/internal/compiler/byval_test.go
@@ -46,6 +46,7 @@ func nativeByval(in []byte) []byte {
 }
 
 func TestByvalDifferential(t *testing.T) {
+	t.Parallel()
 	c, err := CompileProgram(&Program{Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "program.go", Data: byvalSource(t)}}}}})
 	if err != nil {
 		t.Fatal(err)
@@ -78,6 +79,7 @@ func TestByvalDifferential(t *testing.T) {
 // case must leave native Go's output. GOSVM_INT_RESULTS=<dir> keeps the
 // fixtures, ELFs and reports under byval/.
 func TestByvalSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
@@ -112,6 +114,7 @@ func TestByvalSBF(t *testing.T) {
 // after a write that may change the caller's variable opaquely, and no
 // others, so programs without such parameters keep their C.
 func TestByvalCopies(t *testing.T) {
+	t.Parallel()
 	const prefix = `package p
 type P struct{ a, b uint64 }
 type K struct{ key [4]byte; n uint64 }
diff --git a/internal/compiler/cache_test.go b/internal/compiler/cache_test.go
index 709ad8ee..95cc49a7 100644
--- a/internal/compiler/cache_test.go
+++ b/internal/compiler/cache_test.go
@@ -8,6 +8,7 @@ import (
 )
 
 func TestBuildReceiptInvalidation(t *testing.T) {
+	t.Parallel()
 	dir := t.TempDir()
 	llvm := filepath.Join(dir, "llvm")
 	mustWrite := func(p, s string) {
diff --git a/internal/compiler/check_corpus_test.go b/internal/compiler/check_corpus_test.go
index 1aee69de..6afbcf04 100644
--- a/internal/compiler/check_corpus_test.go
+++ b/internal/compiler/check_corpus_test.go
@@ -371,6 +371,7 @@ const (
 // failure after a successful Check would surface here as a mismatch. Entries
 // in corpusChanges are verified against their new expected outcome instead.
 func TestCorpusMatchesPreCheckCompiler(t *testing.T) {
+	t.Parallel()
 	rejected, changed := 0, 0
 	for i, e := range loadCorpus(t) {
 		e := e
diff --git a/internal/compiler/check_test.go b/internal/compiler/check_test.go
index bab073fd..ec520101 100644
--- a/internal/compiler/check_test.go
+++ b/internal/compiler/check_test.go
@@ -16,6 +16,7 @@ func checkSource(t *testing.T, source string) *CheckedProgram {
 }
 
 func TestCheckedProgramDescribesContextProgram(t *testing.T) {
+	t.Parallel()
 	checked := checkSource(t, `package main
 import "gosvm/solana"
 type S struct{ x uint64 }
@@ -73,6 +74,7 @@ func Process(c solana.Context) uint64 {
 }
 
 func TestCheckLegacyEntryAndRejection(t *testing.T) {
+	t.Parallel()
 	checked := checkSource(t, "package main\nfunc Process(input []byte, output []byte) uint64 { return 0 }\n")
 	if checked.EntryKind != EntryBytes || checked.SDKPackage != nil || len(checked.CallOrder) != 1 {
 		t.Fatalf("legacy entry %+v", checked)
diff --git a/internal/compiler/clock_test.go b/internal/compiler/clock_test.go
index 041e1a1b..a554c15e 100644
--- a/internal/compiler/clock_test.go
+++ b/internal/compiler/clock_test.go
@@ -14,6 +14,7 @@ import (
 )
 
 func TestSDK2ClockNativeCDifferential(t *testing.T) {
+	t.Parallel()
 	source := `package app;import "gosvm/solana"
 func Process(c solana.Context)uint64{return solana.Clock(c,solana.Data(c,0)[1:uint64(solana.Instruction(c)[0])+1])}`
 	p := &Program{SDK: 2, Entry: "app", Packages: []PackageSources{unit("app", source)}}
diff --git a/internal/compiler/compiler_test.go b/internal/compiler/compiler_test.go
index 78f92279..05daea52 100644
--- a/internal/compiler/compiler_test.go
+++ b/internal/compiler/compiler_test.go
@@ -47,6 +47,7 @@ func hostGenerated(t *testing.T, c []byte, driver string) string {
 }
 
 func TestWideQuoteDifferential(t *testing.T) {
+	t.Parallel()
 	source, err := os.ReadFile("../../examples/tokenswap/swap.go")
 	if err != nil {
 		t.Fatal(err)
@@ -79,6 +80,7 @@ int main(void){u64 x,y,a;while(scanf("%llu %llu %llu",&x,&y,&a)==3){u8 s[16],i[8
 }
 
 func TestRejectUnsupported(t *testing.T) {
+	t.Parallel()
 	for name, source := range map[string]string{
 		"imports":            `import "fmt";func Process(s,i []byte) uint64 {fmt.Println("x");return 0}`,
 		"float":              `func Process(s,i []byte) uint64 {x:=1.5;return uint64(x)}`,
@@ -108,6 +110,7 @@ func TestRejectUnsupported(t *testing.T) {
 }
 
 func TestSDKContext(t *testing.T) {
+	t.Parallel()
 	// Host execution exercises the emitted account decoder, alias import, opaque
 	// context copies, mutable account views, and boundary getters. CPI/PDA calls
 	// are covered in the actual validator suite rather than mocked here.
@@ -131,6 +134,7 @@ u64 r=entrypoint(raw);return r?r:(raw[96]==42?0:3);}`)
 }
 
 func TestSDKHashBounds(t *testing.T) {
+	t.Parallel()
 	source := `package p
 import "gosvm/solana"
 func Process(c solana.Context)uint64 {
@@ -148,6 +152,7 @@ int main(void){Context c={0};u8 b[64]={0};c.count=1;c.accounts[0].data=b;c.accou
 }
 
 func TestGoSemantics(t *testing.T) {
+	t.Parallel()
 	source := `package p
 func bump(s []byte) uint64 { s[0] = s[0]+1; return uint64(s[0]) }
 func Process(s,i []byte) uint64 {
@@ -175,6 +180,7 @@ func Process(s,i []byte) uint64 {
 }
 
 func TestRuntimeGuards(t *testing.T) {
+	t.Parallel()
 	for name, expr := range map[string]string{"bounds": "uint64(s[uint64(i[0])])", "division": "uint64(s[0])/uint64(i[0])"} {
 		t.Run(name, func(t *testing.T) {
 			index := 0
@@ -192,6 +198,7 @@ func TestRuntimeGuards(t *testing.T) {
 }
 
 func TestAMMDifferential(t *testing.T) {
+	t.Parallel()
 	source, err := os.ReadFile("../../examples/amm/amm.go")
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/compiler/compound_diff_test.go b/internal/compiler/compound_diff_test.go
index 4d279c18..0d0c2dcc 100644
--- a/internal/compiler/compound_diff_test.go
+++ b/internal/compiler/compound_diff_test.go
@@ -88,6 +88,7 @@ func compileCompound(t *testing.T) []byte {
 }
 
 func TestCompoundDifferential(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileCompound(t), DefaultHeapBytes, allocDriver, false)
 	vectors := compoundVectors(20261014, 2400)
 	var want []string
diff --git a/internal/compiler/compound_sbf_test.go b/internal/compiler/compound_sbf_test.go
index da83e7df..7551eb89 100644
--- a/internal/compiler/compound_sbf_test.go
+++ b/internal/compiler/compound_sbf_test.go
@@ -85,6 +85,7 @@ func compoundSBFSource(t *testing.T) []byte {
 // the v1.57 backend or a runner (make test). GOSVM_INT_RESULTS=<dir> keeps
 // fixtures, ELFs, reports and a summary under compound/.
 func TestCompoundSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/compound_test.go b/internal/compiler/compound_test.go
index f677150f..5f5989c5 100644
--- a/internal/compiler/compound_test.go
+++ b/internal/compiler/compound_test.go
@@ -33,6 +33,7 @@ func compoundMessage(t *testing.T, body string) string {
 }
 
 func TestCompoundAcceptedForms(t *testing.T) {
+	t.Parallel()
 	ops := []string{"+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "&^=", "<<=", ">>="}
 	types := []string{"uint8", "uint16", "uint32", "uint64", "uint", "int8", "int16", "int32", "int64", "int", "Amount", "byte"}
 	for _, typ := range types {
@@ -92,6 +93,7 @@ func TestCompoundAcceptedForms(t *testing.T) {
 }
 
 func TestCompoundRejections(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ body, want string }{
 		"bool":           {`b := i[0] > 1; b += true; return 0`, "f.go:13:16: invalid operation: operator + not defined on b (variable of type bool)"},
 		"string minus":   {`t := "a"; t -= "b"; return 0`, "f.go:13:11: invalid operation: operator - not defined on t (variable of type string)"},
@@ -116,6 +118,7 @@ func TestCompoundRejections(t *testing.T) {
 // reassigns the slice, map or index variable of its own target updates the
 // new target. Elements changed by the right operand are seen.
 func TestCompoundOperandOrder(t *testing.T) {
+	t.Parallel()
 	source := `package p
 func Process(s, i []byte) uint64 {
 	b := []uint64{1, 2, 3}
@@ -161,6 +164,7 @@ func Process(s, i []byte) uint64 {
 // Programs without compound assignment take none of its paths; a program
 // with one gets the signed-division runtime only for a signed /= or %=.
 func TestCompoundEmission(t *testing.T) {
+	t.Parallel()
 	compile := func(body string) []byte {
 		t.Helper()
 		c, err := Compile("f.go", []byte("package p\nfunc Process(s, i []byte) uint64 {\n"+body+"\n}\n"))
diff --git a/internal/compiler/control_test.go b/internal/compiler/control_test.go
index fd355613..d5bd3b4e 100644
--- a/internal/compiler/control_test.go
+++ b/internal/compiler/control_test.go
@@ -12,6 +12,7 @@ import (
 )
 
 func TestControlValuesDifferential(t *testing.T) {
+	t.Parallel()
 	source, err := os.ReadFile("../../examples/control-values/program.go")
 	if err != nil {
 		t.Fatal(err)
@@ -50,6 +51,7 @@ func TestControlValuesDifferential(t *testing.T) {
 	}
 }
 func TestControlRejections(t *testing.T) {
+	t.Parallel()
 	for name, source := range map[string]string{
 		"fallthrough":      `func Process(s,i []byte)uint64{switch i[0]{case 1:fallthrough;default:return 0}}`,
 		"labeled continue": `func Process(s,i []byte)uint64{L:for{continue L};return 0}`,
@@ -63,6 +65,7 @@ func TestControlRejections(t *testing.T) {
 	}
 }
 func TestImportedMultipleResults(t *testing.T) {
+	t.Parallel()
 	p := &Program{Entry: "app", Packages: []PackageSources{
 		unit("app", `package app;import "dep";func forward()(dep.Value,uint64){return dep.Pair()};func Process(s,i []byte)uint64{v,code:=forward();v.N,code=code,v.N;return dep.Add(dep.Pair())+v.N+code}`),
 		unit("dep", `package dep;type Value struct{N uint64};func Pair()(Value,uint64){return Value{N:7},3};func Add(v Value,n uint64)uint64{return v.N+n}`),
diff --git a/internal/compiler/cpi_test.go b/internal/compiler/cpi_test.go
index 41027dca..702177e4 100644
--- a/internal/compiler/cpi_test.go
+++ b/internal/compiler/cpi_test.go
@@ -13,6 +13,7 @@ import (
 )
 
 func TestSDK2InvokeBoundaryDifferential(t *testing.T) {
+	t.Parallel()
 	source := `package p;import "gosvm/solana";func Process(c solana.Context)uint64{return solana.Invoke(c,uint64(solana.Instruction(c)[0]),solana.Data(c,1),solana.Data(c,2),solana.Data(c,3))}`
 	driver := `
 #include <stdio.h>
@@ -113,6 +114,7 @@ int main(void){unsigned p,exec;char m[1400],d[20500],s[5600];while(scanf("%u %u
 }
 
 func TestSDKVersionsAndNativeOnlyTypes(t *testing.T) {
+	t.Parallel()
 	if _, err := CompileProgram(&Program{SDK: 3}); err == nil || !strings.Contains(err.Error(), "unsupported SDK") {
 		t.Fatal(err)
 	}
diff --git a/internal/compiler/cpilimits_sbf_test.go b/internal/compiler/cpilimits_sbf_test.go
index e8d24f3e..9f72e31f 100644
--- a/internal/compiler/cpilimits_sbf_test.go
+++ b/internal/compiler/cpilimits_sbf_test.go
@@ -145,6 +145,7 @@ func buildCPICallee(t *testing.T, llvm, profile, dir string) string {
 // signers. Skips without the v1.57 backend or a runner (make test).
 // GOSVM_CPI_RESULTS=<dir> keeps the ELFs, fixtures, reports and per-case CU.
 func TestCPILimitsSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/evalorder_diff_test.go b/internal/compiler/evalorder_diff_test.go
index e18043ec..66591cf6 100644
--- a/internal/compiler/evalorder_diff_test.go
+++ b/internal/compiler/evalorder_diff_test.go
@@ -90,6 +90,7 @@ func compileEvalOrder(t *testing.T) []byte {
 }
 
 func TestEvalOrderDifferential(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileEvalOrder(t), DefaultHeapBytes, valueTypesDriver, false)
 	vectors := evalOrderVectors(20261015, 6)
 	var want []string
diff --git a/internal/compiler/evalorder_sbf_test.go b/internal/compiler/evalorder_sbf_test.go
index 83fc1d99..b7e0fbad 100644
--- a/internal/compiler/evalorder_sbf_test.go
+++ b/internal/compiler/evalorder_sbf_test.go
@@ -19,6 +19,7 @@ import (
 // without the v1.57 backend or a runner (make test). GOSVM_INT_RESULTS=<dir>
 // keeps fixtures, ELFs, reports and a summary under eval-order/.
 func TestEvalOrderSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/evalorder_test.go b/internal/compiler/evalorder_test.go
index 24345f03..faf9a5b7 100644
--- a/internal/compiler/evalorder_test.go
+++ b/internal/compiler/evalorder_test.go
@@ -47,6 +47,7 @@ func hoistedText(p *CheckedProgram) []string {
 // Check records where gc's order differs observably from left to right:
 // a package variable read before a call that writes it, and nowhere else.
 func TestEvalOrderHoisted(t *testing.T) {
+	t.Parallel()
 	p := checkEvalOrder(t, `package p
 var x uint64
 func f() uint64 { x = 10; return 1 }
@@ -77,6 +78,7 @@ func Process(o, in []byte) uint64 {
 // Captured and address-taken locals are writable by calls; a call that
 // may panic makes an earlier trap observable (its log line).
 func TestEvalOrderLocalsAndTraps(t *testing.T) {
+	t.Parallel()
 	p := checkEvalOrder(t, `package p
 func set(q *uint64) uint64 { *q = 3; return 0 }
 func boom(v byte) uint64 {
@@ -106,6 +108,7 @@ func Process(o, in []byte) uint64 {
 // Map literals insert static entries first; m[k] = append(m[k], f()) reuses
 // the target's early copies; slow-path interface keys convert early.
 func TestEvalOrderMaps(t *testing.T) {
+	t.Parallel()
 	p := checkEvalOrder(t, `package p
 type PM struct{ m map[uint64][]uint64 }
 var pm *PM
@@ -154,6 +157,7 @@ func Process(o, in []byte) uint64 {
 // write, calls that write nothing), Check records nothing, so the C is
 // unchanged.
 func TestEvalOrderNothingToHoist(t *testing.T) {
+	t.Parallel()
 	p := checkEvalOrder(t, `package p
 type T struct{ a uint64 }
 func (t T) Get() uint64 { return t.a }
@@ -175,6 +179,7 @@ func Process(o, in []byte) uint64 {
 // Variadic calls (rewritten by Check to pass a slice literal) and writes
 // through pointers to pointers are analyzed like any other operands.
 func TestEvalOrderVariadicAndPointerToPointer(t *testing.T) {
+	t.Parallel()
 	p := checkEvalOrder(t, `package p
 var x uint64
 var q *uint64
diff --git a/internal/compiler/funccombos_sbf_test.go b/internal/compiler/funccombos_sbf_test.go
index d0ce77fa..923ea1be 100644
--- a/internal/compiler/funccombos_sbf_test.go
+++ b/internal/compiler/funccombos_sbf_test.go
@@ -82,6 +82,7 @@ func funcStringLimit(kind byte) int {
 // without the v1.57 backend or a runner (make test). GOSVM_COMBO_RESULTS=<dir>
 // keeps fixtures, ELFs, reports and a summary.
 func TestFuncCombinationsSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/funcmaps_diff_test.go b/internal/compiler/funcmaps_diff_test.go
index f481b487..54d4da05 100644
--- a/internal/compiler/funcmaps_diff_test.go
+++ b/internal/compiler/funcmaps_diff_test.go
@@ -88,6 +88,7 @@ func compileFuncMaps(t *testing.T) []byte {
 }
 
 func TestFuncMapsDifferential(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileFuncMaps(t), DefaultHeapBytes, allocDriver, false)
 	vectors := funcMapVectors(20261014, 1500)
 	var want []string
@@ -192,6 +193,7 @@ func funcMapCounted(n int, done bool, kind byte) string {
 // value that does not fit aborts after exactly the predicted number; native
 // Go never runs out, so the expectation is computed.
 func TestClosureMapHeap(t *testing.T) {
+	t.Parallel()
 	if DefaultHeapBytes-8 != 32760 {
 		t.Fatalf("default heap %d", DefaultHeapBytes)
 	}
diff --git a/internal/compiler/funcmaps_test.go b/internal/compiler/funcmaps_test.go
index c257c248..3c86f33f 100644
--- a/internal/compiler/funcmaps_test.go
+++ b/internal/compiler/funcmaps_test.go
@@ -22,6 +22,7 @@ func Process(s, i []byte) uint64 {
 `
 
 func TestFuncMapAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"closure capturing a map":             `m := map[uint8]uint8{}; f := func(k uint8) { m[k]++ }; f(1); f(1); return uint64(m[1])`,
 		"closure replacing a map":             `m := map[uint8]uint8{1: 1}; f := func() { m = nil }; f(); return uint64(len(m))`,
@@ -60,6 +61,7 @@ func TestFuncMapAcceptedForms(t *testing.T) {
 // signature, and signatures over different map types (or a named map type
 // and its underlying type) are different classes.
 func TestFuncMapRecursion(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ source, want string }{
 		"map closure calling itself": {funcMapPrefix + "var f func(map[string]int) int\nf = func(m map[string]int) int { return f(m) }\nreturn uint64(f(nil))\n}\n",
 			"f.go:12:5: recursion is not supported"},
@@ -86,6 +88,7 @@ func TestFuncMapRecursion(t *testing.T) {
 // values are captured like any variable, and loop defer records save a map
 // as its 8-byte reference.
 func TestCheckedProgramFuncMaps(t *testing.T) {
+	t.Parallel()
 	source := funcMapPrefix + `m := map[uint8]uint64{}
 f := func(k uint8) uint64 { m[k]++; return m[k] }
 g := func(mm map[uint8]uint64) uint64 { return mm[1] }
diff --git a/internal/compiler/funcs_diff_test.go b/internal/compiler/funcs_diff_test.go
index fb945700..9d21aa1b 100644
--- a/internal/compiler/funcs_diff_test.go
+++ b/internal/compiler/funcs_diff_test.go
@@ -85,6 +85,7 @@ func compileFuncValues(t *testing.T) []byte {
 }
 
 func TestFuncValuesDifferential(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileFuncValues(t), DefaultHeapBytes, allocDriver, false)
 	vectors := append(funcVectors(20261014, 1500), FuncVectorsForTest()...)
 	var want []string
@@ -177,6 +178,7 @@ func envLimit(kind byte) int {
 // exactly: the value that does not fit aborts, after exactly the predicted
 // number; native Go never runs out, so the expectation is computed.
 func TestClosureEnvironmentHeap(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileFuncValues(t), DefaultHeapBytes, allocDriver, false)
 	counted := func(n int, done bool, kind byte) string {
 		out := make([]byte, 1024)
diff --git a/internal/compiler/funcs_sbf_test.go b/internal/compiler/funcs_sbf_test.go
index 37d39108..5547cc48 100644
--- a/internal/compiler/funcs_sbf_test.go
+++ b/internal/compiler/funcs_sbf_test.go
@@ -137,6 +137,7 @@ func closureCallCase(mode, n byte) allocCase {
 // the v1.57 backend or a runner (make test). GOSVM_FUNC_RESULTS=<dir> keeps
 // fixtures, ELFs, reports and a summary.
 func TestFuncValuesSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/funcs_test.go b/internal/compiler/funcs_test.go
index e1431e6a..bdd643b4 100644
--- a/internal/compiler/funcs_test.go
+++ b/internal/compiler/funcs_test.go
@@ -44,6 +44,7 @@ func funcMessage(t *testing.T, source string) string {
 }
 
 func TestFuncAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"function value":           `f := add; return f(1, 2)`,
 		"named function type":      `var o Op = add; return o(3, 4)`,
@@ -96,6 +97,7 @@ func (UF) Do(f Op) uint64 { return f(1, 2) }
 }
 
 func TestFuncRejections(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ source, want string }{
 		// Recursion through function values: a call through a value may run
 		// every target of its signature (the address-taken set).
@@ -164,6 +166,7 @@ func TestFuncRejections(t *testing.T) {
 // The backend view: targets, classes, closures with their environments,
 // defer sites, and captured variables moved to the heap.
 func TestCheckedProgramFunctions(t *testing.T) {
+	t.Parallel()
 	source := funcPrefix + `x := uint64(s[0])
 	f := func() uint64 { return x }
 	g := add
@@ -256,6 +259,7 @@ func TestCheckedProgramFunctions(t *testing.T) {
 
 // A closure can capture the Context; a deferred one writes account data.
 func TestFuncContextCapture(t *testing.T) {
+	t.Parallel()
 	source := "package p\nimport \"gosvm/solana\"\nfunc Process(c solana.Context) uint64 {\n" +
 		"defer func() { solana.Data(c, 0)[0] = 1 }()\nn := func() uint64 { return solana.Count(c) }\nreturn n()\n}\n"
 	c, err := CompileProgram(&Program{Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "f.go", Data: []byte(source)}}}}})
@@ -268,6 +272,7 @@ func TestFuncContextCapture(t *testing.T) {
 // Programs without function values or defer emit no function-value
 // runtime; named results alone need none either.
 func TestFuncRuntimeOnlyWhenUsed(t *testing.T) {
+	t.Parallel()
 	for _, tc := range []struct {
 		body string
 		used bool
diff --git a/internal/compiler/funcstrings_diff_test.go b/internal/compiler/funcstrings_diff_test.go
index 61834a80..65d1bff1 100644
--- a/internal/compiler/funcstrings_diff_test.go
+++ b/internal/compiler/funcstrings_diff_test.go
@@ -85,6 +85,7 @@ func compileFuncStrings(t *testing.T) []byte {
 }
 
 func TestFuncStringsDifferential(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileFuncStrings(t), DefaultHeapBytes, allocDriver, false)
 	vectors := funcStringVectors(20261014, 1500)
 	var want []string
@@ -167,6 +168,7 @@ func funcStringInput(kind byte, n int) []byte {
 // not fit aborts after exactly the predicted number; native Go never runs
 // out, so the expectation is computed.
 func TestClosureStringHeap(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileFuncStrings(t), DefaultHeapBytes, allocDriver, false)
 	counted := func(n int, done bool, kind byte) string {
 		out := make([]byte, 1024)
diff --git a/internal/compiler/generic_arrays_test.go b/internal/compiler/generic_arrays_test.go
index 55e7e984..14e60239 100644
--- a/internal/compiler/generic_arrays_test.go
+++ b/internal/compiler/generic_arrays_test.go
@@ -192,6 +192,7 @@ func genericArrayInputs(count int) [][]byte {
 }
 
 func TestGenericArrayTypeArgsDifferential(t *testing.T) {
+	t.Parallel()
 	inputs := genericArrayInputs(256)
 	for name, src := range genericArrayPrograms {
 		t.Run(name, func(t *testing.T) {
@@ -224,6 +225,7 @@ func TestGenericArrayTypeArgsDifferential(t *testing.T) {
 // (each was "array type was not declared before use"), and the storage
 // rules inside them still apply.
 func TestGenericArrayTypeArgsForms(t *testing.T) {
+	t.Parallel()
 	const decls = `type Pair[K any, V any] struct { Key K; Value V }
 type Box[T any] struct { V [][3]T }
 type PB[T any] struct { P *[4]T }
@@ -279,6 +281,7 @@ func Id[T any](x T) T { return x }
 }
 
 func TestGenericArrayTypeArgsSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/generics_sbf_test.go b/internal/compiler/generics_sbf_test.go
index 28e49f93..af66e486 100644
--- a/internal/compiler/generics_sbf_test.go
+++ b/internal/compiler/generics_sbf_test.go
@@ -21,6 +21,7 @@ import (
 // platform-tools v1.57 is absent, and skips the runs (after building) when the
 // managed runners are not installed.
 func TestGenericSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
@@ -121,6 +122,7 @@ func Process(s, i []byte) uint64 {
 // compile to the same SBF machine code as hand-written per-type copies, so
 // size and compute units are identical.
 func TestGenericMatchesHandwrittenSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF builds are skipped in -short mode")
 	}
diff --git a/internal/compiler/generics_test.go b/internal/compiler/generics_test.go
index 94d37069..73fd1d50 100644
--- a/internal/compiler/generics_test.go
+++ b/internal/compiler/generics_test.go
@@ -40,6 +40,7 @@ func genericCheck(t *testing.T, source string) string {
 const unsigned = "type Unsigned interface{ ~uint8 | ~uint16 | ~uint32 | ~uint64 }\n"
 
 func TestGenericAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, source := range map[string]string{
 		"inferred and explicit": unsigned + `func Min[T Unsigned](a, b T) T { if a < b { return a }; return b }
 func Process(s, i []byte) uint64 { return Min(uint64(s[0]), 2) + uint64(Min[uint8](s[0], s[1])) + uint64(Min[uint16](3, 4)) }`,
@@ -101,6 +102,7 @@ func Process(s, i []byte) uint64 { a, b := Split(s[0]); h := Head(s, uint32(2));
 }
 
 func TestGenericRejections(t *testing.T) {
+	t.Parallel()
 	limit := func(format string) string {
 		var b strings.Builder
 		b.WriteString("func Process(s, i []byte) uint64 {\n")
@@ -165,6 +167,7 @@ func TestGenericRejections(t *testing.T) {
 // A library package's generic types and functions are instantiated with the
 // importing package's types; the instance belongs to the generic's package.
 func TestGenericCrossPackage(t *testing.T) {
+	t.Parallel()
 	lib := `package lib
 type Unsigned interface{ ~uint32 | ~uint64 }
 type Stack[T any] struct { top, prev T; n uint64 }
@@ -211,6 +214,7 @@ func Process(s, i []byte) uint64 {
 // CheckedProgram lists each instantiation as an ordinary function, in place
 // of its generic declaration, with its own callees and borrow summary.
 func TestCheckedProgramInstances(t *testing.T) {
+	t.Parallel()
 	checked, err := Check(genericSource(`type Box[T any] struct{ V T }
 func (b *Box[T]) Ref() *T { return &b.V }
 func Pick[T any](a T, s []byte) T { return a }
@@ -285,6 +289,7 @@ func Process(s, i []byte) uint64 {
 // Box[uint8] as distinct, identical instances, which share one key, one C
 // struct, one field layout and one instance per method.
 func TestGenericAliasSpellingsShareInstances(t *testing.T) {
+	t.Parallel()
 	source := `type Box[T any] struct{ V T; N uint64 }
 func (b *Box[T]) Set(v T) { b.V = v; b.N++ }
 func Id[T any](x T) T { return x }
@@ -343,6 +348,7 @@ func symbols(c []byte) []string {
 // every instance and type-instance symbol (local temporaries are numbered in
 // emission order, for generic and ordinary code alike).
 func TestGenericNamesAreDeterministic(t *testing.T) {
+	t.Parallel()
 	source, err := os.ReadFile("../../examples/generic-values/program.go")
 	if err != nil {
 		t.Fatal(err)
@@ -384,6 +390,7 @@ func TestGenericNamesAreDeterministic(t *testing.T) {
 }
 
 func TestMangleIsInjective(t *testing.T) {
+	t.Parallel()
 	keys := []string{"a.F[uint8]", "a.F[uint8]_", "a.F_5buint8]", "a_DF", "a.DF", "a._DF", "a/b.F[x, y]", "a/b.F[x,y]", "a.S[*a.T].M", "a.S[a.T].M", "a.F[[2]uint8]", "é.F", "_xc3_xa9.F"}
 	seen := map[string]string{}
 	for _, k := range keys {
@@ -401,6 +408,7 @@ func TestMangleIsInjective(t *testing.T) {
 // Programs without generics lower to their own files: no instance or type
 // instance, and the lowered view is the original syntax.
 func TestNoGenericsLowersToItself(t *testing.T) {
+	t.Parallel()
 	checked, err := Check(genericSource("type P struct{ a uint64 }\nfunc (p P) A() uint64 { return p.a }\nfunc Process(s, i []byte) uint64 { return P{1}.A() }"))
 	if err != nil {
 		t.Fatal(err)
@@ -448,6 +456,7 @@ func genericVectors() []oracleVector {
 // instance (four unsigned widths, structs, arrays, pointers, nested calls)
 // must match Go's results, panics and state.
 func TestGenericDifferential(t *testing.T) {
+	t.Parallel()
 	differential(t, "../../examples/generic-values/program.go", genericvalues.Process, genericVectors())
 }
 
diff --git a/internal/compiler/globals_diff_test.go b/internal/compiler/globals_diff_test.go
index a1f9c9d8..f7581d60 100644
--- a/internal/compiler/globals_diff_test.go
+++ b/internal/compiler/globals_diff_test.go
@@ -198,6 +198,7 @@ func compareGlobalVectors(t *testing.T, bin string, vectors [][]byte, want []str
 }
 
 func TestGlobalsDifferential(t *testing.T) {
+	t.Parallel()
 	oracle := globalOracle(t)
 	bin := hostCompile(t, compileGlobals(t, nil), DefaultHeapBytes, allocDriver, false)
 	vectors := append(globalVectors(20261014, 300), GlobalVectorsForTest()...)
diff --git a/internal/compiler/globals_sbf_test.go b/internal/compiler/globals_sbf_test.go
index ecb6fe9c..69be9fc1 100644
--- a/internal/compiler/globals_sbf_test.go
+++ b/internal/compiler/globals_sbf_test.go
@@ -130,6 +130,7 @@ func runGlobalProgram(t *testing.T, llvm, runner, profile, name string, program
 // Skips without the v1.57 backend or a runner (make test).
 // GOSVM_GLOBAL_RESULTS=<dir> keeps fixtures, ELFs, reports and a summary.
 func TestGlobalsSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/globals_test.go b/internal/compiler/globals_test.go
index ef13b4b9..5c3280a5 100644
--- a/internal/compiler/globals_test.go
+++ b/internal/compiler/globals_test.go
@@ -50,6 +50,7 @@ func resultOf(t *testing.T, out string) string {
 // Each program's Process returns the value native Go returns (worked out by
 // hand and noted beside each case); each run starts from fresh variables.
 func TestGlobalAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, tc := range map[string]struct {
 		src  string
 		want string
@@ -133,6 +134,7 @@ func Process(o, in []byte) uint64 { a := [2]uint64{1, 2}; keep = a[:]; a[1] = 9;
 // path) and files within a package by name; qualified variables are read,
 // written, addressed and called across packages.
 func TestGlobalPackages(t *testing.T) {
+	t.Parallel()
 	logPkg := unitFiles("ex/log", `package log
 var Trace []byte
 func Mark(b byte) byte { Trace = append(Trace, b); return b }`)
@@ -190,6 +192,7 @@ var C = log.Mark('c') - 'c'`),
 // Read-only placement is decided by every use; anything that could write the
 // variable keeps it in the globals block.
 func TestGlobalReadOnly(t *testing.T) {
+	t.Parallel()
 	src := `package p
 type S struct{ a uint64; b [2]uint8 }
 func (s *S) Ptr() uint64 { return s.a }
@@ -310,6 +313,7 @@ func Process(o, in []byte) uint64 {
 }
 
 func TestGlobalRejections(t *testing.T) {
+	t.Parallel()
 	for name, tc := range map[string]struct{ src, want string }{
 		"context variable": {`import "gosvm/solana"
 var d solana.Context
@@ -352,6 +356,7 @@ func Process(s, i []byte) uint64 { x1.a[0]++; x2.a[0]++; x3.a[0]++; x4.a[0]++; x
 // The globals block is the invocation heap's first allocation: with a block
 // of B bytes, 32,760 - B bytes remain for everything else.
 func TestGlobalHeapAccounting(t *testing.T) {
+	t.Parallel()
 	src := `package p
 var counters [5]uint64 // 40 bytes
 var flag bool          // 1 byte: the block is 48 bytes
@@ -381,6 +386,7 @@ func Process(o, in []byte) uint64 {
 // A trap during initialization aborts before Process runs: nothing is
 // written (Go panics before main).
 func TestGlobalInitTrap(t *testing.T) {
+	t.Parallel()
 	for name, src := range map[string]string{
 		"initializer": `var zero uint64
 var bad = 10 / zero
@@ -405,6 +411,7 @@ func Process(o, in []byte) uint64 { o[0] = 1; return 0 }`,
 // same expression, as gc does: a call that changes it is seen
 // (docs/ERROR_CONTRACT.md#evaluation-order).
 func TestGlobalOperandOrder(t *testing.T) {
+	t.Parallel()
 	src := `package p
 var x uint64 = 1
 func f() uint64 { x = 10; return 0 }
@@ -417,6 +424,7 @@ func Process(o, in []byte) uint64 { return x + f() }`
 // Programs without package variables or init functions get none of the
 // runtime; programs whose variables are all read-only get no initialization.
 func TestGlobalRuntimeOnlyWhenUsed(t *testing.T) {
+	t.Parallel()
 	for name, tc := range map[string]struct {
 		src          string
 		block, inits bool
@@ -444,6 +452,7 @@ func TestGlobalRuntimeOnlyWhenUsed(t *testing.T) {
 // package's synthetic Vars initializer assigns its non-read-only
 // initializers in go/types order; init functions follow in source order.
 func TestCheckedProgramGlobals(t *testing.T) {
+	t.Parallel()
 	src := `package p
 var a = b + 1
 var b uint64 = 2
diff --git a/internal/compiler/globaltables_test.go b/internal/compiler/globaltables_test.go
index f2727496..e9209274 100644
--- a/internal/compiler/globaltables_test.go
+++ b/internal/compiler/globaltables_test.go
@@ -17,6 +17,7 @@ type Pair struct{ K uint32; V uint64 }
 `
 
 func TestLargeTablesAccepted(t *testing.T) {
+	t.Parallel()
 	for name, tc := range map[string]struct{ src, want string }{
 		// Read-only data: a constant [60]Int and a [300]Pair table (4,800
 		// bytes, above the 4 KiB SBF stack frame).
@@ -73,6 +74,7 @@ func Process(o, in []byte) uint64 {
 }
 
 func TestLargeTablesRejected(t *testing.T) {
+	t.Parallel()
 	const limit = "array storage exceeds experimental 1024-byte per-value limit"
 	for name, src := range map[string]string{
 		"local":                     `var pows [60]Int; func Process(o, in []byte) uint64 { var l [60]Int; return l[0][0] + pows[0][0] }`,
diff --git a/internal/compiler/globalvaluetypes_diff_test.go b/internal/compiler/globalvaluetypes_diff_test.go
index be34d2ec..eea53b19 100644
--- a/internal/compiler/globalvaluetypes_diff_test.go
+++ b/internal/compiler/globalvaluetypes_diff_test.go
@@ -152,6 +152,7 @@ func compareLines(t *testing.T, bin string, vectors [][]byte, want []string) {
 }
 
 func TestGlobalValueTypesDifferential(t *testing.T) {
+	t.Parallel()
 	oracle := goBinary(t, "../..", "./examples/global-value-types/oracle")
 	c, err := CompileProgram(globalValueTypesProgram(t, nil))
 	if err != nil {
@@ -192,6 +193,7 @@ func TestGlobalValueTypesDifferential(t *testing.T) {
 // constant initializers (including the two above the per-value limit) are
 // read-only data; written ones are in the globals block.
 func TestGlobalValueTypesPlacement(t *testing.T) {
+	t.Parallel()
 	checked, err := Check(globalValueTypesProgram(t, nil))
 	if err != nil {
 		t.Fatal(err)
@@ -298,6 +300,7 @@ func initPanicProgram(src, lib string, sbf bool) *Program {
 // host-compiled C: the C must log the same line (none for a runtime error)
 // and abort with Process's output untouched.
 func TestGlobalInitPanics(t *testing.T) {
+	t.Parallel()
 	for _, probe := range globalInitPanicProbes {
 		t.Run(probe.name, func(t *testing.T) {
 			dir := t.TempDir()
diff --git a/internal/compiler/globalvaluetypes_sbf_test.go b/internal/compiler/globalvaluetypes_sbf_test.go
index c3f8a263..a2376cb6 100644
--- a/internal/compiler/globalvaluetypes_sbf_test.go
+++ b/internal/compiler/globalvaluetypes_sbf_test.go
@@ -67,6 +67,7 @@ func oracleCase(t *testing.T, name string, in []byte, line string) allocCase {
 // line. Skips without the v1.57 backend or a runner (make test).
 // GOSVM_GLOBAL_RESULTS=<dir> keeps fixtures, ELFs, reports and a summary.
 func TestGlobalValueTypesSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/iface_diff_test.go b/internal/compiler/iface_diff_test.go
index bd75c0f1..d5c2b4b3 100644
--- a/internal/compiler/iface_diff_test.go
+++ b/internal/compiler/iface_diff_test.go
@@ -81,6 +81,7 @@ func ifaceVectors(seed int64, perMode int) [][]byte {
 func IfaceVectorsForTest() [][]byte { return ifaceVectors(20261017, 24) }
 
 func TestInterfaceDifferential(t *testing.T) {
+	t.Parallel()
 	c, err := CompileProgram(&Program{Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "program.go", Data: ifaceSource(t)}}}}})
 	if err != nil {
 		t.Fatal(err)
@@ -158,6 +159,7 @@ var boxLimits = map[byte]int{0: 4095, 1: 1365, 2: -1, 3: -1, 4: 4095, 5: 4095}
 // conversion that does not fit aborts, after exactly the predicted number of
 // conversions; native Go never runs out, so the expectation is computed.
 func TestInterfaceBoxingHeap(t *testing.T) {
+	t.Parallel()
 	c, err := CompileProgram(&Program{Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "program.go", Data: ifaceSource(t)}}}}})
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/compiler/iface_sbf_test.go b/internal/compiler/iface_sbf_test.go
index dda987d0..e49524b3 100644
--- a/internal/compiler/iface_sbf_test.go
+++ b/internal/compiler/iface_sbf_test.go
@@ -149,6 +149,7 @@ func dispatchCase(mode, n byte, u bool) allocCase {
 // the v1.57 backend or a runner (make test). GOSVM_IFACE_RESULTS=<dir> keeps
 // fixtures, ELFs, reports and a summary.
 func TestInterfaceSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/iface_test.go b/internal/compiler/iface_test.go
index 5001f34f..ba7d920a 100644
--- a/internal/compiler/iface_test.go
+++ b/internal/compiler/iface_test.go
@@ -41,6 +41,7 @@ func Process(s, i []byte) uint64 {
 `
 
 func TestInterfaceAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"any variable":            `var a any; _ = a`,
 		"nil interface":           `var a any = nil; if a == nil { s[0] = 1 }`,
@@ -93,6 +94,7 @@ func TestInterfaceAcceptedForms(t *testing.T) {
 }
 
 func TestInterfaceRejections(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ body, want string }{
 		"float boxing":            {`var a any = 1.5; _ = a`, "unsupported type float64"},
 		"zero-size part":          {`type Z struct{ a [0]byte; b uint64 }; _ = Z{}`, "unsupported local declaration"},
@@ -141,6 +143,7 @@ func TestInterfaceRejections(t *testing.T) {
 // The checked program lists conversions, dynamic types (IDs in key order),
 // method slots, method tables, dynamic calls, assertions and type switches.
 func TestCheckedProgramInterfaces(t *testing.T) {
+	t.Parallel()
 	source := ifacePrefix + `var x Solid = &R{1, 1}
 	x.Scale(2)
 	var g Getter[int8] = Box[int8]{-1}
@@ -213,6 +216,7 @@ func TestCheckedProgramInterfaces(t *testing.T) {
 // Converting a reference to an interface is an escape: the referenced local
 // moves to the heap; an interface value holding only heap data moves nothing.
 func TestInterfaceHeapMoves(t *testing.T) {
+	t.Parallel()
 	source := `package p
 type I interface{ M(p *uint64) *uint64 }
 type T struct{}
@@ -268,6 +272,7 @@ func Process(s, i []byte) uint64 {
 // Programs without interface values emit no interface runtime; the C of an
 // interface program is deterministic.
 func TestInterfaceRuntimeOnlyWhenUsed(t *testing.T) {
+	t.Parallel()
 	plain := "package p\ntype C interface{ ~uint8 }\nfunc Id[T C](x T) T { return x }\nfunc Process(s, i []byte) uint64 { return uint64(Id(s[0])) }\n"
 	out, err := Compile("a.go", []byte(plain))
 	if err != nil {
@@ -292,6 +297,7 @@ func TestInterfaceRuntimeOnlyWhenUsed(t *testing.T) {
 // Unexported interface methods are package-qualified: a type in another
 // package with a method of the same name does not implement the interface.
 func TestInterfaceCrossPackage(t *testing.T) {
+	t.Parallel()
 	lib := `package lib
 type Counter interface {
 	inc() uint64
diff --git a/internal/compiler/initeval_diff_test.go b/internal/compiler/initeval_diff_test.go
index a4587f1e..b9d2a4e8 100644
--- a/internal/compiler/initeval_diff_test.go
+++ b/internal/compiler/initeval_diff_test.go
@@ -88,6 +88,7 @@ func constInitVectors(seed int64, n int) [][]byte {
 func ConstInitVectorsForTest() [][]byte { return constInitVectors(20261016, 120) }
 
 func TestConstInitDifferential(t *testing.T) {
+	t.Parallel()
 	oracle := buildOracle(t, "./examples/const-init/oracle")
 	vectors := append(constInitVectors(20261017, 900), ConstInitVectorsForTest()...)
 	want := nativeGlobals(t, oracle, vectors)
@@ -165,6 +166,7 @@ func initHeap(t *testing.T, program *Program) (string, string) {
 // the allocator's in-use word after initialization is the same, so every
 // out-of-memory boundary is; and the heap's live contents are the same.
 func TestInitImageHeapAccounting(t *testing.T) {
+	t.Parallel()
 	programs := map[string]func() *Program{
 		"const-init":    func() *Program { return constInitProgram(t) },
 		"global-values": func() *Program { return globalProgramSources(t, nil) },
diff --git a/internal/compiler/initeval_sbf_test.go b/internal/compiler/initeval_sbf_test.go
index 36c76549..51bc4a81 100644
--- a/internal/compiler/initeval_sbf_test.go
+++ b/internal/compiler/initeval_sbf_test.go
@@ -92,6 +92,7 @@ func keepDir(t *testing.T, keep, profile string) string {
 // measures initialization (the idle vector) both ways.
 // GOSVM_CONSTINIT_RESULTS=<dir> keeps fixtures, ELFs, reports and a summary.
 func TestConstInitSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
@@ -151,6 +152,7 @@ func TestConstInitSBF(t *testing.T) {
 // line, and that an image under a heap budget above 32 KiB faults at entry
 // without a large enough heap frame, as the first allocation does.
 func TestInitEvalEdgesSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
@@ -237,6 +239,7 @@ var realLibsInitMeasured = []string{"none", "uint256", "int256", "uint128", "con
 // CU includes initialization. Outputs must match the libraries run
 // natively both ways. GOSVM_CONSTINIT_RESULTS=<dir> keeps the reports.
 func TestRealLibrariesInitSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/initeval_test.go b/internal/compiler/initeval_test.go
index a74bf53b..06d2e622 100644
--- a/internal/compiler/initeval_test.go
+++ b/internal/compiler/initeval_test.go
@@ -92,6 +92,7 @@ func initEvalProgram(c initEvalCase) *Program {
 }
 
 func TestInitEvalStops(t *testing.T) {
+	t.Parallel()
 	for name, c := range initEvalCases {
 		t.Run(name, func(t *testing.T) {
 			checked, err := Check(initEvalProgram(c))
@@ -145,6 +146,7 @@ func TestInitEvalStops(t *testing.T) {
 // the variable, strings built at initialization are heap bytes, and each
 // PackageInit records the steps the image covers.
 func TestInitImageCheckedProgram(t *testing.T) {
+	t.Parallel()
 	src := `package p
 type T struct{ a, b uint64 }
 var arr [4]uint16
@@ -227,6 +229,7 @@ func Process(o, in []byte) uint64 { return x.a + y.b + uint64(view[1]) + uint64(
 // RuntimeInit disables compile-time evaluation: no image, and the C runs
 // every initializer as before it existed.
 func TestInitEvalRuntimeInit(t *testing.T) {
+	t.Parallel()
 	p := globalsProgram(unitFiles("program", `package p
 var a = f()
 func f() uint64 { return 4 }
@@ -252,6 +255,7 @@ func Process(s, i []byte) uint64 { return a }`))
 // of its synthetic initializer at run time, from the first one not
 // evaluated.
 func TestInitEvalPartialPackage(t *testing.T) {
+	t.Parallel()
 	src := `package p
 type T struct{ n uint64 }
 var a = &T{1}
diff --git a/internal/compiler/intvalues_sbf_test.go b/internal/compiler/intvalues_sbf_test.go
index 7f8a6d2a..36a5a045 100644
--- a/internal/compiler/intvalues_sbf_test.go
+++ b/internal/compiler/intvalues_sbf_test.go
@@ -69,6 +69,7 @@ func intProbeCases() []probeCase {
 // without the v1.57 backend or a runner. GOSVM_INT_RESULTS=<dir> keeps the
 // fixtures, ELFs and runner reports.
 func TestIntValuesSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/intvalues_test.go b/internal/compiler/intvalues_test.go
index bf3fa6e3..7ba69f4f 100644
--- a/internal/compiler/intvalues_test.go
+++ b/internal/compiler/intvalues_test.go
@@ -295,6 +295,7 @@ int main(void) {
 // and remainder by zero and negative shift counts abort exactly where Go
 // panics, and MinInt / -1 and MinInt % -1 do not.
 func TestIntValuesDifferential(t *testing.T) {
+	t.Parallel()
 	bin := hostSources(t, intValuesSources(t), intHostDriver)
 	vectors := intVectors(300)
 	var input strings.Builder
diff --git a/internal/compiler/keccak_sbf_test.go b/internal/compiler/keccak_sbf_test.go
index bcc4ad58..b9b17e5f 100644
--- a/internal/compiler/keccak_sbf_test.go
+++ b/internal/compiler/keccak_sbf_test.go
@@ -25,6 +25,7 @@ import (
 // the v1.57 backend or a runner. GOSVM_KECCAK_RESULTS=<dir> keeps the
 // fixtures, ELFs and reports.
 func TestKeccak256SBF(t *testing.T) {
+	t.Parallel()
 	llvm := modernLLVM()
 	if llvm == "" {
 		t.Skip("pinned platform-tools v1.57 backend required")
diff --git a/internal/compiler/keccak_test.go b/internal/compiler/keccak_test.go
index f8fa01b4..79e5cf8e 100644
--- a/internal/compiler/keccak_test.go
+++ b/internal/compiler/keccak_test.go
@@ -64,6 +64,7 @@ func keccak256(data []byte) []byte {
 }
 
 func TestKeccakReference(t *testing.T) {
+	t.Parallel()
 	for input, want := range map[string]string{
 		"":    "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
 		"abc": "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45",
@@ -76,6 +77,7 @@ func TestKeccakReference(t *testing.T) {
 }
 
 func TestSDK2Keccak256NativeCDifferential(t *testing.T) {
+	t.Parallel()
 	source := strings.Replace(string(mustRead(t, filepath.Join("testdata", "keccak", "program.go"))), "package program", "package app", 1)
 	p := &Program{SDK: 2, Entry: "app", Packages: []PackageSources{unit("app", source)}}
 	c, err := CompileProgram(p)
diff --git a/internal/compiler/lamports_test.go b/internal/compiler/lamports_test.go
index eefd9688..a7d3f8ff 100644
--- a/internal/compiler/lamports_test.go
+++ b/internal/compiler/lamports_test.go
@@ -16,6 +16,7 @@ import (
 // MoveLamports' runtime is emitted only for programs that call it, so the C
 // of every other program is unchanged; SDK 1 does not have it.
 func TestSDK2MoveLamportsEmittedOnlyWhenCalled(t *testing.T) {
+	t.Parallel()
 	plain := `package app;import "gosvm/solana";func Process(c solana.Context)uint64{return solana.CloseAccount(c,0,1)}`
 	moving := `package app;import "gosvm/solana";func Process(c solana.Context)uint64{return solana.MoveLamports(c,0,1,2)}`
 	for _, tc := range []struct {
@@ -39,6 +40,7 @@ func TestSDK2MoveLamportsEmittedOnlyWhenCalled(t *testing.T) {
 // through duplicate descriptors, under undefined-behaviour sanitization.
 // Accounts 2 and 3 duplicate 0 and 1, so moves between them alias.
 func TestSDK2MoveLamportsNativeCDifferential(t *testing.T) {
+	t.Parallel()
 	source := `package app
 import "gosvm/solana"
 func Process(c solana.Context)uint64{
diff --git a/internal/compiler/lifecycle_test.go b/internal/compiler/lifecycle_test.go
index e816692b..c0231f77 100644
--- a/internal/compiler/lifecycle_test.go
+++ b/internal/compiler/lifecycle_test.go
@@ -16,6 +16,7 @@ import (
 )
 
 func TestSDK2LifecycleLoaderSelection(t *testing.T) {
+	t.Parallel()
 	plain := `package app;import "gosvm/solana";func Process(c solana.Context)uint64{return solana.Count(c)}`
 	for _, sdk := range []int{0, 1, 2} {
 		p := &Program{SDK: sdk, Entry: "app", Packages: []PackageSources{unit("app", plain)}}
@@ -39,6 +40,7 @@ func TestSDK2LifecycleLoaderSelection(t *testing.T) {
 }
 
 func TestSDK2OwnedLifecycleDifferential(t *testing.T) {
+	t.Parallel()
 	source := `package app
 import "gosvm/solana"
 func Process(c solana.Context)uint64{
@@ -159,6 +161,7 @@ int main(void){u64 mode,n,original,w,x,owned,dw,dx,left,right,rc;
 }
 
 func TestSDK2RentCalculationC(t *testing.T) {
+	t.Parallel()
 	p, err := ReadProgram("../../examples/lifecycle2")
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/compiler/log_test.go b/internal/compiler/log_test.go
index 4aa1a1af..6aa60eeb 100644
--- a/internal/compiler/log_test.go
+++ b/internal/compiler/log_test.go
@@ -14,6 +14,7 @@ import (
 // The logging runtime is emitted only for programs that call Log, Log64 or
 // LogPubkey; SDK 1 does not have them.
 func TestSDK2LogRuntimeEmittedOnlyWhenCalled(t *testing.T) {
+	t.Parallel()
 	for _, tc := range []struct {
 		source string
 		want   bool
@@ -42,6 +43,7 @@ func TestSDK2LogRuntimeEmittedOnlyWhenCalled(t *testing.T) {
 // same bytes for Log, the same words for Log64 and key for LogPubkey, and
 // the same statuses.
 func TestSDK2LogNativeCDifferential(t *testing.T) {
+	t.Parallel()
 	source := `package app
 import "gosvm/solana"
 func word(b []byte,o uint64)uint64{n:=uint64(0);for j:=uint64(0);j<8;j++{n=n|uint64(b[o+j])<<(j*8)};return n}
diff --git a/internal/compiler/maps_diff_test.go b/internal/compiler/maps_diff_test.go
index d80b56d4..a426eebf 100644
--- a/internal/compiler/maps_diff_test.go
+++ b/internal/compiler/maps_diff_test.go
@@ -121,6 +121,7 @@ func runMapVectors(t *testing.T, bin string, vectors [][]byte) (map[byte]int, ma
 }
 
 func TestMapDifferential(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileMaps(t, 0), DefaultHeapBytes, allocDriver, false)
 	vectors := append(mapVectors(20261014, 600, 380), MapVectorsForTest()...)
 	panics, runs := runMapVectors(t, bin, vectors)
diff --git a/internal/compiler/maps_sbf_test.go b/internal/compiler/maps_sbf_test.go
index 86d782cb..49069318 100644
--- a/internal/compiler/maps_sbf_test.go
+++ b/internal/compiler/maps_sbf_test.go
@@ -108,6 +108,7 @@ func mapSBFCases() ([]allocCase, int) {
 // the v1.57 backend or a runner (make test). GOSVM_MAP_RESULTS=<dir> keeps
 // fixtures, ELFs, reports and a summary.
 func TestMapSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/maps_test.go b/internal/compiler/maps_test.go
index 8a844f05..f6ef218f 100644
--- a/internal/compiler/maps_test.go
+++ b/internal/compiler/maps_test.go
@@ -47,6 +47,7 @@ func Process(s, i []byte) uint64 {
 func mapMessage(t *testing.T, source string) string { return allocMessage(t, source) }
 
 func TestMapAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"make and index":       `m := make(map[uint64]uint64); m[1] = 2; s[0] = byte(m[1] + m[3])`,
 		"make hint":            `m := make(map[int8]uint8, i[0]); neg := -1; n := make(map[uint32]bool, neg); m[-1] = 1; n[1] = true; s[0] = byte(len(m) + len(n))`,
@@ -111,6 +112,7 @@ func TestMapAcceptedForms(t *testing.T) {
 }
 
 func TestMapRejections(t *testing.T) {
+	t.Parallel()
 	const noRange = rangeMapRule
 	cases := map[string][2]string{
 		"range key value":    {`m := map[int]int{}; for k, v := range m { _, _ = k, v }`, noRange},
@@ -322,6 +324,7 @@ var mapHeapKinds = [][2]int{{0, 0}, {1, 1}, {1, 7}, {1, 384}, {1, 385}, {1, 768}
 // TestMapHeap checks the exact out-of-memory point of map growth with the
 // default 32 KiB heap against the documented accounting.
 func TestMapHeap(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileMaps(t, 0), DefaultHeapBytes, allocDriver, false)
 	oom := fmt.Sprintf("P:%x\n", make([]byte, 1024))
 	checked := 0
@@ -368,6 +371,7 @@ func TestMapHeap(t *testing.T) {
 // TestCheckedProgramMaps: the backend view lists every map type with its
 // sizes, slot size and whether hashing a key can abort.
 func TestCheckedProgramMaps(t *testing.T) {
+	t.Parallel()
 	source := `package p
 type K struct {
 	A uint8
@@ -420,6 +424,7 @@ func Process(s, i []byte) uint64 {
 // TestMapRuntimeOnlyWhenUsed: programs without maps carry no map runtime;
 // the C of a map program is deterministic.
 func TestMapRuntimeOnlyWhenUsed(t *testing.T) {
+	t.Parallel()
 	without, err := Compile("a.go", []byte("package p\nfunc Process(s, i []byte) uint64 { b := make([]byte, 2); return uint64(len(b)) }\n"))
 	if err != nil {
 		t.Fatal(err)
@@ -447,6 +452,7 @@ func TestMapRuntimeOnlyWhenUsed(t *testing.T) {
 // TestMapDocumentationExample compiles and runs the example in
 // docs/GO_MAPS.md.
 func TestMapDocumentationExample(t *testing.T) {
+	t.Parallel()
 	doc := string(mustRead(t, "../../docs/GO_MAPS.md"))
 	start := strings.Index(doc, "```go\n")
 	if start < 0 {
@@ -465,6 +471,7 @@ func TestMapDocumentationExample(t *testing.T) {
 // by assignment or in a literal) moves its local to the heap; lookups and
 // deletes do not; elements read from a map are heap storage.
 func TestMapHeapMoves(t *testing.T) {
+	t.Parallel()
 	source := `package p
 type P struct{ X uint64 }
 func get(m map[int]*uint64) *uint64 { v, _ := m[1]; return v }
diff --git a/internal/compiler/memmove_sbf_test.go b/internal/compiler/memmove_sbf_test.go
index bc6605cf..4c2aa6e8 100644
--- a/internal/compiler/memmove_sbf_test.go
+++ b/internal/compiler/memmove_sbf_test.go
@@ -23,6 +23,7 @@ import (
 // without defining it, so every library-free program that LLVM lowered to a
 // memmove call failed to build.
 func TestMemmoveHelperCompiles(t *testing.T) {
+	t.Parallel()
 	cc, err := exec.LookPath("clang")
 	if err != nil {
 		t.Skip("host Clang required")
@@ -41,6 +42,7 @@ func TestMemmoveHelperCompiles(t *testing.T) {
 // copies LLVM lowers to memmove, for fogo-v0 and solana-v3 and checks the
 // copied account bytes, including a self-assignment, through the runners.
 func TestMemmoveSBF(t *testing.T) {
+	t.Parallel()
 	llvm := modernLLVM()
 	if llvm == "" {
 		t.Skip("pinned platform-tools v1.57 backend required")
diff --git a/internal/compiler/memops_diff_test.go b/internal/compiler/memops_diff_test.go
index 6e59b50d..2e799bc3 100644
--- a/internal/compiler/memops_diff_test.go
+++ b/internal/compiler/memops_diff_test.go
@@ -219,6 +219,7 @@ func MemoryVectorsForTest() [][]byte { return memoryVectors(20261019, 300) }
 // (SDK 2's word routines and the legacy byte routines) on the SBF vectors
 // and more random ones.
 func TestMemoryDifferential(t *testing.T) {
+	t.Parallel()
 	for _, sdk := range []int{0, 2} {
 		t.Run(fmt.Sprintf("sdk%d", sdk), func(t *testing.T) {
 			c, err := CompileProgram(&Program{SDK: sdk, Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "program.go", Data: memoryValuesSource(t)}}}}})
@@ -289,6 +290,7 @@ func runHostAll(t *testing.T, bin string, vectors [][]byte) string {
 // set compiled for SBF with the modern define, and the standalone memmove
 // helper, under -Werror.
 func TestMemorySyscallRoutinesCompileForSBF(t *testing.T) {
+	t.Parallel()
 	llvm := modernLLVM()
 	if llvm == "" {
 		t.Skip("pinned platform-tools v1.57 backend required")
@@ -320,6 +322,7 @@ func TestMemorySyscallRoutinesCompileForSBF(t *testing.T) {
 // TestZeroLoopForms checks which loops become a memset on SBF
 // (memclear.go): the two zeroing forms do; near misses compile as written.
 func TestZeroLoopForms(t *testing.T) {
+	t.Parallel()
 	for body, want := range map[string]bool{
 		`for i := range s { s[i] = 0 }`:                            true,
 		`for i := range w { w[i] = 0 }`:                            true,
diff --git a/internal/compiler/memops_sbf_test.go b/internal/compiler/memops_sbf_test.go
index 9f5411ce..f47a42da 100644
--- a/internal/compiler/memops_sbf_test.go
+++ b/internal/compiler/memops_sbf_test.go
@@ -44,7 +44,9 @@ var memoryVariants = []struct {
 	{"loops", 1 << 62},
 }
 
-// buildMemoryVariant builds source with the given thresholds.
+// buildMemoryVariant builds source with the given thresholds. It sets the
+// package-level memorySyscallMin, which every build reads, so its callers
+// must not call t.Parallel.
 func buildMemoryVariant(t *testing.T, dir, llvm, profile string, source []byte, threshold uint64) string {
 	t.Helper()
 	saved := memorySyscallMin
diff --git a/internal/compiler/memory_test.go b/internal/compiler/memory_test.go
index 93073272..5e70add3 100644
--- a/internal/compiler/memory_test.go
+++ b/internal/compiler/memory_test.go
@@ -14,6 +14,7 @@ import (
 )
 
 func TestSDK2AggregateMemory(t *testing.T) {
+	t.Parallel()
 	cc, err := exec.LookPath("clang")
 	if err != nil {
 		t.Skip("host Clang is needed for aggregate memory validation")
@@ -62,6 +63,7 @@ int main(void) {
 }
 
 func TestSDK2ArrayValueSemantics(t *testing.T) {
+	t.Parallel()
 	source, err := os.ReadFile("../../examples/array-values/program.go")
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/compiler/mixed_test.go b/internal/compiler/mixed_test.go
index 10e413aa..e523f605 100644
--- a/internal/compiler/mixed_test.go
+++ b/internal/compiler/mixed_test.go
@@ -38,6 +38,7 @@ func Process(s, i []byte) uint64 {
 `
 
 func TestMixedAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"generic make":              `w := Map([]int8{-1, 2}, -3); s[0] = byte(w[0])`,
 		"generic append field":      `var v Vec[int32]; v.Add(-1); v.Add(2); s[0] = byte(len(v.items))`,
@@ -77,6 +78,7 @@ func TestMixedAcceptedForms(t *testing.T) {
 }
 
 func TestMixedRejections(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ body, want string }{
 		"generic zero-size elements": {`_ = Lit[[0]byte]([0]byte{}, [0]byte{})`,
 			"instantiation Lit[[0]uint8]: alloc.go:15:1: slice elements must not contain zero-length arrays or empty structs"},
@@ -97,6 +99,7 @@ func TestMixedRejections(t *testing.T) {
 // moved parameters and locals are the instance's own objects, and an
 // instance whose values do not escape moves nothing.
 func TestMixedInstanceHeapMoves(t *testing.T) {
+	t.Parallel()
 	source := mixedPrefix + "p, q := Box(int16(-2)), Box(uint8(3)); h := Push[int64](nil, 1); _ = Id(int8(1)); ps := Ptrs([]int{1}); s[0] = byte(*p) + *q + byte(h.Val) + byte(*ps[0])\nreturn 0 }\n"
 	checked, err := Check(&Program{Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "alloc.go", Data: []byte(source)}}}}})
 	if err != nil {
@@ -145,6 +148,7 @@ func TestMixedInstanceHeapMoves(t *testing.T) {
 // uninstantiated generic function that would allocate adds nothing, and an
 // instance over byte slices that only reads them needs no runtime.
 func TestMixedHeapRuntimeOnlyForInstances(t *testing.T) {
+	t.Parallel()
 	plain := "package p\nfunc Process(s, i []byte) uint64 { return uint64(len(s)) }\n"
 	unused := "package p\nfunc Mk[T any](n int) []T { return make([]T, n) }\nfunc Sum[T ~[]E, E ~uint8](s T) uint64 { t := uint64(0); for _, v := range s { t = t + uint64(v) }; return t }\nfunc Process(s, i []byte) uint64 { return Sum(s) }\n"
 	used := "package p\nfunc Mk[T any](n int) []T { return make([]T, n) }\nfunc Process(s, i []byte) uint64 { return uint64(len(Mk[int8](3))) }\n"
@@ -221,6 +225,7 @@ func mixedSource(t *testing.T) []byte { return mustRead(t, "../../examples/mixed
 // C on the host (32 KiB heap, as on chain by default) and compares output
 // bytes, results and panics for every vector.
 func TestMixedDifferential(t *testing.T) {
+	t.Parallel()
 	c, err := CompileProgram(&Program{Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "program.go", Data: mixedSource(t)}}}}})
 	if err != nil {
 		t.Fatal(err)
@@ -291,6 +296,7 @@ func mixedSBFSource(t *testing.T) []byte {
 // completions must leave native Go's output bytes; panics must abort and roll
 // back. Skips without the v1.57 backend or a runner (make test).
 func TestMixedSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/packages_test.go b/internal/compiler/packages_test.go
index 31a93f0e..3ed6d0cc 100644
--- a/internal/compiler/packages_test.go
+++ b/internal/compiler/packages_test.go
@@ -19,6 +19,7 @@ func unit(path, source string) PackageSources {
 	return PackageSources{path, []Source{{path + "/program.go", []byte(source)}}}
 }
 func TestImportedValuesAndCalls(t *testing.T) {
+	t.Parallel()
 	p := &Program{Entry: "app", Packages: []PackageSources{
 		unit("app", `package app
 import first "shared/a"
@@ -57,6 +58,7 @@ func Process(b Box)uint64{return uint64(b.Key[0])+uint64(b.Key[1])+uint64(b.Key[
 	}
 }
 func TestImportedSDKAndEntryIdentity(t *testing.T) {
+	t.Parallel()
 	p := &Program{Entry: "app", Packages: []PackageSources{
 		unit("app", `package app;import "gosvm/solana";import "app/helper";func Process(c solana.Context)uint64{return helper.Process(c)}`),
 		unit("app/helper", `package helper;import chain "gosvm/solana";func Process(c chain.Context)uint64{return chain.Count(c)}`),
@@ -74,6 +76,7 @@ func TestImportedSDKAndEntryIdentity(t *testing.T) {
 	}
 }
 func TestImportedPackageRejections(t *testing.T) {
+	t.Parallel()
 	for name, source := range map[string]string{
 		"float global":                   `var N float64=1;func F()uint64{return 1}`,
 		"unsupported init":               `func init(){go g()};func g(){};func F()uint64{return 1}`,
@@ -207,6 +210,7 @@ func TestModuleImportsAndCache(t *testing.T) {
 	}
 }
 func TestModuleImportFailures(t *testing.T) {
+	t.Parallel()
 	for name, dep := range map[string][3]string{
 		"cycle":            {`import "example.com/app/program";func F()uint64{return program.Process(nil,nil)}`, "example.com/app/lib", "import cycle"},
 		"standard library": {`func F()uint64{return 0}`, "fmt", `unsupported import "fmt"; standard-library packages on chain`},
@@ -232,6 +236,7 @@ func TestModuleImportFailures(t *testing.T) {
 }
 
 func TestSharedExampleDifferential(t *testing.T) {
+	t.Parallel()
 	root, err := filepath.Abs("../../examples/shared-packages")
 	if err != nil {
 		t.Fatal(err)
@@ -332,6 +337,7 @@ func TestSharedExampleDifferential(t *testing.T) {
 }
 
 func TestImportedMainPackage(t *testing.T) {
+	t.Parallel()
 	p := &Program{Entry: "app", Packages: []PackageSources{
 		unit("app", `package app;import "dep";func Process(s,i []byte)uint64{return dep.F()}`),
 		unit("dep", `package main;func F()uint64{return 1}`),
@@ -341,6 +347,7 @@ func TestImportedMainPackage(t *testing.T) {
 	}
 }
 func TestResolverFlagLikeImport(t *testing.T) {
+	t.Parallel()
 	dir := t.TempDir()
 	writePackageFile(t, dir, "go.mod", "module example.com/app\n\ngo 1.22\n")
 	writePackageFile(t, dir, "program.go", `package p;import "-export";func Process(s,i []byte)uint64{return 0}`)
diff --git a/internal/compiler/packed_test.go b/internal/compiler/packed_test.go
index 642e79cd..287f1f04 100644
--- a/internal/compiler/packed_test.go
+++ b/internal/compiler/packed_test.go
@@ -37,6 +37,7 @@ func compilePackedStore(t *testing.T, sdk int, source string) []byte {
 }
 
 func TestPackedStoreRecognition(t *testing.T) {
+	t.Parallel()
 	for _, sdk := range []int{0, 1, 2} {
 		c := compilePackedStore(t, sdk, packedStoreSource)
 		want := 0
@@ -90,6 +91,7 @@ printf("%c:",driver_panic?'P':'W');for(int j=0;j<80;j++)printf("%02x",driver_dat
 return 0;}`
 
 func TestPackedStoreNativeCDifferential(t *testing.T) {
+	t.Parallel()
 	cc, err := exec.LookPath("clang")
 	if err != nil {
 		t.Skip("host Clang needed for packed stores")
diff --git a/internal/compiler/pointers_test.go b/internal/compiler/pointers_test.go
index 6d42052b..ca09b4c5 100644
--- a/internal/compiler/pointers_test.go
+++ b/internal/compiler/pointers_test.go
@@ -11,6 +11,7 @@ import (
 )
 
 func TestPointerValuesDifferential(t *testing.T) {
+	t.Parallel()
 	p, err := ReadProgram("../../examples/pointer-values")
 	if err != nil {
 		t.Fatal(err)
@@ -56,6 +57,7 @@ func TestPointerValuesDifferential(t *testing.T) {
 }
 
 func TestPointerLifetimeRejections(t *testing.T) {
+	t.Parallel()
 	for name, source := range map[string]string{
 		"named pointer":    `type P *uint64;func Process(s,i []byte)uint64{var p P;return *p}`,
 		"pointer slice":    `func Process(s,i []byte)uint64{p:=&s;return uint64(len(*p))}`,
@@ -72,6 +74,7 @@ func TestPointerLifetimeRejections(t *testing.T) {
 }
 
 func TestImportedMethodsAndBorrowedResults(t *testing.T) {
+	t.Parallel()
 	p := &Program{Entry: "app", Packages: []PackageSources{
 		unit("app", `package app;import "dep";func relay(v *dep.Value)(uint64,*uint64){return dep.Forward(v)};func Process(s,i []byte)uint64{v:=dep.Value{N:7};code,p:=relay(&v);*p=*p+5;old:=v.Read(2);v.Add(3);return code+old+v.N+(*dep.Value).Read(&v,1)}`),
 		unit("dep", `package dep;type Value struct{N uint64};func(v Value)Read(n uint64)uint64{v.N=v.N+n;return v.N};func(v *Value)Add(n uint64){v.N=v.N+n};func(v *Value)Field()*uint64{return &v.N};func Forward(v *Value)(uint64,*uint64){return 0,v.Field()}`),
@@ -101,6 +104,7 @@ func TestImportedMethodsAndBorrowedResults(t *testing.T) {
 }
 
 func TestPointerArrayLengthAndReceiverEffects(t *testing.T) {
+	t.Parallel()
 	source := `package p
  type K [4]byte
  type N uint64
diff --git a/internal/compiler/range_sbf_test.go b/internal/compiler/range_sbf_test.go
index eb8cd20e..52d1aa4f 100644
--- a/internal/compiler/range_sbf_test.go
+++ b/internal/compiler/range_sbf_test.go
@@ -58,6 +58,7 @@ func sbfCases(prefix string, process func([]byte, []byte) uint64, vectors [][2][
 // platform-tools v1.57 is absent, and skips the runs (after building) when the
 // managed runners are not installed.
 func TestRangeUint16SBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/range_test.go b/internal/compiler/range_test.go
index 130e17f6..70d1d984 100644
--- a/internal/compiler/range_test.go
+++ b/internal/compiler/range_test.go
@@ -30,6 +30,7 @@ func checkMessage(t *testing.T, source string) string {
 }
 
 func TestRangeAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"slice key value":      `for i, v := range s { s[i] = v }`,
 		"slice key":            `for i := range s { s[i] = 0 }`,
@@ -87,6 +88,7 @@ func TestRangeAcceptedForms(t *testing.T) {
 }
 
 func TestRangeRejections(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ body, want string }{
 		"map":              {`for range map[uint64]uint64{} {}`, rangeMapRule},
 		"channel":          {`for range make(chan uint64) {}`, "range over channels unsupported"},
@@ -115,6 +117,7 @@ func TestRangeRejections(t *testing.T) {
 }
 
 func TestUint16Checks(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ source, want string }{
 		"scalars":         {`type U uint16;type S struct{ A uint16; B U; C [2]uint16 };func f(a uint16, p *uint16) (uint16, U) { *p = a; return a << 3, U(a) };func Process(s, i []byte) uint64 { var x S; x.C[1]++; a, b := f(x.A, &x.A); return uint64(a) + uint64(b) }`, ""},
 		"constant":        {`const C uint16 = 65535;func Process(s, i []byte) uint64 { return uint64(C) }`, ""},
@@ -135,6 +138,7 @@ func TestUint16Checks(t *testing.T) {
 // The uint16 typedef is emitted only for programs that use uint16, so the
 // C of every other program stays byte-identical.
 func TestUint16TypedefOnlyWhenUsed(t *testing.T) {
+	t.Parallel()
 	without, err := Compile("a.go", []byte("package p\nfunc Process(s, i []byte) uint64 { return uint64(s[0]) }\n"))
 	if err != nil {
 		t.Fatal(err)
@@ -273,10 +277,12 @@ func uint16Vectors() []oracleVector {
 }
 
 func TestRangeDifferential(t *testing.T) {
+	t.Parallel()
 	differential(t, "../../examples/range-values/program.go", rangevalues.Process, rangeVectors())
 }
 
 func TestUint16Differential(t *testing.T) {
+	t.Parallel()
 	differential(t, "../../examples/uint16-values/program.go", uint16values.Process, uint16Vectors())
 }
 
diff --git a/internal/compiler/reallibs_diff_test.go b/internal/compiler/reallibs_diff_test.go
index 9d32b578..8a77fb5f 100644
--- a/internal/compiler/reallibs_diff_test.go
+++ b/internal/compiler/reallibs_diff_test.go
@@ -542,6 +542,7 @@ func nativeRealLibs(t *testing.T, oracle string, vectors [][]byte) []string {
 // trimmed module copies, and compares every vector's output, result and
 // panic with the unmodified modules run natively.
 func TestRealLibrariesDifferential(t *testing.T) {
+	t.Parallel()
 	env := realLibs(t)
 	vectors := append(realLibsVectors(20261016, 80), realLibsTickSweep()...)
 	vectors = append(vectors, realLibsSBFVectors()...)
@@ -636,6 +637,7 @@ var realLibsWhole = []struct{ path, use, at, want string }{
 }
 
 func TestRealLibrariesWholePackages(t *testing.T) {
+	t.Parallel()
 	env := realLibs(t)
 	example, err := filepath.Abs(realLibsExample)
 	if err != nil {
diff --git a/internal/compiler/reallibs_forms_test.go b/internal/compiler/reallibs_forms_test.go
index c0bdd8f8..036e2417 100644
--- a/internal/compiler/reallibs_forms_test.go
+++ b/internal/compiler/reallibs_forms_test.go
@@ -306,6 +306,7 @@ func formInputs() [][]byte {
 }
 
 func TestRealLibraryFormsDifferential(t *testing.T) {
+	t.Parallel()
 	inputs := formInputs()
 	for name, src := range formPrograms {
 		t.Run(name, func(t *testing.T) {
@@ -333,6 +334,7 @@ func TestRealLibraryFormsDifferential(t *testing.T) {
 // The checked program's view: the large table stays read-only, the written
 // table does not, and the converted local escapes to the heap.
 func TestRealLibraryFormsCheck(t *testing.T) {
+	t.Parallel()
 	checked, err := Check(globalsProgram(unitFiles("program", formHostSource(formPrograms["read-only-pointer-params"]))))
 	if err != nil {
 		t.Fatal(err)
@@ -359,6 +361,7 @@ func TestRealLibraryFormsCheck(t *testing.T) {
 }
 
 func TestRealLibraryFormsSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/reallibs_sbf_test.go b/internal/compiler/reallibs_sbf_test.go
index f092dda1..67d7fcbe 100644
--- a/internal/compiler/reallibs_sbf_test.go
+++ b/internal/compiler/reallibs_sbf_test.go
@@ -298,6 +298,7 @@ func Process(c solana.Context) uint64 {
 // GOSVM_REALLIBS_RESULTS=<dir> keeps fixtures, ELFs, reports and a summary
 // per target and form.
 func TestRealLibrariesSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/rebuild_test.go b/internal/compiler/rebuild_test.go
index c0f37f72..4c3a3e7b 100644
--- a/internal/compiler/rebuild_test.go
+++ b/internal/compiler/rebuild_test.go
@@ -27,6 +27,7 @@ func modernLLVM() string {
 // Uncached builds of the same source from different absolute paths must be
 // byte-identical (no embedded build paths or temporary names).
 func TestModernRebuildIsByteIdentical(t *testing.T) {
+	t.Parallel()
 	llvm := modernLLVM()
 	if llvm == "" {
 		t.Skip("pinned platform-tools v1.57 backend required")
diff --git a/internal/compiler/return_data_sbf_test.go b/internal/compiler/return_data_sbf_test.go
index 6b76b970..81f9c0ce 100644
--- a/internal/compiler/return_data_sbf_test.go
+++ b/internal/compiler/return_data_sbf_test.go
@@ -81,6 +81,7 @@ func itoa(n int) string {
 // without the v1.57 backend or a runner. GOSVM_RETURN_DATA_RESULTS=<dir>
 // keeps the fixtures, ELFs and reports.
 func TestGetReturnDataSBF(t *testing.T) {
+	t.Parallel()
 	llvm := modernLLVM()
 	if llvm == "" {
 		t.Skip("pinned platform-tools v1.57 backend required")
diff --git a/internal/compiler/return_data_test.go b/internal/compiler/return_data_test.go
index f1003878..5a88d3a9 100644
--- a/internal/compiler/return_data_test.go
+++ b/internal/compiler/return_data_test.go
@@ -12,6 +12,7 @@ import (
 )
 
 func TestSDK2ReturnDataNativeCDifferential(t *testing.T) {
+	t.Parallel()
 	source := `package app;import "gosvm/solana";func Process(c solana.Context)uint64{return solana.SetReturnData(c,solana.Instruction(c))}`
 	p := &Program{SDK: 2, Entry: "app", Packages: []PackageSources{unit("app", source)}}
 	c, err := CompileProgram(p)
@@ -76,6 +77,7 @@ int main(void){u64 n;while(scanf("%llu",&n)==1){
 }
 
 func TestSDK2GetReturnDataNativeCDifferential(t *testing.T) {
+	t.Parallel()
 	source := `package app;import "gosvm/solana"
 func Process(c solana.Context)uint64{
 	ix:=solana.Instruction(c);result:=solana.Data(c,0)
diff --git a/internal/compiler/sdkata_sbf_test.go b/internal/compiler/sdkata_sbf_test.go
index ae52a511..59ca344c 100644
--- a/internal/compiler/sdkata_sbf_test.go
+++ b/internal/compiler/sdkata_sbf_test.go
@@ -122,5 +122,6 @@ func ataCreateFixture() ([]byte, error) {
 
 // TestSDKATACreateSBF runs examples/ata-create against real ATA and token programs.
 func TestSDKATACreateSBF(t *testing.T) {
+	t.Parallel()
 	runSDKProbe(t, "ata-create", ataCreateFixture)
 }
diff --git a/internal/compiler/sdksystem_sbf_test.go b/internal/compiler/sdksystem_sbf_test.go
index 984f6a6b..a19f28ed 100644
--- a/internal/compiler/sdksystem_sbf_test.go
+++ b/internal/compiler/sdksystem_sbf_test.go
@@ -87,5 +87,6 @@ func systemPDAFixture() ([]byte, error) {
 
 // TestSDKSystemPDASBF runs examples/system-pda against the real System program.
 func TestSDKSystemPDASBF(t *testing.T) {
+	t.Parallel()
 	runSDKProbe(t, "system-pda", systemPDAFixture)
 }
diff --git a/internal/compiler/sdktoken_sbf_test.go b/internal/compiler/sdktoken_sbf_test.go
index 60e1e30a..4c0c987b 100644
--- a/internal/compiler/sdktoken_sbf_test.go
+++ b/internal/compiler/sdktoken_sbf_test.go
@@ -141,5 +141,6 @@ func tokenCPIFixture() ([]byte, error) {
 
 // TestSDKTokenCPISBF runs examples/token-cpi against real Token-2022 and Token.
 func TestSDKTokenCPISBF(t *testing.T) {
+	t.Parallel()
 	runSDKProbe(t, "token-cpi", tokenCPIFixture)
 }
diff --git a/internal/compiler/sdktokenext_sbf_test.go b/internal/compiler/sdktokenext_sbf_test.go
index f106b29b..6c4d5897 100644
--- a/internal/compiler/sdktokenext_sbf_test.go
+++ b/internal/compiler/sdktokenext_sbf_test.go
@@ -173,5 +173,6 @@ func tokenExtensionsFixture() ([]byte, error) {
 
 // TestSDKTokenExtensionsSBF runs examples/token-extensions against real Token-2022.
 func TestSDKTokenExtensionsSBF(t *testing.T) {
+	t.Parallel()
 	runSDKProbe(t, "token-extensions", tokenExtensionsFixture)
 }
diff --git a/internal/compiler/secp256k1_sbf_test.go b/internal/compiler/secp256k1_sbf_test.go
index f862b890..4f837d8d 100644
--- a/internal/compiler/secp256k1_sbf_test.go
+++ b/internal/compiler/secp256k1_sbf_test.go
@@ -188,6 +188,7 @@ func secpIx(c secpCase, lengths [3]byte) []byte {
 // syscall. It skips without the v1.57 backend or a runner.
 // GOSVM_SECP256K1_RESULTS=<dir> keeps the fixtures, ELFs and reports.
 func TestSecp256k1RecoverSBF(t *testing.T) {
+	t.Parallel()
 	llvm := modernLLVM()
 	if llvm == "" {
 		t.Skip("pinned platform-tools v1.57 backend required")
diff --git a/internal/compiler/secp256k1_test.go b/internal/compiler/secp256k1_test.go
index 66d45745..0dbda9da 100644
--- a/internal/compiler/secp256k1_test.go
+++ b/internal/compiler/secp256k1_test.go
@@ -12,6 +12,7 @@ import (
 )
 
 func TestSDK2Secp256k1RecoverNativeCDifferential(t *testing.T) {
+	t.Parallel()
 	source := strings.Replace(string(mustRead(t, filepath.Join("testdata", "secp256k1", "program.go"))), "package program", "package app", 1)
 	p := &Program{SDK: 2, Entry: "app", Packages: []PackageSources{unit("app", source)}}
 	c, err := CompileProgram(p)
diff --git a/internal/compiler/signed_test.go b/internal/compiler/signed_test.go
index b77e762f..d7f7fa59 100644
--- a/internal/compiler/signed_test.go
+++ b/internal/compiler/signed_test.go
@@ -10,6 +10,7 @@ import (
 // admits an unsigned scalar admits them, and len/cap results, range keys and
 // math/bits counts are ordinary int values.
 func TestIntegerChecksAccept(t *testing.T) {
+	t.Parallel()
 	for name, source := range map[string]string{
 		"locals":        `func Process(s, i []byte) uint64 { var a int8 = -128; b := int16(a) * 3; var c int32; d := int64(-1); e := 5; var f uint = 7; c = int32(b) - 1; return uint64(a) + uint64(b) + uint64(c) + uint64(d) + uint64(e) + uint64(f) }`,
 		"params":        `func f(a int8, b int, c uint) (int64, int) { return int64(a) * int64(b), b - int(c) };func Process(s, i []byte) uint64 { x, y := f(-1, 2, 3); return uint64(x) ^ uint64(y) }`,
@@ -38,6 +39,7 @@ func TestIntegerChecksAccept(t *testing.T) {
 }
 
 func TestIntegerChecksReject(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ source, want string }{
 		"float":             {`func Process(s, i []byte) uint64 { var f float64; _ = f; return 0 }`, "unsupported type float64"},
 		"uintptr":           {`func Process(s, i []byte) uint64 { var p uintptr; _ = p; return 0 }`, "unsupported type uintptr"},
@@ -68,6 +70,7 @@ func TestIntegerChecksReject(t *testing.T) {
 // programs without a signed / or % emit no division helpers, so their C is
 // unchanged (the frozen corpus checks every recorded program's hash).
 func TestSignedRuntimeOnlyWhenUsed(t *testing.T) {
+	t.Parallel()
 	for _, tc := range []struct {
 		source           string
 		typedefs, divide bool
diff --git a/internal/compiler/slicearray_test.go b/internal/compiler/slicearray_test.go
index 811409a6..f3c266a3 100644
--- a/internal/compiler/slicearray_test.go
+++ b/internal/compiler/slicearray_test.go
@@ -316,6 +316,7 @@ func sliceArrayInputs(count int) [][]byte {
 }
 
 func TestSliceArrayDifferential(t *testing.T) {
+	t.Parallel()
 	inputs := sliceArrayInputs(256)
 	for name, src := range sliceArrayPrograms {
 		t.Run(name, func(t *testing.T) {
@@ -350,6 +351,7 @@ func TestSliceArrayDifferential(t *testing.T) {
 // moves the local to the heap; the slice of a package-level variable makes
 // it writable; and the initializers converting slices run at run time.
 func TestSliceArrayCheck(t *testing.T) {
+	t.Parallel()
 	checked, err := Check(globalsProgram(unitFiles("program", formHostSource(sliceArrayPrograms["slice-array-pointers"]))))
 	if err != nil {
 		t.Fatal(err)
@@ -373,6 +375,7 @@ func TestSliceArrayCheck(t *testing.T) {
 }
 
 func TestSliceArrayRejections(t *testing.T) {
+	t.Parallel()
 	for _, tc := range []struct{ body, want string }{
 		// Go evaluates nothing for an index-only range over a converted
 		// pointer without calls; the existing rule keeps rejecting it.
@@ -386,6 +389,7 @@ func TestSliceArrayRejections(t *testing.T) {
 }
 
 func TestSliceArraySBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/stackframe_test.go b/internal/compiler/stackframe_test.go
index bd3117c6..c938d8ef 100644
--- a/internal/compiler/stackframe_test.go
+++ b/internal/compiler/stackframe_test.go
@@ -10,6 +10,7 @@ import (
 )
 
 func TestFrameDiagnosticsParse(t *testing.T) {
+	t.Parallel()
 	names := map[string]string{"v12": "program.big"}
 	for _, line := range []string{
 		"Error: Function v12 overflows the maximum allowed frame space by accessing an offset 960 bytes greater than the maximum of 4096. Please, minimize large stack variables.",
@@ -29,6 +30,7 @@ func TestFrameDiagnosticsParse(t *testing.T) {
 // A function whose frame exceeds 4 KiB fails the fogo-v0 build (fixed
 // frames) naming the Go function; Clang alone exits successfully.
 func TestFrameOverflowFailsBuild(t *testing.T) {
+	t.Parallel()
 	llvm := modernLLVM()
 	if llvm == "" {
 		t.Skip("pinned platform-tools v1.57 backend required")
diff --git a/internal/compiler/stdlib_diff_test.go b/internal/compiler/stdlib_diff_test.go
index 0836edb4..f75ec99f 100644
--- a/internal/compiler/stdlib_diff_test.go
+++ b/internal/compiler/stdlib_diff_test.go
@@ -237,6 +237,7 @@ func compareHostVectors(t *testing.T, bin string, vectors [][]byte, want []strin
 }
 
 func TestStdlibDifferential(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileStdlib(t), DefaultHeapBytes, valueTypesDriver, false)
 	vectors := append(stdlibVectors(20261014, 600), StdlibVectorsForTest()...)
 	want := make([]string, len(vectors))
diff --git a/internal/compiler/stdlib_sbf_test.go b/internal/compiler/stdlib_sbf_test.go
index dade6f76..f20d98ff 100644
--- a/internal/compiler/stdlib_sbf_test.go
+++ b/internal/compiler/stdlib_sbf_test.go
@@ -167,6 +167,7 @@ func stdlibProbeCase(name string, flag byte, want uint64) allocCase {
 // runner (make test). GOSVM_STDLIB_RESULTS=<dir> keeps fixtures, ELFs,
 // reports and a summary.
 func TestStdlibSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/stdlib_test.go b/internal/compiler/stdlib_test.go
index 51e0c15c..7518ae85 100644
--- a/internal/compiler/stdlib_test.go
+++ b/internal/compiler/stdlib_test.go
@@ -29,6 +29,7 @@ func stdlibCheck(t *testing.T, source string) string {
 // packages that are not available on chain: by name, at the use, with the
 // reason.
 func TestStdlibRejections(t *testing.T) {
+	t.Parallel()
 	importable := "bytes, encoding/binary, errors, io, math, strconv, strings, unicode, unicode/utf8"
 	for name, c := range map[string]struct{ source, want string }{
 		"fmt": {"package p\nimport \"fmt\"\nfunc Process(s, i []byte) uint64 { fmt.Println(); return 0 }\n",
@@ -79,6 +80,7 @@ func TestStdlibRejections(t *testing.T) {
 // TestStdlibImportForms: plain and renamed imports in a single file (no
 // go.mod), in a module program and in its shared packages.
 func TestStdlibImportForms(t *testing.T) {
+	t.Parallel()
 	for name, source := range map[string]string{
 		"plain":   "package p\nimport \"strings\"\nfunc Process(s, i []byte) uint64 { return uint64(strings.Count(string(s), \"a\")) }\n",
 		"renamed": "package p\nimport str \"strings\"\nimport bin \"encoding/binary\"\nfunc Process(s, i []byte) uint64 { return uint64(str.Count(string(s), \"a\")) + bin.LittleEndian.Uint64(i) }\n",
@@ -131,6 +133,7 @@ func writeFile(t *testing.T, path, data string) {
 // TestStdlibConstantsOnly: math has only constants on chain, so a program
 // using them emits the same C as one that writes the values out.
 func TestStdlibConstantsOnly(t *testing.T) {
+	t.Parallel()
 	compile := func(source string) []byte {
 		out, err := CompileSources([]Source{{Name: "p.go", Data: []byte(source)}})
 		if err != nil {
@@ -148,6 +151,7 @@ func TestStdlibConstantsOnly(t *testing.T) {
 // TestStdlibIntrinsics checks the intrinsic and dispatch-except marks in
 // the checked program and the C they produce.
 func TestStdlibIntrinsics(t *testing.T) {
+	t.Parallel()
 	p := &Program{Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "p.go", Data: []byte(`package p
 import (
 	"errors"
@@ -217,6 +221,7 @@ func Process(s, i []byte) uint64 {
 // TestStdlibIdentity: the identity covers every overlay file of the listed
 // packages and the cache key includes it only for programs that reach them.
 func TestStdlibIdentity(t *testing.T) {
+	t.Parallel()
 	if StdlibIdentity(nil) != "" {
 		t.Fatal("identity of no packages")
 	}
@@ -384,6 +389,7 @@ func TestStdlibProvenance(t *testing.T) {
 // TestStdlibPackagesList pins the overlay packages and keeps their sources
 // gofmt-formatted, like Go's.
 func TestStdlibPackagesList(t *testing.T) {
+	t.Parallel()
 	want := "bytes encoding/binary errors internal/bytealg internal/errtext io math strconv strings unicode unicode/utf8"
 	if got := strings.Join(StdlibPackages, " "); got != want {
 		t.Fatalf("StdlibPackages %q", got)
diff --git a/internal/compiler/strings_diff_test.go b/internal/compiler/strings_diff_test.go
index c0908d54..71f79316 100644
--- a/internal/compiler/strings_diff_test.go
+++ b/internal/compiler/strings_diff_test.go
@@ -118,6 +118,7 @@ func compileStrings(t *testing.T) []byte {
 }
 
 func TestStringDifferential(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileStrings(t), DefaultHeapBytes, allocDriver, false)
 	vectors := append(stringVectors(20261014, 1500), StringVectorsForTest()...)
 	var want []string
diff --git a/internal/compiler/strings_sbf_test.go b/internal/compiler/strings_sbf_test.go
index d34c4970..8d9f3f95 100644
--- a/internal/compiler/strings_sbf_test.go
+++ b/internal/compiler/strings_sbf_test.go
@@ -79,6 +79,7 @@ func stringSBFCases() ([]allocCase, int) {
 // backend or a runner (make test). GOSVM_STRING_RESULTS=<dir> keeps
 // fixtures, ELFs, reports and a summary.
 func TestStringSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/strings_test.go b/internal/compiler/strings_test.go
index b066460e..bc496733 100644
--- a/internal/compiler/strings_test.go
+++ b/internal/compiler/strings_test.go
@@ -37,6 +37,7 @@ func Process(s, i []byte) uint64 {
 `
 
 func TestStringAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"literals":             "a, b := \"x\\n\\x00é\", `raw\\n`; s[0] = a[0] + b[0]",
 		"empty":                `var e string; if e == "" { s[0] = byte(len(e)) }`,
@@ -85,6 +86,7 @@ func TestStringAcceptedForms(t *testing.T) {
 }
 
 func TestStringRejections(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ body, want string }{
 		"compound bool":     {`x := true; x += false; _ = x`, "invalid operation: operator + not defined on x (variable of type bool)"},
 		"float conversion":  {`var f float64 = 1; _ = f`, "unsupported type float64"},
@@ -121,6 +123,7 @@ func TestStringRejections(t *testing.T) {
 // string runtime (string constants used only in constant expressions are
 // folded); programs that never allocate strings carry no heap runtime.
 func TestStringRuntimeOnlyWhenUsed(t *testing.T) {
+	t.Parallel()
 	constant := "package p\nconst k = \"abc\"\nfunc Process(s, i []byte) uint64 { s[0] = byte(len(k + \"d\")); return uint64(len(k)) }\n"
 	out, err := Compile("a.go", []byte(constant))
 	if err != nil {
@@ -198,6 +201,7 @@ func intStringNative(in []byte) string {
 // values, surrogates, values above U+10FFFF, including values that only
 // truncate into range) is U+FFFD.
 func TestStringIntegerConversions(t *testing.T) {
+	t.Parallel()
 	c, err := Compile("a.go", []byte(intStringSource()))
 	if err != nil {
 		t.Fatal(err)
@@ -268,6 +272,7 @@ func stringHeapLimit(kind byte, la, lb int) int {
 // exactly: the iteration that does not fit aborts after the predicted number
 // of iterations; native Go never runs out, so the expectation is computed.
 func TestStringHeap(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileStrings(t), DefaultHeapBytes, allocDriver, false)
 	oom := func(n int) string {
 		out := make([]byte, 1024)
@@ -306,6 +311,7 @@ func TestStringHeap(t *testing.T) {
 
 // TestStringDocumentationExample compiles the example in docs/GO_STRINGS.md.
 func TestStringDocumentationExample(t *testing.T) {
+	t.Parallel()
 	doc := string(mustRead(t, "../../docs/GO_STRINGS.md"))
 	start := strings.Index(doc, "```go\n")
 	if start < 0 {
diff --git a/internal/compiler/trim_test.go b/internal/compiler/trim_test.go
index 76c620d8..c192ad61 100644
--- a/internal/compiler/trim_test.go
+++ b/internal/compiler/trim_test.go
@@ -88,6 +88,7 @@ func trimProgram(dep, app string, trim ...string) *Program {
 }
 
 func TestTrimDropsUnreachable(t *testing.T) {
+	t.Parallel()
 	// By default the whole package is checked, and the rejection names the
 	// opt-in.
 	_, err := Check(trimProgram(trimDep, trimApp))
@@ -163,6 +164,7 @@ func TestTrimDropsUnreachable(t *testing.T) {
 // TestTrimRejections: what Process reaches is checked exactly as before,
 // with the same messages (only the opt-in hint is gone).
 func TestTrimRejections(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ dep, app, want string }{
 		"reached float": {"package dep\nfunc F() uint64 { var f float64 = 1; return uint64(f) }\n",
 			"package app\nimport \"example.com/dep\"\nfunc Process(s, i []byte) uint64 { return dep.F() }\n", ""},
@@ -201,6 +203,7 @@ func TestTrimRejections(t *testing.T) {
 // TestTrimEntryPackage: the entry package is trimmed only when a pattern
 // names it exactly.
 func TestTrimEntryPackage(t *testing.T) {
+	t.Parallel()
 	app := trimApp + "\nfunc unused() float64 { return 1 }\n"
 	dep := "package dep\nconst K = 7\nvar Count uint64\nfunc F(x uint64) (uint64, error) { return x, nil }\n"
 	if _, err := Check(trimProgram(dep, app, "example.com/...")); err == nil || !strings.Contains(err.Error(), "float") {
@@ -216,6 +219,7 @@ func TestTrimEntryPackage(t *testing.T) {
 }
 
 func TestValidateTrim(t *testing.T) {
+	t.Parallel()
 	for _, ok := range []string{"example.com/lib", "example.com/lib/...", "lib"} {
 		if err := ValidateTrim([]string{ok}); err != nil {
 			t.Errorf("%s: %v", ok, err)
@@ -237,6 +241,7 @@ func TestValidateTrim(t *testing.T) {
 // information, compiled (promoted) only when a reached declaration uses
 // them; then they follow the ordinary rules.
 func TestTrimModules(t *testing.T) {
+	t.Parallel()
 	dir := t.TempDir()
 	write := func(name, content string) {
 		t.Helper()
@@ -319,6 +324,7 @@ func TestTrimModules(t *testing.T) {
 // TestTrimWarnings: builds write the report beside the output and warn
 // from it.
 func TestTrimWarnings(t *testing.T) {
+	t.Parallel()
 	checked, err := Check(trimProgram(trimDep, trimApp, "example.com/dep"))
 	if err != nil {
 		t.Fatal(err)
diff --git a/internal/compiler/types_test.go b/internal/compiler/types_test.go
index 1ecaf6aa..7050f225 100644
--- a/internal/compiler/types_test.go
+++ b/internal/compiler/types_test.go
@@ -7,6 +7,7 @@ import (
 )
 
 func TestTypeCheckBeforeEntryGeneration(t *testing.T) {
+	t.Parallel()
 	p := &Program{Entry: "app", Packages: []PackageSources{
 		unit("app", `package app;import "gosvm/solana";import "app/model";type Accounts struct{Pool model.Pool};func Swap(c solana.Context,a Accounts,n model.Amount)(model.Pool,uint64){a.Pool.N=a.Pool.N+n;return a.Pool,0}`),
 		unit("app/model", `package model;type Key [32]byte;type Amount uint64;type Pool struct{Authority Key;N Amount}`),
@@ -29,6 +30,7 @@ func TestTypeCheckBeforeEntryGeneration(t *testing.T) {
 	}
 }
 func TestTypeInspectionIsNotSubsetCertification(t *testing.T) {
+	t.Parallel()
 	p := &Program{Entry: "app", Packages: []PackageSources{unit("app", `package app;func Process(s,i []byte)uint64{n:=float64(i[0]);return uint64(n)}`)}}
 	if _, err := TypeCheckProgram(p); err != nil {
 		t.Fatal(err)
diff --git a/internal/compiler/values_test.go b/internal/compiler/values_test.go
index 0cae3489..dc8ee5eb 100644
--- a/internal/compiler/values_test.go
+++ b/internal/compiler/values_test.go
@@ -10,6 +10,7 @@ import (
 )
 
 func TestMultiFileValueSemantics(t *testing.T) {
+	t.Parallel()
 	sources := []Source{
 		{"types.go", []byte(`package p
  type Small uint8
@@ -49,6 +50,7 @@ func TestMultiFileValueSemantics(t *testing.T) {
 }
 
 func TestValueTypeRejections(t *testing.T) {
+	t.Parallel()
 	for name, code := range map[string]string{
 		"hidden context": `import "gosvm/solana";type Box struct { C solana.Context };func Process(c solana.Context)uint64{return 0}`,
 		"float named":    `type Bad float64;func Process(s,i []byte)uint64{var b Bad;return uint64(b)}`,
@@ -68,6 +70,7 @@ func TestValueTypeRejections(t *testing.T) {
 }
 
 func TestPackageSourcesAndCache(t *testing.T) {
+	t.Parallel()
 	dir := t.TempDir()
 	src := filepath.Join(dir, "src")
 	os.Mkdir(src, 0700)
@@ -124,6 +127,7 @@ func TestPackageSourcesAndCache(t *testing.T) {
 }
 
 func TestPlatformWordsInsideFilename(t *testing.T) {
+	t.Parallel()
 	dir := t.TempDir()
 	if e := os.WriteFile(filepath.Join(dir, "my_linux_helpers.go"), []byte("package p"), 0600); e != nil {
 		t.Fatal(e)
diff --git a/internal/compiler/valuetypes_diff_test.go b/internal/compiler/valuetypes_diff_test.go
index afe1adc1..a873edf5 100644
--- a/internal/compiler/valuetypes_diff_test.go
+++ b/internal/compiler/valuetypes_diff_test.go
@@ -160,6 +160,7 @@ func compileValueTypes(t *testing.T) []byte {
 }
 
 func TestValueTypesDifferential(t *testing.T) {
+	t.Parallel()
 	bin := hostCompile(t, compileValueTypes(t), DefaultHeapBytes, valueTypesDriver, false)
 	vectors := valueTypesVectors(20261014, 2000)
 	var want []string
diff --git a/internal/compiler/valuetypes_sbf_test.go b/internal/compiler/valuetypes_sbf_test.go
index a8349a66..eb62f07b 100644
--- a/internal/compiler/valuetypes_sbf_test.go
+++ b/internal/compiler/valuetypes_sbf_test.go
@@ -151,6 +151,7 @@ func valueTypesCases(vectors [][]byte) (cases []allocCase, aborts, logged int) {
 // runner (make test). GOSVM_INT_RESULTS=<dir> keeps fixtures, ELFs, reports
 // and a summary under value-types/.
 func TestValueTypesSBF(t *testing.T) {
+	t.Parallel()
 	if testing.Short() {
 		t.Skip("SBF runs are skipped in -short mode")
 	}
diff --git a/internal/compiler/valuetypes_test.go b/internal/compiler/valuetypes_test.go
index 1fffbc4f..f54239af 100644
--- a/internal/compiler/valuetypes_test.go
+++ b/internal/compiler/valuetypes_test.go
@@ -54,6 +54,7 @@ func Process(s, i []byte) uint64 {
 `
 
 func TestValueTypesAcceptedForms(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"struct equality":         `a, b := P{1, 2}, P{X: int16(i[0])}; if a == b || a != b { s[0] = 1 }`,
 		"struct with every kind":  `x := P{}; a := Q{A: 1, S: "x", I: 3, R: &x}; b := a; b.N[1].Y = 2; if a == b { s[0] = 1 }`,
@@ -112,6 +113,7 @@ func must[T comparable](v T) T { var zero T; if v == zero { panic("zero") }; ret
 `
 
 func TestValueTypesRejections(t *testing.T) {
+	t.Parallel()
 	cases := map[string][2]string{
 		"recover":          {`defer func() { _ = recover() }()`, recoverRule},
 		"defer panic":      {`defer panic("x")`, "defer panic(...) unsupported; defer a function literal that panics"},
@@ -142,6 +144,7 @@ func TestValueTypesRejections(t *testing.T) {
 // of generic instantiations and through chains of aliases behave as the
 // aliased types: methods, map keys, interfaces and comparisons.
 func TestCrossPackageAliases(t *testing.T) {
+	t.Parallel()
 	wide := `package wide
 type Int [4]uint64
 func (z *Int) Add(x, y *Int) *Int { var c uint64; for j := range z { s := x[j] + y[j] + c; c = 0; if s < x[j] || (s == x[j] && y[j]+c != 0 && c != 0) { c = 1 }; z[j] = s }; return z }
@@ -205,6 +208,7 @@ func Process(s, i []byte) uint64 {
 // Arrays of pointers keep Go's escape rules: a local whose address is
 // stored into an array literal or element moves to the heap.
 func TestCompositeArrayEscapes(t *testing.T) {
+	t.Parallel()
 	source := `package p
 type P struct{ X uint8 }
 func f() [2]*P { x := P{1}; return [2]*P{&x, nil} }
@@ -228,6 +232,7 @@ func Process(s, i []byte) uint64 { s[0] = f()[0].X + g()[1].X + h(); return 0 }
 // Check records every panic call's log line; the backend view is complete
 // and the C is deterministic. Programs without panic get no panic runtime.
 func TestPanicSites(t *testing.T) {
+	t.Parallel()
 	source := valuePrefix + `switch i[0] {
 	case 0: panic("boom")
 	case 1: panic(string(i[:2]))
@@ -297,6 +302,7 @@ func TestPanicSites(t *testing.T) {
 // then aborts; deferred calls do not run (Go would run them, but the
 // transaction fails and rolls back either way).
 func TestPanicLogLine(t *testing.T) {
+	t.Parallel()
 	source := `package p
 func Process(s, i []byte) uint64 {
 	defer func() { s[1] = 9 }()
diff --git a/internal/compiler/variadic_test.go b/internal/compiler/variadic_test.go
index 88cf5add..0af14b12 100644
--- a/internal/compiler/variadic_test.go
+++ b/internal/compiler/variadic_test.go
@@ -11,6 +11,7 @@ import (
 // calls with no, one and several extra arguments, spread slices, nil
 // spreads, deferred calls and interface elements check.
 func TestVariadicForms(t *testing.T) {
+	t.Parallel()
 	for name, body := range map[string]string{
 		"none":         `func f(xs ...uint64) uint64 { return uint64(len(xs)) }; func Process(s, i []byte) uint64 { return f() }`,
 		"several":      `func f(a byte, xs ...uint64) uint64 { return uint64(a) + uint64(len(xs)) }; func Process(s, i []byte) uint64 { return f(1, 2, 3, uint64(s[0])) }`,
@@ -32,6 +33,7 @@ func TestVariadicForms(t *testing.T) {
 // TestVariadicRejections: variadic function values, literals, function
 // types and interface methods stay unsupported.
 func TestVariadicRejections(t *testing.T) {
+	t.Parallel()
 	for name, c := range map[string]struct{ body, want string }{
 		"function value": {`func f(xs ...uint64) {}; func Process(s, i []byte) uint64 { g := f; _ = g; return 0 }`, "variadic function types are unsupported"},
 		"literal":        {`func Process(s, i []byte) uint64 { g := func(xs ...uint64) {}; g(); return 0 }`, "variadics are unsupported"},
@@ -50,6 +52,7 @@ func TestVariadicRejections(t *testing.T) {
 // "..." into one that passes the final parameter as a slice literal or nil
 // (docs/BACKEND_INTERFACE.md#variadic-functions).
 func TestVariadicLowering(t *testing.T) {
+	t.Parallel()
 	checked, err := Check(&Program{Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "p.go", Data: []byte(
 		"package p\nfunc f(a byte, xs ...uint64) uint64 { return uint64(len(xs)) }\nfunc Process(s, i []byte) uint64 { return f(1) + f(2, 3, 4) + f(5, nil...) }\n")}}}}})
 	if err != nil {
@@ -87,6 +90,7 @@ func TestVariadicLowering(t *testing.T) {
 // into heap data, so a local stored that way moves to the heap, and a
 // parameter whose address is taken is the caller's obligation.
 func TestPointerToPointerBorrows(t *testing.T) {
+	t.Parallel()
 	checked, err := Check(&Program{Entry: "program", Packages: []PackageSources{{"program", []Source{{Name: "p.go", Data: []byte(`package p
 func viaLocal() *uint64 {
 	var p *uint64
diff --git a/internal/compiler/views_test.go b/internal/compiler/views_test.go
index 9f0692ca..48f6c892 100644
--- a/internal/compiler/views_test.go
+++ b/internal/compiler/views_test.go
@@ -12,6 +12,7 @@ import (
 )
 
 func TestSliceViewsDifferential(t *testing.T) {
+	t.Parallel()
 	p, err := ReadProgram("../../examples/slice-views")
 	if err != nil {
 		t.Fatal(err)
@@ -57,6 +58,7 @@ func TestSliceViewsDifferential(t *testing.T) {
 	}
 }
 func TestSliceViewArrayBoundary(t *testing.T) {
+	t.Parallel()
 	p, err := ReadProgram("../../examples/slice-views")
 	if err != nil {
 		t.Fatal(err)
@@ -82,6 +84,7 @@ func TestSliceViewArrayBoundary(t *testing.T) {
 	}
 }
 func TestSliceViewRejections(t *testing.T) {
+	t.Parallel()
 	for name, source := range map[string]string{
 		"unaddressable array": `func k()[4]byte{return [4]byte{}};func Process(s,i []byte)uint64{return uint64(len(k()[:]))}`,
 	} {
@@ -94,6 +97,7 @@ func TestSliceViewRejections(t *testing.T) {
 	}
 }
 func TestSDKViewCapacities(t *testing.T) {
+	t.Parallel()
 	source := `package p;import "gosvm/solana";func Process(c solana.Context)uint64 {s:=solana.Data(c,0);k:=solana.Key(c,0);o:=solana.Owner(c,0);i:=solana.Instruction(c);p:=solana.ProgramID(c);if cap(s)!=24||cap(k)!=32||cap(o)!=32||cap(i)!=16||cap(p)!=32{return 1};v:=s[4:8:12];w:=v[:8];w[7]=41;return 0}`
 	c, err := Compile("sdk-views.go", []byte(source))
 	if err != nil {
@@ -106,6 +110,7 @@ func TestSDKViewCapacities(t *testing.T) {
 }
 
 func TestNilSliceContexts(t *testing.T) {
+	t.Parallel()
 	source := `package p
  type V uint64
  func accept(s []byte)uint64{if s!=nil{return 1};return uint64(cap(s))}
@@ -130,6 +135,7 @@ func TestNilSliceContexts(t *testing.T) {
 	}
 }
 func TestViewCapacityBoundary(t *testing.T) {
+	t.Parallel()
 	source := `package p
  func Process(s,i []byte)uint64 {
   var k [1024]byte
@@ -149,6 +155,7 @@ func TestViewCapacityBoundary(t *testing.T) {
 }
 
 func TestSDKNilSliceArguments(t *testing.T) {
+	t.Parallel()
 	source := `package p;import "gosvm/solana";func Process(c solana.Context)uint64{if solana.SHA256(c,nil,0,0,nil,0)!=2003{return 1};return 0}`
 	c, err := Compile("sdk-nil.go", []byte(source))
 	if err != nil {
@@ -161,6 +168,7 @@ func TestSDKNilSliceArguments(t *testing.T) {
 }
 
 func TestViewAggregateReturn(t *testing.T) {
+	t.Parallel()
 	// Multiple borrowed descriptors form an aggregate even without array types.
 	// Preserve their individual pointer/length/capacity fields across forwarding.
 	var resultTypes, returns, names, terms []string
diff --git a/scripts/test_shards.py b/scripts/test_shards.py
new file mode 100644
index 00000000..f6b24af7
--- /dev/null
+++ b/scripts/test_shards.py
@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Run the root module tests (`make test`) as shards of concurrent processes.
+
+Every top-level test of every package is assigned to exactly one of N shards
+(--shard i/N) by greedy bin-packing on this platform's durations in
+scripts/test_timings.json (measured in CI); tests without a recorded duration
+go to the lightest shard. Tests are read from each package's test files
+(`go list`), and the script fails unless the shards partition them exactly.
+Within a shard the tests are spread over one go test process per CPU, longest
+first: most of these tests launch processes, and a
+Go process launches children one at a time on macOS, so t.Parallel alone
+does not use the cores there.
+
+Extra arguments go to every go test invocation (e.g. -count=1, -v).
+--update-timings PLATFORM LOG... rewrites PLATFORM's timings from the
+"--- PASS: TestX (1.23s)" lines of -v runs of this script.
+"""
+import argparse, concurrent.futures, json, os, pathlib, platform, re, subprocess, sys, threading
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+TIMINGS = ROOT / 'scripts/test_timings.json'
+
+
+def go_flags(extra):
+    flags = ['-timeout', '30m'] + extra
+    if platform.system() == 'Darwin':
+        flags.append('-ldflags=-linkmode=external')
+    return flags
+
+
+def list_tests():
+    """(package, name) for every top-level test, fuzz target and example of
+    every package, read from the test files `go test` would compile."""
+    out = subprocess.run(['go', 'list', '-json', './...'], cwd=ROOT, check=True, capture_output=True, text=True).stdout
+    tests = []
+    for pkg in decode_stream(out):
+        for name in pkg.get('TestGoFiles', []) + pkg.get('XTestGoFiles', []):
+            source = code_only(pathlib.Path(pkg['Dir'], name).read_text())
+            pattern = r'^func ((Test|Fuzz)(\w*))\(\w+ \*testing\.[TF]\)|^func (Example(\w*))\(\)'
+            for m in re.finditer(pattern, source, re.M):
+                name, suffix = (m.group(1), m.group(3)) if m.group(1) else (m.group(4), m.group(5))
+                # go test's rule: the suffix must not start with a lower-case letter.
+                if not suffix or not suffix[0].islower():
+                    tests.append((pkg['ImportPath'], name))
+    return tests
+
+
+def code_only(src):
+    """src with comments and string/rune literals blanked (newlines kept), so
+    Go source embedded in test strings is not mistaken for tests."""
+    out, i, n = [], 0, len(src)
+    while i < n:
+        c = src[i]
+        if src.startswith('//', i):
+            j = src.find('\n', i)
+            j = n if j < 0 else j
+        elif src.startswith('/*', i):
+            j = src.index('*/', i) + 2
+        elif c == '`':
+            j = src.index('`', i + 1) + 1
+        elif c in '"\'':
+            j = i + 1
+            while src[j] != c:
+                j += 2 if src[j] == '\\' else 1
+            j += 1
+        else:
+            out.append(c)
+            i += 1
+            continue
+        out.append(re.sub(r'[^\n]', ' ', src[i:j]))
+        i = j
+    return ''.join(out)
+
+
+def decode_stream(text):
+    d, i = json.JSONDecoder(), 0
+    while i < len(text):
+        while i < len(text) and text[i].isspace():
+            i += 1
+        if i == len(text):
+            break
+        obj, i = d.raw_decode(text, i)
+        yield obj
+
+
+def pack(items, bins, weight):
+    """Greedy longest-first bin-packing; unweighted items go to the lightest bin."""
+    loads, out = [0.0] * bins, [[] for _ in range(bins)]
+    known = sorted((i for i in items if weight(i) is not None), key=lambda i: (-weight(i), i))
+    for item in known + [i for i in items if weight(i) is None]:
+        b = loads.index(min(loads))
+        out[b].append(item)
+        loads[b] += weight(item) or 0
+    return out, loads
+
+
+def update_timings(platform_name, logs):
+    times, pkg = {}, None
+    for path in logs:
+        for line in open(path, errors='replace'):
+            line = re.sub(r'^.*?Z ', '', line.rstrip('\n'))  # GitHub log timestamps
+            if m := re.match(r'^=== (\S+) \(\d+ tests\): exit', line):
+                pkg = m.group(1)
+            elif (m := re.match(r'^--- (?:PASS|FAIL|SKIP): (\w+) \(([\d.]+)s\)', line)) and pkg:
+                times[f'{pkg} {m.group(1)}'] = float(m.group(2))
+    data = json.loads(TIMINGS.read_text()) if TIMINGS.exists() else {}
+    data[platform_name] = dict(sorted(times.items()))
+    TIMINGS.write_text(json.dumps(dict(sorted(data.items())), indent=1) + '\n')
+    print(f'wrote {len(times)} {platform_name} timings to {TIMINGS}')
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument('--shard', default='1/1', help='i/N: run the i-th of N shards')
+    ap.add_argument('--jobs', type=int, default=os.cpu_count() or 2, help='concurrent go test processes')
+    ap.add_argument('--update-timings', nargs='+', metavar=('PLATFORM', 'LOG'))
+    a, extra = ap.parse_known_args()
+    if a.update_timings:
+        return update_timings(a.update_timings[0], a.update_timings[1:])
+    index, total = map(int, a.shard.split('/'))
+    if not 1 <= index <= total:
+        sys.exit(f'bad --shard {a.shard}')
+    flags = go_flags(extra)
+    goos, goarch = subprocess.run(['go', 'env', 'GOOS', 'GOARCH'], check=True, capture_output=True, text=True).stdout.split()
+    timings = json.loads(TIMINGS.read_text()).get(f'{goos}-{goarch}', {})
+
+    def weight(unit):
+        known = [timings[k] for k in (f'{p} {n}' for p, n in unit) if k in timings]
+        return sum(known) if known else None
+
+    tests = list_tests()
+    shards, loads = pack([(t,) for t in tests], total, weight)
+    if sorted(t for s in shards for u in s for t in u) != sorted(tests) or len(set(tests)) != len(tests):
+        sys.exit('shards do not partition the test list')
+    mine = shards[index - 1]
+    print(f'shard {index}/{total}: {sum(map(len, mine))} of {len(tests)} tests, ~{loads[index - 1]:.0f} s recorded '
+          f'(shards: {", ".join(f"{l:.0f}" for l in loads)})', flush=True)
+
+    # One process per (bucket, package); buckets are packed like shards.
+    buckets, _ = pack(mine, min(a.jobs, len(mine)) or 1, weight)
+    procs = []
+    for bucket in buckets:
+        by_pkg = {}
+        for unit in bucket:
+            for pkg, test in unit:
+                by_pkg.setdefault(pkg, []).append(test)
+        for pkg, names in by_pkg.items():
+            procs.append((weight([(pkg, n) for n in names]) or 0, pkg, names))
+    procs.sort(key=lambda p: -p[0])
+    lock, failed = threading.Lock(), []
+
+    def run(proc):
+        _, pkg, names = proc
+        cmd = ['go', 'test'] + flags + ['-run', '^(' + '|'.join(sorted(names)) + ')$', pkg]
+        r = subprocess.run(cmd, cwd=ROOT, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        with lock:
+            print(f'=== {pkg} ({len(names)} tests): exit {r.returncode}', flush=True)
+            sys.stdout.write(r.stdout)
+            sys.stdout.flush()
+            if r.returncode:
+                failed.append(pkg)
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=a.jobs) as pool:
+        list(pool.map(run, procs))
+    if failed:
+        sys.exit('failed: ' + ', '.join(sorted(failed)))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/test_timings.json b/scripts/test_timings.json
new file mode 100644
index 00000000..112bdf9e
--- /dev/null
+++ b/scripts/test_timings.json
@@ -0,0 +1,962 @@
+{
+ "darwin-arm64": {
+  "gosvm/cmd/gosvm TestCallDryRun": 1.0,
+  "gosvm/cmd/gosvm TestCallList": 0.2,
+  "gosvm/cmd/gosvm TestCallRawAccounts": 0.0,
+  "gosvm/cmd/gosvm TestExternalELFHeaderMustMatchTarget": 0.01,
+  "gosvm/cmd/gosvm TestExternalELFMatchesBuiltProgram": 2.05,
+  "gosvm/cmd/gosvm TestExternalELFRequiresOneTarget": 0.01,
+  "gosvm/cmd/gosvm TestExternalELFRequiresSVM": 0.0,
+  "gosvm/cmd/gosvm TestFastGenerationFailureRemovesPreviousReport": 0.01,
+  "gosvm/cmd/gosvm TestFastTestFlagsRejectConflictingModesBeforeProjectWork": 0.0,
+  "gosvm/cmd/gosvm TestFeaturesCommandProjectAndPackage": 0.42,
+  "gosvm/cmd/gosvm TestGoHostWarning": 0.0,
+  "gosvm/cmd/gosvm TestLCUUIDWatcherFindsSplitMessage": 0.0,
+  "gosvm/cmd/gosvm TestMacOSFromDarwin": 0.0,
+  "gosvm/cmd/gosvm TestSVMFixturesDefault": 0.16,
+  "gosvm/examples/amm TestInvalidLengths": 0.0,
+  "gosvm/examples/amm TestSwapAgainstBigIntegerReference": 0.0,
+  "gosvm/examples/protocol TestFixedRegions": 0.0,
+  "gosvm/examples/protocol TestIndependentReference": 0.0,
+  "gosvm/examples/protocol TestWireWords": 0.0,
+  "gosvm/examples/tokenswap TestFailedSecondCPI": 0.0,
+  "gosvm/examples/tokenswap TestMulDiv": 0.02,
+  "gosvm/examples/tokenswap TestNativeSwap": 0.0,
+  "gosvm/examples/tokenswap TestNativeValidation": 0.0,
+  "gosvm/examples/tokenswap TestWideQuote": 0.05,
+  "gosvm/internal/callplan TestEscrow": 0.12,
+  "gosvm/internal/callplan TestFieldParsing": 0.0,
+  "gosvm/internal/callplan TestFullSwap": 0.15,
+  "gosvm/internal/callplan TestHeapFrame": 0.0,
+  "gosvm/internal/callplan TestTutorialErrors": 0.12,
+  "gosvm/internal/callplan TestTutorialList": 0.0,
+  "gosvm/internal/callplan TestTutorialMatchesRunnerFixtures": 0.09,
+  "gosvm/internal/callplan TestTutorialRunnerE2E": 0.0,
+  "gosvm/internal/compiler TestAMMDifferential": 0.24,
+  "gosvm/internal/compiler TestAccounts64Frames": 11.11,
+  "gosvm/internal/compiler TestAccounts64SBF": 3.95,
+  "gosvm/internal/compiler TestAllocationAcceptedForms": 2.24,
+  "gosvm/internal/compiler TestAllocationDifferential": 6.56,
+  "gosvm/internal/compiler TestAllocationRejections": 0.02,
+  "gosvm/internal/compiler TestAllocationRuntimeOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestAllocationSBF": 19.27,
+  "gosvm/internal/compiler TestArrayCapacityMemory": 1.17,
+  "gosvm/internal/compiler TestArrayDeclarationOrder": 0.06,
+  "gosvm/internal/compiler TestArrayRejections": 0.0,
+  "gosvm/internal/compiler TestArrayStorageLimit": 0.0,
+  "gosvm/internal/compiler TestBitsCheckAcceptsSupportedFunctions": 0.32,
+  "gosvm/internal/compiler TestBitsCheckAcceptsUintAndIntValues": 0.01,
+  "gosvm/internal/compiler TestBitsCheckRejections": 0.0,
+  "gosvm/internal/compiler TestBitsDeclarationsMatchStandardLibrary": 0.01,
+  "gosvm/internal/compiler TestBitsDifferentialAgainstGo": 10.99,
+  "gosvm/internal/compiler TestBitsImportForms": 0.16,
+  "gosvm/internal/compiler TestBitsRuntimeOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestBitsSBF": 8.58,
+  "gosvm/internal/compiler TestBuildReceiptInvalidation": 0.06,
+  "gosvm/internal/compiler TestByvalCopies": 0.01,
+  "gosvm/internal/compiler TestByvalDifferential": 3.06,
+  "gosvm/internal/compiler TestByvalSBF": 6.22,
+  "gosvm/internal/compiler TestCPILimitsSBF": 3.15,
+  "gosvm/internal/compiler TestCheckLegacyEntryAndRejection": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramDescribesContextProgram": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramFuncMaps": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramFunctions": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramGlobals": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramInstances": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramInterfaces": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramMaps": 0.0,
+  "gosvm/internal/compiler TestClosureEnvironmentHeap": 4.32,
+  "gosvm/internal/compiler TestClosureMapHeap": 2.28,
+  "gosvm/internal/compiler TestClosureStringHeap": 2.73,
+  "gosvm/internal/compiler TestCompositeArrayEscapes": 0.0,
+  "gosvm/internal/compiler TestCompoundAcceptedForms": 0.86,
+  "gosvm/internal/compiler TestCompoundDifferential": 43.72,
+  "gosvm/internal/compiler TestCompoundEmission": 0.0,
+  "gosvm/internal/compiler TestCompoundOperandOrder": 0.68,
+  "gosvm/internal/compiler TestCompoundRejections": 0.0,
+  "gosvm/internal/compiler TestCompoundSBF": 14.47,
+  "gosvm/internal/compiler TestConstInitDifferential": 32.22,
+  "gosvm/internal/compiler TestConstInitSBF": 25.02,
+  "gosvm/internal/compiler TestControlRejections": 0.0,
+  "gosvm/internal/compiler TestControlValuesDifferential": 0.16,
+  "gosvm/internal/compiler TestCorpusMatchesPreCheckCompiler": 2.27,
+  "gosvm/internal/compiler TestCrossPackageAliases": 0.22,
+  "gosvm/internal/compiler TestDependencyNamespaceSeparatesImportedContent": 0.24,
+  "gosvm/internal/compiler TestEvalOrderDifferential": 39.46,
+  "gosvm/internal/compiler TestEvalOrderHoisted": 0.0,
+  "gosvm/internal/compiler TestEvalOrderLocalsAndTraps": 0.0,
+  "gosvm/internal/compiler TestEvalOrderMaps": 0.0,
+  "gosvm/internal/compiler TestEvalOrderNothingToHoist": 0.0,
+  "gosvm/internal/compiler TestEvalOrderSBF": 54.1,
+  "gosvm/internal/compiler TestEvalOrderVariadicAndPointerToPointer": 0.0,
+  "gosvm/internal/compiler TestFormerEscapesMoveToHeap": 2.78,
+  "gosvm/internal/compiler TestFrameDiagnosticsParse": 0.0,
+  "gosvm/internal/compiler TestFrameOverflowFailsBuild": 1.33,
+  "gosvm/internal/compiler TestFuncAcceptedForms": 1.67,
+  "gosvm/internal/compiler TestFuncCombinationsSBF": 29.49,
+  "gosvm/internal/compiler TestFuncContextCapture": 0.03,
+  "gosvm/internal/compiler TestFuncMapAcceptedForms": 0.79,
+  "gosvm/internal/compiler TestFuncMapRecursion": 0.0,
+  "gosvm/internal/compiler TestFuncMapsDifferential": 32.8,
+  "gosvm/internal/compiler TestFuncRejections": 0.01,
+  "gosvm/internal/compiler TestFuncRuntimeOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestFuncStringsDifferential": 46.68,
+  "gosvm/internal/compiler TestFuncValuesDifferential": 51.1,
+  "gosvm/internal/compiler TestFuncValuesSBF": 17.12,
+  "gosvm/internal/compiler TestGenericAcceptedForms": 0.01,
+  "gosvm/internal/compiler TestGenericAliasSpellingsShareInstances": 0.09,
+  "gosvm/internal/compiler TestGenericArrayTypeArgsDifferential": 8.85,
+  "gosvm/internal/compiler TestGenericArrayTypeArgsForms": 1.64,
+  "gosvm/internal/compiler TestGenericArrayTypeArgsSBF": 14.73,
+  "gosvm/internal/compiler TestGenericCrossPackage": 0.0,
+  "gosvm/internal/compiler TestGenericDifferential": 21.57,
+  "gosvm/internal/compiler TestGenericMatchesHandwrittenSBF": 6.05,
+  "gosvm/internal/compiler TestGenericNamesAreDeterministic": 0.09,
+  "gosvm/internal/compiler TestGenericRejections": 0.03,
+  "gosvm/internal/compiler TestGenericSBF": 6.94,
+  "gosvm/internal/compiler TestGetReturnDataSBF": 3.05,
+  "gosvm/internal/compiler TestGlobalAcceptedForms": 2.39,
+  "gosvm/internal/compiler TestGlobalHeapAccounting": 0.6,
+  "gosvm/internal/compiler TestGlobalInitPanics": 5.55,
+  "gosvm/internal/compiler TestGlobalInitTrap": 0.36,
+  "gosvm/internal/compiler TestGlobalOperandOrder": 0.17,
+  "gosvm/internal/compiler TestGlobalPackages": 0.24,
+  "gosvm/internal/compiler TestGlobalReadOnly": 0.56,
+  "gosvm/internal/compiler TestGlobalRejections": 0.01,
+  "gosvm/internal/compiler TestGlobalRuntimeOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestGlobalValueTypesDifferential": 11.27,
+  "gosvm/internal/compiler TestGlobalValueTypesPlacement": 0.01,
+  "gosvm/internal/compiler TestGlobalValueTypesSBF": 22.75,
+  "gosvm/internal/compiler TestGlobalsDifferential": 17.8,
+  "gosvm/internal/compiler TestGlobalsSBF": 25.38,
+  "gosvm/internal/compiler TestGoSemantics": 0.11,
+  "gosvm/internal/compiler TestGrowthModelMatchesCompiledAppend": 0.0,
+  "gosvm/internal/compiler TestGrowthModelMatchesGoRuntime": 4.43,
+  "gosvm/internal/compiler TestGrowthRuntimeMatchesModel": 1.03,
+  "gosvm/internal/compiler TestHeapMovesExported": 0.0,
+  "gosvm/internal/compiler TestImportedMainPackage": 0.0,
+  "gosvm/internal/compiler TestImportedMethodsAndBorrowedResults": 0.07,
+  "gosvm/internal/compiler TestImportedMultipleResults": 0.06,
+  "gosvm/internal/compiler TestImportedPackageRejections": 0.0,
+  "gosvm/internal/compiler TestImportedSDKAndEntryIdentity": 0.08,
+  "gosvm/internal/compiler TestImportedValuesAndCalls": 0.07,
+  "gosvm/internal/compiler TestInitEvalEdgesSBF": 3.88,
+  "gosvm/internal/compiler TestInitEvalPartialPackage": 0.71,
+  "gosvm/internal/compiler TestInitEvalRuntimeInit": 0.01,
+  "gosvm/internal/compiler TestInitEvalStops": 6.85,
+  "gosvm/internal/compiler TestInitImageCheckedProgram": 0.0,
+  "gosvm/internal/compiler TestInitImageHeapAccounting": 18.83,
+  "gosvm/internal/compiler TestIntValuesDifferential": 12.78,
+  "gosvm/internal/compiler TestIntValuesFixture": 0.02,
+  "gosvm/internal/compiler TestIntValuesSBF": 17.68,
+  "gosvm/internal/compiler TestIntegerChecksAccept": 0.01,
+  "gosvm/internal/compiler TestIntegerChecksReject": 0.01,
+  "gosvm/internal/compiler TestInterfaceAcceptedForms": 1.14,
+  "gosvm/internal/compiler TestInterfaceBoxingHeap": 4.78,
+  "gosvm/internal/compiler TestInterfaceCrossPackage": 0.12,
+  "gosvm/internal/compiler TestInterfaceDifferential": 21.12,
+  "gosvm/internal/compiler TestInterfaceHeapMoves": 0.0,
+  "gosvm/internal/compiler TestInterfaceRejections": 0.06,
+  "gosvm/internal/compiler TestInterfaceRuntimeOnlyWhenUsed": 0.23,
+  "gosvm/internal/compiler TestInterfaceSBF": 7.13,
+  "gosvm/internal/compiler TestKeccak256SBF": 4.47,
+  "gosvm/internal/compiler TestKeccakReference": 0.0,
+  "gosvm/internal/compiler TestLargeTablesAccepted": 0.88,
+  "gosvm/internal/compiler TestLargeTablesRejected": 0.03,
+  "gosvm/internal/compiler TestMangleIsInjective": 0.0,
+  "gosvm/internal/compiler TestMapAcceptedForms": 1.54,
+  "gosvm/internal/compiler TestMapDifferential": 28.7,
+  "gosvm/internal/compiler TestMapDocumentationExample": 0.04,
+  "gosvm/internal/compiler TestMapHeap": 37.13,
+  "gosvm/internal/compiler TestMapHeapMoves": 0.04,
+  "gosvm/internal/compiler TestMapRejections": 0.01,
+  "gosvm/internal/compiler TestMapRuntimeOnlyWhenUsed": 0.55,
+  "gosvm/internal/compiler TestMapSBF": 69.15,
+  "gosvm/internal/compiler TestMaxAccountsOptIn": 0.08,
+  "gosvm/internal/compiler TestMemmoveHelperCompiles": 0.03,
+  "gosvm/internal/compiler TestMemmoveSBF": 5.68,
+  "gosvm/internal/compiler TestMemoryDifferential": 24.33,
+  "gosvm/internal/compiler TestMemoryLegacyUnchanged": 0.0,
+  "gosvm/internal/compiler TestMemoryReadOnlyWritesSBF": 4.98,
+  "gosvm/internal/compiler TestMemoryRuntimeSBF": 3.17,
+  "gosvm/internal/compiler TestMemorySBF": 36.23,
+  "gosvm/internal/compiler TestMemorySyscallRoutinesCompileForSBF": 1.24,
+  "gosvm/internal/compiler TestMixedAcceptedForms": 0.89,
+  "gosvm/internal/compiler TestMixedDifferential": 61.84,
+  "gosvm/internal/compiler TestMixedHeapRuntimeOnlyForInstances": 0.0,
+  "gosvm/internal/compiler TestMixedInstanceHeapMoves": 0.0,
+  "gosvm/internal/compiler TestMixedRejections": 0.0,
+  "gosvm/internal/compiler TestMixedSBF": 10.97,
+  "gosvm/internal/compiler TestModernRebuildIsByteIdentical": 6.82,
+  "gosvm/internal/compiler TestModuleImportFailures": 0.15,
+  "gosvm/internal/compiler TestModuleImportsAndCache": 0.81,
+  "gosvm/internal/compiler TestMultiFileValueSemantics": 0.07,
+  "gosvm/internal/compiler TestMultiplyBuiltinNativeDifferential": 0.13,
+  "gosvm/internal/compiler TestNilSliceContexts": 0.08,
+  "gosvm/internal/compiler TestNoGenericsLowersToItself": 0.0,
+  "gosvm/internal/compiler TestOutOfMemoryBoundaries": 1.69,
+  "gosvm/internal/compiler TestPackageSourcesAndCache": 0.2,
+  "gosvm/internal/compiler TestPackedStoreNativeCDifferential": 0.82,
+  "gosvm/internal/compiler TestPackedStoreRecognition": 0.01,
+  "gosvm/internal/compiler TestPanicLogLine": 0.85,
+  "gosvm/internal/compiler TestPanicSites": 0.0,
+  "gosvm/internal/compiler TestPlatformWordsInsideFilename": 0.0,
+  "gosvm/internal/compiler TestPointerArrayLengthAndReceiverEffects": 0.07,
+  "gosvm/internal/compiler TestPointerLifetimeRejections": 0.0,
+  "gosvm/internal/compiler TestPointerToPointerBorrows": 0.0,
+  "gosvm/internal/compiler TestPointerValuesDifferential": 0.84,
+  "gosvm/internal/compiler TestRangeAcceptedForms": 0.07,
+  "gosvm/internal/compiler TestRangeDifferential": 1.38,
+  "gosvm/internal/compiler TestRangeRejections": 0.0,
+  "gosvm/internal/compiler TestRangeUint16SBF": 16.03,
+  "gosvm/internal/compiler TestRealLibrariesDifferential": 67.35,
+  "gosvm/internal/compiler TestRealLibrariesInitSBF": 76.67,
+  "gosvm/internal/compiler TestRealLibrariesSBF": 104.63,
+  "gosvm/internal/compiler TestRealLibrariesWholePackages": 16.74,
+  "gosvm/internal/compiler TestRealLibraryFormsCheck": 0.0,
+  "gosvm/internal/compiler TestRealLibraryFormsDifferential": 6.38,
+  "gosvm/internal/compiler TestRealLibraryFormsSBF": 18.38,
+  "gosvm/internal/compiler TestRejectUnsupported": 0.02,
+  "gosvm/internal/compiler TestResolverFlagLikeImport": 0.07,
+  "gosvm/internal/compiler TestRuntimeGuards": 0.23,
+  "gosvm/internal/compiler TestSBFUnresolvedSymbolGuard": 0.0,
+  "gosvm/internal/compiler TestSDK2AggregateMemory": 0.72,
+  "gosvm/internal/compiler TestSDK2ArrayValueSemantics": 0.78,
+  "gosvm/internal/compiler TestSDK2ClockNativeCDifferential": 0.87,
+  "gosvm/internal/compiler TestSDK2GetReturnDataNativeCDifferential": 0.14,
+  "gosvm/internal/compiler TestSDK2InvokeBoundaryDifferential": 1.25,
+  "gosvm/internal/compiler TestSDK2Keccak256NativeCDifferential": 0.5,
+  "gosvm/internal/compiler TestSDK2LifecycleLoaderSelection": 0.01,
+  "gosvm/internal/compiler TestSDK2LogNativeCDifferential": 0.12,
+  "gosvm/internal/compiler TestSDK2LogRuntimeEmittedOnlyWhenCalled": 0.01,
+  "gosvm/internal/compiler TestSDK2MoveLamportsEmittedOnlyWhenCalled": 0.0,
+  "gosvm/internal/compiler TestSDK2MoveLamportsNativeCDifferential": 0.92,
+  "gosvm/internal/compiler TestSDK2OwnedLifecycleDifferential": 0.36,
+  "gosvm/internal/compiler TestSDK2RentCalculationC": 0.59,
+  "gosvm/internal/compiler TestSDK2ReturnDataNativeCDifferential": 0.24,
+  "gosvm/internal/compiler TestSDK2Secp256k1RecoverNativeCDifferential": 0.78,
+  "gosvm/internal/compiler TestSDKATACreateSBF": 6.08,
+  "gosvm/internal/compiler TestSDKAccountDecoderCapacityAndAliases": 3.0,
+  "gosvm/internal/compiler TestSDKContext": 0.07,
+  "gosvm/internal/compiler TestSDKHashBounds": 0.1,
+  "gosvm/internal/compiler TestSDKNilSliceArguments": 0.12,
+  "gosvm/internal/compiler TestSDKSystemPDASBF": 4.41,
+  "gosvm/internal/compiler TestSDKTokenCPISBF": 4.3,
+  "gosvm/internal/compiler TestSDKTokenExtensionsSBF": 2.82,
+  "gosvm/internal/compiler TestSDKVersionsAndNativeOnlyTypes": 0.01,
+  "gosvm/internal/compiler TestSDKViewCapacities": 0.09,
+  "gosvm/internal/compiler TestScalarArraysDifferential": 0.87,
+  "gosvm/internal/compiler TestSecp256k1RecoverSBF": 4.14,
+  "gosvm/internal/compiler TestSharedExampleDifferential": 0.75,
+  "gosvm/internal/compiler TestSignedRuntimeOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestSliceArrayCheck": 0.0,
+  "gosvm/internal/compiler TestSliceArrayDifferential": 11.92,
+  "gosvm/internal/compiler TestSliceArrayRejections": 0.0,
+  "gosvm/internal/compiler TestSliceArraySBF": 8.96,
+  "gosvm/internal/compiler TestSliceViewArrayBoundary": 0.93,
+  "gosvm/internal/compiler TestSliceViewRejections": 0.0,
+  "gosvm/internal/compiler TestSliceViewsDifferential": 1.36,
+  "gosvm/internal/compiler TestStdlibAPI": 0.17,
+  "gosvm/internal/compiler TestStdlibConstantsOnly": 0.0,
+  "gosvm/internal/compiler TestStdlibDifferential": 38.76,
+  "gosvm/internal/compiler TestStdlibIdentity": 0.0,
+  "gosvm/internal/compiler TestStdlibImportForms": 0.48,
+  "gosvm/internal/compiler TestStdlibIntrinsics": 0.08,
+  "gosvm/internal/compiler TestStdlibPackagesList": 0.04,
+  "gosvm/internal/compiler TestStdlibProvenance": 0.01,
+  "gosvm/internal/compiler TestStdlibRejections": 0.35,
+  "gosvm/internal/compiler TestStdlibSBF": 47.82,
+  "gosvm/internal/compiler TestStdlibUnicodeTables": 0.0,
+  "gosvm/internal/compiler TestStringAcceptedForms": 0.98,
+  "gosvm/internal/compiler TestStringDifferential": 43.3,
+  "gosvm/internal/compiler TestStringDocumentationExample": 0.06,
+  "gosvm/internal/compiler TestStringHeap": 9.4,
+  "gosvm/internal/compiler TestStringIntegerConversions": 1.73,
+  "gosvm/internal/compiler TestStringRejections": 0.0,
+  "gosvm/internal/compiler TestStringRuntimeOnlyWhenUsed": 0.35,
+  "gosvm/internal/compiler TestStringSBF": 16.54,
+  "gosvm/internal/compiler TestTrimDropsUnreachable": 1.66,
+  "gosvm/internal/compiler TestTrimEntryPackage": 0.0,
+  "gosvm/internal/compiler TestTrimModules": 2.84,
+  "gosvm/internal/compiler TestTrimRejections": 1.46,
+  "gosvm/internal/compiler TestTrimWarnings": 3.1,
+  "gosvm/internal/compiler TestTypeCheckBeforeEntryGeneration": 0.0,
+  "gosvm/internal/compiler TestTypeInspectionIsNotSubsetCertification": 0.0,
+  "gosvm/internal/compiler TestUint16Checks": 0.0,
+  "gosvm/internal/compiler TestUint16Differential": 1.03,
+  "gosvm/internal/compiler TestUint16TypedefOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestValidateTrim": 0.0,
+  "gosvm/internal/compiler TestValueTypeRejections": 0.0,
+  "gosvm/internal/compiler TestValueTypesAcceptedForms": 1.38,
+  "gosvm/internal/compiler TestValueTypesDifferential": 42.5,
+  "gosvm/internal/compiler TestValueTypesRejections": 0.0,
+  "gosvm/internal/compiler TestValueTypesSBF": 12.34,
+  "gosvm/internal/compiler TestVariadicForms": 0.0,
+  "gosvm/internal/compiler TestVariadicLowering": 0.0,
+  "gosvm/internal/compiler TestVariadicRejections": 0.0,
+  "gosvm/internal/compiler TestViewAggregateReturn": 0.2,
+  "gosvm/internal/compiler TestViewCapacityBoundary": 0.15,
+  "gosvm/internal/compiler TestWideQuoteDifferential": 0.14,
+  "gosvm/internal/compiler TestZeroLoopForms": 0.05,
+  "gosvm/internal/features TestAllocationCounters": 0.0,
+  "gosvm/internal/features TestCompoundCounters": 0.01,
+  "gosvm/internal/features TestDeterministicOutput": 0.39,
+  "gosvm/internal/features TestFullSwapFacts": 0.19,
+  "gosvm/internal/features TestFunctionValueCounters": 0.0,
+  "gosvm/internal/features TestFunctionValueUses": 0.0,
+  "gosvm/internal/features TestGenerics": 0.21,
+  "gosvm/internal/features TestGlobalCounters": 0.0,
+  "gosvm/internal/features TestGlobalUses": 0.01,
+  "gosvm/internal/features TestInlineProgram": 0.0,
+  "gosvm/internal/features TestInterfaceCounters": 0.0,
+  "gosvm/internal/features TestMapCounters": 0.0,
+  "gosvm/internal/features TestMapFunctionCounters": 0.0,
+  "gosvm/internal/features TestPointerConversionCounter": 0.0,
+  "gosvm/internal/features TestSignedIntegers": 0.0,
+  "gosvm/internal/features TestSliceArrayConversionCounter": 0.0,
+  "gosvm/internal/features TestStdlibCalls": 0.14,
+  "gosvm/internal/features TestStdlibUses": 0.06,
+  "gosvm/internal/features TestStringCounters": 0.0,
+  "gosvm/internal/features TestTrimmedUses": 0.47,
+  "gosvm/internal/features TestUsesSummary": 0.5,
+  "gosvm/internal/features TestValueTypeCounters": 0.0,
+  "gosvm/internal/library TestBendBuildKey": 0.01,
+  "gosvm/internal/library TestBendFogoV157Accepted": 0.0,
+  "gosvm/internal/library TestBuildBendSourceFake": 0.15,
+  "gosvm/internal/library TestBuildRustLibrary": 0.0,
+  "gosvm/internal/library TestBuildRustRefusals": 0.0,
+  "gosvm/internal/library TestInspectBendCheckoutPrerequisites": 0.07,
+  "gosvm/internal/library TestParseBendBuild": 0.0,
+  "gosvm/internal/library TestProducerRequiresExplicitPinnedContract": 0.01,
+  "gosvm/internal/library TestPublishedBendContract": 0.0,
+  "gosvm/internal/library TestPublishedBendContractFlatLayout": 0.0,
+  "gosvm/internal/library TestRustFingerprintAndWrapper": 0.0,
+  "gosvm/internal/library TestRustToolchainMissing": 0.0,
+  "gosvm/internal/network TestCheckDeployableFollowsLiveFeatures": 0.0,
+  "gosvm/internal/network TestEnsureKeypairRoundTrips": 0.0,
+  "gosvm/internal/network TestFundingMessage": 0.0,
+  "gosvm/internal/network TestProgramDataAddress": 0.0,
+  "gosvm/internal/network TestSignMatchesInvokeEncoding": 0.0,
+  "gosvm/internal/network TestUpgradeDecisions": 0.0,
+  "gosvm/internal/project TestAddBendLibrary": 0.0,
+  "gosvm/internal/project TestAddRustLibrary": 0.0,
+  "gosvm/internal/project TestBendSourceDeclarationsValidate": 0.0,
+  "gosvm/internal/project TestBendSourceIntegration": 0.0,
+  "gosvm/internal/project TestBendSourceNeedsCheckout": 0.01,
+  "gosvm/internal/project TestBendSourceSyncFake": 0.0,
+  "gosvm/internal/project TestCustomModuleAndDiscovery": 0.39,
+  "gosvm/internal/project TestExplicitSDK2AndLegacySnapshot": 1.39,
+  "gosvm/internal/project TestExplicitTargetMigrationPreservesApplicationAndWire": 0.32,
+  "gosvm/internal/project TestGenerationChecksBeforeWriting": 0.01,
+  "gosvm/internal/project TestGoModuleSyntax": 0.0,
+  "gosvm/internal/project TestHeapBytesSetting": 0.01,
+  "gosvm/internal/project TestLibraryDeclarationsValidate": 0.0,
+  "gosvm/internal/project TestLoadSchemaFullSwap": 0.11,
+  "gosvm/internal/project TestLoadSchemaRejectsSchema1": 0.01,
+  "gosvm/internal/project TestNetworkTargetsResolveAndValidate": 0.02,
+  "gosvm/internal/project TestSDK1RejectsNewBoundaryCalls": 0.01,
+  "gosvm/internal/project TestSDK2FixtureScaffold": 0.65,
+  "gosvm/internal/project TestSDKDriftRejected": 0.01,
+  "gosvm/internal/project TestSchema2AllInitTargetsValidatedBeforeCPI": 0.79,
+  "gosvm/internal/project TestSchema2CheckedConstraintDiagnostics": 1.17,
+  "gosvm/internal/project TestSchema2CheckedTokenAndPDAGeneration": 1.55,
+  "gosvm/internal/project TestSchema2HistoricalManifestValidation": 0.51,
+  "gosvm/internal/project TestSchema2InvalidDeclarations": 1.57,
+  "gosvm/internal/project TestSchema2LayoutVersionsAreGuarded": 0.29,
+  "gosvm/internal/project TestSchema2LifecycleDiagnostics": 0.51,
+  "gosvm/internal/project TestSchema2LifecycleGeneration": 1.34,
+  "gosvm/internal/project TestSchema2NamedScalarArrayWire": 0.38,
+  "gosvm/internal/project TestSchema2PDAAdapterOnlyImport": 0.19,
+  "gosvm/internal/project TestSchema2ReadonlyAliasAndProgramIdentity": 0.36,
+  "gosvm/internal/project TestSchema2RejectsCountsBeyondLoaderABI": 0.09,
+  "gosvm/internal/project TestSchema2RejectsGenericWireTypes": 0.38,
+  "gosvm/internal/project TestSchema2RejectsMaps": 0.35,
+  "gosvm/internal/project TestSchema2RejectsPlatformSizedIntegers": 0.36,
+  "gosvm/internal/project TestSchema2RejectsStrings": 0.37,
+  "gosvm/internal/project TestSchema2SignedFieldsAndSeeds": 0.61,
+  "gosvm/internal/project TestSchema2SourceDiagnosticsBeforePublication": 0.39,
+  "gosvm/internal/project TestSchema2StandaloneCanonicalLayouts": 1.01,
+  "gosvm/internal/project TestSchema2Uint16FieldsAndSeeds": 0.66,
+  "gosvm/internal/project TestStandaloneStarter": 0.31,
+  "gosvm/internal/project TestTrimSetting": 0.01,
+  "gosvm/internal/project TestWireFieldsAndSchemaChanges": 0.11,
+  "gosvm/internal/runner TestAtomicInstallAndPinnedIntegrity": 0.02,
+  "gosvm/internal/runner TestBusyInstallPreservesLock": 0.0,
+  "gosvm/internal/runner TestDownloadRejectsWrongBytesBeforeExecution": 0.05,
+  "gosvm/internal/runner TestEmbeddedPinsAndPackageDetection": 0.29,
+  "gosvm/internal/runner TestFailedSmokeAndCancellationDoNotPublish": 0.0,
+  "gosvm/internal/runner TestGzipTrailerAndInstalledFileType": 0.0,
+  "gosvm/internal/runner TestRejectArchivesBeforeExecution": 0.02,
+  "gosvm/internal/runner TestReleasePinAcceptsHistoricalInstall": 0.0,
+  "gosvm/internal/runner TestWrongPlatformArchiveIsNamed": 0.01,
+  "gosvm/internal/sbftest TestFastFailureRemovesPreviousPassingReport": 0.0,
+  "gosvm/internal/sbftest TestFastSelectionRejectsEmptyAndInvalidMatches": 0.0,
+  "gosvm/internal/sbftest TestFixtureTransactionMergesKeysAndPreservesReferences": 0.0,
+  "gosvm/internal/sbftest TestGeneralChecksMetadataAndExactErrorCategories": 0.0,
+  "gosvm/internal/sbftest TestGeneralFixturesRejectAmbiguousAndUncheckedInputs": 0.0,
+  "gosvm/internal/sbftest TestGeneralReportsAreClearedWithoutOverwritingInputs": 0.0,
+  "gosvm/internal/sbftest TestGeneralSysvarControlsValidateBeforeAnySelectedScenario": 0.0,
+  "gosvm/internal/sbftest TestNativeProgramAliasesAndDeclaredTransactions": 0.0,
+  "gosvm/internal/sbftest TestSimulationStateOverridesKeepCommittedChecks": 0.0,
+  "gosvm/internal/targets TestVersionAndMachineAreBothRequired": 0.0,
+  "gosvm/internal/testvm TestRunnerProfileIsValidAndOverrideIsExplicit": 0.0,
+  "gosvm/internal/testvm TestRunnerSelectionPerProfile": 0.04,
+  "gosvm/internal/testvm TestRunnerSelectionPrecedenceAndDamagedManagedCache": 0.02,
+  "gosvm/internal/testvm TestSVMControlsIntegration": 0.0,
+  "gosvm/internal/testvm TestSelectionAndVersion": 0.0,
+  "gosvm/internal/testvm TestSessionCancellationUnblocksRead": 0.1,
+  "gosvm/internal/testvm TestSessionChecksEveryCallIdentityAndError": 0.02,
+  "gosvm/internal/testvm TestSessionHelperProcess": 0.0,
+  "gosvm/internal/testvm TestSessionRejectsCorruptResponses": 0.02,
+  "gosvm/internal/testvm TestSysvarParsingPreservesIntegerLimitsAndPartialControls": 0.0,
+  "gosvm/internal/testvm TestSysvarParsingRejectsIncompleteAmbiguousAndOutOfRangeValues": 0.0,
+  "gosvm/internal/testvm TestTargetRuntimeContract": 0.0,
+  "gosvm/internal/toolchain TestAllowlistExtraction": 0.0,
+  "gosvm/internal/toolchain TestBadArchiveDoesNotPublish": 0.0,
+  "gosvm/internal/toolchain TestModernDownloadInstallsOnlyPinnedBackend": 0.01,
+  "gosvm/internal/toolchain TestModernLocalArchiveAndRejections": 0.02,
+  "gosvm/internal/toolchain TestModernReceiptSources": 0.01,
+  "gosvm/internal/toolchain TestOfficialArchivesPerHost": 0.0,
+  "gosvm/internal/toolchain TestOfficialFullPins": 0.0,
+  "gosvm/internal/toolchain TestOfficialModernPins": 0.0,
+  "gosvm/internal/toolchain TestRejectUnsafeOrIncompleteBackend": 0.0,
+  "gosvm/internal/toolchain TestRustFullTreeInstall": 0.04,
+  "gosvm/internal/toolchain TestRustFullTreeLocalArchiveWithExistingBackend": 0.01,
+  "gosvm/internal/toolchain TestRustFullTreeRejections": 0.07,
+  "gosvm/internal/toolchain TestRustPlatformToolsReceipt": 0.0,
+  "gosvm/sdk/ata TestAddressMatchesFindProgramAddress": 0.0,
+  "gosvm/sdk/ata TestCreateDelegatesAddressValidation": 0.0,
+  "gosvm/sdk/ata TestCreateEncoding": 0.0,
+  "gosvm/sdk/ata TestCreateGuards": 0.0,
+  "gosvm/sdk/cpi TestBoundedMetasAndSignerGroups": 0.0,
+  "gosvm/sdk/cpi TestInvokeSingleSignedUnsignedAndGuards": 0.0,
+  "gosvm/sdk/cpi TestInvokeValidationAndExactCallbackStatus": 0.0,
+  "gosvm/sdk/cpi TestSingleSignerEncodingAndRejectedAdds": 0.02,
+  "gosvm/sdk/fixture TestBase58Keys": 0.0,
+  "gosvm/sdk/fixture TestBuildErrors": 0.0,
+  "gosvm/sdk/fixture TestDeterministicKeys": 0.0,
+  "gosvm/sdk/fixture TestFindProgramAddressVectors": 0.0,
+  "gosvm/sdk/fixture TestOnCurve": 0.0,
+  "gosvm/sdk/fixture TestRent": 0.0,
+  "gosvm/sdk/fixture TestSuiteLoadsInRunnerValidation": 0.0,
+  "gosvm/sdk/pda TestAddressAndFailureOutput": 0.0,
+  "gosvm/sdk/pda TestExplicitSeedEncodingAndBounds": 0.0,
+  "gosvm/sdk/pda TestFindAddressMatchesSolana": 0.05,
+  "gosvm/sdk/pda TestFindAddressStatuses": 0.0,
+  "gosvm/sdk/system TestRentCurrentSysvar": 0.0,
+  "gosvm/sdk/system TestRentMinimumDifferential": 0.03,
+  "gosvm/sdk/system TestSystemAllocateAssignEncoding": 0.0,
+  "gosvm/sdk/system TestSystemCreateAndTransferEncoding": 0.0,
+  "gosvm/sdk/system TestSystemCreatePDAFundedAndUnfunded": 0.0,
+  "gosvm/sdk/system TestSystemFreeRentRetainsAccount": 0.0,
+  "gosvm/sdk/system TestSystemPDAAndCreationGuards": 0.0,
+  "gosvm/sdk/system TestSystemTransferSignedEncodingAndGuards": 0.0,
+  "gosvm/sdk/token TestCheckedBalanceRevalidation": 0.0,
+  "gosvm/sdk/token TestCheckedInstructionEncodings": 0.0,
+  "gosvm/sdk/token TestCheckedInstructionGuards": 0.0,
+  "gosvm/sdk/token TestCheckedInstructionsClassicAndSelfAuthority": 0.0,
+  "gosvm/sdk/token TestCheckedTransferAndCurrentReads": 0.0,
+  "gosvm/sdk/token TestFindExtensionAndTransferFeeConfig": 0.0,
+  "gosvm/sdk/token TestProgramPredicates": 0.0,
+  "gosvm/sdk/token TestReadAccountLayouts": 0.0,
+  "gosvm/sdk/token TestReadMintLayouts": 0.0,
+  "gosvm/sdk/token TestTokenCloseAuthorityAndCurrentReference": 0.0,
+  "gosvm/sdk/token TestTokenCreateCurrentStorageAndCPIEncoding": 0.0,
+  "gosvm/sdk/token TestTokenCreatePreconditionsAndDownstreamFailures": 0.0,
+  "gosvm/sdk/token TestTokenRevalidationBeforeInvoke": 0.0,
+  "gosvm/sdk/token TestTransferFeeArithmetic": 0.02,
+  "gosvm/solana TestClockCurrentWordsAndFailedOutput": 0.0,
+  "gosvm/solana TestGetReturnDataCopiesPrefixAndSetter": 0.0,
+  "gosvm/solana TestGetReturnDataOverlap": 0.0,
+  "gosvm/solana TestKeccak256BoundsAndCopy": 0.0,
+  "gosvm/solana TestLogMessages": 0.0,
+  "gosvm/solana TestLogRejectsInvalidUTF8": 0.0,
+  "gosvm/solana TestMoveLamportsRules": 0.0,
+  "gosvm/solana TestOwnedLifecycleAliases": 0.0,
+  "gosvm/solana TestOwnedLifecycleFailureAtomicity": 0.0,
+  "gosvm/solana TestRentBoundaryPreservesFailedOutput": 0.0,
+  "gosvm/solana TestReturnDataBoundsCopiesAndUnavailable": 0.0,
+  "gosvm/solana TestSHA256Regions": 0.0,
+  "gosvm/solana TestSecp256k1RecoverBoundsStatusesAndCopy": 0.0
+ },
+ "linux-amd64": {
+  "gosvm/cmd/gosvm TestCallDryRun": 1.76,
+  "gosvm/cmd/gosvm TestCallList": 0.17,
+  "gosvm/cmd/gosvm TestCallRawAccounts": 0.0,
+  "gosvm/cmd/gosvm TestExternalELFHeaderMustMatchTarget": 0.01,
+  "gosvm/cmd/gosvm TestExternalELFMatchesBuiltProgram": 2.05,
+  "gosvm/cmd/gosvm TestExternalELFRequiresOneTarget": 0.01,
+  "gosvm/cmd/gosvm TestExternalELFRequiresSVM": 0.0,
+  "gosvm/cmd/gosvm TestFastGenerationFailureRemovesPreviousReport": 0.01,
+  "gosvm/cmd/gosvm TestFastTestFlagsRejectConflictingModesBeforeProjectWork": 0.0,
+  "gosvm/cmd/gosvm TestFeaturesCommandProjectAndPackage": 0.86,
+  "gosvm/cmd/gosvm TestGoHostWarning": 0.0,
+  "gosvm/cmd/gosvm TestLCUUIDWatcherFindsSplitMessage": 0.0,
+  "gosvm/cmd/gosvm TestMacOSFromDarwin": 0.0,
+  "gosvm/cmd/gosvm TestSVMFixturesDefault": 0.17,
+  "gosvm/examples/amm TestInvalidLengths": 0.0,
+  "gosvm/examples/amm TestSwapAgainstBigIntegerReference": 0.01,
+  "gosvm/examples/protocol TestFixedRegions": 0.0,
+  "gosvm/examples/protocol TestIndependentReference": 0.0,
+  "gosvm/examples/protocol TestWireWords": 0.0,
+  "gosvm/examples/tokenswap TestFailedSecondCPI": 0.0,
+  "gosvm/examples/tokenswap TestMulDiv": 0.03,
+  "gosvm/examples/tokenswap TestNativeSwap": 0.0,
+  "gosvm/examples/tokenswap TestNativeValidation": 0.0,
+  "gosvm/examples/tokenswap TestWideQuote": 0.14,
+  "gosvm/internal/callplan TestEscrow": 0.08,
+  "gosvm/internal/callplan TestFieldParsing": 0.0,
+  "gosvm/internal/callplan TestFullSwap": 0.08,
+  "gosvm/internal/callplan TestHeapFrame": 0.0,
+  "gosvm/internal/callplan TestTutorialErrors": 0.09,
+  "gosvm/internal/callplan TestTutorialList": 0.0,
+  "gosvm/internal/callplan TestTutorialMatchesRunnerFixtures": 0.08,
+  "gosvm/internal/callplan TestTutorialRunnerE2E": 0.0,
+  "gosvm/internal/compiler TestAMMDifferential": 1.27,
+  "gosvm/internal/compiler TestAccounts64Frames": 17.86,
+  "gosvm/internal/compiler TestAccounts64SBF": 1.91,
+  "gosvm/internal/compiler TestAllocationAcceptedForms": 13.0,
+  "gosvm/internal/compiler TestAllocationDifferential": 3.76,
+  "gosvm/internal/compiler TestAllocationRejections": 0.04,
+  "gosvm/internal/compiler TestAllocationRuntimeOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestAllocationSBF": 18.01,
+  "gosvm/internal/compiler TestArrayCapacityMemory": 4.16,
+  "gosvm/internal/compiler TestArrayDeclarationOrder": 1.85,
+  "gosvm/internal/compiler TestArrayRejections": 0.05,
+  "gosvm/internal/compiler TestArrayStorageLimit": 0.01,
+  "gosvm/internal/compiler TestBitsCheckAcceptsSupportedFunctions": 0.42,
+  "gosvm/internal/compiler TestBitsCheckAcceptsUintAndIntValues": 0.07,
+  "gosvm/internal/compiler TestBitsCheckRejections": 0.01,
+  "gosvm/internal/compiler TestBitsDeclarationsMatchStandardLibrary": 0.02,
+  "gosvm/internal/compiler TestBitsDifferentialAgainstGo": 8.45,
+  "gosvm/internal/compiler TestBitsImportForms": 0.57,
+  "gosvm/internal/compiler TestBitsRuntimeOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestBitsSBF": 2.31,
+  "gosvm/internal/compiler TestBuildReceiptInvalidation": 0.15,
+  "gosvm/internal/compiler TestByvalCopies": 0.05,
+  "gosvm/internal/compiler TestByvalDifferential": 4.77,
+  "gosvm/internal/compiler TestByvalSBF": 13.55,
+  "gosvm/internal/compiler TestCPILimitsSBF": 4.55,
+  "gosvm/internal/compiler TestCheckLegacyEntryAndRejection": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramDescribesContextProgram": 0.01,
+  "gosvm/internal/compiler TestCheckedProgramFuncMaps": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramFunctions": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramGlobals": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramInstances": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramInterfaces": 0.0,
+  "gosvm/internal/compiler TestCheckedProgramMaps": 0.0,
+  "gosvm/internal/compiler TestClosureEnvironmentHeap": 9.53,
+  "gosvm/internal/compiler TestClosureMapHeap": 3.9,
+  "gosvm/internal/compiler TestClosureStringHeap": 7.37,
+  "gosvm/internal/compiler TestCompositeArrayEscapes": 0.0,
+  "gosvm/internal/compiler TestCompoundAcceptedForms": 2.82,
+  "gosvm/internal/compiler TestCompoundDifferential": 26.83,
+  "gosvm/internal/compiler TestCompoundEmission": 0.0,
+  "gosvm/internal/compiler TestCompoundOperandOrder": 8.24,
+  "gosvm/internal/compiler TestCompoundRejections": 0.02,
+  "gosvm/internal/compiler TestCompoundSBF": 8.13,
+  "gosvm/internal/compiler TestConstInitDifferential": 19.19,
+  "gosvm/internal/compiler TestConstInitSBF": 12.98,
+  "gosvm/internal/compiler TestControlRejections": 0.01,
+  "gosvm/internal/compiler TestControlValuesDifferential": 0.97,
+  "gosvm/internal/compiler TestCorpusMatchesPreCheckCompiler": 7.59,
+  "gosvm/internal/compiler TestCrossPackageAliases": 0.75,
+  "gosvm/internal/compiler TestDependencyNamespaceSeparatesImportedContent": 0.29,
+  "gosvm/internal/compiler TestEvalOrderDifferential": 21.62,
+  "gosvm/internal/compiler TestEvalOrderHoisted": 0.0,
+  "gosvm/internal/compiler TestEvalOrderLocalsAndTraps": 0.02,
+  "gosvm/internal/compiler TestEvalOrderMaps": 0.0,
+  "gosvm/internal/compiler TestEvalOrderNothingToHoist": 0.0,
+  "gosvm/internal/compiler TestEvalOrderSBF": 40.67,
+  "gosvm/internal/compiler TestEvalOrderVariadicAndPointerToPointer": 0.02,
+  "gosvm/internal/compiler TestFormerEscapesMoveToHeap": 8.14,
+  "gosvm/internal/compiler TestFrameDiagnosticsParse": 0.0,
+  "gosvm/internal/compiler TestFrameOverflowFailsBuild": 1.2,
+  "gosvm/internal/compiler TestFuncAcceptedForms": 5.44,
+  "gosvm/internal/compiler TestFuncCombinationsSBF": 13.05,
+  "gosvm/internal/compiler TestFuncContextCapture": 0.15,
+  "gosvm/internal/compiler TestFuncMapAcceptedForms": 3.5,
+  "gosvm/internal/compiler TestFuncMapRecursion": 0.01,
+  "gosvm/internal/compiler TestFuncMapsDifferential": 29.8,
+  "gosvm/internal/compiler TestFuncRejections": 0.13,
+  "gosvm/internal/compiler TestFuncRuntimeOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestFuncStringsDifferential": 24.21,
+  "gosvm/internal/compiler TestFuncValuesDifferential": 29.5,
+  "gosvm/internal/compiler TestFuncValuesSBF": 21.31,
+  "gosvm/internal/compiler TestGenericAcceptedForms": 0.04,
+  "gosvm/internal/compiler TestGenericAliasSpellingsShareInstances": 0.65,
+  "gosvm/internal/compiler TestGenericArrayTypeArgsDifferential": 6.31,
+  "gosvm/internal/compiler TestGenericArrayTypeArgsForms": 1.18,
+  "gosvm/internal/compiler TestGenericArrayTypeArgsSBF": 16.32,
+  "gosvm/internal/compiler TestGenericCrossPackage": 0.0,
+  "gosvm/internal/compiler TestGenericDifferential": 14.22,
+  "gosvm/internal/compiler TestGenericMatchesHandwrittenSBF": 3.97,
+  "gosvm/internal/compiler TestGenericNamesAreDeterministic": 0.38,
+  "gosvm/internal/compiler TestGenericRejections": 0.11,
+  "gosvm/internal/compiler TestGenericSBF": 8.22,
+  "gosvm/internal/compiler TestGetReturnDataSBF": 1.96,
+  "gosvm/internal/compiler TestGlobalAcceptedForms": 5.35,
+  "gosvm/internal/compiler TestGlobalHeapAccounting": 0.51,
+  "gosvm/internal/compiler TestGlobalInitPanics": 5.31,
+  "gosvm/internal/compiler TestGlobalInitTrap": 5.7,
+  "gosvm/internal/compiler TestGlobalOperandOrder": 0.46,
+  "gosvm/internal/compiler TestGlobalPackages": 2.53,
+  "gosvm/internal/compiler TestGlobalReadOnly": 2.13,
+  "gosvm/internal/compiler TestGlobalRejections": 0.02,
+  "gosvm/internal/compiler TestGlobalRuntimeOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestGlobalValueTypesDifferential": 14.74,
+  "gosvm/internal/compiler TestGlobalValueTypesPlacement": 0.02,
+  "gosvm/internal/compiler TestGlobalValueTypesSBF": 30.13,
+  "gosvm/internal/compiler TestGlobalsDifferential": 12.1,
+  "gosvm/internal/compiler TestGlobalsSBF": 7.53,
+  "gosvm/internal/compiler TestGoSemantics": 0.35,
+  "gosvm/internal/compiler TestGrowthModelMatchesCompiledAppend": 0.01,
+  "gosvm/internal/compiler TestGrowthModelMatchesGoRuntime": 4.58,
+  "gosvm/internal/compiler TestGrowthRuntimeMatchesModel": 2.37,
+  "gosvm/internal/compiler TestHeapMovesExported": 0.01,
+  "gosvm/internal/compiler TestImportedMainPackage": 0.0,
+  "gosvm/internal/compiler TestImportedMethodsAndBorrowedResults": 0.3,
+  "gosvm/internal/compiler TestImportedMultipleResults": 0.53,
+  "gosvm/internal/compiler TestImportedPackageRejections": 0.01,
+  "gosvm/internal/compiler TestImportedSDKAndEntryIdentity": 4.84,
+  "gosvm/internal/compiler TestImportedValuesAndCalls": 6.41,
+  "gosvm/internal/compiler TestInitEvalEdgesSBF": 2.86,
+  "gosvm/internal/compiler TestInitEvalPartialPackage": 5.69,
+  "gosvm/internal/compiler TestInitEvalRuntimeInit": 0.0,
+  "gosvm/internal/compiler TestInitEvalStops": 17.52,
+  "gosvm/internal/compiler TestInitImageCheckedProgram": 0.01,
+  "gosvm/internal/compiler TestInitImageHeapAccounting": 34.54,
+  "gosvm/internal/compiler TestIntValuesDifferential": 8.99,
+  "gosvm/internal/compiler TestIntValuesFixture": 0.07,
+  "gosvm/internal/compiler TestIntValuesSBF": 8.22,
+  "gosvm/internal/compiler TestIntegerChecksAccept": 0.03,
+  "gosvm/internal/compiler TestIntegerChecksReject": 0.01,
+  "gosvm/internal/compiler TestInterfaceAcceptedForms": 5.47,
+  "gosvm/internal/compiler TestInterfaceBoxingHeap": 7.33,
+  "gosvm/internal/compiler TestInterfaceCrossPackage": 0.48,
+  "gosvm/internal/compiler TestInterfaceDifferential": 15.34,
+  "gosvm/internal/compiler TestInterfaceHeapMoves": 0.0,
+  "gosvm/internal/compiler TestInterfaceRejections": 0.06,
+  "gosvm/internal/compiler TestInterfaceRuntimeOnlyWhenUsed": 0.6,
+  "gosvm/internal/compiler TestInterfaceSBF": 11.66,
+  "gosvm/internal/compiler TestKeccak256SBF": 1.53,
+  "gosvm/internal/compiler TestKeccakReference": 0.0,
+  "gosvm/internal/compiler TestLargeTablesAccepted": 4.33,
+  "gosvm/internal/compiler TestLargeTablesRejected": 0.02,
+  "gosvm/internal/compiler TestMangleIsInjective": 0.0,
+  "gosvm/internal/compiler TestMapAcceptedForms": 6.82,
+  "gosvm/internal/compiler TestMapDifferential": 37.28,
+  "gosvm/internal/compiler TestMapDocumentationExample": 0.12,
+  "gosvm/internal/compiler TestMapHeap": 62.34,
+  "gosvm/internal/compiler TestMapHeapMoves": 0.13,
+  "gosvm/internal/compiler TestMapRejections": 0.08,
+  "gosvm/internal/compiler TestMapRuntimeOnlyWhenUsed": 0.94,
+  "gosvm/internal/compiler TestMapSBF": 36.86,
+  "gosvm/internal/compiler TestMaxAccountsOptIn": 0.07,
+  "gosvm/internal/compiler TestMemmoveHelperCompiles": 1.08,
+  "gosvm/internal/compiler TestMemmoveSBF": 3.38,
+  "gosvm/internal/compiler TestMemoryDifferential": 10.86,
+  "gosvm/internal/compiler TestMemoryLegacyUnchanged": 0.0,
+  "gosvm/internal/compiler TestMemoryReadOnlyWritesSBF": 2.28,
+  "gosvm/internal/compiler TestMemoryRuntimeSBF": 1.39,
+  "gosvm/internal/compiler TestMemorySBF": 43.0,
+  "gosvm/internal/compiler TestMemorySyscallRoutinesCompileForSBF": 0.41,
+  "gosvm/internal/compiler TestMixedAcceptedForms": 9.64,
+  "gosvm/internal/compiler TestMixedDifferential": 25.99,
+  "gosvm/internal/compiler TestMixedHeapRuntimeOnlyForInstances": 0.0,
+  "gosvm/internal/compiler TestMixedInstanceHeapMoves": 0.01,
+  "gosvm/internal/compiler TestMixedRejections": 0.02,
+  "gosvm/internal/compiler TestMixedSBF": 9.03,
+  "gosvm/internal/compiler TestModernRebuildIsByteIdentical": 7.09,
+  "gosvm/internal/compiler TestModuleImportFailures": 0.16,
+  "gosvm/internal/compiler TestModuleImportsAndCache": 0.36,
+  "gosvm/internal/compiler TestMultiFileValueSemantics": 0.09,
+  "gosvm/internal/compiler TestMultiplyBuiltinNativeDifferential": 0.72,
+  "gosvm/internal/compiler TestNilSliceContexts": 3.93,
+  "gosvm/internal/compiler TestNoGenericsLowersToItself": 0.0,
+  "gosvm/internal/compiler TestOutOfMemoryBoundaries": 4.67,
+  "gosvm/internal/compiler TestPackageSourcesAndCache": 0.15,
+  "gosvm/internal/compiler TestPackedStoreNativeCDifferential": 11.94,
+  "gosvm/internal/compiler TestPackedStoreRecognition": 0.05,
+  "gosvm/internal/compiler TestPanicLogLine": 0.54,
+  "gosvm/internal/compiler TestPanicSites": 0.01,
+  "gosvm/internal/compiler TestPlatformWordsInsideFilename": 0.0,
+  "gosvm/internal/compiler TestPointerArrayLengthAndReceiverEffects": 0.71,
+  "gosvm/internal/compiler TestPointerLifetimeRejections": 0.03,
+  "gosvm/internal/compiler TestPointerToPointerBorrows": 0.0,
+  "gosvm/internal/compiler TestPointerValuesDifferential": 0.26,
+  "gosvm/internal/compiler TestRangeAcceptedForms": 0.06,
+  "gosvm/internal/compiler TestRangeDifferential": 2.25,
+  "gosvm/internal/compiler TestRangeRejections": 0.01,
+  "gosvm/internal/compiler TestRangeUint16SBF": 24.43,
+  "gosvm/internal/compiler TestRealLibrariesDifferential": 35.57,
+  "gosvm/internal/compiler TestRealLibrariesInitSBF": 76.08,
+  "gosvm/internal/compiler TestRealLibrariesSBF": 70.3,
+  "gosvm/internal/compiler TestRealLibrariesWholePackages": 18.73,
+  "gosvm/internal/compiler TestRealLibraryFormsCheck": 0.01,
+  "gosvm/internal/compiler TestRealLibraryFormsDifferential": 4.72,
+  "gosvm/internal/compiler TestRealLibraryFormsSBF": 7.46,
+  "gosvm/internal/compiler TestRejectUnsupported": 0.03,
+  "gosvm/internal/compiler TestResolverFlagLikeImport": 0.05,
+  "gosvm/internal/compiler TestRuntimeGuards": 8.9,
+  "gosvm/internal/compiler TestSBFUnresolvedSymbolGuard": 0.0,
+  "gosvm/internal/compiler TestSDK2AggregateMemory": 0.8,
+  "gosvm/internal/compiler TestSDK2ArrayValueSemantics": 2.09,
+  "gosvm/internal/compiler TestSDK2ClockNativeCDifferential": 6.56,
+  "gosvm/internal/compiler TestSDK2GetReturnDataNativeCDifferential": 1.35,
+  "gosvm/internal/compiler TestSDK2InvokeBoundaryDifferential": 0.9,
+  "gosvm/internal/compiler TestSDK2Keccak256NativeCDifferential": 0.98,
+  "gosvm/internal/compiler TestSDK2LifecycleLoaderSelection": 0.05,
+  "gosvm/internal/compiler TestSDK2LogNativeCDifferential": 0.51,
+  "gosvm/internal/compiler TestSDK2LogRuntimeEmittedOnlyWhenCalled": 0.04,
+  "gosvm/internal/compiler TestSDK2MoveLamportsEmittedOnlyWhenCalled": 0.03,
+  "gosvm/internal/compiler TestSDK2MoveLamportsNativeCDifferential": 0.82,
+  "gosvm/internal/compiler TestSDK2OwnedLifecycleDifferential": 1.56,
+  "gosvm/internal/compiler TestSDK2RentCalculationC": 1.67,
+  "gosvm/internal/compiler TestSDK2ReturnDataNativeCDifferential": 8.44,
+  "gosvm/internal/compiler TestSDK2Secp256k1RecoverNativeCDifferential": 0.78,
+  "gosvm/internal/compiler TestSDKATACreateSBF": 4.02,
+  "gosvm/internal/compiler TestSDKAccountDecoderCapacityAndAliases": 15.16,
+  "gosvm/internal/compiler TestSDKContext": 0.19,
+  "gosvm/internal/compiler TestSDKHashBounds": 0.43,
+  "gosvm/internal/compiler TestSDKNilSliceArguments": 0.29,
+  "gosvm/internal/compiler TestSDKSystemPDASBF": 10.26,
+  "gosvm/internal/compiler TestSDKTokenCPISBF": 2.12,
+  "gosvm/internal/compiler TestSDKTokenExtensionsSBF": 5.54,
+  "gosvm/internal/compiler TestSDKVersionsAndNativeOnlyTypes": 0.02,
+  "gosvm/internal/compiler TestSDKViewCapacities": 0.69,
+  "gosvm/internal/compiler TestScalarArraysDifferential": 1.51,
+  "gosvm/internal/compiler TestSecp256k1RecoverSBF": 1.22,
+  "gosvm/internal/compiler TestSharedExampleDifferential": 2.05,
+  "gosvm/internal/compiler TestSignedRuntimeOnlyWhenUsed": 0.01,
+  "gosvm/internal/compiler TestSliceArrayCheck": 0.02,
+  "gosvm/internal/compiler TestSliceArrayDifferential": 17.59,
+  "gosvm/internal/compiler TestSliceArrayRejections": 0.0,
+  "gosvm/internal/compiler TestSliceArraySBF": 3.73,
+  "gosvm/internal/compiler TestSliceViewArrayBoundary": 0.6,
+  "gosvm/internal/compiler TestSliceViewRejections": 0.0,
+  "gosvm/internal/compiler TestSliceViewsDifferential": 6.31,
+  "gosvm/internal/compiler TestStdlibAPI": 0.2,
+  "gosvm/internal/compiler TestStdlibConstantsOnly": 0.02,
+  "gosvm/internal/compiler TestStdlibDifferential": 23.67,
+  "gosvm/internal/compiler TestStdlibIdentity": 0.0,
+  "gosvm/internal/compiler TestStdlibImportForms": 0.21,
+  "gosvm/internal/compiler TestStdlibIntrinsics": 0.17,
+  "gosvm/internal/compiler TestStdlibPackagesList": 0.12,
+  "gosvm/internal/compiler TestStdlibProvenance": 0.01,
+  "gosvm/internal/compiler TestStdlibRejections": 0.12,
+  "gosvm/internal/compiler TestStdlibSBF": 54.4,
+  "gosvm/internal/compiler TestStdlibUnicodeTables": 0.0,
+  "gosvm/internal/compiler TestStringAcceptedForms": 3.5,
+  "gosvm/internal/compiler TestStringDifferential": 34.42,
+  "gosvm/internal/compiler TestStringDocumentationExample": 6.67,
+  "gosvm/internal/compiler TestStringHeap": 12.74,
+  "gosvm/internal/compiler TestStringIntegerConversions": 2.08,
+  "gosvm/internal/compiler TestStringRejections": 0.03,
+  "gosvm/internal/compiler TestStringRuntimeOnlyWhenUsed": 0.23,
+  "gosvm/internal/compiler TestStringSBF": 19.6,
+  "gosvm/internal/compiler TestTrimDropsUnreachable": 1.12,
+  "gosvm/internal/compiler TestTrimEntryPackage": 0.0,
+  "gosvm/internal/compiler TestTrimModules": 1.67,
+  "gosvm/internal/compiler TestTrimRejections": 3.03,
+  "gosvm/internal/compiler TestTrimWarnings": 1.85,
+  "gosvm/internal/compiler TestTypeCheckBeforeEntryGeneration": 0.02,
+  "gosvm/internal/compiler TestTypeInspectionIsNotSubsetCertification": 0.02,
+  "gosvm/internal/compiler TestUint16Checks": 0.0,
+  "gosvm/internal/compiler TestUint16Differential": 2.84,
+  "gosvm/internal/compiler TestUint16TypedefOnlyWhenUsed": 0.0,
+  "gosvm/internal/compiler TestValidateTrim": 0.0,
+  "gosvm/internal/compiler TestValueTypeRejections": 0.02,
+  "gosvm/internal/compiler TestValueTypesAcceptedForms": 6.0,
+  "gosvm/internal/compiler TestValueTypesDifferential": 30.89,
+  "gosvm/internal/compiler TestValueTypesRejections": 0.07,
+  "gosvm/internal/compiler TestValueTypesSBF": 8.23,
+  "gosvm/internal/compiler TestVariadicForms": 0.01,
+  "gosvm/internal/compiler TestVariadicLowering": 0.0,
+  "gosvm/internal/compiler TestVariadicRejections": 0.0,
+  "gosvm/internal/compiler TestViewAggregateReturn": 0.43,
+  "gosvm/internal/compiler TestViewCapacityBoundary": 0.43,
+  "gosvm/internal/compiler TestWideQuoteDifferential": 0.64,
+  "gosvm/internal/compiler TestZeroLoopForms": 0.07,
+  "gosvm/internal/features TestAllocationCounters": 0.0,
+  "gosvm/internal/features TestCompoundCounters": 0.0,
+  "gosvm/internal/features TestDeterministicOutput": 0.49,
+  "gosvm/internal/features TestFullSwapFacts": 0.29,
+  "gosvm/internal/features TestFunctionValueCounters": 0.0,
+  "gosvm/internal/features TestFunctionValueUses": 0.0,
+  "gosvm/internal/features TestGenerics": 0.2,
+  "gosvm/internal/features TestGlobalCounters": 0.0,
+  "gosvm/internal/features TestGlobalUses": 0.01,
+  "gosvm/internal/features TestInlineProgram": 0.0,
+  "gosvm/internal/features TestInterfaceCounters": 0.0,
+  "gosvm/internal/features TestMapCounters": 0.0,
+  "gosvm/internal/features TestMapFunctionCounters": 0.0,
+  "gosvm/internal/features TestPointerConversionCounter": 0.0,
+  "gosvm/internal/features TestSignedIntegers": 0.0,
+  "gosvm/internal/features TestSliceArrayConversionCounter": 0.0,
+  "gosvm/internal/features TestStdlibCalls": 0.14,
+  "gosvm/internal/features TestStdlibUses": 0.08,
+  "gosvm/internal/features TestStringCounters": 0.0,
+  "gosvm/internal/features TestTrimmedUses": 0.81,
+  "gosvm/internal/features TestUsesSummary": 0.46,
+  "gosvm/internal/features TestValueTypeCounters": 0.0,
+  "gosvm/internal/library TestBendBuildKey": 0.02,
+  "gosvm/internal/library TestBendFogoV157Accepted": 0.0,
+  "gosvm/internal/library TestBuildBendSourceFake": 0.09,
+  "gosvm/internal/library TestBuildRustLibrary": 0.0,
+  "gosvm/internal/library TestBuildRustRefusals": 0.0,
+  "gosvm/internal/library TestInspectBendCheckoutPrerequisites": 0.02,
+  "gosvm/internal/library TestParseBendBuild": 0.0,
+  "gosvm/internal/library TestProducerRequiresExplicitPinnedContract": 0.0,
+  "gosvm/internal/library TestPublishedBendContract": 0.0,
+  "gosvm/internal/library TestPublishedBendContractFlatLayout": 0.0,
+  "gosvm/internal/library TestRustFingerprintAndWrapper": 0.0,
+  "gosvm/internal/library TestRustToolchainMissing": 0.0,
+  "gosvm/internal/network TestCheckDeployableFollowsLiveFeatures": 0.01,
+  "gosvm/internal/network TestEnsureKeypairRoundTrips": 0.0,
+  "gosvm/internal/network TestFundingMessage": 0.0,
+  "gosvm/internal/network TestProgramDataAddress": 0.0,
+  "gosvm/internal/network TestSignMatchesInvokeEncoding": 0.0,
+  "gosvm/internal/network TestUpgradeDecisions": 0.0,
+  "gosvm/internal/project TestAddBendLibrary": 0.0,
+  "gosvm/internal/project TestAddRustLibrary": 0.0,
+  "gosvm/internal/project TestBendSourceDeclarationsValidate": 0.0,
+  "gosvm/internal/project TestBendSourceIntegration": 0.0,
+  "gosvm/internal/project TestBendSourceNeedsCheckout": 0.01,
+  "gosvm/internal/project TestBendSourceSyncFake": 0.0,
+  "gosvm/internal/project TestCustomModuleAndDiscovery": 0.31,
+  "gosvm/internal/project TestExplicitSDK2AndLegacySnapshot": 1.67,
+  "gosvm/internal/project TestExplicitTargetMigrationPreservesApplicationAndWire": 0.29,
+  "gosvm/internal/project TestGenerationChecksBeforeWriting": 0.01,
+  "gosvm/internal/project TestGoModuleSyntax": 0.0,
+  "gosvm/internal/project TestHeapBytesSetting": 0.01,
+  "gosvm/internal/project TestLibraryDeclarationsValidate": 0.0,
+  "gosvm/internal/project TestLoadSchemaFullSwap": 0.12,
+  "gosvm/internal/project TestLoadSchemaRejectsSchema1": 0.01,
+  "gosvm/internal/project TestNetworkTargetsResolveAndValidate": 0.02,
+  "gosvm/internal/project TestSDK1RejectsNewBoundaryCalls": 0.01,
+  "gosvm/internal/project TestSDK2FixtureScaffold": 0.7,
+  "gosvm/internal/project TestSDKDriftRejected": 0.01,
+  "gosvm/internal/project TestSchema2AllInitTargetsValidatedBeforeCPI": 1.32,
+  "gosvm/internal/project TestSchema2CheckedConstraintDiagnostics": 0.87,
+  "gosvm/internal/project TestSchema2CheckedTokenAndPDAGeneration": 1.94,
+  "gosvm/internal/project TestSchema2HistoricalManifestValidation": 0.68,
+  "gosvm/internal/project TestSchema2InvalidDeclarations": 1.72,
+  "gosvm/internal/project TestSchema2LayoutVersionsAreGuarded": 0.18,
+  "gosvm/internal/project TestSchema2LifecycleDiagnostics": 0.41,
+  "gosvm/internal/project TestSchema2LifecycleGeneration": 1.2,
+  "gosvm/internal/project TestSchema2NamedScalarArrayWire": 0.37,
+  "gosvm/internal/project TestSchema2PDAAdapterOnlyImport": 0.23,
+  "gosvm/internal/project TestSchema2ReadonlyAliasAndProgramIdentity": 0.35,
+  "gosvm/internal/project TestSchema2RejectsCountsBeyondLoaderABI": 0.08,
+  "gosvm/internal/project TestSchema2RejectsGenericWireTypes": 0.33,
+  "gosvm/internal/project TestSchema2RejectsMaps": 0.28,
+  "gosvm/internal/project TestSchema2RejectsPlatformSizedIntegers": 0.54,
+  "gosvm/internal/project TestSchema2RejectsStrings": 0.45,
+  "gosvm/internal/project TestSchema2SignedFieldsAndSeeds": 0.58,
+  "gosvm/internal/project TestSchema2SourceDiagnosticsBeforePublication": 0.36,
+  "gosvm/internal/project TestSchema2StandaloneCanonicalLayouts": 1.48,
+  "gosvm/internal/project TestSchema2Uint16FieldsAndSeeds": 1.08,
+  "gosvm/internal/project TestStandaloneStarter": 0.3,
+  "gosvm/internal/project TestTrimSetting": 0.03,
+  "gosvm/internal/project TestWireFieldsAndSchemaChanges": 0.19,
+  "gosvm/internal/runner TestAtomicInstallAndPinnedIntegrity": 0.02,
+  "gosvm/internal/runner TestBusyInstallPreservesLock": 0.0,
+  "gosvm/internal/runner TestDownloadRejectsWrongBytesBeforeExecution": 0.09,
+  "gosvm/internal/runner TestEmbeddedPinsAndPackageDetection": 0.33,
+  "gosvm/internal/runner TestFailedSmokeAndCancellationDoNotPublish": 0.0,
+  "gosvm/internal/runner TestGzipTrailerAndInstalledFileType": 0.0,
+  "gosvm/internal/runner TestRejectArchivesBeforeExecution": 0.01,
+  "gosvm/internal/runner TestReleasePinAcceptsHistoricalInstall": 0.0,
+  "gosvm/internal/runner TestWrongPlatformArchiveIsNamed": 0.0,
+  "gosvm/internal/sbftest TestFastFailureRemovesPreviousPassingReport": 0.0,
+  "gosvm/internal/sbftest TestFastSelectionRejectsEmptyAndInvalidMatches": 0.0,
+  "gosvm/internal/sbftest TestFixtureTransactionMergesKeysAndPreservesReferences": 0.01,
+  "gosvm/internal/sbftest TestGeneralChecksMetadataAndExactErrorCategories": 0.0,
+  "gosvm/internal/sbftest TestGeneralFixturesRejectAmbiguousAndUncheckedInputs": 0.0,
+  "gosvm/internal/sbftest TestGeneralReportsAreClearedWithoutOverwritingInputs": 0.0,
+  "gosvm/internal/sbftest TestGeneralSysvarControlsValidateBeforeAnySelectedScenario": 0.01,
+  "gosvm/internal/sbftest TestNativeProgramAliasesAndDeclaredTransactions": 0.0,
+  "gosvm/internal/sbftest TestSimulationStateOverridesKeepCommittedChecks": 0.0,
+  "gosvm/internal/targets TestVersionAndMachineAreBothRequired": 0.0,
+  "gosvm/internal/testvm TestRunnerProfileIsValidAndOverrideIsExplicit": 0.0,
+  "gosvm/internal/testvm TestRunnerSelectionPerProfile": 0.04,
+  "gosvm/internal/testvm TestRunnerSelectionPrecedenceAndDamagedManagedCache": 0.04,
+  "gosvm/internal/testvm TestSVMControlsIntegration": 0.0,
+  "gosvm/internal/testvm TestSelectionAndVersion": 0.0,
+  "gosvm/internal/testvm TestSessionCancellationUnblocksRead": 0.1,
+  "gosvm/internal/testvm TestSessionChecksEveryCallIdentityAndError": 0.02,
+  "gosvm/internal/testvm TestSessionHelperProcess": 0.0,
+  "gosvm/internal/testvm TestSessionRejectsCorruptResponses": 0.01,
+  "gosvm/internal/testvm TestSysvarParsingPreservesIntegerLimitsAndPartialControls": 0.0,
+  "gosvm/internal/testvm TestSysvarParsingRejectsIncompleteAmbiguousAndOutOfRangeValues": 0.0,
+  "gosvm/internal/testvm TestTargetRuntimeContract": 0.0,
+  "gosvm/internal/toolchain TestAllowlistExtraction": 0.0,
+  "gosvm/internal/toolchain TestBadArchiveDoesNotPublish": 0.0,
+  "gosvm/internal/toolchain TestModernDownloadInstallsOnlyPinnedBackend": 0.01,
+  "gosvm/internal/toolchain TestModernLocalArchiveAndRejections": 0.02,
+  "gosvm/internal/toolchain TestModernReceiptSources": 0.0,
+  "gosvm/internal/toolchain TestOfficialArchivesPerHost": 0.0,
+  "gosvm/internal/toolchain TestOfficialFullPins": 0.0,
+  "gosvm/internal/toolchain TestOfficialModernPins": 0.0,
+  "gosvm/internal/toolchain TestRejectUnsafeOrIncompleteBackend": 0.0,
+  "gosvm/internal/toolchain TestRustFullTreeInstall": 0.02,
+  "gosvm/internal/toolchain TestRustFullTreeLocalArchiveWithExistingBackend": 0.02,
+  "gosvm/internal/toolchain TestRustFullTreeRejections": 0.08,
+  "gosvm/internal/toolchain TestRustPlatformToolsReceipt": 0.0,
+  "gosvm/sdk/ata TestAddressMatchesFindProgramAddress": 0.01,
+  "gosvm/sdk/ata TestCreateDelegatesAddressValidation": 0.0,
+  "gosvm/sdk/ata TestCreateEncoding": 0.0,
+  "gosvm/sdk/ata TestCreateGuards": 0.0,
+  "gosvm/sdk/cpi TestBoundedMetasAndSignerGroups": 0.0,
+  "gosvm/sdk/cpi TestInvokeSingleSignedUnsignedAndGuards": 0.0,
+  "gosvm/sdk/cpi TestInvokeValidationAndExactCallbackStatus": 0.0,
+  "gosvm/sdk/cpi TestSingleSignerEncodingAndRejectedAdds": 0.07,
+  "gosvm/sdk/fixture TestBase58Keys": 0.0,
+  "gosvm/sdk/fixture TestBuildErrors": 0.0,
+  "gosvm/sdk/fixture TestDeterministicKeys": 0.0,
+  "gosvm/sdk/fixture TestFindProgramAddressVectors": 0.0,
+  "gosvm/sdk/fixture TestOnCurve": 0.02,
+  "gosvm/sdk/fixture TestRent": 0.0,
+  "gosvm/sdk/fixture TestSuiteLoadsInRunnerValidation": 0.01,
+  "gosvm/sdk/pda TestAddressAndFailureOutput": 0.0,
+  "gosvm/sdk/pda TestExplicitSeedEncodingAndBounds": 0.0,
+  "gosvm/sdk/pda TestFindAddressMatchesSolana": 0.14,
+  "gosvm/sdk/pda TestFindAddressStatuses": 0.0,
+  "gosvm/sdk/system TestRentCurrentSysvar": 0.0,
+  "gosvm/sdk/system TestRentMinimumDifferential": 0.05,
+  "gosvm/sdk/system TestSystemAllocateAssignEncoding": 0.0,
+  "gosvm/sdk/system TestSystemCreateAndTransferEncoding": 0.0,
+  "gosvm/sdk/system TestSystemCreatePDAFundedAndUnfunded": 0.0,
+  "gosvm/sdk/system TestSystemFreeRentRetainsAccount": 0.0,
+  "gosvm/sdk/system TestSystemPDAAndCreationGuards": 0.0,
+  "gosvm/sdk/system TestSystemTransferSignedEncodingAndGuards": 0.0,
+  "gosvm/sdk/token TestCheckedBalanceRevalidation": 0.0,
+  "gosvm/sdk/token TestCheckedInstructionEncodings": 0.0,
+  "gosvm/sdk/token TestCheckedInstructionGuards": 0.0,
+  "gosvm/sdk/token TestCheckedInstructionsClassicAndSelfAuthority": 0.0,
+  "gosvm/sdk/token TestCheckedTransferAndCurrentReads": 0.0,
+  "gosvm/sdk/token TestFindExtensionAndTransferFeeConfig": 0.0,
+  "gosvm/sdk/token TestProgramPredicates": 0.0,
+  "gosvm/sdk/token TestReadAccountLayouts": 0.0,
+  "gosvm/sdk/token TestReadMintLayouts": 0.0,
+  "gosvm/sdk/token TestTokenCloseAuthorityAndCurrentReference": 0.0,
+  "gosvm/sdk/token TestTokenCreateCurrentStorageAndCPIEncoding": 0.0,
+  "gosvm/sdk/token TestTokenCreatePreconditionsAndDownstreamFailures": 0.0,
+  "gosvm/sdk/token TestTokenRevalidationBeforeInvoke": 0.0,
+  "gosvm/sdk/token TestTransferFeeArithmetic": 0.05,
+  "gosvm/solana TestClockCurrentWordsAndFailedOutput": 0.0,
+  "gosvm/solana TestGetReturnDataCopiesPrefixAndSetter": 0.0,
+  "gosvm/solana TestGetReturnDataOverlap": 0.0,
+  "gosvm/solana TestKeccak256BoundsAndCopy": 0.0,
+  "gosvm/solana TestLogMessages": 0.01,
+  "gosvm/solana TestLogRejectsInvalidUTF8": 0.01,
+  "gosvm/solana TestMoveLamportsRules": 0.0,
+  "gosvm/solana TestOwnedLifecycleAliases": 0.0,
+  "gosvm/solana TestOwnedLifecycleFailureAtomicity": 0.0,
+  "gosvm/solana TestRentBoundaryPreservesFailedOutput": 0.0,
+  "gosvm/solana TestReturnDataBoundsCopiesAndUnavailable": 0.0,
+  "gosvm/solana TestSHA256Regions": 0.0,
+  "gosvm/solana TestSecp256k1RecoverBoundsStatusesAndCopy": 0.0
+ }
+}