zlib-streams 1.0.7 → 1.1.0

package/src/inflate.c

@@ -91,7 +91,8 @@
 #include "zutil.h"
 #include "inftrees.h"
 #include "inflate.h"
-#include "inffast.h"
+#include "inffast_chunk.h"
+#include "chunkcopy.h"
 
 #ifndef BUILDFIXED
 #  define BUILDFIXED
@@ -215,6 +216,7 @@ int ZEXPORT inflateInit2_(z_streamp strm, int windowBits,
     state->strm = strm;
     state->window = Z_NULL;
     state->mode = HEAD;     /* to pass state test in inflateReset2() */
+    state->check = 1L;      /* 1L is the result of adler32() zero length data */
     ret = inflateReset2(strm, windowBits);
     if (ret != Z_OK) {
         ZFREE(strm, state);
@@ -380,10 +382,20 @@ local int updatewindow(z_streamp strm, const Bytef *end, unsigned copy) {
 
     /* if it hasn't been done already, allocate space for the window */
     if (state->window == Z_NULL) {
+        unsigned wsize = 1U << state->wbits;
         state->window = (unsigned char FAR *)
-                        ZALLOC(strm, 1U << state->wbits,
+                        ZALLOC(strm, wsize + CHUNKCOPY_CHUNK_SIZE,
                                sizeof(unsigned char));
         if (state->window == Z_NULL) return 1;
+#ifdef INFLATE_CLEAR_UNUSED_UNDEFINED
+        /* Copies from the overflow portion of this buffer are undefined and
+           may cause analysis tools to raise a warning if we don't initialize
+           it.  However, this undefined data overwrites other undefined data
+           and is subsequently either overwritten or left deliberately
+           undefined at the end of decode; so there's really no point.
+         */
+        zmemzero(state->window + wsize, CHUNKCOPY_CHUNK_SIZE);
+#endif
     }
 
     /* if window not in use yet, initialize */
@@ -649,12 +661,12 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
             if (
 #endif
                 ((BITS(8) << 8) + (hold >> 8)) % 31) {
-                strm->msg = (z_const char *)"incorrect header check";
+                strm->msg = (char *)"incorrect header check";
                 state->mode = BAD;
                 break;
             }
             if (BITS(4) != Z_DEFLATED) {
-                strm->msg = (z_const char *)"unknown compression method";
+                strm->msg = (char *)"unknown compression method";
                 state->mode = BAD;
                 break;
             }
@@ -663,7 +675,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
             if (state->wbits == 0)
                 state->wbits = len;
             if (len > 15 || len > state->wbits) {
-                strm->msg = (z_const char *)"invalid window size";
+                strm->msg = (char *)"invalid window size";
                 state->mode = BAD;
                 break;
             }
@@ -679,12 +691,12 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
             NEEDBITS(16);
             state->flags = (int)(hold);
             if ((state->flags & 0xff) != Z_DEFLATED) {
-                strm->msg = (z_const char *)"unknown compression method";
+                strm->msg = (char *)"unknown compression method";
                 state->mode = BAD;
                 break;
             }
             if (state->flags & 0xe000) {
-                strm->msg = (z_const char *)"unknown header flags set";
+                strm->msg = (char *)"unknown header flags set";
                 state->mode = BAD;
                 break;
             }
@@ -800,7 +812,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
             if (state->flags & 0x0200) {
                 NEEDBITS(16);
                 if ((state->wrap & 4) && hold != (state->check & 0xffff)) {
-                    strm->msg = (z_const char *)"header crc mismatch";
+                    strm->msg = (char *)"header crc mismatch";
                     state->mode = BAD;
                     break;
                 }
@@ -862,7 +874,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
                 state->mode = TABLE;
                 break;
             case 3:
-                strm->msg = (z_const char *)"invalid block type";
+                strm->msg = (char *)"invalid block type";
                 state->mode = BAD;
             }
             DROPBITS(2);
@@ -871,7 +883,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
             BYTEBITS();                         /* go to byte boundary */
             NEEDBITS(32);
             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
-                strm->msg = (z_const char *)"invalid stored block lengths";
+                strm->msg = (char *)"invalid stored block lengths";
                 state->mode = BAD;
                 break;
             }
@@ -913,7 +925,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
 #ifndef PKZIP_BUG_WORKAROUND
             if (state->nlen > 286 ||
                 (!state->deflate64 && state->ndist > 30)) {
-                strm->msg = (z_const char *)"too many length or distance symbols";
+                strm->msg = (char *)"too many length or distance symbols";
                 state->mode = BAD;
                 break;
             }
@@ -937,7 +949,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
                                 &(state->lenbits), state->work,
                                 state->deflate64);
             if (ret) {
-                strm->msg = (z_const char *)"invalid code lengths set";
+                strm->msg = (char *)"invalid code lengths set";
                 state->mode = BAD;
                 break;
             }
@@ -961,7 +973,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
                         NEEDBITS(here.bits + 2);
                         DROPBITS(here.bits);
                         if (state->have == 0) {
-                            strm->msg = (z_const char *)"invalid bit length repeat";
+                            strm->msg = (char *)"invalid bit length repeat";
                             state->mode = BAD;
                             break;
                         }
@@ -984,7 +996,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
                         DROPBITS(7);
                     }
                     if (state->have + copy > state->nlen + state->ndist) {
-                        strm->msg = (z_const char *)"invalid bit length repeat";
+                        strm->msg = (char *)"invalid bit length repeat";
                         state->mode = BAD;
                         break;
                     }
@@ -998,13 +1010,13 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
 
             /* check for end-of-block code (better have one) */
             if (state->lens[256] == 0) {
-                strm->msg = (z_const char *)"invalid code -- missing end-of-block";
+                strm->msg = (char *)"invalid code -- missing end-of-block";
                 state->mode = BAD;
                 break;
             }
 
             /* build code tables -- note: do not change the lenbits or distbits
-               values here (9 and 6) without reading the comments in inftrees.h
+               values here (10 and 9) without reading the comments in inftrees.h
                concerning the ENOUGH constants, which depend on those values */
             state->next = state->codes;
             state->lencode = (const code FAR *)(state->next);
@@ -1013,7 +1025,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
                                 &(state->lenbits), state->work,
                                 state->deflate64);
             if (ret) {
-                strm->msg = (z_const char *)"invalid literal/lengths set";
+                strm->msg = (char *)"invalid literal/lengths set";
                 state->mode = BAD;
                 break;
             }
