goscript 0.1.2 → 0.1.3

package/gs/crypto/sha1/index.test.ts

@@ -0,0 +1,28 @@
+import { createHash } from 'node:crypto'
+import { describe, expect, it } from 'vitest'
+
+import { New, Sum } from './index.js'
+
+describe('crypto/sha1 override', () => {
+  it('matches Node digest', async () => {
+    const data = new TextEncoder().encode('goscript sha1')
+
+    expect(toHex(await Sum(data))).toBe(nodeHash(data))
+  })
+
+  it('supports incremental hash.Hash use', async () => {
+    const h = New()
+    h.Write(new TextEncoder().encode('go'))
+    h.Write(new TextEncoder().encode('script'))
+
+    expect(toHex(await h.Sum(null))).toBe(nodeHash(new TextEncoder().encode('goscript')))
+  })
+})
+
+function nodeHash(data: Uint8Array): string {
+  return createHash('sha1').update(data).digest('hex')
+}
+
+function toHex(value: Uint8Array): string {
+  return Buffer.from(value).toString('hex')
+}

package/gs/crypto/sha1/index.ts

@@ -0,0 +1,130 @@
+import * as $ from '@goscript/builtin/index.js'
+import {
+  getHostRuntime,
+  type NodeCryptoHash,
+} from '@goscript/builtin/hostio.js'
+
+export const Size = 20
+export const BlockSize = 64
+
+class Sha1Error {
+  constructor(private readonly message: string) {}
+
+  Error(): string {
+    return this.message
+  }
+}
+
+class Digest {
+  private chunks: Uint8Array[] = []
+  private dataLength = 0
+  private hash: NodeCryptoHash | null
+  private canCopyHash: boolean
+
+  constructor() {
+    this.hash = createNodeHash()
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(p)
+    this.hash?.update(bytes)
+    if (!this.canCopyHash) {
+      this.chunks.push(bytes.slice())
+      this.dataLength += bytes.length
+    }
+    return [bytes.length, null]
+  }
+
+  async Sum(b: $.Bytes): Promise<$.Bytes> {
+    const digest =
+      this.canCopyHash ?
+        new Uint8Array(this.hash!.copy!().digest())
+      : await sum(this.snapshotBytes())
+    return appendDigest($.bytesToUint8Array(b), digest)
+  }
+
+  Reset(): void {
+    this.chunks = []
+    this.dataLength = 0
+    this.hash = createNodeHash()
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Size(): number {
+    return Size
+  }
+
+  BlockSize(): number {
+    return BlockSize
+  }
+
+  private snapshotBytes(): Uint8Array {
+    return concatChunks(this.chunks, this.dataLength)
+  }
+}
+
+export function New(): any {
+  return new Digest()
+}
+
+export async function Sum(data: $.Bytes): Promise<Uint8Array> {
+  return sum(data)
+}
+
+async function sum(data: $.Bytes): Promise<Uint8Array> {
+  const hash = createNodeHash()
+  if (hash != null) {
+    return new Uint8Array(hash.update($.bytesToUint8Array(data)).digest())
+  }
+
+  const subtle = subtleCrypto()
+  if (subtle == null) {
+    throw new Error(
+      new Sha1Error('crypto/sha1: WebCrypto digest is unavailable').Error(),
+    )
+  }
+
+  const digest = await subtle.digest(
+    'SHA-1',
+    $.bytesToUint8Array(data) as unknown as BufferSource,
+  )
+  return new Uint8Array(digest)
+}
+
+function appendDigest(prefix: Uint8Array, digest: Uint8Array): Uint8Array {
+  const out = new Uint8Array(prefix.length + digest.length)
+  out.set(prefix)
+  out.set(digest, prefix.length)
+  return out
+}
+
+function createNodeHash(): NodeCryptoHash | null {
+  const nodeCrypto = getHostRuntime().nodeCrypto
+  if (!nodeCrypto?.createHash) {
+    return null
+  }
+  try {
+    return nodeCrypto.createHash('sha1')
+  } catch {
+    return null
+  }
+}
+
+function concatChunks(chunks: Uint8Array[], length: number): Uint8Array {
+  const out = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}
+
+function subtleCrypto(): SubtleCrypto | null {
+  const crypto = globalThis.crypto
+  if (crypto?.subtle && typeof crypto.subtle.digest === 'function') {
+    return crypto.subtle
+  }
+  return null
+}

package/gs/crypto/sha1/meta.json

@@ -0,0 +1,8 @@
+{
+  "asyncFunctions": {
+    "Sum": true
+  },
+  "asyncMethods": {
+    "Digest.Sum": true
+  }
+}

package/gs/fmt/fmt.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { resetHostRuntimeForTests } from '@goscript/builtin/hostio.js'
+import * as $ from '@goscript/builtin/index.js'
 import * as fmt from './fmt.js'
 
 const originalDeno = (globalThis as any).Deno
@@ -187,3 +188,22 @@ describe('fmt parseFormat basic cases', () => {
     expect(fmt.Sprintf('%c', 65)).toBe('A')
   })
 })
