goscript 0.1.3 → 0.2.0

package/gs/net/http/meta.json

@@ -1,6 +1,21 @@
 {
+  "asyncFunctions": {
+    "Get": true,
+    "Head": true,
+    "Post": true,
+    "PostForm": true,
+    "ServeContent": true
+  },
   "asyncMethods": {
     "Client.Do": true,
-    "RoundTripper.RoundTrip": true
+    "Client.Get": true,
+    "Client.Head": true,
+    "Client.Post": true,
+    "Client.PostForm": true,
+    "Handler.ServeHTTP": true,
+    "HandlerFunc.ServeHTTP": true,
+    "ServeMux.ServeHTTP": true,
+    "RoundTripper.RoundTrip": true,
+    "Transport.RoundTrip": true
   }
 }

package/gs/net/http/parity.json

@@ -0,0 +1,193 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "AllowQuerySemicolons": { "status": "real" },
+    "CanonicalHeaderKey": { "status": "real" },
+    "Client": { "status": "real" },
+    "ClientConn": { "status": "real" },
+    "CloseNotifier": { "status": "real" },
+    "ConnState": { "status": "real" },
+    "Cookie": { "status": "real" },
+    "CookieJar": { "status": "real" },
+    "CrossOriginProtection": { "status": "real" },
+    "DefaultClient": { "status": "real" },
+    "DefaultMaxHeaderBytes": { "status": "real" },
+    "DefaultMaxIdleConnsPerHost": { "status": "real" },
+    "DefaultServeMux": { "status": "real" },
+    "DefaultTransport": { "status": "real" },
+    "DetectContentType": { "status": "real" },
+    "Dir": { "status": "real" },
+    "ErrAbortHandler": { "status": "real" },
+    "ErrBodyNotAllowed": { "status": "real" },
+    "ErrBodyReadAfterClose": { "status": "real" },
+    "ErrContentLength": { "status": "real" },
+    "ErrHandlerTimeout": { "status": "real" },
+    "ErrHeaderTooLong": { "status": "real" },
+    "ErrHijacked": { "status": "real" },
+    "ErrLineTooLong": { "status": "real" },
+    "ErrMissingBoundary": { "status": "real" },
+    "ErrMissingContentLength": { "status": "real" },
+    "ErrMissingFile": { "status": "real" },
+    "ErrNoCookie": { "status": "real" },
+    "ErrNoLocation": { "status": "real" },
+    "ErrNotMultipart": { "status": "real" },
+    "ErrNotSupported": { "status": "real" },
+    "ErrSchemeMismatch": { "status": "real" },
+    "ErrServerClosed": { "status": "real" },
+    "ErrShortBody": { "status": "real" },
+    "ErrSkipAltProtocol": { "status": "real" },
+    "ErrUnexpectedTrailer": { "status": "real" },
+    "ErrUseLastResponse": { "status": "real" },
+    "ErrWriteAfterFlush": { "status": "real" },
+    "Error": { "status": "real" },
+    "FS": { "status": "real" },
+    "File": { "status": "real" },
+    "FileServer": { "status": "real" },
+    "FileServerFS": { "status": "real" },
+    "FileSystem": { "status": "real" },
+    "Flusher": { "status": "real" },
+    "Get": { "status": "real" },
+    "HTTP2Config": { "status": "real" },
+    "Handle": { "status": "real" },
+    "HandleFunc": { "status": "real" },
+    "Handler": { "status": "real" },
+    "HandlerFunc": { "status": "real" },
+    "Head": { "status": "real" },
+    "Header": { "status": "real" },
+    "Hijacker": { "status": "real" },
+    "ListenAndServe": { "status": "real" },
+    "ListenAndServeTLS": { "status": "real" },
+    "LocalAddrContextKey": { "status": "real" },
+    "MaxBytesError": { "status": "real" },
+    "MaxBytesHandler": { "status": "real" },
+    "MaxBytesReader": { "status": "real" },
+    "MethodConnect": { "status": "real" },
+    "MethodDelete": { "status": "real" },
+    "MethodGet": { "status": "real" },
+    "MethodHead": { "status": "real" },
+    "MethodOptions": { "status": "real" },
+    "MethodPatch": { "status": "real" },
+    "MethodPost": { "status": "real" },
+    "MethodPut": { "status": "real" },
+    "MethodTrace": { "status": "real" },
+    "NewCrossOriginProtection": { "status": "real" },
+    "NewFileTransport": { "status": "real" },
+    "NewFileTransportFS": { "status": "real" },
+    "NewRequest": { "status": "real" },
+    "NewRequestWithContext": { "status": "real" },
+    "NewResponseController": { "status": "real" },
+    "NewServeMux": { "status": "real" },
+    "NoBody": { "status": "real" },
+    "NotFound": { "status": "real" },
+    "NotFoundHandler": { "status": "real" },
+    "ParseCookie": { "status": "real" },
+    "ParseHTTPVersion": { "status": "real" },
+    "ParseSetCookie": { "status": "real" },
+    "ParseTime": { "status": "real" },
+    "Post": { "status": "real" },
+    "PostForm": { "status": "real" },
+    "ProtocolError": { "status": "real" },
+    "Protocols": { "status": "real" },
+    "ProxyFromEnvironment": { "status": "real" },
+    "ProxyURL": { "status": "real" },
+    "PushOptions": { "status": "real" },
+    "Pusher": { "status": "real" },
+    "ReadRequest": { "status": "real" },
+    "ReadResponse": { "status": "real" },
+    "Redirect": { "status": "real" },
+    "RedirectHandler": { "status": "real" },
+    "Request": { "status": "real" },
+    "Response": { "status": "real" },
+    "ResponseController": { "status": "real" },
+    "ResponseWriter": { "status": "real" },
+    "RoundTripper": { "status": "real" },
+    "SameSite": { "status": "real" },
+    "SameSiteDefaultMode": { "status": "real" },
+    "SameSiteLaxMode": { "status": "real" },
+    "SameSiteNoneMode": { "status": "real" },
+    "SameSiteStrictMode": { "status": "real" },
+    "Serve": { "status": "real" },
+    "ServeContent": { "status": "real" },
+    "ServeFile": { "status": "real" },
+    "ServeFileFS": { "status": "real" },
+    "ServeMux": { "status": "real" },
+    "ServeTLS": { "status": "real" },
+    "Server": { "status": "real" },
+    "ServerContextKey": { "status": "real" },
+    "SetCookie": { "status": "real" },
+    "StateActive": { "status": "real" },
+    "StateClosed": { "status": "real" },
+    "StateHijacked": { "status": "real" },
+    "StateIdle": { "status": "real" },
+    "StateNew": { "status": "real" },
+    "StatusAccepted": { "status": "real" },
+    "StatusAlreadyReported": { "status": "real" },
+    "StatusBadGateway": { "status": "real" },
+    "StatusBadRequest": { "status": "real" },
+    "StatusConflict": { "status": "real" },
+    "StatusContinue": { "status": "real" },
+    "StatusCreated": { "status": "real" },
+    "StatusEarlyHints": { "status": "real" },
+    "StatusExpectationFailed": { "status": "real" },
+    "StatusFailedDependency": { "status": "real" },
+    "StatusForbidden": { "status": "real" },
+    "StatusFound": { "status": "real" },
+    "StatusGatewayTimeout": { "status": "real" },
+    "StatusGone": { "status": "real" },
+    "StatusHTTPVersionNotSupported": { "status": "real" },
+    "StatusIMUsed": { "status": "real" },
+    "StatusInsufficientStorage": { "status": "real" },
+    "StatusInternalServerError": { "status": "real" },
+    "StatusLengthRequired": { "status": "real" },
+    "StatusLocked": { "status": "real" },
+    "StatusLoopDetected": { "status": "real" },
+    "StatusMethodNotAllowed": { "status": "real" },
+    "StatusMisdirectedRequest": { "status": "real" },
+    "StatusMovedPermanently": { "status": "real" },
+    "StatusMultiStatus": { "status": "real" },
+    "StatusMultipleChoices": { "status": "real" },
+    "StatusNetworkAuthenticationRequired": { "status": "real" },
+    "StatusNoContent": { "status": "real" },
+    "StatusNonAuthoritativeInfo": { "status": "real" },
+    "StatusNotAcceptable": { "status": "real" },
+    "StatusNotExtended": { "status": "real" },
+    "StatusNotFound": { "status": "real" },
+    "StatusNotImplemented": { "status": "real" },
+    "StatusNotModified": { "status": "real" },
+    "StatusOK": { "status": "real" },
+    "StatusPartialContent": { "status": "real" },
+    "StatusPaymentRequired": { "status": "real" },
+    "StatusPermanentRedirect": { "status": "real" },
+    "StatusPreconditionFailed": { "status": "real" },
+    "StatusPreconditionRequired": { "status": "real" },
+    "StatusProcessing": { "status": "real" },
+    "StatusProxyAuthRequired": { "status": "real" },
+    "StatusRequestEntityTooLarge": { "status": "real" },
+    "StatusRequestHeaderFieldsTooLarge": { "status": "real" },
+    "StatusRequestTimeout": { "status": "real" },
+    "StatusRequestURITooLong": { "status": "real" },
+    "StatusRequestedRangeNotSatisfiable": { "status": "real" },
+    "StatusResetContent": { "status": "real" },
+    "StatusSeeOther": { "status": "real" },
+    "StatusServiceUnavailable": { "status": "real" },
+    "StatusSwitchingProtocols": { "status": "real" },
+    "StatusTeapot": { "status": "real" },
+    "StatusTemporaryRedirect": { "status": "real" },
+    "StatusText": { "status": "real" },
+    "StatusTooEarly": { "status": "real" },
+    "StatusTooManyRequests": { "status": "real" },
+    "StatusUnauthorized": { "status": "real" },
+    "StatusUnavailableForLegalReasons": { "status": "real" },
+    "StatusUnprocessableEntity": { "status": "real" },
+    "StatusUnsupportedMediaType": { "status": "real" },
+    "StatusUpgradeRequired": { "status": "real" },
+    "StatusUseProxy": { "status": "real" },
+    "StatusVariantAlsoNegotiates": { "status": "real" },
+    "StripPrefix": { "status": "real" },
+    "TimeFormat": { "status": "real" },
+    "TimeoutHandler": { "status": "real" },
+    "TrailerPrefix": { "status": "real" },
+    "Transport": { "status": "real" }
+  }
+}

