goscript 0.2.3 → 0.2.4

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 = {

package/gs/net/http/index.ts

@@ -4,6 +4,8 @@ import * as context from '@goscript/context/index.js'
 import * as errors from '@goscript/errors/index.js'
 import * as fs from '@goscript/io/fs/fs.js'
 import * as io from '@goscript/io/index.js'
+import * as mime from '@goscript/mime/index.js'
+import * as path from '@goscript/path/index.js'
 import * as strings from '@goscript/strings/index.js'
 import * as time from '@goscript/time/index.js'
 
@@ -248,6 +250,8 @@ export function StatusText(code: number): string {
 }
 
 export type Header = Map<string, $.Slice<string>>
+type HeaderBox = { __goValue: HeaderValue }
+type HeaderValue = Header | $.VarRef<Header> | HeaderBox
 
 export const Header = Map as {
   new (entries?: Iterable<readonly [string, $.Slice<string>]> | null): Header
@@ -257,48 +261,62 @@ export function CanonicalHeaderKey(s: string): string {
   return canonicalMIMEHeaderKey(s)
 }
 
-export function Header_Add(h: Header, key: string, value: string): void {
+function headerMap(h: HeaderValue): Header {
+  let value: unknown = $.pointerValue(h as Header | $.VarRef<Header>)
+  while (
+    value !== null &&
+    value !== undefined &&
+    typeof value === 'object' &&
+    '__goValue' in value
+  ) {
+    value = $.pointerValue((value as HeaderBox).__goValue)
+  }
+  return value as Header
+}
+
+export function Header_Add(h: HeaderValue, key: string, value: string): void {
+  const headers = headerMap(h)
   key = canonicalMIMEHeaderKey(key)
-  const values = Array.from(h.get(key) ?? [])
+  const values = Array.from(headers.get(key) ?? [])
   values.push(value)
-  h.set(key, $.arrayToSlice(values))
+  headers.set(key, $.arrayToSlice(values))
 }
 
-export function Header_Del(h: Header, key: string): void {
-  h.delete(canonicalMIMEHeaderKey(key))
+export function Header_Del(h: HeaderValue, key: string): void {
+  headerMap(h).delete(canonicalMIMEHeaderKey(key))
 }
 
-export function Header_Get(h: Header, key: string): string {
-  const values = h.get(canonicalMIMEHeaderKey(key))
+export function Header_Get(h: HeaderValue, key: string): string {
+  const values = headerMap(h).get(canonicalMIMEHeaderKey(key))
   return values == null || values.length === 0 ? '' : String(values[0])
 }
 
-export function Header_Set(h: Header, key: string, value: string): void {
-  h.set(canonicalMIMEHeaderKey(key), $.arrayToSlice([value]))
+export function Header_Set(h: HeaderValue, key: string, value: string): void {
+  headerMap(h).set(canonicalMIMEHeaderKey(key), $.arrayToSlice([value]))
 }
 
-export function Header_Values(h: Header, key: string): $.Slice<string> {
-  return h.get(canonicalMIMEHeaderKey(key)) ?? null
+export function Header_Values(h: HeaderValue, key: string): $.Slice<string> {
+  return headerMap(h).get(canonicalMIMEHeaderKey(key)) ?? null
 }
 
-export function Header_Clone(h: Header): Header {
+export function Header_Clone(h: HeaderValue): Header {
   const cloned = new Header()
-  for (const [key, values] of h.entries()) {
+  for (const [key, values] of headerMap(h).entries()) {
     cloned.set(key, $.arrayToSlice(Array.from(values ?? [])))
   }
   return cloned
 }
 
-export function Header_Write(h: Header, w: io.Writer): $.GoError {
+export function Header_Write(h: HeaderValue, w: io.Writer): $.GoError {
   return Header_WriteSubset(h, w, null)
 }
 
 export function Header_WriteSubset(
-  h: Header,
+  h: HeaderValue,
   w: io.Writer,
   exclude: Map<string, boolean> | null,
 ): $.GoError {
-  for (const [key, values] of h.entries()) {
+  for (const [key, values] of headerMap(h).entries()) {
     if (exclude?.get(key) === true) {
       continue
     }
@@ -615,15 +633,15 @@ function asciiLower(value: string): [string, boolean] {
   return [value.toLowerCase(), true]
 }
 
-export function SetCookie(
+export async function SetCookie(
   w: ResponseWriter | null,
   cookie: Cookie | $.VarRef<Cookie> | null,
-): void {
+): Promise<void> {
   const c = $.pointerValue<Cookie | null>(cookie)
   if (w == null || c == null) {
     return
   }
-  Header_Add(w.Header(), 'Set-Cookie', c.String())
+  Header_Add(await w.Header(), 'Set-Cookie', c.String())
 }
 
 class memoryResponseWriter implements ResponseWriter {
@@ -694,9 +712,9 @@ function inProcessServerRequest(request: Request): Request {
 }
 
 export interface ResponseWriter {
-  Header(): Header
-  Write(p: $.Slice<number>): [number, $.GoError]
-  WriteHeader(statusCode: number): void
+  Header(): Header | Promise<Header>
+  Write(p: $.Slice<number>): [number, $.GoError] | Promise<[number, $.GoError]>
+  WriteHeader(statusCode: number): void | Promise<void>
 }
 
 export class Request {
@@ -1491,7 +1509,7 @@ async function readFetchBody(
 type maybePromise<T> = T | Promise<T>
 
 export interface FileSystem {
-  Open(name: string): [File | null, $.GoError]
+  Open(name: string): maybePromise<[File | null, $.GoError]>
 }
 
 export interface File extends io.Closer, io.Reader, io.Seeker {
@@ -1513,9 +1531,9 @@ interface fileServerFile {
 
 export function FS(fsys: fs.FS): FileSystem {
   return {
-    Open(name: string): [File | null, $.GoError] {
+    async Open(name: string): Promise<[File | null, $.GoError]> {
       const cleaned = cleanFileServerPath(name)
-      const [file, err] = fsys?.Open(cleaned) ?? [null, fs.ErrInvalid]
+      const [file, err] = (await fsys?.Open(cleaned)) ?? [null, fs.ErrInvalid]
       if (err != null || file == null) {
         return [null, err]
       }
@@ -1570,17 +1588,27 @@ export function FileServer(root: fileServerFileSystem | null): Handler {
           NotFound(w, req)
           return
         }
-        const [data, readErr] = await io.ReadAll(file as io.Reader)
-        if (readErr != null) {
-          Error(w, readErr.Error(), StatusInternalServerError)
-          return
+        const header = await w.Header()
+        if (Header_Get(header, 'Content-Type') === '') {
+          const contentType = mime.TypeByExtension(
+            path.Ext(info?.Name?.() || req.URL?.Path || ''),
+          )
+          if (contentType !== '') {
+            Header_Set(header, 'Content-Type', contentType)
+          }
         }
         if (info?.Size != null) {
-          Header_Set(w.Header(), 'Content-Length', String(info.Size()))
+          Header_Set(header, 'Content-Length', String(info.Size()))
         }
-        w.WriteHeader(StatusOK)
+        await w.WriteHeader(StatusOK)
         if (req.Method !== MethodHead) {
-          w.Write(data)
+          const [, copyErr] = await io.Copy(
+            w as unknown as io.Writer,
+            file as io.Reader,
+          )
+          if (copyErr != null) {
+            return
+          }
         }
       } finally {
         await file.Close()
@@ -2131,7 +2159,7 @@ export function NotFoundHandler(): Handler {
 export function RedirectHandler(url: string, code: number): Handler {
   return {
     ServeHTTP(w, r) {
-      Redirect(w, r, url, code)
+      return Redirect(w, r, url, code)
     },
   }
 }
@@ -2168,17 +2196,20 @@ export function NotFound(
   Error(w, '404 page not found', StatusNotFound)
 }
 
-export function Redirect(
+export async function Redirect(
   w: ResponseWriter | null,
   _r: Request | $.VarRef<Request> | null,
   url: string,
   code: number,
-): void {
-  const header = w?.Header()
+): Promise<void> {
+  if (w == null) {
+    return
+  }
+  const header = await w.Header()
   if (header != null) {
     Header_Set(header, 'Location', url)
   }
-  w?.WriteHeader(code)
+  await w.WriteHeader(code)
 }
 
 export function ParseTime(text: string): [time.Time, $.GoError] {

package/gs/net/http/meta.json

@@ -4,7 +4,9 @@
     "Head": true,
     "Post": true,
     "PostForm": true,
-    "ServeContent": true
+    "Redirect": true,
+    "ServeContent": true,
+    "SetCookie": true
   },
   "asyncMethods": {
     "Client.Do": true,

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

@@ -27,19 +27,19 @@ class writer implements ResponseWriter {
 }
 
 describe('net/http/pprof override', () => {
-  it('serves the index text expected by debug handlers', () => {
+  it('serves the index text expected by debug handlers', async () => {
     const w = new writer()
 
-    Index(w, null)
+    await Index(w, null)
 
     expect(Header_Get(w.Header(), 'Content-Type')).toContain('text/html')
     expect(w.String()).toContain('full goroutine stack dump')
   })
 
-  it('serves named runtime profiles', () => {
+  it('serves named runtime profiles', async () => {
     const w = new writer()
 
-    Handler('goroutine').ServeHTTP(w, null)
+    await Handler('goroutine').ServeHTTP(w, null)
 
     expect(Header_Get(w.Header(), 'Content-Type')).toContain('text/plain')
     expect(w.String()).toContain('goroutine profile')

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

@@ -2,82 +2,85 @@ import * as $ from '@goscript/builtin/index.js'
 import * as http from '@goscript/net/http/index.js'
 import * as pprof from '@goscript/runtime/pprof/index.js'
 
-function writeString(w: http.ResponseWriter | null, value: string): void {
-  w?.Write($.stringToBytes(value))
+async function writeString(
+  w: http.ResponseWriter | null,
+  value: string,
+): Promise<void> {
+  await w?.Write($.stringToBytes(value))
 }
 
-export function Index(
+export async function Index(
   w: http.ResponseWriter | null,
   _r: http.Request | $.VarRef<http.Request> | null,
-): void {
-  const header = w?.Header()
+): Promise<void> {
+  const header = await w?.Header()
   if (header != null) {
     http.Header_Set(header, 'Content-Type', 'text/html; charset=utf-8')
   }
-  writeString(
+  await writeString(
     w,
     '<html><body><a href="goroutine?debug=2">full goroutine stack dump</a></body></html>',
   )
 }
 
-export function Cmdline(
+export async function Cmdline(
   w: http.ResponseWriter | null,
   _r: http.Request | $.VarRef<http.Request> | null,
-): void {
-  const header = w?.Header()
+): Promise<void> {
+  const header = await w?.Header()
   if (header != null) {
     http.Header_Set(header, 'Content-Type', 'text/plain; charset=utf-8')
   }
-  writeString(w, 'goscript')
+  await writeString(w, 'goscript')
 }
 
-export function Profile(
+export async function Profile(
   w: http.ResponseWriter | null,
   _r: http.Request | $.VarRef<http.Request> | null,
-): void {
-  const header = w?.Header()
+): Promise<void> {
+  const header = await w?.Header()
   if (header != null) {
     http.Header_Set(header, 'Content-Type', 'application/octet-stream')
   }
-  writeString(w, 'cpu profile\n')
+  await writeString(w, 'cpu profile\n')
 }
 
-export function Symbol(
+export async function Symbol(
   w: http.ResponseWriter | null,
   _r: http.Request | $.VarRef<http.Request> | null,
-): void {
-  const header = w?.Header()
+): Promise<void> {
+  const header = await w?.Header()
   if (header != null) {
     http.Header_Set(header, 'Content-Type', 'text/plain; charset=utf-8')
   }
-  writeString(w, 'num_symbols: 0\n')
+  await writeString(w, 'num_symbols: 0\n')
 }
 
-export function Trace(
+export async function Trace(
   w: http.ResponseWriter | null,
   _r: http.Request | $.VarRef<http.Request> | null,
-): void {
-  const header = w?.Header()
+): Promise<void> {
+  const header = await w?.Header()
   if (header != null) {
     http.Header_Set(header, 'Content-Type', 'application/octet-stream')
   }
-  writeString(w, 'trace\n')
+  await writeString(w, 'trace\n')
 }
 
 export function Handler(name: string): http.Handler {
   return {
-    ServeHTTP(w) {
-      const header = w?.Header()
+    async ServeHTTP(w) {
+      const header = await w?.Header()
       if (header != null) {
         http.Header_Set(header, 'Content-Type', 'text/plain; charset=utf-8')
       }
       const profile = pprof.Lookup(name)
       if (profile == null) {
-        http.NotFound(w, null)
+        await http.NotFound(w, null)
         return
       }
-      writeString(w, `${name} profile\n`)
-      profile.WriteTo(w, 1)
+      await writeString(w, `${name} profile\n`)
+      profile.WriteTo(w as unknown as any, 1)
     },
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",