zlib-streams 1.0.2 → 1.0.4

package/Makefile

@@ -15,11 +15,11 @@ LIBS=-lz
 
 ## Build the payload decompressor test binary used for verification (deduplicated sources)
 PD_SRCS = test/payload_decompress.c \
-	src/inflate9.c src/inffast9.c src/zlib/inffast.c src/zlib/inftrees.c src/zlib/zutil.c src/zlib/inflate.c src/zlib/infback.c \
+	src/inflate9.c src/zlib/inffast.c src/zlib/inftrees.c src/zlib/zutil.c src/zlib/inflate.c src/zlib/infback.c \
 	src/zlib/contrib/infback9/infback9.c src/zlib/contrib/infback9/inftree9.c src/zlib/crc32.c src/zlib/adler32.c src/zlib/trees.c
 
 PD_NOWINDOW_SRCS = test/payload_decompress_nowindow.c \
-	src/inflate9.c src/inffast9.c src/zlib/inffast.c src/zlib/inftrees.c src/zlib/zutil.c src/zlib/inflate.c src/zlib/infback.c \
+	src/inflate9.c src/zlib/inffast.c src/zlib/inftrees.c src/zlib/zutil.c src/zlib/inflate.c src/zlib/infback.c \
 	src/zlib/contrib/infback9/infback9.c src/zlib/contrib/infback9/inftree9.c src/zlib/crc32.c src/zlib/adler32.c src/zlib/trees.c
 
 PD_NOWINDOW_DEBUG_OBJS = $(PD_NOWINDOW_SRCS:%.c=build/debug/%.o)
@@ -129,7 +129,7 @@ ci:
 # -----------------------------------------------------------------------------
 EMCC ?= emsdk/upstream/emscripten/emcc
 
-WASM_SRCS = src/wasm/inflate9_stream_wasm.c src/wasm/inflate_stream_wasm.c src/wasm/deflate_stream_wasm.c src/wasm/allocator.c src/inflate9.c src/inffast9.c \
+WASM_SRCS = src/wasm/inflate9_stream_wasm.c src/wasm/inflate_stream_wasm.c src/wasm/deflate_stream_wasm.c src/wasm/wasm_stream_common.c src/wasm/allocator.c src/inflate9.c \
 	src/zlib/contrib/infback9/inftree9.c \
 	src/zlib/inffast.c src/zlib/inflate.c src/zlib/inftrees.c src/zlib/zutil.c \
 	src/zlib/crc32.c src/zlib/adler32.c src/zlib/trees.c src/zlib/deflate.c

package/build/debug/src/inflate9.d

@@ -1,12 +1,9 @@
 build/debug/src/inflate9.o: src/inflate9.c src/zlib/zutil.h \
   src/zlib/zlib.h src/zlib/zconf.h src/zlib/contrib/infback9/inftree9.h \
-  src/zlib/inflate.h src/inffast9.h src/zlib/contrib/infback9/infback9.h \
-  src/zlib/inffixed.h
+  src/zlib/inflate.h src/zlib/inffixed.h
 src/zlib/zutil.h:
 src/zlib/zlib.h:
 src/zlib/zconf.h:
 src/zlib/contrib/infback9/inftree9.h:
 src/zlib/inflate.h:
-src/inffast9.h:
-src/zlib/contrib/infback9/infback9.h:
 src/zlib/inffixed.h:

package/build/src/inflate9.d

@@ -1,12 +1,9 @@
 build/src/inflate9.o: src/inflate9.c src/zlib/zutil.h src/zlib/zlib.h \
   src/zlib/zconf.h src/zlib/contrib/infback9/inftree9.h \
-  src/zlib/inflate.h src/inffast9.h src/zlib/contrib/infback9/infback9.h \
-  src/zlib/inffixed.h
+  src/zlib/inflate.h src/zlib/inffixed.h
 src/zlib/zutil.h:
 src/zlib/zlib.h:
 src/zlib/zconf.h:
 src/zlib/contrib/infback9/inftree9.h:
 src/zlib/inflate.h:
