goscript 0.0.75 → 0.0.77

package/cmd/goscript/main.js

@@ -7,24 +7,60 @@ import { dirname } from 'node:path';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-// Go up two levels from cmd/goscript/ to the project root
+// Go up two levels from cmd/goscript/ to the goscript module root
 const projectRoot = path.join(__dirname, '..', '..');
 
+// The user's working directory (where they invoked the command)
+const userCwd = process.cwd();
+
 // Get arguments passed to the script, excluding node executable and script path
 const args = process.argv.slice(2);
 
-// Construct the go run command with the absolute path to the goscript executable
-// Use path.join for robustness
-const goscriptCmd = `go run ./cmd/goscript`;
+// Resolve --output and --dir paths relative to the user's cwd, since the
+// go run process executes from the goscript module root, not the user's project.
+const resolvedArgs = [];
+let hasDir = false;
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === '--dir') {
+    hasDir = true;
+    resolvedArgs.push(arg);
+    if (i + 1 < args.length) {
+      i++;
+      resolvedArgs.push(path.resolve(userCwd, args[i]));
+    }
+  } else if (arg.startsWith('--dir=')) {
+    hasDir = true;
+    const val = arg.slice('--dir='.length);
+    resolvedArgs.push('--dir=' + path.resolve(userCwd, val));
+  } else if (arg === '--output' || arg === '-o') {
+    resolvedArgs.push(arg);
+    if (i + 1 < args.length) {
+      i++;
+      resolvedArgs.push(path.resolve(userCwd, args[i]));
+    }
+  } else if (arg.startsWith('--output=')) {
+    const val = arg.slice('--output='.length);
+    resolvedArgs.push('--output=' + path.resolve(userCwd, val));
+  } else {
+    resolvedArgs.push(arg);
+  }
+}
+
+// Inject --dir with user's cwd if not explicitly provided, so the compiler
+// loads packages from the user's project instead of the goscript module root.
+if (!hasDir) {
+  resolvedArgs.push('--dir', userCwd);
+}
 
-// Combine the goscript command with the arguments
-const command = `${goscriptCmd} ${args.join(" ")}`;
+// Build the command: go run from the goscript module root
+const command = `go run ./cmd/goscript ${resolvedArgs.join(' ')}`;
 
-// Execute the command
+// Execute from the goscript module root so Go can resolve the module
 const child = spawn(command, {
-  shell: true, // Use shell to correctly parse the command string
-  stdio: 'inherit', // Inherit stdin, stdout, and stderr
-  cwd: projectRoot, // Execute in the current working directory where the script is run
+  shell: true,
+  stdio: 'inherit',
+  cwd: projectRoot,
 });
 
 child.on('error', (error) => {
@@ -33,5 +69,5 @@ child.on('error', (error) => {
 });
 
 child.on('exit', (code) => {
-  process.exit(code ?? 0); // Exit with the child process's exit code
-});
+  process.exit(code ?? 0);
+});

package/compiler/analysis.go

@@ -240,6 +240,53 @@ func NewPackageAnalysis() *PackageAnalysis {
 	}
 }
 