package/gs/os/dir_unix.gs.ts

@@ -93,7 +93,7 @@ class dirInfo {
 	  new dirInfo(),
 	  [{ name: "close", args: [], returns: [] }],
 	  dirInfo,
-	  {"mu": "Mutex", "buf": { kind: $.TypeKind.Pointer, elemType: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, "nbuf": { kind: $.TypeKind.Basic, name: "number" }, "bufp": { kind: $.TypeKind.Basic, name: "number" }}
+	  [{ name: "mu", key: "mu", type: "Mutex" }, { name: "buf", key: "buf", type: { kind: $.TypeKind.Pointer, elemType: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } } }, { name: "nbuf", key: "nbuf", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "bufp", key: "bufp", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }
 

package/gs/os/error.gs.ts

@@ -119,7 +119,7 @@ export class SyscallError {
 	  new SyscallError(),
 	  [{ name: "Error", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "Unwrap", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Timeout", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }],
 	  SyscallError,
-	  {"Syscall": { kind: $.TypeKind.Basic, name: "string" }, "Err": { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] }}
+	  [{ name: "Syscall", key: "Syscall", type: { kind: $.TypeKind.Basic, name: "string" } }, { name: "Err", key: "Err", type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }]
 	);
 }
 

package/gs/os/exec.gs.ts

@@ -5,6 +5,7 @@ import * as errors from "@goscript/errors/index.js"
 import * as syscall from "@goscript/syscall/index.js"
 
 export let ErrProcessDone: $.GoError = errors.New("os: process already finished")
+export let ErrNoHandle: $.GoError = errors.New("os: process handle unavailable")
 
 // Simplified Process class for JavaScript environment
 export class Process {
@@ -61,7 +62,7 @@ export class Process {
 			{ name: "Signal", args: [{ name: "sig", type: "Signal" }], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }
 		],
 		Process,
-		{ "Pid": { kind: $.TypeKind.Basic, name: "number" } }
+		[{ name: "Pid", key: "Pid", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }
 
@@ -128,12 +129,7 @@ export class ProcAttr {
 		new ProcAttr(),
 		[],
 		ProcAttr,
-		{ 
-			"Dir": { kind: $.TypeKind.Basic, name: "string" },
-			"Env": { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "string" } },
-			"Files": { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "any" } },
-			"Sys": { kind: $.TypeKind.Basic, name: "any" }
-		}
+		[{ name: "Dir", key: "Dir", type: { kind: $.TypeKind.Basic, name: "string" } }, { name: "Env", key: "Env", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "string" } } }, { name: "Files", key: "Files", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "any" } } }, { name: "Sys", key: "Sys", type: { kind: $.TypeKind.Basic, name: "any" } }]
 	);
 }
 