@@ -1023,7 +1035,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
                             &(state->next), &(state->distbits), state->work,
                             state->deflate64);
             if (ret) {
-                strm->msg = (z_const char *)"invalid distances set";
+                strm->msg = (char *)"invalid distances set";
                 state->mode = BAD;
                 break;
             }
@@ -1035,9 +1047,10 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
             state->mode = LEN;
                 /* fallthrough */
         case LEN:
-            if (!state->deflate64 && have >= 6 && left >= 258) {
+            if (!state->deflate64 && have >= INFLATE_FAST_MIN_INPUT &&
+                left >= INFLATE_FAST_MIN_OUTPUT) {
                 RESTORE();
-                inflate_fast(strm, out);
+                inflate_fast_chunk_(strm, out);
                 LOAD();
                 if (state->mode == TYPE)
                     state->back = -1;
@@ -1077,7 +1090,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
                 break;
             }
             if (here.op & 64) {
-                strm->msg = (z_const char *)"invalid literal/length code";
+                strm->msg = (char *)"invalid literal/length code";
                 state->mode = BAD;
                 break;
             }
@@ -1115,7 +1128,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
             DROPBITS(here.bits);
             state->back += here.bits;
             if (here.op & 64) {
-                strm->msg = (z_const char *)"invalid distance code";
+                strm->msg = (char *)"invalid distance code";
                 state->mode = BAD;
                 break;
             }
@@ -1132,7 +1145,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
             }
 #ifdef INFLATE_STRICT
             if (state->offset > state->dmax) {
-                strm->msg = (z_const char *)"invalid distance too far back";
+                strm->msg = (char *)"invalid distance too far back";
                 state->mode = BAD;
                 break;
             }
