goscript 0.0.55 → 0.0.57

package/README.md

@@ -64,6 +64,108 @@ npm install -g goscript
 goscript compile --package . --output ./dist
 ```
 
+## 📦 Using Generated Code in Your Project
+
+After compiling your Go code to TypeScript, you'll need to set up your project appropriately.
+
+### TypeScript Configuration
+
+Create or update your `tsconfig.json` with these settings:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "esnext.disposable", "dom"],
+    "baseUrl": "./",
+    "paths": {
+      "@goscript/*": ["./path/to/generated/output/@goscript/*"]
+    },
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "strict": true
+  }
+}
+```
+
+**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
+- **`moduleResolution: "bundler"`** - Recommended for modern bundlers
+
+You should be able to use any TypeScript bundler to compile the generated TypeScript.
+
+## 🛠️ Integration & Usage
+
+### Command Line
+
+```bash
+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"
+
+conf := &compiler.Config{OutputPath: "./dist"}
+comp, err := compiler.NewCompiler(conf, logger, nil)
+_, err = comp.CompilePackages(ctx, "your/package/path")
+```
+
+**Node.js:**
+```typescript
+import { compile } from 'goscript'
+
+await compile({
+  pkg: './my-go-package',
+  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)
+  }
+
+  return <button onClick={handleAdd}>Add 5 + 3</button>
+}
+```
+
+**Vue + GoScript:**
+```vue
+<script setup lang="ts">
+import { NewUser, FindUserByEmail } from '@goscript/myapp/user'
+
+const users = ref([
+  NewUser(1, "Alice", "alice@example.com")
+])
+
+const searchUser = (email: string) => {
+  return FindUserByEmail(users.value, email)
+}
+</script>
+```
+
+
 ## 💡 See It In Action
 
 ### Example: User Management
