goscript 0.1.0 → 0.1.2

package/gs/compress/zlib/index.ts

@@ -0,0 +1,200 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import * as io from '@goscript/io/index.js'
+
+export type Resetter = {
+  Reset(r: io.Reader | null, dict: $.Bytes | null): Promise<$.GoError>
+}
+
+export let ErrChecksum = errors.New('zlib: invalid checksum')
+export let ErrDictionary = errors.New('zlib: invalid dictionary')
+export let ErrHeader = errors.New('zlib: invalid header')
+
+export function __goscript_set_ErrChecksum(value: $.GoError): void {
+  ErrChecksum = value
+}
+
+export function __goscript_set_ErrDictionary(value: $.GoError): void {
+  ErrDictionary = value
+}
+
+export function __goscript_set_ErrHeader(value: $.GoError): void {
+  ErrHeader = value
+}
+
+class zlibReader implements io.ReadCloser {
+  private offset = 0
+
+  constructor(private data: Uint8Array) {}
+
+  Read(p: $.Bytes): [number, $.GoError] {
+    if (this.offset >= this.data.length) {
+      return [0, io.EOF]
+    }
+    const out = $.bytesToUint8Array(p)
+    const n = Math.min(out.length, this.data.length - this.offset)
+    out.set(this.data.subarray(this.offset, this.offset + n))
+    this.offset += n
+    return [n, null]
+  }
+
+  Close(): $.GoError {
+    return null
+  }
+}
+
+export class Writer {
+  private chunks: Uint8Array[] = []
+  private closed = false
+
+  constructor(private w: io.Writer | null) {}
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    if (this.closed) {
+      return [0, errors.New('zlib: writer closed')]
+    }
+    const data = $.bytesToUint8Array(p)
+    this.chunks.push(data.slice())
+    return [data.length, null]
+  }
+
+  Close(): $.GoError {
+    if (this.closed) {
+      return null
+    }
+    this.closed = true
+    if (this.w == null) {
+      return errors.New('zlib: nil writer')
+    }
+    const compressed = deflate(concat(this.chunks))
+    const [, err] = this.w.Write(compressed)
+    return err
+  }
+
+  Flush(): $.GoError {
+    return null
+  }
+
+  Reset(w: io.Writer | null): void {
+    this.w = w
+    this.chunks = []
+    this.closed = false
+  }
+}
+
+export function NewWriter(w: io.Writer | null): Writer {
+  return new Writer(w)
+}
+
+export function NewWriterLevel(
+  w: io.Writer | null,
+  _level: number,
+): [Writer | null, $.GoError] {
+  return [new Writer(w), null]
+}
+
+export function NewWriterLevelDict(
+  w: io.Writer | null,
+  _level: number,
+  _dict: $.Bytes | null,
+): [Writer | null, $.GoError] {
+  return [new Writer(w), null]
+}
+
+export function NewReader(
+  r: io.Reader | null,
+): [io.ReadCloser | null, $.GoError] {
+  return NewReaderDict(r, null)
+}
+
+export function NewReaderDict(
+  r: io.Reader | null,
+  _dict: $.Bytes | null,
+): [io.ReadCloser | null, $.GoError] {
+  if (r == null) {
+    return [null, errors.New('zlib: nil reader')]
+  }
+  const [data, readErr] = readAll(r)
+  if (readErr != null) {
+    return [null, readErr]
+  }
+  try {
+    const out = inflate($.bytesToUint8Array(data))
+    return [new zlibReader(out), null]
+  } catch {
+    return [null, ErrHeader]
+  }
+}
+
+function deflate(data: Uint8Array): Uint8Array {
+  const zlib = nodeZlib()
+  return new Uint8Array(zlib.deflateSync(data))
+}
+
+function inflate(data: Uint8Array): Uint8Array {
+  const zlib = nodeZlib()
+  return new Uint8Array(zlib.inflateSync(data))
+}
+
+function nodeZlib(): any {
+  const processObj = (globalThis as any).process
+  if (processObj && typeof processObj.getBuiltinModule === 'function') {
+    const mod = processObj.getBuiltinModule('zlib')
+    if (mod && typeof mod.deflateSync === 'function') {
+      return mod
+    }
+  }
+  const requireFn = (() => {
+    try {
+      return Function(
+        "return typeof require !== 'undefined' ? require : null",
+      )() as ((specifier: string) => unknown) | null
+    } catch {
+      return null
+    }
+  })()
+  if (requireFn != null) {
+    for (const specifier of ['node:zlib', 'zlib']) {
+      try {
+        const mod = requireFn(specifier) as any
+        if (mod && typeof mod.deflateSync === 'function') {
+          return mod
+        }
+      } catch {
+        // Try the next fallback.
+      }
+    }
+  }
+  throw new Error('compress/zlib: node zlib module unavailable')
+}
+
+function readAll(r: io.Reader): [Uint8Array, $.GoError] {
+  const chunks: Uint8Array[] = []
+  const buf = $.makeSlice<number>(32 * 1024, undefined, 'byte')
+  while (true) {
+    const [n, err] = r.Read(buf)
+    if (n > 0) {
+      chunks.push($.bytesToUint8Array($.goSlice(buf, 0, n)).slice())
+    }
+    if (err != null) {
+      if (err === io.EOF) {
+        return [concat(chunks), null]
+      }
+      return [new Uint8Array(0), err]
+    }
+  }
+}
+
+function concat(chunks: Uint8Array[]): Uint8Array {
+  let total = 0
+  for (const chunk of chunks) {
+    total += chunk.length
+  }
+  const out = new Uint8Array(total)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}

