goscript 0.0.50 → 0.0.51

package/compiler/analysis.go

@@ -911,6 +911,11 @@ func (v *analysisVisitor) containsAsyncOperations(node ast.Node) bool {
 				return false
 			}
 
+		case *ast.SelectStmt:
+			// Select statement with channel operations
+			hasAsync = true
+			return false
+
 		case *ast.CallExpr:
 			// Check if we're calling a function known to be async
 			if funcIdent, ok := s.Fun.(*ast.Ident); ok {
@@ -928,8 +933,18 @@ func (v *analysisVisitor) containsAsyncOperations(node ast.Node) bool {
 					// Get the type of the receiver
 					if obj := v.pkg.TypesInfo.Uses[ident]; obj != nil {
 						if varObj, ok := obj.(*types.Var); ok {
-							// Get the type name and package
-							if namedType, ok := varObj.Type().(*types.Named); ok {
+							// Handle both direct named types and pointer to named types
+							var namedType *types.Named
+							switch t := varObj.Type().(type) {
+							case *types.Named:
+								namedType = t
+							case *types.Pointer:
+								if nt, isNamed := t.Elem().(*types.Named); isNamed {
+									namedType = nt
+								}
+							}
+
+							if namedType != nil {
 								typeName := namedType.Obj().Name()
 								methodName := selExpr.Sel.Name
 
@@ -944,13 +959,12 @@ func (v *analysisVisitor) containsAsyncOperations(node ast.Node) bool {
 										return false
 									}
 								}
+								// Note: Local method async detection is handled during code generation to avoid circular dependencies
 							}
 						}
 					}
 				}
 			}
-
-			// TODO: Add detection of method calls on async types
 		}
 
 		return true

package/compiler/compiler.go

@@ -433,7 +433,7 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 				switch d := decl.(type) {
 				case *ast.FuncDecl:
 					if d.Recv == nil && d.Name.IsExported() {
-						valueSymbols = append(valueSymbols, d.Name.Name)
+						valueSymbols = append(valueSymbols, sanitizeIdentifier(d.Name.Name))
 					}
 				case *ast.GenDecl:
 					for _, spec := range d.Specs {
@@ -443,17 +443,17 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 								// Check if this is a struct type
 								if _, isStruct := s.Type.(*ast.StructType); isStruct {
 									// Structs become TypeScript classes and need both type and value exports
-									structSymbols = append(structSymbols, s.Name.Name)
+									structSymbols = append(structSymbols, sanitizeIdentifier(s.Name.Name))
 								} else {
 									// Other type declarations (interfaces, type definitions, type aliases)
 									// become TypeScript types and must be exported with "export type"
-									typeSymbols = append(typeSymbols, s.Name.Name)
+									typeSymbols = append(typeSymbols, sanitizeIdentifier(s.Name.Name))
 								}
 							}
 						case *ast.ValueSpec:
 							for _, name := range s.Names {
 								if name.IsExported() {
-									valueSymbols = append(valueSymbols, name.Name)
+									valueSymbols = append(valueSymbols, sanitizeIdentifier(name.Name))
 								}
 							}
 						}
