goscript 0.2.1 → 0.2.3

package/gs/crypto/ecdh/index.ts

@@ -29,7 +29,9 @@ export class PublicKey {
 
   public Equal(x: PublicKey | $.VarRef<PublicKey> | null): boolean {
     const other = $.pointerValueOrNil(x)
-    return other instanceof PublicKey && bytesEqual(this.publicKey, other.publicKey)
+    return (
+      other instanceof PublicKey && bytesEqual(this.publicKey, other.publicKey)
+    )
   }
 }
 
@@ -54,17 +56,27 @@ export class PrivateKey {
     return this.curve
   }
 
-  public ECDH(remote: PublicKey | $.VarRef<PublicKey> | null): [$.Bytes, $.GoError] {
+  public ECDH(
+    remote: PublicKey | $.VarRef<PublicKey> | null,
+  ): [$.Bytes, $.GoError] {
     const remoteKey = $.pointerValueOrNil(remote)
     if (remoteKey == null || remoteKey.curve !== this.curve) {
-      return [null, $.newError('crypto/ecdh: private key and public key curves do not match')]
+      return [
+        null,
+        $.newError(
+          'crypto/ecdh: private key and public key curves do not match',
+        ),
+      ]
     }
     return this.curve.ecdh(this, remoteKey)
   }
 
   public Equal(x: PrivateKey | $.VarRef<PrivateKey> | null): boolean {
     const other = $.pointerValueOrNil(x)
-    return other instanceof PrivateKey && bytesEqual(this.privateKey, other.privateKey)
+    return (
+      other instanceof PrivateKey &&
+      bytesEqual(this.privateKey, other.privateKey)
+    )
   }
 
   public Public(): PublicKey {
@@ -80,7 +92,9 @@ export class x25519Curve {
   public GenerateKey(r: io.Reader | null): [PrivateKey | null, $.GoError] {
     const key = new Uint8Array(x25519PrivateKeySize)
     if (r != null) {
-      throw new Error('crypto/ecdh: custom random readers are not implemented in GoScript')
+      throw new Error(
+        'crypto/ecdh: custom random readers are not implemented in GoScript',
+      )
     }
     globalThis.crypto.getRandomValues(key)
     return this.NewPrivateKey(key)
@@ -113,10 +127,18 @@ export class x25519Curve {
     return 'X25519'
   }
 
-  public ecdh(local: PrivateKey | null, remote: PublicKey | null): [$.Bytes, $.GoError] {
+  public ecdh(
+    local: PrivateKey | null,
+    remote: PublicKey | null,
+  ): [$.Bytes, $.GoError] {
     const out = scalarMult(local?.privateKey ?? null, remote?.publicKey ?? null)
     if (isZero(out)) {
-      return [null, $.newError('crypto/ecdh: bad X25519 remote ECDH input: low order point')]
+      return [
+        null,
+        $.newError(
+          'crypto/ecdh: bad X25519 remote ECDH input: low order point',
+        ),
+      ]
     }
     return [out, null]
   }
@@ -132,23 +154,38 @@ export class unsupportedCurve {
   constructor(private readonly name: string) {}
 
   public GenerateKey(_r: io.Reader | null): [PrivateKey | null, $.GoError] {
-    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+    return [
+      null,
+      $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`),
+    ]
   }
 
   public NewPrivateKey(_key: $.Bytes): [PrivateKey | null, $.GoError] {
-    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+    return [
+      null,
+      $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`),
+    ]
   }
 
   public NewPublicKey(_key: $.Bytes): [PublicKey | null, $.GoError] {
-    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+    return [
+      null,
+      $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`),
+    ]
   }
 
   public String(): string {
     return this.name
   }
 
-  public ecdh(_local: PrivateKey | null, _remote: PublicKey | null): [$.Bytes, $.GoError] {
-    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+  public ecdh(
+    _local: PrivateKey | null,
+    _remote: PublicKey | null,
+  ): [$.Bytes, $.GoError] {
+    return [
+      null,
+      $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`),
+    ]
   }
 }
 

package/gs/crypto/ed25519/index.ts

@@ -14,8 +14,8 @@ export const SignatureSize = 64
 export const SeedSize = 32
 
 const pkcs8Prefix = new Uint8Array([
-  0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70,
-  0x04, 0x22, 0x04, 0x20,
+  0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x04,
+  0x22, 0x04, 0x20,
 ])
 
 export class Options {
@@ -32,7 +32,10 @@ export class Options {
   }
 }
 
-export function PublicKey_Equal(pub: PublicKey, x: PublicKeyInterface | null): boolean {
+export function PublicKey_Equal(
+  pub: PublicKey,
+  x: PublicKeyInterface | null,
+): boolean {
   const [xx, ok] = $.typeAssertTuple<PublicKey>(x, 'ed25519.PublicKey')
   return ok && bytesEqual(pub, xx)
 }
@@ -47,7 +50,10 @@ export function PrivateKey_Public(priv: PrivateKey): PublicKeyInterface | null {
   )
 }
 
-export function PrivateKey_Equal(priv: PrivateKey, x: PrivateKeyInterface | null): boolean {
+export function PrivateKey_Equal(
+  priv: PrivateKey,
+  x: PrivateKeyInterface | null,
+): boolean {
   const [xx, ok] = $.typeAssertTuple<PrivateKey>(x, 'ed25519.PrivateKey')
   return ok && bytesEqual(priv, xx)
 }
@@ -68,7 +74,9 @@ export async function PrivateKey_Sign(
   return [await Sign(priv, message), null]
 }
 
-export async function GenerateKey(random: io.Reader | null): Promise<[PublicKey, PrivateKey, $.GoError]> {
+export async function GenerateKey(
+  random: io.Reader | null,
+): Promise<[PublicKey, PrivateKey, $.GoError]> {
   const seed = new Uint8Array(SeedSize)
   if (random == null) {
     const subtle = subtleCrypto()
@@ -124,7 +132,10 @@ export async function NewKeyFromSeed(seed: $.Bytes): Promise<PrivateKey> {
   return privateKey
 }
 
-export async function Sign(privateKey: PrivateKey, message: $.Bytes): Promise<$.Bytes> {
+export async function Sign(
+  privateKey: PrivateKey,
+  message: $.Bytes,
+): Promise<$.Bytes> {
   const priv = $.bytesToUint8Array(privateKey)
   if (priv.length !== PrivateKeySize) {
     throw new Error(`ed25519: bad private key length: ${priv.length}`)
@@ -150,7 +161,9 @@ export async function Verify(
   message: $.Bytes,
   sig: $.Bytes,
 ): Promise<boolean> {
-  return (await VerifyWithOptions(publicKey, message, sig, new Options())) == null
+  return (
+    (await VerifyWithOptions(publicKey, message, sig, new Options())) == null
+  )
 }
 
 export async function VerifyWithOptions(

package/gs/crypto/rand/index.ts

@@ -71,7 +71,10 @@ export async function Prime(
   bits: number,
 ): Promise<[any, $.GoError]> {
   if (bits < 2) {
-    return [null, new RandError('crypto/rand: prime size must be at least 2-bit')]
+    return [
+      null,
+      new RandError('crypto/rand: prime size must be at least 2-bit'),
+    ]
   }
 
   const bitOffset = bits % 8
@@ -123,8 +126,8 @@ function newBigInt(): any {
     | { zeroValue?: unknown; ctor?: new () => unknown }
     | undefined
   if (info?.zeroValue !== undefined) {
-    return typeof info.zeroValue === 'function'
-      ? (info.zeroValue as () => unknown)()
+    return typeof info.zeroValue === 'function' ?
+        (info.zeroValue as () => unknown)()
       : info.zeroValue
   }
   if (info?.ctor != null) {

package/gs/embed/index.test.ts

@@ -19,7 +19,7 @@ describe('embed.FS', () => {
     expect(Array.from(data)).toEqual([1, 2, 3])
   })
 
-  it('supports io/fs read, stat, and directory APIs', () => {
+  it('supports io/fs read, stat, and directory APIs', async () => {
     const fsys = markAsStructValue(
       new FS(
         new Map([
@@ -37,7 +37,7 @@ describe('embed.FS', () => {
     expect(readAgainErr).toBeNull()
     expect(Array.from(dataAgain)).toEqual([1, 2, 3])
 
-    const [rootEntries, rootErr] = ReadDir(fsys, '.')
+    const [rootEntries, rootErr] = await ReadDir(fsys, '.')
     expect(rootErr).toBeNull()
     expect(rootEntries!.map((entry) => entry!.Name())).toEqual([
       'assets',
@@ -48,7 +48,7 @@ describe('embed.FS', () => {
     expect(statErr).toBeNull()
     expect(assetInfo!.IsDir()).toBe(true)
 
-    const [assetEntries, assetErr] = ReadDir(fsys, 'assets')
+    const [assetEntries, assetErr] = await ReadDir(fsys, 'assets')
     expect(assetErr).toBeNull()
     expect(assetEntries!.map((entry) => entry!.Name())).toEqual(['config.json'])
   })

package/gs/embed/index.ts

@@ -166,9 +166,15 @@ class embedFile {
 
   Stat(): [fs.FileInfo, $.GoError] {
     if (this.data === null) {
-      return [new embedFileInfo(baseName(this.name), 0, fs.ModeDir | 0o555), null]
-    }
-    return [new embedFileInfo(baseName(this.name), this.data.byteLength, 0o444), null]
+      return [
+        new embedFileInfo(baseName(this.name), 0, fs.ModeDir | 0o555),
+        null,
+      ]
+    }
+    return [
+      new embedFileInfo(baseName(this.name), this.data.byteLength, 0o444),
+      null,
+    ]
   }
 }
 

package/gs/fmt/fmt.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { resetHostRuntimeForTests } from '@goscript/builtin/hostio.js'
 import * as $ from '@goscript/builtin/index.js'
+import * as os from '@goscript/os/index.js'
 import * as fmt from './fmt.js'
 
 const originalDeno = (globalThis as any).Deno
@@ -61,10 +62,15 @@ describe('fmt basic value formatting', () => {
     expect(
       fmt.Sprintf(
         'Type: %T',
-        $.namedValueInterfaceValue(123, 'int', {}, {
-          kind: $.TypeKind.Basic,
-          name: 'int',
-        }),
+        $.namedValueInterfaceValue(
+          123,
+          'int',
+          {},
+          {
+            kind: $.TypeKind.Basic,
+            name: 'int',
+          },
+        ),
       ),
     ).toBe('Type: int')
   })
@@ -187,6 +193,25 @@ describe('fmt spacing rules', () => {
     expect(new TextDecoder().decode(chunks[1])).toBe('hi there 1 2\n')
   })
 
+  it('Fprintln writes Stderr through console.log in browser-like hosts', async () => {
+    const consoleLog = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+    delete (globalThis as any).Deno
+    delete (globalThis as any).process
+    resetHostRuntimeForTests()
+
+    try {
+      const [n, err] = await fmt.Fprintln(os.Stderr!, 'err')
+      expect(err).toBeNull()
+      expect(n).toBe(4)
+      expect(consoleLog).toHaveBeenCalledWith('err')
+      expect(consoleError).not.toHaveBeenCalled()
+    } finally {
+      consoleLog.mockRestore()
+      consoleError.mockRestore()
+    }
+  })
+
   it('Fprintf awaits async writers', async () => {
     const chunks: Uint8Array[] = []
     const writer = {

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

@@ -258,6 +258,104 @@ class TimestampParentBoundMessage {
   timestamp: TimestampBoundMessage,
 }
 
+const oneofLeafMessageType = {
+  typeName: 'test.OneofLeafBoundMessage',
+  fields: {
+    list: () => [{ localName: 'label', kind: 'scalar' }],
+  },
+}
+
+class OneofLeafBoundMessage {
+  public get Label(): string {
+    return this._fields.Label.value
+  }
+  public set Label(value: string) {
+    this._fields.Label.value = value
+  }
+
+  public _fields: {
+    Label: $.VarRef<string>
+  }
+
+  constructor(init?: Partial<{ Label?: string }>) {
+    this._fields = {
+      Label: $.varRef(init?.Label ?? ''),
+    }
+  }
+}
+
+;(OneofLeafBoundMessage as any).__protobufTypeScriptMessage =
+  oneofLeafMessageType
+;(OneofLeafBoundMessage as any).__protobufTypeScriptFields = {}
+
+class OneofBoundMessage_TabSet {
+  public get TabSet(): OneofLeafBoundMessage | null {
+    return this._fields.TabSet.value
+  }
+  public set TabSet(value: OneofLeafBoundMessage | null) {
+    this._fields.TabSet.value = value
+  }
+
+  public _fields: {
+    TabSet: $.VarRef<OneofLeafBoundMessage | null>
+  }
+
+  constructor(init?: Partial<{ TabSet?: OneofLeafBoundMessage | null }>) {
+    this._fields = {
+      TabSet: $.varRef(init?.TabSet ?? null),
+    }
+  }
+}
+
+class OneofBoundMessage {
+  public get Node(): OneofBoundMessage_TabSet | null {
+    return this._fields.Node.value
+  }
+  public set Node(value: OneofBoundMessage_TabSet | null) {
+    this._fields.Node.value = value
+  }
+
+  public _fields: {
+    Node: $.VarRef<OneofBoundMessage_TabSet | null>
+  }
+
+  constructor(init?: Partial<{ Node?: OneofBoundMessage_TabSet | null }>) {
+    this._fields = {
+      Node: $.varRef(init?.Node ?? null),
+    }
+  }
+}
+
+;(OneofBoundMessage as any).__protobufTypeScriptMessage = {
+  typeName: 'test.OneofBoundMessage',
+  fields: {
+    list: () => [
+      {
+        localName: 'tabSet',
+        kind: 'message',
+        T: oneofLeafMessageType,
+        oneof: { localName: 'node' },
+      },
+    ],
+  },
+  fromBinary: () => ({
+    node: { case: 'tabSet', value: { label: 'files' } },
+  }),
+  toBinary: (value: {
+    node?: { case: string; value?: { label?: string } }
+  }) => {
+    expect(value.node?.case).toBe('tabSet')
+    expect(value.node?.value?.label).toBe('files')
+    return new Uint8Array([7])
+  },
+}
+;(OneofBoundMessage as any).__protobufTypeScriptFields = {
+  tabSet: OneofLeafBoundMessage,
+}
+;(OneofBoundMessage as any).__protobufTypeScriptOneofFields = {
+  node: { tabSet: OneofBoundMessage_TabSet },
+}
+
 describe('protobuf-go-lite EqualVT helpers', () => {
   it('accepts compiler-emitted runtime type arguments', () => {
     const equal = CompareEqualVT<TestValue>({
@@ -405,6 +503,34 @@ describe('protobuf-go-lite TypeScript binding helpers', () => {
     expect(target.Timestamp?.Seconds).toBe(1780230896)
     expect(target.Timestamp?.Nanos).toBe(789000000)
   })
+
+  it('preserves protobuf oneof branches in bound binary helpers', () => {
+    const source = new OneofBoundMessage({
+      Node: new OneofBoundMessage_TabSet({
+        TabSet: new OneofLeafBoundMessage({ Label: 'files' }),
+      }),
+    })
+
+    const [bytes, marshalErr] = MarshalBoundMessageVT(
+      OneofBoundMessage as any,
+      source,
+    )
+
+    expect(marshalErr).toBeNull()
+    expect(Array.from(bytes ?? [])).toEqual([7])
+
+    const target = new OneofBoundMessage()
+    const unmarshalErr = UnmarshalBoundMessageVT(
+      OneofBoundMessage as any,
+      target,
+      new Uint8Array([7]),
+    )
+
+    expect(unmarshalErr).toBeNull()
+    expect(target.Node).toBeInstanceOf(OneofBoundMessage_TabSet)
+    expect(target.Node?.TabSet).toBeInstanceOf(OneofLeafBoundMessage)
+    expect(target.Node?.TabSet?.Label).toBe('files')
+  })
 })
 
 describe('protobuf-go-lite wire helpers', () => {

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

@@ -369,6 +369,10 @@ type BoundFieldInfo = {
 type BoundMessageCtor<T = any> = {
   new (init?: any): T
   __protobufTypeScriptFields?: Record<string, BoundMessageCtor>
+  __protobufTypeScriptOneofFields?: Record<
+    string,
+    Record<string, BoundMessageCtor>
+  >
   __protobufTypeScriptMessage?: BoundMessageType
 }
 
@@ -404,6 +408,10 @@ function boundFieldValue(source: any, field: BoundFieldInfo): any {
   return source[boundFieldGoName(field)]
 }
 
+function boundOneofGroupGoName(field: BoundFieldInfo): string {
+  return boundFieldGoName({ ...field, localName: field.oneof?.localName ?? '' })
+}
+
 function toTypeScriptScalarValue(value: any, field?: BoundFieldInfo): any {
   const unwrapped = $.pointerValueOrNil(value)
   if (
@@ -471,6 +479,27 @@ function toTypeScriptMessage(
   const out: Record<string, unknown> = {}
   for (const field of fields) {
     if (field.oneof != null) {
+      const groupName = field.oneof.localName
+      const group = boundFieldValue(value, {
+        ...field,
+        localName: groupName,
+        oneof: undefined,
+      })
+      if (group == null || out[groupName] !== undefined) {
+        continue
+      }
+      const raw = boundFieldValue(group, field)
+      if (raw === undefined || raw === null) {
+        continue
+      }
+      out[groupName] = {
+        case: field.localName,
+        value: toTypeScriptFieldValue(
+          field,
+          raw,
+          fieldCtors[field.localName] ?? raw?.constructor,
+        ),
+      }
       continue
     }
     const raw = boundFieldValue(value, field)
@@ -566,8 +595,25 @@ function fromTypeScriptMessage(
     return Object.assign(out, value)
   }
   const fieldCtors = ctor.__protobufTypeScriptFields ?? {}
+  const oneofCtors = ctor.__protobufTypeScriptOneofFields ?? {}
   for (const field of fields) {
     if (field.oneof != null) {
+      const groupName = field.oneof.localName
+      const raw = value[groupName]
+      if (raw?.case !== field.localName) {
+        continue
+      }
+      const branchCtor = oneofCtors[groupName]?.[field.localName]
+      const branchValue = fromTypeScriptFieldValue(
+        field,
+        raw.value,
+        fieldCtors[field.localName],
+      )
+      const branchFieldName = boundFieldGoName(field)
+      out[boundOneofGroupGoName(field)] =
+        branchCtor == null ?
+          { [branchFieldName]: branchValue }
+        : new branchCtor({ [branchFieldName]: branchValue })
       continue
     }
     const raw = value[field.localName]

package/gs/github.com/mr-tron/base58/base58/index.ts

@@ -1,7 +1,8 @@
 import * as $ from '@goscript/builtin/index.js'
 
 const btcAlphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-const flickrAlphabet = '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+const flickrAlphabet =
+  '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
 
 export class Alphabet {
   decode: Int8Array
@@ -130,7 +131,9 @@ export function DecodeAlphabet(
   return FastBase58DecodingAlphabet(str, alphabet)
 }
 
-export function FastBase58Decoding(str: string): [Uint8Array | null, $.GoError] {
+export function FastBase58Decoding(
+  str: string,
+): [Uint8Array | null, $.GoError] {
   return FastBase58DecodingAlphabet(str, BTCAlphabet)
 }
 
@@ -187,7 +190,10 @@ export function FastBase58DecodingAlphabet(
     }
 
     if (c > 0) {
-      return [null, $.newError('Output number too big (carry to the next int32)')]
+      return [
+        null,
+        $.newError('Output number too big (carry to the next int32)'),
+      ]
     }
     if ((outi[0] & zmask) !== 0) {
       return [

package/gs/github.com/zeebo/blake3/internal/consts/index.test.ts

@@ -20,14 +20,8 @@ import {
 describe('blake3 consts override', () => {
   test('uses portable constants for GoScript', () => {
     expect(IV).toEqual([
-      0x6a09e667,
-      0xbb67ae85,
-      0x3c6ef372,
-      0xa54ff53a,
-      0x510e527f,
-      0x9b05688c,
-      0x1f83d9ab,
-      0x5be0cd19,
+      0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+      0x1f83d9ab, 0x5be0cd19,
     ])
     expect(IV[0]).toBe(IV0)
     expect(BlockLen).toBe(64)

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('')
+}