goscript 0.0.26 → 0.0.29

package/compiler/spec.go

@@ -150,6 +150,237 @@ func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType
 	c.tsw.WriteLiterally(")")
 }
 
+// hasReceiverMethods checks if a type declaration has any receiver methods defined
+func (c *GoToTSCompiler) hasReceiverMethods(typeName string) bool {
+	for _, fileSyntax := range c.pkg.Syntax {
+		for _, decl := range fileSyntax.Decls {
+			funcDecl, isFunc := decl.(*ast.FuncDecl)
+			if !isFunc || funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
+				continue
+			}
+			recvField := funcDecl.Recv.List[0]
+			recvType := recvField.Type
+			if starExpr, ok := recvType.(*ast.StarExpr); ok {
+				recvType = starExpr.X
+			}
+
+			// Check for both simple identifiers (FileMode) and generic types (FileMode[T])
+			var recvTypeName string
+			if ident, ok := recvType.(*ast.Ident); ok {
+				recvTypeName = ident.Name
+			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
+				if ident, ok := indexExpr.X.(*ast.Ident); ok {
+					recvTypeName = ident.Name
+				}
+			}
+
+			if recvTypeName == typeName {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// WriteNamedTypeWithMethods generates a TypeScript class for a Go named type that has receiver methods
+func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
+	className := a.Name.Name
+	underlyingType := c.pkg.TypesInfo.TypeOf(a.Type)
+
+	// Add export for Go-exported types (but not if inside a function)
+	isInsideFunction := false
+	if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
+		isInsideFunction = nodeInfo.IsInsideFunction
+	}
+
+	if a.Name.IsExported() && !isInsideFunction {
+		c.tsw.WriteLiterally("export ")
+	}
+
+	c.tsw.WriteLiterallyf("class %s {", className)
+	c.tsw.WriteLine("")
+	c.tsw.Indent(1)
+
+	// Constructor that takes the underlying type value
+	c.tsw.WriteLiterally("constructor(private _value: ")
+	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	c.tsw.WriteLine(") {}")
+	c.tsw.WriteLine("")
+
+	// valueOf method to get the underlying value (for type conversions and operations)
+	c.tsw.WriteLiterally("valueOf(): ")
+	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	c.tsw.WriteLine(" {")
+	c.tsw.Indent(1)
+	c.tsw.WriteLine("return this._value")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("")
+
+	// toString method for string conversion
+	c.tsw.WriteLine("toString(): string {")
+	c.tsw.Indent(1)
+	c.tsw.WriteLine("return String(this._value)")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("")
+
+	// Static from method for type conversion
+	c.tsw.WriteLiterallyf("static from(value: ")
+	c.WriteGoType(underlyingType, GoTypeContextGeneral)
+	c.tsw.WriteLiterallyf("): %s {", className)
+	c.tsw.WriteLine("")
+	c.tsw.Indent(1)
+	c.tsw.WriteLiterallyf("return new %s(value)", className)
+	c.tsw.WriteLine("")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+
+	// Add receiver methods for this type
+	for _, fileSyntax := range c.pkg.Syntax {
+		for _, decl := range fileSyntax.Decls {
+			funcDecl, isFunc := decl.(*ast.FuncDecl)
+			if !isFunc || funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
+				continue
+			}
+			recvField := funcDecl.Recv.List[0]
+			recvType := recvField.Type
+			if starExpr, ok := recvType.(*ast.StarExpr); ok {
+				recvType = starExpr.X
+			}
+
+			// Check for both simple identifiers (FileMode) and generic types (FileMode[T])
+			var recvTypeName string
+			if ident, ok := recvType.(*ast.Ident); ok {
+				recvTypeName = ident.Name
+			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
+				if ident, ok := indexExpr.X.(*ast.Ident); ok {
+					recvTypeName = ident.Name
+				}
+			}
+
+			if recvTypeName == className {
+				c.tsw.WriteLine("")
+				if err := c.writeNamedTypeMethod(funcDecl, className); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+
+	return nil
+}
+
+// writeNamedTypeMethod writes a method for a named type, handling receiver binding properly
+func (c *GoToTSCompiler) writeNamedTypeMethod(decl *ast.FuncDecl, className string) error {
+	if decl.Doc != nil {
+		c.WriteDoc(decl.Doc)
+	}
+
+	// Determine if method is async
+	var isAsync bool
+	if obj := c.pkg.TypesInfo.Defs[decl.Name]; obj != nil {
+		isAsync = c.analysis.IsAsyncFunc(obj)
+	}
+
+	// Methods are typically public in the TS output
+	c.tsw.WriteLiterally("public ")
+
+	// Add async modifier if needed
+	if isAsync {
+		c.tsw.WriteLiterally("async ")
+	}
+
+	// Keep original Go casing for method names
+	if err := c.WriteValueExpr(decl.Name); err != nil { // Method name is a value identifier
+		return err
+	}
+
+	// Write signature (parameters and return type)
+	funcType := decl.Type
+	c.tsw.WriteLiterally("(")
+	if funcType.Params != nil {
+		c.WriteFieldList(funcType.Params, true) // true = arguments
+	}
+	c.tsw.WriteLiterally(")")
+
+	// Handle return type
+	if funcType.Results != nil && len(funcType.Results.List) > 0 {
+		c.tsw.WriteLiterally(": ")
+		if isAsync {
+			c.tsw.WriteLiterally("Promise<")
+		}
+		if len(funcType.Results.List) == 1 {
+			// Single return value
+			resultType := funcType.Results.List[0].Type
+			c.WriteTypeExpr(resultType)
+		} else {
+			// Multiple return values -> tuple type
+			c.tsw.WriteLiterally("[")
+			for i, field := range funcType.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.WriteTypeExpr(field.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		if isAsync {
+			c.tsw.WriteLiterally(">")
+		}
+	} else {
+		// No return value -> void
+		if isAsync {
+			c.tsw.WriteLiterally(": Promise<void>")
+		} else {
+			c.tsw.WriteLiterally(": void")
+		}
+	}
+
+	c.tsw.WriteLiterally(" ")
+
+	// For named types with methods, bind receiver name to this._value
+	if recvField := decl.Recv.List[0]; len(recvField.Names) > 0 {
+		recvName := recvField.Names[0].Name
+		if recvName != "_" {
+			c.tsw.WriteLine("{")
+			c.tsw.Indent(1)
+			// Bind the receiver name to this._value for value types
+			sanitizedRecvName := c.sanitizeIdentifier(recvName)
+			c.tsw.WriteLinef("const %s = this._value", sanitizedRecvName)
+
+			// Add using statement if needed
+			if c.analysis.NeedsDefer(decl.Body) {
+				if c.analysis.IsInAsyncFunction(decl) {
+					c.tsw.WriteLine("await using __defer = new $.AsyncDisposableStack();")
+				} else {
+					c.tsw.WriteLine("using cleanup = new $.DisposableStack();")
+				}
+			}
+
+			// write method body without outer braces
+			for _, stmt := range decl.Body.List {
+				if err := c.WriteStmt(stmt); err != nil {
+					return fmt.Errorf("failed to write statement in function body: %w", err)
+				}
+			}
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+
+			return nil
+		}
+	}
+	// no named receiver, write whole body
+	if err := c.WriteStmt(decl.Body); err != nil {
+		return fmt.Errorf("failed to write function body: %w", err)
+	}
+
+	return nil
+}
+
 // WriteTypeSpec writes the type specification to the output.
 func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 	if a.Doc != nil {
@@ -165,7 +396,20 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 	case *ast.InterfaceType:
 		return c.WriteInterfaceTypeSpec(a, t)
 	default:
-		// type alias
+		// Check if this type has receiver methods
+		if c.hasReceiverMethods(a.Name.Name) {
+			return c.WriteNamedTypeWithMethods(a)
+		}
+
+		// type alias - add export for Go-exported types (but not if inside a function)
+		isInsideFunction := false
+		if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
+			isInsideFunction = nodeInfo.IsInsideFunction
+		}
+
+		if a.Name.IsExported() && !isInsideFunction {
+			c.tsw.WriteLiterally("export ")
+		}
 		c.tsw.WriteLiterally("type ")
 		if err := c.WriteValueExpr(a.Name); err != nil {
 			return err
@@ -179,6 +423,15 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 
 // WriteInterfaceTypeSpec writes the TypeScript type for a Go interface type.
 func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.InterfaceType) error {
+	// Add export for Go-exported interfaces (but not if inside a function)
+	isInsideFunction := false
+	if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
+		isInsideFunction = nodeInfo.IsInsideFunction
+	}
+
+	if a.Name.IsExported() && !isInsideFunction {
+		c.tsw.WriteLiterally("export ")
+	}
 	c.tsw.WriteLiterally("type ")
 	if err := c.WriteValueExpr(a.Name); err != nil {
 		return err

package/compiler/stmt-assign.go

@@ -384,6 +384,27 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 	// Handle multi-variable assignment from a single expression.
 	if len(exp.Lhs) > 1 && len(exp.Rhs) == 1 {
 		rhsExpr := exp.Rhs[0]
+
+		// Check for protobuf method calls first
+		if callExpr, ok := rhsExpr.(*ast.CallExpr); ok {
+			// Handle protobuf MarshalVT: data, err := msg.MarshalVT()
+			if len(exp.Lhs) == 2 && c.isProtobufMethodCall(callExpr, "MarshalVT") {
+				err := c.writeProtobufMarshalAssignment(exp.Lhs, callExpr, exp.Tok)
+				if err != nil {
+					return err
+				}
+				return nil
+			}
+			// Handle protobuf MarshalJSON: data, err := msg.MarshalJSON()
+			if len(exp.Lhs) == 2 && c.isProtobufMethodCall(callExpr, "MarshalJSON") {
+				err := c.writeProtobufMarshalJSONAssignment(exp.Lhs, callExpr, exp.Tok)
+				if err != nil {
+					return err
+				}
+				return nil
+			}
+		}
+
 		if typeAssertExpr, ok := rhsExpr.(*ast.TypeAssertExpr); ok {
 			return c.writeTypeAssert(exp.Lhs, typeAssertExpr, exp.Tok)
 		} else if indexExpr, ok := rhsExpr.(*ast.IndexExpr); ok {
@@ -412,6 +433,20 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		// If none of the specific multi-assign patterns match, fall through to the error check below
 	}
 
+	// Check for single-variable protobuf method calls before general assignment handling
+	if len(exp.Lhs) == 1 && len(exp.Rhs) == 1 {
+		if callExpr, ok := exp.Rhs[0].(*ast.CallExpr); ok {
+			// Handle protobuf UnmarshalVT: err = out.UnmarshalVT(data)
+			if c.isProtobufMethodCall(callExpr, "UnmarshalVT") {
+				return c.writeProtobufUnmarshalAssignment(exp.Lhs, callExpr, exp.Tok)
+			}
+			// Handle protobuf UnmarshalJSON: err = out.UnmarshalJSON(data)
+			if c.isProtobufMethodCall(callExpr, "UnmarshalJSON") {
+				return c.writeProtobufUnmarshalJSONAssignment(exp.Lhs, callExpr, exp.Tok)
+			}
+		}
+	}
+
 	// Ensure LHS and RHS have the same length for valid Go code in these cases
 	if len(exp.Lhs) != len(exp.Rhs) {
 		return fmt.Errorf("invalid assignment statement: LHS count (%d) != RHS count (%d)", len(exp.Lhs), len(exp.Rhs))

package/compiler/type-assert.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/token"
+	"go/types"
 	"strings"
 )
 
@@ -201,6 +202,92 @@ func (c *GoToTSCompiler) writeTypeAssert(lhs []ast.Expr, typeAssertExpr *ast.Typ
 			c.tsw.WriteLine("")
 		}
 
+	case *ast.IndexExpr:
+		// Handle slice[index], ok := expr.(Type) or map[key], ok := expr.(Type)
+		// Use unique temporary variable names to avoid redeclaration
+		tempValName := fmt.Sprintf("_gs_ta_val_%d_", vLHS.Pos()) // Unique name based on AST position
+		tempOkName := fmt.Sprintf("_gs_ta_ok_%d_", vLHS.Pos())   // Unique name based on AST position
+
+		// Declare temporary variables:
+		// let _gs_ta_val_N_: AssertedTypeTS;
+		c.tsw.WriteLiterally("let ")
+		c.tsw.WriteLiterally(tempValName)
+		c.tsw.WriteLiterally(": ")
+		c.WriteTypeExpr(assertedType) // TypeScript type for assertedType
+		c.tsw.WriteLine("")
+
+		// let _gs_ta_ok_N_: boolean;
+		c.tsw.WriteLiterally("let ")
+		c.tsw.WriteLiterally(tempOkName)
+		c.tsw.WriteLiterally(": boolean")
+		c.tsw.WriteLine("")
+
+		// Perform type assertion into temporary variables:
+		// ({ value: _gs_ta_val_N_, ok: _gs_ta_ok_N_ } = $.typeAssert<AssertedTypeTS>(expr, "GoTypeStr"));
+		c.tsw.WriteLiterally("({ value: ")
+		c.tsw.WriteLiterally(tempValName)
+		c.tsw.WriteLiterally(", ok: ")
+		c.tsw.WriteLiterally(tempOkName)
+		c.tsw.WriteLiterally(" } = $.typeAssert<")
+		c.WriteTypeExpr(assertedType) // Generic: <AssertedTypeTS>
+		c.tsw.WriteLiterally(">(")
+		if err := c.WriteValueExpr(interfaceExpr); err != nil { // Arg1: interfaceExpr
+			return fmt.Errorf("failed to write interface expression in type assertion call: %w", err)
+		}
+		c.tsw.WriteLiterally(", ")
+		c.writeTypeDescription(assertedType) // Arg2: type info for runtime
+		c.tsw.WriteLine("))")
+
+		// Check if this is a map assignment and handle it specially
+		if tv, ok := c.pkg.TypesInfo.Types[vLHS.X]; ok {
+			if _, isMap := tv.Type.Underlying().(*types.Map); isMap {
+				// Map assignment: use $.mapSet(map, key, value)
+				c.tsw.WriteLiterally("$.mapSet(")
+				if err := c.WriteValueExpr(vLHS.X); err != nil { // Map
+					return fmt.Errorf("failed to write map expression in type assertion: %w", err)
+				}
+				c.tsw.WriteLiterally(", ")
+				if err := c.WriteValueExpr(vLHS.Index); err != nil { // Key
+					return fmt.Errorf("failed to write map key expression in type assertion: %w", err)
+				}
+				c.tsw.WriteLiterally(", ")
+				c.tsw.WriteLiterally(tempValName) // Value
+				c.tsw.WriteLine(")")
+			} else {
+				// Array/slice assignment: use direct assignment
+				// slice[index] = _gs_ta_val_N_;
+				if err := c.WriteValueExpr(vLHS.X); err != nil { // Array/slice
+					return fmt.Errorf("failed to write array/slice expression in type assertion: %w", err)
+				}
+				c.tsw.WriteLiterally("![")                           // Non-null assertion
+				if err := c.WriteValueExpr(vLHS.Index); err != nil { // Index
+					return fmt.Errorf("failed to write array/slice index expression in type assertion: %w", err)
+				}
+				c.tsw.WriteLiterally("] = ")
+				c.tsw.WriteLiterally(tempValName)
+				c.tsw.WriteLine("")
+			}
+		} else {
+			// Fallback: try direct assignment (might fail for maps)
+			if err := c.WriteValueExpr(vLHS); err != nil { // Writes indexed expression
+				return fmt.Errorf("failed to write LHS indexed expression in type assertion: %w", err)
+			}
+			c.tsw.WriteLiterally(" = ")
+			c.tsw.WriteLiterally(tempValName)
+			c.tsw.WriteLine("")
+		}
+
+		// Assign temporary ok to the ok variable (e.g., okName = _gs_ta_ok_N_; or let okName = ...)
+		if !okIsBlank {
+			if okIsNewInDefine { // okIsNewInDefine was determined earlier based on tok == token.DEFINE and Defs check
+				c.tsw.WriteLiterally("let ")
+			}
+			c.tsw.WriteLiterally(okName)
+			c.tsw.WriteLiterally(" = ")
+			c.tsw.WriteLiterally(tempOkName)
+			c.tsw.WriteLine("")
+		}
+
 	default:
 		return fmt.Errorf("unhandled LHS expression type for value in type assertion: %T", valueExpr)
 	}

package/compiler/type.go

@@ -151,7 +151,10 @@ func (c *GoToTSCompiler) WriteZeroValueForType(typ any) {
 		// Handle named types, especially struct types
 		if _, isStruct := t.Underlying().(*types.Struct); isStruct {
 			// Initialize struct types with a new instance
-			c.tsw.WriteLiterallyf("new %s()", t.Obj().Name())
+			// Use the same logic as WriteNamedType to handle imported types
+			c.tsw.WriteLiterally("new ")
+			c.WriteNamedType(t)
+			c.tsw.WriteLiterally("()")
 			return
 		}
 		// For other named types, use the zero value of the underlying type

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

@@ -5,5 +5,24 @@ export * from './io.js';
 export * from './map.js';
 export * from './slice.js';
 export * from './type.js';
-export declare function copy<T>(dst: T[], src: T[]): 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.
+ *
+ * @param {Uint8Array | number[] | null | undefined | { data: number[] } | { valueOf(): number[] }} bytes
+ *   The input to normalize. Accepted types:
+ *   - `Uint8Array`: Returned as-is.
+ *   - `number[]`: Converted to a `Uint8Array`.
+ *   - `null` or `undefined`: Returns an empty `Uint8Array`.
+ *   - `{ data: number[] }`: An object with a `data` property (e.g., `$.Slice<number>`), where `data` is a `number[]`.
+ *   - `{ valueOf(): number[] }`: An object with a `valueOf` method that returns a `number[]`.
+ * @returns {Uint8Array} A normalized `Uint8Array` representation of the input.
+ * @throws {Error} If the input type is unsupported or cannot be normalized.
+ */
+export declare function normalizeBytes(bytes: Uint8Array | number[] | null | undefined | {
+    data: number[];
+} | {
+    valueOf(): number[];
+}): Uint8Array;

package/dist/gs/builtin/builtin.js

@@ -5,14 +5,62 @@ export * from './io.js';
 export * from './map.js';
 export * from './slice.js';
 export * from './type.js';
+// 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) {
+    // In Go, int is typically 64-bit on 64-bit systems, but for compatibility with JavaScript
+    // we need to handle the conversion properly. The issue is that JavaScript's number type
+    // can represent values larger than 32-bit signed integers, but when cast in certain contexts
+    // they get interpreted as signed 32-bit integers.
+    // For Go's int type on 64-bit systems, we should preserve the full 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) {
-    const n = Math.min(dst.length, src.length);
-    for (let i = 0; i < n; i++) {
-        dst[i] = src[i];
+    // 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;
     }
-    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
@@ -43,4 +91,47 @@ export function multiplyDuration(duration, multiplier) {
     }
     throw new Error(`Cannot multiply duration of type ${typeof duration}`);
 }
+/**
+ * Normalizes various byte representations into a `Uint8Array` for protobuf compatibility.
+ *
+ * @param {Uint8Array | number[] | null | undefined | { data: number[] } | { valueOf(): number[] }} bytes
+ *   The input to normalize. Accepted types:
+ *   - `Uint8Array`: Returned as-is.
+ *   - `number[]`: Converted to a `Uint8Array`.
+ *   - `null` or `undefined`: Returns an empty `Uint8Array`.
+ *   - `{ data: number[] }`: An object with a `data` property (e.g., `$.Slice<number>`), where `data` is a `number[]`.
+ *   - `{ valueOf(): number[] }`: An object with a `valueOf` method that returns a `number[]`.
+ * @returns {Uint8Array} A normalized `Uint8Array` representation of the input.
+ * @throws {Error} If the input type is unsupported or cannot be normalized.
+ */
+export function normalizeBytes(bytes) {
+    if (bytes === null || bytes === undefined) {
+        return new Uint8Array(0);
+    }
+    if (bytes instanceof Uint8Array) {
+        return bytes;
+    }
+    // Handle $.Slice<number> (which has a .data property that's a number[])
+    if (bytes &&
+        typeof bytes === 'object' &&
+        'data' in bytes &&
+        Array.isArray(bytes.data)) {
+        return new Uint8Array(bytes.data);
+    }
+    // Handle plain number arrays
+    if (Array.isArray(bytes)) {
+        return new Uint8Array(bytes);
+    }
+    // Handle objects with valueOf() method that returns a number array
+    if (bytes &&
+        typeof bytes === 'object' &&
+        'valueOf' in bytes &&
+        typeof bytes.valueOf === 'function') {
+        const value = bytes.valueOf();
+        if (Array.isArray(value)) {
+            return new Uint8Array(value);
+        }
+    }
+    throw new Error(`Cannot normalize bytes of type ${typeof bytes}: ${bytes}`);
+}
 //# sourceMappingURL=builtin.js.map

package/dist/gs/builtin/builtin.js.map

@@ -1 +1 @@
-{"version":3,"file":"builtin.js","sourceRoot":"","sources":["../../../gs/builtin/builtin.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AAEzB,oFAAoF;AACpF,4CAA4C;AAC5C,MAAM,UAAU,IAAI,CAAI,GAAQ,EAAE,GAAQ;IACxC,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAA;IACjB,CAAC;IACD,OAAO,CAAC,CAAA;AACV,CAAC;AAED,6DAA6D;AAC7D,0CAA0C;AAC1C,MAAM,UAAU,gBAAgB,CAAC,QAAa,EAAE,UAAkB;IAChE,oEAAoE;IACpE,IAAI,QAAQ,IAAI,OAAO,QAAQ,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;QACxD,OAAO,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAA;IACtC,CAAC;IAED,gEAAgE;IAChE,IAAI,QAAQ,IAAI,OAAO,QAAQ,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACvD,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAA;QACnC,gEAAgE;QAChE,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;YACjC,gDAAgD;YAChD,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;gBACzB,OAAO,IAAI,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAA;YACxD,CAAC;YACD,gDAAgD;YAChD,OAAO;gBACL,OAAO,EAAE,GAAG,EAAE,CAAC,QAAQ,GAAG,UAAU;gBACpC,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,QAAQ,EAAE,GAAG,IAAI;aAC1D,CAAA;QACH,CAAC;IACH,CAAC;IAED,qCAAqC;IACrC,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,OAAO,QAAQ,GAAG,UAAU,CAAA;IAC9B,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,oCAAoC,OAAO,QAAQ,EAAE,CAAC,CAAA;AACxE,CAAC"}
+{"version":3,"file":"builtin.js","sourceRoot":"","sources":["../../../gs/builtin/builtin.ts"],"names":[],"mappings":"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"}

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

@@ -137,7 +137,7 @@ export declare const sliceString: (str: string, low?: number, high?: number) =>
  * @param bytes The Slice<number> to convert.
  * @returns The resulting string.
  */
-export declare const bytesToString: (bytes: Slice<number> | Uint8Array) => string;
+export declare const bytesToString: (bytes: Slice<number> | Uint8Array | string) => string;
 /**
  * Converts a string to a Uint8Array (byte slice).
  * @param s The input string.

package/dist/gs/builtin/slice.js

@@ -1,6 +1,22 @@
-// asArray type-asserts a slice to an array type.
+// asArray converts a slice to a JavaScript array.
 export function asArray(slice) {
-    return slice;
+    if (slice === null || slice === undefined) {
+        return [];
+    }
+    if (slice instanceof Uint8Array) {
+        return Array.from(slice);
+    }
+    if (isComplexSlice(slice)) {
+        const result = [];
+        for (let i = 0; i < slice.__meta__.length; i++) {
+            result.push(slice.__meta__.backing[slice.__meta__.offset + i]);
+        }
+        return result;
+    }
+    if (Array.isArray(slice)) {
+        return slice;
+    }
+    return [];
 }
 /**
  * isComplexSlice checks if a slice is a complex slice (has __meta__ property)
@@ -736,6 +752,9 @@ export const sliceString = (str, low, high) => {
 export const bytesToString = (bytes) => {
     if (bytes === null)
         return '';
+    // If it's already a string, just return it
+    if (typeof bytes === 'string')
+        return bytes;
     if (bytes instanceof Uint8Array) {
         return new TextDecoder().decode(bytes);
     }