package/gs/compress/zlib/meta.json

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

package/gs/context/context.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { AfterFunc, WithCancel, Background, WithValue } from './index.js'
+
+async function nextMicrotask(): Promise<void> {
+  await new Promise<void>((resolve) => queueMicrotask(resolve))
+}
+
+describe('context override', () => {
+  it('matches generated struct keys by Go comparable value', () => {
+    class Key {
+      public _fields: Record<string, $.VarRef<unknown>>
+
+      constructor() {
+        this._fields = {}
+      }
+    }
+
+    const ctx = WithValue(
+      Background(),
+      $.interfaceValue($.markAsStructValue(new Key()), 'example.key'),
+      'stored',
+    )
+
+    expect(
+      ctx.Value($.interfaceValue($.markAsStructValue(new Key()), 'example.key')),
+    ).toBe('stored')
+  })
+
+  it('runs AfterFunc after cancellation', async () => {
+    const [ctx, cancel] = WithCancel(Background())
+    let called = false
+
+    const stop = AfterFunc(ctx, () => {
+      called = true
+    })
+
+    cancel?.()
+    await nextMicrotask()
+    await nextMicrotask()
+
+    expect(called).toBe(true)
+    expect(stop()).toBe(false)
+  })
+
+  it('stops AfterFunc before cancellation', async () => {
+    const [ctx, cancel] = WithCancel(Background())
+    let called = false
+
+    const stop = AfterFunc(ctx, () => {
+      called = true
+    })
+
+    expect(stop()).toBe(true)
+    cancel?.()
+    await nextMicrotask()
+    await nextMicrotask()
+
+    expect(called).toBe(false)
+  })
+
+  it('accepts nil AfterFunc callbacks for type compatibility', () => {
+    const [ctx] = WithCancel(Background())
+
+    const stop = AfterFunc(ctx, null)
+
+    expect(stop()).toBe(true)
+  })
+})

package/gs/context/context.ts

@@ -1,17 +1,18 @@
 import * as $ from '@goscript/builtin/index.js'
