chore: daily optimization patch for bridge/core and eventloop

bridge/core/arraybuffer.go

@@ -11,7 +11,30 @@ import (
 // For shared memory scenarios where modifications should be visible to both
 // Go and JavaScript, use MapSharedBuffer instead.
 func ToArrayBuffer(vm *sobek.Runtime, data []byte) sobek.Value {
-	return vm.ToValue(vm.NewArrayBuffer(data))
+	// @safety: explicitly copy data before vm.NewArrayBuffer because sobek does not copy
+	copiedData := make([]byte, len(data))
+	copy(copiedData, data)
+	return vm.ToValue(vm.NewArrayBuffer(copiedData))
+}
+
+// ToUint8Array converts a Go byte slice to a JavaScript Uint8Array.
+// If Uint8Array is not available, it gracefully falls back to ArrayBuffer.
+func ToUint8Array(vm *sobek.Runtime, data []byte) sobek.Value {
+	// @safety: explicitly copy data
+	copiedData := make([]byte, len(data))
+	copy(copiedData, data)
+	buf := vm.NewArrayBuffer(copiedData)
+	ctor := vm.Get("Uint8Array")
+	if ctor == nil || sobek.IsNull(ctor) || sobek.IsUndefined(ctor) {
+		return vm.ToValue(buf)
+	}
+
+	view := ctor.ToObject(vm)
+	typedArray, err := vm.New(view, vm.ToValue(buf))
+	if err != nil || typedArray == nil {
+		return vm.ToValue(buf)
+	}
+	return vm.ToValue(typedArray)
 }
 
 // MapSharedBuffer exposes a Go byte slice as a global JavaScript TypedArray.
@@ -30,7 +53,15 @@ func ToArrayBuffer(vm *sobek.Runtime, data []byte) sobek.Value {
 //	// In Go: data[0] == 42
 func MapSharedBuffer(vm *sobek.Runtime, name string, data []byte) {
 	buf := vm.NewArrayBuffer(data)
-	view := vm.ToValue(vm.Get("Uint8Array")).ToObject(vm)
-	typedArray, _ := vm.New(view, vm.ToValue(buf))
-	_ = vm.GlobalObject().Set(name, typedArray)
+	ctor := vm.Get("Uint8Array")
+	if ctor == nil || sobek.IsNull(ctor) || sobek.IsUndefined(ctor) {
+		_ = vm.GlobalObject().Set(name, buf)
+		return
+	}
+
+	view := ctor.ToObject(vm)
+	typedArray, err := vm.New(view, vm.ToValue(buf))
+	if err == nil && typedArray != nil {
+		_ = vm.GlobalObject().Set(name, typedArray)
+	}
 }

bridge/core/console.go

@@ -19,12 +19,12 @@ func (c *Console) Log(call sobek.FunctionCall) sobek.Value {
 }
 
 func (c *Console) Error(call sobek.FunctionCall) sobek.Value {
-	// @optimized: Use []interface{} and fmt.Println to avoid string conversion overhead and allocation.
-	args := make([]interface{}, len(call.Arguments))
+	// @optimized: Use []interface{} and a single fmt.Println to avoid double-locking os.Stdout.
+	args := make([]interface{}, len(call.Arguments)+1)
+	args[0] = "Error:"
 	for i, arg := range call.Arguments {
-		args[i] = arg.Export()
+		args[i+1] = arg.Export()
 	}
-	fmt.Print("Error: ")
 	fmt.Println(args...)
 	return sobek.Undefined()
 }

bridge/core/reflection.go

@@ -3,6 +3,7 @@ package core
 import (
 	"fmt"
 	"reflect"
+	"strconv"
 	"sync"
 
 	"github.com/grafana/sobek"
@@ -337,6 +338,20 @@ func wrapJSCallback(vm *sobek.Runtime, callable sobek.Callable, goType reflect.T
 }
 
 func bindSlice(vm *sobek.Runtime, v reflect.Value, visited map[uintptr]sobek.Value) (sobek.Value, error) {
+	// @optimized: Fast path for []byte using Uint8Array view
+	if v.Type().Elem() == reflect.TypeOf(byte(0)) {
+		var data []byte
+		if v.CanAddr() || v.Kind() == reflect.Slice {
+			data = v.Bytes()
+		} else {
+			// Unaddressable array, must copy to a slice first
+			data = make([]byte, v.Len())
+			reflect.Copy(reflect.ValueOf(data), v)
+		}
+		// Data MUST be copied inside ToUint8Array to prevent shared memory mutation
+		return ToUint8Array(vm, data), nil
+	}
+
 	// @optimized: Pre-allocate slice and use NewArray(vals...) to avoid repeated Set calls.
 	l := v.Len()
 	vals := make([]interface{}, l)
@@ -352,16 +367,25 @@ func bindSlice(vm *sobek.Runtime, v reflect.Value, visited map[uintptr]sobek.Val
 
 func bindMap(vm *sobek.Runtime, v reflect.Value, visited map[uintptr]sobek.Value) (sobek.Value, error) {
 	obj := vm.NewObject()
-	for _, key := range v.MapKeys() {
+	// @optimized: Use MapRange to avoid allocating a slice of keys.
+	iter := v.MapRange()
+	for iter.Next() {
+		key := iter.Key()
 		var keyStr string
-		// @optimized: Avoid Sprintf if key is already a string.
-		if key.Kind() == reflect.String {
+
+		// @optimized: Use specific formatting functions to avoid interface boxing overhead.
+		switch key.Kind() {
+		case reflect.String:
 			keyStr = key.String()
-		} else {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			keyStr = strconv.FormatInt(key.Int(), 10)
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			keyStr = strconv.FormatUint(key.Uint(), 10)
+		default:
 			keyStr = fmt.Sprint(key.Interface())
 		}
 
-		val, err := bindValue(vm, v.MapIndex(key), visited)
+		val, err := bindValue(vm, iter.Value(), visited)
 		if err != nil {
 			return nil, err
 		}

eventloop/eventloop.go

@@ -13,11 +13,14 @@ type EventLoop struct {
 	VM       *sobek.Runtime
 	jobQueue chan func()
 	stopChan chan struct{}
-	wg       sync.WaitGroup
-	running  bool
+
+	// @optimized: Group hot fields with their protecting mutex for better cache locality.
 	mu       sync.Mutex
+	running  bool
 	autoStop bool
 
+	wg sync.WaitGroup
+
 	ctx    context.Context
 	cancel context.CancelFunc
 
@@ -124,17 +127,24 @@ func (el *EventLoop) CreatePromise() (promise *sobek.Object, resolve func(interf
 	// Keep the loop alive until the promise is settled
 	el.wg.Add(1)
 
+	// @safety: Use sync.Once to ensure wg.Done is decremented exactly once even if resolve/reject are called multiple times.
+	var once sync.Once
+
 	resolve = func(v interface{}) {
 		el.RunOnLoop(func() {
 			_ = res(v)
-			el.wg.Done()
+			once.Do(func() {
+				el.wg.Done()
+			})
 		})
 	}
 
 	reject = func(v interface{}) {
 		el.RunOnLoop(func() {
 			_ = rej(v)
-			el.wg.Done()
+			once.Do(func() {
+				el.wg.Done()
+			})
 		})
 	}