goscript 0.0.22 → 0.0.24

package/compiler/compiler.go

@@ -8,8 +8,10 @@ import (
 	"go/types"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 
+	gs "github.com/aperturerobotics/goscript"
 	"github.com/sirupsen/logrus"
 	"golang.org/x/tools/go/packages"
 )
@@ -88,6 +90,12 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 		return fmt.Errorf("failed to load packages: %w", err)
 	}
 
+	// build a list of packages that patterns matched
+	patternPkgPaths := make([]string, 0, len(pkgs))
+	for _, pkg := range pkgs {
+		patternPkgPaths = append(patternPkgPaths, pkg.PkgPath)
+	}
+
 	// If AllDependencies is true, we need to collect all dependencies
 	if c.config.AllDependencies {
 		// Create a set to track processed packages by their ID
@@ -140,6 +148,44 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 
 	// Compile all packages
 	for _, pkg := range pkgs {
+		// Check if the package has a handwritten equivalent
+		if !slices.Contains(patternPkgPaths, pkg.PkgPath) {
+			gsSourcePath := "gs/" + pkg.PkgPath
+			_, gsErr := gs.GsOverrides.ReadDir(gsSourcePath)
+			if gsErr != nil && !os.IsNotExist(gsErr) {
+				return gsErr
+			}
+			if gsErr == nil {
+				if c.config.DisableEmitBuiltin {
+					c.le.Infof("Skipping compilation for overridden package %s", 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 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 fmt.Errorf("failed to create output directory for %s: %w", pkg.PkgPath, 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", pkg.PkgPath, err)
+					}
+
+					continue
+				}
+			}
+		}
+
 		// Skip packages that failed to load
 		if len(pkg.Errors) > 0 {
 			c.le.WithError(pkg.Errors[0]).Warnf("Skipping package %s due to errors", pkg.PkgPath)
@@ -182,7 +228,7 @@ func NewPackageCompiler(
 		le:           le,
 		pkg:          pkg,
 		compilerConf: compilerConf,
-		outputPath:   ComputeModulePath(compilerConf.OutputPathRoot, pkg.PkgPath),
+		outputPath:   ComputeModulePath(compilerConf.OutputPath, pkg.PkgPath),
 	}
 
 	return res, nil
@@ -267,7 +313,7 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 // CompileFile handles the compilation of a single Go source file to TypeScript.
 // It first performs a pre-compilation analysis of the file using `AnalyzeFile`
 // to gather information necessary for accurate TypeScript generation (e.g.,
-// about boxing, async functions, defer statements).
+// about varRefing, async functions, defer statements).
 // Then, it creates a `FileCompiler` instance for the file and invokes its
 // `Compile` method to generate the TypeScript code.
 func (p *PackageCompiler) CompileFile(ctx context.Context, name string, syntax *ast.File) error {
@@ -328,10 +374,10 @@ func NewFileCompiler(
 // top-level declarations in the Go file.
 func (c *FileCompiler) Compile(ctx context.Context) error {
 	f := c.ast
-
 	pkgPath := c.pkg.PkgPath
+
 	outputFilePath := TranslateGoFilePathToTypescriptFilePath(pkgPath, filepath.Base(c.fullPath))
-	outputFilePathAbs := filepath.Join(c.compilerConfig.OutputPathRoot, outputFilePath)
+	outputFilePathAbs := filepath.Join(c.compilerConfig.OutputPath, outputFilePath)
 
 	if err := os.MkdirAll(filepath.Dir(outputFilePathAbs), 0o755); err != nil {
 		return err
@@ -349,7 +395,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 	goWriter := NewGoToTSCompiler(c.codeWriter, c.pkg, c.Analysis)
 
 	// Add import for the goscript runtime using namespace import and alias
-	c.codeWriter.WriteLine("import * as $ from \"@goscript/builtin\";")
+	c.codeWriter.WriteLinef("import * as $ from %q;", "@goscript/builtin/builtin.js")
 	c.codeWriter.WriteLine("") // Add a newline after the import
 
 	if err := goWriter.WriteDecls(f.Decls); err != nil {
@@ -362,13 +408,13 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 // GoToTSCompiler is the core component responsible for translating Go AST nodes
 // and type information into TypeScript code. It uses a `TSCodeWriter` to output
 // the generated TypeScript and relies on `Analysis` data to make informed
-// decisions about code generation (e.g., boxing, async behavior).
+// decisions about code generation (e.g., varRefing, async behavior).
 type GoToTSCompiler struct {
 	tsw *TSCodeWriter
 
 	pkg *packages.Package
 
-	analysis *Analysis // Holds analysis information for code generation decisions
+	analysis *Analysis
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,
@@ -388,14 +434,12 @@ func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analy
 // variable, function name) into its TypeScript equivalent.
 //   - If the identifier is `nil`, it writes `null`.
 //   - Otherwise, it writes the identifier's name.
-//   - If `accessBoxedValue` is true and the analysis (`c.analysis.NeedsBoxedAccess`)
-//     indicates that this identifier refers to a variable whose value is stored
-//     in a box (due to its address being taken or other boxing requirements),
-//     it appends `.value` to access the actual value from the box.
+//   - If `accessVarRefedValue` is true and the analysis (`c.analysis.NeedsVarRefAccess`)
+//     indicates the variable is variable referenced, `.value` is appended to access the contained value.
 //
 // This function relies on `go/types` (`TypesInfo.Uses` or `Defs`) to resolve
-// the identifier and the `Analysis` data to determine boxing needs.
-func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessBoxedValue bool) {
+// the identifier and the `Analysis` data to determine varRefing needs.
+func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 	if exp.Name == "nil" {
 		c.tsw.WriteLiterally("null")
 		return
@@ -412,7 +456,7 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessBoxedValue bool) {
 	c.tsw.WriteLiterally(exp.Name)
 
 	// Determine if we need to access .value based on analysis data
-	if obj != nil && accessBoxedValue && c.analysis.NeedsBoxedAccess(obj) {
+	if obj != nil && accessVarRefedValue && c.analysis.NeedsVarRefAccess(obj) {
 		c.tsw.WriteLiterally("!.value")
 	}
 }
@@ -437,28 +481,31 @@ func (c *GoToTSCompiler) WriteCaseClause(exp *ast.CaseClause) error {
 		c.tsw.WriteLine("")
 	} else {
 		// Case with expressions
-		c.tsw.WriteLiterally("case ")
-		for i, expr := range exp.List {
-			if i > 0 {
-				c.tsw.WriteLiterally(", ") // Although Go doesn't support multiple expressions per case like this,
-			} // TypeScript does, so we'll write it this way for now.
-			if err := c.WriteValueExpr(expr); err != nil {
+		// For Go's `case expr1, expr2:`, we translate to:
+		// case expr1:
+		// case expr2:
+		// ... body ...
+		// break
+		for _, caseExpr := range exp.List {
+			c.tsw.WriteLiterally("case ")
+			if err := c.WriteValueExpr(caseExpr); err != nil {
 				return fmt.Errorf("failed to write case clause expression: %w", err)
 			}
+			c.tsw.WriteLiterally(":")
+			c.tsw.WriteLine("")
 		}
-		c.tsw.WriteLiterally(":")
-		c.tsw.WriteLine("")
 	}
 
+	// The body is written once, after all case labels for this clause.
+	// Indentation for the body starts here.
 	c.tsw.Indent(1)
-	// Write the body of the case clause
 	for _, stmt := range exp.Body {
 		if err := c.WriteStmt(stmt); err != nil {
 			return fmt.Errorf("failed to write statement in case clause body: %w", err)
 		}
 	}
-	// Add break statement (Go's switch has implicit breaks)
-	c.tsw.WriteLine("break") // Remove semicolon
+	// Add break statement (Go's switch has implicit breaks, TS needs explicit break)
+	c.tsw.WriteLine("break")
 	c.tsw.Indent(-1)
 	return nil
 }
@@ -527,11 +574,11 @@ func (c *GoToTSCompiler) writeChannelReceiveWithOk(lhs []ast.Expr, unaryExpr *as
 	} else {
 		// If both are blank, just await the call and return
 		if okIsBlank {
-			c.tsw.WriteLiterally("await ")
+			c.tsw.WriteLiterally("await $.chanRecvWithOk(")
 			if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Channel expression
 				return fmt.Errorf("failed to write channel expression in receive: %w", err)
 			}
-			c.tsw.WriteLiterally(".receiveWithOk()")
+			c.tsw.WriteLiterally(")")
 			c.tsw.WriteLine("")
 			return nil // Nothing to assign
 		}
@@ -549,11 +596,11 @@ func (c *GoToTSCompiler) writeChannelReceiveWithOk(lhs []ast.Expr, unaryExpr *as
 	// Write the destructuring assignment/declaration
 	c.tsw.WriteLiterally(keyword) // "const " or ""
 	c.tsw.WriteLiterally(destructuringPattern)
-	c.tsw.WriteLiterally(" = await ")
+	c.tsw.WriteLiterally(" = await $.chanRecvWithOk(")
 	if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Channel expression
 		return fmt.Errorf("failed to write channel expression in receive: %w", err)
 	}
-	c.tsw.WriteLiterally(".receiveWithOk()")
+	c.tsw.WriteLiterally(")")
 	c.tsw.WriteLine("")
 
 	return nil
@@ -604,3 +651,44 @@ func (c *GoToTSCompiler) WriteDoc(doc *ast.CommentGroup) {
 		}
 	}
 }
+
+// copyEmbeddedPackage recursively copies files from an embedded FS path to a filesystem directory.
+// It handles both regular files and directories.
+func (c *Compiler) copyEmbeddedPackage(embeddedPath string, outputPath string) error {
+	// List the entries in the embedded path
+	entries, err := gs.GsOverrides.ReadDir(embeddedPath)
+	if err != nil {
+		return fmt.Errorf("failed to read embedded directory %s: %w", embeddedPath, err)
+	}
+
+	// Process each entry
+	for _, entry := range entries {
+		entryPath := filepath.Join(embeddedPath, entry.Name())
+		outputEntryPath := filepath.Join(outputPath, entry.Name())
+
+		if entry.IsDir() {
+			// Create the output directory
+			if err := os.MkdirAll(outputEntryPath, 0o755); err != nil {
+				return fmt.Errorf("failed to create output directory %s: %w", outputEntryPath, err)
+			}
+
+			// Recursively copy the directory contents
+			if err := c.copyEmbeddedPackage(entryPath, outputEntryPath); err != nil {
+				return err
+			}
+		} else {
+			// Read the file content from the embedded FS
+			content, err := gs.GsOverrides.ReadFile(entryPath)
+			if err != nil {
+				return fmt.Errorf("failed to read embedded file %s: %w", entryPath, err)
+			}
+
+			// Write the content to the output file
+			if err := os.WriteFile(outputEntryPath, content, 0o644); err != nil {
+				return fmt.Errorf("failed to write file %s: %w", outputEntryPath, err)
+			}
+		}
+	}
+
+	return nil
+}

package/compiler/compiler_test.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 	"runtime"
 	"slices"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"testing"
@@ -38,7 +39,7 @@ func TestCompliance(t *testing.T) {
 		testPath := filepath.Join(testsDir, dir.Name())
 		goFiles, err := filepath.Glob(filepath.Join(testPath, "*.go"))
 		if err != nil || len(goFiles) == 0 {
-			t.Errorf("no .go files found in %s", testPath)
+			// t.Errorf("no .go files found in %s", testPath)
 			continue
 		}
 		testPaths = append(testPaths, testPath)
@@ -97,15 +98,42 @@ func TestCompliance(t *testing.T) {
 			t.SkipNow()
 		}
 
-		t.Log("running: npm run typecheck")
-		cmd := exec.Command("npm", "run", "typecheck")
-		cmd.Dir = workspaceDir // Run in the workspace directory
-		cmd.Stdout = os.Stderr
-		cmd.Stderr = os.Stderr
+		// Get parent module path for the global typecheck
+		parentModPath, err := getParentGoModulePath()
+		if err != nil {
+			t.Fatalf("Failed to determine parent Go module path: %v", err)
+		}
+
+		// Create global typecheck tsconfig
+		tsconfigPath := compliance.WriteGlobalTypeCheckConfig(t, parentModPath, workspaceDir)
+
+		// Run TypeScript type checking
+		typecheckDir := filepath.Dir(tsconfigPath)
+		cmd := exec.Command("tsc", "--project", filepath.Base(tsconfigPath))
+		cmd.Dir = typecheckDir
+
+		// Set up PATH to include node_modules/.bin
+		nodeBinDir := filepath.Join(workspaceDir, "node_modules", ".bin")
+		currentPath := os.Getenv("PATH")
+		newPath := nodeBinDir + string(os.PathListSeparator) + currentPath
+		cmd.Env = append(os.Environ(), "PATH="+newPath)
 
-		err = cmd.Run()
+		output, err := cmd.CombinedOutput()
 		if err != nil {
-			t.Errorf("npm run typecheck failed: %v", err)
+			t.Errorf("Global TypeScript type checking failed: %v\noutput:\n%s", err, string(output))
+		} else {
+			t.Logf("Global TypeScript type checking passed")
 		}
 	})
 }
+
+// getParentGoModulePath is a helper function to get the parent Go module path
+// This is similar to the one in compliance.go but simplified for use in tests
+func getParentGoModulePath() (string, error) {
+	cmd := exec.Command("go", "list", "-m")
+	output, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(output)), nil
+}

package/compiler/composite-lit.go

@@ -13,26 +13,28 @@ import (
 //
 // It handles several types of composite literals:
 //   - Map literals (e.g., `map[K]V{k1: v1}`): Translated to `new Map([[k1_ts, v1_ts]])`.
-//     Values are processed by `writeBoxedValue`.
+//     Values are processed by `WriteVarRefedValue`.
 //   - Array/Slice literals (e.g., `[]T{e1, e2}`, `[N]T{idx: val}`):
-//     Translated using the `$.arrayToSlice<T_ts>([...])` runtime helper.
+//   - For `[]byte{...}`, translated to `new Uint8Array([...])`.
+//   - For other `[]T` or `[N]T`, translated using the `$.arrayToSlice<T_ts>([...])` runtime helper.
 //     It handles both keyed and unkeyed elements, infers length if necessary,
 //     and uses zero values for uninitialized array elements.
 //     Multi-dimensional arrays/slices pass a depth parameter to `$.arrayToSlice`.
-//     Element values are processed by `writeBoxedValue`.
+//     Element values are processed by `WriteVarRefedValue`.
 //   - Struct literals:
 //   - Named structs (e.g., `MyStruct{F: v}` or `&MyStruct{F: v}`): Translated to
 //     `new MyStruct_ts({ F: v_ts, ... })`. The constructor typically uses an `_init` method.
 //   - Anonymous structs (e.g., `struct{F int}{F: v}`): Translated to TypeScript
 //     object literals `{ F: v_ts, ... }`.
 //     It processes keyed elements (`FieldName: Value`) and unkeyed elements (for anonymous
-//     structs or arrays). Field values are processed by `writeBoxedValue`.
+//     structs or arrays). Field values are processed by `WriteVarRefedValue`.
 //     Embedded struct fields are initialized, and explicit initializers for embedded
 //     structs (e.g. `Outer{InnerField: InnerType{...}}`) are handled.
-//     The function uses `c.analysis` to determine correct value access (e.g., `.value` for boxed fields).
+//     The function uses `c.analysis` to determine correct value access (e.g., `.value` for var-refed fields).
 func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 	// Get the type of the composite literal
 	litType := c.pkg.TypesInfo.TypeOf(exp)
+
 	if exp.Type != nil {
 		// Handle map literals: map[K]V{k1: v1, k2: v2}
 		if _, isMapType := exp.Type.(*ast.MapType); isMapType {
@@ -46,11 +48,11 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 
 				if kv, ok := elm.(*ast.KeyValueExpr); ok {
 					c.tsw.WriteLiterally("[")
-					if err := c.WriteBoxedValue(kv.Key); err != nil {
+					if err := c.WriteVarRefedValue(kv.Key); err != nil {
 						return fmt.Errorf("failed to write map literal key: %w", err)
 					}
 					c.tsw.WriteLiterally(", ")
-					if err := c.WriteBoxedValue(kv.Value); err != nil {
+					if err := c.WriteVarRefedValue(kv.Value); err != nil {
 						return fmt.Errorf("failed to write map literal value: %w", err)
 					}
 					c.tsw.WriteLiterally("]")
@@ -73,14 +75,29 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 				// We'll handle this with depth parameter to arrayToSlice
 			}
 
-			c.tsw.WriteLiterally("$.arrayToSlice")
+			// Check if it's a []byte literal
+			isByteSliceLiteral := false
+			if typInfo := c.pkg.TypesInfo.TypeOf(exp.Type); typInfo != nil {
+				if sliceT, ok := typInfo.Underlying().(*types.Slice); ok {
+					if basicElem, ok := sliceT.Elem().(*types.Basic); ok && basicElem.Kind() == types.Uint8 {
+						isByteSliceLiteral = true
+					}
+				}
+			}
+
+			if isByteSliceLiteral {
+				c.tsw.WriteLiterally("new Uint8Array")
+			} else {
+				c.tsw.WriteLiterally("$.arrayToSlice")
 
-			// write the type annotation
-			c.tsw.WriteLiterally("<")
-			// Write the element type using the existing function
-			c.WriteTypeExpr(arrType.Elt)
-			c.tsw.WriteLiterally(">")
+				// write the type annotation
+				c.tsw.WriteLiterally("<")
+				// Write the element type using the existing function
+				c.WriteTypeExpr(arrType.Elt)
+				c.tsw.WriteLiterally(">")
+			}
 
+			// opening
 			c.tsw.WriteLiterally("([")
 
 			// Use type info to get array length and element type
@@ -123,7 +140,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 						hasKeyedElements = true
 					} else {
 						c.tsw.WriteCommentInline("unhandled keyed array literal key type")
-						if err := c.WriteBoxedValue(elm); err != nil {
+						if err := c.WriteVarRefedValue(elm); err != nil {
 							return fmt.Errorf("failed to write keyed array literal element with unhandled key type: %w", err)
 						}
 					}
@@ -151,7 +168,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					c.tsw.WriteLiterally(", ")
 				}
 				if elm, ok := elements[i]; ok && elm != nil {
-					if err := c.WriteBoxedValue(elm); err != nil {
+					if err := c.WriteVarRefedValue(elm); err != nil {
 						return fmt.Errorf("failed to write array literal element: %w", err)
 					}
 				} else {
@@ -166,7 +183,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 			c.tsw.WriteLiterally("]")
 
 			// If it's a multi-dimensional array/slice, use depth=2 to convert nested arrays
-			if isMultiDimensional {
+			if isMultiDimensional && !isByteSliceLiteral { // Depth parameter not applicable to Uint8Array constructor
 				c.tsw.WriteLiterally(", 2") // Depth of 2 for one level of nesting
 			}
 
@@ -271,9 +288,8 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 				}
 
 				// Handle the case where an anonymous struct has values without keys
-				// Handle the case where an anonymous struct has values without keys.
 				// This block processes non-key-value elements and associates them with struct fields.
-				if isAnonymousStruct && len(exp.Elts) > 0 && len(directFields) == 0 && structType != nil {
+				if isAnonymousStruct && len(exp.Elts) > 0 && len(directFields) == 0 {
 					// Check if any elements in the composite literal are not key-value pairs.
 					hasNonKeyValueElts := false
 					for _, elt := range exp.Elts {
@@ -325,7 +341,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					}
 					c.tsw.WriteLiterally(keyName)
 					c.tsw.WriteLiterally(": ")
-					if err := c.WriteBoxedValue(directFields[keyName]); err != nil {
+					if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
 						return err
 					}
 					firstFieldWritten = true
@@ -353,14 +369,14 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 							if i > 0 {
 								c.tsw.WriteLiterally(", ")
 							}
-							if err := c.WriteBoxedValue(elem); err != nil {
+							if err := c.WriteVarRefedValue(elem); err != nil {
 								return err
 							}
 						}
 						c.tsw.WriteLiterally("}")
 					} else {
 						// Not a composite literal, write it normally
-						if err := c.WriteBoxedValue(explicitEmbedded[embeddedName]); err != nil {
+						if err := c.WriteVarRefedValue(explicitEmbedded[embeddedName]); err != nil {
 							return err
 						}
 					}
@@ -399,7 +415,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 						}
 						c.tsw.WriteLiterally(keyName) // Field name within the embedded struct
 						c.tsw.WriteLiterally(": ")
-						if err := c.WriteBoxedValue(fieldsMap[keyName]); err != nil {
+						if err := c.WriteVarRefedValue(fieldsMap[keyName]); err != nil {
 							return err
 						}
 					}
@@ -421,7 +437,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					if i != 0 {
 						c.tsw.WriteLiterally(", ")
 					}
-					if err := c.WriteBoxedValue(elm); err != nil {
+					if err := c.WriteVarRefedValue(elm); err != nil {
 						return fmt.Errorf("failed to write literal field: %w", err)
 					}
 				}
@@ -433,60 +449,124 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 
 	// Untyped composite literal. Let's use type information to determine what it is.
 	// First try to get the type information for the expression
-	isObject := false
 	if tv, ok := c.pkg.TypesInfo.Types[exp]; ok && tv.Type != nil {
 		underlying := tv.Type.Underlying()
 		switch underlying.(type) {
 		case *types.Map, *types.Struct:
-			isObject = true
+			// Handle struct directly with the struct literal logic
+			if structType, ok := underlying.(*types.Struct); ok {
+				return c.writeUntypedStructLiteral(exp, structType) // true = anonymous
+			}
+			// Map case would be handled here
+			return fmt.Errorf("untyped map composite literals not yet supported")
 		case *types.Array, *types.Slice:
-			isObject = false
+			// Handle array/slice
+			return c.writeUntypedArrayLiteral(exp)
+		case *types.Pointer:
+			// Handle pointer to composite literal
+			ptrType := underlying.(*types.Pointer)
+			elemType := ptrType.Elem().Underlying()
+			switch elemType.(type) {
+			case *types.Struct:
+				// This is an anonymous struct literal with inferred pointer type
+				// Just create the struct object directly - no var-refing needed
+				// Anonymous literals are not variables, so they don't get var-refed
+				structType := elemType.(*types.Struct)
+				return c.writeUntypedStructLiteral(exp, structType) // true = anonymous
+			default:
+				return fmt.Errorf("unhandled pointer composite literal element type: %T", elemType)
+			}
 		default:
 			return fmt.Errorf("unhandled composite literal type: %T", underlying)
 		}
 	} else {
 		return fmt.Errorf("could not determine composite literal type from type information")
 	}
+}
 
-	if isObject {
-		c.tsw.WriteLiterally("{ ")
-	} else {
-		c.tsw.WriteLiterally("[ ")
-	}
-
+// writeUntypedArrayLiteral handles untyped composite literals that are arrays/slices
+func (c *GoToTSCompiler) writeUntypedArrayLiteral(exp *ast.CompositeLit) error {
+	c.tsw.WriteLiterally("[ ")
 	for i, elm := range exp.Elts {
 		if i != 0 {
 			c.tsw.WriteLiterally(", ")
 		}
-		if err := c.WriteBoxedValue(elm); err != nil {
-			return fmt.Errorf("failed to write untyped composite literal element: %w", err)
+		if err := c.WriteVarRefedValue(elm); err != nil {
+			return fmt.Errorf("failed to write untyped array literal element: %w", err)
 		}
 	}
-	if isObject {
-		c.tsw.WriteLiterally(" }")
-	} else {
-		c.tsw.WriteLiterally(" ]")
+	c.tsw.WriteLiterally(" ]")
+	return nil
+}
+
+// writeUntypedStructLiteral handles untyped composite literals that are structs or pointers to structs
+func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, structType *types.Struct) error {
+	// Create field mapping like the typed struct case
+	directFields := make(map[string]ast.Expr)
+
+	// Handle elements that are key-value pairs
+	for _, elt := range exp.Elts {
+		if kv, ok := elt.(*ast.KeyValueExpr); ok {
+			if keyIdent, ok := kv.Key.(*ast.Ident); ok {
+				directFields[keyIdent.Name] = kv.Value
+			}
+		}
+	}
+
+	// Handle elements that are positional (no key specified)
+	if len(directFields) == 0 {
+		// If no key-value pairs, try to match positional values to struct fields
+		for i, elt := range exp.Elts {
+			if _, isKV := elt.(*ast.KeyValueExpr); !isKV && i < structType.NumFields() {
+				field := structType.Field(i)
+				directFields[field.Name()] = elt
+			}
+		}
 	}
+
+	// Write the object literal (always anonymous for untyped)
+	c.tsw.WriteLiterally("{")
+
+	firstFieldWritten := false
+	// Write fields in order
+	directKeys := make([]string, 0, len(directFields))
+	for k := range directFields {
+		directKeys = append(directKeys, k)
+	}
+	slices.Sort(directKeys)
+	for _, keyName := range directKeys {
+		if firstFieldWritten {
+			c.tsw.WriteLiterally(", ")
+		}
+		c.tsw.WriteLiterally(keyName)
+		c.tsw.WriteLiterally(": ")
+		if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
+			return err
+		}
+		firstFieldWritten = true
+	}
+
+	c.tsw.WriteLiterally("}")
 	return nil
 }
 
-// WriteBoxedValue translates a Go expression (`ast.Expr`) into its TypeScript equivalent,
+// WriteVarRefedValue translates a Go expression (`ast.Expr`) into its TypeScript equivalent,
 // specifically for use as a value within a composite literal (e.g., struct fields,
 // map keys/values, or array/slice elements). Its primary goal is to ensure that the
-// actual, unboxed value of the expression is used.
+// actual un-refed value of the expression is used.
 //
 // How it works:
 //   - Identifiers (`*ast.Ident`): Delegates to `c.WriteIdent(ident, true)`, forcing
 //     the `accessValue` flag to `true`. This ensures that if `ident` refers to a
-//     GoScript boxed variable, the generated TypeScript accesses its underlying `.value`
+//     GoScript var-refed variable, the generated TypeScript accesses its underlying `.value`
 //     (e.g., `myVar.value`).
 //   - Selector Expressions (`*ast.SelectorExpr`, e.g., `obj.Field`): Delegates to
 //     `c.WriteSelectorExpr(e)`. This function handles the necessary logic for
-//     accessing fields or methods, including any required unboxing if the field
-//     itself or the object it's accessed on is boxed (e.g., `obj.value.field` or
+//     accessing fields or methods, including any required un-var-refing if the field
+//     itself or the object it's accessed on is var-refed (e.g., `obj.value.field` or
 //     `obj.field.value`).
 //   - Star Expressions (`*ast.StarExpr`, e.g., `*ptr`): Delegates to `c.WriteStarExpr(e)`.
-//     This function handles pointer dereferencing, which in GoScript's boxing model
+//     This function handles pointer dereferencing, which in GoScript's var-refing model
 //     often translates to accessing the `.value` field of the pointer (e.g., `ptr.value`).
 //   - Basic Literals (`*ast.BasicLit`, e.g., `123`, `"hello"`): Delegates to
 //     `c.WriteBasicLit(e)` for direct translation.
@@ -496,25 +576,25 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 //
 // Necessity and Distinction from `WriteValueExpr`:
 // While `WriteValueExpr` is a general-purpose function for translating Go expressions
-// and also unboxes identifiers (by calling `WriteIdent` with `accessValue: true`),
-// `WriteBoxedValue` serves a specific and crucial role when called from `WriteCompositeLit`:
+// and also un-var-refes identifiers (by calling `WriteIdent` with `accessValue: true`),
+// `WriteVarRefedValue` serves a specific and crucial role when called from `WriteCompositeLit`:
 //  1. Clarity of Intent: It explicitly signals that for the constituents of a composite
-//     literal, the *unboxed value* is mandatory.
+//     literal, the *un-var-refed value* is mandatory.
 //  2. Contract for `WriteCompositeLit`: It ensures that `WriteCompositeLit` receives
 //     the correct values for initialization, insulating it from potential changes in
-//     the default behavior of `WriteValueExpr` regarding unboxing.
+//     the default behavior of `WriteValueExpr` regarding un-var-refing.
 //  3. Prevents Recursion: `WriteValueExpr` handles `*ast.CompositeLit` nodes by
 //     calling `WriteCompositeLit`. If `WriteCompositeLit` were to directly call
 //     `WriteValueExpr` for its elements, it could lead to unintended recursion or
-//     behavior if an element itself was another composite literal. `WriteBoxedValue`
+//     behavior if an element itself was another composite literal. `WriteVarRefedValue`
 //     acts as a specific intermediary for the *elements*.
 //
-// In summary, `WriteBoxedValue` is a specialized dispatcher used by `WriteCompositeLit`
+// In summary, `WriteVarRefedValue` is a specialized dispatcher used by `WriteCompositeLit`
 // to guarantee that all parts of a Go composite literal are initialized with their
-// proper, unboxed TypeScript values.
-func (c *GoToTSCompiler) WriteBoxedValue(expr ast.Expr) error {
+// proper, unrefed TypeScript values.
+func (c *GoToTSCompiler) WriteVarRefedValue(expr ast.Expr) error {
 	if expr == nil {
-		return fmt.Errorf("nil expression passed to writeBoxedValue")
+		return fmt.Errorf("nil expression passed to write var refed value")
 	}
 
 	// Handle different expression types