@@ -676,6 +676,10 @@ type GoToTSCompiler struct {
 	pkg *packages.Package
 
 	analysis *Analysis
+
+	// awaitedCalls tracks which call expressions have already been processed
+	// to avoid adding double await keywords
+	awaitedCalls map[*ast.CallExpr]bool
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,

package/compiler/expr-call-async.go

@@ -2,6 +2,7 @@ package compiler
 
 import (
 	"go/ast"
+	"go/token"
 	"go/types"
 	"strings"
 )
@@ -9,10 +10,19 @@ import (
 // writeAsyncCallIfNeeded writes the await prefix for async function or method calls
 // Returns true if await was written, false otherwise
 func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
+	// Track if we've already processed this call expression to avoid double await
+	if c.awaitedCalls == nil {
+		c.awaitedCalls = make(map[*ast.CallExpr]bool)
+	}
+
+	if c.awaitedCalls[exp] {
+		return false // Already processed this call
+	}
 	switch fun := exp.Fun.(type) {
 	case *ast.Ident:
 		// Function call (e.g., func())
 		if obj := c.pkg.TypesInfo.Uses[fun]; obj != nil && c.analysis.IsAsyncFunc(obj) {
+			c.awaitedCalls[exp] = true
 			c.tsw.WriteLiterally("await ")
 			return true
 		}
@@ -20,8 +30,23 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 
 	case *ast.SelectorExpr:
 		// Method call (e.g., obj.method())
-		ident, ok := fun.X.(*ast.Ident)
-		if !ok {
+		var ident *ast.Ident
+		var identOk bool
+
+		// Handle both direct identifiers and pointer dereferences
+		switch x := fun.X.(type) {
+		case *ast.Ident:
+			ident, identOk = x, true
+		case *ast.StarExpr:
+			// Handle pointer dereference: (*p).method() or p.method() where p is a pointer
+			if id, isIdent := x.X.(*ast.Ident); isIdent {
+				ident, identOk = id, true
+			}
+		default:
+			return false
+		}
+
+		if !identOk {
 			return false
 		}
 
@@ -37,8 +62,20 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 		}
 
 		// Get the type name and package
-		namedType, ok := varObj.Type().(*types.Named)
-		if !ok {
+		var namedType *types.Named
+		var namedTypeOk bool
+
+		// Handle both direct named types and pointer to named types
+		switch t := varObj.Type().(type) {
+		case *types.Named:
+			namedType, namedTypeOk = t, true
+		case *types.Pointer:
+			if nt, isNamed := t.Elem().(*types.Named); isNamed {
+				namedType, namedTypeOk = nt, true
+			}
+		}
+
+		if !namedTypeOk {
 			return false
 		}
 
@@ -47,23 +84,191 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 
 		// Check if the type is from an imported package
 		typePkg := namedType.Obj().Pkg()
-		if typePkg == nil || typePkg == c.pkg.Types {
-			return false
+		if typePkg != nil && typePkg != c.pkg.Types {
+			// Use the full package path from the type information (not just the package name)
+			pkgPath := typePkg.Path()
+
+			// Check if this method is async based on metadata
+			if c.analysis.IsMethodAsync(pkgPath, typeName, methodName) {
+				c.awaitedCalls[exp] = true
+				c.tsw.WriteLiterally("await ")
+				return true
+			}
+		} else {
+			// For local types, check if the method contains async operations at runtime
+			// to avoid circular dependencies during analysis
+			if c.isLocalMethodAsync(namedType, methodName) {
+				c.awaitedCalls[exp] = true
+				c.tsw.WriteLiterally("await ")
+				return true
+			}
 		}
+		return false
 
-		// Use the full package path from the type information (not just the package name)
-		pkgPath := typePkg.Path()
+	default:
+		return false
+	}
+}
 
-		// Check if this method is async based on metadata
-		if c.analysis.IsMethodAsync(pkgPath, typeName, methodName) {
-			c.tsw.WriteLiterally("await ")
-			return true
+// isLocalMethodAsync checks if a local method contains async operations by inspecting its body
+func (c *GoToTSCompiler) isLocalMethodAsync(namedType *types.Named, methodName string) bool {
+	// Find the method in the named type
+	for i := 0; i < namedType.NumMethods(); i++ {
+		method := namedType.Method(i)
+		if method.Name() == methodName {
+			// Find the method declaration in the AST
+			methodDecl := c.findMethodDecl(namedType, methodName)
+			if methodDecl != nil && methodDecl.Body != nil {
+				// Check if the method body contains async operations
+				return c.containsAsyncOperationsRuntime(methodDecl.Body)
+			}
+			break
 		}
+	}
+	return false
+}
+
+// findMethodDecl finds the AST declaration for a method on a named type
+func (c *GoToTSCompiler) findMethodDecl(namedType *types.Named, methodName string) *ast.FuncDecl {
+	// Search through all files in the package for the method declaration
+	for _, file := range c.pkg.Syntax {
+		for _, decl := range file.Decls {
+			if funcDecl, ok := decl.(*ast.FuncDecl); ok {
+				// Check if this is a method with the right name
+				if funcDecl.Name.Name == methodName && funcDecl.Recv != nil {
+					// Check if the receiver type matches
+					if c.isReceiverOfType(funcDecl, namedType) {
+						return funcDecl
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// isReceiverOfType checks if a function declaration is a method of the given named type
+func (c *GoToTSCompiler) isReceiverOfType(funcDecl *ast.FuncDecl, namedType *types.Named) bool {
+	if funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
 		return false
+	}
 
-	default:
+	recvField := funcDecl.Recv.List[0]
+	if len(recvField.Names) == 0 {
 		return false
 	}
+
+	recvIdent := recvField.Names[0]
+	if obj := c.pkg.TypesInfo.Defs[recvIdent]; obj != nil {
+		if varObj, ok := obj.(*types.Var); ok {
+			// Handle both direct named types and pointer to named types
+			var receiverNamedType *types.Named
+			switch t := varObj.Type().(type) {
+			case *types.Named:
+				receiverNamedType = t
+			case *types.Pointer:
+				if nt, isNamed := t.Elem().(*types.Named); isNamed {
+					receiverNamedType = nt
+				}
+			}
+
+			if receiverNamedType != nil {
+				// For generic types, compare the origin types and names
+				// since instantiated generics have different type objects
+				targetObj := namedType.Obj()
+				receiverObj := receiverNamedType.Obj()
+
+				// Compare by name and package path
+				return targetObj.Name() == receiverObj.Name() &&
+					targetObj.Pkg() == receiverObj.Pkg()
+			}
+		}
+	}
+
+	return false
+}
+
+// containsAsyncOperationsRuntime checks if a node contains async operations at runtime
+func (c *GoToTSCompiler) containsAsyncOperationsRuntime(node ast.Node) bool {
+	var hasAsync bool
+
+	ast.Inspect(node, func(n ast.Node) bool {
+		if n == nil {
+			return false
+		}
+
+		switch s := n.(type) {
+		case *ast.SendStmt:
+			// Channel send operation (ch <- value)
+			hasAsync = true
+			return false
+
+		case *ast.UnaryExpr:
+			// Channel receive operation (<-ch)
+			if s.Op == token.ARROW {
+				hasAsync = true
+				return false
+			}
+
+		case *ast.SelectStmt:
+			// Select statement with channel operations
+			hasAsync = true
+			return false
+
+		case *ast.CallExpr:
+			// Check if we're calling a function known to be async
+			if funcIdent, ok := s.Fun.(*ast.Ident); ok {
+				// Get the object for this function call
+				if obj := c.pkg.TypesInfo.Uses[funcIdent]; obj != nil && c.analysis.IsAsyncFunc(obj) {
+					hasAsync = true
+					return false
+				}
+			}
+
+			// Check for method calls on imported types (similar to analysis.go logic)
+			if selExpr, ok := s.Fun.(*ast.SelectorExpr); ok {
+				if ident, ok := selExpr.X.(*ast.Ident); ok {
+					if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+						if varObj, ok := obj.(*types.Var); ok {
+							var namedType *types.Named
+							switch t := varObj.Type().(type) {
+							case *types.Named:
+								namedType = t
+							case *types.Pointer:
+								if nt, isNamed := t.Elem().(*types.Named); isNamed {
+									namedType = nt
+								}
+							}
+
+							if namedType != nil {
+								typeName := namedType.Obj().Name()
+								methodName := selExpr.Sel.Name
+
+								// Check if the type is from an imported package
+								if typePkg := namedType.Obj().Pkg(); typePkg != nil && typePkg != c.pkg.Types {
+									pkgPath := typePkg.Path()
+									if c.analysis.IsMethodAsync(pkgPath, typeName, methodName) {
+										hasAsync = true
+										return false
+									}
+								} else {
+									// For local types, recursively check
+									if c.isLocalMethodAsync(namedType, methodName) {
+										hasAsync = true
+										return false
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		return true
+	})
+
+	return hasAsync
 }
 
 // addNonNullAssertion adds ! for function calls that might return null

package/compiler/sanitize.go

@@ -11,8 +11,7 @@ func sanitizeIdentifier(name string) string {
 
 	// Handle TypeScript built-in types that conflict with Go type parameter names
 	builtinTypes := map[string]string{
-		"Map": "MapType",
-		// Add other built-in types as needed
+		"Promise": "PromiseType",
 	}
 
 	if replacement, exists := builtinTypes[name]; exists {

package/compiler/spec-struct.go

@@ -37,7 +37,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLine("{")
 	c.tsw.Indent(1)
 
-	className := a.Name.Name
+	className := sanitizeIdentifier(a.Name.Name)
 
 	goStructType, ok := c.pkg.TypesInfo.Defs[a.Name].Type().(*types.Named)
 	if !ok {
@@ -231,10 +231,10 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			// Check for both simple identifiers (Pair) and generic types (Pair[T])
 			var recvTypeName string
 			if ident, ok := recvType.(*ast.Ident); ok {
-				recvTypeName = ident.Name
+				recvTypeName = sanitizeIdentifier(ident.Name)
 			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
 				if ident, ok := indexExpr.X.(*ast.Ident); ok {
-					recvTypeName = ident.Name
+					recvTypeName = sanitizeIdentifier(ident.Name)
 				}
 			}
 

package/compiler/spec.go

@@ -136,11 +136,6 @@ func (c *GoToTSCompiler) writeRegularFieldInitializer(fieldName string, fieldTyp
 
 	c.tsw.WriteLiterallyf("init?.%s ?? ", fieldName)
 
-	// Debug for Mode field specifically
-	if fieldName == "Mode" {
-		fmt.Printf("DEBUG Mode field: Type=%T, String=%s\n", fieldType, fieldType.String())
-	}
-
 	// Priority 1: Check if this is a wrapper type
 	if c.analysis.IsNamedBasicType(fieldType) {
 		// For wrapper types, use the zero value of the underlying type with type casting
@@ -161,35 +156,22 @@ func (c *GoToTSCompiler) writeRegularFieldInitializer(fieldName string, fieldTyp
 
 	// Priority 2: Handle imported types with basic underlying types (like os.FileMode)
 	if c.isImportedBasicType(fieldType) {
-		if fieldName == "Mode" {
-			fmt.Printf("DEBUG Mode field: Using imported basic type zero value\n")
-		}
 		c.writeImportedBasicTypeZeroValue(fieldType)
 		return
 	}
 
 	// Priority 3: Handle named types
 	if named, isNamed := fieldType.(*types.Named); isNamed {
-		if fieldName == "Mode" {
-			fmt.Printf("DEBUG Mode field: Using named type zero value\n")
-		}
 		c.writeNamedTypeZeroValue(named)
 		return
 	}
 
 	// Priority 4: Handle type aliases
 	if alias, isAlias := fieldType.(*types.Alias); isAlias {
-		if fieldName == "Mode" {
-			fmt.Printf("DEBUG Mode field: Using type alias zero value\n")
-		}
 		c.writeTypeAliasZeroValue(alias, astType)
 		return
 	}
 
-	// Default: use WriteZeroValueForType
-	if fieldName == "Mode" {
-		fmt.Printf("DEBUG Mode field: Using default WriteZeroValueForType\n")
-	}
 	c.WriteZeroValueForType(fieldType)
 }
 
@@ -241,7 +223,6 @@ func (c *GoToTSCompiler) isImportedBasicType(fieldType types.Type) bool {
 func (c *GoToTSCompiler) writeImportedBasicTypeZeroValue(fieldType types.Type) {
 	if named, ok := fieldType.(*types.Named); ok {
 		underlying := named.Underlying()
-		fmt.Printf("DEBUG writeImportedBasicTypeZeroValue: Named type, underlying=%T\n", underlying)
 		// Write zero value of underlying type with type casting
 		c.WriteZeroValueForType(underlying)
 		c.tsw.WriteLiterally(" as ")
@@ -251,7 +232,6 @@ func (c *GoToTSCompiler) writeImportedBasicTypeZeroValue(fieldType types.Type) {
 
 	if alias, ok := fieldType.(*types.Alias); ok {
 		underlying := alias.Underlying()
-		fmt.Printf("DEBUG writeImportedBasicTypeZeroValue: Alias type, underlying=%T\n", underlying)
 		// Write zero value of underlying type with type casting
 		c.WriteZeroValueForType(underlying)
 		c.tsw.WriteLiterally(" as ")
@@ -260,7 +240,6 @@ func (c *GoToTSCompiler) writeImportedBasicTypeZeroValue(fieldType types.Type) {
 	}
 
 	// Fallback (should not happen if isImportedBasicType was correct)
-	fmt.Printf("DEBUG writeImportedBasicTypeZeroValue: Fallback path\n")
 	c.WriteZeroValueForType(fieldType)
 }
 

package/compiler/stmt-select.go

@@ -8,6 +8,18 @@ import (
 	"github.com/pkg/errors"
 )
 
+// caseEndsWithReturn checks if a case body ends with a return statement
+func (c *GoToTSCompiler) caseEndsWithReturn(body []ast.Stmt) bool {
+	if len(body) == 0 {
+		return false
+	}
+
+	// Check if the last statement is a return statement
+	lastStmt := body[len(body)-1]
+	_, isReturn := lastStmt.(*ast.ReturnStmt)
+	return isReturn
+}
+
 // WriteStmtSelect translates a Go `select` statement into an asynchronous
 // TypeScript operation using the `$.selectStatement` runtime helper.
 // Go's `select` provides non-deterministic choice over channel operations.
@@ -38,8 +50,29 @@ func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
 	// Variable to track whether we have a default case
 	hasDefault := false
 
+	// Analyze if all cases end with return statements
+	allCasesReturn := true
+	for _, stmt := range exp.Body.List {
+		if commClause, ok := stmt.(*ast.CommClause); ok {
+			if commClause.Comm == nil {
+				// Default case - check if it ends with return
+				if !c.caseEndsWithReturn(commClause.Body) {
+					allCasesReturn = false
+				}
+			} else {
+				// Regular case - check if it ends with return
+				if !c.caseEndsWithReturn(commClause.Body) {
+					allCasesReturn = false
+				}
+			}
+		}
+	}
+
+	// Generate unique variable names for this select statement
+	selectID := fmt.Sprintf("%d", exp.Pos()) // Use AST position for uniqueness
+
 	// Start the selectStatement call and the array literal
-	c.tsw.WriteLiterally("await $.selectStatement(")
+	c.tsw.WriteLiterallyf("const [_selectHasReturn%s, _selectValue%s] = await $.selectStatement(", selectID, selectID)
 	c.tsw.WriteLine("[") // Put bracket on new line
 	c.tsw.Indent(1)
 
@@ -207,5 +240,23 @@ func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
 	c.tsw.WriteLiterally(")")
 	c.tsw.WriteLine("")
 
+	// Add code to handle the return value from selectStatement
+	c.tsw.WriteLiterallyf("if (_selectHasReturn%s) {", selectID)
+	c.tsw.WriteLine("")
+	c.tsw.Indent(1)
+	c.tsw.WriteLiterallyf("return _selectValue%s!", selectID)
+	c.tsw.WriteLine("")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+
+	// If all cases return, add a TypeScript-satisfying fallback return
+	if allCasesReturn {
+		c.tsw.WriteLine("// All cases should return, this fallback should never execute")
+		c.tsw.WriteLine("throw new Error('Unexpected: select statement did not return when all cases should return')")
+	} else {
+		c.tsw.WriteLiterallyf("// If _selectHasReturn%s is false, continue execution", selectID)
+		c.tsw.WriteLine("")
+	}
+
 	return nil
 }

package/compiler/type.go

@@ -278,7 +278,7 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 				// Write the qualified name: importAlias.TypeName
 				c.tsw.WriteLiterally(importAlias)
 				c.tsw.WriteLiterally(".")
-				c.tsw.WriteLiterally(t.Obj().Name())
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(t.Obj().Name()))
 
 				// For generic types, include type arguments
 				if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
@@ -306,7 +306,7 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 				// Write the qualified name: importAlias.TypeName
 				c.tsw.WriteLiterally(importAlias)
 				c.tsw.WriteLiterally(".")
-				c.tsw.WriteLiterally(t.Obj().Name())
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(t.Obj().Name()))
 
 				// For generic types, include type arguments
 				if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
@@ -330,7 +330,7 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 	}
 
 	// Use Obj().Name() for the original defined name (local types or unmatched imports)
-	c.tsw.WriteLiterally(t.Obj().Name())
+	c.tsw.WriteLiterally(c.sanitizeIdentifier(t.Obj().Name()))
 
 	// For generic types, include type arguments
 	if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {

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

@@ -77,7 +77,7 @@ export interface SelectCase<T> {
     isSend: boolean;
     channel: Channel<any> | ChannelRef<any> | null;
     value?: any;
-    onSelected?: (result: SelectResult<T>) => Promise<void>;
+    onSelected?: (result: SelectResult<T>) => Promise<any>;
 }
 /**
  * Helper for 'select' statements. Takes an array of select cases
@@ -87,7 +87,7 @@ export interface SelectCase<T> {
  * @param hasDefault Whether there is a default case
  * @returns A promise that resolves with the result of the selected case
  */
-export declare function selectStatement<T>(cases: SelectCase<T>[], hasDefault?: boolean): Promise<void>;
+export declare function selectStatement<T, V = void>(cases: SelectCase<T>[], hasDefault?: boolean): Promise<[boolean, V]>;
 /**
  * Helper function for channel send operations that handles nil channels correctly.
  * In Go, sending to a nil channel blocks forever.

package/dist/gs/builtin/channel.js

@@ -41,13 +41,15 @@ export async function selectStatement(cases, hasDefault = false) {
             if (selectedCase.isSend) {
                 const result = await selectedCase.channel.selectSend(selectedCase.value, selectedCase.id);
                 if (selectedCase.onSelected) {
-                    await selectedCase.onSelected(result); // Await the handler
+                    const handlerResult = await selectedCase.onSelected(result);
+                    return [handlerResult !== undefined, handlerResult];
                 }
             }
             else {
                 const result = await selectedCase.channel.selectReceive(selectedCase.id);
                 if (selectedCase.onSelected) {
-                    await selectedCase.onSelected(result); // Await the handler
+                    const handlerResult = await selectedCase.onSelected(result);
+                    return [handlerResult !== undefined, handlerResult];
                 }
             }
         }
@@ -55,7 +57,7 @@ export async function selectStatement(cases, hasDefault = false) {
             // This case should ideally not happen if channel is required for non-default cases
             console.error('Selected case without a channel:', selectedCase);
         }
-        return; // Return after executing a ready case
+        return [false, undefined]; // Return after executing a ready case
     }
     // 2. If no operations are ready and there's a default case, select default
     if (hasDefault) {
@@ -63,13 +65,14 @@ export async function selectStatement(cases, hasDefault = false) {
         const defaultCase = cases.find((c) => c.id === -1);
         if (defaultCase && defaultCase.onSelected) {
             // Execute the onSelected handler for the default case
-            await defaultCase.onSelected({
+            const handlerResult = await defaultCase.onSelected({
                 value: undefined,
                 ok: false,
                 id: -1,
-            }); // Await the handler
+            });
+            return [handlerResult !== undefined, handlerResult];
         }
-        return; // Return after executing the default case
+        return [false, undefined]; // Return after executing the default case
     }
     // 3. If no operations are ready and no default case, block until one is ready
     // Use Promise.race on the blocking promises
@@ -94,9 +97,11 @@ export async function selectStatement(cases, hasDefault = false) {
     // Execute onSelected handler for the selected case
     const selectedCase = cases.find((c) => c.id === result.id);
     if (selectedCase && selectedCase.onSelected) {
-        await selectedCase.onSelected(result); // Await the handler
+        const handlerResult = await selectedCase.onSelected(result);
+        return [handlerResult !== undefined, handlerResult];
     }
     // No explicit return needed here, as the function will implicitly return after the await
+    return [false, undefined];
 }
 /**
  * Helper function for channel send operations that handles nil channels correctly.