@@ -1147,7 +1160,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
                 copy = state->offset - copy;
                 if (copy > state->whave) {
                     if (state->sane) {
-                        strm->msg = (z_const char *)"invalid distance too far back";
+                        strm->msg = (char *)"invalid distance too far back";
                         state->mode = BAD;
                         break;
                     }
@@ -1172,17 +1185,16 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
                 else
                     from = state->window + (state->wnext - copy);
                 if (copy > state->length) copy = state->length;
+                if (copy > left) copy = left;
+                put = chunkcopy_safe(put, from, copy, put + left);
             }
             else {                              /* copy from output */
-                from = put - state->offset;
                 copy = state->length;
+                if (copy > left) copy = left;
+                put = chunkcopy_lapped_safe(put, state->offset, copy, put + left);
             }
-            if (copy > left) copy = left;
             left -= copy;
             state->length -= copy;
-            do {
-                *put++ = *from++;
-            } while (--copy);
             if (state->length == 0) state->mode = LEN;
             break;
         case LIT:
@@ -1206,7 +1218,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
                      state->flags ? hold :
 #endif
                      ZSWAP32(hold)) != state->check) {
-                    strm->msg = (z_const char *)"incorrect data check";
+                    strm->msg = (char *)"incorrect data check";
                     state->mode = BAD;
                     break;
                 }
@@ -1220,7 +1232,7 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
             if (state->wrap && state->flags) {
                 NEEDBITS(32);
                 if ((state->wrap & 4) && hold != (state->total & 0xffffffff)) {
-                    strm->msg = (z_const char *)"incorrect length check";
+                    strm->msg = (char *)"incorrect length check";
                     state->mode = BAD;
                     break;
                 }
@@ -1251,6 +1263,29 @@ int ZEXPORT inflate(z_streamp strm, int flush) {
        Note: a memory error from inflate() is non-recoverable.
      */
   inf_leave:
+#if defined(ZLIB_DEBUG)
+   /* XXX(cavalcantii): I put this in place back in 2017 to help debug faulty
+    * client code relying on undefined behavior when chunk_copy first landed.
+    *
+    * It is save to say after all these years that Chromium code is well
+    * behaved and works fine with the optimization, therefore we can enable
+    * this only for DEBUG builds.
+    *
+    * We write a defined value in the unused space to help mark
+    * where the stream has ended. We don't use zeros as that can
+    * mislead clients relying on undefined behavior (i.e. assuming
+    * that the data is over when the buffer has a zero/null value).
+    *
+    * The basic idea is that if client code is not relying on the zlib context
+    * to inform the amount of decompressed data, but instead reads the output
+    * buffer until a zero/null is found, it will fail faster and harder
+    * when the remaining of the buffer is marked with a symbol (e.g. 0x55).
+    */
+   if (left >= CHUNKCOPY_CHUNK_SIZE)
+      memset(put, 0x55, CHUNKCOPY_CHUNK_SIZE);
+   else
+      memset(put, 0x55, left);
+#endif
     RESTORE();
     if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
             (state->mode < CHECK || flush != Z_FINISH)))
