goscript 0.0.40 → 0.0.42

package/compiler/analysis.go

@@ -43,6 +43,14 @@ type VariableUsageInfo struct {
 	Destinations []AssignmentInfo
 }
 
+// ShadowingInfo tracks variable shadowing in if statement initializations
+type ShadowingInfo struct {
+	// ShadowedVariables maps shadowed variable names to their outer scope objects
+	ShadowedVariables map[string]types.Object
+	// TempVariables maps shadowed variable names to temporary variable names
+	TempVariables map[string]string
+}
+
 // FunctionTypeInfo represents Go function type information for reflection
 type FunctionTypeInfo struct {
 	Params   []types.Type // Parameter types
@@ -69,8 +77,9 @@ type NodeInfo struct {
 	IsBareReturn      bool
 	EnclosingFuncDecl *ast.FuncDecl
 	EnclosingFuncLit  *ast.FuncLit
-	IsInsideFunction  bool // true if this declaration is inside a function body
-	IsMethodValue     bool // true if this SelectorExpr is a method value that needs binding
+	IsInsideFunction  bool           // true if this declaration is inside a function body
+	IsMethodValue     bool           // true if this SelectorExpr is a method value that needs binding
+	ShadowingInfo     *ShadowingInfo // variable shadowing information for if statements
 }
 
 // Analysis holds information gathered during the analysis phase of the Go code compilation.
@@ -270,6 +279,30 @@ func (a *Analysis) IsMethodValue(node *ast.SelectorExpr) bool {
 	return nodeInfo.IsMethodValue
 }
 
+// HasVariableShadowing returns whether the given node has variable shadowing issues
+func (a *Analysis) HasVariableShadowing(node ast.Node) bool {
+	if node == nil {
+		return false
+	}
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.ShadowingInfo != nil
+}
+
+// GetShadowingInfo returns the variable shadowing information for the given node
+func (a *Analysis) GetShadowingInfo(node ast.Node) *ShadowingInfo {
+	if node == nil {
+		return nil
+	}
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return nil
+	}
+	return nodeInfo.ShadowingInfo
+}
+
 // analysisVisitor implements ast.Visitor and is used to traverse the AST during analysis.
 type analysisVisitor struct {
 	// analysis stores information gathered during the traversal
@@ -631,6 +664,19 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		return v // Continue traversal
 
 	case *ast.AssignStmt:
+		// Detect variable shadowing in any := assignment
+		if n.Tok == token.DEFINE {
+			shadowingInfo := v.detectVariableShadowing(n)
+			if shadowingInfo != nil {
+				// Store shadowing info on the assignment statement itself
+				if v.analysis.NodeData[n] == nil {
+					v.analysis.NodeData[n] = &NodeInfo{}
+				}
+				v.analysis.NodeData[n].ShadowingInfo = shadowingInfo
+			}
+		}
+
+		// Continue with the existing assignment analysis logic
 		for i, currentLHSExpr := range n.Lhs {
 			if i >= len(n.Rhs) {
 				break // Should not happen in valid Go
@@ -779,6 +825,22 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			}
 		}
 		return v // Continue traversal
+
+	case *ast.IfStmt:
+		// Detect variable shadowing in if statement initializations
+		if n.Init != nil {
+			if assignStmt, ok := n.Init.(*ast.AssignStmt); ok && assignStmt.Tok == token.DEFINE {
+				shadowingInfo := v.detectVariableShadowing(assignStmt)
+				if shadowingInfo != nil {
+					// Initialize NodeData for this if statement
+					if v.analysis.NodeData[n] == nil {
+						v.analysis.NodeData[n] = &NodeInfo{}
+					}
+					v.analysis.NodeData[n].ShadowingInfo = shadowingInfo
+				}
+			}
+		}
+		return v // Continue traversal
 	}
 
 	// For all other nodes, continue traversal
@@ -1225,3 +1287,112 @@ func (v *analysisVisitor) markFunctionVariable(ident *ast.Ident, funcType *types
 		v.analysis.MarkFunctionForReflection(funcNode, funcType)
 	}
 }
