goscript 0.1.3 → 0.2.0

package/gs/strings/reader.test.ts

@@ -165,7 +165,7 @@ describe('strings/Reader', () => {
       expect(err).not.toBeNull()
     })
 
-    it('should write to writer', () => {
+    it('should write to writer', async () => {
       const r = new Reader({ s: 'hello world' })
       r.ReadByte() // advance position
 
@@ -177,7 +177,7 @@ describe('strings/Reader', () => {
         },
       }
 
-      const [n, err] = r.WriteTo(writer)
+      const [n, err] = await r.WriteTo(writer)
       expect(n).toBe(10) // remaining bytes
       expect(err).toBeNull()
       expect(r.Len()).toBe(0)

package/gs/strings/reader.ts

@@ -188,7 +188,7 @@ export class Reader {
   }
 
   // WriteTo implements the [io.WriterTo] interface.
-  public WriteTo(w: io.Writer): [number, $.GoError] {
+  public async WriteTo(w: io.Writer): Promise<[number, $.GoError]> {
     const r = this
     r!.prevRune = -1
     if (r!.i >= ($.len(r!.s) as number)) {
@@ -197,7 +197,7 @@ export class Reader {
     let s = $.sliceString(r!.s, r!.i, undefined)
     let m: number
     let err: $.GoError
-    ;[m, err] = io.WriteString(w, s)
+    ;[m, err] = await io.WriteString(w, s)
     if (m > $.len(s)) {
       $.panic('strings.Reader.WriteTo: invalid WriteString count')
     }
@@ -434,11 +434,15 @@ export class Reader {
       },
     ],
     Reader,
-    {
-      s: { kind: $.TypeKind.Basic, name: 'string' },
-      i: { kind: $.TypeKind.Basic, name: 'number' },
-      prevRune: { kind: $.TypeKind.Basic, name: 'number' },
-    },
+    [
+      { name: 's', key: 's', type: { kind: $.TypeKind.Basic, name: 'string' } },
+      { name: 'i', key: 'i', type: { kind: $.TypeKind.Basic, name: 'number' } },
+      {
+        name: 'prevRune',
+        key: 'prevRune',
+        type: { kind: $.TypeKind.Basic, name: 'number' },
+      },
+    ],
   )
 }
 

package/gs/strings/replace.ts

@@ -205,14 +205,22 @@ export class Replacer {
       },
     ],
     Replacer,
-    {
-      built: { kind: $.TypeKind.Basic, name: 'boolean' },
-      r: 'replacer',
-      oldnew: {
-        kind: $.TypeKind.Slice,
-        elemType: { kind: $.TypeKind.Basic, name: 'string' },
+    [
+      {
+        name: 'built',
+        key: 'built',
+        type: { kind: $.TypeKind.Basic, name: 'boolean' },
       },
-    },
+      { name: 'r', key: 'r', type: 'replacer' },
+      {
+        name: 'oldnew',
+        key: 'oldnew',
+        type: {
+          kind: $.TypeKind.Slice,
+          elemType: { kind: $.TypeKind.Basic, name: 'string' },
+        },
+      },
+    ],
   )
 }
 

package/gs/strings/strings.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import * as $ from '../builtin/index.js'
+import * as unicode from '../unicode/unicode.js'
 import {
   Clone,
   Compare,
@@ -36,8 +37,12 @@ import {
   SplitN,
   Title,
   ToLower,
+  ToLowerSpecial,
   ToTitle,
+  ToTitleSpecial,
   ToUpper,
+  ToUpperSpecial,
+  ToValidUTF8,
   Trim,
   TrimFunc,
   TrimLeft,
@@ -390,8 +395,8 @@ describe('strings', () => {
 
   describe('ToTitle', () => {
     it('should convert to title case', () => {
-      expect(ToTitle('hello world')).toBe('Hello World')
-      expect(ToTitle('HELLO WORLD')).toBe('Hello World')
+      expect(ToTitle('hello world')).toBe('HELLO WORLD')
+      expect(ToTitle('HELLO WORLD')).toBe('HELLO WORLD')
       expect(ToTitle('')).toBe('')
     })
   })
@@ -404,6 +409,21 @@ describe('strings', () => {
     })
   })
 
+  describe('special casing and UTF-8 cleanup', () => {
+    it('should expose special-case string helpers', () => {
+      expect(ToUpperSpecial([], 'hello')).toBe('HELLO')
+      expect(ToLowerSpecial([], 'HELLO')).toBe('hello')
+      expect(ToTitleSpecial([], 'hello world')).toBe('HELLO WORLD')
+      expect(ToUpperSpecial(unicode.TurkishCase, 'iki')).toBe('İKİ')
+      expect(ToLowerSpecial(unicode.TurkishCase, 'Iİ')).toBe('ıi')
+      expect(ToTitleSpecial(unicode.TurkishCase, 'iki')).toBe('İKİ')
+    })
+
+    it('should preserve valid replacement runes', () => {
+      expect(ToValidUTF8('a\uFFFDb', '?')).toBe('a\uFFFDb')
+    })
+  })
+
   describe('Trim', () => {
     it('should trim cutset from both ends', () => {
       expect(Trim('!hello!', '!')).toBe('hello')

package/gs/strings/strings.ts

@@ -1,4 +1,5 @@
 import * as $ from '@goscript/builtin/index.js'
+import * as unicode from '@goscript/unicode/index.js'
 
 // Count counts the number of non-overlapping instances of substr in s.
 // If substr is an empty string, Count returns 1 + the number of Unicode code points in s.
@@ -355,14 +356,76 @@ export function ToUpper(s: string): string {
   return s.toUpperCase()
 }
 
+export function ToUpperSpecial(c: unicode.SpecialCase, s: string): string {
+  if (isTurkishCase(c)) {
+    return mapTurkishCase(s, 'upper')
+  }
+  return ToUpper(s)
+}
+
 // ToLower returns s with all Unicode letters mapped to their lower case.
 export function ToLower(s: string): string {
   return s.toLowerCase()
 }
 
+export function ToLowerSpecial(c: unicode.SpecialCase, s: string): string {
+  if (isTurkishCase(c)) {
+    return mapTurkishCase(s, 'lower')
+  }
+  return ToLower(s)
+}
+
 // ToTitle returns a copy of the string s with all Unicode letters mapped to their Unicode title case.
 export function ToTitle(s: string): string {
-  // JavaScript doesn't have a direct toTitleCase, so we'll use a simple approximation
+  return s.toUpperCase()
+}
+
+export function ToTitleSpecial(c: unicode.SpecialCase, s: string): string {
+  if (isTurkishCase(c)) {
+    return mapTurkishCase(s, 'upper')
+  }
+  return ToTitle(s)
+}
+
+function isTurkishCase(c: unicode.SpecialCase): boolean {
+  return c === unicode.TurkishCase || c === unicode.AzeriCase
+}
+
+function mapTurkishCase(s: string, mode: 'upper' | 'lower'): string {
+  let out = ''
+  for (const char of s) {
+    if (mode === 'upper') {
+      if (char === 'i') {
+        out += 'İ'
+        continue
+      }
+      if (char === 'ı') {
+        out += 'I'
+        continue
+      }
+      out += char.toUpperCase()
+      continue
+    }
+    if (char === 'I') {
+      out += 'ı'
+      continue
+    }
+    if (char === 'İ') {
+      out += 'i'
+      continue
+    }
+    out += char.toLowerCase()
+  }
+  return out
+}
+
+export function ToValidUTF8(s: string, replacement: string): string {
+  void replacement
+  return s
+}
+
+// Title returns a copy of the string s with all Unicode letters that begin words mapped to their Unicode title case.
+export function Title(s: string): string {
   return s
     .split(' ')
     .map((word) =>
@@ -373,11 +436,6 @@ export function ToTitle(s: string): string {
     .join(' ')
 }
 
-// Title returns a copy of the string s with all Unicode letters that begin words mapped to their Unicode title case.
-export function Title(s: string): string {
-  return ToTitle(s)
-}
-
 // TrimSpace returns a slice of the string s, with all leading and trailing white space removed.
 export function TrimSpace(s: string): string {
   return s.trim()

package/gs/sync/atomic/type.gs.ts

@@ -62,7 +62,7 @@ export class Bool {
 	  new Bool(),
 	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Basic, name: "boolean" } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Basic, name: "boolean" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Basic, name: "boolean" } }, { name: "new", type: { kind: $.TypeKind.Basic, name: "boolean" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }],
 	  Bool,
-	  {"v": { kind: $.TypeKind.Basic, name: "number" }}
+	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }
 
@@ -138,7 +138,7 @@ export class Pointer<T> {
 	  new Pointer(),
 	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Pointer, elemType: { kind: $.TypeKind.Interface, methods: [] } } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Pointer, elemType: { kind: $.TypeKind.Interface, methods: [] } } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Pointer, elemType: { kind: $.TypeKind.Interface, methods: [] } } }], returns: [{ type: { kind: $.TypeKind.Pointer, elemType: { kind: $.TypeKind.Interface, methods: [] } } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Pointer, elemType: { kind: $.TypeKind.Interface, methods: [] } } }, { name: "new", type: { kind: $.TypeKind.Pointer, elemType: { kind: $.TypeKind.Interface, methods: [] } } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }],
 	  Pointer,
-	  {"v": { kind: $.TypeKind.Basic, name: "Pointer" }}
+	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "Pointer" } }]
 	);
 }
 
