goscript 0.0.35 → 0.0.36

package/dist/gs/sync/atomic/value.gs.js

@@ -0,0 +1,116 @@
+import * as $ from "@goscript/builtin/builtin.js";
+// firstStoreInProgress is a placeholder value used during the first store operation
+const firstStoreInProgress = Symbol('firstStoreInProgress');
+export class Value {
+    get v() {
+        return this._fields.v.value;
+    }
+    set v(value) {
+        this._fields.v.value = value;
+    }
+    _fields;
+    constructor(init) {
+        this._fields = {
+            v: $.varRef(init?.v ?? null)
+        };
+    }
+    clone() {
+        const cloned = new Value();
+        cloned._fields = {
+            v: $.varRef(this._fields.v.value)
+        };
+        return cloned;
+    }
+    // Load returns the value set by the most recent Store.
+    // It returns nil if there has been no call to Store for this Value.
+    Load() {
+        const v = this;
+        // For JavaScript, we can simplify this since we're single-threaded
+        // Just return the stored value directly
+        return v._fields.v.value;
+    }
+    // Store sets the value of the [Value] v to val.
+    // All calls to Store for a given Value must use values of the same concrete type.
+    // Store of an inconsistent type panics, as does Store(nil).
+    Store(val) {
+        const v = this;
+        if (val == null) {
+            $.panic("sync/atomic: store of nil value into Value");
+        }
+        // For JavaScript, store the value directly
+        v._fields.v.value = val;
+    }
+    // Swap stores new into Value and returns the previous value. It returns nil if
+    // the Value is empty.
+    //
+    // All calls to Swap for a given Value must use values of the same concrete
+    // type. Swap of an inconsistent type panics, as does Swap(nil).
+    Swap(_new) {
+        const v = this;
+        if (_new == null) {
+            $.panic("sync/atomic: swap of nil value into Value");
+        }
+        // For JavaScript, swap the values directly
+        const old = v._fields.v.value;
+        v._fields.v.value = _new;
+        return old;
+    }
+    // CompareAndSwap executes the compare-and-swap operation for the [Value].
+    //
+    // All calls to CompareAndSwap for a given Value must use values of the same
+    // concrete type. CompareAndSwap of an inconsistent type panics, as does
+    // CompareAndSwap(old, nil).
+    CompareAndSwap(old, _new) {
+        const v = this;
+        if (_new == null) {
+            $.panic("sync/atomic: compare and swap of nil value into Value");
+        }
+        // For JavaScript, compare and swap directly
+        if (v._fields.v.value === old) {
+            v._fields.v.value = _new;
+            return true;
+        }
+        return false;
+    }
+    // Register this type with the runtime type system
+    static __typeInfo = $.registerStructType('Value', new Value(), [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Interface, methods: [] } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Interface, methods: [] } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Interface, methods: [] } }], returns: [{ type: { kind: $.TypeKind.Interface, methods: [] } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Interface, methods: [] } }, { name: "new", type: { kind: $.TypeKind.Interface, methods: [] } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }], Value, { "v": { kind: $.TypeKind.Interface, methods: [] } });
+}
+class efaceWords {
+    get typ() {
+        return this._fields.typ.value;
+    }
+    set typ(value) {
+        this._fields.typ.value = value;
+    }
+    get data() {
+        return this._fields.data.value;
+    }
+    set data(value) {
+        this._fields.data.value = value;
+    }
+    _fields;
+    constructor(init) {
+        this._fields = {
+            typ: $.varRef(init?.typ ?? null),
+            data: $.varRef(init?.data ?? null)
+        };
+    }
+    clone() {
+        const cloned = new efaceWords();
+        cloned._fields = {
+            typ: $.varRef(this._fields.typ.value),
+            data: $.varRef(this._fields.data.value)
+        };
+        return cloned;
+    }
+    // Register this type with the runtime type system
+    static __typeInfo = $.registerStructType('efaceWords', new efaceWords(), [], efaceWords, { "data": { kind: $.TypeKind.Basic, name: "Pointer" }, "typ": { kind: $.TypeKind.Basic, name: "Pointer" } });
+}
+// Runtime functions for pinning/unpinning (no-ops in JavaScript)
+export function runtime_procPin() {
+    return 0; // No-op in JavaScript
+}
+export function runtime_procUnpin() {
+    // No-op in JavaScript
+}
+//# sourceMappingURL=value.gs.js.map

