goscript 0.2.0 → 0.2.2

package/compiler/lowering_bench_test.go

@@ -88,6 +88,7 @@ func BenchmarkLoweringFile(b *testing.B) {
 			fixture.lazyPackageVarsByPkg,
 			make(runtimeMethodSetCache),
 			false,
+			"",
 		); diagnosticsHaveErrors(diagnostics) {
 			b.Fatal(diagnostics)
 		}

package/compiler/lowering_internal_test.go

@@ -0,0 +1,18 @@
+package compiler
+
+import "testing"
+
+func TestIntegerBitHelpersHandleNilTypes(t *testing.T) {
+	if bits, ok := unsignedIntegerBits(nil); ok || bits != 0 {
+		t.Fatalf("unsignedIntegerBits(nil) = %d, %v; want 0, false", bits, ok)
+	}
+	if bits, ok := signedIntegerBits(nil); ok || bits != 0 {
+		t.Fatalf("signedIntegerBits(nil) = %d, %v; want 0, false", bits, ok)
+	}
+	if bits, ok := integerBits(nil); ok || bits != 0 {
+		t.Fatalf("integerBits(nil) = %d, %v; want 0, false", bits, ok)
+	}
+	if isRuntimeWideIntegerType(nil) {
+		t.Fatalf("isRuntimeWideIntegerType(nil) = true; want false")
+	}
+}

package/compiler/protobuf-ts-binding.go

@@ -66,7 +66,7 @@ func protobufTypeScriptBindings(semPkg *semanticPackage, options LoweringOptions
 			sourcePath:   sourcePath,
 			outputName:   strings.TrimSuffix(filepath.Base(sourcePath), ".go") + ".ts",
 			importSource: importSource,
-			messageNames: protobufTypeScriptBindingMessageNames(syntax),
+			messageNames: protobufTypeScriptBindingMessageNames(syntax, tsPath),
 			hasOneof:     protobufTypeScriptBindingHasOneof(syntax),
 		}
 	}
@@ -158,11 +158,12 @@ func protobufTypeScriptBindingHasOneof(file *ast.File) bool {
 	return false
 }
 
