goscript 0.2.0 → 0.2.2

package/dist/gs/sync/atomic/doc_64.gs.js

@@ -1,3 +1,4 @@
+import * as $ from "@goscript/builtin/index.js";
 // SwapInt64 atomically stores new into *addr and returns the previous *addr value.
 // Consider using the more ergonomic and less error-prone [Int64.Swap] instead
 // (particularly if you target 32-bit platforms; see the bugs section).
@@ -58,7 +59,7 @@ export function CompareAndSwapUint64(addr, old, _new) {
 export function AddInt64(addr, delta) {
     if (!addr)
         return 0;
-    addr.value = addr.value + delta;
+    addr.value = $.int64Add(addr.value, delta);
     return addr.value;
 }
 // AddUint64 atomically adds delta to *addr and returns the new value.
@@ -71,7 +72,7 @@ export function AddInt64(addr, delta) {
 export function AddUint64(addr, delta) {
     if (!addr)
         return 0;
-    addr.value = addr.value + delta;
+    addr.value = $.uint64Add(addr.value, delta);
     return addr.value;
 }
 // AndInt64 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask
@@ -83,7 +84,7 @@ export function AndInt64(addr, mask) {
     if (!addr)
         return 0;
     let old = addr.value;
-    addr.value = addr.value & mask;
+    addr.value = $.int64And(addr.value, mask);
     return old;
 }
 // AndUint64 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask
@@ -95,7 +96,7 @@ export function AndUint64(addr, mask) {
     if (!addr)
         return 0;
     let old = addr.value;
-    addr.value = addr.value & mask;
+    addr.value = $.uint64And(addr.value, mask);
     return old;
 }
 // OrInt64 atomically performs a bitwise OR operation on *addr using the bitmask provided as mask
@@ -107,7 +108,7 @@ export function OrInt64(addr, mask) {
     if (!addr)
         return 0;
     let old = addr.value;
-    addr.value = addr.value | mask;
+    addr.value = $.int64Or(addr.value, mask);
     return old;
 }
 // OrUint64 atomically performs a bitwise OR operation on *addr using the bitmask provided as mask
@@ -119,7 +120,7 @@ export function OrUint64(addr, mask) {
     if (!addr)
         return 0;
     let old = addr.value;
-    addr.value = addr.value | mask;
+    addr.value = $.uint64Or(addr.value, mask);
     return old;
 }
 // LoadInt64 atomically loads *addr.

package/dist/gs/sync/atomic/doc_64.gs.js.map

@@ -1 +1 @@
-{"version":3,"file":"doc_64.gs.js","sourceRoot":"","sources":["../../../../gs/sync/atomic/doc_64.gs.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"doc_64.gs.js","sourceRoot":"","sources":["../../../../gs/sync/atomic/doc_64.gs.ts"],"names":[],"mappings":"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"}

package/go.mod

@@ -2,13 +2,13 @@ module github.com/aperturerobotics/goscript
 
 go 1.25.3
 
-toolchain go1.26.3
+toolchain go1.26.4
 
 require (
 	github.com/aperturerobotics/cli v1.1.0
 	github.com/aperturerobotics/json-iterator-lite v1.1.0
 	github.com/aperturerobotics/protobuf-go-lite v0.14.0
-	github.com/aperturerobotics/util v1.34.6
+	github.com/aperturerobotics/util v1.34.9
 	github.com/pkg/errors v0.9.1
 	github.com/sirupsen/logrus v1.9.5-0.20260508084601-d4a50659cfd6
 	golang.org/x/tools v0.45.0

package/go.sum

@@ -15,6 +15,8 @@ github.com/aperturerobotics/util v1.34.5 h1:007MaOJrrsiGm5o1c8Tt7p8nVwUAxkM6pmGf
 github.com/aperturerobotics/util v1.34.5/go.mod h1:mDe7WnncVuV7yjeeVSsagyfrw4xfncu7d+f0+d70niY=
 github.com/aperturerobotics/util v1.34.6 h1:Z5LOncJ+ooBut7Q2FIJTYZvx5KOFD/F7qFdchCYl1aY=
 github.com/aperturerobotics/util v1.34.6/go.mod h1:4dIoZeVR1RNIgqrZxWe9F9LkDtsGEBvFTiwFAT0vxZ4=
+github.com/aperturerobotics/util v1.34.9 h1:Eyhu1Citt+od7jKIb+Q92h/CEujWCFsvdvJavQeoRjM=
+github.com/aperturerobotics/util v1.34.9/go.mod h1:GxjGkYQNEj8xvLFz+T8ifqANtK5cMesOlCxh50htvBI=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=

package/gs/builtin/hostio.test.ts

@@ -182,18 +182,39 @@ describe('hostio text writes', () => {
     expect(getHostRuntime().platform).toBe('darwin')
   })
 
-  it('uses console fallback in browser-like hosts', () => {
+  it('uses console.log fallback for stdout and stderr text in browser-like hosts', () => {
     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()
 
     writeHostStdoutText('browser\n')
+    writeHostStderrText('stderr\n')
 
     expect(getHostRuntime().platform).toBe('unknown')
     expect(getHostRuntime().nodeFS).toBeNull()
     expect(consoleLog).toHaveBeenCalledWith('browser')
+    expect(consoleLog).toHaveBeenCalledWith('stderr')
+    expect(consoleError).not.toHaveBeenCalled()
+  })
+
+  it('writes stdout and stderr file descriptors to console.log in browser-like hosts', () => {
+    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()
+
+    const runtime = getHostRuntime()
+    expect(runtime.writeFD(1, new Uint8Array([111, 107, 10]))).toBe(3)
+    expect(runtime.writeFD(2, new Uint8Array([101, 114, 114, 10]))).toBe(4)
+
+    expect(consoleLog).toHaveBeenCalledWith('ok')
+    expect(consoleLog).toHaveBeenCalledWith('err')
+    expect(consoleError).not.toHaveBeenCalled()
   })
 })
 

package/gs/builtin/hostio.ts

@@ -104,6 +104,7 @@ export type MainScriptMeta = {
 }
 
 const encoder = new TextEncoder()
+const decoder = new TextDecoder()
 
 function getDynamicRequire(): ((specifier: string) => unknown) | null {
   try {
@@ -342,6 +343,10 @@ function detectHostRuntime(): HostRuntime {
         buffer,
       )
     }
+    if (fd === 1 || fd === 2) {
+      fallbackConsoleWriter('log')(decoder.decode(buffer))
+      return buffer.length
+    }
     throw new HostUnsupportedError()
   }
   const writeStdoutText: HostTextWrite = (data: string) => {
@@ -374,7 +379,7 @@ function detectHostRuntime(): HostRuntime {
       )
       return
     }
-    fallbackConsoleWriter('error')(data)
+    fallbackConsoleWriter('log')(data)
   }
 
   return {

package/gs/builtin/runtime-contract.test.ts

@@ -17,6 +17,7 @@ import {
   int,
   arrayPointerFromIndexRef,
   indexAddress,
+  indexByteAddress,
   indexRef,
   interfaceValue,
   len,
@@ -62,6 +63,7 @@ import {
   uintShr,
   unref,
   unsupportedPointerRef,
+  unsafePointerRef,
   varRef,
 } from './index.js'
 
@@ -423,6 +425,16 @@ describe('builtin runtime contract helpers', () => {
     arrayView[2] = 19
     expect((byteBacking as Uint8Array)[3]).toBe(19)
 
+    const words = [0x11223344, 0]
+    const wordBytes = arrayPointerFromIndexRef(indexRef(words, 0), 8, 4, 1)
+    const byteView = pointerValue(wordBytes) as number[]
+    expect(byteView[0]).toBe(0x44)
+    expect(byteView[3]).toBe(0x11)
+    byteView[4] = 0xaa
+    expect(words[1]).toBe(0xaa)
+    wordBytes.value = [1, 2, 3, 4]
+    expect(words[0]).toBe(0x04030201)
+
     shortBytes![0] = 14
     expect(bytesToUint8Array(shortBytes)).toEqual(new Uint8Array([14, 0]))
 
@@ -473,6 +485,22 @@ describe('builtin runtime contract helpers', () => {
     expect(indexAddress(other, 0)).not.toBe(indexAddress(left, 0))
   })
 
+  it('resolves unsafe byte addresses within numeric slice elements', () => {
+    const words = makeSlice<number>(2, undefined, 'number')
+    const first = indexByteAddress(words, 0, 8)
+    const second = indexByteAddress(words, 1, 8)
+
+    expect(second - first).toBe(8)
+    unsafePointerRef<number>(first + 1).value = 0x12
+    unsafePointerRef<number>(first + 7).value = 0x80
+    expect(unsafePointerRef<number>(first + 1).value).toBe(0x12)
+    expect(unsafePointerRef<number>(first + 7).value).toBe(0x80)
+    expect(words![0]).toBe(0x8000000000001200n as unknown as number)
+
+    unsafePointerRef<number>(second).value = 0x34
+    expect(words![1]).toBe(0x34)
+  })
+
   it('exposes owned pointer handles for addressable collection elements', () => {
     const values = [1, 2, 3, 4]
     const second = indexRef(values, 1)

package/gs/builtin/slice.ts

@@ -76,6 +76,14 @@ interface GoSliceObject<T> {
 const addressStride = 0x100000000
 let nextAddressBase = 1
 const addressBases = new WeakMap<object, number>()
+const byteAddressBases = new WeakMap<object, number>()
+const byteAddressSources = new globalThis.Map<number, ByteAddressSource>()
+
+interface ByteAddressSource {
+  byteLength: number
+  getByte(offset: number): number
+  setByte(offset: number, value: number): void
+}
 
 /**
  * SliceProxy is a proxy object for complex slices
@@ -129,9 +137,7 @@ function wrapSliceProxy<T>(proxy: SliceProxy<T>): SliceProxy<T> {
         if (index < meta.length) {
           return meta.backing[meta.offset + index]
         }
-        throw new Error(
-          `Slice index out of range: ${index} >= ${meta.length}`,
-        )
+        throw new Error(`Slice index out of range: ${index} >= ${meta.length}`)
       }
 
       if (prop === 'length') {
@@ -153,9 +159,7 @@ function wrapSliceProxy<T>(proxy: SliceProxy<T>): SliceProxy<T> {
           target[index] = value // Also update the proxy target for consistency
           return true
         }
-        throw new Error(
-          `Slice index out of range: ${index} >= ${meta.length}`,
-        )
+        throw new Error(`Slice index out of range: ${index} >= ${meta.length}`)
       }
 
       if (prop === 'length' || prop === '__meta__') {
@@ -329,7 +333,12 @@ export const makeSlice = <T>(
       return new Uint8Array(length) as Slice<T>
     }
 
-    return byteSliceView(new Uint8Array(actualCapacity), 0, length, actualCapacity) as Slice<T>
+    return byteSliceView(
+      new Uint8Array(actualCapacity),
+      0,
+      length,
+      actualCapacity,
+    ) as Slice<T>
   }
 
   const actualCapacity = capacity === undefined ? length : capacity
@@ -535,8 +544,7 @@ export function goSlice<T>( // T can be number for Uint8Array case
   if (s instanceof Uint8Array) {
     const meta = byteSliceMeta(s)
     const metaBacking = meta?.backing as unknown
-    const backing =
-      metaBacking instanceof Uint8Array ? metaBacking : s
+    const backing = metaBacking instanceof Uint8Array ? metaBacking : s
     const baseOffset = meta?.offset ?? 0
     const baseCapacity = meta?.capacity ?? s.length
     const actualLow = low ?? 0
@@ -1003,8 +1011,7 @@ export function append<T>(
 function appendByteSlice(slice: Uint8Array, elements: any[]): Uint8Array {
   const meta = byteSliceMeta(slice)
   const metaBacking = meta?.backing as unknown
-  const backing =
-    metaBacking instanceof Uint8Array ? metaBacking : slice
+  const backing = metaBacking instanceof Uint8Array ? metaBacking : slice
   const offset = meta?.offset ?? 0
   const oldLength = slice.length
   const oldCapacity = meta?.capacity ?? oldLength
@@ -1032,12 +1039,18 @@ function byteElementLength(item: any): number {
     return len(item as Slice<any>)
   }
   if (typeof item !== 'number') {
-    throw new Error('Cannot produce Uint8Array: appended elements contain non-numbers.')
+    throw new Error(
+      'Cannot produce Uint8Array: appended elements contain non-numbers.',
+    )
   }
   return 1
 }
 
-function writeByteElements(dst: Uint8Array, offset: number, elements: any[]): void {
+function writeByteElements(
+  dst: Uint8Array,
+  offset: number,
+  elements: any[],
+): void {
   let cursor = offset
   for (const item of elements) {
     if (item instanceof Uint8Array) {
@@ -1060,7 +1073,9 @@ function writeByteElements(dst: Uint8Array, offset: number, elements: any[]): vo
       continue
     }
     if (typeof item !== 'number') {
-      throw new Error('Cannot produce Uint8Array: appended elements contain non-numbers.')
+      throw new Error(
+        'Cannot produce Uint8Array: appended elements contain non-numbers.',
+      )
     }
     dst[cursor] = item
     cursor++
@@ -1394,6 +1409,8 @@ export function sliceFromOwnedPointer<T>(
 export function arrayPointerFromIndexRef<T>(
   ref: VarRef<T>,
   length: number,
+  sourceElementByteSize = 1,
+  targetElementByteSize = sourceElementByteSize,
 ): VarRef<Slice<T> | T[] | Uint8Array> {
   const collection = ref.__goCollection as
     | Slice<T>
@@ -1406,12 +1423,25 @@ export function arrayPointerFromIndexRef<T>(
     )
   }
   const index = ref.__goIndex ?? 0
-  return varRef(
-    goSlice(collection as any, index, index + length) as
-      | Slice<T>
-      | T[]
-      | Uint8Array,
-  )
+  const view =
+    targetElementByteSize === 1 && sourceElementByteSize > 1 ?
+      byteArrayFromAddress(
+        indexByteAddress(collection, index, sourceElementByteSize),
+        length,
+      )
+    : (goSlice(collection as any, index, index + length) as
+        | Slice<T>
+        | T[]
+        | Uint8Array)
+  return {
+    get value() {
+      return view as Slice<T> | T[] | Uint8Array
+    },
+    set value(value: Slice<T> | T[] | Uint8Array) {
+      copy(view as any, value as any)
+    },
+    __isVarRef: true,
+  }
 }
 
 /**
@@ -1460,6 +1490,181 @@ export function indexAddress<T>(
   return base + backingIndex
 }
 
+function uintElementValue(value: unknown, byteSize: number): bigint {
+  const bits = BigInt(byteSize * 8)
+  if (typeof value === 'bigint') {
+    return BigInt.asUintN(Number(bits), value)
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return BigInt.asUintN(Number(bits), BigInt(Math.trunc(value)))
+  }
+  return 0n
+}
+
+function uintElementResult(value: bigint, byteSize: number): number {
+  const normalized = BigInt.asUintN(byteSize * 8, value)
+  if (normalized <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    return Number(normalized)
+  }
+  return normalized as unknown as number
+}
+
+function byteAddressBase(backing: object, source: ByteAddressSource): number {
+  let base = byteAddressBases.get(backing)
+  if (base === undefined) {
+    base = nextAddressBase * addressStride
+    nextAddressBase++
+    byteAddressBases.set(backing, base)
+  }
+  byteAddressSources.set(base, source)
+  return base
+}
+
+function numericByteSource(
+  backing: number[],
+  elementByteSize: number,
+): ByteAddressSource {
+  const byteSize = Math.max(1, Math.trunc(elementByteSize))
+  return {
+    byteLength: backing.length * byteSize,
+    getByte(offset: number): number {
+      const elementIndex = Math.trunc(offset / byteSize)
+      const byteOffset = offset % byteSize
+      const value = uintElementValue(backing[elementIndex], byteSize)
+      return Number((value >> BigInt(byteOffset * 8)) & 0xffn)
+    },
+    setByte(offset: number, value: number): void {
+      const elementIndex = Math.trunc(offset / byteSize)
+      const byteOffset = offset % byteSize
+      const shift = BigInt(byteOffset * 8)
+      const mask = 0xffn << shift
+      const current = uintElementValue(backing[elementIndex], byteSize)
+      const next = (current & ~mask) | ((BigInt(value) & 0xffn) << shift)
+      backing[elementIndex] = uintElementResult(next, byteSize)
+    },
+  }
+}
+
+/**
+ * indexByteAddress returns a byte-addressed synthetic address for unsafe
+ * uintptr arithmetic rooted at a slice or array element.
+ */
+export function indexByteAddress<T>(
+  collection: Slice<T> | T[] | Uint8Array,
+  index: number,
+  elementByteSize: number,
+): number {
+  if (collection === null || collection === undefined) {
+    throw new Error('runtime error: index on nil or undefined collection')
+  }
+
+  if (collection instanceof Uint8Array) {
+    if (index < 0 || index >= collection.length) {
+      throw new Error(
+        `runtime error: index out of range [${index}] with length ${collection.length}`,
+      )
+    }
+    const view = new Uint8Array(collection.buffer)
+    const base = byteAddressBase(collection.buffer, {
+      byteLength: view.length,
+      getByte(offset: number): number {
+        return view[offset]
+      },
+      setByte(offset: number, value: number): void {
+        view[offset] = value
+      },
+    })
+    return base + collection.byteOffset + index
+  }
+
+  if (isComplexSlice(collection)) {
+    if (index < 0 || index >= collection.__meta__.length) {
+      throw new Error(
+        `runtime error: index out of range [${index}] with length ${collection.__meta__.length}`,
+      )
+    }
+    const backing = collection.__meta__.backing as unknown as number[]
+    const byteSize = Math.max(1, Math.trunc(elementByteSize))
+    const base = byteAddressBase(backing, numericByteSource(backing, byteSize))
+    return base + (collection.__meta__.offset + index) * byteSize
+  }
+
+  if (Array.isArray(collection)) {
+    if (index < 0 || index >= collection.length) {
+      throw new Error(
+        `runtime error: index out of range [${index}] with length ${collection.length}`,
+      )
+    }
+    const byteSize = Math.max(1, Math.trunc(elementByteSize))
+    const base = byteAddressBase(
+      collection,
+      numericByteSource(collection as unknown as number[], byteSize),
+    )
+    return base + index * byteSize
+  }
+
+  throw new Error('runtime error: index on unsupported type')
+}
+
+/**
+ * unsafePointerRef resolves a byte-addressed synthetic unsafe pointer created
+ * by indexByteAddress back to an addressable byte reference.
+ */
+export function unsafePointerRef<T>(address: number | bigint): VarRef<T> {
+  const numericAddress = Number(address)
+  const base = Math.floor(numericAddress / addressStride) * addressStride
+  const source = byteAddressSources.get(base)
+  if (source === undefined) {
+    throw new Error(
+      'unsafe pointer dereference is not supported in JavaScript/TypeScript',
+    )
+  }
+  const offset = numericAddress - base
+  if (offset < 0 || offset >= source.byteLength) {
+    throw new Error('runtime error: unsafe pointer address out of range')
+  }
+  return {
+    get value(): T {
+      return source.getByte(offset) as T
+    },
+    set value(value: T) {
+      source.setByte(offset, value as number)
+    },
+    __isVarRef: true,
+  }
+}
+
+function byteArrayFromAddress(
+  address: number | bigint,
+  length: number,
+): number[] {
+  const start = Number(address)
+  const target = new Array<number>(length)
+  return new Proxy(target, {
+    get(arrayTarget, prop, receiver) {
+      const index = sliceIndexProperty(prop)
+      if (index >= 0) {
+        if (index >= length) {
+          throw new Error(`Slice index out of range: ${index} >= ${length}`)
+        }
+        return unsafePointerRef<number>(start + index).value
+      }
+      return Reflect.get(arrayTarget, prop, receiver)
+    },
+    set(arrayTarget, prop, value, receiver) {
+      const index = sliceIndexProperty(prop)
+      if (index >= 0) {
+        if (index >= length) {
+          throw new Error(`Slice index out of range: ${index} >= ${length}`)
+        }
+        unsafePointerRef<number>(start + index).value = value
+        return true
+      }
+      return Reflect.set(arrayTarget, prop, value, receiver)
+    },
+  })
+}
+
 /**
  * Converts a string to an array of Unicode code points (runes).
  * @param str The input string.

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

@@ -0,0 +1,120 @@
+import { describe, expect, test } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+import * as cipher from '@goscript/crypto/cipher/index.js'
+
+import { BlockSize, KeySizeError_Error, NewCipher } from './index.js'
+
+describe('crypto/aes WebCrypto override', () => {
+  test.each([
+    [
+      'AES-128',
+      '000102030405060708090a0b0c0d0e0f',
+      '00112233445566778899aabbccddeeff',
+      '69c4e0d86a7b0430d8cdb78070b4c55a',
+    ],
+    [
+      'AES-192',
+      '000102030405060708090a0b0c0d0e0f1011121314151617',
+      '00112233445566778899aabbccddeeff',
+      'dda97ca4864cdfe06eaf70a0ec0d7191',
+    ],
+    [
+      'AES-256',
+      '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
+      '00112233445566778899aabbccddeeff',
+      '8ea2b7ca516745bfeafc49904b496089',
+    ],
+  ])(
+    'encrypts and decrypts a raw %s block',
+    (_name, key, plaintext, ciphertext) => {
+      const [block, err] = NewCipher(hex(key))
+      expect(err).toBeNull()
+
+      const encrypted = new Uint8Array(BlockSize)
+      block!.Encrypt(encrypted, hex(plaintext))
+      expect(toHex(encrypted)).toBe(ciphertext)
+
+      const decrypted = new Uint8Array(BlockSize)
+      block!.Decrypt(decrypted, encrypted)
+      expect(toHex(decrypted)).toBe(plaintext)
+    },
+  )
+
+  test('seals and opens the NIST AES-256-GCM vector', async () => {
+    const [block, blockErr] = NewCipher(
+      hex('0000000000000000000000000000000000000000000000000000000000000000'),
+    )
+    expect(blockErr).toBeNull()
+    expect(block?.BlockSize()).toBe(BlockSize)
+
+    const [aead, aeadErr] = cipher.NewGCM(block)
+    expect(aeadErr).toBeNull()
+    expect(aead?.NonceSize()).toBe(12)
+    expect(aead?.Overhead()).toBe(16)
+
+    const sealed = await aead!.Seal(
+      null,
+      hex('000000000000000000000000'),
+      hex('00000000000000000000000000000000'),
+      null,
+    )
+    expect(toHex(sealed)).toBe(
+      'cea7403d4d606b6e074ec5d3baf39d18d0d1c8a799996bf0265b98b5d48ab919',
+    )
+
+    const [opened, openErr] = await aead!.Open(
+      $.stringToBytes('prefix:'),
+      hex('000000000000000000000000'),
+      sealed,
+      null,
+    )
+    expect(openErr).toBeNull()
+    expect(toHex(opened)).toBe(
+      toHex($.stringToBytes('prefix:')) + '00000000000000000000000000000000',
+    )
+  })
+
+  test('rejects tampered ciphertext', async () => {
+    const [block] = NewCipher(
+      hex('0000000000000000000000000000000000000000000000000000000000000000'),
+    )
+    const [aead] = cipher.NewGCM(block)
+    const sealed = await aead!.Seal(
+      null,
+      hex('000000000000000000000000'),
+      $.stringToBytes('hello'),
+      $.stringToBytes('aad'),
+    )
+    sealed![0] ^= 1
+
+    const [opened, openErr] = await aead!.Open(
+      null,
+      hex('000000000000000000000000'),
+      sealed,
+      $.stringToBytes('aad'),
+    )
+    expect(opened).toBeNull()
+    expect(openErr?.Error()).toBe('cipher: message authentication failed')
+  })
+
+  test('rejects invalid key lengths', () => {
+    const [block, err] = NewCipher(new Uint8Array(31))
+    expect(block).toBeNull()
+    expect(err?.Error()).toBe(KeySizeError_Error(31))
+  })
+})
+
+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('')
+}