goscript 0.2.3 → 0.2.5

package/gs/golang.org/x/crypto/cryptobyte/meta.json

@@ -0,0 +1,3 @@
+{
+  "dependencies": ["time"]
+}

package/gs/golang.org/x/crypto/internal/alias/index.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'vitest'
+
+import { AnyOverlap, InexactOverlap } from './index.js'
+
+describe('crypto/internal/alias override', () => {
+  test('reports no overlap for distinct backings', () => {
+    const x = new Uint8Array([1, 2, 3, 4])
+    const y = new Uint8Array([1, 2, 3, 4])
+    expect(AnyOverlap(x, y)).toBe(false)
+    expect(InexactOverlap(x, y)).toBe(false)
+  })
+
+  test('reports no overlap when either slice is empty', () => {
+    const buf = new Uint8Array(8)
+    expect(AnyOverlap(buf, new Uint8Array(0))).toBe(false)
+    expect(AnyOverlap(new Uint8Array(0), buf)).toBe(false)
+  })
+
+  test('detects overlap of views over a shared backing', () => {
+    const buf = new Uint8Array(8)
+    const head = buf.subarray(0, 4)
+    const tail = buf.subarray(4, 8)
+    const straddle = buf.subarray(2, 6)
+    // Disjoint halves of the same buffer do not overlap.
+    expect(AnyOverlap(head, tail)).toBe(false)
+    // A straddling view overlaps both halves.
+    expect(AnyOverlap(head, straddle)).toBe(true)
+    expect(AnyOverlap(tail, straddle)).toBe(true)
+  })
+
+  test('InexactOverlap ignores exactly aligned identical starts', () => {
+    const buf = new Uint8Array(8)
+    const a = buf.subarray(0, 4)
+    const b = buf.subarray(0, 4)
+    // Same start address: exact overlap, so InexactOverlap is false.
+    expect(InexactOverlap(a, b)).toBe(false)
+    // But AnyOverlap still reports the shared memory.
+    expect(AnyOverlap(a, b)).toBe(true)
+  })
+})

package/gs/golang.org/x/crypto/internal/alias/index.ts

@@ -0,0 +1,40 @@
+import * as $ from '@goscript/builtin/index.js'
+
+// AnyOverlap reports whether x and y share memory at any (not necessarily
+// corresponding) index. The memory beyond the slice length is ignored.
+//
+// This mirrors the upstream pointer comparison without reflect or unsafe by
+// using GoScript synthetic byte addresses. Those addresses are stride separated
+// per backing array, so slices over distinct backings can never compare as
+// overlapping and slices over a shared backing compare by element offset, which
+// reproduces the Go semantics the crypto cipher modes rely on.
+export function AnyOverlap(x: $.Bytes, y: $.Bytes): boolean {
+  const xLen = $.len(x)
+  const yLen = $.len(y)
+  if (xLen === 0 || yLen === 0) {
+    return false
+  }
+  const xFirst = $.indexByteAddress(x, 0, 1)
+  const xLast = $.indexByteAddress(x, xLen - 1, 1)
+  const yFirst = $.indexByteAddress(y, 0, 1)
+  const yLast = $.indexByteAddress(y, yLen - 1, 1)
+  return xFirst <= yLast && yFirst <= xLast
+}
+
+// InexactOverlap reports whether x and y share memory at any non-corresponding
+// index. The memory beyond the slice length is ignored. Note that x and y can
+// have different lengths and still not have any inexact overlap.
+//
+// InexactOverlap can be used to implement the requirements of the crypto/cipher
+// AEAD, Block, BlockMode and Stream interfaces.
+export function InexactOverlap(x: $.Bytes, y: $.Bytes): boolean {
+  const xLen = $.len(x)
+  const yLen = $.len(y)
+  if (xLen === 0 || yLen === 0) {
+    return false
+  }
+  if ($.indexByteAddress(x, 0, 1) === $.indexByteAddress(y, 0, 1)) {
+    return false
+  }
+  return AnyOverlap(x, y)
+}