@@ -1464,8 +1499,9 @@ int ZEXPORT inflateCopy(z_streamp dest, z_streamp source) {
     if (copy == Z_NULL) return Z_MEM_ERROR;
     window = Z_NULL;
     if (state->window != Z_NULL) {
-        window = (unsigned char FAR *)
-                 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
+        window = (unsigned char FAR *)ZALLOC(
+            source, (1U << state->wbits) + CHUNKCOPY_CHUNK_SIZE,
+            sizeof(unsigned char));
         if (window == Z_NULL) {
             ZFREE(source, copy);
             return Z_MEM_ERROR;

package/src/insert_string.h

@@ -0,0 +1,80 @@
+/* insert_string.h
+ *
+ * Copyright 2019 The Chromium Authors
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the Chromium source repository LICENSE file.
+ */
+
+#ifndef INSERT_STRING_H
+#define INSERT_STRING_H
+
+#ifndef INLINE
+#if defined(_MSC_VER) && !defined(__clang__)
+#define INLINE __inline
+#else
+#define INLINE inline
+#endif
+#endif
+
+#include <stdint.h>
+
+/**
+ * Some applications need to match zlib DEFLATE output exactly [3]. Use the
+ * canonical zlib Rabin-Karp rolling hash [1,2] in that case.
+ *
+ *  [1] For a description of the Rabin and Karp algorithm, see "Algorithms"
+ *      book by R. Sedgewick, Addison-Wesley, p252.
+ *  [2] https://www.euccas.me/zlib/#zlib_rabin_karp and also "rolling hash"
+ *      https://en.wikipedia.org/wiki/Rolling_hash
+ *  [3] crbug.com/1316541 AOSP incremental client APK package OTA upgrades.
+ */
+#ifdef CHROMIUM_ZLIB_NO_CASTAGNOLI
+#define USE_ZLIB_RABIN_KARP_ROLLING_HASH
+#endif
+
+/* ===========================================================================
+ * Update a hash value with the given input byte (Rabin-Karp rolling hash).
+ * IN  assertion: all calls to UPDATE_HASH are made with consecutive input
+ *    characters, so that a running hash key can be computed from the previous
+ *    key instead of complete recalculation each time.
+ */
+#define UPDATE_HASH(s, h, c) (h = (((h) << s->hash_shift) ^ (c)) & s->hash_mask)
+
+/* ===========================================================================
+ * Insert string str in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * If this file is compiled with -DFASTEST, the compression level is forced
+ * to 1, and no hash chains are maintained.
+ * IN  assertion: all calls to INSERT_STRING are made with consecutive input
+ *    characters and the first MIN_MATCH bytes of str are valid (except for
+ *    the last MIN_MATCH-1 bytes of the input file).
+ */
+local INLINE Pos insert_string(deflate_state* const s, const Pos str) {
+  Pos ret;
+/* insert_string dictionary insertion: ANZAC++ hasher
+ * significantly improves data compression speed.
+ *
+ * Note: the generated compressed output is a valid DEFLATE stream, but will
+ * differ from canonical zlib output.
+ */
+#if defined(USE_ZLIB_RABIN_KARP_ROLLING_HASH)
+  UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH - 1)]);
+#else
+  uint32_t value;
+  // Validated for little endian archs (i.e. x86, Arm). YMMV for big endian.
+  zmemcpy(&value, &s->window[str], sizeof(value));
+  s->ins_h = ((value * 66521 + 66521) >> 16) & s->hash_mask;
+#endif
+
+#ifdef FASTEST
+  ret = s->head[s->ins_h];
+#else
+  ret = s->prev[str & s->w_mask] = s->head[s->ins_h];
+#endif
+  s->head[s->ins_h] = str;
+
+  return ret;
+}
+
+#endif /* INSERT_STRING_H */

package/src/wasm/api/zlib-streams.js

@@ -1,7 +1,39 @@
-/* eslint-disable no-unused-vars */
-/* global Buffer, process, TransformStream */
+/*
+ Copyright (c) 2025 Gildas Lormeau. All rights reserved.
 
-let wasm, malloc, free, memory;
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* global TransformStream */
+
+const FORMAT_DEFLATE = "deflate";
+const FORMAT_DEFLATE_RAW = "deflate-raw";
+const FORMAT_DEFLATE64_RAW = "deflate64-raw";
+const FORMAT_GZIP = "gzip";
+
+let wasm, malloc, free, memory, initError;
 
 export function setWasmExports(wasmAPI) {
 	wasm = wasmAPI;
@@ -12,53 +44,74 @@ export function setWasmExports(wasmAPI) {
 	}
 }
 