@@ -155,7 +151,7 @@ export class ProcessState {
 		new ProcessState(),
 		[],
 		ProcessState,
-		{}
+		[]
 	);
 }
 

package/gs/os/exec_posix.gs.ts

@@ -89,6 +89,6 @@ export class ProcessState {
 			{ name: "ExitCode", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }
 		],
 		ProcessState,
-		{ "pid": { kind: $.TypeKind.Basic, name: "number" } }
+		[{ name: "pid", key: "pid", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }

package/gs/os/file_unix_js.test.ts

@@ -286,4 +286,56 @@ describe('os stdio', () => {
     expect(readSync).toHaveBeenCalledTimes(1)
     expect(writeSync).toHaveBeenCalledTimes(1)
   })
+
+  it('copies from File without recursing through io.Copy', async () => {
+    const readSync = vi
+      .fn<(buffer: Uint8Array) => number>()
+      .mockImplementationOnce((buffer) => {
+        buffer.set([65, 66, 67], 0)
+        return 3
+      })
+      .mockImplementationOnce(() => 0)
+
+    const file = createHostFile('descriptor-file', 7, { readSync })
+    const chunks: number[] = []
+    const writer = {
+      Write(p: Uint8Array): [number, null] {
+        chunks.push(...Array.from(p))
+        return [p.length, null]
+      },
+    }
+
+    const [n, err] = await io.Copy(writer, file)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(chunks).toString('utf8')).toBe('ABC')
+  })
+
+  it('copies into File without recursing through io.Copy', async () => {
+    const writes: number[] = []
+    const writeSync = vi.fn((buffer: Uint8Array) => {
+      writes.push(...Array.from(buffer))
+      return buffer.length
+    })
+
+    let sent = false
+    const reader = {
+      Read(p: Uint8Array): [number, typeof io.EOF | null] {
+        if (sent) {
+          return [0, io.EOF]
+        }
+        sent = true
+        p.set([88, 89, 90], 0)
+        return [3, null]
+      },
+    }
+    const file = createHostFile('descriptor-file', 7, { writeSync })
+
+    const [n, err] = await io.Copy(file, reader)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(writes).toString('utf8')).toBe('XYZ')
+  })
 })

