goscript 0.0.38 → 0.0.40

package/compiler/analysis.go

@@ -831,10 +831,8 @@ func (v *analysisVisitor) containsAsyncOperations(node ast.Node) bool {
 
 								// Check if the type is from an imported package
 								if typePkg := namedType.Obj().Pkg(); typePkg != nil && typePkg != v.pkg.Types {
-									pkgPath := typePkg.Path()
-									// Extract package name from path (e.g., "sync" from "github.com/.../gs/sync")
-									parts := strings.Split(pkgPath, "/")
-									pkgName := parts[len(parts)-1]
+									// Use the actual package name from the type information
+									pkgName := typePkg.Name()
 
 									// Check if this method is async based on metadata
 									if v.analysis.IsMethodAsync(pkgName, typeName, methodName) {
@@ -905,10 +903,21 @@ func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap
 				importVars: make(map[string]struct{}),
 			}
 
-			// Use the import name or package name as the key
-			key := packageNameFromGoPath(path)
+			// Use the import name or the actual package name as the key
+			var key string
 			if name != "" {
+				// Explicit alias provided
 				key = name
+			} else {
+				// No explicit alias, use the actual package name from type information
+				// This handles cases where package name differs from the last path segment
+				if actualName, err := getActualPackageName(path, pkg.Imports); err == nil {
+					key = actualName
+				} else {
+					// Fallback to last segment of path if package not found in type information
+					pts := strings.Split(path, "/")
+					key = pts[len(pts)-1]
+				}
 			}
 
 			analysis.Imports[key] = fileImp

package/compiler/compiler.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/constant"
+	"go/parser"
 	"go/token"
 	"go/types"
 	"os"
@@ -140,7 +141,7 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			// Check if this package has a handwritten equivalent
 			if hasHandwrittenEquivalent(pkg.PkgPath) {
 				// Add this package but don't visit its dependencies
-				c.le.Debugf("Skipping dependencies of handwritten package: %s", pkg.PkgPath)
+				// c.le.Debugf("Skipping dependencies of handwritten package: %s", pkg.PkgPath)
 				return
 			}
 
@@ -148,13 +149,13 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			for _, imp := range pkg.Imports {
 				// Skip protobuf-go-lite packages and their dependencies
 				if isProtobufGoLitePackage(imp.PkgPath) {
-					c.le.Debugf("Skipping protobuf-go-lite package: %s", imp.PkgPath)
+					// c.le.Debugf("Skipping protobuf-go-lite package: %s", imp.PkgPath)
 					continue
 				}
 
 				// Skip packages that are only used by .pb.go files
 				if isPackageOnlyUsedByProtobufFiles(pkg, imp.PkgPath) {
-					c.le.Debugf("Skipping package only used by .pb.go files: %s", imp.PkgPath)
+					// c.le.Debugf("Skipping package only used by .pb.go files: %s", imp.PkgPath)
 					continue
 				}
 
@@ -193,7 +194,7 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 
 	// If DisableEmitBuiltin is false, we need to copy the builtin package to the output directory
 	if !c.config.DisableEmitBuiltin {
-		c.le.Infof("Copying builtin package to output directory")
+		c.le.Debugf("Copying builtin package to output directory")
 		builtinPath := "gs/builtin"
 		outputPath := ComputeModulePath(c.config.OutputPath, "builtin")
 		if err := c.copyEmbeddedPackage(builtinPath, outputPath); err != nil {
@@ -202,6 +203,9 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 		result.CopiedPackages = append(result.CopiedPackages, "builtin")
 	}
 
+	// Track which gs packages have been processed to avoid duplicates
+	processedGsPackages := make(map[string]bool)
+
 	// Compile all packages
 	for _, pkg := range pkgs {
 		// Check if the package has a handwritten equivalent
@@ -214,32 +218,14 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			}
 			if gsErr == nil {
 				if c.config.DisableEmitBuiltin {
-					c.le.Infof("Skipping compilation for overridden package %s", pkg.PkgPath)
+					// c.le.Infof("Skipping compilation for overridden package %s", pkg.PkgPath)
 					result.CopiedPackages = append(result.CopiedPackages, pkg.PkgPath)
 					continue
 				} else {
-					// If DisableEmitBuiltin is false, we need to copy the handwritten package to the output directory
-					c.le.Infof("Copying handwritten package %s to output directory", pkg.PkgPath)
-
-					// Compute output path for this package
-					outputPath := ComputeModulePath(c.config.OutputPath, pkg.PkgPath)
-
-					// Remove existing directory if it exists
-					if err := os.RemoveAll(outputPath); err != nil {
-						return nil, fmt.Errorf("failed to remove existing output directory for %s: %w", pkg.PkgPath, err)
-					}
-
-					// Create the output directory
-					if err := os.MkdirAll(outputPath, 0o755); err != nil {
-						return nil, fmt.Errorf("failed to create output directory for %s: %w", pkg.PkgPath, err)
+					// If DisableEmitBuiltin is false, we need to copy the handwritten package and its dependencies
+					if err := c.copyGsPackageWithDependencies(pkg.PkgPath, processedGsPackages, result); err != nil {
+						return nil, fmt.Errorf("failed to copy handwritten package %s with dependencies: %w", pkg.PkgPath, err)
 					}
-
-					// Copy files from embedded FS to output directory
-					if err := c.copyEmbeddedPackage(gsSourcePath, outputPath); err != nil {
-						return nil, fmt.Errorf("failed to copy embedded package %s: %w", pkg.PkgPath, err)
-					}
-
-					result.CopiedPackages = append(result.CopiedPackages, pkg.PkgPath)
 					continue
 				}
 			}
@@ -260,6 +246,8 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			return nil, fmt.Errorf("failed to compile package %s: %w", pkg.PkgPath, err)
 		}
 
+		c.le.Info(pkg.PkgPath)
+
 		result.CompiledPackages = append(result.CompiledPackages, pkg.PkgPath)
 	}
 
@@ -352,7 +340,8 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 			}
 		}
 
-		c.le.WithField("file", relWdFileName).Debug("compiling file")
+		// log just the filename
+		c.le.Debugf("GS: %s", filepath.Base(fileName))
 		if err := c.CompileFile(ctx, fileName, f, packageAnalysis); err != nil {
 			return err
 		}
@@ -945,13 +934,9 @@ func (c *GoToTSCompiler) writeConstantValue(constObj *types.Const) {
 
 // copyEmbeddedPackage recursively copies files from an embedded FS path to a filesystem directory.
 // It handles both regular files and directories, but only copies .gs.ts and .ts files.
+// It preserves existing subdirectories that aren't being overwritten.
 func (c *Compiler) copyEmbeddedPackage(embeddedPath string, outputPath string) error {
-	// Remove the output path if it exists
-	if err := os.RemoveAll(outputPath); err != nil {
-		return fmt.Errorf("failed to remove output directory %s: %w", outputPath, err)
-	}
-
-	// Create the output path
+	// Create the output path if it doesn't exist
 	if err := os.MkdirAll(outputPath, 0o755); err != nil {
 		return fmt.Errorf("failed to create output directory %s: %w", outputPath, err)
 	}
@@ -981,10 +966,17 @@ func (c *Compiler) copyEmbeddedPackage(embeddedPath string, outputPath string) e
 			// Only copy .gs.ts and .ts files, skip .go files and others
 			fileName := entry.Name()
 			if !strings.HasSuffix(fileName, ".gs.ts") && !strings.HasSuffix(fileName, ".ts") {
-				c.le.Debugf("Skipping non-TypeScript file: %s", fileName)
+				// c.le.Debugf("Skipping non-TypeScript file: %s", fileName)
 				continue
 			}
 
+			// Remove existing file if it exists (but preserve directories)
+			if stat, err := os.Stat(outputEntryPath); err == nil && !stat.IsDir() {
+				if err := os.Remove(outputEntryPath); err != nil {
+					return fmt.Errorf("failed to remove existing file %s: %w", outputEntryPath, err)
+				}
+			}
+
 			// Read the file content from the embedded FS
 			content, err := gs.GsOverrides.ReadFile(entryPath)
 			if err != nil {
@@ -1000,3 +992,161 @@ func (c *Compiler) copyEmbeddedPackage(embeddedPath string, outputPath string) e
 
 	return nil
 }
+
+// GsPackageMetadata holds metadata about a gs/ package
+type GsPackageMetadata struct {
+	// Dependencies lists the import paths that this gs/ package requires
+	Dependencies []string
+}
+
+// ReadGsPackageMetadata reads dependency metadata from .go files in a gs/ package
+// It looks for a var variable named "GsDependencies" which should be a slice of strings
+// containing the import paths that this package depends on.
+func (c *Compiler) ReadGsPackageMetadata(gsSourcePath string) (*GsPackageMetadata, error) {
+	metadata := &GsPackageMetadata{
+		Dependencies: []string{},
+	}
+
+	// Check if there are any .go files in the gs package directory
+	entries, err := gs.GsOverrides.ReadDir(gsSourcePath)
+	if err != nil {
+		return metadata, nil // No metadata files, return empty metadata
+	}
+
+	// Look for .go files containing metadata
+	for _, entry := range entries {
+		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".go") {
+			metadataFilePath := filepath.Join(gsSourcePath, entry.Name())
+
+			// Read the .go file content
+			content, err := gs.GsOverrides.ReadFile(metadataFilePath)
+			if err != nil {
+				continue // Skip files we can't read
+			}
+
+			// Parse the file to extract metadata
+			if deps, err := c.extractDependenciesFromGoFile(content); err == nil {
+				metadata.Dependencies = append(metadata.Dependencies, deps...)
+			}
+		}
+	}
+
+	return metadata, nil
+}
+
+// extractDependenciesFromGoFile parses a .go file and extracts the GsDependencies var
+func (c *Compiler) extractDependenciesFromGoFile(content []byte) ([]string, error) {
+	// Parse the Go file
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "metadata.go", content, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	var dependencies []string
+
+	// Look for var declarations
+	for _, decl := range file.Decls {
+		if genDecl, ok := decl.(*ast.GenDecl); ok && genDecl.Tok == token.VAR {
+			for _, spec := range genDecl.Specs {
+				if valueSpec, ok := spec.(*ast.ValueSpec); ok {
+					for i, name := range valueSpec.Names {
+						if name.Name == "GsDependencies" {
+							// Found the GsDependencies var, extract its value
+							if i < len(valueSpec.Values) {
+								if deps := c.extractStringSliceFromExpr(valueSpec.Values[i]); deps != nil {
+									dependencies = append(dependencies, deps...)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return dependencies, nil
+}
+
+// extractStringSliceFromExpr extracts string values from a composite literal expression
+func (c *Compiler) extractStringSliceFromExpr(expr ast.Expr) []string {
+	var result []string
+
+	if compLit, ok := expr.(*ast.CompositeLit); ok {
+		for _, elt := range compLit.Elts {
+			if basicLit, ok := elt.(*ast.BasicLit); ok && basicLit.Kind == token.STRING {
+				// Remove quotes from string literal
+				value := basicLit.Value
+				if len(value) >= 2 && value[0] == '"' && value[len(value)-1] == '"' {
+					result = append(result, value[1:len(value)-1])
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+// copyGsPackageWithDependencies copies a gs/ package and all its dependencies recursively
+// It tracks already processed packages to avoid infinite loops and duplicate work
+func (c *Compiler) copyGsPackageWithDependencies(packagePath string, processedPackages map[string]bool, result *CompilationResult) error {
+	// Check if we've already processed this package
+	if processedPackages[packagePath] {
+		return nil
+	}
+
+	// Mark this package as being processed
+	processedPackages[packagePath] = true
+
+	gsSourcePath := "gs/" + packagePath
+
+	// Check if the gs package actually exists
+	_, gsErr := gs.GsOverrides.ReadDir(gsSourcePath)
+	if gsErr != nil {
+		if os.IsNotExist(gsErr) {
+			c.le.Debugf("gs package %s does not exist, skipping", packagePath)
+			return nil
+		}
+		return gsErr
+	}
+
+	// Read metadata to get dependencies
+	metadata, err := c.ReadGsPackageMetadata(gsSourcePath)
+	if err != nil {
+		c.le.WithError(err).Warnf("Failed to read metadata for gs package %s, continuing without dependencies", packagePath)
+		metadata = &GsPackageMetadata{Dependencies: []string{}}
+	}
+
+	// Log dependencies if any are found
+	/*
+		if len(metadata.Dependencies) > 0 {
+			c.le.Debugf("Package %s has dependencies: %v", packagePath, metadata.Dependencies)
+		}
+	*/
+
+	// First, recursively process all dependencies
+	for _, depPath := range metadata.Dependencies {
+		if err := c.copyGsPackageWithDependencies(depPath, processedPackages, result); err != nil {
+			return fmt.Errorf("failed to copy dependency %s of package %s: %w", depPath, packagePath, err)
+		}
+	}
+
+	// Now copy the package itself
+	// c.le.Debugf("Copying handwritten package %s to output directory", packagePath)
+
+	// Compute output path for this package
+	outputPath := ComputeModulePath(c.config.OutputPath, packagePath)
+
+	// Create the output directory
+	if err := os.MkdirAll(outputPath, 0o755); err != nil {
+		return fmt.Errorf("failed to create output directory for %s: %w", packagePath, err)
+	}
+
+	// Copy files from embedded FS to output directory
+	if err := c.copyEmbeddedPackage(gsSourcePath, outputPath); err != nil {
+		return fmt.Errorf("failed to copy embedded package %s: %w", packagePath, err)
+	}
+
+	result.CopiedPackages = append(result.CopiedPackages, packagePath)
+	return nil
+}

package/compiler/expr-call.go

@@ -22,7 +22,7 @@ import (
 // - `make(map[K]V)` becomes `$.makeMap<K_ts, V_ts>()`.
 // - `make([]T, len, cap)` becomes `$.makeSlice<T_ts>(len, cap)`.
 // - `make([]byte, len, cap)` becomes `new Uint8Array(len)`.
-// - `string(runeVal)` becomes `String.fromCharCode(runeVal)`.
+// - `string(runeVal)` becomes `$.runeOrStringToString(runeVal)`.
 // - `string([]runeVal)` becomes `$.runesToString(sliceVal)`.
 // - `string([]byteVal)` becomes `$.bytesToString(sliceVal)`.
 // - `[]rune(stringVal)` becomes `$.stringToRunes(stringVal)“.
@@ -132,6 +132,18 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				return errors.Errorf("unhandled delete call with incorrect number of arguments: %d != 2", len(exp.Args))
 			}
 			c.tsw.WriteLiterally("$.deleteMapEntry")
+		case "copy":
+			// Translate copy(dst, src) to $.copy(dst, src)
+			if len(exp.Args) != 2 {
+				return errors.Errorf("unhandled copy call with incorrect number of arguments: %d != 2", len(exp.Args))
+			}
+			c.tsw.WriteLiterally("$.copy")
+		case "recover":
+			// Translate recover() to $.recover()
+			if len(exp.Args) != 0 {
+				return errors.Errorf("unhandled recover call with incorrect number of arguments: %d != 0", len(exp.Args))
+			}
+			c.tsw.WriteLiterally("$.recover")
 		case "make":
 			// First check if we have a channel type
 			if typ := c.pkg.TypesInfo.TypeOf(exp.Args[0]); typ != nil {
@@ -818,9 +830,9 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				if isCallExpr {
 					// Check if it's a call to rune()
 					if innerFunIdent, innerFunIsIdent := innerCall.Fun.(*ast.Ident); innerFunIsIdent && innerFunIdent.String() == "rune" {
-						// Translate string(rune(val)) to String.fromCharCode(val)
+						// Translate string(rune(val)) to $.runeOrStringToString(val)
 						if len(innerCall.Args) == 1 {
-							c.tsw.WriteLiterally("String.fromCharCode(")
+							c.tsw.WriteLiterally("$.runeOrStringToString(")
 							if err := c.WriteValueExpr(innerCall.Args[0]); err != nil {
 								return fmt.Errorf("failed to write argument for string(rune) conversion: %w", err)
 							}
@@ -843,8 +855,8 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					}
 
 					if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && (basic.Kind() == types.Int32 || basic.Kind() == types.UntypedRune) {
-						// Translate string(rune_val) to String.fromCharCode(rune_val)
-						c.tsw.WriteLiterally("String.fromCharCode(")
+						// Translate string(rune_val) to $.runeOrStringToString(rune_val)
+						c.tsw.WriteLiterally("$.runeOrStringToString(")
 						if err := c.WriteValueExpr(arg); err != nil {
 							return fmt.Errorf("failed to write argument for string(int32) conversion: %w", err)
 						}
@@ -1155,10 +1167,8 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 							// Check if the type is from an imported package
 							if typePkg := namedType.Obj().Pkg(); typePkg != nil && typePkg != c.pkg.Types {
-								pkgPath := typePkg.Path()
-								// Extract package name from path (e.g., "sync" from "github.com/.../gs/sync")
-								parts := strings.Split(pkgPath, "/")
-								pkgName := parts[len(parts)-1]
+								// Use the actual package name from the type information
+								pkgName := typePkg.Name()
 
 								// Check if this method is async based on metadata
 								if c.analysis.IsMethodAsync(pkgName, typeName, methodName) {

package/compiler/field.go

@@ -1,6 +1,9 @@
 package compiler
 
-import "go/ast"
+import (
+	"go/ast"
+	"go/types"
+)
 
 // WriteFieldList translates a Go field list (`ast.FieldList`), which can represent
 // function parameters, function results, or struct fields, into its TypeScript equivalent.
@@ -70,8 +73,19 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 
 		c.tsw.WriteLiterally(": ")
 		if ellipsis, ok := lastParam.Type.(*ast.Ellipsis); ok {
-			c.WriteTypeExpr(ellipsis.Elt)
-			c.tsw.WriteLiterally("[]")
+			// Get the actual variadic parameter type from the type checker
+			// This gives us the slice type (e.g., []interface{})
+			variadicType := c.pkg.TypesInfo.TypeOf(lastParam.Type)
+			if sliceType, isSlice := variadicType.(*types.Slice); isSlice {
+				// For variadic parameters, write the element type followed by []
+				// This handles interface{} properly by generating "any[]" instead of "null | any[]"
+				c.WriteGoType(sliceType.Elem(), GoTypeContextVariadicParam)
+				c.tsw.WriteLiterally("[]")
+			} else {
+				// Fallback to the original AST-based approach for edge cases
+				c.WriteTypeExpr(ellipsis.Elt)
+				c.tsw.WriteLiterally("[]")
+			}
 		}
 	} else {
 		// Handle regular parameter list for function declarations

package/compiler/gs_dependencies_test.go

@@ -0,0 +1,80 @@
+package compiler
+
+import (
+	"testing"
+
+	"github.com/sirupsen/logrus"
+)
+
+func TestReadGsPackageMetadata(t *testing.T) {
+	// Create a basic compiler configuration
+	config := &Config{
+		OutputPath: "./test_output",
+		Dir:        ".",
+	}
+
+	// Create a logger (set to warn level to reduce noise in tests)
+	logger := logrus.New()
+	logger.SetLevel(logrus.WarnLevel)
+	le := logrus.NewEntry(logger)
+
+	// Create a compiler
+	comp, err := NewCompiler(config, le, nil)
+	if err != nil {
+		t.Fatalf("Failed to create compiler: %v", err)
+	}
+
+	// Test reading metadata from the bytes package
+	metadata, err := comp.ReadGsPackageMetadata("gs/bytes")
+	if err != nil {
+		t.Fatalf("Failed to read metadata: %v", err)
+	}
+
+	// Check that we found the expected dependency
+	if len(metadata.Dependencies) == 0 {
+		t.Errorf("Expected at least one dependency, got none")
+	}
+
+	// Check for the specific "iter" dependency
+	foundIter := false
+	for _, dep := range metadata.Dependencies {
+		if dep == "iter" {
+			foundIter = true
+			break
+		}
+	}
+
+	if !foundIter {
+		t.Errorf("Expected to find 'iter' dependency, got dependencies: %v", metadata.Dependencies)
+	}
+}
+
+func TestReadGsPackageMetadataNonExistent(t *testing.T) {
+	// Create a basic compiler configuration
+	config := &Config{
+		OutputPath: "./test_output",
+		Dir:        ".",
+	}
+
+	// Create a logger (set to warn level to reduce noise in tests)
+	logger := logrus.New()
+	logger.SetLevel(logrus.WarnLevel)
+	le := logrus.NewEntry(logger)
+
+	// Create a compiler
+	comp, err := NewCompiler(config, le, nil)
+	if err != nil {
+		t.Fatalf("Failed to create compiler: %v", err)
+	}
+
+	// Test reading metadata from a non-existent package
+	metadata, err := comp.ReadGsPackageMetadata("gs/nonexistent")
+	if err != nil {
+		t.Fatalf("Expected no error for non-existent package, got: %v", err)
+	}
+
+	// Should return empty metadata for non-existent packages
+	if len(metadata.Dependencies) != 0 {
+		t.Errorf("Expected empty dependencies for non-existent package, got: %v", metadata.Dependencies)
+	}
+}

package/compiler/lit.go

@@ -70,14 +70,20 @@ func (c *GoToTSCompiler) WriteBasicLit(exp *ast.BasicLit) {
 
 		// Check if this is a raw string literal (starts and ends with backticks)
 		if len(value) >= 2 && value[0] == '`' && value[len(value)-1] == '`' {
-			// This is a Go raw string - need to escape invalid \x sequences for JavaScript
+			// This is a Go raw string
 			content := value[1 : len(value)-1] // Remove surrounding backticks
 
-			// Escape invalid \x, \u, and \U sequences that would cause TS1125 errors
-			content = c.escapeInvalidEscapeSequences(content)
-
-			// Write as template literal with corrected content
-			c.tsw.WriteLiterallyf("`%s`", content)
+			// Check if the raw string contains backslashes that would be problematic in template literals
+			if strings.Contains(content, `\`) {
+				// Convert to a regular string literal with proper escaping
+				c.tsw.WriteLiterallyf("%q", content)
+			} else {
+				// No backslashes, safe to use template literal
+				// Escape invalid \x, \u, and \U sequences that would cause TS1125 errors
+				content = c.escapeInvalidEscapeSequences(content)
+				// Write as template literal with corrected content
+				c.tsw.WriteLiterallyf("`%s`", content)
+			}
 		} else {
 			// Regular string literal (double quotes) - write as-is
 			c.tsw.WriteLiterally(value)

package/compiler/output.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"path/filepath"
 	"strings"
+
+	"golang.org/x/tools/go/packages"
 )
 
 // ComputeModulePath computes the root of the output typescript module.
@@ -21,10 +23,14 @@ func translateGoPathToTypescriptPath(goImportPath string) string {
 	return fmt.Sprintf("@goscript/%s", goImportPath)
 }
 
-// packageNameFromGoPath attempts to determine the package name from the last segment of the go path.
-func packageNameFromGoPath(goPkgPath string) string {
-	pts := strings.Split(goPkgPath, "/")
-	return pts[len(pts)-1]
+// getActualPackageName returns the actual Go package name from package information.
+// If the package is not found in the imports map, returns an error instead of falling back.
+// This handles cases where the package name differs from the last segment of the import path.
+func getActualPackageName(importPath string, importsMap map[string]*packages.Package) (string, error) {
+	if pkg, exists := importsMap[importPath]; exists && pkg.Name != "" {
+		return pkg.Name, nil
+	}
+	return "", fmt.Errorf("package %s not found in imports map", importPath)
 }
 
 // TranslateGoFilePathToTypescriptFilePath converts the go package path and typescript filename to output path within the typescript output dir

package/compiler/spec.go

@@ -499,7 +499,7 @@ func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.Interfac
 // It extracts the Go import path (e.g., `"path/to/pkg"`) and determines the
 // import alias/name for TypeScript. If the Go import has an explicit name
 // (e.g., `alias "path/to/pkg"`), that alias is used. Otherwise, the package
-// name is derived from the Go path.
+// name is derived from the actual Go package name, not the import path.
 //
 // The Go path is then translated to a TypeScript module path using
 // `translateGoPathToTypescriptPath`.
@@ -516,9 +516,22 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 	}
 
 	goPath := a.Path.Value[1 : len(a.Path.Value)-1]
-	impName := packageNameFromGoPath(goPath)
+
+	// Determine the import name to use in TypeScript
+	var impName string
 	if a.Name != nil && a.Name.Name != "" {
+		// Explicit alias provided: import alias "path/to/pkg"
 		impName = a.Name.Name
+	} else {
+		// No explicit alias, use the actual package name from type information
+		// This handles cases where package name differs from the last path segment
+		if actualName, err := getActualPackageName(goPath, c.pkg.Imports); err == nil {
+			impName = actualName
+		} else {
+			// Fallback to last segment of path if package not found in type information
+			pts := strings.Split(goPath, "/")
+			impName = pts[len(pts)-1]
+		}
 	}
 
 	// All Go package imports are mapped to the @goscript/ scope.