goscript 0.0.76 → 0.0.78

package/compiler/gs_dependencies_test.go

@@ -1,6 +1,7 @@
 package compiler
 
 import (
+	"slices"
 	"testing"
 
 	"github.com/sirupsen/logrus"
@@ -36,13 +37,7 @@ func TestReadGsPackageMetadata(t *testing.T) {
 	}
 
 	// Check for the specific "iter" dependency
-	foundIter := false
-	for _, dep := range metadata.Dependencies {
-		if dep == "iter" {
-			foundIter = true
-			break
-		}
-	}
+	foundIter := slices.Contains(metadata.Dependencies, "iter")
 
 	if !foundIter {
 		t.Errorf("Expected to find 'iter' dependency, got dependencies: %v", metadata.Dependencies)
@@ -51,13 +46,7 @@ func TestReadGsPackageMetadata(t *testing.T) {
 	// Also check for other expected dependencies from the bytes package
 	expectedDeps := []string{"errors", "io", "iter", "unicode", "unicode/utf8", "unsafe"}
 	for _, expected := range expectedDeps {
-		found := false
-		for _, dep := range metadata.Dependencies {
-			if dep == expected {
-				found = true
-				break
-			}
-		}
+		found := slices.Contains(metadata.Dependencies, expected)
 		if !found {
 			t.Errorf("Expected to find dependency '%s', got dependencies: %v", expected, metadata.Dependencies)
 		}

package/compiler/index.ts

@@ -65,15 +65,30 @@ export async function compile(config: CompileConfig): Promise<void> {
       // Go compiler often prints status messages to stderr, treat as info unless exit code is non-zero
       console.info(`GoScript stderr:\n${stderr}`);
     }
-  } catch (error: any) {  
-    console.error(`GoScript compilation failed: ${error.message}`);
-    if (error.stderr) {
+  } catch (error: unknown) {
+    const compileErr =
+      error instanceof Error ? error : new Error(String(error));
+
+    console.error(`GoScript compilation failed: ${compileErr.message}`);
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "stderr" in error &&
+      typeof error.stderr === "string"
+    ) {
       console.error(`GoScript stderr:\n${error.stderr}`);
     }
-    if (error.stdout) {
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "stdout" in error &&
+      typeof error.stdout === "string"
+    ) {
       console.error(`GoScript stdout:\n${error.stdout}`);
     }
-    throw new Error(`GoScript compilation failed: ${error.message}`);
+    throw new Error(`GoScript compilation failed: ${compileErr.message}`, {
+      cause: error,
+    });
   }
 }
 

package/compiler/protobuf.go

@@ -146,35 +146,35 @@ func (c *PackageCompiler) writeProtobufExports(indexFile *os.File, fileName stri
 	//  - export function Name
 	// We avoid type-only exports for now.
 	var exports []string
-	lines := strings.Split(string(content), "\n")
-	for _, ln := range lines {
+	lines := strings.SplitSeq(string(content), "\n")
+	for ln := range lines {
 		l := strings.TrimSpace(ln)
-		if strings.HasPrefix(l, "export const ") {
-			rest := strings.TrimPrefix(l, "export const ")
+		if after, ok := strings.CutPrefix(l, "export const "); ok {
+			rest := after
 			name := takeIdent(rest)
 			if name != "" {
 				exports = append(exports, name)
 			}
 			continue
 		}
-		if strings.HasPrefix(l, "export interface ") {
-			rest := strings.TrimPrefix(l, "export interface ")
+		if after, ok := strings.CutPrefix(l, "export interface "); ok {
+			rest := after
 			name := takeIdent(rest)
 			if name != "" {
 				exports = append(exports, name)
 			}
 			continue
 		}
-		if strings.HasPrefix(l, "export class ") {
-			rest := strings.TrimPrefix(l, "export class ")
+		if after, ok := strings.CutPrefix(l, "export class "); ok {
+			rest := after
 			name := takeIdent(rest)
 			if name != "" {
 				exports = append(exports, name)
 			}
 			continue
 		}
-		if strings.HasPrefix(l, "export function ") {
-			rest := strings.TrimPrefix(l, "export function ")
+		if after, ok := strings.CutPrefix(l, "export function "); ok {
+			rest := after
 			name := takeIdent(rest)
 			if name != "" {
 				exports = append(exports, name)
@@ -236,9 +236,9 @@ func (c *FileCompiler) addProtobufImports() error {
 
 	for _, fileName := range c.pkg.CompiledGoFiles {
 		baseFileName := filepath.Base(fileName)
-		if strings.HasSuffix(baseFileName, ".pb.go") {
+		if before, ok := strings.CutSuffix(baseFileName, ".pb.go"); ok {
 			// Check if there's a corresponding .pb.ts file
-			pbTsFileName := strings.TrimSuffix(baseFileName, ".pb.go") + ".pb.ts"
+			pbTsFileName := before + ".pb.ts"
 			pbTsPath := filepath.Join(packageDir, pbTsFileName)
 
 			if _, err := os.Stat(pbTsPath); err == nil {
@@ -252,28 +252,28 @@ func (c *FileCompiler) addProtobufImports() error {
 
 				// Discover exported identifiers (const/interface/class/function)
 				var exports []string
-				for _, ln := range strings.Split(string(content), "\n") {
+				for ln := range strings.SplitSeq(string(content), "\n") {
 					l := strings.TrimSpace(ln)
-					if strings.HasPrefix(l, "export const ") {
-						if name := takeIdent(strings.TrimPrefix(l, "export const ")); name != "" {
+					if after, ok := strings.CutPrefix(l, "export const "); ok {
+						if name := takeIdent(after); name != "" {
 							exports = append(exports, name)
 						}
 						continue
 					}
-					if strings.HasPrefix(l, "export interface ") {
-						if name := takeIdent(strings.TrimPrefix(l, "export interface ")); name != "" {
+					if after, ok := strings.CutPrefix(l, "export interface "); ok {
+						if name := takeIdent(after); name != "" {
 							exports = append(exports, name)
 						}
 						continue
 					}
-					if strings.HasPrefix(l, "export class ") {
-						if name := takeIdent(strings.TrimPrefix(l, "export class ")); name != "" {
+					if after, ok := strings.CutPrefix(l, "export class "); ok {
+						if name := takeIdent(after); name != "" {
 							exports = append(exports, name)
 						}
 						continue
 					}
-					if strings.HasPrefix(l, "export function ") {
-						if name := takeIdent(strings.TrimPrefix(l, "export function ")); name != "" {
+					if after, ok := strings.CutPrefix(l, "export function "); ok {
+						if name := takeIdent(after); name != "" {
 							exports = append(exports, name)
 						}
 						continue

package/compiler/spec-struct.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/types"
+	"maps"
 	"slices"
 	"strings"
 )
@@ -72,8 +73,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	}
 
 	// Generate getters and setters for EMBEDDED struct fields themselves
-	for i := range underlyingStruct.NumFields() {
-		field := underlyingStruct.Field(i)
+	for field := range underlyingStruct.Fields() {
 		if field.Anonymous() {
 			fieldKeyName := c.getEmbeddedFieldKeyName(field.Type())
 			c.writeGetterSetter(fieldKeyName, field.Type(), nil, nil, nil)
@@ -95,8 +95,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.Indent(1)
 	c.tsw.WriteLine("")
 
-	for i := 0; i < underlyingStruct.NumFields(); i++ {
-		field := underlyingStruct.Field(i)
+	for field := range underlyingStruct.Fields() {
 		var fieldKeyName string
 		if field.Anonymous() {
 			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
@@ -166,25 +165,26 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLine("")
 
 	// Generate the clone method
-	cloneReturnType := className
+	var cloneReturnType strings.Builder
+	cloneReturnType.WriteString(className)
 	if a.TypeParams != nil && len(a.TypeParams.List) > 0 {
-		cloneReturnType += "<"
+		cloneReturnType.WriteString("<")
 		first := true
 		for _, field := range a.TypeParams.List {
 			for _, name := range field.Names {
 				if !first {
-					cloneReturnType += ", "
+					cloneReturnType.WriteString(", ")
 				}
 				first = false
-				cloneReturnType += name.Name
+				cloneReturnType.WriteString(name.Name)
 			}
 		}
-		cloneReturnType += ">"
+		cloneReturnType.WriteString(">")
 	}
 
-	c.tsw.WriteLinef("public clone(): %s {", cloneReturnType)
+	c.tsw.WriteLinef("public clone(): %s {", cloneReturnType.String())
 	c.tsw.Indent(1)
-	c.tsw.WriteLinef("const cloned = new %s()", cloneReturnType)
+	c.tsw.WriteLinef("const cloned = new %s()", cloneReturnType.String())
 	c.tsw.WriteLine("cloned._fields = {")
 	c.tsw.Indent(1)
 
@@ -257,8 +257,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	seenPromotedFields := make(map[string]bool)
 	directMethods := make(map[string]bool)
 	// Populate directMethods (methods defined directly on this struct type)
-	for i := range goStructType.NumMethods() {
-		method := goStructType.Method(i)
+	for method := range goStructType.Methods() {
 		sig := method.Type().(*types.Signature)
 		if sig.Recv() != nil {
 			recvType := sig.Recv().Type()
@@ -272,8 +271,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		}
 	}
 
-	for i := range underlyingStruct.NumFields() {
-		field := underlyingStruct.Field(i)
+	for field := range underlyingStruct.Fields() {
 		if !field.Anonymous() {
 			continue
 		}
@@ -293,8 +291,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		// Promoted fields
 		if namedEmbedded, ok := trueEmbeddedType.(*types.Named); ok {
 			if underlyingEmbeddedStruct, ok := namedEmbedded.Underlying().(*types.Struct); ok {
-				for j := 0; j < underlyingEmbeddedStruct.NumFields(); j++ {
-					promotedField := underlyingEmbeddedStruct.Field(j)
+				for promotedField := range underlyingEmbeddedStruct.Fields() {
 					if !promotedField.Exported() && promotedField.Pkg() != c.pkg.Types {
 						continue
 					}
@@ -304,8 +301,8 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 					}
 					// Check for conflicts with outer struct's own fields or other promoted fields
 					conflict := false
-					for k := 0; k < underlyingStruct.NumFields(); k++ {
-						if !underlyingStruct.Field(k).Anonymous() && underlyingStruct.Field(k).Name() == promotedFieldName {
+					for field := range underlyingStruct.Fields() {
+						if !field.Anonymous() && field.Name() == promotedFieldName {
 							conflict = true
 							break
 						}
@@ -358,8 +355,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			}
 		}
 		embeddedMethodSet := types.NewMethodSet(methodSetType)
-		for k := range embeddedMethodSet.Len() {
-			methodSelection := embeddedMethodSet.At(k)
+		for methodSelection := range embeddedMethodSet.Methods() {
 			method := methodSelection.Obj().(*types.Func)
 			methodName := method.Name()
 
@@ -367,8 +363,8 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			if len(methodSelection.Index()) == 1 && !directMethods[methodName] && !seenPromotedFields[methodName] {
 				// Check for conflict with outer struct's own fields
 				conflictWithField := false
-				for k_idx := 0; k_idx < underlyingStruct.NumFields(); k_idx++ {
-					if !underlyingStruct.Field(k_idx).Anonymous() && underlyingStruct.Field(k_idx).Name() == methodName {
+				for field := range underlyingStruct.Fields() {
+					if !field.Anonymous() && field.Name() == methodName {
 						conflictWithField = true
 						break
 					}
@@ -457,8 +453,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLiterally("  [")
 	// Collect methods for the struct type
 	var structMethods []*types.Func
-	for i := range goStructType.NumMethods() {
-		method := goStructType.Method(i)
+	for method := range goStructType.Methods() {
 		// Ensure it's a method directly on this type (not promoted here, promotion handled separately)
 		// Check if receiver is *T or T where T is goStructType
 		sig := method.Type().(*types.Signature)
@@ -517,6 +512,179 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	return nil
 }
 
+// WriteNamedStructTypeSpec generates a TypeScript class for a named type whose
+// underlying type is a struct defined elsewhere.
+func (c *GoToTSCompiler) WriteNamedStructTypeSpec(a *ast.TypeSpec, named *types.Named) error {
+	isInsideFunction := false
+	if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
+		isInsideFunction = nodeInfo.IsInsideFunction
+	}
+	if !isInsideFunction {
+		c.tsw.WriteLiterally("export ")
+	}
+	c.tsw.WriteLiterally("class ")
+	if err := c.WriteValueExpr(a.Name); err != nil {
+		return err
+	}
+
+	if a.TypeParams != nil {
+		c.WriteTypeParameters(a.TypeParams)
+	}
+
+	c.tsw.WriteLiterally(" extends ")
+	c.WriteTypeExpr(a.Type)
+	c.tsw.WriteLiterally(" ")
+	c.tsw.WriteLine("{")
+	c.tsw.Indent(1)
+
+	className := sanitizeIdentifier(a.Name.Name)
+	underlyingStruct, ok := named.Underlying().(*types.Struct)
+	if !ok {
+		return fmt.Errorf("underlying type of %s is not a struct", a.Name.Name)
+	}
+
+	c.tsw.WriteLine("constructor(init?: any) {")
+	c.tsw.Indent(1)
+	c.tsw.WriteLine("super(init)")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("")
+
+	c.tsw.WriteLinef("public clone(): %s {", className)
+	c.tsw.Indent(1)
+	c.tsw.WriteLinef("const cloned = new %s()", className)
+	c.tsw.WriteLine("cloned._fields = {")
+	c.tsw.Indent(1)
+
+	firstFieldWritten := false
+	for i := 0; i < underlyingStruct.NumFields(); i++ {
+		field := underlyingStruct.Field(i)
+		fieldType := field.Type()
+		var fieldKeyName string
+		if field.Anonymous() {
+			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
+		} else {
+			fieldKeyName = field.Name()
+		}
+		if fieldKeyName == "_" {
+			continue
+		}
+
+		if firstFieldWritten {
+			c.tsw.WriteLine(",")
+		}
+		c.writeClonedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
+		firstFieldWritten = true
+	}
+	if firstFieldWritten {
+		c.tsw.WriteLine("")
+	}
+
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("return cloned")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+
+	for _, fileSyntax := range c.pkg.Syntax {
+		for _, decl := range fileSyntax.Decls {
+			funcDecl, isFunc := decl.(*ast.FuncDecl)
+			if !isFunc || funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
+				continue
+			}
+			recvType := funcDecl.Recv.List[0].Type
+			if starExpr, ok := recvType.(*ast.StarExpr); ok {
+				recvType = starExpr.X
+			}
+
+			var recvTypeName string
+			if ident, ok := recvType.(*ast.Ident); ok {
+				recvTypeName = sanitizeIdentifier(ident.Name)
+			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
+				if ident, ok := indexExpr.X.(*ast.Ident); ok {
+					recvTypeName = sanitizeIdentifier(ident.Name)
+				}
+			}
+
+			if recvTypeName == className {
+				c.tsw.WriteLine("")
+				if err := c.WriteFuncDeclAsMethod(funcDecl); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	c.tsw.WriteLine("")
+	c.tsw.WriteLine("// Register this type with the runtime type system")
+
+	structName := className
+	pkgPath := c.pkg.Types.Path()
+	pkgName := c.pkg.Types.Name()
+	if pkgPath != "" && pkgName != "main" {
+		structName = pkgPath + "." + className
+	} else if pkgName == "main" {
+		structName = "main." + className
+	}
+
+	c.tsw.WriteLine("static __typeInfo = $.registerStructType(")
+	c.tsw.WriteLinef("  %q,", structName)
+	c.tsw.WriteLinef("  new %s(),", className)
+	c.tsw.WriteLiterally("  [")
+
+	var structMethods []*types.Func
+	for method := range named.Methods() {
+		sig := method.Type().(*types.Signature)
+		recv := sig.Recv().Type()
+		if ptr, ok := recv.(*types.Pointer); ok {
+			recv = ptr.Elem()
+		}
+		if namedRecv, ok := recv.(*types.Named); ok && namedRecv.Obj() == named.Obj() {
+			structMethods = append(structMethods, method)
+		}
+	}
+	c.writeMethodSignatures(structMethods)
+	c.tsw.WriteLiterally("],")
+	c.tsw.WriteLine("")
+
+	c.tsw.WriteLinef("  %s,", className)
+	c.tsw.WriteLiterally("  {")
+	firstField := true
+	for i := 0; i < underlyingStruct.NumFields(); i++ {
+		field := underlyingStruct.Field(i)
+		var fieldKeyName string
+		if field.Anonymous() {
+			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
+		} else {
+			fieldKeyName = field.Name()
+		}
+		if fieldKeyName == "_" {
+			continue
+		}
+		if !firstField {
+			c.tsw.WriteLiterally(", ")
+		}
+		firstField = false
+		c.tsw.WriteLiterallyf("%q: ", fieldKeyName)
+
+		tag := underlyingStruct.Tag(i)
+		if tag != "" {
+			c.tsw.WriteLiterally("{ type: ")
+			c.writeTypeInfoObject(field.Type())
+			c.tsw.WriteLiterallyf(", tag: %q }", tag)
+		} else {
+			c.writeTypeInfoObject(field.Type())
+		}
+	}
+	c.tsw.WriteLiterally("}")
+	c.tsw.WriteLine("")
+	c.tsw.WriteLine(");")
+
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	return nil
+}
+
 // generateFlattenedInitTypeString generates a TypeScript type string for the
 // initialization object passed to a Go struct's constructor (`_init` method in TypeScript).
 // The generated type is a `Partial`-like structure, `"{ Field1?: Type1, Field2?: Type2, ... }"`,
@@ -545,8 +713,7 @@ func (c *GoToTSCompiler) generateFlattenedInitTypeString(structType *types.Named
 	}
 
 	// First add the direct fields and track embedded types
-	for i := 0; i < underlying.NumFields(); i++ {
-		field := underlying.Field(i)
+	for field := range underlying.Fields() {
 		fieldName := field.Name()
 
 		// Skip underscore fields
@@ -587,9 +754,7 @@ func (c *GoToTSCompiler) generateFlattenedInitTypeString(structType *types.Named
 	// not typically set directly in `init?` unless the embedded struct itself is named in `init?`.
 
 	// Add embedded types to the field map (these are the names of the embedded structs themselves)
-	for embeddedName, embeddedTSType := range embeddedTypeMap {
-		fieldMap[embeddedName] = embeddedTSType
-	}
+	maps.Copy(fieldMap, embeddedTypeMap)
 
 	var fieldNames []string
 	for name := range fieldMap {

package/compiler/spec.go

@@ -366,6 +366,20 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 
 			if recvTypeName == className {
 				c.tsw.WriteLiterally("export function ")
+				var isAsync bool
+				if obj := c.pkg.TypesInfo.Defs[funcDecl.Name]; obj != nil {
+					isAsync = c.analysis.IsAsyncFunc(obj)
+				}
+				if !isAsync {
+					bodyNeedsAsync, err := c.funcBodyNeedsAsync(funcDecl, false)
+					if err != nil {
+						return err
+					}
+					isAsync = bodyNeedsAsync
+				}
+				if isAsync {
+					c.tsw.WriteLiterally("async ")
+				}
 				c.tsw.WriteLiterally(className)
 				c.tsw.WriteLiterally("_")
 				c.tsw.WriteLiterally(funcDecl.Name.Name)
@@ -403,6 +417,9 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 				// Add return type
 				if funcDecl.Type.Results != nil && len(funcDecl.Type.Results.List) > 0 {
 					c.tsw.WriteLiterally(": ")
+					if isAsync {
+						c.tsw.WriteLiterally("Promise<")
+					}
 					if len(funcDecl.Type.Results.List) == 1 {
 						c.WriteTypeExpr(funcDecl.Type.Results.List[0].Type)
 					} else {
@@ -424,8 +441,15 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 						}
 						c.tsw.WriteLiterally("]")
 					}
+					if isAsync {
+						c.tsw.WriteLiterally(">")
+					}
 				} else {
-					c.tsw.WriteLiterally(": void")
+					if isAsync {
+						c.tsw.WriteLiterally(": Promise<void>")
+					} else {
+						c.tsw.WriteLiterally(": void")
+					}
 				}
 
 				c.tsw.WriteLine(" {")
@@ -476,6 +500,11 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 	default:
 		// Check if this type has receiver methods
 		if c.hasReceiverMethods(a.Name.Name) {
+			if named, ok := c.pkg.TypesInfo.Defs[a.Name].Type().(*types.Named); ok {
+				if _, isStruct := named.Underlying().(*types.Struct); isStruct {
+					return c.WriteNamedStructTypeSpec(a, named)
+				}
+			}
 			return c.WriteNamedTypeWithMethods(a)
 		}
 
@@ -560,8 +589,8 @@ func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.Interfac
 	// Collect methods for the interface type
 	var interfaceMethods []*types.Func
 	if ifaceType != nil { // ifaceType is *types.Interface
-		for i := range ifaceType.NumExplicitMethods() {
-			interfaceMethods = append(interfaceMethods, ifaceType.ExplicitMethod(i))
+		for method := range ifaceType.ExplicitMethods() {
+			interfaceMethods = append(interfaceMethods, method)
 		}
 		// TODO: Handle embedded interface methods if necessary for full signature collection.
 		// For now, explicit methods are covered.

package/compiler/stmt-assign.go

@@ -313,8 +313,8 @@ func (c *GoToTSCompiler) writeMultiVarAssignFromCall(lhs []ast.Expr, callExpr *a
 			if funType := c.pkg.TypesInfo.TypeOf(callExpr.Fun); funType != nil {
 				if funcType, ok := funType.Underlying().(*types.Signature); ok {
 					if funcType.Results() != nil && funcType.Results().Len() > 0 {
-						for i := 0; i < funcType.Results().Len(); i++ {
-							resultTypes = append(resultTypes, funcType.Results().At(i))
+						for v := range funcType.Results().Variables() {
+							resultTypes = append(resultTypes, v)
 						}
 					}
 				}

package/compiler/type-info.go

@@ -2,6 +2,23 @@ package compiler
 
 import "go/types"
 
+func qualifiedTypeName(namedType *types.Named) string {
+	if namedType == nil || namedType.Obj() == nil {
+		return ""
+	}
+
+	typeName := namedType.Obj().Name()
+	if pkg := namedType.Obj().Pkg(); pkg != nil {
+		switch {
+		case pkg.Name() == "main":
+			typeName = "main." + typeName
+		case pkg.Path() != "":
+			typeName = pkg.Path() + "." + typeName
+		}
+	}
+	return typeName
+}
+
 // writeTypeInfoObject writes a TypeScript TypeInfo object literal for a given Go type.
 func (c *GoToTSCompiler) writeTypeInfoObject(typ types.Type) {
 	if typ == nil {
@@ -17,7 +34,7 @@ func (c *GoToTSCompiler) writeTypeInfoObject(typ types.Type) {
 			// For all other named types, output their name as a string literal.
 			// This relies on the type being registered elsewhere (e.g., via registerStructType or registerInterfaceType)
 			// so the TypeScript runtime can resolve the reference.
-			c.tsw.WriteLiterallyf("%q", namedType.Obj().Name())
+			c.tsw.WriteLiterallyf("%q", qualifiedTypeName(namedType))
 		}
 		return // Return after handling the named type by reference.
 	}
@@ -64,8 +81,8 @@ func (c *GoToTSCompiler) writeTypeInfoObject(typ types.Type) {
 	case *types.Interface: // Anonymous interface or underlying of a non-named type alias
 		c.tsw.WriteLiterally("{ kind: $.TypeKind.Interface, methods: [")
 		var methods []*types.Func
-		for i := 0; i < t.NumExplicitMethods(); i++ {
-			methods = append(methods, t.ExplicitMethod(i))
+		for method := range t.ExplicitMethods() {
+			methods = append(methods, method)
 		}
 		// TODO: Handle embedded methods for anonymous interfaces if needed.
 		c.writeMethodSignatures(methods) // Calls writeMethodSignatures -> writeTypeInfoObject

package/compiler/type-utils.go

@@ -47,12 +47,10 @@ func (c *GoToTSCompiler) constraintIncludesString(constraint *types.Interface) b
 		return false // Pure method interface, no type terms
 	}
 	// For union constraints like []byte | string, check each term
-	for i := 0; i < constraint.NumEmbeddeds(); i++ {
-		embedded := constraint.EmbeddedType(i)
+	for embedded := range constraint.EmbeddedTypes() {
 		// Check if embedded is a union
 		if union, isUnion := embedded.(*types.Union); isUnion {
-			for j := 0; j < union.Len(); j++ {
-				term := union.Term(j)
+			for term := range union.Terms() {
 				termType := term.Type()
 				// Check if term is string or ~string
 				if basic, isBasic := termType.Underlying().(*types.Basic); isBasic {

package/compiler/type.go

@@ -605,8 +605,7 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 		c.tsw.Indent(1)
 		c.tsw.WriteLine("") // Newline after opening brace, before the first method
 
-		for i := 0; i < iface.NumExplicitMethods(); i++ {
-			method := iface.ExplicitMethod(i)
+		for method := range iface.ExplicitMethods() {
 			sig := method.Type().(*types.Signature)
 
 			// Find corresponding ast.Field for comments if astNode is available
@@ -745,14 +744,14 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 
 	// Handle embedded types
 	if iface.NumEmbeddeds() > 0 {
-		for i := 0; i < iface.NumEmbeddeds(); i++ {
+		for etyp := range iface.EmbeddedTypes() {
 			if firstPartWritten {
 				c.tsw.WriteLiterally(" & ")
 			} else {
 				// This is the first part being written (no explicit methods, only embedded)
 				firstPartWritten = true
 			}
-			embeddedType := iface.EmbeddedType(i)
+			embeddedType := etyp
 			// When WriteGoType encounters an interface, it will call WriteInterfaceType
 			// which will pass nil for astNode, so comments for deeply embedded interface literals
 			// might not be available unless they are named types.