goscript 0.1.3 → 0.1.4

package/gs/io/io.ts

@@ -72,67 +72,111 @@ export interface WriteSeeker extends Writer, Seeker {}
 export interface ReadWriteSeeker extends Reader, Writer, Seeker {}
 
 class pipeState {
-  private chunks: Uint8Array[] = []
-  private readOffset = 0
   private readerClosed = false
   private writerClosed = false
   private readerErr: $.GoError = null
   private writerErr: $.GoError = null
-
-  Read(p: $.Bytes): [number, $.GoError] {
-    if (this.readerClosed) {
-      return [0, this.readerErr ?? ErrClosedPipe]
-    }
-    if ($.len(p) === 0) {
-      return [0, null]
-    }
-    if (this.chunks.length === 0) {
+  private pendingReads: Array<{
+    data: $.Bytes
+    resolve: (result: [number, $.GoError]) => void
+  }> = []
+  private pendingWrites: Array<{
+    data: Uint8Array
+    offset: number
+    resolve: (result: [number, $.GoError]) => void
+  }> = []
+
+  Read(p: $.Bytes): Promise<[number, $.GoError]> {
+    return (async (): Promise<[number, $.GoError]> => {
+      if (this.readerClosed) {
+        return [0, this.readerErr ?? ErrClosedPipe]
+      }
+      if ($.len(p) === 0) {
+        return [0, null]
+      }
+      if (this.pendingWrites.length > 0) {
+        return this.consumeNextWrite(p)
+      }
       if (this.writerClosed) {
         return [0, this.writerErr ?? EOF]
       }
-      return [0, EOF]
-    }
-
-    let copied = 0
-    while (copied < $.len(p) && this.chunks.length > 0) {
-      const chunk = this.chunks[0]
-      const available = chunk.length - this.readOffset
-      const want = Math.min($.len(p) - copied, available)
-      const target = $.goSlice(p, copied, copied + want)
-      $.copy(target, chunk.subarray(this.readOffset, this.readOffset + want))
-      copied += want
-      this.readOffset += want
-      if (this.readOffset === chunk.length) {
-        this.chunks.shift()
-        this.readOffset = 0
-      }
-    }
-    return [copied, null]
+      return await new Promise<[number, $.GoError]>((resolve) => {
+        this.pendingReads.push({ data: p, resolve })
+      })
+    })()
   }
 
-  Write(p: $.Bytes): [number, $.GoError] {
-    if (this.writerClosed || this.readerClosed) {
-      return [0, this.readerErr ?? ErrClosedPipe]
-    }
-    const data = new Uint8Array($.len(p))
-    $.copy(data, p)
-    this.chunks.push(data)
-    return [$.len(p), null]
+  Write(p: $.Bytes): Promise<[number, $.GoError]> {
+    return (async (): Promise<[number, $.GoError]> => {
+      if (this.writerClosed || this.readerClosed) {
+        return [0, this.readerErr ?? ErrClosedPipe]
+      }
+      if ($.len(p) === 0) {
+        return [0, null]
+      }
+      const data = new Uint8Array($.len(p))
+      $.copy(data, p)
+      return await new Promise<[number, $.GoError]>((resolve) => {
+        this.pendingWrites.push({ data, offset: 0, resolve })
+        this.drain()
+      })
+    })()
   }
 
   CloseReader(err: $.GoError): $.GoError {
     this.readerClosed = true
     this.readerErr = err
-    this.chunks = []
-    this.readOffset = 0
+    this.resolvePendingReads(ErrClosedPipe)
+    this.resolvePendingWrites(ErrClosedPipe)
     return null
   }
 
   CloseWriter(err: $.GoError): $.GoError {
     this.writerClosed = true
     this.writerErr = err
+    if (this.pendingWrites.length === 0) {
+      this.resolvePendingReads(err ?? EOF)
+    }
     return null
   }
+
+  private drain(): void {
+    while (this.pendingWrites.length > 0 && this.pendingReads.length > 0) {
+      if (this.readerClosed) {
+        this.resolvePendingWrites(this.readerErr ?? ErrClosedPipe)
+        return
+      }
+      const pending = this.pendingReads.shift()!
+      pending.resolve(this.consumeNextWrite(pending.data))
+    }
+  }
+
+  private consumeNextWrite(p: $.Bytes): [number, $.GoError] {
+    const pending = this.pendingWrites[0]
+    const n = Math.min($.len(p), pending.data.length - pending.offset)
+    $.copy(p, pending.data.subarray(pending.offset, pending.offset + n))
+    pending.offset += n
+    if (pending.offset === pending.data.length) {
+      this.pendingWrites.shift()
+      pending.resolve([pending.data.length, null])
+      if (this.writerClosed && this.pendingWrites.length === 0) {
+        this.resolvePendingReads(this.writerErr ?? EOF)
+      }
+    }
+    return [n, null]
+  }
+
+  private resolvePendingReads(err: $.GoError): void {
+    while (this.pendingReads.length > 0) {
+      this.pendingReads.shift()!.resolve([0, err])
+    }
+  }
+
+  private resolvePendingWrites(err: $.GoError): void {
+    while (this.pendingWrites.length > 0) {
+      this.pendingWrites.shift()!.resolve([0, err])
+    }
+  }
 }
 
 // PipeReader is the read half of a pipe.
@@ -140,7 +184,7 @@ export class PipeReader implements Reader, Closer {
   constructor(private pipe: pipeState) {}
 
   Read(data: $.Bytes): [number, $.GoError] {
-    return this.pipe.Read(data)
+    return this.pipe.Read(data) as any
   }
 
   Close(): $.GoError {
@@ -157,7 +201,7 @@ export class PipeWriter implements Writer, Closer {
   constructor(private pipe: pipeState) {}
 
   Write(data: $.Bytes): [number, $.GoError] {
-    return this.pipe.Write(data)
+    return this.pipe.Write(data) as any
   }
 
   Close(): $.GoError {
@@ -235,15 +279,18 @@ class DiscardWriter implements Writer {
 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] {
+export async function WriteString(
+  w: Writer,
+  s: string,
+): Promise<[number, $.GoError]> {
   // Check if w implements StringWriter interface
   if ('WriteString' in w && typeof (w as any).WriteString === 'function') {
-    return (w as StringWriter).WriteString(s)
+    return await ((w as StringWriter).WriteString(s) as any)
   }
 
   // Convert string to bytes and write
   const bytes = new TextEncoder().encode(s)
-  return w.Write(bytes)
+  return await (w.Write(bytes) as any)
 }
 
 // LimitedReader reads from R but limits the amount of data returned to just N bytes
@@ -251,7 +298,10 @@ export class LimitedReader implements Reader {
   public R: Reader | null
   public N: number
 
-  constructor(r?: Reader | { R?: Reader | null; N?: number } | null, n?: number) {
+  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
@@ -605,7 +655,15 @@ export async function ReadAll(r: Reader): Promise<[$.Bytes, $.GoError]> {
 }
 
 // NopCloser returns a ReadCloser with a no-op Close method wrapping the provided Reader r
-export function NopCloser(r: Reader): ReadCloser {
+export function NopCloser(r: Reader | null): ReadCloser {
+  if (r == null) {
+    return {
+      Read: () => {
+        throw new Error('nil Reader')
+      },
+      Close: () => null,
+    }
+  }
   return {
     Read: r.Read.bind(r),
     Close: () => null,
@@ -655,22 +713,22 @@ class multiReader implements Reader {
 
 // MultiWriter creates a writer that duplicates its writes to all the provided writers
 export function MultiWriter(...writers: (Writer | null)[]): Writer {
-  return new multiWriter(writers.slice())
+  return new multiWriter(writers.slice()) as any
 }
 
-class multiWriter implements Writer {
+class multiWriter {
   private writers: (Writer | null)[]
 
   constructor(writers: (Writer | null)[]) {
     this.writers = writers
   }
 
-  Write(p: $.Bytes): [number, $.GoError] {
+  async Write(p: $.Bytes): Promise<[number, $.GoError]> {
     for (const w of this.writers) {
       if (w == null) {
         throw new Error('io.MultiWriter: nil writer')
       }
-      const [n, err] = w.Write(p)
+      const [n, err] = await w.Write(p)
       if (err !== null) {
         return [n, err]
       }
@@ -697,15 +755,19 @@ class teeReader implements Reader {
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
+    return this.read(p) as any
+  }
+
+  private async read(p: $.Bytes): Promise<[number, $.GoError]> {
     if (this.r == null) {
       throw new Error('io.TeeReader: nil reader')
     }
-    const [n, err] = this.r.Read(p)
+    const [n, err] = await 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))
+      const [nw, ew] = await this.w.Write($.goSlice(p, 0, n))
       if (ew !== null) {
         return [n, ew]
       }

package/gs/io/meta.json

@@ -12,6 +12,12 @@
     "CopyN": true,
     "ReadAtLeast": true,
     "ReadFull": true,
-    "ReadAll": true
+    "ReadAll": true,
+    "WriteString": true
+  },
+  "asyncMethods": {
+    "PipeReader.Read": true,
+    "PipeWriter.Write": true,
+    "TeeReader.Read": true
   }
 }

package/gs/math/bits/index.ts

@@ -2,7 +2,7 @@
 // This replaces the auto-generated version that has TypeScript syntax errors
 
 // UintSize is the size of a uint in bits
-export const UintSize = 32 // Assuming 32-bit for JavaScript numbers
+export const UintSize = 64
 
 type Word64 = number | bigint
 
@@ -23,8 +23,8 @@ function word64Result(value: bigint, useBigInt: boolean): Word64 {
 }
 
 // --- Leading zeros ---
-export function LeadingZeros(x: number): number {
-  return Math.clz32(x >>> 0)
+export function LeadingZeros(x: Word64): number {
+  return LeadingZeros64(x)
 }
 
 export function LeadingZeros8(x: number): number {
@@ -53,9 +53,8 @@ export function LeadingZeros64(x: Word64): number {
 }
 
 // --- Trailing zeros ---
-export function TrailingZeros(x: number): number {
-  if (x === 0) return UintSize
-  return TrailingZeros32(x)
+export function TrailingZeros(x: Word64): number {
+  return TrailingZeros64(x)
 }
 
 export function TrailingZeros8(x: number): number {
@@ -90,8 +89,8 @@ export function TrailingZeros64(x: Word64): number {
 }
 
 // --- Ones count ---
-export function OnesCount(x: number): number {
-  return OnesCount32(x)
+export function OnesCount(x: Word64): number {
+  return OnesCount64(x)
 }
 
 export function OnesCount8(x: number): number {
@@ -124,8 +123,11 @@ export function OnesCount64(x: Word64): number {
 }
 
 // --- Rotate left ---
-export function RotateLeft(x: number, k: number): number {
-  return RotateLeft32(x, k)
+export function RotateLeft(x: number, k: number): number
+export function RotateLeft(x: bigint, k: number): bigint
+export function RotateLeft(x: Word64, k: number): number
+export function RotateLeft(x: Word64, k: number): Word64 {
+  return RotateLeft64(x, k)
 }
 
 export function RotateLeft8(x: number, k: number): number {
@@ -151,6 +153,7 @@ export function RotateLeft32(x: number, k: number): number {
 
 export function RotateLeft64(x: number, k: number): number
 export function RotateLeft64(x: bigint, k: number): bigint
+export function RotateLeft64(x: Word64, k: number): number
 export function RotateLeft64(x: Word64, k: number): Word64 {
   const n = 64
   k = k % n
@@ -163,8 +166,11 @@ export function RotateLeft64(x: Word64, k: number): Word64 {
 }
 
 // --- Reverse ---
-export function Reverse(x: number): number {
-  return Reverse32(x)
+export function Reverse(x: number): number
+export function Reverse(x: bigint): bigint
+export function Reverse(x: Word64): number
+export function Reverse(x: Word64): Word64 {
+  return Reverse64(x)
 }
 
 export function Reverse8(x: number): number {
@@ -196,6 +202,7 @@ export function Reverse32(x: number): number {
 
 export function Reverse64(x: number): number
 export function Reverse64(x: bigint): bigint
+export function Reverse64(x: Word64): number
 export function Reverse64(x: Word64): Word64 {
   // Implement 64-bit reverse using similar bit manipulation
   const useBigInt = useBigIntResult(x)
@@ -226,8 +233,11 @@ export function Reverse64(x: Word64): Word64 {
 }
 
 // --- ReverseBytes ---
-export function ReverseBytes(x: number): number {
-  return ReverseBytes32(x)
+export function ReverseBytes(x: number): number
+export function ReverseBytes(x: bigint): bigint
+export function ReverseBytes(x: Word64): number
+export function ReverseBytes(x: Word64): Word64 {
+  return ReverseBytes64(x)
 }
 
 export function ReverseBytes16(x: number): number {
@@ -247,6 +257,7 @@ export function ReverseBytes32(x: number): number {
 
 export function ReverseBytes64(x: number): number
 export function ReverseBytes64(x: bigint): bigint
+export function ReverseBytes64(x: Word64): number
 export function ReverseBytes64(x: Word64): Word64 {
   const useBigInt = useBigIntResult(x)
   const word = toUint64(x)
@@ -266,8 +277,8 @@ export function ReverseBytes64(x: Word64): Word64 {
 }
 
 // --- Len ---
-export function Len(x: number): number {
-  return Len32(x)
+export function Len(x: Word64): number {
+  return Len64(x)
 }
 
 export function Len8(x: number): number {
@@ -287,8 +298,11 @@ export function Len64(x: Word64): number {
 }
 
 // --- Multiplication functions ---
-export function Mul(x: number, y: number): [number, number] {
-  return Mul32(x, y)
+export function Mul(x: number, y: number): [number, number]
+export function Mul(x: bigint, y: bigint): [bigint, bigint]
+export function Mul(x: Word64, y: Word64): [number, number]
+export function Mul(x: Word64, y: Word64): [Word64, Word64] {
+  return Mul64(x, y)
 }
 
 export function Mul32(x: number, y: number): [number, number] {
@@ -301,6 +315,7 @@ export function Mul32(x: number, y: number): [number, number] {
 
 export function Mul64(x: number, y: number): [number, number]
 export function Mul64(x: bigint, y: bigint): [bigint, bigint]
+export function Mul64(x: Word64, y: Word64): [number, number]
 export function Mul64(x: Word64, y: Word64): [Word64, Word64] {
   const useBigInt = useBigIntResult(x, y)
   x = toUint64(x)
@@ -309,15 +324,15 @@ export function Mul64(x: Word64, y: Word64): [Word64, Word64] {
   const lo = product & uint64Mask
   const hi = product >> 64n
 
-  return [
-    word64Result(hi & uint64Mask, useBigInt),
-    word64Result(lo, useBigInt),
-  ]
+  return [word64Result(hi & uint64Mask, useBigInt), word64Result(lo, useBigInt)]
 }
 
 // --- Division functions ---
-export function Div(hi: number, lo: number, y: number): [number, number] {
-  return Div32(hi, lo, y)
+export function Div(hi: number, lo: number, y: number): [number, number]
+export function Div(hi: bigint, lo: bigint, y: bigint): [bigint, bigint]
+export function Div(hi: Word64, lo: Word64, y: Word64): [number, number]
+export function Div(hi: Word64, lo: Word64, y: Word64): [Word64, Word64] {
+  return Div64(hi, lo, y)
 }
 
 export function Div32(hi: number, lo: number, y: number): [number, number] {
@@ -337,6 +352,7 @@ export function Div32(hi: number, lo: number, y: number): [number, number] {
 
 export function Div64(hi: number, lo: number, y: number): [number, number]
 export function Div64(hi: bigint, lo: bigint, y: bigint): [bigint, bigint]
+export function Div64(hi: Word64, lo: Word64, y: Word64): [number, number]
 export function Div64(hi: Word64, lo: Word64, y: Word64): [Word64, Word64] {
   const useBigInt = useBigIntResult(hi, lo, y)
   hi = toUint64(hi)
@@ -356,8 +372,11 @@ export function Div64(hi: Word64, lo: Word64, y: Word64): [Word64, Word64] {
 }
 
 // --- Add and Sub with carry ---
-export function Add(x: number, y: number, carry: number): [number, number] {
-  return Add32(x, y, carry)
+export function Add(x: number, y: number, carry: number): [number, number]
+export function Add(x: bigint, y: bigint, carry: bigint): [bigint, bigint]
+export function Add(x: Word64, y: Word64, carry: Word64): [number, number]
+export function Add(x: Word64, y: Word64, carry: Word64): [Word64, Word64] {
+  return Add64(x, y, carry)
 }
 
 export function Add32(x: number, y: number, carry: number): [number, number] {
@@ -369,6 +388,7 @@ export function Add32(x: number, y: number, carry: number): [number, number] {
 
 export function Add64(x: number, y: number, carry: number): [number, number]
 export function Add64(x: bigint, y: bigint, carry: bigint): [bigint, bigint]
+export function Add64(x: Word64, y: Word64, carry: Word64): [number, number]
 export function Add64(x: Word64, y: Word64, carry: Word64): [Word64, Word64] {
   const useBigInt = useBigIntResult(x, y, carry)
   const sum = toUint64(x) + toUint64(y) + toUint64(carry)
@@ -377,8 +397,11 @@ export function Add64(x: Word64, y: Word64, carry: Word64): [Word64, Word64] {
   return [word64Result(result, useBigInt), word64Result(carryOut, useBigInt)]
 }
 
-export function Sub(x: number, y: number, borrow: number): [number, number] {
-  return Sub32(x, y, borrow)
+export function Sub(x: number, y: number, borrow: number): [number, number]
+export function Sub(x: bigint, y: bigint, borrow: bigint): [bigint, bigint]
+export function Sub(x: Word64, y: Word64, borrow: Word64): [number, number]
+export function Sub(x: Word64, y: Word64, borrow: Word64): [Word64, Word64] {
+  return Sub64(x, y, borrow)
 }
 
 export function Sub32(x: number, y: number, borrow: number): [number, number] {
@@ -390,6 +413,7 @@ export function Sub32(x: number, y: number, borrow: number): [number, number] {
 
 export function Sub64(x: number, y: number, borrow: number): [number, number]
 export function Sub64(x: bigint, y: bigint, borrow: bigint): [bigint, bigint]
+export function Sub64(x: Word64, y: Word64, borrow: Word64): [number, number]
 export function Sub64(x: Word64, y: Word64, borrow: Word64): [Word64, Word64] {
   const useBigInt = useBigIntResult(x, y, borrow)
   const diff = toUint64(x) - toUint64(y) - toUint64(borrow)

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

@@ -72,6 +72,22 @@ describe('net/http override', () => {
     expect(err?.Error()).toBe('net/http: Client.Do is not implemented in GoScript')
   })
 
+  it('wraps request body readers and keeps response metadata', () => {
+    const reader = {
+      Read: (p: Uint8Array) => [p.length, null] as [number, null],
+    }
+
+    const [req, reqErr] = NewRequest(MethodPost, 'https://example.invalid/upload', reader)
+
+    expect(reqErr).toBeNull()
+    expect(req!.Body).not.toBeNull()
+    expect(req!.Body!.Close()).toBeNull()
+
+    const resp = new Response({ StatusCode: StatusCreated, ContentLength: -1, Request: varRef(req!) })
+    expect(resp.ContentLength).toBe(-1)
+    expect((resp.Request as any).value).toBe(req)
+  })
+
   it('exports the default transport surface', async () => {
     const [req] = NewRequest(MethodPost, 'https://example.invalid', null)
 

package/gs/net/http/index.ts

@@ -259,7 +259,7 @@ export interface ResponseWriter {
 export class Request {
   public Method: string
   public URL: any
-  public Body: io.Reader | null
+  public Body: io.ReadCloser | null
   public Header: Header
   public ContentLength: number
   public RequestURI: string
@@ -313,12 +313,16 @@ export class Response {
   public StatusCode: number
   public Body: io.ReadCloser | null
   public Header: Header
+  public ContentLength: number
+  public Request: Request | $.VarRef<Request> | null
 
   constructor(init?: Partial<Response>) {
     this.Status = init?.Status ?? ''
     this.StatusCode = init?.StatusCode ?? 0
     this.Body = init?.Body ?? null
     this.Header = init?.Header ?? new Header()
+    this.ContentLength = init?.ContentLength ?? 0
+    this.Request = init?.Request ?? null
     if (this.Status === '' && this.StatusCode !== 0) {
       const text = StatusText(this.StatusCode)
       this.Status = text === '' ? String(this.StatusCode) : `${this.StatusCode} ${text}`
@@ -331,6 +335,8 @@ export class Response {
       Header: this.Header,
       Status: this.Status,
       StatusCode: this.StatusCode,
+      ContentLength: this.ContentLength,
+      Request: this.Request,
     })
   }
 }
@@ -573,9 +579,20 @@ export function NewRequestWithContext(
     method = MethodGet
   }
   const parsedURL = parseRequestURL(url)
-  return [new Request({ Method: method, URL: parsedURL, Body: body, RequestURI: parsedURL.Path, ctx: _ctx }), null]
+  return [new Request({ Method: method, URL: parsedURL, Body: readCloserForBody(body), RequestURI: parsedURL.Path, ctx: _ctx }), null]
 }
 
 export function Get(_url: string): [Response | null, $.GoError] {
   return [null, errors.New('net/http: Get is not implemented in GoScript')]
 }
+
+function readCloserForBody(body: io.Reader | null): io.ReadCloser | null {
+  if (body == null) {
+    return null
+  }
+  const closer = body as io.Reader & Partial<io.Closer>
+  if (typeof closer.Close === 'function') {
+    return closer as io.ReadCloser
+  }
+  return io.NopCloser(body)
+}

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/meta.json

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