package/dist/gs/sync/atomic/value.gs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value.gs.js","sourceRoot":"","sources":["../../../../gs/sync/atomic/value.gs.ts"],"names":[],"mappings":"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"}

package/dist/gs/unsafe/unsafe.d.ts

@@ -9,3 +9,4 @@ export declare function Slice(_ptr: Pointer, _len: IntegerType): any[];
 export declare function SliceData(_slice: any[]): Pointer;
 export declare function String(_ptr: Pointer, _len: IntegerType): string;
 export declare function StringData(_str: string): Pointer;
+export declare function Pointer(value: any): Pointer;

package/dist/gs/unsafe/unsafe.js

@@ -41,4 +41,9 @@ export function String(_ptr, _len) {
 export function StringData(_str) {
     throw new Error('unsafe.StringData is not supported in JavaScript/TypeScript: direct memory access is not available in JavaScript');
 }
+// Pointer converts a value to an unsafe.Pointer for atomic operations
+// In JavaScript/TypeScript, this is just a pass-through function
+export function Pointer(value) {
+    return value;
+}
 //# sourceMappingURL=unsafe.js.map

package/dist/gs/unsafe/unsafe.js.map

@@ -1 +1 @@
-{"version":3,"file":"unsafe.js","sourceRoot":"","sources":["../../../gs/unsafe/unsafe.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,2FAA2F;AAC3F,mCAAmC;AAYnC,uEAAuE;AACvE,4DAA4D;AAC5D,MAAM,UAAU,OAAO,CAAC,SAAwB;IAC9C,MAAM,IAAI,KAAK,CACb,sHAAsH,CACvH,CAAA;AACH,CAAC;AAED,8EAA8E;AAC9E,4DAA4D;AAC5D,MAAM,UAAU,QAAQ,CAAC,SAAwB;IAC/C,MAAM,IAAI,KAAK,CACb,sIAAsI,CACvI,CAAA;AACH,CAAC;AAED,iEAAiE;AACjE,4DAA4D;AAC5D,MAAM,UAAU,MAAM,CAAC,SAAwB;IAC7C,MAAM,IAAI,KAAK,CACb,gHAAgH,CACjH,CAAA;AACH,CAAC;AAED,sDAAsD;AACtD,+DAA+D;AAC/D,MAAM,UAAU,GAAG,CAAC,IAAa,EAAE,IAAiB;IAClD,MAAM,IAAI,KAAK,CACb,yGAAyG,CAC1G,CAAA;AACH,CAAC;AAED,6DAA6D;AAC7D,4DAA4D;AAC5D,MAAM,UAAU,KAAK,CAAC,IAAa,EAAE,IAAiB;IACpD,MAAM,IAAI,KAAK,CACb,6GAA6G,CAC9G,CAAA;AACH,CAAC;AAED,mEAAmE;AACnE,4DAA4D;AAC5D,MAAM,UAAU,SAAS,CAAC,MAAa;IACrC,MAAM,IAAI,KAAK,CACb,iHAAiH,CAClH,CAAA;AACH,CAAC;AAED,oEAAoE;AACpE,4DAA4D;AAC5D,MAAM,UAAU,MAAM,CAAC,IAAa,EAAE,IAAiB;IACrD,MAAM,IAAI,KAAK,CACb,8GAA8G,CAC/G,CAAA;AACH,CAAC;AAED,kEAAkE;AAClE,4DAA4D;AAC5D,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,MAAM,IAAI,KAAK,CACb,kHAAkH,CACnH,CAAA;AACH,CAAC"}
+{"version":3,"file":"unsafe.js","sourceRoot":"","sources":["../../../gs/unsafe/unsafe.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,2FAA2F;AAC3F,mCAAmC;AAYnC,uEAAuE;AACvE,4DAA4D;AAC5D,MAAM,UAAU,OAAO,CAAC,SAAwB;IAC9C,MAAM,IAAI,KAAK,CACb,sHAAsH,CACvH,CAAA;AACH,CAAC;AAED,8EAA8E;AAC9E,4DAA4D;AAC5D,MAAM,UAAU,QAAQ,CAAC,SAAwB;IAC/C,MAAM,IAAI,KAAK,CACb,sIAAsI,CACvI,CAAA;AACH,CAAC;AAED,iEAAiE;AACjE,4DAA4D;AAC5D,MAAM,UAAU,MAAM,CAAC,SAAwB;IAC7C,MAAM,IAAI,KAAK,CACb,gHAAgH,CACjH,CAAA;AACH,CAAC;AAED,sDAAsD;AACtD,+DAA+D;AAC/D,MAAM,UAAU,GAAG,CAAC,IAAa,EAAE,IAAiB;IAClD,MAAM,IAAI,KAAK,CACb,yGAAyG,CAC1G,CAAA;AACH,CAAC;AAED,6DAA6D;AAC7D,4DAA4D;AAC5D,MAAM,UAAU,KAAK,CAAC,IAAa,EAAE,IAAiB;IACpD,MAAM,IAAI,KAAK,CACb,6GAA6G,CAC9G,CAAA;AACH,CAAC;AAED,mEAAmE;AACnE,4DAA4D;AAC5D,MAAM,UAAU,SAAS,CAAC,MAAa;IACrC,MAAM,IAAI,KAAK,CACb,iHAAiH,CAClH,CAAA;AACH,CAAC;AAED,oEAAoE;AACpE,4DAA4D;AAC5D,MAAM,UAAU,MAAM,CAAC,IAAa,EAAE,IAAiB;IACrD,MAAM,IAAI,KAAK,CACb,8GAA8G,CAC/G,CAAA;AACH,CAAC;AAED,kEAAkE;AAClE,4DAA4D;AAC5D,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,MAAM,IAAI,KAAK,CACb,kHAAkH,CACnH,CAAA;AACH,CAAC;AAED,sEAAsE;AACtE,iEAAiE;AACjE,MAAM,UAAU,OAAO,CAAC,KAAU;IAChC,OAAO,KAAK,CAAC;AACf,CAAC"}

package/gs/maps/iter.ts

@@ -58,7 +58,7 @@ export function Insert<K extends $.Comparable, V>(
 
 // Collect collects key-value pairs from seq into a new map
 // and returns it.
-export function Collect<K extends $.Comparable, V extends any>(
+export function Collect<K extends $.Comparable, V>(
   seq: iter.Seq2<K, V>,
 ): Map<K, V> {
   let m = $.makeMap<K, V>()

package/gs/math/erfinv.gs.test.ts

@@ -46,8 +46,8 @@ describe('Erfinv', () => {
   })
 
   it('should handle very small values', () => {
-    expect(Erfinv(1e-10)).toBeCloseTo(8.862269254527579e-11, 14)
-    expect(Erfinv(-1e-10)).toBeCloseTo(-8.862269254527579e-11, 14)
+    expect(Erfinv(1e-10)).toBeCloseTo(8.862269254527579e-11, 14) //eslint-disable-line no-loss-of-precision
+    expect(Erfinv(-1e-10)).toBeCloseTo(-8.862269254527579e-11, 14) //eslint-disable-line no-loss-of-precision
   })
 
   it('should handle values close to boundaries', () => {

package/gs/math/fma.gs.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { FMA } from './fma.gs.js';
-import { Inf, NaN, IsNaN, IsInf } from './bits.gs.js';
+import { Inf, NaN as GoNaN, IsNaN } from './bits.gs.js';
 
 describe('FMA', () => {
   it('should compute fused multiply-add correctly for basic cases', () => {
@@ -35,10 +35,10 @@ describe('FMA', () => {
   });
 
   it('should handle NaN cases', () => {
-    expect(IsNaN(FMA(NaN(), 2, 3))).toBe(true);
-    expect(IsNaN(FMA(2, NaN(), 3))).toBe(true);
-    expect(IsNaN(FMA(2, 3, NaN()))).toBe(true);
-    expect(IsNaN(FMA(NaN(), NaN(), NaN()))).toBe(true);
+    expect(IsNaN(FMA(GoNaN(), 2, 3))).toBe(true);
+    expect(IsNaN(FMA(2, GoNaN(), 3))).toBe(true);
+    expect(IsNaN(FMA(2, 3, GoNaN()))).toBe(true);
+    expect(IsNaN(FMA(GoNaN(), GoNaN(), GoNaN()))).toBe(true);
   });
 
   it('should handle special infinity and zero combinations', () => {

package/gs/math/ldexp.gs.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { Ldexp, ldexp } from './ldexp.gs.js';
 import { Frexp } from './frexp.gs.js';
-import { Inf, NaN, IsNaN, IsInf } from './bits.gs.js';
+import { Inf, NaN as GoNaN, IsNaN } from './bits.gs.js';
 
 describe('Ldexp', () => {
   it('should compute frac × 2^exp correctly for basic cases', () => {
@@ -47,9 +47,9 @@ describe('Ldexp', () => {
   });
 
   it('should handle NaN cases', () => {
-    expect(IsNaN(Ldexp(NaN(), 5))).toBe(true);
-    expect(IsNaN(Ldexp(NaN(), -5))).toBe(true);
-    expect(IsNaN(Ldexp(NaN(), 0))).toBe(true);
+    expect(IsNaN(Ldexp(GoNaN(), 5))).toBe(true);
+    expect(IsNaN(Ldexp(GoNaN(), -5))).toBe(true);
+    expect(IsNaN(Ldexp(GoNaN(), 0))).toBe(true);
   });
 
   it('should be the inverse of Frexp', () => {
@@ -123,6 +123,6 @@ describe('ldexp (lowercase)', () => {
     // Test special cases
     expect(ldexp(Inf(1), 5)).toBe(Ldexp(Inf(1), 5));
     expect(ldexp(Inf(-1), 5)).toBe(Ldexp(Inf(-1), 5));
-    expect(IsNaN(ldexp(NaN(), 5))).toBe(IsNaN(Ldexp(NaN(), 5)));
+    expect(IsNaN(ldexp(GoNaN(), 5))).toBe(IsNaN(Ldexp(GoNaN(), 5)));
   });
 }); 

package/gs/math/lgamma.gs.test.ts

@@ -94,8 +94,8 @@ describe('Lgamma', () => {
   it('should satisfy reflection formula for negative values', () => {
     // For non-integer x: Lgamma(x) + Lgamma(1-x) = log(π/sin(πx))
     const x = 0.3
-    const [lgamma_x, sign_x] = Lgamma(x)
-    const [lgamma_1_minus_x, sign_1_minus_x] = Lgamma(1 - x)
+    const [lgamma_x, _sign_x] = Lgamma(x)
+    const [lgamma_1_minus_x, _sign_1_minus_x] = Lgamma(1 - x)
     const expected = Math.log(Math.PI / Math.sin(Math.PI * x))
     expect(lgamma_x + lgamma_1_minus_x).toBeCloseTo(expected, 5)
   })

package/gs/sync/atomic/doc.gs.ts

@@ -0,0 +1,276 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+import * as unsafe from "@goscript/unsafe/index.js"
+
+// Type alias for uintptr (pointer-sized unsigned integer)
+export type uintptr = number;
+export type Pointer = any;
+
+// SwapInt32 atomically stores new into *addr and returns the previous *addr value.
+// Consider using the more ergonomic and less error-prone [Int32.Swap] instead.
+//
+//go:noescape
+export function SwapInt32(addr: $.VarRef<number> | null, _new: number): number {
+	if (!addr) return 0;
+	let old = addr.value;
+	addr.value = _new;
+	return old;
+}
+
+// SwapUint32 atomically stores new into *addr and returns the previous *addr value.
+// Consider using the more ergonomic and less error-prone [Uint32.Swap] instead.
+//
+//go:noescape
+export function SwapUint32(addr: $.VarRef<number> | null, _new: number): number {
+	if (!addr) return 0;
+	let old = addr.value;
+	addr.value = _new;
+	return old;
+}
+
+// SwapUintptr atomically stores new into *addr and returns the previous *addr value.
+// Consider using the more ergonomic and less error-prone [Uintptr.Swap] instead.
+//
+//go:noescape
+export function SwapUintptr(addr: $.VarRef<uintptr> | null, _new: uintptr): uintptr {
+	if (!addr) return 0;
+	let old = addr.value;
+	addr.value = _new;
+	return old;
+}
+
+// SwapPointer atomically stores new into *addr and returns the previous *addr value.
+// Consider using the more ergonomic and less error-prone [Pointer.Swap] instead.
+export function SwapPointer(addr: $.VarRef<Pointer> | null, _new: Pointer): Pointer {
+	if (!addr) return null;
+	let old = addr.value;
+	addr.value = _new;
+	return old;
+}
+
+// CompareAndSwapInt32 executes the compare-and-swap operation for an int32 value.
+// Consider using the more ergonomic and less error-prone [Int32.CompareAndSwap] instead.
+//
+//go:noescape
+export function CompareAndSwapInt32(addr: $.VarRef<number> | null, old: number, _new: number): boolean {
+	if (!addr) return false;
+	if (addr.value === old) {
+		addr.value = _new;
+		return true;
+	}
+	return false;
+}
+
+// CompareAndSwapUint32 executes the compare-and-swap operation for a uint32 value.
+// Consider using the more ergonomic and less error-prone [Uint32.CompareAndSwap] instead.
+//
+//go:noescape
+export function CompareAndSwapUint32(addr: $.VarRef<number> | null, old: number, _new: number): boolean {
+	if (!addr) return false;
+	if (addr.value === old) {
+		addr.value = _new;
+		return true;
+	}
+	return false;
+}
+
+// CompareAndSwapUintptr executes the compare-and-swap operation for a uintptr value.
+// Consider using the more ergonomic and less error-prone [Uintptr.CompareAndSwap] instead.
+//
+//go:noescape
+export function CompareAndSwapUintptr(addr: $.VarRef<uintptr> | null, old: uintptr, _new: uintptr): boolean {
+	if (!addr) return false;
+	if (addr.value === old) {
+		addr.value = _new;
+		return true;
+	}
+	return false;
+}
+
+// CompareAndSwapPointer executes the compare-and-swap operation for a unsafe.Pointer value.
+// Consider using the more ergonomic and less error-prone [Pointer.CompareAndSwap] instead.
+export function CompareAndSwapPointer(addr: $.VarRef<Pointer> | null, old: Pointer, _new: Pointer): boolean {
+	if (!addr) return false;
+	if (addr.value === old) {
+		addr.value = _new;
+		return true;
+	}
+	return false;
+}
+
+// AddInt32 atomically adds delta to *addr and returns the new value.
+// Consider using the more ergonomic and less error-prone [Int32.Add] instead.
+//
+//go:noescape
+export function AddInt32(addr: $.VarRef<number> | null, delta: number): number {
+	if (!addr) return 0;
+	addr.value = (addr.value + delta) | 0; // Use bitwise OR to ensure 32-bit signed integer
+	return addr.value;
+}
+
+// AddUint32 atomically adds delta to *addr and returns the new value.
+// To subtract a signed positive constant value c from x, do AddUint32(&x, ^uint32(c-1)).
+// In particular, to decrement x, do AddUint32(&x, ^uint32(0)).
+// Consider using the more ergonomic and less error-prone [Uint32.Add] instead.
+//
+//go:noescape
+export function AddUint32(addr: $.VarRef<number> | null, delta: number): number {
+	if (!addr) return 0;
+	addr.value = (addr.value + delta) >>> 0; // Use unsigned right shift to ensure 32-bit unsigned integer
+	return addr.value;
+}
+
+// AddUintptr atomically adds delta to *addr and returns the new value.
+// Consider using the more ergonomic and less error-prone [Uintptr.Add] instead.
+//
+//go:noescape
+export function AddUintptr(addr: $.VarRef<uintptr> | null, delta: uintptr): uintptr {
+	if (!addr) return 0;
+	addr.value = (addr.value + delta) >>> 0; // Use unsigned right shift for uintptr
+	return addr.value;
+}
+
+// AndInt32 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask
+// and returns the old value.
+// Consider using the more ergonomic and less error-prone [Int32.And] instead.
+//
+//go:noescape
+export function AndInt32(addr: $.VarRef<number> | null, mask: number): number {
+	if (!addr) return 0;
+	let old = addr.value;
+	addr.value = (addr.value & mask) | 0; // Use bitwise OR to ensure 32-bit signed integer
+	return old;
+}
+
+// AndUint32 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask
+// and returns the old value.
+// Consider using the more ergonomic and less error-prone [Uint32.And] instead.
+//
+//go:noescape
+export function AndUint32(addr: $.VarRef<number> | null, mask: number): number {
+	if (!addr) return 0;
+	let old = addr.value;
+	addr.value = (addr.value & mask) >>> 0; // Use unsigned right shift to ensure 32-bit unsigned integer
+	return old;
+}
+
+// AndUintptr atomically performs a bitwise AND operation on *addr using the bitmask provided as mask
+// and returns the old value.
+// Consider using the more ergonomic and less error-prone [Uintptr.And] instead.
+//
+//go:noescape
+export function AndUintptr(addr: $.VarRef<uintptr> | null, mask: uintptr): uintptr {
+	if (!addr) return 0;
+	let old = addr.value;
+	addr.value = (addr.value & mask) >>> 0; // Use unsigned right shift for uintptr
+	return old;
+}
+
+// OrInt32 atomically performs a bitwise OR operation on *addr using the bitmask provided as mask
+// and returns the old value.
+// Consider using the more ergonomic and less error-prone [Int32.Or] instead.
+//
+//go:noescape
+export function OrInt32(addr: $.VarRef<number> | null, mask: number): number {
+	if (!addr) return 0;
+	let old = addr.value;
+	addr.value = (addr.value | mask) | 0; // Use bitwise OR to ensure 32-bit signed integer
+	return old;
+}
+
+// OrUint32 atomically performs a bitwise OR operation on *addr using the bitmask provided as mask
+// and returns the old value.
+// Consider using the more ergonomic and less error-prone [Uint32.Or] instead.
+//
+//go:noescape
+export function OrUint32(addr: $.VarRef<number> | null, mask: number): number {
+	if (!addr) return 0;
+	let old = addr.value;
+	addr.value = (addr.value | mask) >>> 0; // Use unsigned right shift to ensure 32-bit unsigned integer
+	return old;
+}
+
+// OrUintptr atomically performs a bitwise OR operation on *addr using the bitmask provided as mask
+// and returns the old value.
+// Consider using the more ergonomic and less error-prone [Uintptr.Or] instead.
+//
+//go:noescape
+export function OrUintptr(addr: $.VarRef<uintptr> | null, mask: uintptr): uintptr {
+	if (!addr) return 0;
+	let old = addr.value;
+	addr.value = (addr.value | mask) >>> 0; // Use unsigned right shift for uintptr
+	return old;
+}
+
+// LoadInt32 atomically loads *addr.
+// Consider using the more ergonomic and less error-prone [Int32.Load] instead.
+//
+//go:noescape
+export function LoadInt32(addr: $.VarRef<number> | null): number {
+	if (!addr) return 0;
+	return addr.value;
+}
+
+// LoadUint32 atomically loads *addr.
+// Consider using the more ergonomic and less error-prone [Uint32.Load] instead.
+//
+//go:noescape
+export function LoadUint32(addr: $.VarRef<number> | null): number {
+	if (!addr) return 0;
+	return addr.value;
+}
+
+// LoadUintptr atomically loads *addr.
+// Consider using the more ergonomic and less error-prone [Uintptr.Load] instead.
+//
+//go:noescape
+export function LoadUintptr(addr: $.VarRef<uintptr> | null): uintptr {
+	if (!addr) return 0;
+	return addr.value;
+}
+
+// LoadPointer atomically loads *addr.
+// Consider using the more ergonomic and less error-prone [Pointer.Load] instead.
+export function LoadPointer(addr: $.VarRef<Pointer> | null): Pointer {
+	if (!addr) return null;
+	return addr.value;
+}
+
+// StoreInt32 atomically stores val into *addr.
+// Consider using the more ergonomic and less error-prone [Int32.Store] instead.
+//
+//go:noescape
+export function StoreInt32(addr: $.VarRef<number> | null, val: number): void {
+	if (addr) {
+		addr.value = val | 0; // Use bitwise OR to ensure 32-bit signed integer
+	}
+}
+
+// StoreUint32 atomically stores val into *addr.
+// Consider using the more ergonomic and less error-prone [Uint32.Store] instead.
+//
+//go:noescape
+export function StoreUint32(addr: $.VarRef<number> | null, val: number): void {
+	if (addr) {
+		addr.value = val >>> 0; // Use unsigned right shift to ensure 32-bit unsigned integer
+	}
+}
+
+// StoreUintptr atomically stores val into *addr.
+// Consider using the more ergonomic and less error-prone [Uintptr.Store] instead.
+//
+//go:noescape
+export function StoreUintptr(addr: $.VarRef<uintptr> | null, val: uintptr): void {
+	if (addr) {
+		addr.value = val >>> 0; // Use unsigned right shift for uintptr
+	}
+}
+
+// StorePointer atomically stores val into *addr.
+// Consider using the more ergonomic and less error-prone [Pointer.Store] instead.
+export function StorePointer(addr: $.VarRef<Pointer> | null, val: Pointer): void {
+	if (addr) {
+		addr.value = val;
+	}
+}
+