package/gs/os/index.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest'
+
+import { ErrNoHandle } from './index.js'
+
+describe('os override', () => {
+  it('exports ErrNoHandle', () => {
+    expect(ErrNoHandle?.Error()).toBe('os: process handle unavailable')
+  })
+})

package/gs/os/index.ts

@@ -27,6 +27,7 @@ export {
   SyscallError,
 } from './error.gs.js'
 export {
+  ErrNoHandle,
   ErrProcessDone,
   FindProcess,
   Getpid,

package/gs/os/meta.json

@@ -1,4 +1,8 @@
 {
+  "asyncMethods": {
+    "File.ReadFrom": true,
+    "File.WriteTo": true
+  },
   "dependencies": [
     "errors",
     "internal/byteorder",

package/gs/os/parity.json

@@ -0,0 +1,9 @@
+{
+  "schemaVersion": 1,
+  "strict": false,
+  "symbols": {
+    "ErrNoHandle": {
+      "status": "real"
+    }
+  }
+}

package/gs/os/proc.gs.ts

@@ -6,6 +6,20 @@ import * as runtime from "@goscript/runtime/index.js"
 
 import * as syscall from "@goscript/syscall/index.js"
 
+interface ProcessLike {
+	exit?: (code?: number) => never | void
+}
+
+export class ProcessExitError extends Error {
+	public readonly __goscriptExitCode: number
+
+	constructor(code: number) {
+		super("process exited with status " + String(code))
+		this.name = "ProcessExitError"
+		this.__goscriptExitCode = code
+	}
+}
+
 export let Args: $.Slice<string> = null
 
 export function init(): void {
@@ -72,13 +86,12 @@ export function Exit(code: number): void {
 	// enable us to write out a coverage data file.
 	runtime_beforeExit(code)
 
-	// In JavaScript environment, use process.exit if available
-	if (typeof process !== 'undefined' && process.exit) {
+	// In JavaScript environment, use process.exit if available.
+	const process = (globalThis as { process?: ProcessLike }).process
+	if (process?.exit !== undefined) {
 		process.exit(code)
-	} else {
-		// Fallback: just return (can't really exit in browser)
-		return
 	}
+	throw new ProcessExitError(code)
 }
 
 export function runtime_beforeExit(exitCode: number): void {

package/gs/os/proc.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest'
+
+import { Exit, ProcessExitError } from './proc.gs.js'
+
+describe('os process control', () => {
+  it('throws a structured browser exit error when process.exit is unavailable', () => {
+    const originalProcess = (globalThis as { process?: unknown }).process
+    try {
+      ;(globalThis as { process?: unknown }).process = {}
+
+      let err: unknown
+      try {
+        Exit(7)
+      } catch (caught) {
+        err = caught
+      }
+
+      expect(err).toBeInstanceOf(ProcessExitError)
+      expect((err as { __goscriptExitCode?: number }).__goscriptExitCode).toBe(
+        7,
+      )
+    } finally {
+      ;(globalThis as { process?: unknown }).process = originalProcess
+    }
+  })
+})

package/gs/os/readdir.test.ts

@@ -0,0 +1,56 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import * as io from '@goscript/io/index.js'
+
+import { Open } from './file_js.gs.js'
+
+const tempRoots: string[] = []
+
+afterEach(() => {
+  for (const root of tempRoots.splice(0)) {
+    rmSync(root, { force: true, recursive: true })
+  }
+})
+
+function makeTempRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), 'goscript-os-readdir-'))
+  tempRoots.push(root)
+  return root
+}
+
+describe('os file directory reads', () => {
+  it('reads host directory entries through os.File', () => {
+    const root = makeTempRoot()
+    writeFileSync(join(root, 'a.txt'), 'a')
+    writeFileSync(join(root, 'b.txt'), 'b')
+
+    const [dir, openErr] = Open(root)
+    expect(openErr).toBeNull()
+    expect(dir).not.toBeNull()
+    const [entries, readErr] = dir!.ReadDir(-1)
+    expect(readErr).toBeNull()
+    expect(entries?.map((entry) => entry!.Name()).sort()).toEqual([
+      'a.txt',
+      'b.txt',
+    ])
+    expect(dir!.Close()).toBeNull()
+  })
+
+  it('returns EOF after positive-count directory reads are exhausted', () => {
+    const root = makeTempRoot()
+    writeFileSync(join(root, 'a.txt'), 'a')
+
+    const [dir] = Open(root)
+    const [first, firstErr] = dir!.Readdirnames(1)
+    expect(firstErr).toBeNull()
+    expect(first).toHaveLength(1)
+
+    const [second, secondErr] = dir!.Readdirnames(1)
+    expect(second).toBeNull()
+    expect(secondErr).toBe(io.EOF)
+    expect(dir!.Close()).toBeNull()
+  })
+})

package/gs/os/root_js.gs.ts

@@ -119,7 +119,7 @@ export class Root {
 			{ name: "Close", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }
 		],
 		Root,
-		{ "name": { kind: $.TypeKind.Basic, name: "string" } }
+		[{ name: "name", key: "name", type: { kind: $.TypeKind.Basic, name: "string" } }]
 	);
 }
 

package/gs/os/types.gs.ts

@@ -140,7 +140,7 @@ export class File {
 			{ name: "Close", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }
 		],
 		File,
-		{ "name": { kind: $.TypeKind.Basic, name: "string" }, "closed": { kind: $.TypeKind.Basic, name: "boolean" } }
+		[{ name: "name", key: "name", type: { kind: $.TypeKind.Basic, name: "string" } }, { name: "closed", key: "closed", type: { kind: $.TypeKind.Basic, name: "boolean" } }]
 	);
 }