goscript 0.1.0 → 0.1.2

package/gs/os/dir_unix.gs.ts

@@ -130,7 +130,7 @@ export function readIntBE(b: $.Bytes, size: uintptr): number {
 		case 4:
 			return (byteorder.BEUint32(b) as number)
 		case 8:
-			return (byteorder.BEUint64(b) as number)
+			return Number(byteorder.BEUint64(b))
 		default:
 			$.panic("syscall: readInt with unsupported size")
 			return 0 // This line will never be reached due to panic, but satisfies TypeScript
@@ -146,10 +146,9 @@ export function readIntLE(b: $.Bytes, size: uintptr): number {
 		case 4:
 			return (byteorder.LEUint32(b) as number)
 		case 8:
-			return (byteorder.LEUint64(b) as number)
+			return Number(byteorder.LEUint64(b))
 		default:
 			$.panic("syscall: readInt with unsupported size")
 			return 0 // This line will never be reached due to panic, but satisfies TypeScript
 	}
 }
-

package/gs/os/error.gs.ts

@@ -184,6 +184,9 @@ export function underlyingErrorIs(err: $.GoError, target: $.GoError): boolean {
 	if (err == target) {
 		return true
 	}
+	if (err !== null && typeof (err as any).Is === "function") {
+		return (err as any).Is(target) === true
+	}
 	// To preserve prior behavior, only examine syscall errors.
 	let { value: e, ok: ok } = $.typeAssert<any>(err, 'syscallErrorType')
 	return ok && e.Is(target)
@@ -191,15 +194,11 @@ export function underlyingErrorIs(err: $.GoError, target: $.GoError): boolean {
 
 // underlyingError returns the underlying error for known os error types.
 export function underlyingError(err: $.GoError): $.GoError {
-	$.typeSwitch(err, [{ types: [{kind: $.TypeKind.Pointer, elemType: 'PathError'}], body: (err) => {
-		return err!.Err
-	}},
-	{ types: [{kind: $.TypeKind.Pointer, elemType: 'LinkError'}], body: (err) => {
-		return err!.Err
-	}},
-	{ types: [{kind: $.TypeKind.Pointer, elemType: 'SyscallError'}], body: (err) => {
-		return err!.Err
-	}}])
+	if (err !== null && typeof (err as any).Unwrap === "function") {
+		const unwrapped = (err as any).Unwrap()
+		if (unwrapped !== null && typeof unwrapped?.Error === "function") {
+			return unwrapped
+		}
+	}
 	return err
 }
-

package/gs/os/error.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  ErrNotExist,
+  IsExist,
+  IsNotExist,
+  IsPermission,
+  PathError,
+} from './error.gs.js'
+import { newHostError } from './types_js.gs.js'
+
+function hostError(code: string): Error {
+  return Object.assign(new Error(code), { code })
+}
+
+describe('os error classification', () => {
+  it('unwraps path errors before comparing sentinel errors', () => {
+    const err = new PathError({
+      Err: ErrNotExist,
+      Op: 'open',
+      Path: 'missing',
+    })
+
+    expect(IsNotExist(err)).toBe(true)
+    expect(IsExist(err)).toBe(false)
+  })
+
+  it('recognizes host filesystem error codes', () => {
+    expect(IsNotExist(newHostError(hostError('ENOENT')))).toBe(true)
+    expect(IsNotExist(newHostError(hostError('ENOTDIR')))).toBe(true)
+    expect(IsExist(newHostError(hostError('EEXIST')))).toBe(true)
+    expect(IsPermission(newHostError(hostError('EACCES')))).toBe(true)
+    expect(IsPermission(newHostError(hostError('EPERM')))).toBe(true)
+  })
+
+  it('does not treat unrelated host errors as filesystem sentinels', () => {
+    expect(IsNotExist(newHostError(hostError('EIO')))).toBe(false)
+    expect(IsExist(newHostError(hostError('EIO')))).toBe(false)
+    expect(IsPermission(newHostError(hostError('EIO')))).toBe(false)
+  })
+})

package/gs/os/file_unix_js.test.ts

@@ -231,4 +231,59 @@ describe('os stdio', () => {
     expect(handle.writeSync).toHaveBeenCalledTimes(2)
     expect(Array.from(handle.writeSync.mock.calls[1][0])).toEqual([22, 23])
   })
+
+  it('supports ReadAt and WriteAt on process fs descriptors', () => {
+    const readSync = vi.fn(
+      (
+        _fd: number,
+        buffer: Uint8Array,
+        offset?: number,
+        length?: number,
+        position?: number | null,
+      ) => {
+        expect(offset).toBe(0)
+        expect(length).toBe(3)
+        expect(position).toBe(5)
+        buffer.set([31, 32, 33], 0)
+        return 3
+      },
+    )
+    const writeSync = vi.fn(
+      (
+        _fd: number,
+        _buffer: Uint8Array,
+        offset?: number,
+        length?: number,
+        position?: number | null,
+      ) => {
+        expect(offset).toBe(0)
+        expect(length).toBe(2)
+        expect(position).toBe(8)
+        return length ?? 0
+      },
+    )
+
+    delete (globalThis as any).Deno
+    ;(globalThis as any).process = {
+      getBuiltinModule: vi.fn(() => ({
+        readSync,
+        writeSync,
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    const file = createHostFile('descriptor-file', 7)
+    const buf = new Uint8Array(3)
+
+    const [readN, readErr] = file.ReadAt(buf, 5)
+    expect(readN).toBe(3)
+    expect(readErr).toBeNull()
+    expect(Array.from(buf)).toEqual([31, 32, 33])
+
+    const [writeN, writeErr] = file.WriteAt(new Uint8Array([41, 42]), 8)
+    expect(writeN).toBe(2)
+    expect(writeErr).toBeNull()
+    expect(readSync).toHaveBeenCalledTimes(1)
+    expect(writeSync).toHaveBeenCalledTimes(1)
+  })
 })

package/gs/os/tempfile.gs.test.ts

@@ -1,16 +1,29 @@
 import { basename, join } from 'node:path'
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
 import { tmpdir } from 'node:os'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import { ErrUnimplemented } from './error.gs.js'
 import { CreateTemp, MkdirTemp } from './tempfile.gs.js'
+import * as errors from '../errors/errors.js'
+import { ErrNotExist } from './error.gs.js'
+import { Stat } from './stat_js.gs.js'
 
 const tempRoots: string[] = []
+const originalCrypto = globalThis.crypto
 
 afterEach(() => {
   vi.restoreAllMocks()
-  vi.unstubAllGlobals()
+  Object.defineProperty(globalThis, 'crypto', {
+    configurable: true,
+    value: originalCrypto,
+  })
   for (const root of tempRoots.splice(0)) {
     rmSync(root, { force: true, recursive: true })
   }
@@ -23,13 +36,16 @@ function makeTempRoot(): string {
 }
 
 function stubRandomBytes(bytes: number[]): void {
-  vi.stubGlobal('crypto', {
-    getRandomValues: vi.fn((dst: Uint8Array) => {
-      for (let i = 0; i < dst.length; i++) {
-        dst[i] = bytes[i] ?? 0
-      }
-      return dst
-    }),
+  Object.defineProperty(globalThis, 'crypto', {
+    configurable: true,
+    value: {
+      getRandomValues: vi.fn((dst: Uint8Array) => {
+        for (let i = 0; i < dst.length; i++) {
+          dst[i] = bytes[i] ?? 0
+        }
+        return dst
+      }),
+    },
   })
 }
 
@@ -74,7 +90,10 @@ describe('os temp files', () => {
 
   it('reports ErrUnimplemented without a secure random source', () => {
     const root = makeTempRoot()
-    vi.stubGlobal('crypto', {})
+    Object.defineProperty(globalThis, 'crypto', {
+      configurable: true,
+      value: {},
+    })
     forbidMathRandom()
 
     const [dir, err] = MkdirTemp(root, 'dir-*')
@@ -82,4 +101,12 @@ describe('os temp files', () => {
     expect(dir).toBe('')
     expect(err).toBe(ErrUnimplemented)
   })
+
+  it('maps host missing-path errors to ErrNotExist', () => {
+    const root = makeTempRoot()
+
+    const [, err] = Stat(join(root, 'missing'))
+
+    expect(errors.Is(err, ErrNotExist)).toBe(true)
+  })
 })

package/gs/os/types_js.gs.ts

@@ -29,7 +29,37 @@ export function newHostError(err: unknown): $.GoError {
 		err instanceof Error ? err.message
 		: typeof err === "string" ? err
 		: String(err)
-	return { Error: () => message }
+	const target = hostErrorTarget(err)
+	const hostErr: Exclude<$.GoError, null> = {
+		Error: () => message,
+	}
+	Object.defineProperty(hostErr, "Is", {
+		value: (candidate: $.GoError) => target !== null && candidate === target,
+	})
+	return hostErr
+}
+
+function hostErrorTarget(err: unknown): $.GoError {
+	const codeValue = typeof err === "object" && err !== null && "code" in err
+		? Reflect.get(err, "code")
+		: ""
+	const code = codeValue === undefined ? "" : String(codeValue)
+	switch (code) {
+	case "ENOENT":
+	case "ENOTDIR":
+		return fs.ErrNotExist
+	case "EEXIST":
+		return fs.ErrExist
+	case "EACCES":
+	case "EPERM":
+		return fs.ErrPermission
+	case "EBADF":
+		return ErrClosed
+	case "EINVAL":
+		return ErrInvalid
+	default:
+		return null
+	}
 }
 
 export function getNodeFS(): NodeFSModule | null {
@@ -296,23 +326,51 @@ export class File {
 	}
 
 	public ReadAt(b: $.Bytes, off: number): [number, $.GoError] {
+		if (this.closed) {
+			return [0, ErrClosed]
+		}
+		if (off < 0) {
+			return [0, ErrInvalid]
+		}
+		if (b === null) {
+			return [0, null]
+		}
+		const buf = $.bytesToUint8Array(b)
 		const handle = this.file?.handle
-		if (!handle || typeof handle.seekSync !== "function" || b === null) {
-			return [0, ErrUnimplemented]
+		if (handle && typeof handle.seekSync === "function") {
+			try {
+				handle.seekSync(off, io.SeekStart)
+				return this.Read(b)
+			} catch (err) {
+				return [0, newHostError(err)]
+			}
 		}
-		try {
-			handle.seekSync(off, io.SeekStart)
-			return this.Read(b)
-		} catch (err) {
-			return [0, newHostError(err)]
+		if (this.fd < 0) {
+			return [0, ErrInvalid]
+		}
+		const nodeFS = getNodeFS()
+		if (nodeFS?.readSync && this.fd >= 0) {
+			try {
+				const n = nodeFS.readSync(this.fd, buf, 0, buf.length, off)
+				if (!(b instanceof Uint8Array) && n > 0) {
+					$.copy(b, buf.subarray(0, n))
+				}
+				if (n === 0) {
+					return [0, io.EOF]
+				}
+				return [n, null]
+			} catch (err) {
+				return [0, newHostError(err)]
+			}
 		}
+		return [0, ErrUnimplemented]
 	}
 
 	public ReadFrom(r: io.Reader): [number, $.GoError] {
 		if (this.closed) {
 			return [0, ErrClosed]
 		}
-		return io.Copy(this, r)
+		return io.Copy(this, r) as any
 	}
 
 	public Write(b: $.Bytes): [number, $.GoError] {
@@ -333,23 +391,44 @@ export class File {
 	}
 
 	public WriteAt(b: $.Bytes, off: number): [number, $.GoError] {
+		if (this.closed) {
+			return [0, ErrClosed]
+		}
+		if (off < 0) {
+			return [0, ErrInvalid]
+		}
+		if (b === null) {
+			return [0, null]
+		}
+		const buf = $.bytesToUint8Array(b)
 		const handle = this.file?.handle
-		if (!handle || typeof handle.seekSync !== "function" || b === null) {
-			return [0, ErrUnimplemented]
+		if (handle && typeof handle.seekSync === "function") {
+			try {
+				handle.seekSync(off, io.SeekStart)
+				return this.Write(b)
+			} catch (err) {
+				return [0, newHostError(err)]
+			}
 		}
-		try {
-			handle.seekSync(off, io.SeekStart)
-			return this.Write(b)
-		} catch (err) {
-			return [0, newHostError(err)]
+		if (this.fd < 0) {
+			return [0, ErrInvalid]
 		}
+		const nodeFS = getNodeFS()
+		if (nodeFS?.writeSync && this.fd >= 0) {
+			try {
+				return [nodeFS.writeSync(this.fd, buf, 0, buf.length, off), null]
+			} catch (err) {
+				return [0, newHostError(err)]
+			}
+		}
+		return [0, ErrUnimplemented]
 	}
 
 	public WriteTo(w: io.Writer): [number, $.GoError] {
 		if (this.closed) {
 			return [0, ErrClosed]
 		}
-		return io.Copy(w, this)
+		return io.Copy(w, this) as any
 	}
 
 	public Seek(offset: number, whence: number): [number, $.GoError] {

package/gs/path/filepath/match.test.ts

@@ -1,4 +1,7 @@
 import { describe, it, expect } from 'vitest'
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import { Match, Glob, ErrBadPattern } from './match.js'
 
 describe('path/filepath - Pattern matching functions', () => {
@@ -216,20 +219,36 @@ describe('path/filepath - Pattern matching functions', () => {
   })
 
   describe('Glob', () => {
-    it('should validate patterns but return empty results (no filesystem)', () => {
-      // Valid patterns should not error
-      const [files1, err1] = Glob('*.txt')
-      expect(err1).toBeNull()
-      expect(files1).toEqual([])
+    it('should read host filesystem matches', () => {
+      const root = mkdtempSync(join(tmpdir(), 'goscript-filepath-glob-'))
+      const oldwd = process.cwd()
+      try {
+        mkdirSync(join(root, 'a', 'b', 'c.d', 'e.f'), { recursive: true })
+        process.chdir(root)
+
+        const [files1, err1] = Glob('./*/*/*.d')
+        expect(err1).toBeNull()
+        expect(files1).toEqual(['a/b/c.d'])
 
-      const [files2, err2] = Glob('dir/*')
-      expect(err2).toBeNull()
-      expect(files2).toEqual([])
+        const [files2, err2] = Glob('a/b/c.d/e.*')
+        expect(err2).toBeNull()
+        expect(files2).toEqual(['a/b/c.d/e.f'])
+      } finally {
+        process.chdir(oldwd)
+        rmSync(root, { force: true, recursive: true })
+      }
+    })
 
-      // Invalid patterns should error
-      const [files3, err3] = Glob('[unclosed')
-      expect(err3).toBe(ErrBadPattern)
-      expect(files3).toEqual([])
+    it('should validate bad patterns', () => {
+      const [files1, err1] = Glob('[unclosed')
+      expect(err1).toBe(ErrBadPattern)
+      expect(files1).toEqual([])
+    })
+
+    it('should return empty results for unmatched valid patterns', () => {
+      const [files1, err1] = Glob('missing-*.txt')
+      expect(err1).toBeNull()
+      expect(files1).toEqual([])
     })
   })
 

package/gs/path/filepath/match.ts

@@ -1,4 +1,5 @@
 import * as $ from '@goscript/builtin/index.js'
+import { getHostRuntime, type NodeFSModule } from '@goscript/builtin/hostio.js'
 
 export const ErrBadPattern = $.newError('syntax error in pattern')
 
@@ -238,12 +239,189 @@ function matchCharClass(
 // The only possible returned error is ErrBadPattern, when pattern is malformed.
 export function Glob(pattern: string): [string[], $.GoError] {
   try {
-    // Validate the pattern using the same logic as Match
     validatePattern(pattern)
-    // We don't have filesystem access, so return empty array
-    return [[], null]
+    return [globHost(pattern), null]
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
   } catch (err) {
     return [[], ErrBadPattern]
   }
 }
+
+function hasMeta(path: string): boolean {
+  return /[*?[\\]/.test(path)
+}
+
+function splitPattern(pattern: string): {
+  absolute: boolean
+  segments: string[]
+} {
+  const absolute = pattern.startsWith('/')
+  const segments = pattern.split('/').filter((segment, index) => {
+    if (index === 0 && segment === '') {
+      return false
+    }
+    return segment !== '' && segment !== '.'
+  })
+  return { absolute, segments }
+}
+
+function cleanMatch(path: string): string {
+  const absolute = path.startsWith('/')
+  const parts: string[] = []
+  for (const part of path.split('/')) {
+    if (part === '' || part === '.') {
+      continue
+    }
+    if (part === '..') {
+      if (parts.length > 0 && parts[parts.length - 1] !== '..') {
+        parts.pop()
+      } else if (!absolute) {
+        parts.push(part)
+      }
+      continue
+    }
+    parts.push(part)
+  }
+  const out = parts.join('/')
+  if (absolute) {
+    return '/' + out
+  }
+  return out === '' ? '.' : out
+}
+
+function joinPath(dir: string, name: string): string {
+  if (dir === '' || dir === '.') {
+    return name
+  }
+  if (dir === '/') {
+    return '/' + name
+  }
+  return dir.replace(/\/+$/, '') + '/' + name
+}
+
+type HostDirEntry = { name: string; isDir: boolean }
+
+function readDir(path: string): HostDirEntry[] | null {
+  const runtime = getHostRuntime()
+  const denoObj = runtime.deno
+  if (denoObj?.readDirSync) {
+    try {
+      const entries: HostDirEntry[] = []
+      for (const entry of denoObj.readDirSync(path)) {
+        entries.push({ name: entry.name, isDir: !!entry.isDirectory })
+      }
+      entries.sort((a, b) => a.name.localeCompare(b.name))
+      return entries
+    } catch {
+      return null
+    }
+  }
+
+  const nodeFS = runtime.nodeFS
+  if (nodeFS?.readdirSync) {
+    try {
+      const entries = nodeFS
+        .readdirSync(path, { withFileTypes: true })
+        .map((entry: any) => ({
+          name: String(entry.name),
+          isDir:
+            typeof entry.isDirectory === 'function' ?
+              entry.isDirectory()
+            : false,
+        }))
+      entries.sort((a, b) => a.name.localeCompare(b.name))
+      return entries
+    } catch {
+      return null
+    }
+  }
+
+  return null
+}
+
+function exists(path: string): boolean {
+  const runtime = getHostRuntime()
+  if (runtime.deno?.statSync) {
+    try {
+      runtime.deno.statSync(path)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  const nodeFS = runtime.nodeFS
+  if (nodeFS?.statSync) {
+    try {
+      nodeFS.statSync(path)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  return false
+}
+
+function isDir(path: string, nodeFS?: NodeFSModule | null): boolean {
+  const runtime = getHostRuntime()
+  if (runtime.deno?.statSync) {
+    try {
+      return !!runtime.deno.statSync(path).isDirectory
+    } catch {
+      return false
+    }
+  }
+
+  const fs = nodeFS ?? runtime.nodeFS
+  if (fs?.statSync) {
+    try {
+      const stat = fs.statSync(path)
+      return typeof stat.isDirectory === 'function' ? stat.isDirectory() : false
+    } catch {
+      return false
+    }
+  }
+
+  return false
+}
+
+function globHost(pattern: string): string[] {
+  const { absolute, segments } = splitPattern(pattern)
+  if (!hasMeta(pattern)) {
+    return exists(pattern) ? [cleanMatch(pattern)] : []
+  }
+
+  let prefixes = [absolute ? '/' : '.']
+  for (const [index, segment] of segments.entries()) {
+    const next: string[] = []
+    const last = index === segments.length - 1
+    const segmentHasMeta = hasMeta(segment)
+    for (const prefix of prefixes) {
+      if (!segmentHasMeta) {
+        const candidate = joinPath(prefix, segment)
+        if (last || isDir(candidate)) {
+          next.push(candidate)
+        }
+        continue
+      }
+
+      const entries = readDir(prefix)
+      if (entries === null) {
+        continue
+      }
+      for (const entry of entries) {
+        const [matched, err] = Match(segment, entry.name)
+        if (err !== null || !matched) {
+          continue
+        }
+        if (last || entry.isDir) {
+          next.push(joinPath(prefix, entry.name))
+        }
+      }
+    }
+    prefixes = next
+  }
+
+  return prefixes.map(cleanMatch).sort()
+}

package/gs/path/filepath/meta.json

@@ -0,0 +1,6 @@
+{
+  "asyncFunctions": {
+    "Walk": true,
+    "WalkDir": true
+  }
+}