goscript 0.1.4 → 0.2.1

package/gs/strings/reader.ts

@@ -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/doc_64.gs.ts

@@ -59,7 +59,7 @@ export function CompareAndSwapUint64(addr: $.VarRef<number> | null, old: number,
 //go:noescape
 export function AddInt64(addr: $.VarRef<number> | null, delta: number): number {
 	if (!addr) return 0;
-	addr.value = addr.value + delta;
+	addr.value = $.int64Add(addr.value, delta);
 	return addr.value;
 }
 
@@ -72,7 +72,7 @@ export function AddInt64(addr: $.VarRef<number> | null, delta: number): number {
 //go:noescape
 export function AddUint64(addr: $.VarRef<number> | null, delta: number): number {
 	if (!addr) return 0;
-	addr.value = addr.value + delta;
+	addr.value = $.uint64Add(addr.value, delta);
 	return addr.value;
 }
 
@@ -84,7 +84,7 @@ export function AddUint64(addr: $.VarRef<number> | null, delta: number): number
 export function AndInt64(addr: $.VarRef<number> | null, mask: number): number {
 	if (!addr) return 0;
 	let old = addr.value;
-	addr.value = addr.value & mask;
+	addr.value = $.int64And(addr.value, mask);
 	return old;
 }
 
@@ -96,7 +96,7 @@ export function AndInt64(addr: $.VarRef<number> | null, mask: number): number {
 export function AndUint64(addr: $.VarRef<number> | null, mask: number): number {
 	if (!addr) return 0;
 	let old = addr.value;
-	addr.value = addr.value & mask;
+	addr.value = $.uint64And(addr.value, mask);
 	return old;
 }
 
@@ -108,7 +108,7 @@ export function AndUint64(addr: $.VarRef<number> | null, mask: number): number {
 export function OrInt64(addr: $.VarRef<number> | null, mask: number): number {
 	if (!addr) return 0;
 	let old = addr.value;
-	addr.value = addr.value | mask;
+	addr.value = $.int64Or(addr.value, mask);
 	return old;
 }
 
@@ -120,7 +120,7 @@ export function OrInt64(addr: $.VarRef<number> | null, mask: number): number {
 export function OrUint64(addr: $.VarRef<number> | null, mask: number): number {
 	if (!addr) return 0;
 	let old = addr.value;
-	addr.value = addr.value | mask;
+	addr.value = $.uint64Or(addr.value, mask);
 	return old;
 }
 
@@ -165,4 +165,3 @@ export function StoreUint64(addr: $.VarRef<number> | null, val: number): void {
 		addr.value = val;
 	}
 }
-

package/gs/sync/atomic/doc_64.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'vitest'
+
+import * as $ from '../../builtin/index.js'
+import {
+  AddInt64,
+  AddUint64,
+  AndUint64,
+  OrUint64,
+} from './doc_64.gs.js'
+
+function asBigInt(value: number): bigint {
+  return typeof value === 'bigint' ? value : BigInt(value)
+}
+
+describe('sync/atomic 64-bit operations', () => {
+  test('adds uint64 values without mixing number and bigint arithmetic', () => {
+    const value = $.varRef($.uint('18446744073709551614', 64))
+
+    expect(AddUint64(value, $.uint(2, 64))).toBe(0)
+    expect(value.value).toBe(0)
+  })
+
+  test('preserves high uint64 bits for bitwise operations', () => {
+    const value = $.varRef($.uint('9223372036854775808', 64))
+
+    expect(asBigInt(OrUint64(value, $.uint(1, 64)))).toBe(
+      9223372036854775808n,
+    )
+    expect(asBigInt(value.value)).toBe(9223372036854775809n)
+
+    expect(asBigInt(AndUint64(value, $.uint('18446744073709551614', 64)))).toBe(
+      9223372036854775809n,
+    )
+    expect(asBigInt(value.value)).toBe(9223372036854775808n)
+  })
+
+  test('adds int64 values without number coercion', () => {
+    const value = $.varRef($.int('9223372036854775807', 64))
+
+    expect(AddInt64(value, 1)).toBe(-9223372036854775808)
+    expect(value.value).toBe(-9223372036854775808)
+  })
+})

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/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/testing/testing.test.ts

@@ -108,6 +108,73 @@ describe('testing.T', () => {
     )
   })
 
+  it('propagates process exits out of subtests without cleanup', async () => {
+    const t = new T('root')
+    const exit = { __goscriptExitCode: 7 }
+    let cleaned = false
+
+    await expect(
+      t.Run('child', (child) => {
+        child.Cleanup(() => {
+          cleaned = true
+        })
+        throw exit
+      }),
+    ).rejects.toBe(exit)
+    expect(cleaned).toBe(false)
+  })
+
+  it('propagates process exits out of subtest cleanups', async () => {
+    const t = new T('root')
+    const exit = { __goscriptExitCode: 8 }
+
+    await expect(
+      t.Run('child', (child) => {
+        child.Cleanup(() => {
+          throw exit
+        })
+      }),
+    ).rejects.toBe(exit)
+    expect(t.Failed()).toBe(false)
+  })
+
+  it('propagates process exits out of package tests without cleanup', async () => {
+    const exit = { __goscriptExitCode: 9 }
+    let cleaned = false
+
+    await expect(
+      runTests('example.test/exit', [
+        {
+          name: 'TestExit',
+          fn: (t) => {
+            t.Cleanup(() => {
+              cleaned = true
+            })
+            throw exit
+          },
+        },
+      ]),
+    ).rejects.toBe(exit)
+    expect(cleaned).toBe(false)
+  })
+
+  it('propagates process exits out of package test cleanups', async () => {
+    const exit = { __goscriptExitCode: 10 }
+
+    await expect(
+      runTests('example.test/exit-cleanup', [
+        {
+          name: 'TestExitCleanup',
+          fn: (t) => {
+            t.Cleanup(() => {
+              throw exit
+            })
+          },
+        },
+      ]),
+    ).rejects.toBe(exit)
+  })
+
   it('returns a non-nil context', () => {
     const t = new T('root')