package/gs/io/fs/glob.ts

@@ -96,7 +96,7 @@ export async function globWithLimit(
     }
     if (!hasMeta(pattern)) {
       {
-        const [, statErr] = Stat(fsys, pattern)
+        const [, statErr] = await Stat(fsys, pattern)
         if (statErr != null) {
           return [null, null]
         }

package/gs/io/fs/meta.json

@@ -1,7 +1,10 @@
 {
   "asyncFunctions": {
     "Glob": true,
+    "Lstat": true,
     "ReadDir": true,
+    "Stat": true,
+    "Sub": true,
     "WalkDir": true
   }
 }

package/gs/io/fs/readlink.test.ts

@@ -35,8 +35,8 @@ describe('io/fs ReadLink', () => {
     expect(err?.Error()).toBe('readlink link: invalid argument')
   })
 
-  it('uses Lstat from ReadLinkFS implementations', () => {
-    const [, err] = Lstat(new linkFS(), 'link')
+  it('uses Lstat from ReadLinkFS implementations', async () => {
+    const [, err] = await Lstat(new linkFS(), 'link')
 
     expect(err).toBe(ErrInvalid)
   })

package/gs/io/fs/readlink.ts

@@ -60,10 +60,13 @@ export function ReadLink(fsys: FS, name: string): [string, $.GoError] {
   return sym!.ReadLink(name)
 }
 
-export function Lstat(fsys: FS, name: string): [FileInfo, $.GoError] {
+export async function Lstat(
+  fsys: FS,
+  name: string,
+): Promise<[FileInfo, $.GoError]> {
   const { value: sym, ok } = $.typeAssert<ReadLinkFS>(fsys, 'ReadLinkFS')
   if (!ok) {
-    return Stat(fsys, name)
+    return await Stat(fsys, name)
   }
   return sym!.Lstat(name)
 }

package/gs/io/fs/stat.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { File, FileInfo, Stat } from './index.js'
+
+function fileInfo(name: string, isDir = false): FileInfo {
+  return {
+    IsDir(): boolean {
+      return isDir
+    },
+    ModTime(): any {
+      return null
+    },
+    Mode(): number {
+      return isDir ? 0o040000 : 0
+    },
+    Name(): string {
+      return name
+    },
+    Size(): number {
+      return 0
+    },
+    Sys(): null {
+      return null
+    },
+  }
+}
+
+describe('io/fs Stat override', () => {
+  it('awaits async StatFS implementations', async () => {
+    const info = fileInfo('pkg', true)
+
+    const [got, err] = await Stat(
+      {
+        async Stat(_name: string): Promise<[FileInfo, $.GoError]> {
+          return [info, null]
+        },
+        Open(_name: string): [File, $.GoError] {
+          throw new Error('StatFS path should not open')
+        },
+      },
+      'pkg',
+    )
+
+    expect(err).toBeNull()
+    expect(got).toBe(info)
+  })
+
+  it('awaits async Open, File.Stat, and Close fallback implementations', async () => {
+    const info = fileInfo('file.txt')
+    let closed = false
+    const file: File = {
+      async Close(): Promise<$.GoError> {
+        closed = true
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      async Stat(): Promise<[FileInfo, $.GoError]> {
+        expect(closed).toBe(false)
+        return [info, null]
+      },
+    } as unknown as File
+
+    const [got, err] = await Stat(
+      {
+        async Open(_name: string): Promise<[File, $.GoError]> {
+          return [file, null]
+        },
+      } as any,
+      'file.txt',
+    )
+
+    expect(err).toBeNull()
+    expect(got).toBe(info)
+    expect(closed).toBe(true)
+  })
+})

package/gs/io/fs/stat.ts

@@ -1,14 +1,25 @@
 import * as $ from '@goscript/builtin/index.js'
-import { FS, FileInfo } from './fs.js'
+import { FS, File, FileInfo } from './fs.js'
+
+type maybePromise<T> = T | Promise<T>
 
 export type StatFS =
   | null
   | ({
       // Stat returns a FileInfo describing the file.
       // If there is an error, it should be of type *PathError.
-      Stat(name: string): [FileInfo, $.GoError]
+      Stat(name: string): maybePromise<[FileInfo, $.GoError]>
     } & FS)
 
+type asyncFS = null | {
+  Open(name: string): maybePromise<[File, $.GoError]>
+}
+
+type asyncFile = null | {
+  Close(): maybePromise<$.GoError>
+  Stat(): maybePromise<[FileInfo, $.GoError]>
+}
+
 $.registerInterfaceType(
   'StatFS',
   null, // Zero value for interface is null
@@ -42,21 +53,24 @@ $.registerInterfaceType(
 //
 // If fs implements [StatFS], Stat calls fs.Stat.
 // Otherwise, Stat opens the [File] to stat it.
-export function Stat(fsys: FS, name: string): [FileInfo, $.GoError] {
-  using __defer = new $.DisposableStack()
+export async function Stat(
+  fsys: FS,
+  name: string,
+): Promise<[FileInfo, $.GoError]> {
   {
     let { value: fsysTyped, ok: ok } = $.typeAssert<StatFS>(fsys, 'StatFS')
     if (ok) {
-      return fsysTyped!.Stat(name)
+      return await fsysTyped!.Stat(name)
     }
   }
 
-  let [file, err] = fsys!.Open(name)
+  let [file, err] = await (fsys as asyncFS)!.Open(name)
   if (err != null) {
     return [null, err]
   }
-  __defer.defer(() => {
-    file!.Close()
-  })
-  return file!.Stat()
+  try {
+    return await (file as asyncFile)!.Stat()
+  } finally {
+    await (file as asyncFile)!.Close()
+  }
 }

package/gs/io/fs/sub.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { File, FileInfo, Sub, Stat } from './index.js'
+
+function fileInfo(name: string, isDir = false): FileInfo {
+  return {
+    IsDir(): boolean {
+      return isDir
+    },
+    ModTime(): any {
+      return null
+    },
+    Mode(): number {
+      return isDir ? 0o040000 : 0
+    },
+    Name(): string {
+      return name
+    },
+    Size(): number {
+      return 0
+    },
+    Sys(): null {
+      return null
+    },
+  }
+}
+
+describe('io/fs Sub override', () => {
+  it('preserves the backing filesystem and directory in fallback subFS', async () => {
+    const opened: string[] = []
+    const dirInfo = fileInfo('pkg', true)
+    const file: File = {
+      async Close(): Promise<$.GoError> {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      async Stat(): Promise<[FileInfo, $.GoError]> {
+        return [dirInfo, null]
+      },
+    } as unknown as File
+
+    const [sub, subErr] = await Sub(
+      {
+        async Open(name: string): Promise<[File, $.GoError]> {
+          opened.push(name)
+          return [file, null]
+        },
+      } as any,
+      'pkg',
+    )
+    expect(subErr).toBeNull()
+
+    const [got, statErr] = await Stat(sub, '.')
+    expect(statErr).toBeNull()
+    expect(got).toBe(dirInfo)
+    expect(opened).toEqual(['pkg'])
+  })
+
+  it('joins nested fallback subFS directories', async () => {
+    const opened: string[] = []
+    const fileInfoValue = fileInfo('index.js')
+    const file: File = {
+      async Close(): Promise<$.GoError> {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      async Stat(): Promise<[FileInfo, $.GoError]> {
+        return [fileInfoValue, null]
+      },
+    } as unknown as File
+
+    const backingFS = {
+      async Open(name: string): Promise<[File, $.GoError]> {
+        opened.push(name)
+        return [file, null]
+      },
+    } as any
+    const [pkgFS, pkgErr] = await Sub(backingFS, '@scope')
+    expect(pkgErr).toBeNull()
+    const [clientFS, clientErr] = await Sub(pkgFS, 'client')
+    expect(clientErr).toBeNull()
+
+    const [got, statErr] = await Stat(clientFS, 'index.js')
+    expect(statErr).toBeNull()
+    expect(got).toBe(fileInfoValue)
+    expect(opened).toEqual(['@scope/client/index.js'])
+  })
+})

package/gs/io/fs/sub.ts

@@ -12,7 +12,7 @@ export type SubFS =
   | null
   | ({
       // Sub returns an FS corresponding to the subtree rooted at dir.
-      Sub(dir: string): [FS, $.GoError]
+      Sub(dir: string): [FS, $.GoError] | Promise<[FS, $.GoError]>
     } & FS)
 
 $.registerInterfaceType(
@@ -56,7 +56,7 @@ $.registerInterfaceType(
 // does not check for symbolic links inside "/prefix" that point to
 // other directories. That is, [os.DirFS] is not a general substitute for a
 // chroot-style security mechanism, and Sub does not change that fact.
-export function Sub(fsys: FS, dir: string): [FS, $.GoError] {
+export async function Sub(fsys: FS, dir: string): Promise<[FS, $.GoError]> {
   if (!ValidPath(dir)) {
     return [null, new PathError({ Err: ErrInvalid, Op: 'sub', Path: dir })]
   }
@@ -66,10 +66,10 @@ export function Sub(fsys: FS, dir: string): [FS, $.GoError] {
   {
     let { value: fsysTyped, ok: ok } = $.typeAssert<SubFS>(fsys, 'SubFS')
     if (ok) {
-      return fsysTyped!.Sub(dir)
+      return await fsysTyped!.Sub(dir)
     }
   }
-  return [new subFS({}), null]
+  return [new subFS({ fsys, dir }) as unknown as FS, null]
 }
 
 class subFS {
@@ -153,14 +153,14 @@ class subFS {
     return err
   }
 
-  public Open(name: string): [File, $.GoError] {
+  public async Open(name: string): Promise<[File, $.GoError]> {
     const f = this
     let [full, err] = f!.fullName('open', name)
     if (err != null) {
       return [null, err]
     }
     let file: File
-    ;[file, err] = f!.fsys!.Open(full)
+    ;[file, err] = await (f!.fsys as any)!.Open(full)
     return [file, f!.fixErr(err)]
   }
 
@@ -225,13 +225,13 @@ class subFS {
   public Sub(dir: string): [FS, $.GoError] {
     const f = this
     if (dir == '.') {
-      return [f, null]
+      return [f as unknown as FS, null]
     }
-    let [_full, err] = f!.fullName('sub', dir)
+    let [full, err] = f!.fullName('sub', dir)
     if (err != null) {
       return [null, err]
     }
-    return [new subFS({}), null]
+    return [new subFS({ fsys: f.fsys, dir: full }) as unknown as FS, null]
   }
 
   // Register this type with the runtime type system

package/gs/io/fs/walk.ts

@@ -88,7 +88,7 @@ export async function WalkDir(
   root: string,
   fn: WalkDirFunc,
 ): Promise<$.GoError> {
-  let [info, err] = Stat(fsys, root)
+  let [info, err] = await Stat(fsys, root)
   if (err != null) {
     err = await fn!(root, null, err)
   } else {

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

@@ -20,6 +20,7 @@ import {
   ErrServerClosed,
   File,
   FileServer,
+  FileServerFS,
   FileSystem,
   FS,
   Get,
@@ -192,6 +193,36 @@ describe('net/http override', () => {
     expect(protocols.String()).toBe('{HTTP1,UnencryptedHTTP2}')
   })
 
+  it('accepts pointer-wrapped headers from generated ResponseWriter methods', () => {
+    const header = varRef(new Header())
+
+    Header_Set(header, 'content-length', '12')
+    Header_Add(header, 'content-type', 'text/plain')
+
+    expect(Header_Get(header, 'Content-Length')).toBe('12')
+    expect(Array.from(Header_Values(header, 'Content-Type') ?? [])).toEqual([
+      'text/plain',
+    ])
+
+    const cloned = Header_Clone(header)
+    Header_Del(header, 'Content-Type')
+
+    expect(Header_Get(header, 'Content-Type')).toBe('')
+    expect(Header_Get(cloned, 'Content-Type')).toBe('text/plain')
+  })
+
+  it('accepts interface-boxed named headers from generated interface calls', () => {
+    const header = $.namedValueInterfaceValue(new Header(), 'http.Header', {})
+
+    Header_Set(header, 'content-length', '12')
+    Header_Add(header, 'content-type', 'text/plain')
+
+    expect(Header_Get(header, 'Content-Length')).toBe('12')
+    expect(Array.from(Header_Values(header, 'Content-Type') ?? [])).toEqual([
+      'text/plain',
+    ])
+  })
+
   it('validates outgoing request construction', () => {
     const [req, reqErr] = NewRequestWithContext(
       context.Background(),
@@ -1171,7 +1202,7 @@ describe('net/http override', () => {
     ])
   })
 
-  it('formats Set-Cookie headers for browser bootstrap routes', () => {
+  it('formats Set-Cookie headers for browser bootstrap routes', async () => {
     const header = new Header()
     const writer: ResponseWriter = {
       Header: () => header,
@@ -1179,7 +1210,7 @@ describe('net/http override', () => {
       WriteHeader: () => undefined,
     }
 
-    SetCookie(
+    await SetCookie(
       writer,
       new Cookie({
         Name: 'spacewave_local_capability',
@@ -1314,6 +1345,7 @@ describe('net/http override', () => {
     expect(opened).toEqual(['file.txt'])
     expect(writes).toEqual(['status:200', 'hello'])
     expect(Header_Get(header, 'Content-Length')).toBe('5')
+    expect(Header_Get(header, 'Content-Type')).toBe('text/plain; charset=utf-8')
 
     writes.length = 0
     opened.length = 0
@@ -1399,6 +1431,179 @@ describe('net/http override', () => {
     expect(closeCalls).toEqual(['async.txt'])
   })
 
+  it('serves files through FS adapters backed by async io/fs Open', async () => {
+    const opened: string[] = []
+    const root = {
+      async Open(name: string) {
+        opened.push(name)
+        const data = $.stringToBytes('fs-adapter')
+        let offset = 0
+        return [
+          {
+            Close: async () => null,
+            Read: async (p: $.Slice<number>) => {
+              if (offset >= data.length) {
+                return [0, io.EOF] as [number, $.GoError]
+              }
+              const n = Math.min(p?.length ?? 0, data.length - offset)
+              p?.set(data.subarray(offset, offset + n), 0)
+              offset += n
+              return [n, null] as [number, $.GoError]
+            },
+            Stat: async () => [
+              {
+                Name: () => name,
+                Size: () => data.length,
+                Mode: () => 0,
+                ModTime: () => new time.Time(),
+                IsDir: () => false,
+                Sys: () => null,
+              },
+              null,
+            ],
+          },
+          null,
+        ]
+      },
+    }
+    const writes: string[] = []
+    const header = new Header()
+    const writer: ResponseWriter = {
+      Header: () => header,
+      Write: (p) => {
+        writes.push(Buffer.from(p ?? []).toString('utf8'))
+        return [p?.length ?? 0, null]
+      },
+      WriteHeader: (code) => writes.push(`status:${code}`),
+    }
+    const [req] = NewRequest(
+      MethodGet,
+      'http://example.invalid/dir/fs-adapter.txt',
+      null,
+    )
+
+    await FileServerFS(root).ServeHTTP(writer, req)
+
+    expect(opened).toEqual(['dir/fs-adapter.txt'])
+    expect(writes).toEqual(['status:200', 'fs-adapter'])
+    expect(Header_Get(header, 'Content-Length')).toBe('10')
+  })
+
+  it('serves files through async response writer adapters', async () => {
+    const root = {
+      async Open(name: string) {
+        const data = $.stringToBytes('async-adapter')
+        return [
+          {
+            Read: (p: $.Slice<number>) => {
+              p?.set(data.subarray(0, p.length))
+              return [data.length, io.EOF] as [number, $.GoError]
+            },
+            Close: async () => null,
+            Stat: async () => [
+              {
+                Name: () => name,
+                Size: () => data.length,
+                Mode: () => 0,
+                ModTime: () => new time.Time(),
+                IsDir: () => false,
+                Sys: () => null,
+              },
+              null,
+            ],
+          },
+          null,
+        ] as [File, $.GoError]
+      },
+    }
+    const writes: string[] = []
+    const header = new Header()
+    const writer: ResponseWriter = {
+      Header: async () => header,
+      Write: async (p) => {
+        writes.push(Buffer.from(p ?? []).toString('utf8'))
+        return [p?.length ?? 0, null]
+      },
+      WriteHeader: async (code) => {
+        writes.push(`status:${code}`)
+      },
+    }
+    const [req] = NewRequest(
+      MethodGet,
+      'http://example.invalid/async-adapter.txt',
+      null,
+    )
+
+    await FileServer(root).ServeHTTP(writer, req)
+
+    expect(writes).toEqual(['status:200', 'async-adapter'])
+    expect(Header_Get(header, 'Content-Length')).toBe('13')
+  })
+
+  it('writes file server headers before reading response bodies', async () => {
+    let headerWritten = false
+    let readSawHeader = false
+    let offset = 0
+    const data = $.stringToBytes('streamed-body')
+    const root = {
+      async Open(name: string) {
+        return [
+          {
+            Close: async () => null,
+            Read: async (p: $.Slice<number>) => {
+              readSawHeader = headerWritten
+              if (offset >= data.length) {
+                return [0, io.EOF] as [number, $.GoError]
+              }
+              const n = Math.min(p?.length ?? 0, data.length - offset)
+              p?.set(data.subarray(offset, offset + n), 0)
+              offset += n
+              return [n, null] as [number, $.GoError]
+            },
+            Seek: async () => [0, null] as [number, $.GoError],
+            Readdir: async () => [null, null] as [null, $.GoError],
+            Stat: async () => [
+              {
+                Name: () => name,
+                Size: () => data.length,
+                Mode: () => 0,
+                ModTime: () => null as never,
+                IsDir: () => false,
+                Sys: () => null,
+              },
+              null,
+            ],
+          },
+          null,
+        ] as [File, $.GoError]
+      },
+    }
+    const writes: string[] = []
+    const header = new Header()
+    const writer: ResponseWriter = {
+      Header: () => header,
+      Write: (p) => {
+        writes.push(Buffer.from(p ?? []).toString('utf8'))
+        return [p?.length ?? 0, null]
+      },
+      WriteHeader: (code) => {
+        headerWritten = true
+        writes.push(`status:${code}`)
+      },
+    }
+    const [req] = NewRequest(
+      MethodGet,
+      'http://example.invalid/streamed.mjs',
+      null,
+    )
+
+    await FileServer(root).ServeHTTP(writer, req)
+
+    expect(readSawHeader).toBe(true)
+    expect(writes).toEqual(['status:200', 'streamed-body'])
+    expect(Header_Get(header, 'Content-Type')).toBe('text/javascript; charset=utf-8')
+  })
+
   it('awaits ServeContent writes before returning', async () => {
     const writes: string[] = []
     const writer: ResponseWriter = {