goscript 0.1.4 → 0.2.0

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/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')
 

package/gs/testing/testing.ts

@@ -1,7 +1,3 @@
-import * as nodeFS from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
 import * as context from '@goscript/context/index.js'
 
 export type TestFunc = (t: T) => void | Promise<void>
@@ -24,6 +20,18 @@ export type RunResult = {
   skipped: number
 }
 
+interface HostProcess {
+  env?: Record<string, string | undefined>
+  cwd?: () => string
+  chdir?: (dir: string) => void
+  getBuiltinModule?: (name: string) => unknown
+}
+
+interface HostGlobal {
+  process?: HostProcess
+  require?: (name: string) => unknown
+}
+
 class TestControl extends Error {
   public readonly kind: 'fatal' | 'skip'
 
@@ -127,6 +135,9 @@ export class T {
     try {
       await fn(child)
     } catch (err) {
+      if (isProcessExitError(err)) {
+        throw err
+      }
       if (err instanceof TestControl && err.kind === 'skip') {
         // A skipped subtest is still a successful Run result.
       } else {
@@ -139,6 +150,9 @@ export class T {
     try {
       await child.runCleanups()
     } catch (err) {
+      if (isProcessExitError(err)) {
+        throw err
+      }
       child.Fail()
       if (!(err instanceof TestControl)) {
         child.Log(formatValue(err))
@@ -153,9 +167,21 @@ export class T {
   }
 
   public TempDir(): string {
-    const path = (nodeFS as any).mkdtempSync(
-      join(
-        tmpdir(),
+    const fs = requireHostModule<{
+      mkdtempSync(prefix: string): string
+      rmSync(path: string, opts: { force: boolean; recursive: boolean }): void
+    }>('node:fs', 'testing.TempDir')
+    const os = requireHostModule<{ tmpdir(): string }>(
+      'node:os',
+      'testing.TempDir',
+    )
+    const pathMod = requireHostModule<{ join(...parts: string[]): string }>(
+      'node:path',
+      'testing.TempDir',
+    )
+    const path = fs.mkdtempSync(
+      pathMod.join(
+        os.tmpdir(),
         'goscript-test-' +
           this.testName.replace(/[^A-Za-z0-9_.-]/g, '_') +
           '-' +
@@ -164,7 +190,7 @@ export class T {
     )
     this.tempDirs.push(path)
     this.Cleanup(() => {
-      ;(nodeFS as any).rmSync(path, { force: true, recursive: true })
+      fs.rmSync(path, { force: true, recursive: true })
     })
     return path
   }
@@ -172,12 +198,9 @@ export class T {
   public Parallel(): void {}
 
   public Setenv(key: string, value: string): void {
-    const proc = (globalThis as any).process as
-      | { env?: Record<string, string | undefined> }
-      | undefined
-    const env = proc?.env
+    const env = (globalThis as HostGlobal).process?.env
     if (env === undefined) {
-      return
+      throw new Error('testing.Setenv is not supported without a host process')
     }
     const oldValue = env[key]
     env[key] = value
@@ -191,11 +214,9 @@ export class T {
   }
 
   public Chdir(dir: string): void {
-    const proc = (globalThis as any).process as
-      | { cwd?: () => string; chdir?: (dir: string) => void }
-      | undefined
+    const proc = (globalThis as HostGlobal).process
     if (proc?.cwd === undefined || proc.chdir === undefined) {
-      return
+      throw new Error('testing.Chdir is not supported without a host process')
     }
     const oldDir = proc.cwd()
     proc.chdir(dir)
@@ -249,6 +270,9 @@ export class B extends T {
     try {
       await fn(child)
     } catch (err) {
+      if (isProcessExitError(err)) {
+        throw err
+      }
       child.Error(err)
     }
     if (child.Failed()) {
@@ -328,6 +352,9 @@ export async function runTests(
         try {
           await test.fn(t)
         } catch (err) {
+          if (isProcessExitError(err)) {
+            throw err
+          }
           if (err instanceof TestControl && err.kind === 'skip') {
             skipped++
           } else {
@@ -336,9 +363,8 @@ export async function runTests(
               t.Log(formatValue(err))
             }
           }
-        } finally {
-          await t.runCleanups()
         }
+        await t.runCleanups()
         const elapsed = ((Date.now() - start) / 1000).toFixed(2)
         if (t.Skipped()) {
           if (options.verbose) {
@@ -383,6 +409,48 @@ function formatMessage(format: string, args: unknown[]): string {
   })
 }
 
+function requireHostModule<T>(name: string, api: string): T {
+  const fromProcess = (globalThis as HostGlobal).process?.getBuiltinModule?.(
+    name,
+  )
+  if (fromProcess !== undefined && fromProcess !== null) {
+    return fromProcess as T
+  }
+  const req = hostRequire()
+  if (req !== undefined) {
+    return req(name) as T
+  }
+  throw new Error(
+    api + ' is not supported without Node-compatible host modules',
+  )
+}
+
+function hostRequire(): ((name: string) => unknown) | undefined {
+  const globalRequire = (globalThis as HostGlobal).require
+  if (typeof globalRequire === 'function') {
+    return globalRequire
+  }
+  try {
+    const req = eval(
+      'typeof require === "function" ? require : undefined',
+    ) as unknown
+    if (typeof req === 'function') {
+      return req as (name: string) => unknown
+    }
+  } catch {
+    return undefined
+  }
+  return undefined
+}
+
+function isProcessExitError(err: unknown): boolean {
+  if (err === null || typeof err !== 'object') {
+    return false
+  }
+  const code = (err as { __goscriptExitCode?: unknown }).__goscriptExitCode
+  return typeof code === 'number'
+}
+
 function formatValue(value: unknown): string {
   if (value instanceof Error) {
     return value.message