+export function setInitError(error) {
+	initError = error;
+}
+
+export function resetWasmExports() {
+	wasm = malloc = free = memory = initError = null;
+}
+
 function _make(isCompress, type, options = {}) {
+	if (!wasm) {
+		const error = new Error("WASM module not loaded");
+		error.cause = initError;
+		throw error;
+	}
 	const level = (typeof options.level === "number") ? options.level : -1;
 	const outBufferSize = (typeof options.outBuffer === "number") ? options.outBuffer : 64 * 1024;
 	const inBufferSize = (typeof options.inBufferSize === "number") ? options.inBufferSize : 64 * 1024;
 
 	return new TransformStream({
 		start() {
-			let result;
-			this.out = malloc(outBufferSize);
-			this.in = malloc(inBufferSize);
-			this.inBufferSize = inBufferSize;
-			this._scratch = new Uint8Array(outBufferSize);
-			if (isCompress) {
-				this._process = wasm.deflate_process;
-				this._last_consumed = wasm.deflate_last_consumed;
-				this._end = wasm.deflate_end;
-				this.streamHandle = wasm.deflate_new();
-				if (type === "gzip") {
-					result = wasm.deflate_init_gzip(this.streamHandle, level);
-				} else if (type === "deflate-raw") {
-					result = wasm.deflate_init_raw(this.streamHandle, level);
-				} else {
-					result = wasm.deflate_init(this.streamHandle, level);
+			try {
+				let result;
+				this.out = malloc(outBufferSize);
+				this.in = malloc(inBufferSize);
+				this.inBufferSize = inBufferSize;
+				if (!this.out || !this.in) {
+					throw new Error("allocation failed");
 				}
-			} else {
-				if (type === "deflate64-raw") {
-					this._process = wasm.inflate9_process;
-					this._last_consumed = wasm.inflate9_last_consumed;
-					this._end = wasm.inflate9_end;
-					this.streamHandle = wasm.inflate9_new();
-					result = wasm.inflate9_init_raw(this.streamHandle);
+				this._scratch = new Uint8Array(outBufferSize);
+				if (isCompress) {
+					this._process = wasm.deflate_process;
+					this._last_consumed = wasm.deflate_last_consumed;
+					this._end = wasm.deflate_end;
+					this.streamHandle = wasm.deflate_new();
+					if (type === FORMAT_GZIP) {
+						result = wasm.deflate_init_gzip(this.streamHandle, level);
+					} else if (type === FORMAT_DEFLATE_RAW) {
+						result = wasm.deflate_init_raw(this.streamHandle, level);
+					} else {
+						result = wasm.deflate_init(this.streamHandle, level);
+					}
 				} else {
-					this._process = wasm.inflate_process;
-					this._last_consumed = wasm.inflate_last_consumed;
-					this._end = wasm.inflate_end;
-					this.streamHandle = wasm.inflate_new();
-					if (type === "deflate-raw") {
-						result = wasm.inflate_init_raw(this.streamHandle);
-					} else if (type === "gzip") {
-						result = wasm.inflate_init_gzip(this.streamHandle);
+					if (type === FORMAT_DEFLATE64_RAW) {
+						this._process = wasm.inflate9_process;
+						this._last_consumed = wasm.inflate9_last_consumed;
+						this._end = wasm.inflate9_end;
+						this.streamHandle = wasm.inflate9_new();
+						result = wasm.inflate9_init_raw(this.streamHandle);
 					} else {
-						result = wasm.inflate_init(this.streamHandle);
+						this._process = wasm.inflate_process;
+						this._last_consumed = wasm.inflate_last_consumed;
+						this._end = wasm.inflate_end;
+						this.streamHandle = wasm.inflate_new();
+						if (type === FORMAT_DEFLATE_RAW) {
+							result = wasm.inflate_init_raw(this.streamHandle);
+						} else if (type === FORMAT_GZIP) {
+							result = wasm.inflate_init_gzip(this.streamHandle);
+						} else {
+							result = wasm.inflate_init(this.streamHandle);
+						}
 					}
 				}
-			}
-			if (result !== 0) {
-				throw new Error("init failed:" + result);
+				if (result !== 0) {
+					throw new Error("init failed:" + result);
+				}
+			} catch (error) {
+				disposeStream(this);
+				throw error;
 			}
 		},
 		transform(chunk, controller) {
@@ -75,9 +128,13 @@ function _make(isCompress, type, options = {}) {
 					if (!this.in || this.inBufferSize < toRead) {
 						if (this.in && free) {
 							free(this.in);
+							this.in = 0;
 						}
 						this.in = malloc(toRead);
 						this.inBufferSize = toRead;
+						if (!this.in) {
+							throw new Error("allocation failed");
+						}
 					}
 					heap.set(buffer.subarray(offset, offset + toRead), this.in);
 					const result = process(this.streamHandle, this.in, toRead, out, outBufferSize, 0);
@@ -94,21 +151,13 @@ function _make(isCompress, type, options = {}) {
 						}
 					}
 					const consumed = last_consumed(this.streamHandle);
-					if (consumed === 0) {
+					if (consumed === 0 && prod === 0) {
 						break;
 					}
 					offset += consumed;
 				}
 			} catch (error) {
-				if (this._end && this.streamHandle) {
-					this._end(this.streamHandle);
-				}
-				if (this.in && free) {
-					free(this.in);
-				}
-				if (this.out && free) {
-					free(this.out);
-				}
+				disposeStream(this);
 				controller.error(error);
 			}
 		},
@@ -139,30 +188,54 @@ function _make(isCompress, type, options = {}) {
 			} catch (error) {
 				controller.error(error);
 			} finally {
-				if (this._end && this.streamHandle) {
-					const result = this._end(this.streamHandle);
-					if (result !== 0) {
-						controller.error(new Error("end error:" + result));
-					}
-				}
-				if (this.in && free) {
-					free(this.in);
-				}
-				if (this.out && free) {
-					free(this.out);
+				const result = disposeStream(this);
+				if (result !== 0) {
+					controller.error(new Error("end error:" + result));
 				}
 			}
+		},
+		cancel() {
+			// release the stream handle and buffers when the pipeline is aborted,
+			// they would be leaked in the process-lifetime wasm heap otherwise
+			disposeStream(this);
 		}
 	});
+
+	function disposeStream(state) {
+		let endResult = 0;
+		if (state.streamHandle && state._end) {
+			endResult = state._end(state.streamHandle);
+		}
+		state.streamHandle = 0;
+		if (state.in && free) {
+			free(state.in);
+		}
+		state.in = 0;
+		if (state.out && free) {
+			free(state.out);
+		}
+		state.out = 0;
+		return endResult;
+	}
 }
 
 export class CompressionStreamZlib {
-	constructor(type = "deflate", options) {
+	constructor(type = FORMAT_DEFLATE, options) {
 		return _make(true, type, options);
 	}
 }
 export class DecompressionStreamZlib {
-	constructor(type = "deflate", options) {
+	constructor(type = FORMAT_DEFLATE, options) {
 		return _make(false, type, options);
 	}
-}
+}
+// These codecs are backed by the WASM module; they are unusable until setWasmExports() has run.
+// The worker uses this flag to know it must fall back to the native CompressionStream when the
+// module fails to load, rather than discarding a self-contained codec supplied through config.
+CompressionStreamZlib.requiresModule = true;
+DecompressionStreamZlib.requiresModule = true;
+// Constructing these classes before the module is loaded throws, so capability probes cannot rely
+// on trying the constructor; the formats are declared instead, next to the branches implementing
+// them in _make().
+CompressionStreamZlib.supportedFormats = [FORMAT_DEFLATE, FORMAT_DEFLATE_RAW, FORMAT_GZIP];
+DecompressionStreamZlib.supportedFormats = [FORMAT_DEFLATE, FORMAT_DEFLATE_RAW, FORMAT_GZIP, FORMAT_DEFLATE64_RAW];

package/build/debug/src/inffast.d

@@ -1,8 +0,0 @@
-build/debug/src/inffast.o: src/inffast.c src/zlib/zutil.h src/zlib/zlib.h \
-  src/zlib/zconf.h src/inftrees.h src/inflate.h src/zlib/inffast.h
-src/zlib/zutil.h:
-src/zlib/zlib.h:
-src/zlib/zconf.h:
-src/inftrees.h:
-src/inflate.h:
-src/zlib/inffast.h:

package/build/debug/src/inflate.d

@@ -1,8 +0,0 @@
-build/debug/src/inflate.o: src/inflate.c src/zlib/zutil.h src/zlib/zlib.h \
-  src/zlib/zconf.h src/inftrees.h src/inflate.h src/zlib/inffast.h
-src/zlib/zutil.h:
-src/zlib/zlib.h:
-src/zlib/zconf.h:
-src/inftrees.h:
-src/inflate.h:
-src/zlib/inffast.h:

package/build/debug/src/inftrees.d

@@ -1,6 +0,0 @@
-build/debug/src/inftrees.o: src/inftrees.c src/zlib/zutil.h \
-  src/zlib/zlib.h src/zlib/zconf.h src/inftrees.h
-src/zlib/zutil.h:
-src/zlib/zlib.h:
-src/zlib/zconf.h:
-src/inftrees.h: