hash/maphash fails to compile with Go 1.27: undefined: abi.MapType

[joeblew999]

TinyGo 0.42.0 fails to compile any program that imports hash/maphash when built with Go 1.27. The same program builds with Go 1.26.

Reproducer

package main

import "hash/maphash"

func main() { var h maphash.Hash; h.WriteString("x"); println(h.Sum64()) }

With Go 1.27.1:

$ tinygo build -o m.wasm -target wasm .
# internal/runtime/maps
.../go/1.27.1/src/internal/runtime/maps/group.go:298:39: undefined: abi.MapType
.../go/1.27.1/src/internal/runtime/maps/group.go:305:40: undefined: abi.MapType
.../go/1.27.1/src/internal/runtime/maps/group.go:327:25: undefined: abi.MapType
...
.../go/1.27.1/src/internal/runtime/maps/table.go:888:27: undefined: abi.MapGroupSlots
.../go/1.27.1/src/internal/runtime/maps/table.go:1032:32: undefined: abi.MapGroupSlotsBits

• Go 1.26.8, tinygo build -target wasm: builds

• Go 1.27.1, tinygo build -target wasm: fails as above

• Go 1.27.1, tinygo build (native): fails the same way

• Go 1.27.1, go run: works

• tinygo version 0.42.0 darwin/arm64 (using go version go1.27.1 and LLVM version 22.1.4)

• internal/abi on dev still has only abi.go, escape.go, funcpc.go and type.go (checked 2026-09-15)

Cause

In Go 1.26, hash/maphash was split by build tag:

• maphash_runtime.go (//go:build !purego) imports internal/runtime/maps
• maphash_purego.go (//go:build purego) does not

TinyGo builds with the purego tag, so it used the pure Go version.

Go 1.27 removed that split. maphash.go now imports internal/runtime/maps for every build, and the purego file is gone. That package needs abi.MapType, abi.MapGroupSlots and abi.MapGroupSlotsBits, which TinyGo's internal/abi doesn't define.

TinyGo overrides runtime, reflect and unique, but not hash/maphash, so the Go 1.27 version is used as-is.

Impact

Anything that imports hash/maphash, directly or through a dependency, stops compiling on Go 1.27. We hit it through github.com/modelcontextprotocol/go-sdk → github.com/google/jsonschema-go (used for uniqueItems validation), while building a Cloudflare Worker with syumai/workers-go. The Worker build doesn't compile with TinyGo unless MCP is compiled out.

Possible fixes

• Provide a TinyGo version of hash/maphash in src/hash/maphash, as is already done for unique and reflect. It would be based on the 1.26 maphash_purego.go and not use internal/runtime/maps.
• Or add the Go 1.27 map types to TinyGo's internal/abi so internal/runtime/maps compiles. This is probably the larger change.

[joeblew999]

hash/maphash turned out to be the first of eight gaps between TinyGo 0.42.0 and what github.com/modelcontextprotocol/go-sdk needs. I worked around each one locally to find the next (patched TINYGOROOT copy plus scratch forks), until an MCP server built with TinyGo worked. Here is the full list, each with a minimal repro against stock TinyGo.

Versions: tinygo 0.42.0 darwin/arm64, go1.27.1, go-sdk v1.8.0, google/jsonschema-go v0.4.3, segmentio/encoding v0.5.4. Target -target wasm, run in Cloudflare workerd. Repros 2–8 fail the same way natively.

Summary

#	Gap	Kind	Hit by
1	hash/maphash doesn't compile on Go 1.27	compile, Go 1.27 regression	jsonschema-go (see above)
2	crypto/rand.Text missing	compile	go-sdk auth, mcp/server.go session IDs
3	net.Dialer.Control field missing	compile	go-sdk oauthex
4	net/http.Transport.DialTLSContext field missing	compile	go-sdk oauthex
5	os.OpenRoot / os.Root missing	compile	go-sdk mcp/resource.go
6	net/http.CrossOriginProtection missing	compile	go-sdk mcp/streamable.go
7	reflect.NewAt unimplemented	runtime panic	segmentio/encoding/json, via go-sdk internal/json
8	reflect.VisibleFields returns fields whose Type panics	runtime panic, also on Go 1.26	jsonschema-go ForType

2–6: missing APIs (compile errors)

package main

import (
	"crypto/rand"
	"net"
	"net/http"
	"os"
	"syscall"
)

func main() {
	_ = rand.Text()
	_ = net.Dialer{Control: func(network, address string, c syscall.RawConn) error { return nil }}
	_ = http.Transport{DialTLSContext: nil}
	_, _ = os.OpenRoot(".")
	_ = http.NewCrossOriginProtection()
}

$ tinygo build -o /dev/null .
main.go:12:11: undefined: rand.Text
main.go:13:17: unknown field Control in struct literal of type net.Dialer
main.go:14:21: unknown field DialTLSContext in struct literal of type http.Transport
main.go:15:12: undefined: os.OpenRoot
main.go:16:11: undefined: http.NewCrossOriginProtection

go vet accepts the same file. What I used locally to get past them:

• rand.Text: Go's implementation (26 random bytes mapped onto the base32 alphabet)
• Dialer.Control and Transport.DialTLSContext: field added and ignored, like the existing TINYGO: present for API compatibility fields
• os.OpenRoot: stub returning ErrNotImplemented
• CrossOriginProtection: Go 1.27's net/http/csrf.go copied in unchanged; it compiled and worked

7: reflect.NewAt panics (with a misleading message)

package main

import (
	"reflect"
	"unsafe"
)

func main() {
	var x int
	v := reflect.NewAt(reflect.TypeFor[int](), unsafe.Pointer(&x))
	println(v.Kind().String())
}

$ tinygo run .
panic: unimplemented: reflect.New()

go run prints ptr. The message names reflect.New(), but the panic comes from NewAt (src/reflect/value.go and src/internal/reflectlite/value.go). That sent me looking at the wrong function at first.

go-sdk's internal/json uses github.com/segmentio/encoding/json, which calls reflect.NewAt. Every MCP request panicked while the server was being set up. To keep going I swapped go-sdk's internal JSON package to encoding/json, so I haven't verified whether segmentio/encoding works on TinyGo once NewAt exists.

8: reflect.VisibleFields field Type is broken

package main

import "reflect"

type out struct {
	A string `json:"a"`
}

func main() {
	t := reflect.TypeFor[out]()
	println(t.Field(0).Type.Kind().String())
	println(reflect.VisibleFields(t)[0].Type.Kind().String())
}

$ tinygo run .
string
panic: runtime error at 0x...: nil pointer dereference

This fails the same way with Go 1.26.8, so it isn't a Go 1.27 problem.

Cause: src/reflect/visiblefields.go unsafe-casts []reflectlite.StructField to []reflect.StructField. That skips toStructField / toType, which (*rawType).Field uses. So each Type interface holds a *reflectlite.RawType where a *reflect.rawType is expected. This fixed it for me:

func VisibleFields(t Type) []StructField {
	fields := reflectlite.VisibleFields(toRawType(t))
	out := make([]StructField, len(fields))
	for i, f := range fields {
		out[i] = toStructField(f)
	}
	return out
}

Result

With all eight worked around, a go-sdk streamable-HTTP MCP server built with TinyGo worked in workerd: initialize, tools/list, tools/call with struct inputs and outputs, and input-schema validation errors. Its responses matched the gc build byte for byte, apart from map iteration order in one error message. The wasm was 2.7 MB, against 15 MB from gc.

Happy to split these into separate issues if that's easier to track.

[jakebailey]

I don't think it's a good idea to make one issue that contains so many unrelated things (some of which I believe have been reported)