goscript 0.1.3 → 0.2.0

package/gs/builtin/varRef.ts

@@ -1,3 +1,10 @@
+export interface OwnedPointerHandle<T = unknown> {
+  readonly __goOwnedPointer: true
+  __goAddress: () => number
+  __goRef: () => VarRef<T>
+  __goSlice?: (length: number) => unknown
+}
+
 /**
  * VarRef represents a Go variable which can be referred to by other variables.
  *
@@ -12,6 +19,51 @@ export type VarRef<T> = {
   __goAddress?: () => number
   __goCollection?: unknown
   __goIndex?: number
+  __goPointer?: OwnedPointerHandle<T>
+}
+
+const pointerAddressStride = 0x100000000
+const pointerAddresses = new WeakMap<object, number>()
+const fieldPointerAddresses = new WeakMap<
+  object,
+  globalThis.Map<PropertyKey, number>
+>()
+let nextPointerAddress = 1
+
+function pointerAddress(value: object): number {
+  let address = pointerAddresses.get(value)
+  if (address === undefined) {
+    address = nextPointerAddress * pointerAddressStride
+    nextPointerAddress++
+    pointerAddresses.set(value, address)
+  }
+  return address
+}
+
+function fieldPointerAddress(target: object, key: PropertyKey): number {
+  let addresses = fieldPointerAddresses.get(target)
+  if (addresses === undefined) {
+    addresses = new globalThis.Map<PropertyKey, number>()
+    fieldPointerAddresses.set(target, addresses)
+  }
+  let address = addresses.get(key)
+  if (address === undefined) {
+    address = nextPointerAddress * pointerAddressStride
+    nextPointerAddress++
+    addresses.set(key, address)
+  }
+  return address
+}
+
+function refPointer<T>(
+  ref: VarRef<T>,
+  address: () => number,
+): OwnedPointerHandle<T> {
+  return {
+    __goOwnedPointer: true,
+    __goAddress: address,
+    __goRef: () => ref,
+  }
 }
 
 /** Wrap a non-null T in a variable reference. */
@@ -19,7 +71,10 @@ export function varRef<T>(v: T): VarRef<T> {
   // We create a new object wrapper for every varRef call to ensure
   // distinct pointer identity, crucial for pointer comparisons (p1 == p2).
   // The __isVarRef marker allows the reflect system to identify this as a pointer type.
-  return { value: v, __isVarRef: true }
+  const ref: VarRef<T> = { value: v, __isVarRef: true }
+  ref.__goAddress = () => pointerAddress(ref)
+  ref.__goPointer = refPointer(ref, ref.__goAddress)
+  return ref
 }
 
 /** Create a variable reference to an object field. */
