goscript 0.2.4 → 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/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)
+    }
   })
 })