@btoon/js 0.1.1 → 0.1.2

package/dist/cjs/web.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webFormat = webFormat;
+exports.trustedDecompressionFormat = trustedDecompressionFormat;
+exports.mayDecompressAsync = mayDecompressAsync;
 exports.webCompress = webCompress;
 exports.webDecompress = webDecompress;
 exports.subtle = subtle;
@@ -9,8 +11,10 @@ exports.webHmacVerify = webHmacVerify;
 // Asynchronous implementations on top of web platform APIs: Compression Streams and
 // WebCrypto. Used by encodeAsync/decodeAsync wherever the runtime provides them.
 const errors_js_1 = require("./errors.js");
-const inflate_js_1 = require("./inflate.js");
 const FORMATS = { zlib: 'deflate', brotli: 'brotli', zstd: 'zstd' };
+// DecompressionStream has no way to bound a Zstandard window (SPEC §6), so it is never used
+// for zstd.
+const DECOMPRESSION_FORMATS = { zlib: 'deflate', brotli: 'brotli' };
 const CHUNK = 64 * 1024;
 const supported = new Map();
 function streamCtor(kind) {
@@ -48,6 +52,76 @@ function concat(chunks, total) {
     }
     return out;
 }
+function fromHex(h) {
+    const out = new Uint8Array(h.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(h.slice(2 * i, 2 * i + 2), 16);
+    return out;
+}
+// Streams of the five bytes "BTOON" (zlib level 9, Brotli quality 11) for the trust probe.
+const PROBE_TEXT = 'BTOON';
+const PROBE_STREAMS = { deflate: '78da730af1f7f7030004780183', brotli: '0b028042544f4f4e03' };
+const trust = new Map();
+/**
+ * Whether this runtime's DecompressionStream can be trusted with `format`: it must decode a
+ * valid stream and reject one followed by a byte (in the same write or in the next), or by a
+ * second stream. Node.js 18 to 23 (some later 22.x releases excepted) ignore bytes after a
+ * zlib stream, and Node.js 22 and 24 after a Brotli stream, while SPEC §6 requires
+ * `invalid_envelope`. Checked once per format.
+ */
+function trusted(format) {
+    let p = trust.get(format);
+    if (p === undefined) {
+        p = probe(format);
+        trust.set(format, p);
+    }
+    return p;
+}
+async function probe(format) {
+    const hex = PROBE_STREAMS[format];
+    if (hex === undefined)
+        return false;
+    const valid = fromHex(hex);
+    const next = (extra) => {
+        const out = new Uint8Array(valid.length + extra.length);
+        out.set(valid);
+        out.set(extra, valid.length);
+        return out;
+    };
+    try {
+        const out = await decompressChunks(format, [valid], 64, format);
+        if (String.fromCharCode(...out) !== PROBE_TEXT)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    for (const chunks of [[next(Uint8Array.of(0))], [valid, Uint8Array.of(0)], [next(valid)]]) {
+        try {
+            await decompressChunks(format, chunks, 64, format);
+            return false; // trailing bytes accepted
+        }
+        catch {
+            // rejected, as it should be
+        }
+    }
+    return true;
+}
+/**
+ * The DecompressionStream format that decodeAsync may use for `alg` when no other
+ * decompressor is available, or undefined: never for zstd, and only once the runtime has
+ * shown that it rejects trailing bytes.
+ */
+async function trustedDecompressionFormat(alg) {
+    const format = DECOMPRESSION_FORMATS[alg];
+    if (format === undefined || webFormat(alg, 'DecompressionStream') === undefined)
+        return undefined;
+    return (await trusted(format)) ? format : undefined;
+}
+/** Whether decodeAsync might decompress `alg` with a DecompressionStream here (for error messages). */
+function mayDecompressAsync(alg) {
+    return DECOMPRESSION_FORMATS[alg] !== undefined && webFormat(alg, 'DecompressionStream') !== undefined;
+}
 async function readAll(reader, limit, alg) {
     const chunks = [];
     let total = 0;
@@ -64,11 +138,18 @@ async function readAll(reader, limit, alg) {
     }
     return concat(chunks, total);
 }
-/** Feeds `data` in chunks, honouring backpressure, then closes the writer. */
-async function pump(writer, data) {
-    for (let i = 0; i < data.length; i += CHUNK) {
+/** Splits `data` into the chunks written to a stream. */
+function chunked(data) {
+    const chunks = [];
+    for (let i = 0; i < data.length; i += CHUNK)
+        chunks.push(data.subarray(i, Math.min(i + CHUNK, data.length)));
+    return chunks;
+}
+/** Writes `chunks`, honouring backpressure, then closes the writer. */
+async function pump(writer, chunks) {
+    for (const chunk of chunks) {
         await writer.ready;
-        await writer.write(data.subarray(i, Math.min(i + CHUNK, data.length)));
+        await writer.write(chunk);
     }
     await writer.close();
 }
@@ -78,41 +159,45 @@ function messageOf(e) {
 async function webCompress(format, data) {
     const stream = new (streamCtor('CompressionStream'))(format);
     const writer = stream.writable.getWriter();
-    const writing = pump(writer, data);
+    const writing = pump(writer, chunked(data));
     writing.catch(() => undefined);
     const out = await readAll(stream.readable.getReader(), Infinity, format);
     await writing;
     return out;
 }
 /**
- * Decompresses with a DecompressionStream, stopping as soon as the output exceeds
- * `limit` (the declared size). For zlib it also checks that the payload ends with the
- * Adler-32 of the output: older runtimes silently ignore bytes after the end of the
- * stream, which a strict decoder must reject.
+ * Runs `chunks` through a DecompressionStream. Output beyond `limit` bytes fails with
+ * `invalid_envelope` ("<label> payload decompresses to more than the declared size").
  */
-async function webDecompress(alg, format, data, limit) {
+async function decompressChunks(format, chunks, limit, label) {
     const stream = new (streamCtor('DecompressionStream'))(format);
     const writer = stream.writable.getWriter();
-    const writing = pump(writer, data);
+    const writing = pump(writer, chunks);
     writing.catch(() => undefined);
-    let out;
     try {
-        out = await readAll(stream.readable.getReader(), limit, alg);
+        const out = await readAll(stream.readable.getReader(), limit, label);
         await writing;
+        return out;
     }
     catch (e) {
         writer.abort(e).catch(() => undefined);
+        throw e;
+    }
+}
+/**
+ * Decompresses with a DecompressionStream, stopping as soon as the output exceeds `limit`
+ * (the declared size). Only for a format that trustedDecompressionFormat() returned, which
+ * rejects bytes after the end of the stream.
+ */
+async function webDecompress(alg, format, data, limit) {
+    try {
+        return await decompressChunks(format, chunked(data), limit, alg);
+    }
+    catch (e) {
         if (e instanceof errors_js_1.BtoonError)
             throw e;
         throw (0, errors_js_1.fail)('invalid_envelope', `${alg} payload is corrupt: ${messageOf(e)}`, e);
     }
-    if (alg === 'zlib') {
-        const n = data.length;
-        const trailer = n >= 4 ? ((data[n - 4] << 24) | (data[n - 3] << 16) | (data[n - 2] << 8) | data[n - 1]) >>> 0 : -1;
-        if (trailer !== (0, inflate_js_1.adler32)(out))
-            throw (0, errors_js_1.fail)('invalid_envelope', 'zlib payload has trailing bytes');
-    }
-    return out;
 }
 /** WebCrypto's SubtleCrypto, if available (absent in Node 18 and on insecure origins). */
 function subtle() {

package/dist/esm/constants.d.ts

@@ -1,5 +1,5 @@
 /** Version of this library. */
-export declare const VERSION: "0.1.1";
+export declare const VERSION: "0.1.2";
 /** Version of the BTOON specification this library implements. */
 export declare const SPEC_VERSION: "0.1";
 export declare const EXT_TIMESTAMP = -1;

package/dist/esm/constants.js

@@ -1,5 +1,5 @@
 /** Version of this library. */
-export const VERSION = '0.1.1';
+export const VERSION = '0.1.2';
 /** Version of the BTOON specification this library implements. */
 export const SPEC_VERSION = '0.1';
 // Extension type ids (SPEC §5).

package/dist/esm/core.d.ts

@@ -1,8 +1,13 @@
 import { type CompressionAlgorithm, type DecodeOptions, type EncodeOptions } from './options.js';
-/** Synchronous building blocks of one environment. */
+/** Building blocks of one environment: its synchronous codecs and HMAC, and non-blocking decompressors. */
 export interface Platform {
     /** Decompressors; `size` is the declared uncompressed size (already checked against the limit). */
     readonly decompress: Readonly<Partial<Record<CompressionAlgorithm, (data: Uint8Array, size: number) => Uint8Array>>>;
+    /**
+     * Non-blocking forms of `decompress` that reach the same verdict (node:zlib on the thread
+     * pool). decodeAsync prefers them.
+     */
+    readonly decompressAsync?: Readonly<Partial<Record<CompressionAlgorithm, (data: Uint8Array, size: number) => Promise<Uint8Array>>>>;
     readonly compress: Readonly<Partial<Record<CompressionAlgorithm, (data: Uint8Array) => Uint8Array>>>;
     hmac(key: Uint8Array, parts: readonly Uint8Array[]): Uint8Array;
     equal(a: Uint8Array, b: Uint8Array): boolean;

package/dist/esm/core.js

@@ -7,7 +7,7 @@ import { encodeDocument } from './encode.js';
 import { BtoonError, fail } from './errors.js';
 import { decodeConfig, encodeConfig, } from './options.js';
 import { isUint8Array } from './values.js';
-import { subtle, webCompress, webDecompress, webFormat, webHmacSign, webHmacVerify } from './web.js';
+import { mayDecompressAsync, subtle, trustedDecompressionFormat, webCompress, webDecompress, webFormat, webHmacSign, webHmacVerify, } from './web.js';
 const COMPRESSED_MAGIC = [0x42, 0x54, 0x4f, 0x4e]; // "BTON"
 const SIGNED_MAGIC = [0x42, 0x54, 0x53, 0x47]; // "BTSG"
 const SIGNED_HEADER = new Uint8Array([0x42, 0x54, 0x53, 0x47, 1, 1, 0, 0]);
@@ -198,7 +198,7 @@ export function decodeWith(data, options, platform) {
         if (out === undefined) {
             const builtin = platform.decompress[alg];
             if (builtin === undefined)
-                throw unavailable(alg, 'decompression', webFormat(alg, 'DecompressionStream') !== undefined);
+                throw unavailable(alg, 'decompression', mayDecompressAsync(alg));
             out = builtin(payload, size);
         }
         bytes = checkSize(out, size, alg);
@@ -253,17 +253,30 @@ export async function decodeAsyncWith(data, options, platform) {
     if (env !== null) {
         const { alg, payload, size } = env;
         let out = await callCodecAsync(cfg.codecs, alg, 'decompress', [payload, size]);
-        if (out === undefined) {
-            const format = webFormat(alg, 'DecompressionStream');
-            const builtin = platform.decompress[alg];
-            if (format !== undefined)
-                out = await webDecompress(alg, format, payload, size);
-            else if (builtin !== undefined)
-                out = builtin(payload, size);
-            else
-                throw unavailable(alg, 'decompression', false);
-        }
+        if (out === undefined)
+            out = await decompressAsync(platform, alg, payload, size);
         bytes = checkSize(out, size, alg);
     }
     return decodeDocument(bytes, cfg);
 }
+/**
+ * decodeAsync's decompressor. It reaches the same verdict as decode's: first the same
+ * decompressor, in its non-blocking form where there is one (node:zlib), then the synchronous
+ * one (the pure-JS inflate). A DecompressionStream is the last resort, only for a format that
+ * the runtime has shown it handles strictly, and never for zstd.
+ */
+async function decompressAsync(platform, alg, payload, size) {
+    const nonBlocking = platform.decompressAsync?.[alg];
+    if (nonBlocking !== undefined)
+        return nonBlocking(payload, size);
+    const builtin = platform.decompress[alg];
+    if (builtin !== undefined)
+        return builtin(payload, size);
+    const format = await trustedDecompressionFormat(alg);
+    if (format !== undefined)
+        return webDecompress(alg, format, payload, size);
+    if (mayDecompressAsync(alg)) {
+        throw fail('unsupported_compression', `${alg} decompression is not available in this environment: its DecompressionStream accepts bytes after the end of a stream; pass options.codecs.${alg}`);
+    }
+    throw unavailable(alg, 'decompression', false);
+}

package/dist/esm/decode.js

@@ -1,7 +1,8 @@
 // Hardened BTOON decoder (SPEC §7). Invariants:
 //  * every read is bounds-checked against `end` (no reads past the input);
 //  * containers are depth-limited (max_depth) — no unbounded recursion;
-//  * nothing is allocated beyond what the remaining input could encode.
+//  * nothing is allocated beyond what the remaining input could encode, and what containers
+//    allocate before their elements are decoded is bounded for the whole document.
 import { DEFAULT_MAX_DEPTH, EXT_BIGINT, EXT_DATE, EXT_DATETIME, EXT_F32_VECTOR, EXT_F64_VECTOR, EXT_TABULAR, EXT_TIMESTAMP, MAX_DATE_MS, MAX_OFFSET_MINUTES, NANOS_PER_SECOND, TABULAR_VERSION, } from './constants.js';
 import { BtoonError, fail, isStackOverflow } from './errors.js';
 import { decodeUtf8 } from './utf8.js';
@@ -17,6 +18,15 @@ const fromCharCode = String.fromCharCode;
 const KEY_CACHE_SIZE = 4096;
 const KEY_CACHE_MAX_LEN = 16;
 const keyCache = new Array(KEY_CACHE_SIZE).fill(undefined);
+// Limits on what containers allocate before their elements are decoded. A header may announce
+// as many elements as there are bytes left, but nested containers announce the same bytes
+// again at every level, so trusting the counts let a 1 MiB document of 64 nested tabulars
+// build 4 GB of rows and exhaust the heap (review 2026-11-13, X1). An array, or the row list
+// of a table, reserves at most MAX_RESERVE slots, and those open at any time at most
+// RESERVE_BUDGET together; beyond that they grow as elements are decoded. Each tabular row is
+// created once its first cell has been decoded.
+const MAX_RESERVE = 1024;
+const RESERVE_BUDGET = 64 * MAX_RESERVE;
 const HEX = [];
 for (let i = 0; i < 256; i++)
     HEX.push((i < 16 ? '0' : '') + i.toString(16));
@@ -45,6 +55,8 @@ export function plainBytes(b) {
 class Decoder {
     constructor(bytes, strict, maxDepth, tsObjects, bigAlways) {
         this.pos = 0;
+        /** Slots reserved by the arrays and row lists being decoded (see reserve). */
+        this.reserved = 0;
         this.bytes = plainBytes(bytes);
         this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
         this.end = this.bytes.length;
@@ -209,15 +221,26 @@ class Decoder {
         this.pos += len;
         return b;
     }
+    /**
+     * How many of the `n` elements that an array, or a table's row list, announces it may
+     * allocate up front. They are charged to the document's budget until it is complete.
+     */
+    reserve(n) {
+        const r = Math.min(n, MAX_RESERVE, RESERVE_BUDGET - this.reserved);
+        this.reserved += r;
+        return r;
+    }
     array(n, depth) {
         if (depth >= this.maxDepth)
             throw this.err('max_depth', 'maximum nesting depth exceeded');
         // Every element takes at least one byte.
         if (n > this.end - this.pos)
             throw this.err('truncated', 'array length exceeds the remaining input');
-        const a = new Array(n);
+        const r = this.reserve(n);
+        const a = new Array(r); // grows as elements beyond the reservation arrive
         for (let i = 0; i < n; i++)
             a[i] = this.value(depth + 1);
+        this.reserved -= r;
         return a;
     }
     key() {
@@ -447,7 +470,7 @@ class Decoder {
         // Each column needs at least 9 bytes: name length, type code, column length.
         if (cols > (end - p) / 9)
             throw bad('tabular column count exceeds the payload');
-        const names = new Array(cols);
+        const names = [];
         for (let c = 0; c < cols; c++) {
             if (end - p < 4)
                 throw bad('tabular payload truncated');
@@ -458,7 +481,7 @@ class Decoder {
             const name = decodeUtf8(this.bytes, p, n, this.strict);
             if (name === undefined)
                 throw this.err('invalid_utf8', 'column name is not valid UTF-8', p);
-            names[c] = name;
+            names.push(name);
             p += n;
         }
         if (new Set(names).size !== cols)
@@ -469,9 +492,10 @@ class Decoder {
         // Every cell is at least one byte.
         if (rowCount * cols > end - p)
             throw bad('tabular row count exceeds the payload');
-        const rows = new Array(rowCount);
-        for (let r = 0; r < rowCount; r++)
-            rows[r] = {};
+        // Each row is created once its first cell has been decoded, so the rows are backed by
+        // input actually consumed, however many the header announces.
+        const reserved = this.reserve(rowCount);
+        const rows = new Array(reserved);
         const savedEnd = this.end;
         for (let c = 0; c < cols; c++) {
             if (end - p < 4)
@@ -485,7 +509,15 @@ class Decoder {
             this.pos = p;
             this.end = colEnd;
             try {
-                if (name === '__proto__') {
+                if (c === 0) {
+                    for (let r = 0; r < rowCount; r++) {
+                        const v = this.value(depth + 2);
+                        const row = {};
+                        setProperty(row, name, v);
+                        rows[r] = row;
+                    }
+                }
+                else if (name === '__proto__') {
                     for (let r = 0; r < rowCount; r++)
                         setProperty(rows[r], name, this.value(depth + 2));
                 }
@@ -505,6 +537,7 @@ class Decoder {
             p = colEnd;
         }
         this.end = savedEnd;
+        this.reserved -= reserved;
         if (p !== end)
             throw bad('trailing bytes in tabular payload');
         this.pos = end;

package/dist/esm/index.d.ts

@@ -60,9 +60,12 @@ export declare function decode(data: BinaryInput, options?: DecodeOptions): unkn
  */
 export declare function encodeAsync(value: unknown, options?: EncodeOptions): Promise<Uint8Array<ArrayBuffer>>;
 /**
- * Like {@link decode}, but decompresses with `DecompressionStream` (when the runtime
- * supports the algorithm) and verifies signatures with `crypto.subtle.verify`, falling back
- * to the synchronous implementations. The input is copied first, so the caller may reuse
- * its buffer immediately. Rejects with a {@link BtoonError}.
+ * Like {@link decode}, but asynchronous. In the Node.js entry, decompression runs on the
+ * `node:zlib` thread pool. In the portable entry, zlib uses the same pure-JS inflate as
+ * `decode`, and Brotli can also be decompressed with a `DecompressionStream` where the runtime
+ * has shown that it rejects bytes after the end of a stream (never Zstandard, whose window
+ * size it can't bound). Signatures are verified with `crypto.subtle.verify` where available.
+ * `decodeAsync` never accepts a document that `decode` rejects. The input is copied first, so
+ * the caller may reuse its buffer immediately. Rejects with a {@link BtoonError}.
  */
 export declare function decodeAsync(data: BinaryInput, options?: DecodeOptions): Promise<unknown>;

package/dist/esm/index.js

@@ -64,10 +64,13 @@ export function encodeAsync(value, options) {
     return encodeAsyncWith(value, options, portablePlatform);
 }
 /**
- * Like {@link decode}, but decompresses with `DecompressionStream` (when the runtime
- * supports the algorithm) and verifies signatures with `crypto.subtle.verify`, falling back
- * to the synchronous implementations. The input is copied first, so the caller may reuse
- * its buffer immediately. Rejects with a {@link BtoonError}.
+ * Like {@link decode}, but asynchronous. In the Node.js entry, decompression runs on the
+ * `node:zlib` thread pool. In the portable entry, zlib uses the same pure-JS inflate as
+ * `decode`, and Brotli can also be decompressed with a `DecompressionStream` where the runtime
+ * has shown that it rejects bytes after the end of a stream (never Zstandard, whose window
+ * size it can't bound). Signatures are verified with `crypto.subtle.verify` where available.
+ * `decodeAsync` never accepts a document that `decode` rejects. The input is copied first, so
+ * the caller may reuse its buffer immediately. Rejects with a {@link BtoonError}.
  */
 export function decodeAsync(data, options) {
     return decodeAsyncWith(data, options, portablePlatform);

package/dist/esm/node.d.ts

@@ -56,9 +56,12 @@ export declare function decode(data: BinaryInput, options?: DecodeOptions): unkn
  */
 export declare function encodeAsync(value: unknown, options?: EncodeOptions): Promise<Uint8Array<ArrayBuffer>>;
 /**
- * Like {@link decode}, but decompresses with `DecompressionStream` (when the runtime
- * supports the algorithm) and verifies signatures with `crypto.subtle.verify`, falling back
- * to the synchronous implementations. The input is copied first, so the caller may reuse
- * its buffer immediately. Rejects with a {@link BtoonError}.
+ * Like {@link decode}, but asynchronous. In the Node.js entry, decompression runs on the
+ * `node:zlib` thread pool. In the portable entry, zlib uses the same pure-JS inflate as
+ * `decode`, and Brotli can also be decompressed with a `DecompressionStream` where the runtime
+ * has shown that it rejects bytes after the end of a stream (never Zstandard, whose window
+ * size it can't bound). Signatures are verified with `crypto.subtle.verify` where available.
+ * `decodeAsync` never accepts a document that `decode` rejects. The input is copied first, so
+ * the caller may reuse its buffer immediately. Rejects with a {@link BtoonError}.
  */
 export declare function decodeAsync(data: BinaryInput, options?: DecodeOptions): Promise<unknown>;

package/dist/esm/node.js

@@ -60,10 +60,13 @@ export function encodeAsync(value, options) {
     return encodeAsyncWith(value, options, nodePlatform);
 }
 /**
- * Like {@link decode}, but decompresses with `DecompressionStream` (when the runtime
- * supports the algorithm) and verifies signatures with `crypto.subtle.verify`, falling back
- * to the synchronous implementations. The input is copied first, so the caller may reuse
- * its buffer immediately. Rejects with a {@link BtoonError}.
+ * Like {@link decode}, but asynchronous. In the Node.js entry, decompression runs on the
+ * `node:zlib` thread pool. In the portable entry, zlib uses the same pure-JS inflate as
+ * `decode`, and Brotli can also be decompressed with a `DecompressionStream` where the runtime
+ * has shown that it rejects bytes after the end of a stream (never Zstandard, whose window
+ * size it can't bound). Signatures are verified with `crypto.subtle.verify` where available.
+ * `decodeAsync` never accepts a document that `decode` rejects. The input is copied first, so
+ * the caller may reuse its buffer immediately. Rejects with a {@link BtoonError}.
  */
 export function decodeAsync(data, options) {
     return decodeAsyncWith(data, options, nodePlatform);

package/dist/esm/platform-node.js

@@ -1,7 +1,7 @@
 import { createHmac, timingSafeEqual } from 'node:crypto';
 import * as zlib from 'node:zlib';
 import { fail } from './errors.js';
-import { adler32 } from './inflate.js';
+import { inflateZlib } from './inflate.js';
 function nodeFn(name) {
     const f = zlib[name];
     return typeof f === 'function' ? f : undefined;
@@ -9,80 +9,115 @@ function nodeFn(name) {
 function plain(b) {
     return new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
 }
-/**
- * Wraps a node:zlib `*Sync` decompressor: output is capped at the declared size
- * (`maxOutputLength`), and input left over after the end of the stream is rejected.
- */
+/** node:zlib options: output capped at the declared size, and `info` to learn how much input was consumed. */
+function options(size, extra) {
+    return { ...extra?.(size), info: true, maxOutputLength: Math.max(1, size) };
+}
+function failure(alg, e) {
+    if (e.code === 'ERR_BUFFER_TOO_LARGE') {
+        return fail('invalid_envelope', `${alg} payload decompresses to more than the declared size`, e);
+    }
+    return fail('invalid_envelope', `${alg} payload is corrupt: ${e.message}`, e);
+}
+/** The output of a node:zlib decompressor, once it is clear that the stream used the whole payload. */
+function output(alg, data, size, r) {
+    let out;
+    let consumed;
+    if (r instanceof Uint8Array) {
+        out = r;
+    }
+    else {
+        const info = r;
+        out = info.buffer;
+        consumed = info.engine?.bytesWritten;
+    }
+    if (typeof consumed !== 'number') {
+        // A runtime that doesn't report the input it consumed can't show that no bytes follow the
+        // stream (SPEC §6). zlib has an exact pure-JS decoder; the other algorithms don't.
+        if (alg === 'zlib')
+            return inflateZlib(data, size);
+        throw fail('unsupported_compression', `${alg} decompression in this runtime cannot detect trailing bytes; pass options.codecs.${alg}`);
+    }
+    if (consumed !== data.length)
+        throw fail('invalid_envelope', `${alg} payload has trailing bytes`);
+    return plain(out);
+}
+/** Wraps a node:zlib `*Sync` decompressor, for decode. */
 function decompressor(alg, fn, extra) {
     if (fn === undefined)
         return undefined;
     return (data, size) => {
         let r;
         try {
-            r = fn(data, { ...extra?.(size), info: true, maxOutputLength: Math.max(1, size) });
+            r = fn(data, options(size, extra));
         }
         catch (e) {
-            if (e.code === 'ERR_BUFFER_TOO_LARGE') {
-                throw fail('invalid_envelope', `${alg} payload decompresses to more than the declared size`, e);
-            }
-            throw fail('invalid_envelope', `${alg} payload is corrupt: ${e.message}`, e);
-        }
-        let out;
-        let consumed;
-        if (r instanceof Uint8Array) {
-            out = r;
-        }
-        else {
-            const info = r;
-            out = info.buffer;
-            consumed = info.engine?.bytesWritten;
-        }
-        if (typeof consumed === 'number') {
-            if (consumed !== data.length)
-                throw fail('invalid_envelope', `${alg} payload has trailing bytes`);
-        }
-        else if (alg === 'zlib') {
-            // A runtime that doesn't report consumed input: the stream must end in its Adler-32.
-            const n = data.length;
-            const trailer = n >= 4 ? ((data[n - 4] << 24) | (data[n - 3] << 16) | (data[n - 2] << 8) | data[n - 1]) >>> 0 : -1;
-            if (trailer !== adler32(out))
-                throw fail('invalid_envelope', 'zlib payload has trailing bytes');
+            throw failure(alg, e);
         }
-        return plain(out);
+        return output(alg, data, size, r);
     };
 }
-function compressor(fn, options) {
+/**
+ * Wraps the callback form of the same node:zlib decompressor, for decodeAsync: it runs on the
+ * thread pool, with the same limits and checks, so both give the same verdict.
+ */
+function asyncDecompressor(alg, fn, extra) {
+    if (fn === undefined)
+        return undefined;
+    return (data, size) => new Promise((resolve, reject) => {
+        fn(data, options(size, extra), (e, r) => {
+            if (e) {
+                reject(failure(alg, e));
+                return;
+            }
+            try {
+                resolve(output(alg, data, size, r));
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    });
+}
+function compressor(fn, opts) {
     if (fn === undefined)
         return undefined;
-    return (data) => plain(fn(data, options));
+    return (data) => plain(fn(data, opts));
 }
 const decompress = {};
+const decompressAsync = {};
 const compress = {};
 decompress.zlib = decompressor('zlib', nodeFn('inflateSync'));
+decompressAsync.zlib = asyncDecompressor('zlib', nodeFn('inflate'));
 compress.zlib = compressor(nodeFn('deflateSync'), { level: 6 });
 const brotliQuality = zlib.constants?.BROTLI_PARAM_QUALITY;
 if (brotliQuality !== undefined) {
     decompress.brotli = decompressor('brotli', nodeFn('brotliDecompressSync'));
+    decompressAsync.brotli = asyncDecompressor('brotli', nodeFn('brotliDecompress'));
     compress.brotli = compressor(nodeFn('brotliCompressSync'), { params: { [brotliQuality]: 6 } });
 }
-// node:zlib has Zstandard from Node.js 22.15 / 23.8. SPEC §6: bound the decoder's memory
-// by rejecting frames whose window exceeds max(8 MiB, min(uncompressed_size, 128 MiB)).
+// node:zlib has Zstandard from Node.js 22.15 / 23.8. SPEC §6: bound the decoder's memory by
+// rejecting frames whose window exceeds max(8 MiB, min(uncompressed_size, 128 MiB)). Without
+// the windowLogMax parameter there is no bound, so zstd decompression is not offered at all.
 const zstdWindowLogMax = zlib.constants?.ZSTD_d_windowLogMax;
-decompress.zstd = decompressor('zstd', nodeFn('zstdDecompressSync'), (size) => zstdWindowLogMax === undefined
-    ? {}
-    : { params: { [zstdWindowLogMax]: Math.ceil(Math.log2(Math.max(8 << 20, Math.min(size, 128 << 20)))) } });
-compress.zstd = compressor(nodeFn('zstdCompressSync'), {});
-for (const alg of Object.keys(decompress)) {
-    if (decompress[alg] === undefined)
-        delete decompress[alg];
+if (zstdWindowLogMax !== undefined) {
+    const zstdWindow = (size) => ({
+        params: { [zstdWindowLogMax]: Math.ceil(Math.log2(Math.max(8 << 20, Math.min(size, 128 << 20)))) },
+    });
+    decompress.zstd = decompressor('zstd', nodeFn('zstdDecompressSync'), zstdWindow);
+    decompressAsync.zstd = asyncDecompressor('zstd', nodeFn('zstdDecompress'), zstdWindow);
 }
-for (const alg of Object.keys(compress)) {
-    if (compress[alg] === undefined)
-        delete compress[alg];
+compress.zstd = compressor(nodeFn('zstdCompressSync'), {});
+for (const table of [decompress, decompressAsync, compress]) {
+    for (const alg of Object.keys(table)) {
+        if (table[alg] === undefined)
+            delete table[alg];
+    }
 }
 /** Node.js (and Bun): node:zlib for zlib, Brotli and Zstandard; node:crypto for HMAC. */
 export const nodePlatform = {
     decompress,
+    decompressAsync,
     compress,
     hmac(key, parts) {
         const h = createHmac('sha256', key);