goscript 0.0.62 → 0.0.63

package/compiler/analysis_test.go

@@ -12,7 +12,7 @@ import (
 )
 
 // TestAnalysisVarRefLogic verifies that the analysis correctly identifies
-// which variables need variable references based on actual compliance test cases
+// which variables need variable references based on actual tests test cases
 func TestAnalysisVarRefLogic(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -235,8 +235,8 @@ func main() {
 
 // TestWrapperTypeDetection verifies that the analysis correctly identifies wrapper types
 func TestWrapperTypeDetection(t *testing.T) {
-	// Use the actual compliance test case
-	testPath := "../compliance/tests/wrapper_type_args"
+	// Use the actual tests test case
+	testPath := "../tests/tests/wrapper_type_args"
 
 	// Load the package using the packages config like the main compiler does
 	cfg := &packages.Config{

package/compiler/assignment.go

@@ -148,9 +148,32 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		}
 	}
 
+	// Check for integer division compound assignment (i /= n)
+	// Go's integer division truncates, but JavaScript's /= doesn't
+	// We need to convert `i /= n` to `i = Math.trunc(i / n)`
+	isIntegerDivisionAssign := false
+	if tok == token.QUO_ASSIGN && len(lhs) == 1 && len(rhs) == 1 {
+		if lhsType := c.pkg.TypesInfo.TypeOf(lhs[0]); lhsType != nil {
+			if basic, ok := lhsType.Underlying().(*types.Basic); ok {
+				if basic.Info()&types.IsInteger != 0 {
+					isIntegerDivisionAssign = true
+				}
+			}
+		}
+	}
+
 	// Only write the assignment operator for regular variables, not for map assignments handled by mapSet
 	if isMapIndexLHS && len(lhs) == 1 { // Only skip operator if it's a single map assignment
 		// Continue, we've already written part of the mapSet() function call
+	} else if isIntegerDivisionAssign {
+		// For integer division compound assignment, convert `i /= n` to `i = Math.trunc(i / n)`
+		c.tsw.WriteLiterally(" = Math.trunc(")
+		// Write LHS again as first operand of division
+		if err := c.WriteValueExpr(lhs[0]); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(" / ")
+		// RHS will be written below, then we close the parenthesis
 	} else {
 		c.tsw.WriteLiterally(" ")
 		if err := c.writeAssignmentOperator(tok); err != nil {
@@ -298,6 +321,11 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		c.tsw.WriteLiterally(")")
 	}
 
+	// Close the parenthesis for integer division compound assignment
+	if isIntegerDivisionAssign {
+		c.tsw.WriteLiterally(")")
+	}
+
 	// If the LHS was a single map index, close the mapSet call
 	if isMapIndexLHS && len(lhs) == 1 {
 		c.tsw.WriteLiterally(")")

package/compiler/builtin_test.go

@@ -24,7 +24,7 @@ func TestEmitBuiltinOption(t *testing.T) {
 	log.SetLevel(logrus.DebugLevel)
 	le := logrus.NewEntry(log)
 
-	// Case 1: DisableEmitBuiltin = true (default behavior in compliance tests)
+	// Case 1: DisableEmitBuiltin = true (default behavior in tests tests)
 	t.Run("DisableEmitBuiltin=true", func(t *testing.T) {
 		outputDir := filepath.Join(tempDir, "disabled")
 		config := &Config{

package/compiler/compiler.go

@@ -593,7 +593,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 	c.codeWriter = NewTSCodeWriter(of)
 
 	// Pass analysis to compiler
-	goWriter := NewGoToTSCompiler(c.codeWriter, c.pkg, c.Analysis)
+	goWriter := NewGoToTSCompiler(c.codeWriter, c.pkg, c.Analysis, c.fullPath)
 
 	// Add import for the goscript runtime using namespace import and alias
 	c.codeWriter.WriteLinef("import * as $ from %q", "@goscript/builtin/index.js")
@@ -701,15 +701,18 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 	}
 
 	// Write synthetic imports (for promoted methods from embedded structs)
-	// Sort by package name for consistent output
-	var syntheticPkgNames []string
-	for pkgName := range c.Analysis.SyntheticImports {
-		syntheticPkgNames = append(syntheticPkgNames, pkgName)
-	}
-	slices.Sort(syntheticPkgNames)
-	for _, pkgName := range syntheticPkgNames {
-		imp := c.Analysis.SyntheticImports[pkgName]
-		c.codeWriter.WriteImport(pkgName, imp.importPath+"/index.js")
+	// Use per-file synthetic imports to avoid adding unused imports
+	if syntheticImports := c.Analysis.SyntheticImportsPerFile[c.fullPath]; syntheticImports != nil {
+		// Sort by package name for consistent output
+		var syntheticPkgNames []string
+		for pkgName := range syntheticImports {
+			syntheticPkgNames = append(syntheticPkgNames, pkgName)
+		}
+		slices.Sort(syntheticPkgNames)
+		for _, pkgName := range syntheticPkgNames {
+			imp := syntheticImports[pkgName]
+			c.codeWriter.WriteImport(pkgName, imp.importPath+"/index.js")
+		}
 	}
 
 	c.codeWriter.WriteLine("") // Add a newline after imports
@@ -731,6 +734,10 @@ type GoToTSCompiler struct {
 
 	analysis *Analysis
 
+	// currentFilePath is the path of the file being compiled
+	// Used for looking up per-file synthetic imports
+	currentFilePath string
+
 	// Context flags
 	insideAddressOf bool // true when processing operand of & operator
 
@@ -739,15 +746,15 @@ type GoToTSCompiler struct {
 	renamedVars map[types.Object]string
 }
 
-// It initializes the compiler with a `TSCodeWriter` for output,
-// Go package information (`packages.Package`), and pre-computed
-// analysis results (`Analysis`) to guide the translation process.
-func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analysis) *GoToTSCompiler {
+// NewGoToTSCompiler creates a new GoToTSCompiler with a TSCodeWriter for output,
+// Go package information, pre-computed analysis results, and the current file path.
+func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analysis, filePath string) *GoToTSCompiler {
 	return &GoToTSCompiler{
-		tsw:         tsw,
-		pkg:         pkg,
-		analysis:    analysis,
-		renamedVars: make(map[types.Object]string),
+		tsw:             tsw,
+		pkg:             pkg,
+		analysis:        analysis,
+		currentFilePath: filePath,
+		renamedVars:     make(map[types.Object]string),
 	}
 }
 

package/compiler/compiler_test.go

@@ -12,10 +12,10 @@ import (
 	"sync/atomic"
 	"testing"
 
-	"github.com/aperturerobotics/goscript/compliance"
+	"github.com/aperturerobotics/goscript/tests"
 )
 
-// NOTE: this is here instead of compliance/compliance_test.go so coverage ends up in this package.
+// NOTE: this is here instead of tests/tests_test.go so coverage ends up in this package.
 
 func TestCompliance(t *testing.T) {
 	// Get workspace directory (project root)
@@ -26,7 +26,7 @@ func TestCompliance(t *testing.T) {
 	workspaceDir = filepath.Join(workspaceDir, "..")
 
 	// First collect all test paths
-	testsDir := filepath.Join(workspaceDir, "compliance/tests")
+	testsDir := filepath.Join(workspaceDir, "tests/tests")
 	dirs, err := os.ReadDir(testsDir)
 	if err != nil {
 		t.Fatalf("failed to read tests dir: %v", err)
@@ -50,7 +50,7 @@ func TestCompliance(t *testing.T) {
 	slices.Sort(testPaths)
 
 	// limit concurrency
-	simulLimit := make(chan struct{}, runtime.GOMAXPROCS(-1)*2)
+	simulLimit := make(chan struct{}, runtime.GOMAXPROCS(-1))
 	for range cap(simulLimit) {
 		simulLimit <- struct{}{}
 	}
@@ -71,7 +71,7 @@ func TestCompliance(t *testing.T) {
 				defer func() {
 					simulLimit <- struct{}{}
 				}()
-				compliance.RunGoScriptTestDir(t, workspaceDir, path) // Pass workspaceDir
+				tests.RunGoScriptTestDir(t, workspaceDir, path) // Pass workspaceDir
 
 				// Remove dir if everything passed
 				if !t.Failed() {
@@ -89,13 +89,13 @@ func TestCompliance(t *testing.T) {
 	t.Run("typecheck", func(t *testing.T) {
 		t.Helper()
 		if failed {
-			t.Log("at least one compliance test failed: skipping typecheck")
+			t.Log("at least one tests test failed: skipping typecheck")
 			t.SkipNow()
 		}
 
 		// NOTE: typecheck does not yet pass, so we skip for now.
 		if ranTests.Load() != 0 {
-			t.Log("at least one compliance test ran: skipping typecheck")
+			t.Log("at least one tests test ran: skipping typecheck")
 			t.SkipNow()
 		}
 
@@ -106,7 +106,7 @@ func TestCompliance(t *testing.T) {
 		}
 
 		// Create global typecheck tsconfig
-		tsconfigPath := compliance.WriteGlobalTypeCheckConfig(t, parentModPath, workspaceDir)
+		tsconfigPath := tests.WriteGlobalTypeCheckConfig(t, parentModPath, workspaceDir)
 
 		// Run TypeScript type checking
 		typecheckDir := filepath.Dir(tsconfigPath)
@@ -129,7 +129,7 @@ func TestCompliance(t *testing.T) {
 }
 
 // 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
+// This is similar to the one in tests.go but simplified for use in tests
 func getParentGoModulePath() (string, error) {
 	cmd := exec.Command("go", "list", "-m")
 	output, err := cmd.Output()

package/compiler/expr-call.go

@@ -223,8 +223,8 @@ func (c *GoToTSCompiler) writeArgumentWithTypeHandling(arg ast.Expr, funcSig *ty
 	return nil
 }
 
-// resolveImportAlias returns the import alias for a given package
-// This is the single source of truth for import alias resolution
+// resolveImportAlias returns the import alias for a given package.
+// This is the single source of truth for import alias resolution.
 func (c *GoToTSCompiler) resolveImportAlias(pkg *types.Package) (alias string, found bool) {
 	if c.analysis == nil || pkg == nil {
 		return "", false
@@ -232,11 +232,18 @@ func (c *GoToTSCompiler) resolveImportAlias(pkg *types.Package) (alias string, f
 
 	pkgName := pkg.Name()
 
-	// Try to match by the actual package name
+	// Try to match by the actual package name in regular imports
 	if _, exists := c.analysis.Imports[pkgName]; exists {
 		return pkgName, true
 	}
 
+	// Also check synthetic imports for the current file
+	if syntheticImports := c.analysis.SyntheticImportsPerFile[c.currentFilePath]; syntheticImports != nil {
+		if _, exists := syntheticImports[pkgName]; exists {
+			return pkgName, true
+		}
+	}
+
 	return "", false
 }
 

package/compiler/expr.go

@@ -472,6 +472,26 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		}
 	}
 
+	// Check if this is integer division (Go's / operator truncates for integers)
+	isIntegerDivision := false
+	if exp.Op == token.QUO && c.pkg != nil && c.pkg.TypesInfo != nil {
+		leftType := c.pkg.TypesInfo.TypeOf(exp.X)
+		rightType := c.pkg.TypesInfo.TypeOf(exp.Y)
+		if leftType != nil && rightType != nil {
+			leftBasic, leftIsBasic := leftType.Underlying().(*types.Basic)
+			rightBasic, rightIsBasic := rightType.Underlying().(*types.Basic)
+			if leftIsBasic && rightIsBasic {
+				// Check if both are integer types (not floating point)
+				isIntegerDivision = (leftBasic.Info()&types.IsInteger != 0) && (rightBasic.Info()&types.IsInteger != 0)
+			}
+		}
+	}
+
+	if isIntegerDivision {
+		// Wrap integer division in Math.trunc() to match Go's integer division behavior
+		c.tsw.WriteLiterally("Math.trunc(")
+	}
+
 	if needsNumberCast {
 		c.tsw.WriteLiterally("Number(")
 	}
@@ -495,6 +515,10 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		return fmt.Errorf("failed to write binary expression right operand: %w", err)
 	}
 
+	if isIntegerDivision {
+		c.tsw.WriteLiterally(")") // Close Math.trunc()
+	}
+
 	if isBitwise {
 		c.tsw.WriteLiterally(")") // Add closing parenthesis for bitwise operations
 	}

package/compiler/spec.go

@@ -638,8 +638,10 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 	// Skip writing the import if it was already written as a synthetic import
 	// This prevents duplicate imports when a file needs an import both from
 	// its AST and for promoted methods from embedded structs
-	if _, isSynthetic := c.analysis.SyntheticImports[impName]; isSynthetic {
-		return
+	if syntheticImports := c.analysis.SyntheticImportsPerFile[c.currentFilePath]; syntheticImports != nil {
+		if _, isSynthetic := syntheticImports[impName]; isSynthetic {
+			return
+		}
 	}
 
 	c.tsw.WriteImport(impName, tsImportPath+"/index.js")

package/compiler/stmt-assign.go

@@ -320,6 +320,59 @@ func (c *GoToTSCompiler) writeMultiVarAssignFromCall(lhs []ast.Expr, callExpr *a
 		}
 
 		if allNewVars && anyNewVars {
+			// Check if any variable needs VarRef - if so, we need a different approach
+			anyNeedsVarRef := false
+			needsVarRefVars := make([]bool, len(lhs))
+			for i, lhsExpr := range lhs {
+				if ident, ok := lhsExpr.(*ast.Ident); ok && ident.Name != "_" {
+					if obj := c.pkg.TypesInfo.Defs[ident]; obj != nil {
+						if c.analysis.NeedsVarRef(obj) {
+							needsVarRefVars[i] = true
+							anyNeedsVarRef = true
+						}
+					}
+				}
+			}
+
+			if anyNeedsVarRef {
+				// Use temp variables for destructuring, then wrap in VarRef as needed
+				c.tsw.WriteLiterally("let [")
+				for i, lhsExpr := range lhs {
+					if i != 0 {
+						c.tsw.WriteLiterally(", ")
+					}
+					if ident, ok := lhsExpr.(*ast.Ident); ok {
+						if ident.Name == "_" {
+							// Empty slot for blank identifier
+						} else if needsVarRefVars[i] {
+							c.tsw.WriteLiterally("_varref_tmp_")
+							c.tsw.WriteLiterally(ident.Name)
+						} else {
+							c.WriteIdent(ident, false)
+						}
+					} else {
+						c.WriteValueExpr(lhsExpr)
+					}
+				}
+				c.tsw.WriteLiterally("] = ")
+				c.WriteValueExpr(callExpr)
+				c.tsw.WriteLine("")
+
+				// Now declare the VarRef-wrapped variables
+				for i, lhsExpr := range lhs {
+					if ident, ok := lhsExpr.(*ast.Ident); ok && ident.Name != "_" && needsVarRefVars[i] {
+						c.tsw.WriteLiterally("let ")
+						c.WriteIdent(ident, false)
+						c.tsw.WriteLiterally(" = $.varRef(_varref_tmp_")
+						c.tsw.WriteLiterally(ident.Name)
+						// Add non-null assertion to handle cases where the tuple type includes null
+						c.tsw.WriteLiterally("!)")
+						c.tsw.WriteLine("")
+					}
+				}
+				return nil
+			}
+
 			c.tsw.WriteLiterally("let [")
 
 			for i, lhsExpr := range lhs {

package/compiler/stmt.go

@@ -167,9 +167,17 @@ func (c *GoToTSCompiler) WriteStmtIncDec(stmt *ast.IncDecStmt) error {
 func (c *GoToTSCompiler) WriteStmtBranch(stmt *ast.BranchStmt) error {
 	switch stmt.Tok {
 	case token.BREAK:
-		c.tsw.WriteLine("break") // No semicolon needed
+		if stmt.Label != nil {
+			c.tsw.WriteLinef("break %s", stmt.Label.Name)
+		} else {
+			c.tsw.WriteLine("break")
+		}
 	case token.CONTINUE:
-		c.tsw.WriteLine("continue") // No semicolon needed
+		if stmt.Label != nil {
+			c.tsw.WriteLinef("continue %s", stmt.Label.Name)
+		} else {
+			c.tsw.WriteLine("continue")
+		}
 	case token.GOTO:
 		// TypeScript doesn't support goto, but we can handle it by skipping it
 		// since the labeled statement restructuring should handle the control flow
@@ -484,17 +492,10 @@ func (c *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 		}
 		c.tsw.WriteLiterally(") ")
 
-		if err := c.WriteStmt(exp.Body); err != nil {
+		if err := c.writeIfBody(exp); err != nil {
 			return err
 		}
 
-		if exp.Else != nil {
-			c.tsw.WriteLiterally(" else ")
-			if err := c.WriteStmt(exp.Else); err != nil {
-				return err
-			}
-		}
-
 		c.tsw.Indent(-1)
 		c.tsw.WriteLine("}")
 		return nil
@@ -507,14 +508,31 @@ func (c *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 	}
 	c.tsw.WriteLiterally(") ")
 
-	if err := c.WriteStmt(exp.Body); err != nil {
+	return c.writeIfBody(exp)
+}
+
+// writeIfBody writes the if body and optional else clause, handling newline suppression.
+func (c *GoToTSCompiler) writeIfBody(exp *ast.IfStmt) error {
+	hasElse := exp.Else != nil
+	if err := c.WriteStmtBlock(exp.Body, hasElse); err != nil {
 		return err
 	}
 
-	if exp.Else != nil {
+	if hasElse {
 		c.tsw.WriteLiterally(" else ")
-		if err := c.WriteStmt(exp.Else); err != nil {
-			return err
+		switch elseStmt := exp.Else.(type) {
+		case *ast.BlockStmt:
+			if err := c.WriteStmtBlock(elseStmt, false); err != nil {
+				return err
+			}
+		case *ast.IfStmt:
+			if err := c.WriteStmtIf(elseStmt); err != nil {
+				return err
+			}
+		default:
+			if err := c.WriteStmt(exp.Else); err != nil {
+				return err
+			}
 		}
 	}
 

package/compiler/type-info.go

@@ -26,11 +26,9 @@ func (c *GoToTSCompiler) writeTypeInfoObject(typ types.Type) {
 	underlying := typ.Underlying()
 	switch t := underlying.(type) {
 	case *types.Basic:
-		tsTypeName, _ := GoBuiltinToTypescript(t.Name())
-		if tsTypeName == "" {
-			tsTypeName = t.Name() // Fallback
-		}
-		c.tsw.WriteLiterallyf("{ kind: $.TypeKind.Basic, name: %q }", tsTypeName)
+		// Use Go type name (e.g., "int") not TypeScript type name (e.g., "number")
+		// The reflect system needs Go type names to correctly determine Kind()
+		c.tsw.WriteLiterallyf("{ kind: $.TypeKind.Basic, name: %q }", t.Name())
 	// Note: The original 'case *types.Named:' here for 'underlying' is intentionally omitted.
 	// If typ.Underlying() is *types.Named (e.g. type T1 MyInt; type T2 T1;),
 	// then writeTypeInfoObject(typ.Underlying()) would be called in some contexts,

package/compiler/type.go

@@ -718,7 +718,7 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 func (c *GoToTSCompiler) getTypeString(goType types.Type) string {
 	var typeStr strings.Builder
 	writer := NewTSCodeWriter(&typeStr)
-	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis)
+	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis, c.currentFilePath)
 	tempCompiler.WriteGoType(goType, GoTypeContextGeneral)
 	return typeStr.String()
 }
@@ -730,7 +730,7 @@ func (c *GoToTSCompiler) getTypeString(goType types.Type) string {
 func (c *GoToTSCompiler) getASTTypeString(astType ast.Expr, goType types.Type) string {
 	var typeStr strings.Builder
 	writer := NewTSCodeWriter(&typeStr)
-	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis)
+	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis, c.currentFilePath)
 
 	if astType != nil {
 		// Use AST-based type writing to preserve qualified names

package/dist/gs/builtin/slice.js

@@ -1,3 +1,43 @@
+/**
+ * wrapSliceProxy wraps a SliceProxy in a Proxy to intercept index access
+ * and route it through the backing array.
+ */
+function wrapSliceProxy(proxy) {
+    const handler = {
+        get(target, prop) {
+            if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+                const index = Number(prop);
+                if (index >= 0 && index < target.__meta__.length) {
+                    return target.__meta__.backing[target.__meta__.offset + index];
+                }
+                throw new Error(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
+            }
+            if (prop === 'length') {
+                return target.__meta__.length;
+            }
+            if (prop === '__meta__') {
+                return target.__meta__;
+            }
+            return Reflect.get(target, prop);
+        },
+        set(target, prop, value) {
+            if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+                const index = Number(prop);
+                if (index >= 0 && index < target.__meta__.length) {
+                    target.__meta__.backing[target.__meta__.offset + index] = value;
+                    target[index] = value; // Also update the proxy target for consistency
+                    return true;
+                }
+                throw new Error(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
+            }
+            if (prop === 'length' || prop === '__meta__') {
+                return false;
+            }
+            return Reflect.set(target, prop, value);
+        },
+    };
+    return new Proxy(proxy, handler);
+}
 // asArray converts a slice to a JavaScript array.
 export function asArray(slice) {
     if (slice === null || slice === undefined) {
@@ -65,41 +105,7 @@ export const makeSlice = (length, capacity, typeHint) => {
             length: length,
             capacity: actualCapacity,
         };
-        // Create a proper Proxy with the handler for SliceProxy behavior
-        const handler = {
-            get(target, prop) {
-                if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-                    const index = Number(prop);
-                    if (index >= 0 && index < target.__meta__.length) {
-                        return target.__meta__.backing[target.__meta__.offset + index];
-                    }
-                    throw new Error(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
-                }
-                if (prop === 'length') {
-                    return target.__meta__.length;
-                }
-                if (prop === '__meta__') {
-                    return target.__meta__;
-                }
-                return Reflect.get(target, prop);
-            },
-            set(target, prop, value) {
-                if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-                    const index = Number(prop);
-                    if (index >= 0 && index < target.__meta__.length) {
-                        target.__meta__.backing[target.__meta__.offset + index] = value;
-                        target[index] = value; // Also update the proxy target for consistency
-                        return true;
-                    }
-                    throw new Error(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
-                }
-                if (prop === 'length' || prop === '__meta__') {
-                    return false;
-                }
-                return Reflect.set(target, prop, value);
-            },
-        };
-        return new Proxy(proxy, handler);
+        return wrapSliceProxy(proxy);
     }
     const actualCapacity = capacity === undefined ? length : capacity;
     if (length < 0 || actualCapacity < 0 || length > actualCapacity) {
@@ -581,7 +587,7 @@ export function append(slice, ...elements) {
             length: newLength,
             capacity: oldCapacity,
         };
-        return resultProxy;
+        return wrapSliceProxy(resultProxy);
     }
     // Case 2: Reallocation is needed.
     let newCapacity = oldCapacity;
@@ -613,7 +619,7 @@ export function append(slice, ...elements) {
         length: newLength,
         capacity: newCapacity,
     };
-    return resultProxy;
+    return wrapSliceProxy(resultProxy);
 }
 export function copy(dst, src) {
     if (dst === null) {