@@ -27,7 +82,8 @@ export function fieldRef<T extends object, K extends keyof T>(
   target: T,
   key: K,
 ): VarRef<T[K]> {
-  return {
+  const address = () => fieldPointerAddress(target, key)
+  const ref: VarRef<T[K]> = {
     get value(): T[K] {
       return target[key]
     },
@@ -35,7 +91,10 @@ export function fieldRef<T extends object, K extends keyof T>(
       target[key] = value
     },
     __isVarRef: true,
+    __goAddress: address,
   }
+  ref.__goPointer = refPointer(ref, address)
+  return ref
 }
 
 /** Check if a value is a VarRef (pointer) */
@@ -43,6 +102,30 @@ export function isVarRef(v: unknown): v is VarRef<unknown> {
   return v !== null && typeof v === 'object' && (v as any).__isVarRef === true
 }
 
+export function isOwnedPointerHandle(
+  value: unknown,
+): value is OwnedPointerHandle {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    (value as { __goOwnedPointer?: unknown }).__goOwnedPointer === true
+  )
+}
+
+export function ownedPointerFromRef<T>(
+  ref: VarRef<T>,
+): OwnedPointerHandle<T> | undefined {
+  return ref.__goPointer
+}
+
+export function ownedPointerAddress(pointer: OwnedPointerHandle): number {
+  return pointer.__goAddress()
+}
+
+export function ownedPointerRef<T>(pointer: OwnedPointerHandle<T>): VarRef<T> {
+  return pointer.__goRef()
+}
+
 /** Dereference a variable reference, throws on null → simulates Go panic. */
 export function unref<T>(b: VarRef<T>): T {
   if (b === null) {

package/gs/bytes/buffer.gs.ts

@@ -549,7 +549,7 @@ export class Buffer {
 	  new Buffer(),
 	  [{ name: "Bytes", args: [], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }] }, { name: "AvailableBuffer", args: [], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }] }, { name: "String", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "empty", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Len", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Cap", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Available", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Truncate", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "Reset", args: [], returns: [] }, { name: "tryGrowByReslice", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "grow", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Grow", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "Write", args: [{ name: "p", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteString", args: [{ name: "s", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadFrom", args: [{ name: "r", type: "Reader" }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteTo", args: [{ name: "w", type: "Writer" }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteByte", args: [{ name: "c", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteRune", args: [{ name: "r", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Read", args: [{ name: "p", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Next", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }] }, { name: "ReadByte", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadRune", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "UnreadRune", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "UnreadByte", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadBytes", args: [{ name: "delim", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "readSlice", args: [{ name: "delim", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadString", args: [{ name: "delim", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }],
 	  Buffer,
-	  {"buf": { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } }, "off": { kind: $.TypeKind.Basic, name: "number" }, "lastRead": "readOp"}
+	  [{ name: "buf", key: "buf", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { name: "off", key: "off", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "lastRead", key: "lastRead", type: "readOp" }]
 	);
 }
 

package/gs/bytes/reader.gs.ts

@@ -221,7 +221,7 @@ export class Reader {
 	  new Reader(),
 	  [{ name: "Len", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Size", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Read", args: [{ name: "b", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadAt", args: [{ name: "b", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { name: "off", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadByte", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "UnreadByte", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadRune", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "UnreadRune", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Seek", args: [{ name: "offset", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "whence", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteTo", args: [{ name: "w", type: "Writer" }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Reset", args: [{ name: "b", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [] }],
 	  Reader,
-	  {"s": { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } }, "i": { kind: $.TypeKind.Basic, name: "number" }, "prevRune": { kind: $.TypeKind.Basic, name: "number" }}
+	  [{ name: "s", key: "s", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { name: "i", key: "i", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "prevRune", key: "prevRune", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }
 

package/gs/compress/zlib/index.test.ts

@@ -4,9 +4,43 @@ import * as $ from '@goscript/builtin/index.js'
 import * as bytes from '@goscript/bytes/index.js'
 import * as io from '@goscript/io/index.js'
 
-import { NewReader, NewWriter } from './index.js'
+import {
+  BestCompression,
+  BestSpeed,
+  DefaultCompression,
+  ErrChecksum,
+  ErrDictionary,
+  HuffmanOnly,
+  NewReader,
+  NewReaderDict,
+  NewWriter,
+  NewWriterLevel,
+  NewWriterLevelDict,
+  NoCompression,
+} from './index.js'
 
 describe('compress/zlib override', () => {
+  test('exports flate compression level constants', () => {
+    expect(NoCompression).toBe(0)
+    expect(BestSpeed).toBe(1)
+    expect(BestCompression).toBe(9)
+    expect(DefaultCompression).toBe(-1)
+    expect(HuffmanOnly).toBe(-2)
+  })
+
+  test('rejects invalid compression levels', () => {
+    const buf = $.markAsStructValue(new bytes.Buffer())
+
+    expect(NewWriterLevel(buf, HuffmanOnly)[1]).toBeNull()
+    expect(NewWriterLevel(buf, BestCompression)[1]).toBeNull()
+    expect(NewWriterLevel(buf, HuffmanOnly - 1)[1]?.Error()).toBe(
+      'zlib: invalid compression level: -3',
+    )
+    expect(NewWriterLevelDict(buf, BestCompression + 1, null)[1]?.Error()).toBe(
+      'zlib: invalid compression level: 10',
+    )
+  })
+
   test('round trips bytes through writer and reader', async () => {
     const input = $.stringToBytes('hello compressed world')
     const buf = $.markAsStructValue(new bytes.Buffer())
@@ -25,4 +59,128 @@ describe('compress/zlib override', () => {
     expect(readErr).toBeNull()
     expect($.bytesToString(out)).toBe('hello compressed world')
   })
+
+  test('reader implements resettable zlib reader contract', async () => {
+    const first = $.markAsStructValue(new bytes.Buffer())
+    const firstWriter = NewWriter(first)
+    expect(firstWriter.Write($.stringToBytes('first stream'))[1]).toBeNull()
+    expect(await firstWriter.Close()).toBeNull()
+
+    const second = $.markAsStructValue(new bytes.Buffer())
+    const secondWriter = NewWriter(second)
+    expect(secondWriter.Write($.stringToBytes('second stream'))[1]).toBeNull()
+    expect(await secondWriter.Close()).toBeNull()
+
+    const readerInterface = $.registerInterfaceType(
+      'compress/zlib.testReader',
+      null,
+      [
+        { name: 'Close', args: [], returns: [{ type: 'error' }] },
+        {
+          name: 'Read',
+          args: [
+            {
+              name: 'p',
+              type: {
+                kind: $.TypeKind.Slice,
+                elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+              },
+            },
+          ],
+          returns: [{ type: 'int' }, { type: 'error' }],
+        },
+        {
+          name: 'Reset',
+          args: [{ type: 'io.Reader' }, { type: '[]byte' }],
+          returns: [{ type: 'error' }],
+        },
+      ],
+    )
+
+    const [reader, readerErr] = NewReader(bytes.NewReader(first.Bytes()))
+    expect(readerErr).toBeNull()
+    const [zlibReader, ok] = $.typeAssertTuple<
+      io.ReadCloser & {
+        Reset(r: io.Reader | null, dict: $.Bytes | null): $.GoError
+      }
+    >(reader, readerInterface)
+    expect(ok).toBe(true)
+
+    const [firstOut, firstReadErr] = await io.ReadAll(zlibReader)
+    expect(firstReadErr).toBeNull()
+    expect($.bytesToString(firstOut)).toBe('first stream')
+
+    expect(zlibReader.Reset(bytes.NewReader(second.Bytes()), null)).toBeNull()
+    const [secondOut, secondReadErr] = await io.ReadAll(zlibReader)
+    expect(secondReadErr).toBeNull()
+    expect($.bytesToString(secondOut)).toBe('second stream')
+  })
+
+  test('writer and reader honor preset dictionaries', async () => {
+    const dict = $.stringToBytes('hello dictionary')
+    const compressed = $.markAsStructValue(new bytes.Buffer())
+    const [writer, writerErr] = NewWriterLevelDict(compressed, DefaultCompression, dict)
+    expect(writerErr).toBeNull()
+    expect(writer!.Write($.stringToBytes('hello dictionary payload'))[1]).toBeNull()
+    expect(await writer!.Close()).toBeNull()
+
+    const [missingDictReader, missingDictErr] = NewReader(bytes.NewReader(compressed.Bytes()))
+    expect(missingDictReader).toBeNull()
+    expect(missingDictErr).toBe(ErrDictionary)
+
+    const [reader, readerErr] = NewReaderDict(bytes.NewReader(compressed.Bytes()), dict)
+    expect(readerErr).toBeNull()
+    const [out, readErr] = await io.ReadAll(reader!)
+    expect(readErr).toBeNull()
+    expect($.bytesToString(out)).toBe('hello dictionary payload')
+
+    const [, wrongDictErr] = NewReaderDict(bytes.NewReader(compressed.Bytes()), $.stringToBytes('wrong dictionary'))
+    expect(wrongDictErr).toBe(ErrDictionary)
+
+    const corrupt = Uint8Array.from(compressed.Bytes())
+    corrupt[corrupt.length - 1] ^= 0xff
+    const [, corruptErr] = NewReaderDict(bytes.NewReader(corrupt), dict)
+    expect(corruptErr).toBe(ErrChecksum)
+  })
+
+  test('reader reset accepts async generated readers', async () => {
+    const compressed = $.markAsStructValue(new bytes.Buffer())
+    const writer = NewWriter(compressed)
+    expect(writer.Write($.stringToBytes('async source stream'))[1]).toBeNull()
+    expect(await writer.Close()).toBeNull()
+
+    const source = bytes.NewReader(compressed.Bytes())
+    const asyncReader = {
+      async Read(p: $.Bytes): Promise<[number, $.GoError]> {
+        await Promise.resolve()
+        return source.Read(p)
+      },
+    }
+
+    const [reader, readerErr] = NewReader(asyncReader as io.Reader)
+    expect(readerErr).toBeNull()
+    const [out, readErr] = await io.ReadAll(reader!)
+    expect(readErr).toBeNull()
+    expect($.bytesToString(out)).toBe('async source stream')
+  })
+
+  test('Close awaits pointer-wrapped generated writers', async () => {
+    const chunks: number[] = []
+    const sink = {
+      async Write(p: $.Bytes): Promise<[number, $.GoError]> {
+        await Promise.resolve()
+        chunks.push(...Array.from(p ?? []))
+        return [$.len(p), null]
+      },
+    }
+    const writer = NewWriter(
+      $.interfaceValue($.varRef(sink), '*zlib.asyncWriter'),
+    )
+
+    const [written, writeErr] = writer.Write($.stringToBytes('async zlib sink'))
+    expect(writeErr).toBeNull()
+    expect(written).toBe('async zlib sink'.length)
+    expect(await writer.Close()).toBeNull()
+    expect(chunks.length).toBeGreaterThan(0)
+  })
 })

package/gs/compress/zlib/index.ts

@@ -3,13 +3,25 @@ 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>
+  Reset(r: io.Reader | null, dict: $.Bytes | null): $.GoError
 }
 
+type maybeAsyncWriter = {
+  Write(p: $.Bytes): [number, $.GoError] | Promise<[number, $.GoError]>
+}
+
+export const NoCompression = 0
+export const BestSpeed = 1
+export const BestCompression = 9
+export const DefaultCompression = -1
+export const HuffmanOnly = -2
+
 export let ErrChecksum = errors.New('zlib: invalid checksum')
 export let ErrDictionary = errors.New('zlib: invalid dictionary')
 export let ErrHeader = errors.New('zlib: invalid header')
 
+type nodeZlibError = Error & { code?: unknown }
+
 export function __goscript_set_ErrChecksum(value: $.GoError): void {
   ErrChecksum = value
 }
@@ -22,12 +34,30 @@ export function __goscript_set_ErrHeader(value: $.GoError): void {
   ErrHeader = value
 }
 
-class zlibReader implements io.ReadCloser {
+class zlibReader implements Resetter {
+  private data: Uint8Array = new Uint8Array(0)
   private offset = 0
+  private pending:
+    | Promise<{ data: Uint8Array | null; err: $.GoError }>
+    | null = null
 
-  constructor(private data: Uint8Array) {}
+  constructor(data?: Uint8Array) {
+    if (data != null) {
+      this.data = data
+    }
+  }
 
-  Read(p: $.Bytes): [number, $.GoError] {
+  async Read(p: $.Bytes): Promise<[number, $.GoError]> {
+    const pending = this.pending
+    if (pending != null) {
+      this.pending = null
+      const result = await pending
+      if (result.err != null) {
+        return [0, result.err]
+      }
+      this.data = result.data ?? new Uint8Array(0)
+      this.offset = 0
+    }
     if (this.offset >= this.data.length) {
       return [0, io.EOF]
     }
@@ -41,13 +71,37 @@ class zlibReader implements io.ReadCloser {
   Close(): $.GoError {
     return null
   }
+
+  Reset(r: io.Reader | null, dict: $.Bytes | null): $.GoError {
+    if (r == null) {
+      return errors.New('zlib: nil reader')
+    }
+    const result = readInflated(r, dict)
+    if (result instanceof Promise) {
+      this.data = new Uint8Array(0)
+      this.offset = 0
+      this.pending = result
+      return null
+    }
+    if (result.err != null) {
+      return result.err
+    }
+    this.data = result.data ?? new Uint8Array(0)
+    this.offset = 0
+    this.pending = null
+    return null
+  }
 }
 
 export class Writer {
   private chunks: Uint8Array[] = []
   private closed = false
 
-  constructor(private w: io.Writer | null) {}
+  constructor(
+    private w: io.Writer | null,
+    private dict: $.Bytes | null = null,
+    private level = DefaultCompression,
+  ) {}
 
   Write(p: $.Bytes): [number, $.GoError] {
     if (this.closed) {
@@ -58,7 +112,7 @@ export class Writer {
     return [data.length, null]
   }
 
-  Close(): $.GoError {
+  async Close(): Promise<$.GoError> {
     if (this.closed) {
       return null
     }
@@ -66,8 +120,9 @@ export class Writer {
     if (this.w == null) {
       return errors.New('zlib: nil writer')
     }
-    const compressed = deflate(concat(this.chunks))
-    const [, err] = this.w.Write(compressed)
+    const compressed = deflate(concat(this.chunks), this.dict, this.level)
+    const writer = $.pointerValue<maybeAsyncWriter>(this.w)
+    const [, err] = await writer.Write(compressed)
     return err
   }
 
@@ -88,17 +143,23 @@ export function NewWriter(w: io.Writer | null): Writer {
 
 export function NewWriterLevel(
   w: io.Writer | null,
-  _level: number,
+  level: number,
 ): [Writer | null, $.GoError] {
-  return [new Writer(w), null]
+  if (level < HuffmanOnly || level > BestCompression) {
+    return [null, errors.New(`zlib: invalid compression level: ${level}`)]
+  }
+  return [new Writer(w, null, level), null]
 }
 
 export function NewWriterLevelDict(
   w: io.Writer | null,
-  _level: number,
+  level: number,
   _dict: $.Bytes | null,
 ): [Writer | null, $.GoError] {
-  return [new Writer(w), null]
+  if (level < HuffmanOnly || level > BestCompression) {
+    return [null, errors.New(`zlib: invalid compression level: ${level}`)]
+  }
+  return [new Writer(w, _dict, level), null]
 }
 
 export function NewReader(
@@ -109,31 +170,35 @@ export function NewReader(
 
 export function NewReaderDict(
   r: io.Reader | null,
-  _dict: $.Bytes | 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]
+  const reader = new zlibReader()
+  const err = reader.Reset(r, dict)
+  if (err != null) {
+    return [null, err]
   }
+  return [reader as any, null]
 }
 
-function deflate(data: Uint8Array): Uint8Array {
+function deflate(data: Uint8Array, dict: $.Bytes | null, level: number): Uint8Array {
   const zlib = nodeZlib()
-  return new Uint8Array(zlib.deflateSync(data))
+  const opts: Record<string, unknown> = {}
+  if (dict != null && $.len(dict) > 0) {
+    opts.dictionary = $.bytesToUint8Array(dict)
+  }
+  if (level === HuffmanOnly) {
+    opts.strategy = zlib.constants?.Z_HUFFMAN_ONLY
+    opts.level = DefaultCompression
+  } else {
+    opts.level = level
+  }
+  return new Uint8Array(zlib.deflateSync(data, opts))
 }
 
-function inflate(data: Uint8Array): Uint8Array {
+function inflate(data: Uint8Array, dict: $.Bytes | null): Uint8Array {
   const zlib = nodeZlib()
-  return new Uint8Array(zlib.inflateSync(data))
+  const opts = dict != null && $.len(dict) > 0 ? { dictionary: $.bytesToUint8Array(dict) } : undefined
+  return new Uint8Array(zlib.inflateSync(data, opts))
 }
 
 function nodeZlib(): any {
@@ -168,23 +233,85 @@ function nodeZlib(): any {
   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')
+function readInflated(
+  r: io.Reader,
+  dict: $.Bytes | null,
+):
+  | { data: Uint8Array | null; err: $.GoError }
+  | Promise<{ data: Uint8Array | null; err: $.GoError }> {
+  const chunks: number[] = []
+  const buf = $.makeSlice<number>(1, undefined, 'byte')
   while (true) {
-    const [n, err] = r.Read(buf)
-    if (n > 0) {
-      chunks.push($.bytesToUint8Array($.goSlice(buf, 0, n)).slice())
+    const read = r.Read(buf)
+    if (read instanceof Promise) {
+      return readInflatedAsync(read, r, buf, chunks, dict)
+    }
+    const [n, err] = read
+    const result = recordCompressedBytes(chunks, buf, n, dict)
+    if (result.err == null && result.data != null) {
+      return result
     }
     if (err != null) {
       if (err === io.EOF) {
-        return [concat(chunks), null]
+        return result
       }
-      return [new Uint8Array(0), err]
+      return { data: null, err }
     }
   }
 }
 
+async function readInflatedAsync(
+  first: Promise<[number, $.GoError]>,
+  r: io.Reader,
+  buf: $.Bytes,
+  chunks: number[],
+  dict: $.Bytes | null,
+): Promise<{ data: Uint8Array | null; err: $.GoError }> {
+  let read = await first
+  while (true) {
+    const [n, err] = read
+    const result = recordCompressedBytes(chunks, buf, n, dict)
+    if (result.err == null && result.data != null) {
+      return result
+    }
+    if (err != null) {
+      if (err === io.EOF) {
+        return result
+      }
+      return { data: null, err }
+    }
+    read = await r.Read(buf)
+  }
+}
+
+function recordCompressedBytes(
+  chunks: number[],
+  buf: $.Bytes,
+  n: number,
+  dict: $.Bytes | null,
+): { data: Uint8Array | null; err: $.GoError } {
+  if (n > 0) {
+    chunks.push(...$.bytesToUint8Array($.goSlice(buf, 0, n)))
+  }
+  const compressed = new Uint8Array(chunks)
+  try {
+    return { data: inflate(compressed, dict), err: null }
+  } catch (err) {
+    return { data: null, err: classifyInflateError(err) }
+  }
+}
+
+function classifyInflateError(err: unknown): $.GoError {
+  const zerr = err instanceof Error ? err as nodeZlibError : null
+  if (zerr?.code === 'Z_NEED_DICT') {
+    return ErrDictionary
+  }
+  if (zerr?.code === 'Z_DATA_ERROR' && zerr.message.includes('incorrect data check')) {
+    return ErrChecksum
+  }
+  return ErrHeader
+}
+
 function concat(chunks: Uint8Array[]): Uint8Array {
   let total = 0
   for (const chunk of chunks) {

package/gs/compress/zlib/meta.json

@@ -1,3 +1,6 @@
 {
-  "dependencies": []
+  "dependencies": [],
+  "asyncMethods": {
+    "Writer.Close": true
+  }
 }

package/gs/compress/zlib/parity.json

@@ -0,0 +1,51 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "BestCompression": {
+      "status": "real"
+    },
+    "BestSpeed": {
+      "status": "real"
+    },
+    "DefaultCompression": {
+      "status": "real"
+    },
+    "ErrChecksum": {
+      "status": "real"
+    },
+    "ErrDictionary": {
+      "status": "real"
+    },
+    "ErrHeader": {
+      "status": "real"
+    },
+    "HuffmanOnly": {
+      "status": "real"
+    },
+    "NewReader": {
+      "status": "real"
+    },
+    "NewReaderDict": {
+      "status": "real"
+    },
+    "NewWriter": {
+      "status": "real"
+    },
+    "NewWriterLevel": {
+      "status": "real"
+    },
+    "NewWriterLevelDict": {
+      "status": "real"
+    },
+    "NoCompression": {
+      "status": "real"
+    },
+    "Resetter": {
+      "status": "real"
+    },
+    "Writer": {
+      "status": "real"
+    }
+  }
+}