+
+describe('fmt scanning', () => {
+  it('scans decimal fields separated by literals', () => {
+    const start = $.varRef(0)
+    const end = $.varRef(0)
+
+    const [n, err] = fmt.Sscanf(
+      'bytes=12-34',
+      'bytes=%d-%d',
+      $.interfaceValue(start, '*int64'),
+      $.interfaceValue(end, '*int64'),
+    )
+
+    expect(err).toBeNull()
+    expect(n).toBe(2)
+    expect(start.value).toBe(12)
+    expect(end.value).toBe(34)
+  })
+})

package/gs/fmt/fmt.ts

@@ -488,12 +488,82 @@ export function Sscan(_str: string, ..._a: any[]): [number, $.GoError | null] {
 }
 
 export function Sscanf(
-  _str: string,
-  _format: string,
-  ..._a: any[]
+  str: string,
+  format: string,
+  ...a: any[]
 ): [number, $.GoError | null] {
-  // TODO: Implement formatted scanning from string
-  return [0, $.newError('Sscanf not implemented')]
+  const parts = buildScanPattern(format)
+  if (parts == null) {
+    return [0, $.newError(`unsupported Sscanf format: ${format}`)]
+  }
+  const match = parts.pattern.exec(str)
+  if (match == null) {
+    return [0, $.newError('input does not match format')]
+  }
+
+  let assigned = 0
+  for (let i = 0; i < parts.verbs.length && i < a.length; i++) {
+    const raw = match[i + 1]
+    const value = parts.verbs[i] === 'd' ? Number.parseInt(raw, 10) : raw
+    if (!assignScanValue(a[i], value)) {
+      return [assigned, $.newError('scan destination is not assignable')]
+    }
+    assigned++
+  }
+  return [assigned, null]
+}
+
+function buildScanPattern(
+  format: string,
+): { pattern: RegExp; verbs: string[] } | null {
+  let source = '^'
+  const verbs: string[] = []
+  for (let i = 0; i < format.length; i++) {
+    const ch = format[i]
+    if (ch !== '%') {
+      source += /\s/.test(ch) ? '\\s+' : escapeRegExp(ch)
+      continue
+    }
+    const verb = format[++i]
+    if (verb === '%') {
+      source += '%'
+      continue
+    }
+    if (verb === 'd') {
+      source += '([+-]?\\d+)'
+      verbs.push(verb)
+      continue
+    }
+    if (verb === 's') {
+      source += '(\\S+)'
+      verbs.push(verb)
+      continue
+    }
+    return null
+  }
+  source += '$'
+  return { pattern: new RegExp(source), verbs }
+}
+
+function assignScanValue(target: any, value: string | number): boolean {
+  const ref =
+    $.isVarRef(target) ? target
+    : (
+      target != null &&
+      typeof target === 'object' &&
+      $.isVarRef(target.__goValue)
+    ) ?
+      target.__goValue
+    : null
+  if (ref == null) {
+    return false
+  }
+  ref.value = value
+  return true
+}
+
+function escapeRegExp(ch: string): string {
+  return ch.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
 }
 
 export function Sscanln(

package/gs/github.com/aperturerobotics/util/conc/index.test.ts

@@ -25,6 +25,6 @@ describe('util/conc override', () => {
 
     release.close()
     expect(await q.WaitIdle(Background(), null)).toBeNull()
-    expect(done).toEqual([0, 1, 2, 3, 4])
+    expect([...done].sort((a, b) => a - b)).toEqual([0, 1, 2, 3, 4])
   })
 })

package/gs/io/io.test.ts