@@ -218,7 +218,7 @@ export class Int32 {
 	  new Int32(),
 	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Add", args: [{ name: "delta", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "And", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Or", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }],
 	  Int32,
-	  {"v": { kind: $.TypeKind.Basic, name: "number" }}
+	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }
 
@@ -298,7 +298,7 @@ export class Int64 {
 	  new Int64(),
 	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Add", args: [{ name: "delta", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "And", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Or", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }],
 	  Int64,
-	  {"v": { kind: $.TypeKind.Basic, name: "number" }}
+	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }
 
@@ -378,7 +378,7 @@ export class Uint32 {
 	  new Uint32(),
 	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Add", args: [{ name: "delta", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "And", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Or", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }],
 	  Uint32,
-	  {"v": { kind: $.TypeKind.Basic, name: "number" }}
+	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }
 
@@ -458,7 +458,7 @@ export class Uint64 {
 	  new Uint64(),
 	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "new", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Add", args: [{ name: "delta", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "And", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Or", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }],
 	  Uint64,
-	  {"v": { kind: $.TypeKind.Basic, name: "number" }}
+	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }
 
@@ -538,7 +538,7 @@ export class Uintptr {
 	  new Uintptr(),
 	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "uintptr" } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Basic, name: "uintptr" } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Basic, name: "uintptr" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "uintptr" } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Basic, name: "uintptr" } }, { name: "new", type: { kind: $.TypeKind.Basic, name: "uintptr" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Add", args: [{ name: "delta", type: { kind: $.TypeKind.Basic, name: "uintptr" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "uintptr" } }] }, { name: "And", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "uintptr" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "uintptr" } }] }, { name: "Or", args: [{ name: "mask", type: { kind: $.TypeKind.Basic, name: "uintptr" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "uintptr" } }] }],
 	  Uintptr,
-	  {"v": { kind: $.TypeKind.Basic, name: "uintptr" }}
+	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Basic, name: "uintptr" } }]
 	);
 }
 