-src/inffast9.h:
-src/zlib/contrib/infback9/infback9.h:
 src/zlib/inffixed.h:

package/dist/zlib-streams.js

@@ -6,6 +6,10 @@ let wasm, malloc, free, memory;
 export function setWasmExports(wasmAPI) {
 	wasm = wasmAPI;
 	({ malloc, free, memory } = wasm);
+	if (typeof malloc !== "function" || typeof free !== "function" || !memory) {
+		wasm = malloc = free = memory = null;
+		throw new Error("Invalid WASM module");
+	}
 }
 
 function _make(isCompress, type, options = {}) {
@@ -77,14 +81,18 @@ function _make(isCompress, type, options = {}) {
 					}
 					heap.set(buffer.subarray(offset, offset + toRead), this.in);
 					const result = process(this.streamHandle, this.in, toRead, out, outBufferSize, 0);
-					if (!isCompress && result < 0) {
-						throw new Error("process error:" + result);
-					}
 					const prod = result & 0x00ffffff;
 					if (prod) {
 						scratch.set(heap.subarray(out, out + prod), 0);
 						controller.enqueue(scratch.slice(0, prod));
 					}
+					if (!isCompress) {
+						const code = (result >> 24) & 0xff;
+						const signedCode = (code & 0x80) ? code - 256 : code;
+						if (signedCode < 0) {
+							throw new Error("process error:" + signedCode);
+						}
+					}
 					const consumed = last_consumed(this.streamHandle);
 					if (consumed === 0) {
 						break;
@@ -112,11 +120,14 @@ function _make(isCompress, type, options = {}) {
 				const scratch = this._scratch;
 				while (true) {
 					const result = process(this.streamHandle, 0, 0, out, outBufferSize, 4);
-					if (!isCompress && result < 0) {
-						throw new Error("process error:" + result);
-					}
 					const produced = result & 0x00ffffff;
 					const code = (result >> 24) & 0xff;
+					if (!isCompress) {
+						const signedCode = (code & 0x80) ? code - 256 : code;
+						if (signedCode < 0) {
+							throw new Error("process error:" + signedCode);
+						}
+					}
 					if (produced) {
 						scratch.set(heap.subarray(out, out + produced), 0);
 						controller.enqueue(scratch.slice(0, produced));

package/package.json

@@ -3,7 +3,7 @@
   "description": "WASM-based Compression Streams API implementation using zlib, with support for deflate64 decompression.",
   "author": "Gildas Lormeau",
   "license": "BSD-3-Clause",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
   "keywords": [
     "deflate",

package/src/README.md

@@ -0,0 +1 @@
+See https://github.com/gildas-lormeau/inflate9.c

package/src/inflate9.c

@@ -6,8 +6,6 @@
 #include "zutil.h"
 #include "inftree9.h"
 #include "inflate.h"
-#include "inffast9.h"
-#include "infback9.h"
 
 #ifdef MAKEFIXED
 #ifndef BUILDFIXED
@@ -650,14 +648,6 @@ int ZEXPORT inflate9(z_streamp strm, int flush) {
       state->mode = LEN;
       /* fallthrough */
     case LEN:
-      if (have >= 6 && left >= 65536) {
-        RESTORE();
-        inflate_fast9(strm, out);
-        LOAD();
-        if (state->mode == TYPE)
-          state->back = -1;
-        break;
-      }
       state->back = 0;
       for (;;) {
         here = state->lencode[BITS(state->lenbits)];
@@ -774,7 +764,7 @@ int ZEXPORT inflate9(z_streamp strm, int flush) {
             break;
           }
 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
-          Trace((stderr, "inflate.c too far\n"));
+          Trace((stderr, "inflate9.c too far\n"));
           copy -= state->whave;
           if (copy > state->length)
             copy = state->length;
@@ -855,4 +845,15 @@ inf_leave:
   return ret;
 }
 
-int ZEXPORT inflate9End(z_streamp strm) { return inflateEnd(strm); }
+int ZEXPORT inflate9End(z_streamp strm) {
+  struct inflate_state FAR *state;
+  if (inflateStateCheck(strm))
+    return Z_STREAM_ERROR;
+  state = (struct inflate_state FAR *)strm->state;
+  if (state->window != Z_NULL)
+    ZFREE(strm, state->window);
+  ZFREE(strm, strm->state);
+  strm->state = Z_NULL;
+  Tracev((stderr, "inflate: end\n"));
+  return Z_OK;
+}

package/src/inflate9.h

@@ -1,9 +1,4 @@
-#ifndef ZLIB_INFLATE9_H_COMPAT
-#define ZLIB_INFLATE9_H_COMPAT
-
 #include "zutil.h"
-#include "inftree9.h"
-#include "inflate.h"
 
 int ZEXPORT inflate9Init(z_streamp strm);
 int ZEXPORT inflate9(z_streamp strm, int flush);
@@ -11,6 +6,4 @@ int ZEXPORT inflate9End(z_streamp strm);
 int ZEXPORT inflate9Init_(z_streamp strm, const char *version, int stream_size);
 int ZEXPORT inflate9Init2_(z_streamp strm, int windowBits, const char *version,
                            int stream_size);
-int ZEXPORT inflate9Reset2(z_streamp strm, int windowBits);
-
-#endif /* ZLIB_INFLATE9_H_COMPAT */
+int ZEXPORT inflate9Reset2(z_streamp strm, int windowBits);

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

@@ -6,6 +6,10 @@ let wasm, malloc, free, memory;
 export function setWasmExports(wasmAPI) {
 	wasm = wasmAPI;
 	({ malloc, free, memory } = wasm);
+	if (typeof malloc !== "function" || typeof free !== "function" || !memory) {
+		wasm = malloc = free = memory = null;
+		throw new Error("Invalid WASM module");
+	}
 }
 
 function _make(isCompress, type, options = {}) {
@@ -77,14 +81,18 @@ function _make(isCompress, type, options = {}) {
 					}
 					heap.set(buffer.subarray(offset, offset + toRead), this.in);
 					const result = process(this.streamHandle, this.in, toRead, out, outBufferSize, 0);
-					if (!isCompress && result < 0) {
-						throw new Error("process error:" + result);
-					}
 					const prod = result & 0x00ffffff;
 					if (prod) {
 						scratch.set(heap.subarray(out, out + prod), 0);
 						controller.enqueue(scratch.slice(0, prod));
 					}
+					if (!isCompress) {
+						const code = (result >> 24) & 0xff;
+						const signedCode = (code & 0x80) ? code - 256 : code;
+						if (signedCode < 0) {
+							throw new Error("process error:" + signedCode);
+						}
+					}
 					const consumed = last_consumed(this.streamHandle);
 					if (consumed === 0) {
 						break;
@@ -112,11 +120,14 @@ function _make(isCompress, type, options = {}) {
 				const scratch = this._scratch;
 				while (true) {
 					const result = process(this.streamHandle, 0, 0, out, outBufferSize, 4);
-					if (!isCompress && result < 0) {
-						throw new Error("process error:" + result);
-					}
 					const produced = result & 0x00ffffff;
 					const code = (result >> 24) & 0xff;
+					if (!isCompress) {
+						const signedCode = (code & 0x80) ? code - 256 : code;
+						if (signedCode < 0) {
+							throw new Error("process error:" + signedCode);
+						}
+					}
 					if (produced) {
 						scratch.set(heap.subarray(out, out + produced), 0);
 						controller.enqueue(scratch.slice(0, produced));

package/src/wasm/deflate_stream_wasm.c

@@ -3,6 +3,7 @@
 #include <stdint.h>
 #include "zlib.h"
 #include "allocator.h"
+#include "wasm_stream_common.h"
 
 #ifndef RAW_WBITS
 #if defined(MAX_WBITS)
@@ -13,24 +14,10 @@
 #endif
 
 struct wasm_deflate_ctx {
-  z_stream strm;
-  unsigned char *inbuf;
-  unsigned inbuf_sz;
-  unsigned last_consumed;
+  WASM_STREAM_COMMON_FIELDS
 };
 
-unsigned deflate_new(void) {
-  struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)malloc(sizeof(*c));
-  if (!c)
-    return 0;
-  memset(c, 0, sizeof(*c));
-  c->strm.zalloc = my_zalloc;
-  c->strm.zfree = my_zfree;
-  c->strm.opaque = Z_NULL;
-  c->inbuf = NULL;
-  c->inbuf_sz = 0;
-  return (unsigned)(uintptr_t)c;
-}
+unsigned deflate_new(void) { return wasm_stream_new(); }
 
 int deflate_init(unsigned zptr, int level) {
   struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)(uintptr_t)zptr;
@@ -63,27 +50,8 @@ int deflate_init_gzip(unsigned zptr, int level) {
 
 int deflate_process(unsigned zptr, unsigned in_ptr, unsigned in_len,
                     unsigned out_ptr, unsigned out_len, int flush) {
-  struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return Z_STREAM_ERROR;
-  if (in_len > c->inbuf_sz) {
-    unsigned char *nb = (unsigned char *)realloc(c->inbuf, in_len);
-    if (!nb)
-      return Z_MEM_ERROR;
-    c->inbuf = nb;
-    c->inbuf_sz = in_len;
-  }
-  memcpy(c->inbuf, (unsigned char *)(uintptr_t)in_ptr, in_len);
-  c->strm.next_in = c->inbuf;
-  c->strm.avail_in = in_len;
-  c->strm.next_out = (unsigned char *)(uintptr_t)out_ptr;
-  c->strm.avail_out = out_len;
-
-  int ret = deflate(&c->strm, flush);
-  int produced = (int)(out_len - c->strm.avail_out);
-  c->last_consumed = (unsigned)(in_len - c->strm.avail_in);
-  int code = ret & 0xff;
-  return (produced & 0x00ffffff) | ((code & 0xff) << 24);
+  return wasm_stream_process_common(zptr, in_ptr, in_len, out_ptr, out_len,
+                                    flush, deflate);
 }
 
 int deflate_end(unsigned zptr) {
@@ -97,8 +65,5 @@ int deflate_end(unsigned zptr) {
 }
 
 unsigned deflate_last_consumed(unsigned zptr) {
-  struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return 0;
-  return c->last_consumed;
+  return wasm_stream_last_consumed(zptr);
 }

package/src/wasm/inflate9_stream_wasm.c

@@ -3,7 +3,7 @@
 #include <stdint.h>
 #include "zlib.h"
 #include "inflate9.h"
-#include "allocator.h"
+#include "wasm_stream_common.h"
 #ifndef DEFLATE64_WBITS
 #if defined(MAX_WBITS) && (MAX_WBITS >= 16)
 #define DEFLATE64_WBITS MAX_WBITS
@@ -13,24 +13,10 @@
 #endif
 
 struct wasm_inflate9_ctx {
-  z_stream strm;
-  unsigned char *inbuf;
-  unsigned inbuf_sz;
-  unsigned last_consumed;
+  WASM_STREAM_COMMON_FIELDS;
 };
 
-unsigned inflate9_new(void) {
-  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)malloc(sizeof(*c));
-  if (!c)
-    return 0;
-  memset(c, 0, sizeof(*c));
-  c->strm.zalloc = my_zalloc;
-  c->strm.zfree = my_zfree;
-  c->strm.opaque = Z_NULL;
-  c->inbuf = NULL;
-  c->inbuf_sz = 0;
-  return (unsigned)(uintptr_t)c;
-}
+unsigned inflate9_new(void) { return wasm_stream_new(); }
 
 int inflate9_init(unsigned zptr) {
   struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
@@ -49,42 +35,12 @@ int inflate9_init_raw(unsigned zptr) {
 
 int inflate9_process(unsigned zptr, unsigned in_ptr, unsigned in_len,
                      unsigned out_ptr, unsigned out_len, int flush) {
-  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return Z_STREAM_ERROR;
-  if (in_len > c->inbuf_sz) {
-    unsigned char *nb = (unsigned char *)realloc(c->inbuf, in_len);
-    if (!nb)
-      return Z_MEM_ERROR;
-    c->inbuf = nb;
-    c->inbuf_sz = in_len;
-  }
-  memcpy(c->inbuf, (unsigned char *)(uintptr_t)in_ptr, in_len);
-  c->strm.next_in = c->inbuf;
-  c->strm.avail_in = in_len;
-  c->strm.next_out = (unsigned char *)(uintptr_t)out_ptr;
-  c->strm.avail_out = out_len;
-
-  int ret = inflate9(&c->strm, flush);
-  int produced = (int)(out_len - c->strm.avail_out);
-  c->last_consumed = (unsigned)(in_len - c->strm.avail_in);
-  int code = ret & 0xff;
-  return (produced & 0x00ffffff) | ((code & 0xff) << 24);
+  return wasm_stream_process_common(zptr, in_ptr, in_len, out_ptr, out_len,
+                                    flush, inflate9);
 }
 
-int inflate9_end(unsigned zptr) {
-  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return Z_STREAM_ERROR;
-  int r = inflate9End(&c->strm);
-  free(c->inbuf);
-  free(c);
-  return r;
-}
+int inflate9_end(unsigned zptr) { return wasm_stream_end(zptr, inflate9End); }
 
 unsigned inflate9_last_consumed(unsigned zptr) {
-  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return 0;
-  return c->last_consumed;
+  return wasm_stream_last_consumed(zptr);
 }

package/src/wasm/inflate_stream_wasm.c

@@ -3,6 +3,7 @@
 #include <stdint.h>
 #include "zlib.h"
 #include "allocator.h"
+#include "wasm_stream_common.h"
 
 #ifndef RAW_WBITS
 #if defined(MAX_WBITS)
@@ -13,24 +14,10 @@
 #endif
 
 struct wasm_inflate_ctx {
-  z_stream strm;
-  unsigned char *inbuf;
-  unsigned inbuf_sz;
-  unsigned last_consumed;
+  WASM_STREAM_COMMON_FIELDS
 };
 
-unsigned inflate_new(void) {
-  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)malloc(sizeof(*c));
-  if (!c)
-    return 0;
-  memset(c, 0, sizeof(*c));
-  c->strm.zalloc = my_zalloc;
-  c->strm.zfree = my_zfree;
-  c->strm.opaque = NULL;
-  c->inbuf = NULL;
-  c->inbuf_sz = 0;
-  return (unsigned)(uintptr_t)c;
-}
+unsigned inflate_new(void) { return wasm_stream_new(); }
 
 int inflate_init(unsigned zptr) {
   struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
@@ -59,42 +46,12 @@ int inflate_init_gzip(unsigned zptr) {
 
 int inflate_process(unsigned zptr, unsigned in_ptr, unsigned in_len,
                     unsigned out_ptr, unsigned out_len, int flush) {
-  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return Z_STREAM_ERROR;
-  if (in_len > c->inbuf_sz) {
-    unsigned char *nb = (unsigned char *)realloc(c->inbuf, in_len);
-    if (!nb)
-      return Z_MEM_ERROR;
-    c->inbuf = nb;
-    c->inbuf_sz = in_len;
-  }
-  memcpy(c->inbuf, (unsigned char *)(uintptr_t)in_ptr, in_len);
-  c->strm.next_in = c->inbuf;
-  c->strm.avail_in = in_len;
-  c->strm.next_out = (unsigned char *)(uintptr_t)out_ptr;
-  c->strm.avail_out = out_len;
-
-  int ret = inflate(&c->strm, flush);
-  int produced = (int)(out_len - c->strm.avail_out);
-  c->last_consumed = (unsigned)(in_len - c->strm.avail_in);
-  int code = ret & 0xff;
-  return (produced & 0x00ffffff) | ((code & 0xff) << 24);
+  return wasm_stream_process_common(zptr, in_ptr, in_len, out_ptr, out_len,
+                                    flush, inflate);
 }
 
-int inflate_end(unsigned zptr) {
-  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return Z_STREAM_ERROR;
-  int r = inflateEnd(&c->strm);
-  free(c->inbuf);
-  free(c);
-  return r;
-}
+int inflate_end(unsigned zptr) { return wasm_stream_end(zptr, inflateEnd); }
 
 unsigned inflate_last_consumed(unsigned zptr) {
-  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
-  if (!c)
-    return 0;
-  return c->last_consumed;
+  return wasm_stream_last_consumed(zptr);
 }

package/src/wasm/wasm_stream_common.c

@@ -0,0 +1,63 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "wasm_stream_common.h"
+#include "allocator.h"
+
+unsigned wasm_stream_new(void) {
+  struct wasm_stream_ctx *c = (struct wasm_stream_ctx *)malloc(sizeof(*c));
+  if (!c)
+    return 0;
+  memset(c, 0, sizeof(*c));
+  c->strm.zalloc = my_zalloc;
+  c->strm.zfree = my_zfree;
+  c->strm.opaque = Z_NULL;
+  c->inbuf = NULL;
+  c->inbuf_sz = 0;
+  return (unsigned)(uintptr_t)c;
+}
+
+int wasm_stream_end(unsigned zptr, int (*end_func)(z_stream *)) {
+  struct wasm_stream_ctx *c = (struct wasm_stream_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  int r = end_func(&c->strm);
+  free(c->inbuf);
+  free(c);
+  return r;
+}
+
+unsigned wasm_stream_last_consumed(unsigned zptr) {
+  struct wasm_stream_ctx *c = (struct wasm_stream_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return 0;
+  return c->last_consumed;
+}
+
+int wasm_stream_process_common(unsigned zptr, unsigned in_ptr, unsigned in_len,
+                               unsigned out_ptr, unsigned out_len, int flush,
+                               int (*process_func)(z_streamp, int)) {
+  struct wasm_stream_ctx *c = (struct wasm_stream_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+
+  if (in_len > c->inbuf_sz) {
+    unsigned char *nb = (unsigned char *)realloc(c->inbuf, in_len);
+    if (!nb)
+      return Z_MEM_ERROR;
+    c->inbuf = nb;
+    c->inbuf_sz = in_len;
+  }
+
+  memcpy(c->inbuf, (unsigned char *)(uintptr_t)in_ptr, in_len);
+  c->strm.next_in = c->inbuf;
+  c->strm.avail_in = in_len;
+  c->strm.next_out = (unsigned char *)(uintptr_t)out_ptr;
+  c->strm.avail_out = out_len;
+
+  int ret = process_func(&c->strm, flush);
+  int produced = (int)(out_len - c->strm.avail_out);
+  c->last_consumed = (unsigned)(in_len - c->strm.avail_in);
+  int code = ret & 0xff;
+  return (produced & 0x00ffffff) | ((code & 0xff) << 24);
+}

package/src/wasm/wasm_stream_common.h

@@ -0,0 +1,26 @@
+#ifndef WASM_STREAM_COMMON_H
+#define WASM_STREAM_COMMON_H
+
+#include "zlib.h"
+#include "allocator.h"
+
+// Common fields for all WASM stream contexts
+#define WASM_STREAM_COMMON_FIELDS                                              \
+  z_stream strm;                                                               \
+  unsigned char *inbuf;                                                        \
+  unsigned inbuf_sz;                                                           \
+  unsigned last_consumed;
+
+struct wasm_stream_ctx {
+  WASM_STREAM_COMMON_FIELDS;
+};
+
+// Common function declarations
+unsigned wasm_stream_new(void);
+int wasm_stream_end(unsigned zptr, int (*end_func)(z_stream *));
+unsigned wasm_stream_last_consumed(unsigned zptr);
+int wasm_stream_process_common(unsigned zptr, unsigned in_ptr, unsigned in_len,
+                               unsigned out_ptr, unsigned out_len, int flush,
+                               int (*process_func)(z_stream *, int));
+
+#endif // WASM_STREAM_COMMON_H

package/tmp/{all_runs/payload_decompress_ref_debug__100k_lines.deflate64.log → trace_ref.log}

@@ -1 +1,2 @@
 inflateBack9 loop ret=1
+OK