@@ -0,0 +1,64 @@
+import * as $ from '@goscript/builtin/index.js'
+import { LimitedReader, MultiWriter, TeeReader } from './index.js'
+import { describe, expect, test } from 'vitest'
+
+class sliceReader {
+  constructor(private data: Uint8Array) {}
+
+  Read(p: $.Bytes): [number, $.GoError] {
+    const n = Math.min($.len(p), this.data.length)
+    p!.set(this.data.subarray(0, n), 0)
+    this.data = this.data.subarray(n)
+    return [n, n === 0 ? new Error('EOF') as $.GoError : null]
+  }
+}
+
+class captureWriter {
+  public chunks: number[] = []
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    this.chunks.push(...Array.from(p ?? []))
+    return [$.len(p), null]
+  }
+}
+
+describe('io override', () => {
+  test('LimitedReader accepts generated struct-literal construction', async () => {
+    const reader = new LimitedReader({
+      R: new sliceReader($.stringToBytes('abcdef')),
+      N: 3,
+    })
+    const buf = new Uint8Array(8)
+
+    const [n, err] = await reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(buf.subarray(0, n)).toString('utf8')).toBe('abc')
+  })
+
+  test('TeeReader accepts nullable generated interface values', () => {
+    const writer = new captureWriter()
+    const reader = TeeReader(new sliceReader($.stringToBytes('abc')), writer)
+    const buf = new Uint8Array(4)
+
+    const [n, err] = reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(writer.chunks).toString('utf8')).toBe('abc')
+  })
+
+  test('MultiWriter accepts nullable generated interface values', () => {
+    const first = new captureWriter()
+    const second = new captureWriter()
+    const writer = MultiWriter(first, second)
+
+    const [n, err] = writer.Write($.stringToBytes('abc'))
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(first.chunks).toString('utf8')).toBe('abc')
+    expect(Buffer.from(second.chunks).toString('utf8')).toBe('abc')
+  })
+})

package/gs/io/io.ts

@@ -232,7 +232,7 @@ class DiscardWriter implements Writer {
   }
 }
 