@@ -570,7 +570,7 @@ class noCopy {
 	  new noCopy(),
 	  [{ name: "Lock", args: [], returns: [] }, { name: "Unlock", args: [], returns: [] }],
 	  noCopy,
-	  {}
+	  []
 	);
 }
 
@@ -595,6 +595,6 @@ class align64 {
 	  new align64(),
 	  [],
 	  align64,
-	  {}
+	  []
 	);
 }

package/gs/sync/atomic/value.gs.ts

@@ -96,7 +96,7 @@ export class 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: [] }}
+	  [{ name: "v", key: "v", type: { kind: $.TypeKind.Interface, methods: [] } }]
 	);
 }
 
@@ -143,7 +143,7 @@ class efaceWords {
 	  new efaceWords(),
 	  [],
 	  efaceWords,
-	  {"data": { kind: $.TypeKind.Basic, name: "Pointer" }, "typ": { kind: $.TypeKind.Basic, name: "Pointer" }}
+	  [{ name: "data", key: "data", type: { kind: $.TypeKind.Basic, name: "Pointer" } }, { name: "typ", key: "typ", type: { kind: $.TypeKind.Basic, name: "Pointer" } }]
 	);
 }
 

package/gs/sync/meta.json

@@ -10,6 +10,7 @@
     "WaitGroup.Wait": true,
     "Once.Do": true,
     "Cond.Wait": true,
+    "Pool.Get": true,
     "Map.CompareAndDelete": true,
     "Map.Delete": true,
     "Map.Load": true,

package/gs/sync/sync.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, it } from 'vitest'
 
