goscript 0.0.84 → 0.1.1

package/gs/math/const.gs.ts

@@ -47,10 +47,10 @@ export let SmallestNonzeroFloat64: number = Number.MIN_VALUE
 let intSize: number = (32 << ((~(0 as number) >> 63)))
 
 // MaxInt32 or MaxInt64 depending on intSize.
-export let MaxInt: bigint = 9223372036854775807n
+export let MaxInt: number = 9223372036854775807
 
 // MinInt32 or MinInt64 depending on intSize.
-export let MinInt: bigint = -9223372036854775808n
+export let MinInt: number = -9223372036854775808
 
 // 127
 export let MaxInt8: number = 127
@@ -71,10 +71,10 @@ export let MaxInt32: number = 2147483647
 export let MinInt32: number = -2147483648
 
 // 9223372036854775807
-export let MaxInt64: bigint = 9223372036854775807n
+export let MaxInt64: number = 9223372036854775807
 
 // -9223372036854775808
-export let MinInt64: bigint = -9223372036854775808n
+export let MinInt64: number = -9223372036854775808
 
 // MaxUint32 or MaxUint64 depending on intSize.
 export let MaxUint: bigint = 0xFFFFFFFFFFFFFFFFn
@@ -89,5 +89,4 @@ export let MaxUint16: number = 65535
 export let MaxUint32: number = 4294967295
 
 // 18446744073709551615
-export let MaxUint64: bigint = 0xFFFFFFFFFFFFFFFFn
-
+export let MaxUint64: number | bigint = 0xFFFFFFFFFFFFFFFFn

package/gs/mime/index.ts

@@ -0,0 +1,54 @@
+export function FormatMediaType(t: string, param: Map<string, string> | Record<string, string> | null): string {
+  if (!isToken(t)) {
+    return ''
+  }
+  let out = t
+  const entries = param instanceof Map ? Array.from(param.entries()) : Object.entries(param ?? {})
+  entries.sort(([a], [b]) => a.localeCompare(b))
+  for (const [key, value] of entries) {
+    if (!isToken(key)) {
+      return ''
+    }
+    out += formatParam(key, String(value))
+  }
+  return out
+}
+
+function formatParam(key: string, value: string): string {
+  if (isToken(value)) {
+    return `; ${key}=${value}`
+  }
+  return `; ${key}*=utf-8''${percentEncode(value)}`
+}
+
+function isToken(value: string): boolean {
+  return /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(value)
+}
+
+function percentEncode(value: string): string {
+  let out = ''
+  for (const byte of new TextEncoder().encode(value)) {
+    if (
+      (byte >= 0x30 && byte <= 0x39) ||
+      (byte >= 0x41 && byte <= 0x5a) ||
+      (byte >= 0x61 && byte <= 0x7a) ||
+      byte === 0x21 ||
+      byte === 0x23 ||
+      byte === 0x24 ||
+      byte === 0x26 ||
+      byte === 0x2b ||
+      byte === 0x2d ||
+      byte === 0x2e ||
+      byte === 0x5e ||
+      byte === 0x5f ||
+      byte === 0x60 ||
+      byte === 0x7c ||
+      byte === 0x7e
+    ) {
+      out += String.fromCharCode(byte)
+      continue
+    }
+    out += `%${byte.toString(16).toUpperCase().padStart(2, '0')}`
+  }
+  return out
+}

package/gs/net/http/httptest/index.ts

@@ -0,0 +1,25 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as http from '@goscript/net/http/index.js'
+
+export class ResponseRecorder implements http.ResponseWriter {
+  public Code = 200
+  public Body: $.Slice<number> = null
+  private headerMap = new http.Header()
+
+  public Header(): http.Header {
+    return this.headerMap
+  }
+
+  public Write(p: $.Slice<number>): [number, $.GoError] {
+    this.Body = $.append(this.Body, p)
+    return [$.len(p), null]
+  }
+
+  public WriteHeader(statusCode: number): void {
+    this.Code = statusCode
+  }
+}
+
+export function NewRecorder(): ResponseRecorder {
+  return new ResponseRecorder()
+}

package/gs/net/http/index.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+
+import { Get, Response, StatusOK, StatusText } from './index.js'
+
+describe('net/http override', () => {
+  it('exports response status helpers', () => {
+    const resp = new Response({ StatusCode: StatusOK })
+
+    expect(resp.StatusCode).toBe(200)
+    expect(StatusText(resp.StatusCode)).toBe('OK')
+    expect(StatusText(599)).toBe('')
+  })
+
+  it('returns an explicit unsupported error for Get', () => {
+    const [resp, err] = Get('https://example.invalid')
+
+    expect(resp).toBeNull()
+    expect(err?.Error()).toBe('net/http: Get is not implemented in GoScript')
+  })
+})