+import * as time from '@goscript/time/index.js'
 
 export const Canceled = $.newError('context canceled')
 
 export const DeadlineExceeded = $.newError('context deadline exceeded')
 
 // Function types
-export type CancelFunc = () => void
+export type CancelFunc = (() => void) | null
 export type CancelCauseFunc = (cause: $.GoError) => void
 
 // Context interface matching Go's context.Context
 export type Context = null | {
   // Deadline returns the time when work done on behalf of this context should be canceled
-  Deadline(): [Date | null, boolean]
+  Deadline(): [time.Time, boolean]
 
   // Done returns a channel that's closed when work done on behalf of this context should be canceled
   Done(): $.Channel<{}>
@@ -28,7 +29,7 @@ export type ContextNonNil = Exclude<Context, null>
 
 // Base implementation for all contexts
 abstract class baseContext implements ContextNonNil {
-  abstract Deadline(): [Date | null, boolean]
+  abstract Deadline(): [time.Time, boolean]
   abstract Done(): $.Channel<{}>
   abstract Err(): $.GoError
   abstract Value(key: any): any
@@ -42,8 +43,8 @@ class backgroundContext extends baseContext {
     return backgroundContext.neverClosedChannel
   }
 
-  Deadline(): [Date | null, boolean] {
-    return [null, false]
+  Deadline(): [time.Time, boolean] {
+    return [new time.Time(), false]
   }
 
   Done(): $.Channel<{}> {
@@ -73,7 +74,7 @@ class valueContext extends baseContext {
     return this.parent
   }
 
-  Deadline(): [Date | null, boolean] {
+  Deadline(): [time.Time, boolean] {
     return this.parent.Deadline()
   }
 
@@ -86,7 +87,7 @@ class valueContext extends baseContext {
   }
 
   Value(key: any): any {
-    if (this.key === key) {
+    if (this.key === key || $.comparableEqual(this.key, key)) {
       return this.val
     }
     return this.parent.Value(key)
@@ -109,7 +110,7 @@ class cancelContext extends baseContext {
     this.doneChannel = $.makeChannel<{}>(0, {}, 'both')
   }
 
-  Deadline(): [Date | null, boolean] {
+  Deadline(): [time.Time, boolean] {
     return this.parent.Deadline()
   }
 
@@ -195,21 +196,20 @@ class cancelContext extends baseContext {
 
 // Timer context with deadline
 class timerContext extends cancelContext {
-  private deadline: Date
+  private deadline: time.Time
   private timer: any
 
-  constructor(parent: ContextNonNil, deadline: Date) {
+  constructor(parent: ContextNonNil, deadline: time.Time) {
     super(parent)
-    this.deadline = deadline
+    this.deadline = deadline.clone()
   }
 
-  Deadline(): [Date | null, boolean] {
-    return [this.deadline, true]
+  Deadline(): [time.Time, boolean] {
+    return [this.deadline.clone(), true]
   }
 
   startTimer(): void {
-    const now = Date.now()
-    const duration = this.deadline.getTime() - now
+    const duration = this.deadline.Sub(time.Now()) / 1000000
 
     if (duration <= 0) {
       // Already expired
@@ -237,8 +237,8 @@ class withoutCancelContext extends baseContext {
     super()
   }
 
-  Deadline(): [Date | null, boolean] {
-    return [null, false]
+  Deadline(): [time.Time, boolean] {
+    return [new time.Time(), false]
   }
 
   Done(): $.Channel<{}> {
@@ -305,7 +305,7 @@ export function WithCancelCause(
 // WithDeadline returns a copy of parent with the deadline adjusted to be no later than d
 export function WithDeadline(
   parent: Context,
-  d: Date,
+  d: time.Time,
 ): [ContextNonNil, CancelFunc] {
   return WithDeadlineCause(parent, d, null)
 }
@@ -313,7 +313,7 @@ export function WithDeadline(
 // WithDeadlineCause is like WithDeadline but also sets the cause
 export function WithDeadlineCause(
   parent: Context,
-  d: Date,
+  d: time.Time,
   cause: $.GoError,
 ): [ContextNonNil, CancelFunc] {
   if (parent === null) {
@@ -321,7 +321,7 @@ export function WithDeadlineCause(
   }
   // Check if parent deadline is already earlier
   const [parentDeadline, ok] = parent.Deadline()
-  if (ok && parentDeadline && parentDeadline <= d) {
+  if (ok && (parentDeadline.Before(d) || parentDeadline.Equal(d))) {
     // Parent deadline is already sooner
     return WithCancel(parent)
   }
@@ -343,7 +343,7 @@ export function WithTimeout(
   parent: Context,
   timeout: number,
 ): [ContextNonNil, CancelFunc] {
-  return WithDeadline(parent, new Date(Date.now() + timeout / 1000000))
+  return WithDeadline(parent, time.Now().Add(timeout))
 }
 
 // WithTimeoutCause is like WithTimeout but also sets the cause
@@ -352,11 +352,7 @@ export function WithTimeoutCause(
   timeout: number,
   cause: $.GoError,
 ): [ContextNonNil, CancelFunc] {
-  return WithDeadlineCause(
-    parent,
-    new Date(Date.now() + timeout / 1000000),
-    cause,
-  )
+  return WithDeadlineCause(parent, time.Now().Add(timeout), cause)
 }
 
 // WithValue returns a copy of parent with the value associated with key
@@ -392,8 +388,8 @@ export function Cause(ctx: Context): $.GoError {
   return c.Err()
 }
 
-// AfterFunc runs f in a separate goroutine after ctx is done
-export function AfterFunc(ctx: Context, f: () => void): () => boolean {
+// AfterFunc runs f in a separate goroutine after ctx is done.
+export function AfterFunc(ctx: Context, f: (() => void) | null): () => boolean {
   if (ctx === null) {
     throw new Error('cannot create context from nil parent')
   }
@@ -409,7 +405,12 @@ export function AfterFunc(ctx: Context, f: () => void): () => boolean {
     if (!stopped) {
       done = true
       // Run in next tick to simulate goroutine
-      setImmediate(f)
+      queueMicrotask(() => {
+        if (f === null) {
+          throw new Error('context: nil AfterFunc callback')
+        }
+        f()
+      })
     }
   })()
 

package/gs/crypto/ecdh/index.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+
+import { X25519 } from './index.js'
+
+describe('crypto/ecdh override', () => {
+  it('matches the RFC 7748 X25519 test vector', () => {
+    const curve = X25519()
+    const [alice, aliceErr] = curve.NewPrivateKey(
+      hex('77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a'),
+    )
+    const [bobPub, bobPubErr] = curve.NewPublicKey(
+      hex('de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f'),
+    )
+
+    expect(aliceErr).toBeNull()
+    expect(bobPubErr).toBeNull()
+    expect(toHex(alice!.PublicKey().Bytes())).toBe(
+      '8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a',
+    )
+
+    const [shared, sharedErr] = alice!.ECDH(bobPub)
+    expect(sharedErr).toBeNull()
+    expect(toHex(shared)).toBe(
+      '4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742',
+    )
+  })
+
+  it('rejects low-order remote points', () => {
+    const [priv] = X25519().NewPrivateKey(new Uint8Array(32).fill(7))
+    const [zero] = X25519().NewPublicKey(new Uint8Array(32))
+    const [, err] = priv!.ECDH(zero)
+
+    expect(err?.Error()).toContain('low order point')
+  })
+})
+
+function hex(value: string): Uint8Array {
+  return new Uint8Array(value.match(/../g)!.map((byte) => Number.parseInt(byte, 16)))
+}
+
+function toHex(value: Uint8Array | null): string {
+  return Array.from(value ?? [], (byte) => byte.toString(16).padStart(2, '0')).join('')
+}