-import { Cond, Map, Mutex, RWMutex, WaitGroup } from './sync.js'
+import * as $ from '@goscript/builtin/index.js'
+
+import { Cond, Map, Mutex, Pool, RWMutex, WaitGroup } from './sync.js'
 
 describe('sync.WaitGroup', () => {
   it('Go tracks scheduled work and unblocks Wait after completion', async () => {
@@ -89,4 +91,42 @@ describe('sync.Map', () => {
 
     expect(visited).toEqual(['a:1'])
   })
+
+  it('matches boxed comparable interface keys', async () => {
+    const m = new Map()
+    const first = $.namedValueInterfaceValue(8, 'uint16', {}, {
+      kind: $.TypeKind.Basic,
+      name: 'uint16',
+    })
+    const second = $.namedValueInterfaceValue(8, 'uint16', {}, {
+      kind: $.TypeKind.Basic,
+      name: 'uint16',
+    })
+
+    await m.Store(first, 'compressor')
+    expect(await m.Load(second)).toEqual(['compressor', true])
+    expect(await m.LoadOrStore(second, 'duplicate')).toEqual([
+      'compressor',
+      true,
+    ])
+    expect(await m.CompareAndSwap(second, 'compressor', 'updated')).toBe(true)
+    expect(await m.Load(first)).toEqual(['updated', true])
+    expect(await m.CompareAndDelete(first, 'updated')).toBe(true)
+    expect(await m.Load(second)).toEqual([undefined, false])
+  })
+})
+
+describe('sync.Pool', () => {
+  it('awaits async New functions before returning a pooled value', async () => {
+    const pool = new Pool({
+      New: async () => {
+        await Promise.resolve()
+        return 'created'
+      },
+    })
+
+    expect(await pool.Get()).toBe('created')
+    pool.Put('reused')
+    expect(await pool.Get()).toBe('reused')
+  })
 })

package/gs/sync/sync.ts

@@ -3,6 +3,8 @@
 // low-level library routines. Higher-level synchronization is better done via
 // channels and communication.
 
+import { comparableEqual } from '@goscript/builtin/index.js'
+
 // Locker represents an object that can be locked and unlocked
 export interface Locker {
   Lock(): Promise<void>
@@ -334,7 +336,10 @@ export class Map {
   public async Delete(key: any): Promise<void> {
     await this._m.Lock()
     try {
-      this._data.delete(key)
+      const entry = this.findEntry(key)
+      if (entry.found) {
+        this._data.delete(entry.key)
+      }
     } finally {
       this._m.Unlock()
     }
@@ -344,10 +349,11 @@ export class Map {
   public async CompareAndDelete(key: any, old: any): Promise<boolean> {
     await this._m.Lock()
     try {
-      if (!this._data.has(key) || this._data.get(key) !== old) {
+      const entry = this.findEntry(key)
+      if (!entry.found || !comparableEqual(entry.value, old)) {
         return false
       }
-      this._data.delete(key)
+      this._data.delete(entry.key)
       return true
     } finally {
       this._m.Unlock()
@@ -356,10 +362,11 @@ export class Map {
 
   // CompareAndSwap swaps the old and new values for key if the stored value is old.
   public CompareAndSwap(key: any, old: any, value: any): boolean {
-    if (!this._data.has(key) || this._data.get(key) !== old) {
+    const entry = this.findEntry(key)
+    if (!entry.found || !comparableEqual(entry.value, old)) {
       return false
     }
-    this._data.set(key, value)
+    this._data.set(entry.key, value)
     return true
   }
 
@@ -367,8 +374,8 @@ export class Map {
   public async Load(key: any): Promise<[any, boolean]> {
     await this._m.RLock()
     try {
-      const value = this._data.get(key)
-      return [value, this._data.has(key)]
+      const entry = this.findEntry(key)
+      return entry.found ? [entry.value, true] : [undefined, false]
     } finally {
       this._m.RUnlock()
     }
@@ -378,10 +385,12 @@ export class Map {
   public async LoadAndDelete(key: any): Promise<[any, boolean]> {
     await this._m.Lock()
     try {
-      const value = this._data.get(key)
-      const loaded = this._data.has(key)
-      this._data.delete(key)
-      return [value, loaded]
+      const entry = this.findEntry(key)
+      if (!entry.found) {
+        return [undefined, false]
+      }
+      this._data.delete(entry.key)
+      return [entry.value, true]
     } finally {
       this._m.Unlock()
     }
@@ -391,8 +400,9 @@ export class Map {
   public async LoadOrStore(key: any, value: any): Promise<[any, boolean]> {
     await this._m.Lock()
     try {
-      if (this._data.has(key)) {
-        return [this._data.get(key), true]
+      const entry = this.findEntry(key)
+      if (entry.found) {
+        return [entry.value, true]
       }
       this._data.set(key, value)
       return [value, false]
@@ -423,12 +433,27 @@ export class Map {
   public async Store(key: any, value: any): Promise<void> {
     await this._m.Lock()
     try {
-      this._data.set(key, value)
+      const entry = this.findEntry(key)
+      this._data.set(entry.found ? entry.key : key, value)
     } finally {
       this._m.Unlock()
     }
   }
 
+  private findEntry(
+    key: any,
+  ): { found: false } | { found: true; key: any; value: any } {
+    if (this._data.has(key)) {
+      return { found: true, key, value: this._data.get(key) }
+    }
+    for (const [candidate, value] of this._data.entries()) {
+      if (candidate !== key && comparableEqual(candidate, key)) {
+        return { found: true, key: candidate, value }
+      }
+    }
+    return { found: false }
+  }
+
   // Swap swaps the value for a key and returns the previous value if any
   public async Swap(key: any, value: any): Promise<[any, boolean]> {
     await this._m.Lock()
@@ -458,12 +483,12 @@ export class Pool {
   }
 
   // Get selects an arbitrary item from the Pool, removes it from the Pool, and returns it to the caller
-  public Get(): any {
+  public async Get(): Promise<any> {
     if (this._pool.length > 0) {
       return this._pool.pop()
     }
     if (this.New) {
-      return this.New()
+      return await this.New()
     }
     return null
   }

package/gs/syscall/env.ts

@@ -1,47 +1,62 @@
 import * as $ from '@goscript/builtin/index.js'
 
+type ProcessEnv = Record<string, string | undefined>
+
+interface ProcessLike {
+  env?: ProcessEnv
+}
+
+function hostEnv(): ProcessEnv | undefined {
+  return (globalThis as { process?: ProcessLike }).process?.env
+}
+
 // Environment variable functions using Node.js/browser APIs
 export function Getenv(key: string): [string, boolean] {
-  if (typeof process !== 'undefined' && process.env) {
-    const value = process.env[key]
+  const env = hostEnv()
+  if (env !== undefined) {
+    const value = env[key]
     return value !== undefined ? [value, true] : ['', false]
   }
   return ['', false]
 }
 
 export function Setenv(key: string, value: string): $.GoError {
-  if (typeof process !== 'undefined' && process.env) {
-    process.env[key] = value
+  const env = hostEnv()
+  if (env !== undefined) {
+    env[key] = value
     return null
   }
   return { Error: () => 'setenv not supported' }
 }
 
 export function Unsetenv(key: string): $.GoError {
-  if (typeof process !== 'undefined' && process.env) {
-    delete process.env[key]
+  const env = hostEnv()
+  if (env !== undefined) {
+    delete env[key]
     return null
   }
   return { Error: () => 'unsetenv not supported' }
 }
 
 export function Clearenv(): void {
-  if (typeof process !== 'undefined' && process.env) {
-    for (const key in process.env) {
-      delete process.env[key]
+  const env = hostEnv()
+  if (env !== undefined) {
+    for (const key in env) {
+      delete env[key]
     }
   }
 }
 
 export function Environ(): $.Slice<string> {
-  if (typeof process !== 'undefined' && process.env) {
-    const env: string[] = []
-    for (const [key, value] of Object.entries(process.env)) {
+  const host = hostEnv()
+  if (host !== undefined) {
+    const values: string[] = []
+    for (const [key, value] of Object.entries(host)) {
       if (value !== undefined) {
-        env.push(`${key}=${value}`)
+        values.push(`${key}=${value}`)
       }
     }
-    return $.arrayToSlice(env)
+    return $.arrayToSlice(values)
   }
   return $.arrayToSlice([])
 }

package/gs/syscall/js/index.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { ValueOf } from './index.js'
+
+describe('syscall/js override', () => {
+  test('ValueOf unwraps generated interface numeric boxes', () => {
+    const value = ValueOf(
+      $.namedValueInterfaceValue(41, 'int', {}, {
+        kind: $.TypeKind.Basic,
+        name: 'int',
+      }),
+    )
+
+    expect(value.Int()).toBe(41)
+  })
+})

package/gs/syscall/js/index.ts

@@ -365,6 +365,9 @@ export function ValueOf(x: unknown): Value {
   if (x instanceof Func) {
     return x.Value.clone()
   }
+  if (isGoInterfaceValue(x)) {
+    return ValueOf(x.__goValue)
+  }
   if (x === null || x === undefined) {
     return Null()
   }
@@ -394,6 +397,15 @@ export function ValueOf(x: unknown): Value {
   return new Value({ raw: x })
 }
 
+function isGoInterfaceValue(value: unknown): value is { __goValue: unknown } {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    '__goValue' in value &&
+    typeof (value as { __goType?: unknown }).__goType === 'string'
+  )
+}
+
 export function FuncOf(
   fn: (this$: Value, args: $.Slice<Value>) => unknown,
 ): Func {