Write bytes.
Read them back.

import { "moonbitstack/moonzip" }

let packed = @gzip.gzip(b"the body"[:])
let back   = @gzip.gunzip(packed[:])

// Nothing is held whole: the only state between calls is the 32 KiB window
// the compressor needs and four bytes of running checksum.
let writer = @gzip.Writer::new(level=9)
for part in parts {
  for b in writer.push(part) { out.push(b) }
}
for b in writer.finish() { out.push(b) }

let archive = @zip.zip([
  @zip.Entry::new("readme.txt", body),
  @zip.Entry::new("data/table.csv", table),
][:])

// or the same thing, one member at a time
let w = @zip.Writer::new(password="a password")
w.add(entry)   // returns that member's bytes now
w.finish()     // returns the directory at the end

// compressor
w.push(chunk)   → the bytes that are ready (maybe none)
w.finish()      → the rest, plus the trailer

// decompressor
r.push(chunk)   → the bytes it decoded, possibly across a symbol
r.finish()      → the rest, and the trailer is checked here

• A header field. Status lines, file names, pax records. The reader gathers until the header is complete, with a bound so a stream that never ends is refused rather than buffered forever.
• A Huffman code. The decoder never consumes half a symbol and waits: eight bytes of buffered input cover the widest step, and with fewer than that it stops.
• A stored block. The payload is copied straight out of the buffer, and a chunk boundary in the middle of one is ordinary.
• A data descriptor. When an entry's sizes follow its data, the DEFLATE stream itself says where it ended, and the descriptor is read from there.

Every streaming test feeds the same body in one, two, three, five, seven, thirteen, sixty-four, five-hundred-and-eleven, four-thousand-and-ninety-six and sixty-five-thousand-five-hundred-and-thirty-six byte pieces, and requires the same bytes out each time. The boundaries that break a naive decoder are never the round ones.

pub(all) suberror Refused {
  Truncated(at~ : Int32)                   // ends in the middle of something
  Header(at~ : Int32, what~ : String)      // a field the format does not allow
  Code(at~ : Int32)                        // a code no symbol is assigned to
  Distance(at~ : Int32)                    // a back-reference before the start
  Checksum(want~ : UInt32, got~ : UInt32)
  Length(want~ : UInt32, got~ : Int32)
  TooBig(limit~ : Int32)                   // the caller's own bound
}

scripts/conformance.py takes every stream src/examples/vectors prints and hands it to an independent reference decoder. Every combination of level, block type, chunk size, Zip64, descriptor and password has to come back as the body it started from.

scripts/interop.py writes archives with the platform's standard archive writers — the plain form, one with data descriptors because the sink it wrote to could not seek, a forced Zip64 header, and tar in ustar, pax and GNU — and pins them as tests. They are the shapes our own writer would never produce.

• moon check --target all --deny-warn — four backends, and a warning is an error.
• moon test --target all — the same tests on wasm, wasm-gc, js and native.
• moon fmt, then git diff --exit-code — formatting is not a matter of taste here.
• moon info, then git diff --exit-code — the interface is checked in, so a change to it shows up in the diff.