-export const Discard: Writer = new DiscardWriter()
+export const Discard: Writer | null = new DiscardWriter()
 
 // WriteString writes the contents of the string s to w, which accepts a slice of bytes
 export function WriteString(w: Writer, s: string): [number, $.GoError] {
@@ -248,12 +248,18 @@ export function WriteString(w: Writer, s: string): [number, $.GoError] {
 
 // LimitedReader reads from R but limits the amount of data returned to just N bytes
 export class LimitedReader implements Reader {
-  public R: Reader
+  public R: Reader | null
   public N: number
 
-  constructor(r: Reader, n: number) {
-    this.R = r
-    this.N = n
+  constructor(r?: Reader | { R?: Reader | null; N?: number } | null, n?: number) {
+    if (r != null && typeof (r as { Read?: unknown }).Read !== 'function') {
+      const init = r as { R?: Reader | null; N?: number }
+      this.R = init.R ?? null
+      this.N = init.N ?? 0
+      return
+    }
+    this.R = (r as Reader | null | undefined) ?? null
+    this.N = n ?? 0
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
@@ -261,6 +267,9 @@ export class LimitedReader implements Reader {
       if (this.N <= 0) {
         return [0, EOF]
       }
+      if (this.R == null) {
+        throw new Error('io.LimitedReader: nil reader')
+      }
 
       let readBuf = p
       if ($.len(p) > this.N) {
@@ -645,19 +654,22 @@ class multiReader implements Reader {
 }
 
 // MultiWriter creates a writer that duplicates its writes to all the provided writers
-export function MultiWriter(...writers: Writer[]): Writer {
+export function MultiWriter(...writers: (Writer | null)[]): Writer {
   return new multiWriter(writers.slice())
 }
 
 class multiWriter implements Writer {
-  private writers: Writer[]
+  private writers: (Writer | null)[]
 
-  constructor(writers: Writer[]) {
+  constructor(writers: (Writer | null)[]) {
     this.writers = writers
   }
 
   Write(p: $.Bytes): [number, $.GoError] {
     for (const w of this.writers) {
+      if (w == null) {
+        throw new Error('io.MultiWriter: nil writer')
+      }
       const [n, err] = w.Write(p)
       if (err !== null) {
         return [n, err]
@@ -671,22 +683,28 @@ class multiWriter implements Writer {
 }
 
 // TeeReader returns a Reader that writes to w what it reads from r
-export function TeeReader(r: Reader, w: Writer): Reader {
+export function TeeReader(r: Reader | null, w: Writer | null): Reader {
   return new teeReader(r, w)
 }
 
 class teeReader implements Reader {
-  private r: Reader
-  private w: Writer
+  private r: Reader | null
+  private w: Writer | null
 
-  constructor(r: Reader, w: Writer) {
+  constructor(r: Reader | null, w: Writer | null) {
     this.r = r
     this.w = w
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
+    if (this.r == null) {
+      throw new Error('io.TeeReader: nil reader')
+    }
     const [n, err] = this.r.Read(p)
     if (n > 0) {
+      if (this.w == null) {
+        throw new Error('io.TeeReader: nil writer')
+      }
       const [nw, ew] = this.w.Write($.goSlice(p, 0, n))
       if (ew !== null) {
         return [n, ew]

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

@@ -2,7 +2,14 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { Handler, Header_Get, Header_Set, MethodGet, NewRequest, StatusPartialContent } from '../index.js'
+import {
+  Handler,
+  Header_Get,
+  Header_Set,
+  MethodGet,
+  NewRequest,
+  StatusPartialContent,
+} from '../index.js'
 import { NewServer, NewUnstartedServer, Server_Start } from './index.js'
 
 describe('net/http/httptest override', () => {
@@ -12,12 +19,13 @@ describe('net/http/httptest override', () => {
     }
 
     const srv = NewServer(handler)
-    expect(srv.URL).toBe('http://127.0.0.1')
+    expect(srv.URL).toMatch(/^http:\/\/goscript-httptest-\d+\.invalid$/)
     expect(srv.Client()).toBeTruthy()
     expect(srv.Config().Handler).toBe(handler)
     expect(Server_Start(NewUnstartedServer(handler))?.Error()).toBe(
       'net/http/httptest: Server.Start is not implemented in GoScript',
     )
+    srv.Close()
   })
 
   it('routes Client.Do through the in-memory server handler', async () => {
@@ -49,5 +57,29 @@ describe('net/http/httptest override', () => {
     expect(n).toBe(4)
     expect(Buffer.from(buf).toString('utf8')).toBe('data')
     expect(resp!.Body!.Close()).toBeNull()
+    srv.Close()
+  })
+
+  it('awaits async handlers through Server.Client transport', async () => {
+    const srv = NewServer({
+      async ServeHTTP(w) {
+        await Promise.resolve()
+        w!.WriteHeader(StatusPartialContent)
+        w!.Write($.stringToBytes('async'))
+      },
+    })
+    const [req, reqErr] = NewRequest(MethodGet, srv.URL + '/async', null)
+    expect(reqErr).toBeNull()
+
+    const [resp, err] = await srv.Client().Do(req)
+
+    expect(err).toBeNull()
+    expect(resp?.StatusCode).toBe(StatusPartialContent)
+    const buf = new Uint8Array(5)
+    const [n, readErr] = resp!.Body!.Read(buf)
+    expect(readErr).toBeNull()
+    expect(n).toBe(5)
+    expect(Buffer.from(buf).toString('utf8')).toBe('async')
+    srv.Close()
   })
 })

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

@@ -58,10 +58,16 @@ export function NewRecorder(): ResponseRecorder {
   return new ResponseRecorder()
 }
 
-export function NewRequest(method: string, target: string, body: io.Reader | null): http.Request {
+export function NewRequest(
+  method: string,
+  target: string,
+  body: io.Reader | null,
+): http.Request {
   const [req, err] = http.NewRequest(method, target, body)
   if (err != null || req == null) {
-    throw err ?? errors.New('net/http/httptest: NewRequest returned nil request')
+    throw (
+      err ?? errors.New('net/http/httptest: NewRequest returned nil request')
+    )
   }
   return req
 }
@@ -71,21 +77,26 @@ export class Server {
   private handler: http.Handler | null
 
   constructor(init?: Partial<Server> & { Handler?: http.Handler | null }) {
-    this.URL = init?.URL ?? 'http://127.0.0.1'
     this.handler = init?.Handler ?? null
+    this.URL = init?.URL ?? http.RegisterInProcessServer(this.handler)
   }
 
   public Client(): http.Client {
     return new http.Client({ Transport: new serverTransport(this) })
   }
 
-  public Close(): void {}
+  public Close(): void {
+    http.UnregisterInProcessServer(this.URL)
+  }
 
   public Config(): http.Server {
     return new http.Server({ Handler: this.handler })
   }
 
-  public ServeHTTP(w: http.ResponseWriter | null, r: http.Request | $.VarRef<http.Request> | null): void | Promise<void> {
+  public ServeHTTP(
+    w: http.ResponseWriter | null,
+    r: http.Request | $.VarRef<http.Request> | null,
+  ): void | Promise<void> {
     return this.handler?.ServeHTTP(w, r)
   }
 }
@@ -93,7 +104,9 @@ export class Server {
 class serverTransport implements http.RoundTripper {
   constructor(private server: Server) {}
 
-  public RoundTrip(req: http.Request | $.VarRef<http.Request> | null): [http.Response | null, $.GoError] {
+  public async RoundTrip(
+    req: http.Request | $.VarRef<http.Request> | null,
+  ): Promise<[http.Response | null, $.GoError]> {
     const request = $.pointerValue<http.Request | null>(req)
     if (request == null) {
       return [null, errors.New('net/http: nil Request')]
@@ -101,7 +114,7 @@ class serverTransport implements http.RoundTripper {
     const recorder = NewRecorder()
     const served = this.server.ServeHTTP(recorder, request)
     if (served instanceof Promise) {
-      return [null, errors.New('net/http/httptest: async handlers are not supported by Client.Do')]
+      await served
     }
     return [recorder.Result(), null]
   }
@@ -116,5 +129,7 @@ export function NewUnstartedServer(handler: http.Handler | null): Server {
 }
 
 export function Server_Start(_s: Server | $.VarRef<Server> | null): $.GoError {
-  return errors.New('net/http/httptest: Server.Start is not implemented in GoScript')
+  return errors.New(
+    'net/http/httptest: Server.Start is not implemented in GoScript',
+  )
 }

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

@@ -7,6 +7,9 @@ import {
   File,
   FileSystem,
   Header,
+  Header_Add,
+  Header_Del,
+  Header_Get,
   Header_Set,
   HandlerFunc_ServeHTTP,
   Get,
@@ -19,11 +22,16 @@ import {
   ResponseWriter,
   Server,
   StatusCreated,
+  StatusForbidden,
+  StatusMethodNotAllowed,
   StatusNotFound,
   StatusOK,
   StatusServiceUnavailable,
+  StatusTeapot,
   StatusText,
   StatusTooManyRequests,
+  StatusUnauthorized,
+  StatusUnsupportedMediaType,
 } from './index.js'
 
 describe('net/http override', () => {
@@ -33,6 +41,11 @@ describe('net/http override', () => {
     expect(resp.StatusCode).toBe(200)
     expect(StatusText(resp.StatusCode)).toBe('OK')
     expect(StatusText(StatusNotFound)).toBe('Not Found')
+    expect(StatusText(StatusUnauthorized)).toBe('Unauthorized')
+    expect(StatusText(StatusForbidden)).toBe('Forbidden')
+    expect(StatusText(StatusMethodNotAllowed)).toBe('Method Not Allowed')
+    expect(StatusText(StatusUnsupportedMediaType)).toBe('Unsupported Media Type')
+    expect(StatusText(StatusTeapot)).toBe("I'm a teapot")
     expect(StatusText(StatusTooManyRequests)).toBe('Too Many Requests')
     expect(StatusText(StatusServiceUnavailable)).toBe('Service Unavailable')
     expect(StatusText(599)).toBe('')
@@ -92,6 +105,23 @@ describe('net/http override', () => {
     expect(resp?.StatusCode).toBe(StatusOK)
   })
 
+  it('canonicalizes header keys for case-insensitive lookup', () => {
+    const header = new Header()
+
+    Header_Set(header, 'Content-Type', 'application/json')
+
+    expect(header.has('Content-Type')).toBe(true)
+    expect(header.has('content-type')).toBe(false)
+    expect(Header_Get(header, 'content-type')).toBe('application/json')
+
+    Header_Add(header, 'x-pack-id', 'pack-1')
+    Header_Add(header, 'X-Pack-Id', 'pack-2')
+    expect(Array.from(header.get('X-Pack-Id') ?? [])).toEqual(['pack-1', 'pack-2'])
+
+    Header_Del(header, 'x-pack-id')
+    expect(Header_Get(header, 'X-Pack-ID')).toBe('')
+  })
+
   it('accepts server context and shutdown surfaces', () => {
     const srv = new Server({
       Addr: ':0',