+// collectZeroValueTypeNames records named struct types whose zero value emits a
+// runtime constructor call.
+func collectZeroValueTypeNames(typ types.Type, names map[string]struct{}) {
+	switch t := typ.(type) {
+	case *types.Array:
+		collectZeroValueTypeNames(t.Elem(), names)
+	case *types.Named:
+		if _, isStruct := t.Underlying().(*types.Struct); isStruct {
+			names[t.Obj().Name()] = struct{}{}
+			return
+		}
+		collectZeroValueTypeNames(t.Underlying(), names)
+	case *types.Alias:
+		collectZeroValueTypeNames(t.Underlying(), names)
+	}
+}
+
+// addTypeRefsFromZeroValue adds same-package type imports needed when code
+// generation synthesizes a zero value without an explicit AST type reference.
+func addTypeRefsFromZeroValue(analysis *PackageAnalysis, currentFileName string, typ types.Type, refs map[string][]string) {
+	typeNames := make(map[string]struct{})
+	collectZeroValueTypeNames(typ, typeNames)
+	if len(typeNames) == 0 {
+		return
+	}
+
+	currentFileTypes := analysis.TypeDefs[currentFileName]
+	for typeName := range typeNames {
+		if slices.Contains(currentFileTypes, typeName) {
+			continue
+		}
+
+		for sourceFile, types := range analysis.TypeDefs {
+			if sourceFile == currentFileName || !slices.Contains(types, typeName) {
+				continue
+			}
+
+			if refs[sourceFile] == nil {
+				refs[sourceFile] = []string{}
+			}
+			if !slices.Contains(refs[sourceFile], typeName) {
+				refs[sourceFile] = append(refs[sourceFile], typeName)
+			}
+		}
+	}
+}
+
 // ensureNodeData ensures that NodeData exists for a given node and returns it
 func (a *Analysis) ensureNodeData(node ast.Node) *NodeInfo {
 	if node == nil {
@@ -1148,8 +1195,7 @@ func (v *analysisVisitor) visitTypeAssertExpr(typeAssert *ast.TypeAssertExpr) as
 	}
 
 	// For each method in the interface, check if the struct implements it
-	for i := 0; i < interfaceType.NumExplicitMethods(); i++ {
-		interfaceMethod := interfaceType.ExplicitMethod(i)
+	for interfaceMethod := range interfaceType.ExplicitMethods() {
 
 		// Find the corresponding method in the struct type
 		structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
@@ -1417,8 +1463,7 @@ func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
 			}
 
 			// Look for embedded fields
-			for i := 0; i < structType.NumFields(); i++ {
-				field := structType.Field(i)
+			for field := range structType.Fields() {
 				if !field.Embedded() {
 					continue
 				}
@@ -1442,8 +1487,7 @@ func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
 				embeddedMethodSet := types.NewMethodSet(methodSetType)
 
 				// Scan all methods in the method set
-				for j := 0; j < embeddedMethodSet.Len(); j++ {
-					selection := embeddedMethodSet.At(j)
+				for selection := range embeddedMethodSet.Methods() {
 					method := selection.Obj()
 					sig, ok := method.Type().(*types.Signature)
 					if !ok {
@@ -1452,16 +1496,14 @@ func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
 
 					// Scan parameters
 					if sig.Params() != nil {
-						for k := 0; k < sig.Params().Len(); k++ {
-							param := sig.Params().At(k)
+						for param := range sig.Params().Variables() {
 							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)
+						for result := range sig.Results().Variables() {
 							a.collectPackageFromType(result.Type(), pkg.Types, packagesToAdd)
 						}
 					}
@@ -1494,17 +1536,16 @@ func (a *Analysis) collectPackageFromType(t types.Type, currentPkg *types.Packag
 		}
 		// Check type arguments for generics
 		if typ.TypeArgs() != nil {
-			for i := 0; i < typ.TypeArgs().Len(); i++ {
-				a.collectPackageFromType(typ.TypeArgs().At(i), currentPkg, packagesToAdd)
+			for t := range typ.TypeArgs().Types() {
+				a.collectPackageFromType(t, currentPkg, packagesToAdd)
 			}
 		}
 	case *types.Interface:
 		// For interfaces, we need to check embedded interfaces and method signatures
-		for i := 0; i < typ.NumEmbeddeds(); i++ {
-			a.collectPackageFromType(typ.EmbeddedType(i), currentPkg, packagesToAdd)
+		for etyp := range typ.EmbeddedTypes() {
+			a.collectPackageFromType(etyp, currentPkg, packagesToAdd)
 		}
-		for i := 0; i < typ.NumExplicitMethods(); i++ {
-			method := typ.ExplicitMethod(i)
+		for method := range typ.ExplicitMethods() {
 			a.collectPackageFromType(method.Type(), currentPkg, packagesToAdd)
 		}
 	case *types.Pointer:
@@ -1521,14 +1562,14 @@ func (a *Analysis) collectPackageFromType(t types.Type, currentPkg *types.Packag
 	case *types.Signature:
 		// Collect from parameters
 		if typ.Params() != nil {
-			for i := 0; i < typ.Params().Len(); i++ {
-				a.collectPackageFromType(typ.Params().At(i).Type(), currentPkg, packagesToAdd)
+			for v := range typ.Params().Variables() {
+				a.collectPackageFromType(v.Type(), currentPkg, packagesToAdd)
 			}
 		}
 		// Collect from results
 		if typ.Results() != nil {
-			for i := 0; i < typ.Results().Len(); i++ {
-				a.collectPackageFromType(typ.Results().At(i).Type(), currentPkg, packagesToAdd)
+			for v := range typ.Results().Variables() {
+				a.collectPackageFromType(v.Type(), currentPkg, packagesToAdd)
 			}
 		}
 	}
@@ -1693,6 +1734,37 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 					}
 				}
 			}
+
+			if callExpr, ok := n.(*ast.CallExpr); ok {
+				if funIdent, ok := callExpr.Fun.(*ast.Ident); ok && funIdent.Name == "make" && len(callExpr.Args) > 0 {
+					if typ := pkg.TypesInfo.TypeOf(callExpr.Args[0]); typ != nil {
+						if chanType, ok := typ.Underlying().(*types.Chan); ok {
+							addTypeRefsFromZeroValue(analysis, baseFileName, chanType.Elem(), typeRefsFromOtherFiles)
+						}
+					}
+				}
+			}
+
+			if indexExpr, ok := n.(*ast.IndexExpr); ok {
+				if tv, ok := pkg.TypesInfo.Types[indexExpr.X]; ok {
+					if mapType, ok := tv.Type.Underlying().(*types.Map); ok {
+						addTypeRefsFromZeroValue(analysis, baseFileName, mapType.Elem(), typeRefsFromOtherFiles)
+						return true
+					}
+
+					if typeParam, ok := tv.Type.(*types.TypeParam); ok {
+						constraint := typeParam.Constraint()
+						if constraint == nil {
+							return true
+						}
+						if iface, ok := constraint.Underlying().(*types.Interface); ok && hasMapConstraint(iface) {
+							if mapValueType := getMapValueTypeFromConstraint(iface); mapValueType != nil {
+								addTypeRefsFromZeroValue(analysis, baseFileName, mapValueType, typeRefsFromOtherFiles)
+							}
+						}
+					}
+				}
+			}
 			return true
 		})
 
@@ -1830,8 +1902,8 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 			// Check if this type has the method being called
 			methodName := selectorExpr.Sel.Name
 			found := false
-			for j := 0; j < namedType.NumMethods(); j++ {
-				if namedType.Method(j).Name() == methodName {
+			for method := range namedType.Methods() {
+				if method.Name() == methodName {
 					found = true
 					break
 				}
@@ -2351,8 +2423,7 @@ func (a *Analysis) GetIdentifierMapping(ident *ast.Ident) string {
 // findStructMethod finds a method with the given name on a named type
 func (v *analysisVisitor) findStructMethod(namedType *types.Named, methodName string) *types.Func {
 	// Check methods directly on the type
-	for i := 0; i < namedType.NumMethods(); i++ {
-		method := namedType.Method(i)
+	for method := range namedType.Methods() {
 		if method.Name() == methodName {
 			return method
 		}
@@ -2455,8 +2526,7 @@ func (v *analysisVisitor) trackInterfaceAssignments(assignStmt *ast.AssignStmt)
 		}
 
 		// Track implementations for all interface methods
-		for j := 0; j < interfaceType.NumExplicitMethods(); j++ {
-			interfaceMethod := interfaceType.ExplicitMethod(j)
+		for interfaceMethod := range interfaceType.ExplicitMethods() {
 
 			structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
 			if structMethod != nil {
@@ -2514,8 +2584,7 @@ func (v *analysisVisitor) trackInterfaceCallArguments(callExpr *ast.CallExpr) {
 		}
 
 		// Track implementations for all interface methods
-		for j := 0; j < interfaceType.NumExplicitMethods(); j++ {
-			interfaceMethod := interfaceType.ExplicitMethod(j)
+		for interfaceMethod := range interfaceType.ExplicitMethods() {
 
 			structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
 			if structMethod != nil {
@@ -2659,8 +2728,7 @@ func (v *interfaceImplementationVisitor) findImplementationsInPackage(interfaceT
 // trackImplementation records that a named type implements an interface
 func (v *interfaceImplementationVisitor) trackImplementation(interfaceType *types.Interface, namedType *types.Named) {
 	// For each method in the interface, find the corresponding implementation
-	for i := 0; i < interfaceType.NumExplicitMethods(); i++ {
-		interfaceMethod := interfaceType.ExplicitMethod(i)
+	for interfaceMethod := range interfaceType.ExplicitMethods() {
 
 		// Find the method in the implementing type
 		structMethod := v.findMethodInType(namedType, interfaceMethod.Name())
@@ -2672,8 +2740,7 @@ func (v *interfaceImplementationVisitor) trackImplementation(interfaceType *type
 
 // findMethodInType finds a method with the given name in a named type
 func (v *interfaceImplementationVisitor) findMethodInType(namedType *types.Named, methodName string) *types.Func {
-	for i := 0; i < namedType.NumMethods(); i++ {
-		method := namedType.Method(i)
+	for method := range namedType.Methods() {
 		if method.Name() == methodName {
 			return method
 		}
@@ -2696,7 +2763,7 @@ func (v *analysisVisitor) analyzeAllMethodsAsync() {
 	// We need to iterate multiple times because methods in cycles can call each other,
 	// and we need to propagate async status until no changes occur
 	maxIterations := 10
-	for iteration := 0; iteration < maxIterations; iteration++ {
+	for range maxIterations {
 		changed := false
 
 		for _, methodKey := range cycles {

package/compiler/analysis_test.go

@@ -6,6 +6,7 @@ import (
 	"go/token"
 	"go/types"
 	"os"
+	"slices"
 	"testing"
 
 	"golang.org/x/tools/go/packages"
@@ -329,13 +330,7 @@ func TestDiscoverGsPackages(t *testing.T) {
 	// Check for some known packages that should exist
 	expectedPackages := []string{"sync", "bytes", "strings"}
 	for _, expected := range expectedPackages {
-		found := false
-		for _, pkg := range packages {
-			if pkg == expected {
-				found = true
-				break
-			}
-		}
+		found := slices.Contains(packages, expected)
 		if !found {
 			t.Logf("Expected package '%s' not found in discovered packages: %v", expected, packages)
 		}

package/compiler/assignment.go

@@ -396,7 +396,37 @@ func (c *GoToTSCompiler) writeBlankIdentifierAssign(rhs ast.Expr) error {
 
 // writePointerDerefAssign handles assignments to dereferenced pointers (*p = val)
 func (c *GoToTSCompiler) writePointerDerefAssign(starExpr *ast.StarExpr, rhs ast.Expr, tok token.Token) error {
-	// Write pointer dereference
+	// Check if RHS is a struct - if so, use $.assignStruct() to copy fields
+	if shouldApplyClone(c.pkg, rhs) {
+		// For struct assignments, use $.assignStruct(target, source)
+		// This copies all fields from source to target
+		c.tsw.WriteLiterally("$.assignStruct(")
+
+		// Write the pointer as the target
+		if ident, ok := starExpr.X.(*ast.Ident); ok {
+			obj := c.objectOfIdent(ident)
+			if obj != nil && c.analysis.NeedsVarRef(obj) {
+				c.WriteIdent(ident, true)
+			} else {
+				c.WriteIdent(ident, false)
+			}
+		} else {
+			if err := c.WriteValueExpr(starExpr.X); err != nil {
+				return err
+			}
+		}
+		c.tsw.WriteLiterally("!, ")
+
+		// Write the RHS with clone as the source
+		c.tsw.WriteLiterally("$.markAsStructValue(")
+		if err := c.WriteValueExpr(rhs); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(".clone()))")
+		return nil
+	}
+
+	// For non-struct types, use the original p!.value = val approach
 	if ident, ok := starExpr.X.(*ast.Ident); ok {
 		obj := c.objectOfIdent(ident)
 		if obj != nil && c.analysis.NeedsVarRef(obj) {
@@ -426,17 +456,9 @@ func (c *GoToTSCompiler) writePointerDerefAssign(starExpr *ast.StarExpr, rhs ast
 		c.tsw.WriteLiterally(" ")
 	}
 
-	// Write RHS with cloning if needed
-	if shouldApplyClone(c.pkg, rhs) {
-		c.tsw.WriteLiterally("$.markAsStructValue(")
-		if err := c.WriteValueExpr(rhs); err != nil {
-			return err
-		}
-		c.tsw.WriteLiterally(".clone())")
-	} else {
-		if err := c.WriteValueExpr(rhs); err != nil {
-			return err
-		}
+	// Write RHS
+	if err := c.WriteValueExpr(rhs); err != nil {
+		return err
 	}
 
 	if tok == token.AND_NOT_ASSIGN {

package/compiler/code-writer.go

@@ -59,8 +59,8 @@ func (w *TSCodeWriter) WriteImport(symbolName, importPath string) {
 
 // WriteCommentLine writes a comment as a // line.
 func (w *TSCodeWriter) WriteCommentLine(commentText string) {
-	lines := strings.Split(commentText, "\n")
-	for _, line := range lines {
+	lines := strings.SplitSeq(commentText, "\n")
+	for line := range lines {
 		w.WriteLinef("// %s", line)
 	}
 }

package/compiler/compiler.go

@@ -414,9 +414,9 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 
 		// Check if this is a .pb.go file that should be skipped
 		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"
 			packageDir := filepath.Dir(fileName)
 			pbTsPath := filepath.Join(packageDir, pbTsFileName)
 
@@ -1131,10 +1131,10 @@ func (c *GoToTSCompiler) WriteDoc(doc *ast.CommentGroup) {
 		// Preserve original comment style (// or /*)
 		if strings.HasPrefix(comment.Text, "//") {
 			c.tsw.WriteLine(comment.Text)
-		} else if strings.HasPrefix(comment.Text, "/*") {
+		} else if after, ok := strings.CutPrefix(comment.Text, "/*"); ok {
 			// Write block comments potentially spanning multiple lines
 			// Remove /* and */, then split by newline
-			content := strings.TrimSuffix(strings.TrimPrefix(comment.Text, "/*"), "*/")
+			content := strings.TrimSuffix(after, "*/")
 			lines := strings.Split(content, "\n") // Use \n as Split expects a separator string
 
 			if len(lines) == 1 && !strings.Contains(lines[0], "\n") { // Check again for internal newlines just in case

package/compiler/composite-lit.go

@@ -107,7 +107,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 			// Use type info to get array length and element type
 			var arrayLen int
 			var elemType ast.Expr
-			var goElemType interface{}
+			var goElemType any
 			if typ := c.pkg.TypesInfo.TypeOf(exp.Type); typ != nil {
 				if at, ok := typ.Underlying().(*types.Array); ok {
 					arrayLen = int(at.Len())
@@ -534,7 +534,7 @@ func (c *GoToTSCompiler) WriteVarRefedValue(expr ast.Expr) error {
 // evaluateConstantExpr attempts to evaluate a Go expression as a compile-time constant.
 // It returns the constant value if successful, or nil if the expression is not a constant.
 // This is used for evaluating array literal keys that are constant expressions.
-func (c *GoToTSCompiler) evaluateConstantExpr(expr ast.Expr) interface{} {
+func (c *GoToTSCompiler) evaluateConstantExpr(expr ast.Expr) any {
 	// Use the type checker's constant evaluation
 	if tv, ok := c.pkg.TypesInfo.Types[expr]; ok && tv.Value != nil {
 		// The expression has a constant value
@@ -575,8 +575,7 @@ func (c *GoToTSCompiler) categorizeStructFields(
 	explicitEmbedded = make(map[string]ast.Expr)
 
 	// Pre-populate embeddedFields map keys using the correct property name
-	for i := 0; i < structType.NumFields(); i++ {
-		field := structType.Field(i)
+	for field := range structType.Fields() {
 		if field.Anonymous() {
 			fieldType := field.Type()
 			if ptr, ok := fieldType.(*types.Pointer); ok {
@@ -611,8 +610,7 @@ func (c *GoToTSCompiler) categorizeStructFields(
 		}
 
 		isDirectField := false
-		for i := range structType.NumFields() {
-			field := structType.Field(i)
+		for field := range structType.Fields() {
 			if field.Name() == keyName {
 				isDirectField = true
 				directFields[keyName] = kv.Value

package/compiler/constraint.go

@@ -16,11 +16,9 @@ type ConstraintInfo struct {
 func analyzeConstraint(iface *types.Interface) ConstraintInfo {
 	info := ConstraintInfo{}
 
-	for i := 0; i < iface.NumEmbeddeds(); i++ {
-		embedded := iface.EmbeddedType(i)
+	for embedded := range iface.EmbeddedTypes() {
 		if union, ok := embedded.(*types.Union); ok {
-			for j := 0; j < union.Len(); j++ {
-				term := union.Term(j)
+			for term := range union.Terms() {
 				checkType(term.Type(), &info)
 			}
 		} else {

package/compiler/expr-call-async.go

@@ -169,6 +169,10 @@ func (c *GoToTSCompiler) addNonNullAssertion(expFun ast.Expr) {
 						c.tsw.WriteLiterally("!")
 					}
 				}
+			} else if _, isParenExpr := expFun.(*ast.ParenExpr); isParenExpr {
+				// Parenthesized function expressions often come from pointer dereferences
+				// like (*rel)(), which remain nullable in TypeScript.
+				c.tsw.WriteLiterally("!")
 			} else if _, isNamed := funType.(*types.Named); isNamed {
 				c.tsw.WriteLiterally("!")
 			}

package/compiler/expr-call-helpers.go

@@ -8,12 +8,12 @@ import (
 )
 
 // writeByteSliceCreation handles the creation of []byte slices with proper Uint8Array handling
-func (c *GoToTSCompiler) writeByteSliceCreation(lengthArg, capacityArg interface{}) error {
+func (c *GoToTSCompiler) writeByteSliceCreation(lengthArg, capacityArg any) error {
 	return c.writeSliceCreationForType(lengthArg, capacityArg, true)
 }
 
 // writeSliceCreationForType handles slice creation with special handling for byte slices
-func (c *GoToTSCompiler) writeSliceCreationForType(lengthArg, capacityArg interface{}, isByteSlice bool) error {
+func (c *GoToTSCompiler) writeSliceCreationForType(lengthArg, capacityArg any, isByteSlice bool) error {
 	hasCapacity := capacityArg != nil
 
 	if isByteSlice && !hasCapacity {
@@ -52,7 +52,7 @@ func (c *GoToTSCompiler) writeSliceCreationForType(lengthArg, capacityArg interf
 }
 
 // writeGenericSliceCreation handles the creation of generic slices with proper type hints
-func (c *GoToTSCompiler) writeGenericSliceCreation(elemType types.Type, lengthArg, capacityArg interface{}) error {
+func (c *GoToTSCompiler) writeGenericSliceCreation(elemType types.Type, lengthArg, capacityArg any) error {
 	hasCapacity := capacityArg != nil
 
 	c.tsw.WriteLiterally("$.makeSlice<")
@@ -90,7 +90,7 @@ func (c *GoToTSCompiler) writeSliceTypeHint(elemType types.Type, hasCapacity boo
 }
 
 // writeExprOrDefault writes an expression if it's not nil, otherwise writes a default value
-func (c *GoToTSCompiler) writeExprOrDefault(expr interface{}, defaultValue string) error {
+func (c *GoToTSCompiler) writeExprOrDefault(expr any, defaultValue string) error {
 	if expr == nil {
 		c.tsw.WriteLiterally(defaultValue)
 		return nil
@@ -149,6 +149,14 @@ func (c *GoToTSCompiler) writeReflectTypeFor(exp *ast.CallExpr, selectorExpr *as
 	typeArg := instance.TypeArgs.At(0)
 	// fmt.Printf("DEBUG: Type argument: %v\n", typeArg)
 
+	if named, ok := typeArg.(*types.Named); ok {
+		if _, isInterface := named.Underlying().(*types.Interface); isInterface {
+			typeName := qualifiedTypeName(named)
+			c.tsw.WriteLiterally("reflect.getInterfaceLiteralTypeByName(\"" + typeName + "\")")
+			return true, nil
+		}
+	}
+
 	// Generate TypeScript code to create a Type for this type
 	if err := c.writeTypeForTypeArg(typeArg); err != nil {
 		return true, err
@@ -157,6 +165,54 @@ func (c *GoToTSCompiler) writeReflectTypeFor(exp *ast.CallExpr, selectorExpr *as
 	return true, nil
 }
 
+// writeReflectTypeAssert handles reflect.TypeAssert[T](v) calls.
+func (c *GoToTSCompiler) writeReflectTypeAssert(exp *ast.CallExpr, selectorExpr *ast.SelectorExpr) (handled bool, err error) {
+	if selectorExpr.Sel.Name != "TypeAssert" {
+		return false, nil
+	}
+
+	xIdent, ok := selectorExpr.X.(*ast.Ident)
+	if !ok {
+		return false, nil
+	}
+
+	obj := c.objectOfIdent(xIdent)
+	if obj == nil {
+		return false, nil
+	}
+
+	pkgName, ok := obj.(*types.PkgName)
+	if !ok || pkgName.Imported().Path() != "reflect" {
+		return false, nil
+	}
+
+	if len(exp.Args) != 1 {
+		return false, errors.New("reflect.TypeAssert called with unexpected argument count")
+	}
+
+	if c.pkg.TypesInfo.Instances == nil {
+		return false, errors.New("reflect.TypeAssert called but no type instances available")
+	}
+
+	instance, hasInstance := c.pkg.TypesInfo.Instances[selectorExpr.Sel]
+	if !hasInstance || instance.TypeArgs == nil || instance.TypeArgs.Len() == 0 {
+		return false, errors.New("reflect.TypeAssert called without type arguments")
+	}
+
+	typeArg := instance.TypeArgs.At(0)
+
+	c.tsw.WriteLiterally("$.typeAssertTuple<")
+	c.WriteGoType(typeArg, GoTypeContextGeneral)
+	c.tsw.WriteLiterally(">(")
+	if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+		return true, err
+	}
+	c.tsw.WriteLiterally(".Interface(), ")
+	c.writeTypeInfoObject(typeArg)
+	c.tsw.WriteLiterally(")")
+	return true, nil
+}
+
 // writeTypeForTypeArg generates TypeScript code to create a reflect.Type for the given Go type
 func (c *GoToTSCompiler) writeTypeForTypeArg(t types.Type) error {
 	// Handle basic types
@@ -175,12 +231,46 @@ func (c *GoToTSCompiler) writeTypeForTypeArg(t types.Type) error {
 		c.tsw.WriteLiterally(")")
 		return nil
 	case *types.Slice:
-		// For slice types, use TypeOf with an empty slice
-		c.tsw.WriteLiterally("reflect.TypeOf([])")
+		c.tsw.WriteLiterally("reflect.SliceOf(")
+		if err := c.writeTypeForTypeArg(underlying.Elem()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
 		return nil
 	case *types.Array:
-		// For array types, use TypeOf with an empty array
-		c.tsw.WriteLiterally("reflect.TypeOf([])")
+		c.tsw.WriteLiterally("reflect.ArrayOf(")
+		c.tsw.WriteLiterallyf("%d, ", underlying.Len())
+		if err := c.writeTypeForTypeArg(underlying.Elem()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	case *types.Map:
+		c.tsw.WriteLiterally("reflect.MapOf(")
+		if err := c.writeTypeForTypeArg(underlying.Key()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(", ")
+		if err := c.writeTypeForTypeArg(underlying.Elem()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	case *types.Chan:
+		c.tsw.WriteLiterally("reflect.ChanOf(")
+		switch underlying.Dir() {
+		case types.RecvOnly:
+			c.tsw.WriteLiterally("reflect.RecvDir")
+		case types.SendOnly:
+			c.tsw.WriteLiterally("reflect.SendDir")
+		default:
+			c.tsw.WriteLiterally("reflect.BothDir")
+		}
+		c.tsw.WriteLiterally(", ")
+		if err := c.writeTypeForTypeArg(underlying.Elem()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
 		return nil
 	case *types.Struct:
 		// For struct types, use TypeOf with zero value