goscript 0.0.62 → 0.0.63

package/README.md

@@ -19,45 +19,42 @@ GoScript is an experimental **Go to TypeScript compiler** that translates Go cod
 
 Write once, run everywhere. Share your Go algorithms, business logic, and data structures seamlessly between your backend and frontend without maintaining two codebases.
 
-🔬 **Experimental features being developed:**
+**Use cases:**
+
 - Sharing business logic between Go services and web apps
 - Porting Go algorithms to run in browsers
 - Building TypeScript libraries from existing Go code
 
 Go has powerful concurrency support and an excellent standard library. GoScript brings these capabilities to TypeScript with as simple and readable of a translation as possible.
 
-⚠️ **Current development status:**
-GoScript is working on compiling a subset of Go:
-- ✅ Basic structs, interfaces, methods, and functions
-- ✅ Channels and goroutines (translating to async/await)
-- ✅ Slice semantics, maps, and built-in types
-- ✅ Standard control flow (if, for, switch, select, range, etc.)
-- 🚧 Basic reflection support
-- 🚧 Standard library support
+**✅ What works:**
 
-**Known limitations in this preview:**
-- Uses JavaScript `number` type (64-bit float, not Go's int types)
-- No pointer arithmetic (`uintptr`) or `unsafe` package
-- No complex numbers
-- Limited standard library (working on it)
-- Performance not yet optimized
+- Structs, interfaces, methods, and functions with full value semantics
+- Channels and goroutines (translated to async/await with function coloring)
+- Pointers and addressability (via VarRef system)
+- Slices, maps, and built-in types
+- Control flow (if, for, switch, select, range, defer, etc.)
+- Type assertions and interface implementations
+- Closures and anonymous functions
 
-**This is a prototype!** Expect bugs and missing features. Please contribute!
+**🚧 In progress:**
 
-### ⚠️ Development Preview
+- Reflection support
+- Standard library coverage
+- Generics
 
-**This project is currently in active development and should be considered experimental.** GoScript is a work-in-progress prototype that may have bugs, incomplete features, and breaking changes. We're actively iterating on the compiler and welcome your feedback!
+**Known limitations:**
 
-🐛 **Found an issue?** Please [open an issue](https://github.com/aperturerobotics/goscript/issues) and we'll fix it.
+- Uses JavaScript `number` type (64-bit float, not Go's int types)
+- No pointer arithmetic (`uintptr`) or `unsafe` package
+- No complex numbers
 
-🤖 **AI** This prototype is heavily AI-written, but I plan to manually rewrite the codebase by hand once it reaches a working state for advanced use cases. AI Producer, human Reducer.
+📖 **Learn more:** [Design document](./design/DESIGN.md) | [Architecture explainer](./docs/explainer.md) | [Compliance tests](./tests/README.md)
 
-📖 **Learn more:** [Design document](./design/DESIGN.md) | [Compliance tests](./compliance/COMPLIANCE.md)
+🐛 **Found an issue?** Please [open an issue](https://github.com/aperturerobotics/goscript/issues).
 
 ## 🚀 Try It
 
-> **Warning:** This is experimental software. Features may be incomplete or broken. Please report any issues!
-
 ### Prerequisites
 
 GoScript requires [Bun](https://bun.sh) to be installed for running compliance tests:
@@ -70,11 +67,13 @@ curl -fsSL https://bun.sh/install | bash
 ### Installation
 
 **Option 1: Go Install**
+
 ```bash
 go install github.com/aperturerobotics/goscript/cmd/goscript@latest
 ```
 
 **Option 2: NPM** (if available)
+
 ```bash
 npm install -g goscript
 ```
@@ -86,8 +85,6 @@ npm install -g goscript
 goscript compile --package . --output ./dist
 ```
 
-**Note:** Many Go packages may not compile successfully yet. Start with simple code and gradually test more complex features.
-
 ## 📦 Using Generated Code in Your Project
 
 After compiling your Go code to TypeScript, you'll need to set up your project appropriately.
@@ -116,6 +113,7 @@ Create or update your `tsconfig.json` with these settings:
 ```
 
 **Important requirements:**
+
 - **`target: "ES2022"` or newer** - Required for `Disposable` and other features
 - **`lib: ["esnext.disposable"]`** - Enables TypeScript's disposable types for resource management
 - **`baseUrl` and `paths`** - Allows TypeScript to resolve `@goscript/*` imports
@@ -132,12 +130,14 @@ goscript compile --package ./my-go-code --output ./dist
 ```
 
 **Options:**
+
 - `--package <path>` - Go package to compile (default: ".")
 - `--output <dir>` - Output directory for TypeScript files
 
 ### Programmatic API
 
 **Go:**
+
 ```go
 import "github.com/aperturerobotics/goscript/compiler"
 
@@ -147,24 +147,26 @@ _, err = comp.CompilePackages(ctx, "your/package/path")
 ```
 
 **Node.js:**
+
 ```typescript
 import { compile } from 'goscript'
 
 await compile({
   pkg: './my-go-package',
-  output: './dist'
+  output: './dist',
 })
 ```
 
 ### Frontend Frameworks
 
 **React + GoScript:**
+
 ```typescript
 import { NewCalculator } from '@goscript/myapp/calculator'
 
 function CalculatorApp() {
   const [calc] = useState(() => NewCalculator())
-  
+
   const handleAdd = () => {
     const result = calc.Add(5, 3)
     setResult(result)
@@ -175,13 +177,12 @@ function CalculatorApp() {
 ```
 
 **Vue + GoScript:**
+
 ```vue
 <script setup lang="ts">
 import { NewUser, FindUserByEmail } from '@goscript/myapp/user'
 
-const users = ref([
-  NewUser(1, "Alice", "alice@example.com")
-])
+const users = ref([NewUser(1, 'Alice', 'alice@example.com')])
 
 const searchUser = (email: string) => {
   return FindUserByEmail(users.value, email)
@@ -189,14 +190,14 @@ const searchUser = (email: string) => {
 </script>
 ```
 
-
 ## 💡 See It In Action
 
-> **Disclaimer:** These examples represent the target functionality. Your mileage may vary with the current development preview.
+See the [example/app](./example/app) for a full todo list application using GoScript with tRPC, Drizzle ORM, and React, or [example/simple](./example/simple) for a comprehensive demo of language features.
 
 ### Example: User Management
 
 **Go Code** (`user.go`):
+
 ```go
 package main
 
@@ -225,20 +226,22 @@ func FindUserByEmail(users []*User, email string) *User {
 ```
 
 **Compile it:**
+
 ```bash
 goscript compile --package . --output ./dist
 ```
 
 **Generated TypeScript** (`user.gs.ts`):
+
 ```typescript
 export class User {
   public ID: number = 0
-  public Name: string = ""
-  public Email: string = ""
+  public Name: string = ''
+  public Email: string = ''
 
   public IsValid(): boolean {
     const u = this
-    return u.Name !== "" && u.Email !== ""
+    return u.Name !== '' && u.Email !== ''
   }
 
   constructor(init?: Partial<User>) {
@@ -261,26 +264,28 @@ export function FindUserByEmail(users: User[], email: string): User | null {
 ```
 
 **Use in your frontend:**
+
 ```typescript
 import { NewUser, FindUserByEmail } from '@goscript/myapp/user'
 
 // Same logic, now in TypeScript!
 const users = [
-  NewUser(1, "Alice", "alice@example.com"),
-  NewUser(2, "Bob", "bob@example.com")
+  NewUser(1, 'Alice', 'alice@example.com'),
+  NewUser(2, 'Bob', 'bob@example.com'),
 ]
 
-const alice = FindUserByEmail(users, "alice@example.com")
+const alice = FindUserByEmail(users, 'alice@example.com')
 console.log(alice?.IsValid()) // true
 ```
 
 ### Example: Async Processing with Channels
 
 **Go Code:**
+
 ```go
 func ProcessMessages(messages []string) chan string {
     results := make(chan string, len(messages))
-    
+
     for _, msg := range messages {
         go func(m string) {
             // Simulate processing
@@ -288,34 +293,36 @@ func ProcessMessages(messages []string) chan string {
             results <- processed
         }(msg)
     }
-    
+
     return results
 }
 ```
 
 **Generated TypeScript:**
+
 ```typescript
 export function ProcessMessages(messages: string[]): $.Channel<string> {
-  let results = $.makeChannel<string>(messages.length, "")
-  
+  let results = $.makeChannel<string>(messages.length, '')
+
   for (let msg of messages) {
     queueMicrotask(async (m: string) => {
-      let processed = "✓ " + m
+      let processed = '✓ ' + m
       await results.send(processed)
     })(msg)
   }
-  
+
   return results
 }
 ```
 
 **Use with async/await:**
+
 ```typescript
 import { ProcessMessages } from '@goscript/myapp/processor'
 
 async function handleMessages() {
-  const channel = ProcessMessages(["hello", "world", "goscript"])
-  
+  const channel = ProcessMessages(['hello', 'world', 'goscript'])
+
   // Receive processed messages
   for (let i = 0; i < 3; i++) {
     const result = await channel.receive()
@@ -327,7 +334,7 @@ async function handleMessages() {
 ## 🤝 How You Can Help
 
 - Try GoScript on your code and [report issues](https://github.com/aperturerobotics/goscript/issues)
-- Check the [compliance tests](./compliance/COMPLIANCE.md) for current progress
+- Check the [compliance tests](./tests/README.md) for current progress
 - Contribute test cases for edge cases you discover
 
 ## License

package/compiler/analysis.go

@@ -126,10 +126,6 @@ type Analysis struct {
 	// Imports stores the imports for the file
 	Imports map[string]*fileImport
 
-	// SyntheticImports stores imports that need to be written but were not in the source file.
-	// These are typically needed for promoted methods from embedded structs.
-	SyntheticImports map[string]*fileImport
-
 	// Cmap stores the comment map for the file
 	Cmap ast.CommentMap
 
@@ -169,6 +165,16 @@ type Analysis struct {
 	// MethodAsyncStatus stores the async status of all methods analyzed
 	// This is computed once during analysis and reused during code generation
 	MethodAsyncStatus map[MethodKey]bool
+
+	// ReferencedTypesPerFile tracks which named types are referenced in each file.
+	// This is used to filter synthetic imports to only include packages needed
+	// by types actually used in each specific file, not all types in the package.
+	// Key: file path, Value: set of named types referenced in that file
+	ReferencedTypesPerFile map[string]map[*types.Named]bool
+
+	// SyntheticImportsPerFile stores synthetic imports needed per file.
+	// Key: file path, Value: map of package name to import info
+	SyntheticImportsPerFile map[string]map[string]*fileImport
 }
 
 // PackageAnalysis holds cross-file analysis data for a package
@@ -205,19 +211,20 @@ func NewAnalysis(allPackages map[string]*packages.Package) *Analysis {
 	}
 
 	return &Analysis{
-		VariableUsage:        make(map[types.Object]*VariableUsageInfo),
-		Imports:              make(map[string]*fileImport),
-		SyntheticImports:     make(map[string]*fileImport),
-		FunctionData:         make(map[types.Object]*FunctionInfo),
-		NodeData:             make(map[ast.Node]*NodeInfo),
-		FuncLitData:          make(map[*ast.FuncLit]*FunctionInfo),
-		ReflectedFunctions:   make(map[ast.Node]*ReflectedFunctionInfo),
-		FunctionAssignments:  make(map[types.Object]ast.Node),
-		AsyncReturningVars:   make(map[types.Object]bool),
-		NamedBasicTypes:      make(map[types.Type]bool),
-		AllPackages:          allPackages,
-		InterfaceImplementations: make(map[InterfaceMethodKey][]ImplementationInfo),
-		MethodAsyncStatus:        make(map[MethodKey]bool),
+		VariableUsage:            make(map[types.Object]*VariableUsageInfo),
+		Imports:                  make(map[string]*fileImport),
+		FunctionData:             make(map[types.Object]*FunctionInfo),
+		NodeData:                 make(map[ast.Node]*NodeInfo),
+		FuncLitData:              make(map[*ast.FuncLit]*FunctionInfo),
+		ReflectedFunctions:       make(map[ast.Node]*ReflectedFunctionInfo),
+		FunctionAssignments:      make(map[types.Object]ast.Node),
+		AsyncReturningVars:       make(map[types.Object]bool),
+		NamedBasicTypes:          make(map[types.Type]bool),
+		AllPackages:              allPackages,
+		InterfaceImplementations:  make(map[InterfaceMethodKey][]ImplementationInfo),
+		MethodAsyncStatus:         make(map[MethodKey]bool),
+		ReferencedTypesPerFile:    make(map[string]map[*types.Named]bool),
+		SyntheticImportsPerFile:   make(map[string]map[string]*fileImport),
 	}
 }
 
@@ -492,6 +499,10 @@ type analysisVisitor struct {
 
 	// currentFuncLit tracks the *ast.FuncLit of the function literal we're currently analyzing.
 	currentFuncLit *ast.FuncLit
+
+	// currentFilePath tracks the file path of the file we're currently analyzing.
+	// This is used to track which types are referenced in each file.
+	currentFilePath string
 }
 
 // getOrCreateUsageInfo retrieves or creates the VariableUsageInfo for a given object.
@@ -524,6 +535,18 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		if n.Tok == token.VAR {
 			for _, spec := range n.Specs {
 				if valueSpec, ok := spec.(*ast.ValueSpec); ok {
+					// Track type references from variable declarations for synthetic import filtering
+					if valueSpec.Type != nil {
+						if t := v.pkg.TypesInfo.TypeOf(valueSpec.Type); t != nil {
+							v.trackTypeReference(t)
+						}
+					}
+					for _, name := range valueSpec.Names {
+						if obj := v.pkg.TypesInfo.ObjectOf(name); obj != nil {
+							v.trackTypeReference(obj.Type())
+						}
+					}
+
 					// Process each declared variable (LHS)
 					for i, lhsIdent := range valueSpec.Names {
 						if lhsIdent.Name == "_" {
@@ -813,9 +836,30 @@ func (v *analysisVisitor) visitCallExpr(n *ast.CallExpr) ast.Visitor {
 	// Check for implicit address-taking in method calls with pointer receivers
 	v.checkImplicitAddressTaking(n)
 
+	// Check for address-of expressions in function arguments
+	v.checkAddressOfInArguments(n)
+
 	return v
 }
 
+// checkAddressOfInArguments detects when &variable is passed as a function argument.
+// Example: json.Unmarshal(data, &person) where person needs to be marked as NeedsVarRef
+func (v *analysisVisitor) checkAddressOfInArguments(callExpr *ast.CallExpr) {
+	for _, arg := range callExpr.Args {
+		if unaryExpr, ok := arg.(*ast.UnaryExpr); ok && unaryExpr.Op == token.AND {
+			if ident, ok := unaryExpr.X.(*ast.Ident); ok {
+				if obj := v.pkg.TypesInfo.ObjectOf(ident); obj != nil {
+					usageInfo := v.getOrCreateUsageInfo(obj)
+					usageInfo.Destinations = append(usageInfo.Destinations, AssignmentInfo{
+						Object: nil,
+						Type:   AddressOfAssignment,
+					})
+				}
+			}
+		}
+	}
+}
+
 // checkImplicitAddressTaking detects when a method call with a pointer receiver
 // is called on a non-pointer variable, which requires implicit address-taking.
 // Example: var s MySlice; s.Add(10) where Add has receiver *MySlice
@@ -1027,12 +1071,28 @@ func (v *analysisVisitor) visitDeclStmt(n *ast.DeclStmt) ast.Visitor {
 		// Check if we're inside a function (either FuncDecl or FuncLit)
 		isInsideFunction := v.currentFuncDecl != nil || v.currentFuncLit != nil
 
-		if isInsideFunction {
-			// Mark all specs in this declaration as being inside a function
-			for _, spec := range genDecl.Specs {
+		for _, spec := range genDecl.Specs {
+			if isInsideFunction {
+				// Mark all specs in this declaration as being inside a function
 				nodeInfo := v.analysis.ensureNodeData(spec)
 				nodeInfo.IsInsideFunction = true
 			}
+
+			// Track type references from variable declarations (e.g., var w MyWriter)
+			if valueSpec, ok := spec.(*ast.ValueSpec); ok {
+				// Track explicit type if present
+				if valueSpec.Type != nil {
+					if t := v.pkg.TypesInfo.TypeOf(valueSpec.Type); t != nil {
+						v.trackTypeReference(t)
+					}
+				}
+				// Also track types inferred from values
+				for _, name := range valueSpec.Names {
+					if obj := v.pkg.TypesInfo.ObjectOf(name); obj != nil {
+						v.trackTypeReference(obj.Type())
+					}
+				}
+			}
 		}
 	}
 	return v
@@ -1061,6 +1121,9 @@ func (v *analysisVisitor) visitTypeAssertExpr(typeAssert *ast.TypeAssertExpr) as
 		return v
 	}
 
+	// Track the asserted type for synthetic import filtering
+	v.trackTypeReference(assertedType)
+
 	// Check if the asserted type is an interface
 	interfaceType, isInterface := assertedType.Underlying().(*types.Interface)
 	if !isInterface {
@@ -1098,10 +1161,36 @@ func (v *analysisVisitor) visitTypeAssertExpr(typeAssert *ast.TypeAssertExpr) as
 	return v
 }
 
+// trackTypeReference records that a named type is referenced in the current file.
+// This is used to filter synthetic imports to only include packages actually needed.
+func (v *analysisVisitor) trackTypeReference(t types.Type) {
+	if t == nil || v.currentFilePath == "" {
+		return
+	}
+	// Unwrap pointers
+	if ptr, ok := t.(*types.Pointer); ok {
+		t = ptr.Elem()
+	}
+	// Track named types per file
+	if named, ok := t.(*types.Named); ok {
+		if v.analysis.ReferencedTypesPerFile[v.currentFilePath] == nil {
+			v.analysis.ReferencedTypesPerFile[v.currentFilePath] = make(map[*types.Named]bool)
+		}
+		v.analysis.ReferencedTypesPerFile[v.currentFilePath][named] = true
+	}
+}
+
 // visitCompositeLit analyzes composite literals for address-of expressions
 // This is important for detecting cases like: arr := []interface{}{value1, &value2}
 // where value2 needs to be marked as NeedsVarRef due to the &value2 usage
 func (v *analysisVisitor) visitCompositeLit(compLit *ast.CompositeLit) ast.Visitor {
+	// Track the type of this composite literal for synthetic import filtering
+	if compLit.Type != nil {
+		if t := v.pkg.TypesInfo.TypeOf(compLit.Type); t != nil {
+			v.trackTypeReference(t)
+		}
+	}
+
 	// Analyze each element of the composite literal
 	for _, elt := range compLit.Elts {
 		// Handle both direct elements and key-value pairs
@@ -1261,7 +1350,11 @@ func AnalyzePackageFiles(pkg *packages.Package, allPackages map[string]*packages
 	}
 
 	// First pass: analyze all declarations and statements across all files
-	for _, file := range pkg.Syntax {
+	for i, file := range pkg.Syntax {
+		// Set the current file path for per-file type tracking
+		if i < len(pkg.CompiledGoFiles) {
+			visitor.currentFilePath = pkg.CompiledGoFiles[i]
+		}
 		ast.Walk(visitor, file)
 	}
 
@@ -1300,105 +1393,93 @@ func AnalyzePackageFiles(pkg *packages.Package, allPackages map[string]*packages
 	return analysis
 }
 
-// addImportsForPromotedMethods scans all struct types in the package for embedded fields
+// addImportsForPromotedMethods scans struct types that are actually referenced in each file
 // and adds imports for any packages referenced by the promoted methods' parameter/return types.
+// This generates per-file synthetic imports to avoid adding unused imports.
 func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
-	// Collect all package names we need to add
-	packagesToAdd := make(map[string]*types.Package)
-
-	// Iterate through all type definitions in the package
-	scope := pkg.Types.Scope()
-	for _, name := range scope.Names() {
-		obj := scope.Lookup(name)
-		if obj == nil {
-			continue
-		}
-
-		// Check if it's a type definition
-		typeName, ok := obj.(*types.TypeName)
-		if !ok {
-			continue
-		}
-
-		// Get the underlying type
-		namedType, ok := typeName.Type().(*types.Named)
-		if !ok {
-			continue
-		}
-
-		// Check if it's a struct
-		structType, ok := namedType.Underlying().(*types.Struct)
-		if !ok {
-			continue
-		}
-
-		// Look for embedded fields
-		for i := 0; i < structType.NumFields(); i++ {
-			field := structType.Field(i)
-			if !field.Embedded() {
+	// Process each file's referenced types separately
+	for filePath, referencedTypes := range a.ReferencedTypesPerFile {
+		// Collect package imports needed for this specific file
+		packagesToAdd := make(map[string]*types.Package)
+
+		// Only process types that are actually referenced in this file
+		// and are defined in the current package
+		for namedType := range referencedTypes {
+			// Skip types from other packages - we only need to process types defined in this package
+			if namedType.Obj().Pkg() != pkg.Types {
 				continue
 			}
 
-			// Get the type of the embedded field
-			embeddedType := field.Type()
-
-			// Handle pointer to embedded type
-			if ptr, ok := embeddedType.(*types.Pointer); ok {
-				embeddedType = ptr.Elem()
+			// Check if it's a struct
+			structType, ok := namedType.Underlying().(*types.Struct)
+			if !ok {
+				continue
 			}
 
-			// Use method set to get all promoted methods including pointer receiver methods
-			// This matches Go's behavior where embedding T promotes both T and *T methods
-			methodSetType := embeddedType
-			if _, isPtr := embeddedType.(*types.Pointer); !isPtr {
-				if _, isInterface := embeddedType.Underlying().(*types.Interface); !isInterface {
-					methodSetType = types.NewPointer(embeddedType)
+			// Look for embedded fields
+			for i := 0; i < structType.NumFields(); i++ {
+				field := structType.Field(i)
+				if !field.Embedded() {
+					continue
 				}
-			}
-			embeddedMethodSet := types.NewMethodSet(methodSetType)
 
-			// Scan all methods in the method set
-			for j := 0; j < embeddedMethodSet.Len(); j++ {
-				selection := embeddedMethodSet.At(j)
-				method := selection.Obj()
-				sig, ok := method.Type().(*types.Signature)
-				if !ok {
-					continue
+				// Get the type of the embedded field
+				embeddedType := field.Type()
+
+				// Handle pointer to embedded type
+				if ptr, ok := embeddedType.(*types.Pointer); ok {
+					embeddedType = ptr.Elem()
 				}
 
-				// Scan parameters
-				if sig.Params() != nil {
-					for k := 0; k < sig.Params().Len(); k++ {
-						param := sig.Params().At(k)
-						a.collectPackageFromType(param.Type(), pkg.Types, packagesToAdd)
+				// Use method set to get all promoted methods including pointer receiver methods
+				// This matches Go's behavior where embedding T promotes both T and *T methods
+				methodSetType := embeddedType
+				if _, isPtr := embeddedType.(*types.Pointer); !isPtr {
+					if _, isInterface := embeddedType.Underlying().(*types.Interface); !isInterface {
+						methodSetType = types.NewPointer(embeddedType)
 					}
 				}
+				embeddedMethodSet := types.NewMethodSet(methodSetType)
+
+				// Scan all methods in the method set
+				for j := 0; j < embeddedMethodSet.Len(); j++ {
+					selection := embeddedMethodSet.At(j)
+					method := selection.Obj()
+					sig, ok := method.Type().(*types.Signature)
+					if !ok {
+						continue
+					}
 
-				// Scan results
-				if sig.Results() != nil {
-					for k := 0; k < sig.Results().Len(); k++ {
-						result := sig.Results().At(k)
-						a.collectPackageFromType(result.Type(), pkg.Types, packagesToAdd)
+					// Scan parameters
+					if sig.Params() != nil {
+						for k := 0; k < sig.Params().Len(); k++ {
+							param := sig.Params().At(k)
+							a.collectPackageFromType(param.Type(), pkg.Types, packagesToAdd)
+						}
+					}
+
+					// Scan results
+					if sig.Results() != nil {
+						for k := 0; k < sig.Results().Len(); k++ {
+							result := sig.Results().At(k)
+							a.collectPackageFromType(result.Type(), pkg.Types, packagesToAdd)
+						}
 					}
 				}
 			}
 		}
-	}
 
-	// Add collected packages to imports (both regular and synthetic)
-	// Always add to SyntheticImports - the file compiler will check if
-	// the import was already written from the AST to avoid duplicates
-	for pkgName, pkgObj := range packagesToAdd {
-		tsImportPath := "@goscript/" + pkgObj.Path()
-		fileImp := &fileImport{
-			importPath: tsImportPath,
-			importVars: make(map[string]struct{}),
-		}
-		// Add to SyntheticImports unconditionally
-		a.SyntheticImports[pkgName] = fileImp
-		// Also add to Imports if not already present
-		if _, exists := a.Imports[pkgName]; !exists {
-			a.Imports[pkgName] = fileImp
+		// Store the synthetic imports for this file
+		if len(packagesToAdd) > 0 {
+			fileImports := make(map[string]*fileImport)
+			for pkgName, pkgObj := range packagesToAdd {
+				tsImportPath := "@goscript/" + pkgObj.Path()
+				fileImports[pkgName] = &fileImport{
+					importPath: tsImportPath,
+					importVars: make(map[string]struct{}),
+				}
+			}
+			a.SyntheticImportsPerFile[filePath] = fileImports
 		}
 	}
 }