goscript 0.2.0 → 0.2.2

package/gs/github.com/aperturerobotics/protobuf-go-lite/index.ts

@@ -345,6 +345,7 @@ export function EqualVTMapImplicit<K, V extends EqualVT<V>>(
 }
 
 type BoundMessageType = {
+  typeName?: string
   fields?: { list(): readonly BoundFieldInfo[] }
   clone?: (value: any) => any
   equals?: (a: any, b: any) => boolean
@@ -371,6 +372,8 @@ type BoundMessageCtor<T = any> = {
   __protobufTypeScriptMessage?: BoundMessageType
 }
 
+const protobufScalarTypeBytes = 12
+
 function boundMessageType(ctor: BoundMessageCtor): BoundMessageType {
   const messageType = ctor.__protobufTypeScriptMessage
   if (messageType == null) {
@@ -401,8 +404,16 @@ function boundFieldValue(source: any, field: BoundFieldInfo): any {
   return source[boundFieldGoName(field)]
 }
 
-function toTypeScriptScalarValue(value: any): any {
+function toTypeScriptScalarValue(value: any, field?: BoundFieldInfo): any {
   const unwrapped = $.pointerValueOrNil(value)
+  if (
+    field?.kind === 'scalar' &&
+    field.T === protobufScalarTypeBytes &&
+    unwrapped != null &&
+    !(unwrapped instanceof Uint8Array)
+  ) {
+    return Uint8Array.from($.asArray(unwrapped))
+  }
   if (unwrapped instanceof Uint8Array) {
     return unwrapped
   }
@@ -440,7 +451,7 @@ function toTypeScriptFieldValue(
     const messageType = resolveBoundMessageType(field.T)
     return toTypeScriptMessage(value, messageType, ctor)
   }
-  return toTypeScriptScalarValue(value)
+  return toTypeScriptScalarValue(value, field)
 }
 
 function toTypeScriptMessage(
@@ -520,6 +531,23 @@ function fromTypeScriptFieldValue(
   return fromTypeScriptScalarValue(value)
 }
 
+function fromTypeScriptWellKnownMessage(
+  value: any,
+  ctor: BoundMessageCtor,
+  messageType?: BoundMessageType,
+): any {
+  if (
+    messageType?.typeName === 'google.protobuf.Timestamp' &&
+    value instanceof Date
+  ) {
+    const ms = value.getTime()
+    const seconds = Math.floor(ms / 1000)
+    const nanos = Math.trunc((ms - seconds * 1000) * 1000000)
+    return new ctor({ Seconds: seconds, Nanos: nanos })
+  }
+  return undefined
+}
+
 function fromTypeScriptMessage(
   value: any,
   ctor: BoundMessageCtor,
@@ -528,6 +556,10 @@ function fromTypeScriptMessage(
   if (value == null) {
     return null
   }
+  const wellKnown = fromTypeScriptWellKnownMessage(value, ctor, messageType)
+  if (wellKnown !== undefined) {
+    return wellKnown
+  }
   const out = new ctor()
   const fields = (messageType ?? boundMessageType(ctor)).fields?.list()
   if (fields == null) {
@@ -579,14 +611,17 @@ export function MarshalBoundMessageVT<T>(
   ctor: BoundMessageCtor<T>,
   value: T | $.VarRef<T> | null,
 ): [$.Slice<number>, $.GoError] {
+  let typeName = ctor.name
   try {
     const messageType = boundMessageType(ctor)
+    typeName = messageType.typeName ?? typeName
     return [
       messageType.toBinary(toTypeScriptMessage(value, messageType, ctor)),
       null,
     ]
   } catch (err) {
-    return [null, $.toGoError(err as Error)]
+    const msg = err instanceof Error ? err.message : String(err)
+    return [null, $.toGoError(new Error(`marshal ${typeName}: ${msg}`))]
   }
 }
 
@@ -599,12 +634,13 @@ export function MarshalBoundMessageToSizedBufferVT<T>(
   if (err != null) {
     return [0, err]
   }
-  const offset = $.len(dAtA) - $.len(bytes)
+  const byteCount = $.len(bytes)
+  const offset = $.len(dAtA) - byteCount
   const src = $.asArray(bytes)
   for (let i = 0; i < src.length; i++) {
     ;(dAtA as any)[offset + i] = src[i]
   }
-  return [offset, null]
+  return [byteCount, null]
 }
 
 export function SizeBoundMessageVT<T>(

package/gs/github.com/aperturerobotics/protobuf-go-lite/json/index.test.ts

@@ -113,6 +113,24 @@ describe('protobuf-go-lite/json override', () => {
     ])
   })
 
+  it('matches jsoniter value types while reading object fields', () => {
+    const state = NewUnmarshalState(
+      jsonBytes('{"id":"step","config":{"kind":"inline"}}'),
+      DefaultUnmarshalerConfig,
+    )
+
+    expect(state?.ReadObjectField()).toBe('id')
+    expect(state?.WhatIsNext()).toBe(1)
+    expect(state?.ReadString()).toBe('step')
+    expect(state?.ReadObjectField()).toBe('config')
+    expect(state?.WhatIsNext()).toBe(6)
+    expect(
+      new TextDecoder().decode(new Uint8Array(state?.SkipAndReturnBytes())),
+    ).toBe('{"kind":"inline"}')
+    expect(state?.ReadObjectField()).toBe('')
+    expect(state?.Err()).toBeNull()
+  })
+
   it('tracks unmarshaled field masks through nested fields', () => {
     const state = NewUnmarshalState(jsonBytes('{}'), DefaultUnmarshalerConfig)
     state?.AddField('top')

package/gs/github.com/aperturerobotics/protobuf-go-lite/json/index.ts

@@ -423,6 +423,7 @@ export class UnmarshalState {
   private path: string[]
   private objectEntries: Array<[string, unknown]> | null = null
   private objectIndex = 0
+  private objectValue: unknown = undefined
 
   constructor(
     init?: Partial<{
@@ -612,16 +613,21 @@ export class UnmarshalState {
   }
 
   public ReadObjectField(): string {
-    const record = recordValue(this.value)
-    if (record == null) {
-      this.SetErrorf('expected JSON object')
-      return ''
-    }
     if (this.objectEntries == null) {
+      const record = recordValue(this.value)
+      if (record == null) {
+        this.SetErrorf('expected JSON object')
+        return ''
+      }
       this.objectEntries = Object.entries(record)
       this.objectIndex = 0
+      this.objectValue = this.value
     }
     if (this.objectIndex >= this.objectEntries.length) {
+      this.value = this.objectValue
+      this.objectEntries = null
+      this.objectIndex = 0
+      this.objectValue = undefined
       return ''
     }
     const [key, value] = this.objectEntries[this.objectIndex]
@@ -747,22 +753,22 @@ export class UnmarshalState {
 
   public WhatIsNext(): number {
     if (this.value === null) {
-      return 0
+      return 3
     }
     if (Array.isArray(this.value)) {
-      return 1
+      return 5
     }
     if (typeof this.value === 'object') {
-      return 2
+      return 6
     }
     if (typeof this.value === 'string') {
-      return 3
+      return 1
     }
     if (typeof this.value === 'number') {
-      return 4
+      return 2
     }
     if (typeof this.value === 'boolean') {
-      return 5
+      return 4
     }
     return 0
   }

package/gs/golang.org/x/crypto/chacha20poly1305/index.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, test } from 'vitest'
+
+import { New, NewX, NonceSize, NonceSizeX, Overhead } from './index.js'
+
+describe('chacha20poly1305 override', () => {
+  test('matches the RFC 8439 ChaCha20-Poly1305 AEAD vector', () => {
+    const [aead, err] = New(
+      hex('808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f'),
+    )
+    expect(err).toBeNull()
+    expect(aead?.NonceSize()).toBe(NonceSize)
+    expect(aead?.Overhead()).toBe(Overhead)
+
+    const nonce = hex('070000004041424344454647')
+    const aad = hex('50515253c0c1c2c3c4c5c6c7')
+    const plaintext = hex(
+      '4c616469657320616e642047656e746c656d656e206f662074686520636c617373206f66202739393a204966204920636f756c64206f6666657220796f75206f6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73637265656e20776f756c642062652069742e',
+    )
+    const sealed = aead!.Seal(null, nonce, plaintext, aad)
+    expect(toHex(sealed)).toBe(
+      'd31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5a736ee62d63dbea45e8ca9671282fafb69da92728b1a71de0a9e060b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fab324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d26586cec64b61161ae10b594f09e26a7e902ecbd0600691',
+    )
+
+    const [opened, openErr] = aead!.Open(null, nonce, sealed, aad)
+    expect(openErr).toBeNull()
+    expect(toHex(opened)).toBe(toHex(plaintext))
+  })
+
+  test('rejects tampered ciphertexts', () => {
+    const [aead, err] = New(
+      hex('000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f'),
+    )
+    expect(err).toBeNull()
+    const sealed = aead!.Seal(
+      null,
+      hex('000000000000000000000002'),
+      hex('68656c6c6f'),
+      null,
+    )
+    sealed![0] ^= 1
+
+    const [opened, openErr] = aead!.Open(
+      null,
+      hex('000000000000000000000002'),
+      sealed,
+      null,
+    )
+    expect(opened).toBeNull()
+    expect(openErr?.Error()).toBe(
+      'chacha20poly1305: message authentication failed',
+    )
+  })
+
+  test('round trips XChaCha20-Poly1305', () => {
+    const [aead, err] = NewX(
+      hex('1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0'),
+    )
+    expect(err).toBeNull()
+    expect(aead?.NonceSize()).toBe(NonceSizeX)
+    expect(aead?.Overhead()).toBe(Overhead)
+
+    const nonce = hex('000000000102030405060708090a0b0c0d0e0f1011121314')
+    const aad = hex('f33388860000000000004e91')
+    const plaintext = hex('496e7465726f70657261626c6520584368614368613230')
+    const sealed = aead!.Seal(null, nonce, plaintext, aad)
+
+    const [opened, openErr] = aead!.Open(null, nonce, sealed, aad)
+    expect(openErr).toBeNull()
+    expect(toHex(opened)).toBe(toHex(plaintext))
+  })
+
+  test('rejects invalid key length', () => {
+    const [aead, err] = New(new Uint8Array(31))
+    expect(aead).toBeNull()
+    expect(err?.Error()).toBe('chacha20poly1305: bad key length')
+  })
+})
+
+function hex(input: string): Uint8Array {
+  const out = new Uint8Array(input.length / 2)
+  for (let idx = 0; idx < out.length; idx++) {
+    out[idx] = Number.parseInt(input.slice(idx * 2, idx * 2 + 2), 16)
+  }
+  return out
+}
+
+function toHex(input: Uint8Array | number[] | null): string {
+  return Array.from(input ?? [])
+    .map((value) => value.toString(16).padStart(2, '0'))
+    .join('')
+}

package/gs/golang.org/x/crypto/chacha20poly1305/index.ts

@@ -0,0 +1,245 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import {
+  chacha20poly1305 as nobleChaCha20Poly1305,
+  xchacha20poly1305 as nobleXChaCha20Poly1305,
+} from '@noble/ciphers/chacha.js'
+
+export const KeySize = 32
+export const NonceSize = 12
+export const NonceSizeX = 24
+export const Overhead = 16
+
+const maxIETFPlaintext = 2 ** 38 - 64
+const maxIETFCiphertext = 2 ** 38 - 48
+
+type NobleAEAD = typeof nobleChaCha20Poly1305 | typeof nobleXChaCha20Poly1305
+
+export let errOpen: $.GoError = errors.New(
+  'chacha20poly1305: message authentication failed',
+)
+
+export function __goscript_set_errOpen(value: $.GoError): void {
+  errOpen = value
+}
+
+export interface AEAD {
+  NonceSize(): number
+  Overhead(): number
+  Seal(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    plaintext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): $.Slice<number>
+  Open(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    ciphertext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): [$.Slice<number>, $.GoError]
+}
+
+export class chacha20poly1305 implements AEAD {
+  readonly key: Uint8Array
+
+  constructor(key: Uint8Array) {
+    this.key = key.slice()
+  }
+
+  NonceSize(): number {
+    return NonceSize
+  }
+
+  Overhead(): number {
+    return Overhead
+  }
+
+  Seal(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    plaintext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): $.Slice<number> {
+    return seal(
+      dst,
+      nobleChaCha20Poly1305,
+      this.key,
+      nonce,
+      NonceSize,
+      plaintext,
+      additionalData,
+    )
+  }
+
+  Open(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    ciphertext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): [$.Slice<number>, $.GoError] {
+    return open(
+      dst,
+      nobleChaCha20Poly1305,
+      this.key,
+      nonce,
+      NonceSize,
+      ciphertext,
+      additionalData,
+    )
+  }
+}
+
+export class xchacha20poly1305 implements AEAD {
+  readonly key: Uint8Array
+
+  constructor(key: Uint8Array) {
+    this.key = key.slice()
+  }
+
+  NonceSize(): number {
+    return NonceSizeX
+  }
+
+  Overhead(): number {
+    return Overhead
+  }
+
+  Seal(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    plaintext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): $.Slice<number> {
+    return seal(
+      dst,
+      nobleXChaCha20Poly1305,
+      this.key,
+      nonce,
+      NonceSizeX,
+      plaintext,
+      additionalData,
+    )
+  }
+
+  Open(
+    dst: $.Slice<number>,
+    nonce: $.Slice<number>,
+    ciphertext: $.Slice<number>,
+    additionalData: $.Slice<number>,
+  ): [$.Slice<number>, $.GoError] {
+    return open(
+      dst,
+      nobleXChaCha20Poly1305,
+      this.key,
+      nonce,
+      NonceSizeX,
+      ciphertext,
+      additionalData,
+    )
+  }
+}
+
+export function New(key: $.Slice<number>): [AEAD | null, $.GoError] {
+  const keyBytes = bytes(key)
+  if (keyBytes.length !== KeySize) {
+    return [null, errors.New('chacha20poly1305: bad key length')]
+  }
+  return [
+    $.interfaceValue<AEAD | null>(
+      new chacha20poly1305(keyBytes),
+      '*chacha20poly1305.chacha20poly1305',
+    ),
+    null,
+  ]
+}
+
+export function NewX(key: $.Slice<number>): [AEAD | null, $.GoError] {
+  const keyBytes = bytes(key)
+  if (keyBytes.length !== KeySize) {
+    return [null, errors.New('chacha20poly1305: bad key length')]
+  }
+  return [
+    $.interfaceValue<AEAD | null>(
+      new xchacha20poly1305(keyBytes),
+      '*chacha20poly1305.xchacha20poly1305',
+    ),
+    null,
+  ]
+}
+
+function seal(
+  dst: $.Slice<number>,
+  cipher: NobleAEAD,
+  key: Uint8Array,
+  nonce: $.Slice<number>,
+  expectedNonceSize: number,
+  plaintext: $.Slice<number>,
+  additionalData: $.Slice<number>,
+): $.Slice<number> {
+  const nonceBytes = bytes(nonce)
+  if (nonceBytes.length !== expectedNonceSize) {
+    $.panic('chacha20poly1305: bad nonce length passed to Seal')
+  }
+  const plaintextBytes = bytes(plaintext)
+  if (plaintextBytes.length > maxIETFPlaintext) {
+    $.panic('chacha20poly1305: plaintext too large')
+  }
+
+  const sealed = cipher(key, nonceBytes, bytes(additionalData)).encrypt(
+    plaintextBytes,
+  )
+  return appendBytes(dst, sealed)
+}
+
+function open(
+  dst: $.Slice<number>,
+  cipher: NobleAEAD,
+  key: Uint8Array,
+  nonce: $.Slice<number>,
+  expectedNonceSize: number,
+  ciphertext: $.Slice<number>,
+  additionalData: $.Slice<number>,
+): [$.Slice<number>, $.GoError] {
+  const nonceBytes = bytes(nonce)
+  if (nonceBytes.length !== expectedNonceSize) {
+    $.panic('chacha20poly1305: bad nonce length passed to Open')
+  }
+  const ciphertextBytes = bytes(ciphertext)
+  if (ciphertextBytes.length < Overhead) {
+    return [null, errOpen]
+  }
+  if (ciphertextBytes.length > maxIETFCiphertext) {
+    $.panic('chacha20poly1305: ciphertext too large')
+  }
+
+  try {
+    return [
+      appendBytes(
+        dst,
+        cipher(key, nonceBytes, bytes(additionalData)).decrypt(ciphertextBytes),
+      ),
+      null,
+    ]
+  } catch {
+    return [null, errOpen]
+  }
+}
+
+function bytes(value: $.Slice<number>): Uint8Array {
+  return $.bytesToUint8Array(value).slice()
+}
+
+function appendBytes(
+  dst: $.Slice<number>,
+  suffix: Uint8Array,
+): $.Slice<number> {
+  const prefix = $.bytesToUint8Array(dst)
+  if (prefix.length === 0) {
+    return suffix.slice()
+  }
+  const out = new Uint8Array(prefix.length + suffix.length)
+  out.set(prefix)
+  out.set(suffix, prefix.length)
+  return out
+}

package/gs/internal/byteorder/index.test.ts

@@ -16,7 +16,7 @@ describe('internal/byteorder uint64', () => {
     BEPutUint64(bytes, 0x0102030405060708n)
 
     expect(Array.from(bytes)).toEqual([1, 2, 3, 4, 5, 6, 7, 8])
-    expect(BEUint64(bytes)).toBe(Number(0x0102030405060708n))
+    expect(BEUint64(bytes)).toBe(0x0102030405060708n)
   })
 
   test('reads and writes little-endian bigint values', () => {
@@ -25,7 +25,7 @@ describe('internal/byteorder uint64', () => {
     LEPutUint64(bytes, 0x0102030405060708n)
 
     expect(Array.from(bytes)).toEqual([8, 7, 6, 5, 4, 3, 2, 1])
-    expect(LEUint64(bytes)).toBe(Number(0x0102030405060708n))
+    expect(LEUint64(bytes)).toBe(0x0102030405060708n)
   })
 
   test('appends uint64 values', () => {

package/gs/internal/byteorder/index.ts

@@ -13,7 +13,7 @@ export function BEUint32(b: $.Bytes): number {
 }
 
 export function BEUint64(b: $.Bytes): number {
-  return Number(
+  return $.uint(
     (BigInt(b![0]) << 56n) |
       (BigInt(b![1]) << 48n) |
       (BigInt(b![2]) << 40n) |
@@ -34,7 +34,7 @@ export function LEUint32(b: $.Bytes): number {
 }
 
 export function LEUint64(b: $.Bytes): number {
-  return Number(
+  return $.uint(
     BigInt(b![0]) |
       (BigInt(b![1]) << 8n) |
       (BigInt(b![2]) << 16n) |

package/gs/io/io.test.ts

@@ -1,5 +1,12 @@
 import * as $ from '@goscript/builtin/index.js'
-import { LimitedReader, MultiWriter, NopCloser, Pipe, TeeReader } from './index.js'
+import {
+  LimitedReader,
+  MultiWriter,
+  NewSectionReader,
+  NopCloser,
+  Pipe,
+  TeeReader,
+} from './index.js'
 import { describe, expect, test } from 'vitest'
 
 class sliceReader {
@@ -22,6 +29,15 @@ class captureWriter {
   }
 }
 
+class syncReaderAt {
+  constructor(private data: Uint8Array) {}
+
+  ReadAt(p: $.Bytes, off: number): [number, $.GoError] {
+    const n = $.copy(p, this.data.subarray(off))
+    return [n, n < $.len(p) ? (new Error('EOF') as $.GoError) : null]
+  }
+}
+
 describe('io override', () => {
   test('LimitedReader accepts generated struct-literal construction', async () => {
     const reader = new LimitedReader({
@@ -118,6 +134,45 @@ describe('io override', () => {
     expect(Buffer.from(chunks).toString('utf8')).toBe('abc')
   })
 
+  test('SectionReader preserves sync reads for sync ReaderAt', () => {
+    const reader = NewSectionReader(
+      new syncReaderAt($.stringToBytes('abcdef')),
+      1,
+      3,
+    )
+    const buf = new Uint8Array(4)
+
+    const result = reader.Read(buf)
+    expect(result).not.toBeInstanceOf(Promise)
+    const [n, err] = result
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(buf.subarray(0, n)).toString('utf8')).toBe('bcd')
+  })
+
+  test('SectionReader awaits async ReaderAt', async () => {
+    const reader = NewSectionReader(
+      {
+        async ReadAt(p: $.Bytes, off: number): Promise<[number, $.GoError]> {
+          await Promise.resolve()
+          const data = $.stringToBytes('abcdef')
+          const n = $.copy(p, data.subarray(off))
+          return [n, n < $.len(p) ? (new Error('EOF') as $.GoError) : null]
+        },
+      } as any,
+      1,
+      3,
+    )
+    const buf = new Uint8Array(4)
+
+    const [n, err] = await reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(buf.subarray(0, n)).toString('utf8')).toBe('bcd')
+  })
+
   test('PipeReader waits for a later write', async () => {
     const [reader, writer] = Pipe()
     const buf = new Uint8Array(5)

package/gs/io/io.ts

@@ -363,7 +363,15 @@ export class SectionReader implements Reader, Seeker, ReaderAt {
       p = $.goSlice(p, 0, max)
     }
 
-    const [n, err] = this.r.ReadAt(p, this.off)
+    const res = this.r.ReadAt(p, this.off) as any
+    if (res instanceof Promise) {
+      return res.then(([n, err]: [number, $.GoError]) => {
+        this.off += n
+        return [n, err]
+      }) as any
+    }
+
+    const [n, err] = res
     this.off += n
     return [n, err]
   }
@@ -400,7 +408,16 @@ export class SectionReader implements Reader, Seeker, ReaderAt {
     off += this.base
     if (off + $.len(p) > this.limit) {
       p = $.goSlice(p, 0, this.limit - off)
-      const [n, err] = this.r.ReadAt(p, off)
+      const res = this.r.ReadAt(p, off) as any
+      if (res instanceof Promise) {
+        return res.then(([n, err]: [number, $.GoError]) => {
+          if (err === null) {
+            return [n, EOF]
+          }
+          return [n, err]
+        }) as any
+      }
+      const [n, err] = res
       if (err === null) {
         return [n, EOF]
       }