package/gs/net/http/index.ts

@@ -0,0 +1,81 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import * as io from '@goscript/io/index.js'
+
+export const StatusOK = 200
+
+export function StatusText(code: number): string {
+  switch (code) {
+    case StatusOK:
+      return 'OK'
+    default:
+      return ''
+  }
+}
+
+export class Header extends Map<string, $.Slice<string>> {
+  public Add(key: string, value: string): void {
+    const values = Array.from(this.get(key) ?? [])
+    values.push(value)
+    this.set(key, $.arrayToSlice(values))
+  }
+
+  public Del(key: string): void {
+    this.delete(key)
+  }
+
+  public Get(key: string): string {
+    const values = this.get(key)
+    return values == null || values.length === 0 ? '' : String(values[0])
+  }
+
+  public Set(key: string, value: string): void {
+    this.set(key, $.arrayToSlice([value]))
+  }
+}
+
+export function Header_Add(h: Header, key: string, value: string): void {
+  h.Add(key, value)
+}
+
+export function Header_Del(h: Header, key: string): void {
+  h.Del(key)
+}
+
+export function Header_Get(h: Header, key: string): string {
+  return h.Get(key)
+}
+
+export function Header_Set(h: Header, key: string, value: string): void {
+  h.Set(key, value)
+}
+
+export interface ResponseWriter {
+  Header(): Header
+  Write(p: $.Slice<number>): [number, $.GoError]
+  WriteHeader(statusCode: number): void
+}
+
+export class Response {
+  public StatusCode: number
+  public Body: io.ReadCloser | null
+  public Header: Header
+
+  constructor(init?: Partial<Response>) {
+    this.StatusCode = init?.StatusCode ?? 0
+    this.Body = init?.Body ?? null
+    this.Header = init?.Header ?? new Header()
+  }
+
+  public clone(): Response {
+    return new Response({
+      Body: this.Body,
+      Header: this.Header,
+      StatusCode: this.StatusCode,
+    })
+  }
+}
+
+export function Get(_url: string): [Response | null, $.GoError] {
+  return [null, errors.New('net/http: Get is not implemented in GoScript')]
+}

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

@@ -115,6 +115,56 @@ describe('os stdio', () => {
     expect(writeSync).toHaveBeenCalledTimes(1)
   })
 