-func protobufTypeScriptBindingMessageNames(file *ast.File) map[string]string {
+func protobufTypeScriptBindingMessageNames(file *ast.File, tsPath string) map[string]string {
 	names := make(map[string]string)
 	if file == nil {
 		return names
 	}
+	exportedTSMessages := protobufTypeScriptBindingExportedConsts(tsPath)
 	for _, decl := range file.Decls {
 		genDecl, ok := decl.(*ast.GenDecl)
 		if !ok {
@@ -177,12 +178,46 @@ func protobufTypeScriptBindingMessageNames(file *ast.File) map[string]string {
 				continue
 			}
 			name := typeSpec.Name.Name
-			names[name] = protobufTypeScriptBindingSafeIdentifier(name)
+			safeName := protobufTypeScriptBindingSafeIdentifier(name)
+			if len(exportedTSMessages) != 0 && !exportedTSMessages[safeName] {
+				continue
+			}
+			names[name] = safeName
 		}
 	}
 	return names
 }
 
+func protobufTypeScriptBindingExportedConsts(tsPath string) map[string]bool {
+	data, err := os.ReadFile(tsPath)
+	if err != nil {
+		return nil
+	}
+	exports := make(map[string]bool)
+	for line := range strings.SplitSeq(string(data), "\n") {
+		line = strings.TrimSpace(line)
+		if !strings.HasPrefix(line, "export const ") {
+			continue
+		}
+		rest := strings.TrimPrefix(line, "export const ")
+		end := 0
+		for end < len(rest) && protobufTypeScriptBindingIdentifierByte(rest[end]) {
+			end++
+		}
+		if end != 0 {
+			exports[rest[:end]] = true
+		}
+	}
+	return exports
+}
+
+func protobufTypeScriptBindingIdentifierByte(ch byte) bool {
+	return ch == '_' || ch == '$' ||
+		ch >= '0' && ch <= '9' ||
+		ch >= 'A' && ch <= 'Z' ||
+		ch >= 'a' && ch <= 'z'
+}
+
 func protobufTypeScriptBindingSafeIdentifier(name string) string {
 	switch name {
 	case "break",
@@ -250,9 +285,6 @@ func rewriteProtobufTypeScriptBindingFile(file *loweredFile, binding protobufTyp
 		return
 	}
 	file.outputName = binding.outputName
-	if binding.hasOneof {
-		return
-	}
 	const importAlias = "__protobuf_ts"
 	file.imports = append(file.imports, loweredImport{
 		alias:      importAlias,
@@ -267,8 +299,14 @@ func rewriteProtobufTypeScriptBindingFile(file *loweredFile, binding protobufTyp
 		if protobufTypeScriptBindingSyntheticMapEntry(decl.structType.name) {
 			continue
 		}
-		rewriteProtobufTypeScriptBindingStruct(decl.structType)
-		setup := protobufTypeScriptBindingStructSetupDecl(decl.structType, importAlias, binding.messageNames[decl.structType.name])
+		if !binding.hasOneof {
+			rewriteProtobufTypeScriptBindingStruct(decl.structType, binding.sourcePath)
+		}
+		messageName, ok := binding.messageNames[decl.structType.name]
+		if !ok {
+			continue
+		}
+		setup := protobufTypeScriptBindingStructSetupDecl(decl.structType, importAlias, messageName)
 		if setup.code != "" {
 			setupDecls = append(setupDecls, setup)
 		}
@@ -322,12 +360,18 @@ func protobufSRPCHasGoScriptReplacement(sourcePath string) bool {
 	return err == nil
 }
 
-func rewriteProtobufTypeScriptBindingStruct(structType *loweredStruct) {
+func rewriteProtobufTypeScriptBindingStruct(structType *loweredStruct, bindingSourcePath string) {
 	if structType == nil {
 		return
 	}
 	for idx := range structType.methods {
 		method := &structType.methods[idx]
+		if method.sourcePath != bindingSourcePath {
+			continue
+		}
+		if structType.protobufPreserveJSON && protobufTypeScriptBindingJSONMethodName(method.name) {
+			continue
+		}
 		body := protobufTypeScriptBindingMethodBody(structType, method)
 		if body == "" {
 			continue
@@ -383,6 +427,15 @@ func protobufTypeScriptBindingMethodBody(structType *loweredStruct, method *lowe
 	}
 }
 
+func protobufTypeScriptBindingJSONMethodName(name string) bool {
+	switch name {
+	case "MarshalJSON", "MarshalProtoJSON", "UnmarshalJSON", "UnmarshalProtoJSON":
+		return true
+	default:
+		return false
+	}
+}
+
 func protobufTypeScriptBindingReplacesMethodName(name string) bool {
 	switch name {
 	case "CloneMessageVT",
@@ -448,11 +501,11 @@ func protobufTypeScriptBindingFieldLocalName(field loweredStructField) string {
 }
 
 func protobufTypeScriptBindingTagValue(tag, key string) string {
-	idx := strings.Index(tag, key)
-	if idx < 0 {
+	_, after, ok := strings.Cut(tag, key)
+	if !ok {
 		return ""
 	}
-	rest := tag[idx+len(key):]
+	rest := after
 	end := len(rest)
 	for idx, ch := range rest {
 		if ch == ',' || ch == '"' || ch == '`' || ch == ' ' {

package/compiler/protobuf-ts-binding_test.go

@@ -80,6 +80,345 @@ func NewFoo() Foo {
 	}
 }
 
+func TestProtobufTypeScriptBindingRewritesGeneratedMethodsToBoundHelpers(t *testing.T) {
+	dir := t.TempDir()
+	writeTestFile(t, dir, "go.mod", `module example.test/protobufbindingmethods
+
+go 1.25
+
+require github.com/aperturerobotics/protobuf-go-lite v0.0.0
+
+replace github.com/aperturerobotics/protobuf-go-lite => ./protobuf-go-lite
+`)
+	writeTestFile(t, dir, "protobuf-go-lite/go.mod", `module github.com/aperturerobotics/protobuf-go-lite
+
+go 1.25
+`)
+	writeTestFile(t, dir, "protobuf-go-lite/protobuf-go-lite.go", `package protobuf_go_lite
+
+type CloneMessage interface {
+	CloneMessageVT() CloneMessage
+}
+`)
+	writeTestFile(t, dir, "foo.pb.go", `package protobufbindingmethods
+
+import protobuf_go_lite "github.com/aperturerobotics/protobuf-go-lite"
+
+type Foo struct {
+	Name string
+}
+
+func (x *Foo) CloneMessageVT() protobuf_go_lite.CloneMessage {
+	println("inline CloneMessageVT marker")
+	return x.CloneVT()
+}
+
+func (x *Foo) CloneVT() *Foo {
+	println("inline CloneVT marker")
+	return &Foo{Name: x.Name}
+}
+
+func (x *Foo) EqualVT(other *Foo) bool {
+	println("inline EqualVT marker")
+	return other != nil && x.Name == other.Name
+}
+
+func (x *Foo) MarshalVT() ([]byte, error) {
+	println("inline MarshalVT marker")
+	return []byte(x.Name), nil
+}
+
+func (x *Foo) MarshalToSizedBufferVT(data []byte) (int, error) {
+	println("inline MarshalToSizedBufferVT marker")
+	return copy(data, x.Name), nil
+}
+
+func (x *Foo) SizeVT() int {
+	println("inline SizeVT marker")
+	return len(x.Name)
+}
+
+func (x *Foo) UnmarshalVT(data []byte) error {
+	println("inline UnmarshalVT marker")
+	x.Name = string(data)
+	return nil
+}
+
+func (x *Foo) Reset() {
+	println("inline Reset marker")
+	*x = Foo{}
+}
+`)
+	writeTestFile(t, dir, "foo.pb.ts", `export interface Foo {
+  name?: string
+}
+export const Foo = {} as any
+`)
+
+	out := filepath.Join(dir, "out")
+	comp, err := NewCompiler(&Config{
+		Dir:                       dir,
+		OutputPath:                out,
+		ProtobufTypeScriptBinding: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with protobuf TypeScript binding: %v", err)
+	}
+
+	binding := readTestFile(t, filepath.Join(out, "@goscript", "example.test", "protobufbindingmethods", "foo.pb.ts"))
+	wantSnippets := []string{
+		`$.interfaceValue<protobuf_go_lite.CloneMessage | null>(protobuf_go_lite.CloneBoundMessage(Foo, this) as any, "*protobufbindingmethods.Foo")`,
+		`return protobuf_go_lite.CloneBoundMessage(Foo, this) as any`,
+		`protobuf_go_lite.EqualBoundMessage(Foo, this, other)`,
+		`protobuf_go_lite.MarshalBoundMessageVT(Foo, this)`,
+		`protobuf_go_lite.MarshalBoundMessageToSizedBufferVT(Foo, this, data)`,
+		`protobuf_go_lite.SizeBoundMessageVT(Foo, this)`,
+		`protobuf_go_lite.UnmarshalBoundMessageVT(Foo, this, data)`,
+		`$.assignStruct($.pointerValue<Foo>(this), $.markAsStructValue(new Foo()))`,
+	}
+	for _, snippet := range wantSnippets {
+		if !strings.Contains(binding, snippet) {
+			t.Fatalf("binding file should rewrite generated methods through %q, got:\n%s", snippet, binding)
+		}
+	}
+	if strings.Contains(binding, "inline ") {
+		t.Fatalf("binding file should not preserve inline generated method bodies, got:\n%s", binding)
+	}
+}
+
+func TestProtobufTypeScriptBindingEmitsMetadataForPreservedOneofFiles(t *testing.T) {
+	dir := t.TempDir()
+	writeTestFile(t, dir, "go.mod", "module example.test/oneofpb\n\ngo 1.25\n")
+	writeTestFile(t, dir, "foo.pb.go", "package oneofpb\n\n"+
+		"type Inner struct {\n"+
+		"\tName string `protobuf:\"bytes,1,opt,name=name,proto3\" json:\"name,omitempty\"`\n"+
+		"}\n\n"+
+		"type Wrapper struct {\n"+
+		"\tInner *Inner `protobuf:\"bytes,1,opt,name=inner,proto3\" json:\"inner,omitempty\"`\n"+
+		"\tChoice isWrapper_Choice `protobuf_oneof:\"choice\"`\n"+
+		"}\n\n"+
+		"type isWrapper_Choice interface { isWrapper_Choice() }\n\n"+
+		"type Wrapper_StringValue struct {\n"+
+		"\tStringValue string `protobuf:\"bytes,2,opt,name=string_value,json=stringValue,proto3,oneof\"`\n"+
+		"}\n\n"+
+		"func (*Wrapper_StringValue) isWrapper_Choice() {}\n")
+	writeTestFile(t, dir, "foo.pb.ts", `export interface Inner {
+  name?: string
+}
+export const Inner = {} as any
+export interface Wrapper {
+  inner?: Inner
+}
+export const Wrapper = {} as any
+`)
+
+	out := filepath.Join(dir, "out")
+	comp, err := NewCompiler(&Config{
+		Dir:                       dir,
+		OutputPath:                out,
+		ProtobufTypeScriptBinding: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with protobuf TypeScript binding: %v", err)
+	}
+
+	binding := readTestFile(t, filepath.Join(out, "@goscript", "example.test", "oneofpb", "foo.pb.ts"))
+	if !strings.Contains(binding, `import * as __protobuf_ts`) ||
+		!strings.Contains(binding, `(Wrapper as any).__protobufTypeScriptMessage = __protobuf_ts.Wrapper;`) ||
+		!strings.Contains(binding, `(Wrapper as any).__protobufTypeScriptFields = {"inner": Inner};`) {
+		t.Fatalf("oneof-preserved protobuf file should still expose TypeScript metadata, got:\n%s", binding)
+	}
+	if strings.Contains(binding, `__protobuf_ts.Wrapper_StringValue`) {
+		t.Fatalf("oneof wrapper structs should not reference missing TypeScript exports, got:\n%s", binding)
+	}
+}
+
+func TestProtobufTypeScriptBindingPreservesCustomJSONMethods(t *testing.T) {
+	dir := t.TempDir()
+	writeTestFile(t, dir, "go.mod", "module example.test/custompbjson\n\ngo 1.25\n")
+	writeTestFile(t, dir, "foo.pb.go", `package custompbjson
+
+type Foo struct {
+	Config []byte
+}
+`)
+	writeTestFile(t, dir, "foo.pb.ts", `export interface Foo {
+  config?: Uint8Array
+}
+export const Foo = {} as any
+`)
+	writeTestFile(t, dir, "foo-json.go", `package custompbjson
+
+func (x *Foo) UnmarshalJSON(b []byte) error {
+	x.Config = b
+	return nil
+}
+`)
+
+	out := filepath.Join(dir, "out")
+	comp, err := NewCompiler(&Config{
+		Dir:                       dir,
+		OutputPath:                out,
+		ProtobufTypeScriptBinding: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with protobuf TypeScript binding: %v", err)
+	}
+
+	binding := readTestFile(t, filepath.Join(out, "@goscript", "example.test", "custompbjson", "foo.pb.ts"))
+	if strings.Contains(binding, `UnmarshalBoundMessageJSON(Foo`) {
+		t.Fatalf("custom JSON method should not be replaced by generic protobuf helper, got:\n%s", binding)
+	}
+	if !strings.Contains(binding, `.Config = b`) {
+		t.Fatalf("custom JSON method body should be preserved, got:\n%s", binding)
+	}
+}
+
+func TestProtobufTypeScriptBindingPreservesJSONGraphWithCustomNestedMessage(t *testing.T) {
+	dir := t.TempDir()
+	writeTestFile(t, dir, "go.mod", "module example.test/nestedcustompbjson\n\ngo 1.25\n")
+	writeTestFile(t, dir, "foo.pb.go", `package nestedcustompbjson
+
+type Foo struct {
+	Items []*Item
+}
+
+type Item struct {
+	Config []byte
+}
+
+func generatedFooJSONMarker(x *Foo) error {
+	return nil
+}
+
+func (x *Foo) UnmarshalJSON(b []byte) error {
+	return generatedFooJSONMarker(x)
+}
+
+func (x *Foo) UnmarshalProtoJSON(s any) {
+}
+`)
+	writeTestFile(t, dir, "foo.pb.ts", `export interface Foo {
+  items?: Item[]
+}
+export const Foo = {} as any
+export interface Item {
+  config?: Uint8Array
+}
+export const Item = {} as any
+`)
+	writeTestFile(t, dir, "item-json.go", `package nestedcustompbjson
+
+func (x *Item) UnmarshalJSON(b []byte) error {
+	x.Config = b
+	return nil
+}
+`)
+
+	out := filepath.Join(dir, "out")
+	comp, err := NewCompiler(&Config{
+		Dir:                       dir,
+		OutputPath:                out,
+		ProtobufTypeScriptBinding: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with protobuf TypeScript binding: %v", err)
+	}
+
+	binding := readTestFile(t, filepath.Join(out, "@goscript", "example.test", "nestedcustompbjson", "foo.pb.ts"))
+	if strings.Contains(binding, `UnmarshalBoundMessageJSON(Foo`) {
+		t.Fatalf("outer message with nested custom JSON should keep generated JSON body, got:\n%s", binding)
+	}
+	if !strings.Contains(binding, `generatedFooJSONMarker`) {
+		t.Fatalf("outer generated JSON body should be preserved, got:\n%s", binding)
+	}
+	if strings.Contains(binding, `UnmarshalBoundMessageJSON(Item`) {
+		t.Fatalf("nested custom JSON method should not be replaced, got:\n%s", binding)
+	}
+	if !strings.Contains(binding, `.Config = b`) {
+		t.Fatalf("nested custom JSON method body should be preserved, got:\n%s", binding)
+	}
+}
+
+func TestProtobufTypeScriptBindingPreservesJSONGraphWithImportedCustomNestedMessage(t *testing.T) {
+	dir := t.TempDir()
+	writeTestFile(t, dir, "go.mod", "module example.test/importedcustompbjson\n\ngo 1.25\n")
+	writeTestFile(t, dir, "inner/inner.pb.go", `package inner
+
+type Inner struct {
+	Config []byte
+}
+`)
+	writeTestFile(t, dir, "inner/inner.pb.ts", `export interface Inner {
+  config?: Uint8Array
+}
+export const Inner = {} as any
+`)
+	writeTestFile(t, dir, "inner/inner-json.go", `package inner
+
+func (x *Inner) UnmarshalJSON(b []byte) error {
+	x.Config = b
+	return nil
+}
+`)
+	writeTestFile(t, dir, "outer.pb.go", `package importedcustompbjson
+
+import "example.test/importedcustompbjson/inner"
+
+type Outer struct {
+	Inner *inner.Inner
+}
+
+func generatedOuterJSONMarker(x *Outer) error {
+	return nil
+}
+
+func (x *Outer) UnmarshalJSON(b []byte) error {
+	return generatedOuterJSONMarker(x)
+}
+`)
+	writeTestFile(t, dir, "outer.pb.ts", `import type { Inner } from './inner/inner.pb.js'
+
+export interface Outer {
+  inner?: Inner
+}
+export const Outer = {} as any
+`)
+
+	out := filepath.Join(dir, "out")
+	comp, err := NewCompiler(&Config{
+		Dir:                       dir,
+		OutputPath:                out,
+		ProtobufTypeScriptBinding: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with protobuf TypeScript binding: %v", err)
+	}
+
+	binding := readTestFile(t, filepath.Join(out, "@goscript", "example.test", "importedcustompbjson", "outer.pb.ts"))
+	if strings.Contains(binding, `UnmarshalBoundMessageJSON(Outer`) {
+		t.Fatalf("outer message with imported nested custom JSON should keep generated JSON body, got:\n%s", binding)
+	}
+	if !strings.Contains(binding, `generatedOuterJSONMarker`) {
+		t.Fatalf("outer generated JSON body should be preserved, got:\n%s", binding)
+	}
+}
+
 func TestProtobufTypeScriptBindingReportsMissingSibling(t *testing.T) {
 	dir := t.TempDir()
 	writeTestFile(t, dir, "go.mod", "module example.test/missingpbts\n\ngo 1.25\n")

package/compiler/runtime-contract.go

@@ -105,6 +105,8 @@ const (
 	RuntimeHelperSliceStringOrBytes           RuntimeHelper = "slice.sliceStringOrBytes"
 	RuntimeHelperIndexRef                     RuntimeHelper = "slice.indexRef"
 	RuntimeHelperIndexAddress                 RuntimeHelper = "slice.indexAddress"
+	RuntimeHelperIndexByteAddress             RuntimeHelper = "slice.indexByteAddress"
+	RuntimeHelperUnsafePointerRef             RuntimeHelper = "slice.unsafePointerRef"
 
 	RuntimeHelperMakeMap        RuntimeHelper = "map.makeMap"
 	RuntimeHelperMapGet         RuntimeHelper = "map.mapGet"
@@ -333,6 +335,8 @@ func runtimeHelperContracts() []RuntimeHelperContract {
 		runtimeHelper(RuntimeHelperSliceStringOrBytes, "sliceStringOrBytes", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperIndexRef, "indexRef", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperIndexAddress, "indexAddress", RuntimeHelperCategorySlice),
+		runtimeHelper(RuntimeHelperIndexByteAddress, "indexByteAddress", RuntimeHelperCategorySlice),
+		runtimeHelper(RuntimeHelperUnsafePointerRef, "unsafePointerRef", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperMakeMap, "makeMap", RuntimeHelperCategoryMap),
 		runtimeHelper(RuntimeHelperMapGet, "mapGet", RuntimeHelperCategoryMap),
 		runtimeHelper(RuntimeHelperMapSet, "mapSet", RuntimeHelperCategoryMap),

package/compiler/runtime-contract_test.go

@@ -25,6 +25,8 @@ func TestRuntimeContractOwnsBuiltinImportAndHelpers(t *testing.T) {
 		RuntimeHelperMakeSlice:                RuntimeHelperCategorySlice,
 		RuntimeHelperAppend:                   RuntimeHelperCategorySlice,
 		RuntimeHelperIndexAddress:             RuntimeHelperCategorySlice,
+		RuntimeHelperIndexByteAddress:         RuntimeHelperCategorySlice,
+		RuntimeHelperUnsafePointerRef:         RuntimeHelperCategorySlice,
 		RuntimeHelperMakeMap:                  RuntimeHelperCategoryMap,
 		RuntimeHelperMapGet:                   RuntimeHelperCategoryMap,
 		RuntimeHelperNewError:                 RuntimeHelperCategoryError,

package/compiler/service.go

@@ -127,6 +127,7 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 
 	loweredProgram, loweringDiagnostics := s.loweringOwner.Build(ctx, semanticModel, LoweringOptions{
 		SourceRoot:                protobufTypeScriptBindingRoot(req.Dir),
+		DisplayRoot:               req.Dir,
 		OutputPath:                req.OutputPath,
 		ProtobufTypeScriptBinding: req.ProtobufTypeScriptBinding,
 	})

package/compiler/skeleton_test.go

@@ -1496,6 +1496,56 @@ func TestCompilePackagesEmitsIndexAddressRefs(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesLowersUnsafeBytePointerArithmetic(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/unsafeaddr\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"unsafe\"",
+			"func Set(bits []uint64, idx uint64, mask []uint8) uint8 {",
+			"  ptr := unsafe.Pointer(uintptr(unsafe.Pointer(&bits[idx>>6])) + uintptr((idx%64)>>3))",
+			"  *(*uint8)(ptr) |= mask[idx%8]",
+			"  return *(*uint8)(ptr)",
+			"}",
+			"func CopyBlock(dst []byte, words *[16]uint32) {",
+			"  *(*[64]byte)(unsafe.Pointer(&dst[0])) = *(*[64]byte)(unsafe.Pointer(&words[0]))",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	_, err = comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "unsafeaddr", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.indexByteAddress(bits!, $.uint64Shr(idx, 6), 8)") {
+		t.Fatalf("missing byte-addressed unsafe pointer root:\n%s", text)
+	}
+	if !strings.Contains(text, "$.unsafePointerRef<number>(ptr).value =") {
+		t.Fatalf("missing unsafe pointer storage ref:\n%s", text)
+	}
+	if !strings.Contains(text, "return $.uint($.unsafePointerRef<number>(ptr).value, 8)") {
+		t.Fatalf("missing unsafe pointer value ref:\n%s", text)
+	}
+	if !strings.Contains(text, "$.arrayPointerFromIndexRef<number>($.indexRef($.pointerValue<number[]>(words), 0), 64, 4, 1)") {
+		t.Fatalf("missing byte-view array pointer conversion:\n%s", text)
+	}
+	if !strings.Contains(text, "($.arrayPointerFromIndexRef<number>($.indexRef(dst!, 0), 64, 1, 1) as unknown as $.VarRef<Uint8Array> | null)!.value =") {
+		t.Fatalf("missing non-null byte-view array pointer storage:\n%s", text)
+	}
+}
+
 func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/structs\n\ngo 1.25.3\n",
@@ -2388,6 +2438,7 @@ func TestCompilePackagesEmitsInterfacesMethodValuesTypeSwitchesAndFunctionAssert
 		"Read(): string",
 		"Close(): string",
 		"$.registerInterfaceType(\n\t\"main.ReadCloser\"",
+		"{ name: \"Close\", args: [], returns: [{ name: \"_r0\", type: { kind: $.TypeKind.Basic, name: \"string\" } }] }]\n);",
 		"((__receiver) => () => __receiver.Inc())($.pointerValue<Counter>(counter))",
 		"$.namedFunction(greet, \"main.Greeter\", ({ kind: $.TypeKind.Function, name: \"main.Greeter\"",
 		"params: [{ kind: $.TypeKind.Basic, name: \"string\" }]",
@@ -3388,7 +3439,7 @@ func TestCompilePackagesEmitsAsyncChannelsSelectAndDefer(t *testing.T) {
 	for _, want := range []string{
 		"Process(v: number): number | globalThis.Promise<number>",
 		"public async Process(v: number): globalThis.Promise<number>",
-		"let ch = $.makeChannel<number>(1, 0, \"both\")",
+		"let ch: $.Channel<number> | null = $.makeChannel<number>(1, 0, \"both\")",
 		"await $.chanSend($.pointerValue<Worker>(w).ch, v)",
 		"return await $.chanRecv($.pointerValue<Worker>(w).ch)",
 		"await using __defer = new $.AsyncDisposableStack()",
@@ -4353,10 +4404,15 @@ func TestCompilePackagesLowersUnaryBitwiseComplement(t *testing.T) {
 		"main.go": strings.Join([]string{
 			"package main",
 			"var value = 1",
+			"var wide uint64 = 1",
+			"var signed int64 = 1",
+			"func invert(crc uint64) uint64 {",
+			"  return ^crc",
+			"}",
 			"func main() {",
 			"  mask := 7",
 			"  mask &^= 3",
-			"  println(^value, value &^ 3, mask, 0700)",
+			"  println(^value, ^wide, ^signed, invert(wide), value &^ 3, mask, 0700)",
 			"}",
 			"",
 		}, "\n"),
@@ -4377,8 +4433,9 @@ func TestCompilePackagesLowersUnaryBitwiseComplement(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
+		"return $.uint($.uint64Xor(crc, -1n), 64)",
 		"mask = mask & ~((3))",
-		"$.println(~value, value & ~(3), mask, 0o700)",
+		"$.println($.int64Xor(value, -1n), $.uint($.uint64Xor(wide, -1n), 64), $.int($.int64Xor(signed, -1n)), $.uint(invert($.uint(wide, 64)), 64), value & ~(3), mask, 0o700)",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)