goscript 0.2.3 → 0.2.5

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/gs/runtime/runtime.test.ts

@@ -1,8 +1,12 @@
 import { describe, expect, it } from 'vitest'
 
+import * as $ from '@goscript/builtin/index.js'
+
 import {
   Compiler,
   FuncForPC,
+  MemStats,
+  ReadMemStats,
   ReadTrace,
   SetFinalizer,
   StartTrace,
@@ -25,4 +29,16 @@ describe('runtime override', () => {
     expect(() => SetFinalizer(obj, () => {})).not.toThrow()
     expect(() => SetFinalizer(obj, null)).not.toThrow()
   })
+
+  it('exposes heap and stack MemStats fields', () => {
+    const stats = new MemStats()
+
+    ReadMemStats($.varRef(stats))
+
+    expect(stats.HeapAlloc).toBe(stats.Alloc)
+    expect(stats.HeapSys).toBe(stats.Sys)
+    expect(stats.HeapInuse).toBe(stats.Alloc)
+    expect(stats.StackInuse).toBe(0)
+    expect(stats.StackSys).toBe(0)
+  })
 })

package/gs/runtime/runtime.ts

@@ -170,6 +170,11 @@ export class MemStats {
   public Alloc: number = 0 // bytes allocated and not yet freed
   public TotalAlloc: number = 0 // bytes allocated (even if freed)
   public Sys: number = 0 // bytes obtained from system
+  public HeapAlloc: number = 0 // bytes allocated and not yet freed on the heap
+  public HeapSys: number = 0 // bytes obtained from system for the heap
+  public HeapInuse: number = 0 // bytes in in-use heap spans
+  public StackInuse: number = 0 // bytes in stack spans
+  public StackSys: number = 0 // bytes obtained from system for stacks
   public Lookups: number = 0 // number of pointer lookups
   public Mallocs: number = 0 // number of mallocs
   public Frees: number = 0 // number of frees
@@ -181,25 +186,28 @@ export class MemStats {
   }
 
   private updateMemoryStats(): void {
-    // Use performance.memory if available (Chrome/Edge)
-    if (typeof performance !== 'undefined' && (performance as any).memory) {
-      const mem = (performance as any).memory
-      this.Alloc = mem.usedJSHeapSize || 0
-      this.Sys = mem.totalJSHeapSize || 0
-      this.TotalAlloc = this.Alloc // Simplified
-    }
+    updateMemoryStats(this)
   }
 }
 
 // ReadMemStats populates m with memory allocator statistics