+  it('falls back to process builtin fs when Deno lacks sync stdio', () => {
+    const readSync = vi.fn(
+      (
+        _fd: number,
+        buffer: Uint8Array,
+        _offset?: number,
+        _length?: number,
+        _position?: number | null,
+      ) => {
+        buffer.set([5, 6], 0)
+        return 2
+      },
+    )
+    const writeSync = vi.fn(
+      (
+        _fd: number,
+        _buffer: Uint8Array,
+        _offset?: number,
+        length?: number,
+        _position?: number | null,
+      ) => length ?? 0,
+    )
+
+    ;(globalThis as any).Deno = {
+      stdin: {},
+      stdout: {},
+    }
+    ;(globalThis as any).process = {
+      getBuiltinModule: vi.fn(() => ({
+        readSync,
+        writeSync,
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    const input = NewFile(0, 'stdin')
+    const output = NewFile(1, 'stdout')
+    const readBuf = new Uint8Array(2)
+
+    const [readN, readErr] = input!.Read(readBuf)
+    expect(readN).toBe(2)
+    expect(readErr).toBeNull()
+    expect(Array.from(readBuf)).toEqual([5, 6])
+
+    const [writeN, writeErr] = output!.Write(new Uint8Array([7, 8, 9]))
+    expect(writeN).toBe(3)
+    expect(writeErr).toBeNull()
+    expect(writeSync).toHaveBeenCalledTimes(1)
+  })
+
   it('returns EOF on zero-byte reads and ErrClosed after Close', () => {
     const stdinReadSync = vi.fn(() => 0)
 

package/gs/os/meta.json

@@ -3,7 +3,6 @@
     "errors",
     "internal/byteorder",
     "internal/goarch",
-    "internal/poll",
     "io",
     "io/fs",
     "runtime",
@@ -12,4 +11,4 @@
     "time",
     "unsafe"
   ]
-} 
+}

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

@@ -0,0 +1,85 @@
+import { basename, join } from 'node:path'
+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'
+
+const tempRoots: string[] = []
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  vi.unstubAllGlobals()
+  for (const root of tempRoots.splice(0)) {
+    rmSync(root, { force: true, recursive: true })
+  }
+})
+
+function makeTempRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), 'goscript-os-temp-'))
+  tempRoots.push(root)
+  return root
+}
+
+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
+    }),
+  })
+}
+
+function forbidMathRandom(): void {
+  vi.spyOn(Math, 'random').mockImplementation(() => {
+    throw new Error('os temp names must not use Math.random')
+  })
+}
+
+describe('os temp files', () => {
+  it('uses Web Crypto bytes for temp names', () => {
+    const root = makeTempRoot()
+    stubRandomBytes([0x78, 0x56, 0x34, 0x12])
+    forbidMathRandom()
+
+    const [dir, dirErr] = MkdirTemp(root, 'dir-*.tmp')
+    expect(dirErr).toBeNull()
+    expect(basename(dir)).toBe('dir-305419896.tmp')
+    expect(existsSync(dir)).toBe(true)
+
+    const [file, fileErr] = CreateTemp(root, 'file-*.tmp')
+    expect(fileErr).toBeNull()
+    expect(file).not.toBeNull()
+    expect(basename(file!.Name())).toBe('file-305419896.tmp')
+    expect(existsSync(file!.Name())).toBe(true)
+    file!.Close()
+  })
+
+  it('does not truncate an existing path after a random collision', () => {
+    const root = makeTempRoot()
+    const existing = join(root, 'file-305419896.tmp')
+    writeFileSync(existing, 'keep')
+    stubRandomBytes([0x78, 0x56, 0x34, 0x12])
+    forbidMathRandom()
+
+    const [file, err] = CreateTemp(root, 'file-*.tmp')
+
+    expect(file).toBeNull()
+    expect(err).not.toBeNull()
+    expect(readFileSync(existing, 'utf8')).toBe('keep')
+  })
+
+  it('reports ErrUnimplemented without a secure random source', () => {
+    const root = makeTempRoot()
+    vi.stubGlobal('crypto', {})
+    forbidMathRandom()
+
+    const [dir, err] = MkdirTemp(root, 'dir-*')
+
+    expect(dir).toBe('')
+    expect(err).toBe(ErrUnimplemented)
+  })
+})

package/gs/os/tempfile.gs.ts

@@ -1,8 +1,8 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
 import { TempDir } from "./file_constants_js.gs.js";