@@ -196,72 +298,6 @@ async function handleMessages() {
 }
 ```
 
-## 🛠️ Integration & Usage
-
-### Command Line
-
-```bash
-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"
-
-conf := &compiler.Config{OutputPath: "./dist"}
-comp, err := compiler.NewCompiler(conf, logger, nil)
-_, err = comp.CompilePackages(ctx, "your/package/path")
-```
-
-**Node.js:**
-```typescript
-import { compile } from 'goscript'
-
-await compile({
-  pkg: './my-go-package',
-  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)
-  }
-
-  return <button onClick={handleAdd}>Add 5 + 3</button>
-}
-```
-
-**Vue + GoScript:**
-```vue
-<script setup lang="ts">
-import { NewUser, FindUserByEmail } from '@goscript/myapp/user'
-
-const users = ref([
-  NewUser(1, "Alice", "alice@example.com")
-])
-
-const searchUser = (email: string) => {
-  return FindUserByEmail(users.value, email)
-}
-</script>
-```
-
 ## 🚀 What's Next?
 
 **Current Status:**
@@ -276,19 +312,7 @@ const searchUser = (email: string) => {
 - ⚡ Performance optimizations
 - 🔧 Better tooling integration
 
-Check our [compliance tests](./compliance/COMPLIANCE.md) for detailed progress.
-
-## 🤝 Real-World Use Cases
-
-**Fintech:** Share complex financial calculations between Go services and trading dashboards
-
-**Gaming:** Run the same game logic on servers and in browser clients
-
-**Data Processing:** Use identical algorithms for backend ETL and frontend analytics
-
-**Validation:** Keep business rules consistent across your entire stack
-
-Ready to eliminate code duplication? [Get started now](#-get-started-in-2-minutes) 🚀
+Check the [compliance tests](./compliance/COMPLIANCE.md) for detailed progress.
 
 ## License
 

package/compiler/analysis.go

@@ -589,6 +589,12 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 
 	case *ast.TypeAssertExpr:
 		return v.visitTypeAssertExpr(n)
+
+	case *ast.CompositeLit:
+		// Traverse into composite literal elements to detect &variable expressions
+		// This is important for cases like: arr := []interface{}{value1, &value2}
+		// where value2 needs to be marked as NeedsVarRef due to the &value2 usage
+		return v.visitCompositeLit(n)
 	}
 
 	// For all other nodes, continue traversal
@@ -869,10 +875,89 @@ func (v *analysisVisitor) visitIfStmt(n *ast.IfStmt) ast.Visitor {
 	return v
 }
 
-// visitTypeAssertExpr handles type assertion expression analysis
-func (v *analysisVisitor) visitTypeAssertExpr(n *ast.TypeAssertExpr) ast.Visitor {
-	// Track interface implementations when we see type assertions
-	v.trackTypeAssertion(n)
+// visitTypeAssertExpr handles type assertion analysis for interface method implementations
+func (v *analysisVisitor) visitTypeAssertExpr(typeAssert *ast.TypeAssertExpr) ast.Visitor {
+	// Get the type being asserted to
+	assertedType := v.pkg.TypesInfo.TypeOf(typeAssert.Type)
+	if assertedType == nil {
+		return v
+	}
+
+	// Check if the asserted type is an interface
+	interfaceType, isInterface := assertedType.Underlying().(*types.Interface)
+	if !isInterface {
+		return v
+	}
+
+	// Get the type of the expression being asserted
+	exprType := v.pkg.TypesInfo.TypeOf(typeAssert.X)
+	if exprType == nil {
+		return v
+	}
+
+	// Handle pointer types by getting the element type
+	if ptrType, isPtr := exprType.(*types.Pointer); isPtr {
+		exprType = ptrType.Elem()
+	}
+
+	// Check if the expression type is a named struct type
+	namedType, isNamed := exprType.(*types.Named)
+	if !isNamed {
+		return v
+	}
+
+	// For each method in the interface, check if the struct implements it
+	for i := 0; i < interfaceType.NumExplicitMethods(); i++ {
+		interfaceMethod := interfaceType.ExplicitMethod(i)
+
+		// Find the corresponding method in the struct type
+		structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
+		if structMethod != nil {
+			// Determine if this struct method is async using unified system
+			isAsync := false
+			if obj := structMethod; obj != nil {
+				isAsync = v.analysis.IsAsyncFunc(obj)
+			}
+
+			// Track this interface implementation
+			v.analysis.trackInterfaceImplementation(interfaceType, namedType, structMethod, isAsync)
+		}
+	}
+	return v
+}
+
+// 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 {
+	// Analyze each element of the composite literal
+	for _, elt := range compLit.Elts {
+		// Handle both direct elements and key-value pairs
+		var expr ast.Expr
+		if kv, ok := elt.(*ast.KeyValueExpr); ok {
+			// For key-value pairs, analyze the value expression
+			expr = kv.Value
+		} else {
+			// For direct elements, analyze the element expression
+			expr = elt
+		}
+
+		// Check if this element is an address-of expression
+		if unaryExpr, ok := expr.(*ast.UnaryExpr); ok && unaryExpr.Op == token.AND {
+			// Found &something in the composite literal
+			if ident, ok := unaryExpr.X.(*ast.Ident); ok {
+				// Found &variable - mark the variable as needing VarRef
+				if obj := v.pkg.TypesInfo.ObjectOf(ident); obj != nil {
+					// Record that this variable has its address taken
+					usageInfo := v.getOrCreateUsageInfo(obj)
+					usageInfo.Destinations = append(usageInfo.Destinations, AssignmentInfo{
+						Object: nil, // No specific destination object for composite literals
+						Type:   AddressOfAssignment,
+					})
+				}
+			}
+		}
+	}
 	return v
 }
 

package/compiler/assignment.go

@@ -56,10 +56,12 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 
 			// Handle the RHS expression (potentially adding .clone() for structs)
 			if shouldApplyClone(c.pkg, rhs[0]) {
+				// When cloning for value assignment, mark the result as struct value
+				c.tsw.WriteLiterally("$.markAsStructValue(")
 				if err := c.WriteValueExpr(rhs[0]); err != nil {
 					return err
 				}
-				c.tsw.WriteLiterally(".clone()")
+				c.tsw.WriteLiterally(".clone())")
 			} else {
 				if err := c.WriteValueExpr(rhs[0]); err != nil {
 					return err
@@ -338,8 +340,37 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 			}
 		}
 
+		// Check for pointer-to-pointer assignment
+		if rhsIsIdent && rhsObj != nil && len(lhs) == 1 {
+			lhsType := c.pkg.TypesInfo.TypeOf(lhs[0])
+			rhsType := rhsObj.Type()
+
+			if lhsType != nil && rhsType != nil {
+				// Check if both LHS and RHS are pointer types
+				if _, lhsIsPtr := lhsType.(*types.Pointer); lhsIsPtr {
+					if _, rhsIsPtr := rhsType.(*types.Pointer); rhsIsPtr {
+						// This is pointer-to-pointer assignment
+						// The key question: is the RHS variable itself varref'd?
+						// - If RHS is varref'd (like pp1), use .value to get the actual pointer
+						// - If RHS is not varref'd (like p1), use the variable directly
+
+						if c.analysis.NeedsVarRef(rhsObj) {
+							// RHS variable is varref'd, so we need its .value to get the actual pointer
+							c.WriteIdent(rhsIdent, true) // Add .value access
+						} else {
+							// RHS variable is not varref'd, so it directly holds the pointer
+							c.WriteIdent(rhsIdent, false) // No .value access
+						}
+						continue
+					}
+				}
+			}
+		}
+
 		// Handle different cases for struct cloning
 		if shouldApplyClone(c.pkg, r) {
+			// When cloning for value assignment, mark the result as struct value
+			c.tsw.WriteLiterally("$.markAsStructValue(")
 			// For other expressions, we need to handle variable referenced access differently
 			if _, isIdent := r.(*ast.Ident); isIdent {
 				// For identifiers, WriteValueExpr already adds .value if needed
@@ -357,8 +388,39 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 				}
 			}
 
-			c.tsw.WriteLiterally(".clone()") // Always add clone for struct values
+			c.tsw.WriteLiterally(".clone())") // Always add clone for struct values
 		} else {
+			// Check if this is a pointer variable assignment to an interface type
+			if rhsIsIdent && rhsObj != nil {
+				// Check if LHS is interface type and RHS is a pointer variable
+				if len(lhs) == 1 {
+					lhsType := c.pkg.TypesInfo.TypeOf(lhs[0])
+					rhsType := rhsObj.Type()
+
+					if lhsType != nil && rhsType != nil {
+						// Check if LHS is interface and RHS is pointer
+						if _, isInterface := lhsType.Underlying().(*types.Interface); isInterface {
+							if ptrType, isPtr := rhsType.(*types.Pointer); isPtr {
+								// This is pointer-to-interface assignment
+								// For pointer variables that point to varrefed values, write without .value
+								// We want to pass the VarRef object itself to the interface, not its .value
+								if c.analysis.NeedsVarRefAccess(rhsObj) {
+									// Write the pointer variable without .value access
+									c.WriteIdent(rhsIdent, false)
+									continue
+								}
+
+								// Check if this is a struct pointer for the element type
+								if _, isStruct := ptrType.Elem().Underlying().(*types.Struct); isStruct {
+									// Struct pointer to interface - might need special handling
+									// Continue to normal WriteValueExpr handling
+								}
+							}
+						}
+					}
+				}
+			}
+
 			// Non-struct case: write RHS normally
 			if err := c.WriteValueExpr(r); err != nil { // RHS is a non-struct value
 				return err

package/compiler/compiler.go

@@ -434,6 +434,24 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 				case *ast.FuncDecl:
 					if d.Recv == nil && d.Name.IsExported() {
 						valueSymbols = append(valueSymbols, sanitizeIdentifier(d.Name.Name))
+					} else if d.Recv != nil && len(d.Recv.List) == 1 && d.Name.IsExported() {
+						recvField := d.Recv.List[0]
+						recvTypeExpr := recvField.Type
+						if star, ok := recvTypeExpr.(*ast.StarExpr); ok {
+							recvTypeExpr = star.X
+						}
+						if ident, ok := recvTypeExpr.(*ast.Ident); ok {
+							typeObj := c.pkg.TypesInfo.ObjectOf(ident)
+							if typeObj != nil && typeObj.Exported() {
+								if typeName, ok := typeObj.(*types.TypeName); ok {
+									underlying := typeName.Type().Underlying()
+									if _, isStruct := underlying.(*types.Struct); !isStruct {
+										methodName := sanitizeIdentifier(ident.Name + "_" + d.Name.Name)
+										valueSymbols = append(valueSymbols, methodName)
+									}
+								}
+							}
+						}
 					}
 				case *ast.GenDecl:
 					for _, spec := range d.Specs {
@@ -686,6 +704,9 @@ type GoToTSCompiler struct {
 	pkg *packages.Package
 
 	analysis *Analysis
+
+	// Context flags
+	insideAddressOf bool // true when processing operand of & operator
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,

package/compiler/compiler_test.go

@@ -1,6 +1,7 @@
 package compiler_test
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -135,5 +136,14 @@ func getParentGoModulePath() (string, error) {
 	if err != nil {
 		return "", err
 	}
-	return strings.TrimSpace(string(output)), nil
+	// note: in a go work configuration, go list -m can report multiple modules
+	// only one of which is the goscript case, so we need to filter:
+	pf := strings.Fields(strings.TrimSpace(string(output)))
+	pf = slices.DeleteFunc(pf, func(n string) bool {
+		return !strings.HasSuffix(n, "goscript")
+	})
+	if len(pf) != 1 {
+		return "", fmt.Errorf("'go list -m' did not have exactly 1 goscript package -- run in root of goscript package")
+	}
+	return pf[0], nil
 }

package/compiler/composite-lit.go

@@ -212,6 +212,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 			var structType *types.Struct
 			isStructLiteral := false
 			isAnonymousStruct := false
+			needsValueMarkerClose := false // Track if we need to close $.markAsStructValue()
 
 			if namedType, ok := litType.(*types.Named); ok {
 				if underlyingStruct, ok := namedType.Underlying().(*types.Struct); ok {
@@ -224,8 +225,14 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 							return err
 						}
 					} else {
-						// Named struct, use constructor
-						c.tsw.WriteLiterally("new ")
+						// Named struct value, use constructor
+						if !c.insideAddressOf {
+							// Only mark as struct value if not inside address-of operator
+							c.tsw.WriteLiterally("$.markAsStructValue(new ")
+							needsValueMarkerClose = true
+						} else {
+							c.tsw.WriteLiterally("new ")
+						}
 						c.WriteTypeExpr(exp.Type)
 					}
 				}
@@ -241,8 +248,14 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 							return err
 						}
 					} else {
-						// Type alias for struct, use constructor
-						c.tsw.WriteLiterally("new ")
+						// Type alias for struct value, use constructor
+						if !c.insideAddressOf {
+							// Only mark as struct value if not inside address-of operator
+							c.tsw.WriteLiterally("$.markAsStructValue(new ")
+							needsValueMarkerClose = true
+						} else {
+							c.tsw.WriteLiterally("new ")
+						}
 						c.WriteTypeExpr(exp.Type)
 					}
 				}
@@ -483,6 +496,10 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					c.tsw.WriteLiterally("}")
 				} else {
 					c.tsw.WriteLiterally("})")
+					// Close markAsStructValue wrapper if we opened one
+					if needsValueMarkerClose {
+						c.tsw.WriteLiterally(")")
+					}
 				}
 
 			} else {

package/compiler/expr-call.go

@@ -349,9 +349,47 @@ func (c *GoToTSCompiler) writeWrapperTypeMethodCall(exp *ast.CallExpr, selectorE
 	c.tsw.WriteLiterally(selectorExpr.Sel.Name)
 	c.tsw.WriteLiterally("(")
 
-	// First argument is the receiver
-	if err := c.WriteValueExpr(selectorExpr.X); err != nil {
-		return true, fmt.Errorf("failed to write wrapper type method receiver: %w", err)
+	// Write the receiver (the object the method is called on)
+	// For pointer receiver methods, we need to pass the VarRef instead of the value
+	receiverNeedsVarRef := false
+
+	// Check if the method has a pointer receiver by looking at the method signature
+	if selection := c.pkg.TypesInfo.Selections[selectorExpr]; selection != nil {
+		if methodObj := selection.Obj(); methodObj != nil {
+			if methodFunc, ok := methodObj.(*types.Func); ok {
+				if sig, ok := methodFunc.Type().(*types.Signature); ok && sig != nil {
+					if recv := sig.Recv(); recv != nil {
+						if _, isPointer := recv.Type().(*types.Pointer); isPointer {
+							receiverNeedsVarRef = true
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if receiverNeedsVarRef {
+		// For pointer receivers, we need to pass the VarRef
+		// Convert p.field to p._fields.field
+		if selExpr, ok := selectorExpr.X.(*ast.SelectorExpr); ok {
+			if baseIdent, ok := selExpr.X.(*ast.Ident); ok {
+				c.tsw.WriteLiterally(baseIdent.Name)
+				c.tsw.WriteLiterally("._fields.")
+				c.tsw.WriteLiterally(selExpr.Sel.Name)
+			} else {
+				if err := c.WriteValueExpr(selectorExpr.X); err != nil {
+					return true, fmt.Errorf("failed to write wrapper type method receiver: %w", err)
+				}
+			}
+		} else {
+			if err := c.WriteValueExpr(selectorExpr.X); err != nil {
+				return true, fmt.Errorf("failed to write wrapper type method receiver: %w", err)
+			}
+		}
+	} else {
+		if err := c.WriteValueExpr(selectorExpr.X); err != nil {
+			return true, fmt.Errorf("failed to write wrapper type method receiver: %w", err)
+		}
 	}
 
 	// Add other arguments

package/compiler/expr-selector.go

@@ -239,24 +239,24 @@ func (c *GoToTSCompiler) writeMethodValue(exp *ast.SelectorExpr, selection *type
 		// The receiver should be a copy of the dereferenced value
 		c.tsw.WriteLiterally(".value.")
 		c.WriteIdent(exp.Sel, false)
-		c.tsw.WriteLiterally(".bind(")
+		c.tsw.WriteLiterally(".bind($.markAsStructValue(")
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write method value receiver for binding: %w", err)
 		}
-		c.tsw.WriteLiterally("!.value.clone())")
+		c.tsw.WriteLiterally("!.value.clone()))")
 	} else if !isPointerReceiver && !baseIsPointer {
 		// Value receiver method on value type: t.Mv
 		// The receiver should be a copy of the value
 		c.tsw.WriteLiterally(".")
 		c.WriteIdent(exp.Sel, false)
-		c.tsw.WriteLiterally(".bind(")
+		c.tsw.WriteLiterally(".bind($.markAsStructValue(")
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write method value receiver for binding: %w", err)
 		}
 		if baseIsPointer {
 			c.tsw.WriteLiterally("!")
 		}
-		c.tsw.WriteLiterally(".clone())")
+		c.tsw.WriteLiterally(".clone()))")
 	} else {
 		// Pointer receiver method on pointer type: pt.Mp
 		// The receiver should be the pointer itself

package/compiler/expr.go

@@ -382,9 +382,45 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	// Compare the varRef objects directly using === or !==
 	if c.isPointerComparison(exp) {
 		c.tsw.WriteLiterally("(") // Wrap comparison
-		if err := c.WriteValueExpr(exp.X); err != nil {
-			return fmt.Errorf("failed to write binary expression left operand: %w", err)
+
+		// For pointer comparisons, we need to handle variable varref status
+		// If a variable is varref'd, we need its .value to get the actual pointer value
+
+		// Check if operands are varref'd variables
+		var leftObj, rightObj types.Object
+		leftIsVarRef := false
+		rightIsVarRef := false
+
+		if leftIdent, ok := exp.X.(*ast.Ident); ok {
+			leftObj = c.pkg.TypesInfo.ObjectOf(leftIdent)
+			if leftObj != nil {
+				leftIsVarRef = c.analysis.NeedsVarRef(leftObj)
+			}
+		}
+
+		if rightIdent, ok := exp.Y.(*ast.Ident); ok {
+			rightObj = c.pkg.TypesInfo.ObjectOf(rightIdent)
+			if rightObj != nil {
+				rightIsVarRef = c.analysis.NeedsVarRef(rightObj)
+			}
 		}
+
+		// Write left operand
+		if leftIdent, ok := exp.X.(*ast.Ident); ok {
+			if leftIsVarRef {
+				// Variable is varref'd, access its .value to get the pointer
+				c.WriteIdent(leftIdent, true)
+			} else {
+				// Variable is not varref'd, use it directly
+				c.WriteIdent(leftIdent, false)
+			}
+		} else {
+			// For non-identifiers, use WriteValueExpr
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return fmt.Errorf("failed to write binary expression left operand: %w", err)
+			}
+		}
+
 		c.tsw.WriteLiterally(" ")
 		// Use === for == and !== for !=
 		tokStr := ""
@@ -398,9 +434,23 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		}
 		c.tsw.WriteLiterally(tokStr)
 		c.tsw.WriteLiterally(" ")
-		if err := c.WriteValueExpr(exp.Y); err != nil {
-			return fmt.Errorf("failed to write binary expression right operand: %w", err)
+
+		// Write right operand
+		if rightIdent, ok := exp.Y.(*ast.Ident); ok {
+			if rightIsVarRef {
+				// Variable is varref'd, access its .value to get the pointer
+				c.WriteIdent(rightIdent, true)
+			} else {
+				// Variable is not varref'd, use it directly
+				c.WriteIdent(rightIdent, false)
+			}
+		} else {
+			// For non-identifiers, use WriteValueExpr
+			if err := c.WriteValueExpr(exp.Y); err != nil {
+				return fmt.Errorf("failed to write binary expression right operand: %w", err)
+			}
 		}
+
 		c.tsw.WriteLiterally(")") // Close wrap
 		return nil
 	}
@@ -503,12 +553,21 @@ func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 			}
 		}
 
+		// Note: With inversion to markAsStructValue, we no longer mark &CompositeLit{}
+		// since we now mark the CompositeLit{} (struct values) instead of pointers
+
 		// Otherwise (&unvarrefedVar, &CompositeLit{}, &FuncCall(), etc.),
 		// the address-of operator in Go, when used to create a pointer,
 		// translates to simply evaluating the operand in TypeScript.
 		// The resulting value (e.g., a new object instance) acts as the "pointer".
 		// VarRefing decisions are handled at the assignment site based on the LHS variable.
-		if err := c.WriteValueExpr(exp.X); err != nil {
+
+		// Set context flag to prevent marking composite literals as struct values
+		c.insideAddressOf = true
+		err := c.WriteValueExpr(exp.X)
+		c.insideAddressOf = false
+
+		if err != nil {
 			return fmt.Errorf("failed to write &-operand: %w", err)
 		}