-export function ReadMemStats(m: MemStats): void {
-  // Update the provided MemStats object with current values
+export function ReadMemStats(m: MemStats | $.VarRef<MemStats> | null): void {
+  m = $.pointerValue<MemStats>(m)
+  updateMemoryStats(m)
+}
+
+function updateMemoryStats(m: MemStats): void {
   if (typeof performance !== 'undefined' && (performance as any).memory) {
     const mem = (performance as any).memory
     m.Alloc = mem.usedJSHeapSize || 0
     m.Sys = mem.totalJSHeapSize || 0
     m.TotalAlloc = m.Alloc // Simplified
   }
+  m.HeapAlloc = m.Alloc
+  m.HeapSys = m.Sys
+  m.HeapInuse = m.Alloc
+  m.StackInuse = 0
+  m.StackSys = 0
 }
 
 // Error interface for runtime errors

package/gs/runtime/trace/index.test.ts

@@ -12,8 +12,69 @@ import {
   WithRegion,
 } from './index.js'
 
+function captureWriter(): { chunks: Uint8Array[]; bytes(): Uint8Array } {
+  const chunks: Uint8Array[] = []
+  return {
+    chunks,
+    bytes(): Uint8Array {
+      const total = chunks.reduce((n, c) => n + c.length, 0)
+      const out = new Uint8Array(total)
+      let off = 0
+      for (const c of chunks) {
+        out.set(c, off)
+        off += c.length
+      }
+      return out
+    },
+  }
+}
+
+const writerOf = (chunks: Uint8Array[]) => ({
+  Write(p: Uint8Array): [number, null] {
+    chunks.push(new Uint8Array(p))
+    return [p.length, null]
+  },
+})
+
+// maxBatchSize mirrors the trace v2 reader limit (tracev2.MaxBatchSize, 64<<10).
+// A batch whose declared data length exceeds this is rejected with "invalid
+// batch size", so the encoder must split large captures across batches.
+const maxBatchSize = 64 * 1024
+
+// batchSizes walks the trace v2 stream past the 16-byte header and returns the
+// declared data length of every EvEventBatch frame. Each frame is the batch
+// kind byte (1), then uvarints for generation, M id, base timestamp, and data
+// length, then the data block.
+function batchSizes(bytes: Uint8Array): number[] {
+  const sizes: number[] = []
+  let i = 16 // header: "go 1.22 trace\x00\x00\x00"
+  const readUvarint = (): number => {
+    let value = 0
+    let shift = 0
+    for (;;) {
+      const b = bytes[i++]
+      value += (b & 0x7f) * 2 ** shift
+      if ((b & 0x80) === 0) {
+        break
+      }
+      shift += 7
+    }
+    return value
+  }
+  while (i < bytes.length) {
+    i++ // EvEventBatch kind byte
+    readUvarint() // generation
+    readUvarint() // M id
+    readUvarint() // base timestamp
+    const size = readUvarint()
+    sizes.push(size)
+    i += size
+  }
+  return sizes
+}
+
 describe('runtime/trace override', () => {
-  it('creates no-op tasks from nil context', () => {
+  it('creates no-op tasks when tracing is disabled', () => {
     const [ctx, task] = NewTask(null, 'task')
 
     expect(ctx).not.toBeNull()
@@ -23,7 +84,7 @@ describe('runtime/trace override', () => {
     expect(IsEnabled()).toBe(false)
   })
 
-  it('runs no-op regions', () => {
+  it('runs regions', () => {
     const [ctx] = NewTask(context.Background(), 'task')
     const called = { value: false }
 
@@ -35,21 +96,59 @@ describe('runtime/trace override', () => {
     expect(called.value).toBe(true)
   })
 
-  it('reports execution tracing as unsupported', () => {
-    const chunks: Uint8Array[] = []
-    const writer = {
-      Write(p: Uint8Array): [number, null] {
-        chunks.push(new Uint8Array(p))
-        return [p.length, null]
-      },
+  it('rejects a nil trace writer', () => {
+    expect(Start(null)?.Error()).toBe('runtime/trace: nil trace writer')
+  })
+
+  it('emits a trace v2 stream for user tasks', () => {
+    const capture = captureWriter()
+
+    expect(Start(writerOf(capture.chunks))).toBeNull()
+    expect(IsEnabled()).toBe(true)
+
+    const [ctx, task] = NewTask(context.Background(), 'proof-task')
+    WithRegion(ctx, 'proof-region', () => {
+      Log(ctx, 'proof-key', 'proof-value')
+    })
+    task.End()
+
+    Stop()
+    expect(IsEnabled()).toBe(false)
+
+    const bytes = capture.bytes()
+    expect(bytes.length).toBeGreaterThan(0)
+
+    const header = new TextDecoder().decode(bytes.slice(0, 13))
+    expect(header).toBe('go 1.22 trace')
+
+    // The interned task and region names appear in the string batch.
+    const text = new TextDecoder('latin1').decode(bytes)
+    expect(text).toContain('proof-task')
+    expect(text).toContain('proof-region')
+    expect(text).toContain('proof-value')
+  })
+
+  it('splits a large capture into batches under the size limit', () => {
+    const capture = captureWriter()
+
+    expect(Start(writerOf(capture.chunks))).toBeNull()
+
+    // Record enough distinct tasks and logs to overflow the single-batch ceiling
+    // in both the string dictionary and the event stream.
+    const eventCount = 4000
+    for (let i = 0; i < eventCount; i++) {
+      const [ctx, task] = NewTask(context.Background(), `multibatch-task-${i}`)
+      Log(ctx, 'multibatch-key', `multibatch-message-${i}`)
+      task.End()
     }
 
-    expect(Start(writer)?.Error()).toBe(
-      'runtime/trace: execution tracing is unsupported in GoScript',
-    )
-    Log(context.Background(), 'category', 'message')
     Stop()
 
-    expect(chunks).toHaveLength(0)
+    const sizes = batchSizes(capture.bytes())
+    // Frequency, plus several string and event batches.
+    expect(sizes.length).toBeGreaterThan(3)
+    for (const size of sizes) {
+      expect(size).toBeLessThanOrEqual(maxBatchSize)
+    }
   })
 })