-import { Create, Mkdir } from "./file_js.gs.js";
-import { File } from "./types_js.gs.js";
+import { Mkdir } from "./file_js.gs.js";
+import { createHostFile, File, getDeno, getNodeFS, newHostError } from "./types_js.gs.js";
 
 export function joinPath(dir: string, file: string): string {
   if (dir === "" || dir === ".") {
@@ -20,33 +20,93 @@ export function joinPath(dir: string, file: string): string {
   return dir + "/" + file
 }
 
-function nextTempPath(dir: string, pattern: string): string {
+function nextTempPath(dir: string, pattern: string): [string, $.GoError] {
   const baseDir = dir === "" ? TempDir() : dir
-  const suffix = Math.random().toString(36).slice(2, 10) + Date.now().toString(36)
-  const name = pattern.includes("*") ? pattern.replace("*", suffix) : pattern + suffix
-  return joinPath(baseDir, name)
+  const [suffix, err] = nextRandom()
+  if (err !== null) {
+    return ["", err]
+  }
+  const star = pattern.lastIndexOf("*")
+  const name =
+    star >= 0
+      ? pattern.slice(0, star) + suffix + pattern.slice(star + 1)
+      : pattern + suffix
+  return [joinPath(baseDir, name), null]
+}
+
+function nextRandom(): [string, $.GoError] {
+  const crypto = globalThis.crypto
+  if (!crypto || typeof crypto.getRandomValues !== "function") {
+    return ["", ErrUnimplemented]
+  }
+  const bytes = new Uint8Array(4)
+  crypto.getRandomValues(bytes)
+  const value =
+    bytes[0] |
+    (bytes[1] << 8) |
+    (bytes[2] << 16) |
+    (bytes[3] << 24)
+  return [(value >>> 0).toString(10), null]
+}
+
+function createTempFile(path: string): [File | null, $.GoError] {
+  const denoObj = getDeno()
+  if (denoObj?.openSync) {
+    try {
+      const handle = denoObj.openSync(path, {
+        createNew: true,
+        mode: 0o600,
+        read: true,
+        write: true,
+      })
+      return [createHostFile(path, handle?.rid ?? -1, handle), null]
+    } catch (err) {
+      return [null, newHostError(err)]
+    }
+  }
+
+  const nodeFS = getNodeFS()
+  if (nodeFS?.openSync) {
+    try {
+      return [createHostFile(path, nodeFS.openSync(path, "wx+", 0o600)), null]
+    } catch (err) {
+      return [null, newHostError(err)]
+    }
+  }
+
+  return [null, ErrUnimplemented]
 }
 
 export function CreateTemp(dir: string, pattern: string): [File | null, $.GoError] {
   const template = pattern === "" ? "tmp-*" : pattern
+  let lastErr: $.GoError = ErrUnimplemented
   for (let i = 0; i < 16; i++) {
-    const path = nextTempPath(dir, template)
-    const [file, err] = Create(path)
+    const [path, randErr] = nextTempPath(dir, template)
+    if (randErr !== null) {
+      return [null, randErr]
+    }
+    const [file, err] = createTempFile(path)
     if (err === null) {
       return [file, null]
     }
+    lastErr = err
   }
-  return [null, ErrUnimplemented]
+  return [null, lastErr]
 }
 
 export function MkdirTemp(dir: string, pattern: string): [string, $.GoError] {
   const template = pattern === "" ? "tmp-*" : pattern
+  let lastErr: $.GoError = ErrUnimplemented
   for (let i = 0; i < 16; i++) {
-    const path = nextTempPath(dir, template)
+    const [path, randErr] = nextTempPath(dir, template)
+    if (randErr !== null) {
+      return ["", randErr]
+    }
     const err = Mkdir(path, 0o700)
     if (err === null) {
       return [path, null]
     }
+    lastErr = err
   }
-  return ["", ErrUnimplemented]
+  return ["", lastErr]
 }

package/gs/os/types_js.gs.ts

@@ -8,8 +8,8 @@ import * as syscall from "@goscript/syscall/index.js"
 import {
 	DenoFileLike,
 	DenoStream,
+	getHostRuntime,
 	HostUnsupportedError,
-	hostRuntime,
 	NodeFSModule,
 	resetHostRuntimeForTests,
 } from "@goscript/builtin/hostio.js"
@@ -33,23 +33,23 @@ export function newHostError(err: unknown): $.GoError {
 }
 
 export function getNodeFS(): NodeFSModule | null {
-	return hostRuntime.nodeFS
+	return getHostRuntime().nodeFS
 }
 
 export function getDeno(): any | null {
-	return hostRuntime.deno
+	return getHostRuntime().deno
 }
 
 export function getPlatform(): string {
-	return hostRuntime.platform
+	return getHostRuntime().platform
 }
 
 export function getEnv(name: string): string {
-	return hostRuntime.getEnv(name)
+	return getHostRuntime().getEnv(name)
 }
 
 export function getDenoStream(fd: number): DenoStream | null {
-	return hostRuntime.getStdioHandle(fd)
+	return getHostRuntime().getStdioHandle(fd)
 }
 
 function readFD(fd: number, b: Uint8Array): [number, $.GoError] {
@@ -58,7 +58,7 @@ function readFD(fd: number, b: Uint8Array): [number, $.GoError] {
 	}
 
 	try {
-		const n = hostRuntime.readFD(fd, b)
+		const n = getHostRuntime().readFD(fd, b)
 		if (n === null || n === 0) {
 			return [0, io.EOF]
 		}
@@ -77,7 +77,7 @@ function writeFD(fd: number, b: Uint8Array): [number, $.GoError] {
 	}
 
 	try {
-		return [hostRuntime.writeFD(fd, b), null]
+		return [getHostRuntime().writeFD(fd, b), null]
 	} catch (err) {
 		if (err instanceof HostUnsupportedError) {
 			return [0, ErrUnimplemented]
@@ -192,7 +192,7 @@ export function createFileInfo(name: string, stat: HostStatLike): fs.FileInfo {
 export function createHostFile(name: string, fd: number = -1, handle: DenoFileLike | null = null): File {
 	return new File({
 		fd,
-		file: new file({ handle: handle ?? hostRuntime.getStdioHandle(fd), path: name }),
+		file: new file({ handle: handle ?? getHostRuntime().getStdioHandle(fd), path: name }),
 		name,
 	})
 }
@@ -312,7 +312,7 @@ export class File {
 		if (this.closed) {
 			return [0, ErrClosed]
 		}
-		return io.Copy(this, r)
+		return io.Copy(this, r) as any
 	}
 
 	public Write(b: $.Bytes): [number, $.GoError] {
@@ -349,7 +349,7 @@ export class File {
 		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([])
     })
   })