goscript 0.0.61 → 0.0.63

package/compiler/expr-call-builtins.go

@@ -25,6 +25,9 @@ var builtinFunctions = map[string]bool{
 	"recover": true,
 	"print":   true,
 	"println": true,
+	"min":     true,
+	"max":     true,
+	"clear":   true,
 }
 
 // writeBuiltinFunction handles built-in Go functions
@@ -34,7 +37,7 @@ func (c *GoToTSCompiler) writeBuiltinFunction(exp *ast.CallExpr, funName string)
 		c.tsw.WriteLiterally("$.panic")
 		return true, nil
 	case "println":
-		c.tsw.WriteLiterally("console.log")
+		c.tsw.WriteLiterally("$.println")
 		return true, nil
 	case "len":
 		if len(exp.Args) != 1 {
@@ -89,6 +92,46 @@ func (c *GoToTSCompiler) writeBuiltinFunction(exp *ast.CallExpr, funName string)
 		return true, nil
 	case "append":
 		return true, c.writeAppendCall(exp)
+	case "min":
+		if len(exp.Args) < 1 {
+			return true, errors.New("unhandled min call with no arguments")
+		}
+		c.tsw.WriteLiterally("Math.min(")
+		for i, arg := range exp.Args {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return true, fmt.Errorf("failed to write argument %d in min call: %w", i, err)
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		return true, nil
+	case "max":
+		if len(exp.Args) < 1 {
+			return true, errors.New("unhandled max call with no arguments")
+		}
+		c.tsw.WriteLiterally("Math.max(")
+		for i, arg := range exp.Args {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return true, fmt.Errorf("failed to write argument %d in max call: %w", i, err)
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		return true, nil
+	case "clear":
+		if len(exp.Args) != 1 {
+			return true, errors.Errorf("unhandled clear call with incorrect number of arguments: %d != 1", len(exp.Args))
+		}
+		c.tsw.WriteLiterally("$.clear(")
+		if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+			return true, fmt.Errorf("failed to write argument in clear call: %w", err)
+		}
+		c.tsw.WriteLiterally(")")
+		return true, nil
 	case "byte":
 		if len(exp.Args) != 1 {
 			return true, errors.Errorf("unhandled byte call with incorrect number of arguments: %d != 1", len(exp.Args))
@@ -119,13 +162,16 @@ func (c *GoToTSCompiler) writeAppendCall(exp *ast.CallExpr) error {
 	}
 
 	// The remaining arguments are the elements to append
-	for i, arg := range exp.Args[1:] {
+	elemsToAppend := exp.Args[1:]
+	for i, arg := range elemsToAppend {
 		if i > 0 || len(exp.Args) > 1 {
 			c.tsw.WriteLiterally(", ")
 		}
 
-		// Special case: append([]byte, string...) should convert string to bytes
-		if exp.Ellipsis != token.NoPos && i == 0 { // This is the first element after slice and has ellipsis
+		// Handle ellipsis (spread) for the last argument: append(slice, elems...)
+		// The ellipsis can only appear on the last argument, so check if this is the last element
+		isLastElement := i == len(elemsToAppend)-1
+		if exp.Ellipsis != token.NoPos && isLastElement {
 			// Check if the slice is []byte and the argument is a string
 			sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
 			argType := c.pkg.TypesInfo.TypeOf(arg)
@@ -141,6 +187,16 @@ func (c *GoToTSCompiler) writeAppendCall(exp *ast.CallExpr) error {
 					continue
 				}
 			}
+
+			// For other slice types with ellipsis, use spread operator
+			// append(slice, anotherSlice...) -> $.append(slice, ...(anotherSlice || []))
+			// The || [] handles the case where anotherSlice is null (nil in Go)
+			c.tsw.WriteLiterally("...(")
+			if err := c.WriteValueExpr(arg); err != nil {
+				return fmt.Errorf("failed to write spread argument in append call: %w", err)
+			}
+			c.tsw.WriteLiterally(" || [])")
+			continue
 		}
 
 		if err := c.WriteValueExpr(arg); err != nil {

package/compiler/expr-call-type-conversion.go

@@ -18,14 +18,33 @@ func (c *GoToTSCompiler) writeNilConversion(exp *ast.CallExpr) (handled bool, er
 		return false, nil
 	}
 
-	// Handle nil pointer to struct type conversions: (*struct{})(nil)
-	if starExpr, isStarExpr := exp.Fun.(*ast.StarExpr); isStarExpr {
-		if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
-			c.tsw.WriteLiterally("null")
+	// Check if this is actually a type conversion, not a method/function call
+	// For type conversions, exp.Fun is a type expression (IsType() is true)
+	// For method calls like s.ptr.Swap(nil), exp.Fun is a selector expression (IsType() is false)
+	if tv, ok := c.pkg.TypesInfo.Types[exp.Fun]; !ok || !tv.IsType() {
+		// This is not a type conversion, let the normal call handling proceed
+		return false, nil
+	}
+
+	// Get the type being converted to
+	if typ := c.pkg.TypesInfo.TypeOf(exp.Fun); typ != nil {
+		// For pointer types, create a typed nil that preserves type information
+		if ptrType, ok := typ.(*types.Pointer); ok {
+			// Use a qualifier that returns the package name for local types
+			// This matches Go's reflect output format (e.g., "main.Stringer")
+			qualifier := func(pkg *types.Package) string {
+				if pkg == nil {
+					return ""
+				}
+				return pkg.Name()
+			}
+			typeName := types.TypeString(ptrType, qualifier)
+			c.tsw.WriteLiterallyf("$.typedNil(%q)", typeName)
 			return true, nil
 		}
 	}
 
+	// For non-pointer types (or if type info is unavailable), use plain null
 	c.tsw.WriteLiterally("null")
 	return true, nil
 }
@@ -141,8 +160,21 @@ func (c *GoToTSCompiler) writeStringConversion(exp *ast.CallExpr) error {
 
 	// Handle direct string(int32) conversion
 	if tv, ok := c.pkg.TypesInfo.Types[arg]; ok {
-		// Case 3a: Argument is already a string - no-op
+		// Case 3a: Argument is already a string - no-op (unless it's a named type with toString)
 		if c.isStringType(tv.Type) {
+			// Check if this is a named type from the reflect package (like StructTag)
+			// which is implemented as a class in TypeScript with a toString() method
+			if namedType, isNamed := tv.Type.(*types.Named); isNamed {
+				obj := namedType.Obj()
+				if obj != nil && obj.Pkg() != nil && obj.Pkg().Path() == "reflect" && obj.Name() == "StructTag" {
+					// Call toString() for reflect.StructTag
+					if err := c.WriteValueExpr(arg); err != nil {
+						return fmt.Errorf("failed to write argument for string(reflect.StructTag) conversion: %w", err)
+					}
+					c.tsw.WriteLiterally(".toString()")
+					return nil
+				}
+			}
 			// Translate string(stringValue) to stringValue (no-op)
 			if err := c.WriteValueExpr(arg); err != nil {
 				return fmt.Errorf("failed to write argument for string(string) no-op conversion: %w", err)

package/compiler/expr-call.go

@@ -61,7 +61,8 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			// For built-ins that don't return early, write the arguments
 			if funIdent.String() != "new" && funIdent.String() != "close" && funIdent.String() != "make" &&
 				funIdent.String() != "string" && funIdent.String() != "append" && funIdent.String() != "byte" &&
-				funIdent.String() != "int" {
+				funIdent.String() != "int" && funIdent.String() != "min" && funIdent.String() != "max" &&
+				funIdent.String() != "clear" {
 				return c.writeCallArguments(exp)
 			}
 			return nil
@@ -117,14 +118,26 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 		}
 		c.tsw.WriteLiterally(")")
 	} else {
+		// Check if this is a function call that returns a function (e.g., simpleIterator(m)())
+		// and if the inner call is async, wrap it in parentheses
+		innerCallExpr, isCallExpr := expFun.(*ast.CallExpr)
+		needsParens := isCallExpr && c.isCallExprAsync(innerCallExpr)
+
+		if needsParens {
+			c.tsw.WriteLiterally("(")
+		}
+
 		// Not an identifier (e.g., method call on a value, function call result)
 		if err := c.WriteValueExpr(expFun); err != nil {
 			return fmt.Errorf("failed to write method expression in call: %w", err)
 		}
 
-		// Check if this is a function call that returns a function (e.g., simpleIterator(m)())
+		if needsParens {
+			c.tsw.WriteLiterally(")")
+		}
+
 		// Add non-null assertion since the returned function could be null
-		if _, isCallExpr := expFun.(*ast.CallExpr); isCallExpr {
+		if isCallExpr {
 			c.tsw.WriteLiterally("!")
 		} else {
 			c.addNonNullAssertion(expFun)
@@ -210,8 +223,8 @@ func (c *GoToTSCompiler) writeArgumentWithTypeHandling(arg ast.Expr, funcSig *ty
 	return nil
 }
 
-// resolveImportAlias returns the import alias for a given package
-// This is the single source of truth for import alias resolution
+// resolveImportAlias returns the import alias for a given package.
+// This is the single source of truth for import alias resolution.
 func (c *GoToTSCompiler) resolveImportAlias(pkg *types.Package) (alias string, found bool) {
 	if c.analysis == nil || pkg == nil {
 		return "", false
@@ -219,11 +232,18 @@ func (c *GoToTSCompiler) resolveImportAlias(pkg *types.Package) (alias string, f
 
 	pkgName := pkg.Name()
 
-	// Try to match by the actual package name
+	// Try to match by the actual package name in regular imports
 	if _, exists := c.analysis.Imports[pkgName]; exists {
 		return pkgName, true
 	}
 
+	// Also check synthetic imports for the current file
+	if syntheticImports := c.analysis.SyntheticImportsPerFile[c.currentFilePath]; syntheticImports != nil {
+		if _, exists := syntheticImports[pkgName]; exists {
+			return pkgName, true
+		}
+	}
+
 	return "", false
 }
 

package/compiler/expr-selector.go

@@ -130,10 +130,23 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 
 	// Fallback / Normal Case (e.g., obj.Field, pkg.Var, method calls)
 	// WriteValueExpr handles adding .value for the base variable itself if it's varrefed.
+
+	// Check if the base expression is an async call - if so, we need to wrap it in parentheses
+	// so that await binds correctly: (await asyncFn()).method instead of await asyncFn().method
+	needsParensForAsync := false
+	if callExpr, isCall := exp.X.(*ast.CallExpr); isCall && c.isCallExprAsync(callExpr) {
+		needsParensForAsync = true
+		c.tsw.WriteLiterally("(")
+	}
+
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write selector base expression: %w", err)
 	}
 
+	if needsParensForAsync {
+		c.tsw.WriteLiterally(")")
+	}
+
 	// Add null assertion for selector expressions when accessing fields/methods on nullable types
 	// In Go, accessing fields or calling methods on nil pointers/interfaces panics, so we should throw in TypeScript
 	baseType := c.pkg.TypesInfo.TypeOf(exp.X)
@@ -212,8 +225,24 @@ func (c *GoToTSCompiler) writeMethodValue(exp *ast.SelectorExpr, selection *type
 			return fmt.Errorf("failed to get qualified type name for primitive receiver")
 		}
 
-		// Generate: () => TypeName_MethodName(receiverValue)
-		c.tsw.WriteLiterally("(() => ")
+		// Get the method parameters to forward them
+		params := sig.Params()
+		paramNames := make([]string, params.Len())
+		for i := 0; i < params.Len(); i++ {
+			paramNames[i] = fmt.Sprintf("_p%d", i)
+		}
+
+		// Generate: ((_p0: type0, _p1: type1, ...) => TypeName_MethodName(receiverValue, _p0, _p1, ...))
+		c.tsw.WriteLiterally("((")
+		for i, name := range paramNames {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.tsw.WriteLiterally(name)
+			c.tsw.WriteLiterally(": ")
+			c.WriteGoType(params.At(i).Type(), GoTypeContextGeneral)
+		}
+		c.tsw.WriteLiterally(") => ")
 		c.tsw.WriteLiterally(typeName)
 		c.tsw.WriteLiterally("_")
 		c.tsw.WriteLiterally(exp.Sel.Name)
@@ -221,6 +250,10 @@ func (c *GoToTSCompiler) writeMethodValue(exp *ast.SelectorExpr, selection *type
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write method value receiver: %w", err)
 		}
+		for _, name := range paramNames {
+			c.tsw.WriteLiterally(", ")
+			c.tsw.WriteLiterally(name)
+		}
 		c.tsw.WriteLiterally("))")
 
 		return nil

package/compiler/expr-type.go

@@ -26,13 +26,23 @@ func (c *GoToTSCompiler) WriteTypeExpr(a ast.Expr) {
 			// Check if this is a package selector (e.g., os.FileInfo)
 			if obj := c.pkg.TypesInfo.Uses[pkgIdent]; obj != nil {
 				if _, isPkg := obj.(*types.PkgName); isPkg {
-					// This is a package.Type reference - write the qualified name
+					// This is a package.Type reference
+					typ := c.pkg.TypesInfo.TypeOf(a)
+
+					// Check if this is an interface type and add null | prefix
+					if typ != nil {
+						if _, isInterface := typ.Underlying().(*types.Interface); isInterface {
+							c.tsw.WriteLiterally("null | ")
+						}
+					}
+
+					// Write the qualified name
 					c.tsw.WriteLiterally(pkgIdent.Name)
 					c.tsw.WriteLiterally(".")
 					c.tsw.WriteLiterally(selectorExpr.Sel.Name)
 
 					// Check if this is a function type and add | null
-					if typ := c.pkg.TypesInfo.TypeOf(a); typ != nil {
+					if typ != nil {
 						if namedType, isNamed := typ.(*types.Named); isNamed {
 							if _, isSignature := namedType.Underlying().(*types.Signature); isSignature {
 								c.tsw.WriteLiterally(" | null")

package/compiler/expr.go

@@ -441,9 +441,66 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		c.tsw.WriteLiterally("(") // Add opening parenthesis for bitwise operations
 	}
 
+	// Check if this is a comparison that might trigger TypeScript's control flow narrowing.
+	// When a numeric field is compared to a literal, TypeScript may narrow the field type
+	// to that literal, causing subsequent comparisons to appear unintentional.
+	// We cast to number to widen the type and avoid these false positives.
+	needsNumberCast := false
+	if (exp.Op == token.EQL || exp.Op == token.NEQ) && c.pkg != nil && c.pkg.TypesInfo != nil {
+		// Check if left side is a selector expression (field access) and right is a literal or constant
+		_, leftIsSelector := exp.X.(*ast.SelectorExpr)
+		_, rightIsLiteral := exp.Y.(*ast.BasicLit)
+		// Also check if right side is an identifier referring to a constant
+		rightIsConstant := false
+		if rightIdent, ok := exp.Y.(*ast.Ident); ok {
+			if obj := c.pkg.TypesInfo.Uses[rightIdent]; obj != nil {
+				if _, isConst := obj.(*types.Const); isConst {
+					rightIsConstant = true
+				}
+			}
+		}
+		if leftIsSelector && (rightIsLiteral || rightIsConstant) {
+			leftType := c.pkg.TypesInfo.TypeOf(exp.X)
+			if leftType != nil {
+				if basic, ok := leftType.Underlying().(*types.Basic); ok {
+					// Check if it's a numeric type
+					if basic.Info()&types.IsNumeric != 0 {
+						needsNumberCast = true
+					}
+				}
+			}
+		}
+	}
+
+	// Check if this is integer division (Go's / operator truncates for integers)
+	isIntegerDivision := false
+	if exp.Op == token.QUO && c.pkg != nil && c.pkg.TypesInfo != nil {
+		leftType := c.pkg.TypesInfo.TypeOf(exp.X)
+		rightType := c.pkg.TypesInfo.TypeOf(exp.Y)
+		if leftType != nil && rightType != nil {
+			leftBasic, leftIsBasic := leftType.Underlying().(*types.Basic)
+			rightBasic, rightIsBasic := rightType.Underlying().(*types.Basic)
+			if leftIsBasic && rightIsBasic {
+				// Check if both are integer types (not floating point)
+				isIntegerDivision = (leftBasic.Info()&types.IsInteger != 0) && (rightBasic.Info()&types.IsInteger != 0)
+			}
+		}
+	}
+
+	if isIntegerDivision {
+		// Wrap integer division in Math.trunc() to match Go's integer division behavior
+		c.tsw.WriteLiterally("Math.trunc(")
+	}
+
+	if needsNumberCast {
+		c.tsw.WriteLiterally("Number(")
+	}
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write binary expression left operand: %w", err)
 	}
+	if needsNumberCast {
+		c.tsw.WriteLiterally(")")
+	}
 
 	c.tsw.WriteLiterally(" ")
 	tokStr, ok := TokenToTs(exp.Op)
@@ -458,6 +515,10 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		return fmt.Errorf("failed to write binary expression right operand: %w", err)
 	}
 
+	if isIntegerDivision {
+		c.tsw.WriteLiterally(")") // Close Math.trunc()
+	}
+
 	if isBitwise {
 		c.tsw.WriteLiterally(")") // Add closing parenthesis for bitwise operations
 	}

package/compiler/index.test.ts

@@ -24,6 +24,8 @@ describe("GoScript Compiler API", () => {
     };
 
     await expect(compile(config)).resolves.toBeUndefined();
-    await expect(fs.access(expectedOutputFile)).resolves.toBeUndefined();
+    // fs.access resolves to undefined/null on success - verify file exists
+    const fileExists = await fs.access(expectedOutputFile).then(() => true).catch(() => false);
+    expect(fileExists).toBe(true);
   }, 30000); // 30 second timeout for compilation
 });

package/compiler/lit.go

@@ -143,11 +143,20 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 			c.WriteTypeExpr(exp.Type.Results.List[0].Type)
 		} else {
 			c.tsw.WriteLiterally("[")
-			for i, field := range exp.Type.Results.List {
-				if i > 0 {
-					c.tsw.WriteLiterally(", ")
+			first := true
+			for _, field := range exp.Type.Results.List {
+				// Each field may represent multiple return values (e.g., "a, b int")
+				count := len(field.Names)
+				if count == 0 {
+					count = 1 // Unnamed return value
+				}
+				for j := 0; j < count; j++ {
+					if !first {
+						c.tsw.WriteLiterally(", ")
+					}
+					first = false
+					c.WriteTypeExpr(field.Type)
 				}
-				c.WriteTypeExpr(field.Type)
 			}
 			c.tsw.WriteLiterally("]")
 		}

package/compiler/spec-struct.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/types"
-	"sort"
+	"slices"
 	"strings"
 )
 
@@ -109,8 +109,10 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		}
 
 		// Use AST-based type string when available, fall back to types-based
+		// Note: getASTTypeString already includes "null |" for interface types
 		astType := fieldASTTypes[fieldKeyName]
 		fieldTsType := c.getASTTypeString(astType, field.Type())
+
 		c.tsw.WriteLinef("%s: $.VarRef<%s>;", fieldKeyName, fieldTsType)
 	}
 	c.tsw.Indent(-1)
@@ -346,7 +348,16 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		}
 
 		// Promoted methods
-		embeddedMethodSet := types.NewMethodSet(embeddedFieldType) // Use original field type for method set
+		// Use pointer to embedded type to get both value and pointer receiver methods
+		// This matches Go's behavior where embedding T promotes both T and *T methods
+		// Exception: For interfaces, use the interface directly as pointer-to-interface has no methods
+		methodSetType := embeddedFieldType
+		if _, isPtr := embeddedFieldType.(*types.Pointer); !isPtr {
+			if _, isInterface := embeddedFieldType.Underlying().(*types.Interface); !isInterface {
+				methodSetType = types.NewPointer(embeddedFieldType)
+			}
+		}
+		embeddedMethodSet := types.NewMethodSet(methodSetType)
 		for k := range embeddedMethodSet.Len() {
 			methodSelection := embeddedMethodSet.At(k)
 			method := methodSelection.Obj().(*types.Func)
@@ -479,13 +490,23 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		if fieldKeyName == "_" {
 			continue
 		}
-		// fieldTsType := c.getTypeString(field.Type())
 		if !firstField {
 			c.tsw.WriteLiterally(", ")
 		}
 		firstField = false
 		c.tsw.WriteLiterallyf("%q: ", fieldKeyName)
-		c.writeTypeInfoObject(field.Type()) // Use writeTypeInfoObject for field types
+
+		// Get the struct tag for this field
+		tag := underlyingStruct.Tag(i)
+		if tag != "" {
+			// Write field info with tag as StructFieldInfo object
+			c.tsw.WriteLiterally("{ type: ")
+			c.writeTypeInfoObject(field.Type())
+			c.tsw.WriteLiterallyf(", tag: %q }", tag)
+		} else {
+			// No tag, write type info directly for backwards compatibility
+			c.writeTypeInfoObject(field.Type())
+		}
 	}
 	c.tsw.WriteLiterally("}")
 	c.tsw.WriteLine("")
@@ -543,15 +564,16 @@ func (c *GoToTSCompiler) generateFlattenedInitTypeString(structType *types.Named
 				fieldType = ptr.Elem()
 			}
 
-			if named, ok := fieldType.(*types.Named); ok {
-				embeddedName := named.Obj().Name()
+			if _, ok := fieldType.(*types.Named); ok {
 				// Check if the embedded type is an interface
 				if _, isInterface := fieldType.Underlying().(*types.Interface); isInterface {
 					// For embedded interfaces, use the full qualified interface type
 					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = c.getTypeString(field.Type())
 				} else {
 					// For embedded structs, use ConstructorParameters for field-based initialization
-					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = fmt.Sprintf("Partial<ConstructorParameters<typeof %s>[0]>", embeddedName)
+					// Use getTypeString to get the qualified type name (e.g., bytes.Buffer not just Buffer)
+					qualifiedTypeName := c.getTypeString(fieldType)
+					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = fmt.Sprintf("Partial<ConstructorParameters<typeof %s>[0]>", qualifiedTypeName)
 				}
 			}
 			continue
@@ -573,7 +595,7 @@ func (c *GoToTSCompiler) generateFlattenedInitTypeString(structType *types.Named
 	for name := range fieldMap {
 		fieldNames = append(fieldNames, name)
 	}
-	sort.Strings(fieldNames)
+	slices.Sort(fieldNames)
 
 	var fieldDefs []string
 	for _, fieldName := range fieldNames {

package/compiler/spec-value.go

@@ -164,7 +164,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 			isInsideFunction = nodeInfo.IsInsideFunction
 		}
 
-		if name.IsExported() && !isInsideFunction {
+		if !isInsideFunction {
 			c.tsw.WriteLiterally("export ")
 		}
 		c.tsw.WriteLiterally("let ")
@@ -493,7 +493,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 				isInsideFunction = nodeInfo.IsInsideFunction
 			}
 
-			if name.IsExported() && !isInsideFunction {
+			if !isInsideFunction {
 				c.tsw.WriteLiterally("export ")
 			}
 

package/compiler/spec.go

@@ -57,6 +57,7 @@ func (c *GoToTSCompiler) getEmbeddedFieldKeyName(fieldType types.Type) string {
 
 func (c *GoToTSCompiler) writeGetterSetter(fieldName string, fieldType types.Type, doc, comment *ast.CommentGroup, astType ast.Expr) {
 	// Use AST type information if available to preserve qualified names
+	// Note: getASTTypeString/getTypeString already includes "null |" for interface types
 	var fieldTypeStr string
 	if astType != nil {
 		fieldTypeStr = c.getASTTypeString(astType, fieldType)
@@ -406,11 +407,20 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 						c.WriteTypeExpr(funcDecl.Type.Results.List[0].Type)
 					} else {
 						c.tsw.WriteLiterally("[")
-						for i, field := range funcDecl.Type.Results.List {
-							if i > 0 {
-								c.tsw.WriteLiterally(", ")
+						first := true
+						for _, field := range funcDecl.Type.Results.List {
+							// Each field may represent multiple return values (e.g., "a, b int")
+							count := len(field.Names)
+							if count == 0 {
+								count = 1 // Unnamed return value
+							}
+							for j := 0; j < count; j++ {
+								if !first {
+									c.tsw.WriteLiterally(", ")
+								}
+								first = false
+								c.WriteTypeExpr(field.Type)
 							}
-							c.WriteTypeExpr(field.Type)
 						}
 						c.tsw.WriteLiterally("]")
 					}
@@ -625,6 +635,15 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 		importVars: make(map[string]struct{}),
 	}
 
+	// Skip writing the import if it was already written as a synthetic import
+	// This prevents duplicate imports when a file needs an import both from
+	// its AST and for promoted methods from embedded structs
+	if syntheticImports := c.analysis.SyntheticImportsPerFile[c.currentFilePath]; syntheticImports != nil {
+		if _, isSynthetic := syntheticImports[impName]; isSynthetic {
+			return
+		}
+	}
+
 	c.tsw.WriteImport(impName, tsImportPath+"/index.js")
 }