+
+// detectVariableShadowing detects variable shadowing in any := assignment
+func (v *analysisVisitor) detectVariableShadowing(assignStmt *ast.AssignStmt) *ShadowingInfo {
+	shadowingInfo := &ShadowingInfo{
+		ShadowedVariables: make(map[string]types.Object),
+		TempVariables:     make(map[string]string),
+	}
+
+	hasShadowing := false
+
+	// First, collect all LHS variable names that are being declared
+	lhsVarNames := make(map[string]*ast.Ident)
+	for _, lhsExpr := range assignStmt.Lhs {
+		if lhsIdent, ok := lhsExpr.(*ast.Ident); ok && lhsIdent.Name != "_" {
+			lhsVarNames[lhsIdent.Name] = lhsIdent
+		}
+	}
+
+	// Next, check all RHS expressions for usage of variables that are also being declared on LHS
+	for _, rhsExpr := range assignStmt.Rhs {
+		v.findVariableUsageInExpr(rhsExpr, lhsVarNames, shadowingInfo, &hasShadowing)
+	}
+
+	if hasShadowing {
+		return shadowingInfo
+	}
+	return nil
+}
+
+// findVariableUsageInExpr recursively searches for variable usage in an expression
+func (v *analysisVisitor) findVariableUsageInExpr(expr ast.Expr, lhsVarNames map[string]*ast.Ident, shadowingInfo *ShadowingInfo, hasShadowing *bool) {
+	if expr == nil {
+		return
+	}
+
+	switch e := expr.(type) {
+	case *ast.Ident:
+		// Check if this identifier is being shadowed
+		if lhsIdent, exists := lhsVarNames[e.Name]; exists {
+			// This variable is being used on RHS but also declared on LHS - this is shadowing!
+
+			// Get the outer scope object for this variable
+			if outerObj := v.pkg.TypesInfo.Uses[e]; outerObj != nil {
+				// Make sure this isn't the same object as the LHS (which would mean no shadowing)
+				if lhsObj := v.pkg.TypesInfo.Defs[lhsIdent]; lhsObj != outerObj {
+					shadowingInfo.ShadowedVariables[e.Name] = outerObj
+					shadowingInfo.TempVariables[e.Name] = "_temp_" + e.Name
+					*hasShadowing = true
+				}
+			}
+		}
+
+	case *ast.CallExpr:
+		// Check function arguments
+		for _, arg := range e.Args {
+			v.findVariableUsageInExpr(arg, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+		// Check function expression itself
+		v.findVariableUsageInExpr(e.Fun, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.SelectorExpr:
+		// Check the base expression (e.g., x in x.Method())
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.IndexExpr:
+		// Check both the expression and index (e.g., arr[i])
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+		v.findVariableUsageInExpr(e.Index, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.SliceExpr:
+		// Check the expression and slice bounds
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+		if e.Low != nil {
+			v.findVariableUsageInExpr(e.Low, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+		if e.High != nil {
+			v.findVariableUsageInExpr(e.High, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+		if e.Max != nil {
+			v.findVariableUsageInExpr(e.Max, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+
+	case *ast.UnaryExpr:
+		// Check the operand (e.g., &x, -x, !x)
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.BinaryExpr:
+		// Check both operands (e.g., x + y)
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+		v.findVariableUsageInExpr(e.Y, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.ParenExpr:
+		// Check the parenthesized expression
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.TypeAssertExpr:
+		// Check the expression being type-asserted
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.StarExpr:
+		// Check the expression being dereferenced
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	// Add more expression types as needed
+	default:
+		// For other expression types, we might need to add specific handling
+		// For now, we'll ignore them as they're less common in shadowing scenarios
+	}
+}

package/compiler/compiler.go

@@ -593,7 +593,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.WriteLinef("import * as $ from %q;", "@goscript/builtin/builtin.js")
+	c.codeWriter.WriteLinef("import * as $ from %q;", "@goscript/builtin/index.js")
 
 	// Check if there are any .pb.go files in this package and add imports for them
 	if err := c.addProtobufImports(); err != nil {
@@ -639,6 +639,9 @@ type GoToTSCompiler struct {
 	pkg *packages.Package
 
 	analysis *Analysis
+
+	// shadowingContext tracks temporary variable mappings when we're in a shadowing context
+	shadowingContext map[string]string
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,
@@ -646,9 +649,10 @@ type GoToTSCompiler struct {
 // analysis results (`Analysis`) to guide the translation process.
 func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analysis) *GoToTSCompiler {
 	return &GoToTSCompiler{
-		tsw:      tsw,
-		pkg:      pkg,
-		analysis: analysis,
+		tsw:              tsw,
+		pkg:              pkg,
+		analysis:         analysis,
+		shadowingContext: make(map[string]string),
 	}
 }
 
@@ -670,6 +674,12 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 		return
 	}
 
+	// Check if we're in a shadowing context and should use a temporary variable
+	if tempVarName, exists := c.shadowingContext[exp.Name]; exists {
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(tempVarName))
+		return
+	}
+
 	// Use TypesInfo to find the object associated with the identifier
 	var obj types.Object
 	obj = c.pkg.TypesInfo.Uses[exp]

package/compiler/expr-type.go

@@ -20,6 +20,31 @@ import (
 // - Interface types -> TypeScript interface types or "any"
 // - Function types -> TypeScript function signatures
 func (c *GoToTSCompiler) WriteTypeExpr(a ast.Expr) {
+	// Handle selector expressions (e.g., os.FileInfo) specially to preserve qualified names
+	if selectorExpr, ok := a.(*ast.SelectorExpr); ok {
+		if pkgIdent, ok := selectorExpr.X.(*ast.Ident); ok {
+			// Check if this is a package selector (e.g., os.FileInfo)
+			if obj := c.pkg.TypesInfo.Uses[pkgIdent]; obj != nil {
+				if _, isPkg := obj.(*types.PkgName); isPkg {
+					// This is a package.Type reference - write the qualified name
+					c.tsw.WriteLiterally(pkgIdent.Name)
+					c.tsw.WriteLiterally(".")
+					c.tsw.WriteLiterally(selectorExpr.Sel.Name)
+
+					// Check if this is a function type and add | null
+					if typ := c.pkg.TypesInfo.TypeOf(a); typ != nil {
+						if namedType, isNamed := typ.(*types.Named); isNamed {
+							if _, isSignature := namedType.Underlying().(*types.Signature); isSignature {
+								c.tsw.WriteLiterally(" | null")
+							}
+						}
+					}
+					return
+				}
+			}
+		}
+	}
+
 	// Get type information for the expression and use WriteGoType
 	typ := c.pkg.TypesInfo.TypeOf(a)
 	c.WriteGoType(typ, GoTypeContextGeneral)

package/compiler/field.go

@@ -52,8 +52,8 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 				}
 				c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 				c.tsw.WriteLiterally(": ")
-				typ := c.pkg.TypesInfo.TypeOf(field.Type)
-				c.WriteGoType(typ, GoTypeContextGeneral)
+				// Use WriteTypeExpr to preserve qualified names like os.FileInfo
+				c.WriteTypeExpr(field.Type)
 			}
 		}
 
@@ -102,8 +102,8 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 					}
 					c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 					c.tsw.WriteLiterally(": ")
-					typ := c.pkg.TypesInfo.TypeOf(field.Type)
-					c.WriteGoType(typ, GoTypeContextGeneral) // Use WriteGoType for parameter type
+					// Use WriteTypeExpr to preserve qualified names like os.FileInfo
+					c.WriteTypeExpr(field.Type)
 				}
 			} else {
 				// For struct fields and other non-argument fields

package/compiler/spec.go

@@ -539,7 +539,7 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 	// handwritten versions (in .goscript-assets) or transpiled versions (in goscript).
 	var tsImportPath string
 	if goPath == "github.com/aperturerobotics/goscript/builtin" {
-		tsImportPath = "@goscript/builtin/builtin.js"
+		tsImportPath = "@goscript/builtin/index.js"
 	} else {
 		tsImportPath = "@goscript/" + goPath
 	}

package/compiler/stmt.go

@@ -444,53 +444,90 @@ func (c *GoToTSCompiler) WriteStmtSend(exp *ast.SendStmt) error {
 //     recursively calling `WriteStmtIf`.
 //
 // The function aims to produce idiomatic TypeScript `if/else if/else` structures.
-func (s *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
+func (c *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 	if exp.Init != nil {
-		s.tsw.WriteLiterally("{") // Write opening brace
-		s.tsw.WriteLine("")       // Add newline immediately after opening brace
-		s.tsw.Indent(1)           // Indent for the initializer
+		// Check if we need to handle variable shadowing BEFORE creating the block
+		var shadowingInfo *ShadowingInfo
+		if assignStmt, ok := exp.Init.(*ast.AssignStmt); ok {
+			shadowingInfo = c.analysis.GetShadowingInfo(assignStmt)
+		}
+
+		// Generate temporary variables OUTSIDE the block to avoid temporal dead zone
+		if shadowingInfo != nil {
+			for varName, tempVarName := range shadowingInfo.TempVariables {
+				c.tsw.WriteLiterally("let ")
+				c.tsw.WriteLiterally(tempVarName)
+				c.tsw.WriteLiterally(" = ")
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(varName))
+				c.tsw.WriteLine("")
+			}
+		}
 
-		if err := s.WriteStmt(exp.Init); err != nil { // Write the initializer
-			return err
+		c.tsw.WriteLiterally("{") // Write opening brace
+		c.tsw.WriteLine("")       // Add newline immediately after opening brace
+		c.tsw.Indent(1)           // Indent for the initializer
+
+		// Check if we need to handle variable shadowing
+		if assignStmt, ok := exp.Init.(*ast.AssignStmt); ok {
+			if shadowingInfo != nil {
+				// Write the assignment statement with special handling for shadowing
+				if err := c.writeShadowedAssignment(assignStmt, shadowingInfo); err != nil {
+					return err
+				}
+			} else {
+				// No shadowing, write normally
+				if err := c.WriteStmt(exp.Init); err != nil {
+					return err
+				}
+			}
+		} else {
+			// Not an assignment statement, write normally
+			if err := c.WriteStmt(exp.Init); err != nil {
+				return err
+			}
 		}
 
 		// This defer handles closing the synthetic block for the initializer
 		defer func() {
-			s.tsw.Indent(-1)
-			s.tsw.WriteLiterally("}") // Write the closing brace at the now-correct indent level
-			s.tsw.WriteLine("")       // Ensure a newline *after* this '}', critical for preventing '}}'
+			c.tsw.Indent(-1)
+			c.tsw.WriteLiterally("}") // Write the closing brace at the now-correct indent level
+			c.tsw.WriteLine("")       // Ensure a newline *after* this '}', critical for preventing '}}'
 		}()
 	}
 
-	s.tsw.WriteLiterally("if (")
-	if err := s.WriteValueExpr(exp.Cond); err != nil { // Condition is a value
+	// Ensure shadowing context is clear before writing condition
+	// (condition should refer to new local variables, not temp variables)
+	c.shadowingContext = make(map[string]string)
+
+	c.tsw.WriteLiterally("if (")
+	if err := c.WriteValueExpr(exp.Cond); err != nil { // Condition is a value
 		return err
 	}
-	s.tsw.WriteLiterally(") ")
+	c.tsw.WriteLiterally(") ")
 
 	if exp.Body != nil {
-		if err := s.WriteStmtBlock(exp.Body, exp.Else != nil); err != nil {
+		if err := c.WriteStmtBlock(exp.Body, exp.Else != nil); err != nil {
 			return fmt.Errorf("failed to write if body block statement: %w", err)
 		}
 	} else {
 		// Handle nil body case using WriteStmtBlock with an empty block
-		if err := s.WriteStmtBlock(&ast.BlockStmt{}, exp.Else != nil); err != nil {
+		if err := c.WriteStmtBlock(&ast.BlockStmt{}, exp.Else != nil); err != nil {
 			return fmt.Errorf("failed to write empty block statement in if statement: %w", err)
 		}
 	}
 
 	// handle else branch
 	if exp.Else != nil {
-		s.tsw.WriteLiterally(" else ")
+		c.tsw.WriteLiterally(" else ")
 		switch elseStmt := exp.Else.(type) {
 		case *ast.BlockStmt:
 			// Always pass false for suppressNewline here
-			if err := s.WriteStmtBlock(elseStmt, false); err != nil {
+			if err := c.WriteStmtBlock(elseStmt, false); err != nil {
 				return fmt.Errorf("failed to write else block statement in if statement: %w", err)
 			}
 		case *ast.IfStmt:
 			// Recursive call handles its own block formatting
-			if err := s.WriteStmtIf(elseStmt); err != nil {
+			if err := c.WriteStmtIf(elseStmt); err != nil {
 				return fmt.Errorf("failed to write else if statement in if statement: %w", err)
 			}
 		}
@@ -897,3 +934,67 @@ func (c *GoToTSCompiler) WriteStmtLabeled(stmt *ast.LabeledStmt) error {
 
 	return nil
 }
+
+// writeShadowedAssignment writes an assignment statement that has variable shadowing,
+// applying the shadowing context only to RHS expressions.
+func (c *GoToTSCompiler) writeShadowedAssignment(stmt *ast.AssignStmt, shadowingInfo *ShadowingInfo) error {
+	// Write the LHS variables (these are new declarations, don't use temp variables)
+	for i, lhsExpr := range stmt.Lhs {
+		if i > 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+
+		if ident, ok := lhsExpr.(*ast.Ident); ok {
+			if ident.Name == "_" {
+				c.tsw.WriteLiterally("_")
+			} else {
+				c.tsw.WriteLiterally("let ")
+				c.WriteIdent(ident, false) // Don't use temp variable for LHS
+			}
+		} else {
+			// For non-identifier LHS (shouldn't happen in := assignments), write normally
+			if err := c.WriteValueExpr(lhsExpr); err != nil {
+				return err
+			}
+		}
+	}
+
+	c.tsw.WriteLiterally(" = ")
+
+	// Set up shadowing context for RHS expressions only
+	originalContext := make(map[string]string)
+	for varName, tempVarName := range shadowingInfo.TempVariables {
+		originalContext[varName] = c.shadowingContext[varName] // backup original
+		c.shadowingContext[varName] = tempVarName
+	}
+
+	// Write RHS expressions with shadowing context
+	for i, rhsExpr := range stmt.Rhs {
+		if i > 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		if err := c.WriteValueExpr(rhsExpr); err != nil {
+			// Restore context on error
+			for varName := range shadowingInfo.TempVariables {
+				if original, existed := originalContext[varName]; existed {
+					c.shadowingContext[varName] = original
+				} else {
+					delete(c.shadowingContext, varName)
+				}
+			}
+			return err
+		}
+	}
+
+	// Restore original context after writing RHS
+	for varName := range shadowingInfo.TempVariables {
+		if original, existed := originalContext[varName]; existed {
+			c.shadowingContext[varName] = original
+		} else {
+			delete(c.shadowingContext, varName)
+		}
+	}
+
+	c.tsw.WriteLine("")
+	return nil
+}

package/compiler/type.go

@@ -259,6 +259,11 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 					}
 					c.tsw.WriteLiterally(">")
 				}
+
+				// Check if the underlying type is a function signature and add | null
+				if _, isSignature := t.Underlying().(*types.Signature); isSignature {
+					c.tsw.WriteLiterally(" | null")
+				}
 				return
 			}
 
@@ -282,6 +287,11 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 					}
 					c.tsw.WriteLiterally(">")
 				}
+
+				// Check if the underlying type is a function signature and add | null
+				if _, isSignature := t.Underlying().(*types.Signature); isSignature {
+					c.tsw.WriteLiterally(" | null")
+				}
 				return
 			}
 		}
@@ -301,6 +311,11 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 		}
 		c.tsw.WriteLiterally(">")
 	}
+
+	// Check if the underlying type is a function signature and add | null for local types too
+	if _, isSignature := t.Underlying().(*types.Signature); isSignature {
+		c.tsw.WriteLiterally(" | null")
+	}
 }
 
 // WritePointerType translates a Go pointer type (*T) to its TypeScript equivalent.
@@ -400,8 +415,8 @@ func (c *GoToTSCompiler) WriteFuncType(exp *ast.FuncType, isAsync bool) {
 		}
 		if len(exp.Results.List) == 1 {
 			// Single return type (named or unnamed)
-			typ := c.pkg.TypesInfo.TypeOf(exp.Results.List[0].Type)
-			c.WriteGoType(typ, GoTypeContextFunctionReturn)
+			// Use WriteTypeExpr to preserve qualified names like os.FileInfo
+			c.WriteTypeExpr(exp.Results.List[0].Type)
 		} else {
 			// Multiple return types -> tuple
 			c.tsw.WriteLiterally("[")
@@ -409,8 +424,8 @@ func (c *GoToTSCompiler) WriteFuncType(exp *ast.FuncType, isAsync bool) {
 				if i > 0 {
 					c.tsw.WriteLiterally(", ")
 				}
-				typ := c.pkg.TypesInfo.TypeOf(field.Type)
-				c.WriteGoType(typ, GoTypeContextFunctionReturn)
+				// Use WriteTypeExpr to preserve qualified names like os.FileInfo
+				c.WriteTypeExpr(field.Type)
 			}
 			c.tsw.WriteLiterally("]")
 		}

package/dist/gs/builtin/builtin.d.ts

@@ -1,14 +1,16 @@
-export * from './varRef.js';
-export * from './channel.js';
-export * from './defer.js';
-export * from './io.js';
-export * from './map.js';
-export * from './slice.js';
-export * from './type.js';
 import type { Slice } from './slice.js';
+/**
+ * Implementation of Go's built-in println function
+ * @param args Arguments to print
+ */
+export declare function println(...args: any[]): void;
+/**
+ * Implementation of Go's built-in panic function
+ * @param args Arguments passed to panic
+ */
+export declare function panic(...args: any[]): void;
 export type Bytes = Uint8Array | Slice<number>;
 export declare function int(value: number): number;
-export declare function copy<T>(dst: T[] | Uint8Array, src: T[] | Uint8Array | string): number;
 export declare function multiplyDuration(duration: any, multiplier: number): any;
 /**
  * Normalizes various byte representations into a `Uint8Array` for protobuf compatibility.

package/dist/gs/builtin/builtin.js

@@ -1,11 +1,18 @@
-export * from './varRef.js';
-export * from './channel.js';
-export * from './defer.js';
-export * from './io.js';
-export * from './map.js';
-export * from './slice.js';
-export * from './type.js';
 import { isSliceProxy } from './slice.js';
+/**
+ * Implementation of Go's built-in println function
+ * @param args Arguments to print
+ */
+export function println(...args) {
+    console.log(...args);
+}
+/**
+ * Implementation of Go's built-in panic function
+ * @param args Arguments passed to panic
+ */
+export function panic(...args) {
+    throw new Error(`panic: ${args.map((arg) => String(arg)).join(' ')}`);
+}
 // int converts a value to a Go int type, handling proper signed integer conversion
 // This ensures that values like 2147483648 (2^31) are properly handled according to Go semantics
 export function int(value) {
@@ -17,52 +24,6 @@ export function int(value) {
     // since JavaScript numbers can safely represent integers up to Number.MAX_SAFE_INTEGER
     return Math.trunc(value);
 }
-// Copy is the Go builtin function that copies the contents of one slice to another.
-// It returns the number of elements copied.
-export function copy(dst, src) {
-    // Handle string to Uint8Array copy (common in Go)
-    if (typeof src === 'string' && dst instanceof Uint8Array) {
-        const encoder = new TextEncoder();
-        const srcBytes = encoder.encode(src);
-        const n = Math.min(dst.length, srcBytes.length);
-        for (let i = 0; i < n; i++) {
-            dst[i] = srcBytes[i];
-        }
-        return n;
-    }
-    // Handle Uint8Array to Uint8Array copy
-    if (dst instanceof Uint8Array && src instanceof Uint8Array) {
-        const n = Math.min(dst.length, src.length);
-        for (let i = 0; i < n; i++) {
-            dst[i] = src[i];
-        }
-        return n;
-    }
-    // Handle array to array copy (original implementation)
-    if (Array.isArray(dst) && Array.isArray(src)) {
-        const n = Math.min(dst.length, src.length);
-        for (let i = 0; i < n; i++) {
-            dst[i] = src[i];
-        }
-        return n;
-    }
-    // Handle mixed types - convert to compatible format
-    if (dst instanceof Uint8Array && Array.isArray(src)) {
-        const n = Math.min(dst.length, src.length);
-        for (let i = 0; i < n; i++) {
-            dst[i] = src[i];
-        }
-        return n;
-    }
-    if (Array.isArray(dst) && src instanceof Uint8Array) {
-        const n = Math.min(dst.length, src.length);
-        for (let i = 0; i < n; i++) {
-            dst[i] = src[i];
-        }
-        return n;
-    }
-    throw new Error(`Unsupported copy operation between ${typeof dst} and ${typeof src}`);
-}
 // Duration multiplication helper for time package operations
 // Handles expressions like time.Hour * 24
 export function multiplyDuration(duration, multiplier) {