@norskvideo/moq-net 0.1.8 → 0.2.0

package/stream.js

@@ -1,9 +1,20 @@
 /* @ts-self-types="./stream.d.ts" */
-import { fromTransport } from "./error.js";
+import { race } from "@norskvideo/moq-signals";
+import { fromTransport, StreamCode, StreamError, toStreamCode, toTransport } from "./error.js";
 import { Version } from "./ietf/version.js";
+import { Version as Lite } from "./lite/version.js";
 import { TimeoutError, withTimeout } from "./util/timeout.js";
+import { POW32, toBigInt, toNumber, U64 } from "./util/u64.js";
 import { decodeUtf8 } from "./util/utf8.js";
-import * as Varint from "./varint.js";
+import { lengthLeadingOnes, lengthQuic, parts, peekLeadingOnes, peekQuic, readLeadingOnes, readQuic, split, writeLeadingOnes, writeQuic, } from "./util/varint.js";
+// Decode raw transport errors before mapping so they cannot bypass the negotiated
+// registry. Ordinary errors already send 0 and retain their local identity.
+function withCode(reason, stream) {
+    const version = asIetf(stream);
+    const decoded = fromTransport(reason, { version });
+    const code = toStreamCode(decoded, { version });
+    return code === StreamCode.Internal && decoded === reason ? reason : toTransport(code, decoded.message);
+}
 const MAX_U31 = 2 ** 31 - 1;
 const MAX_READ_SIZE = 1024 * 1024 * 64; // don't allocate more than 64MB for a message
 /**
@@ -35,18 +46,56 @@ async function openWithin(opening, timeout, discard) {
         throw err;
     }
 }
+const LITE = new Set(Object.values(Lite));
+function isLite(version) {
+    return LITE.has(version);
+}
+/** The moq-transport draft a stream follows, or undefined on moq-lite, whose stream codes are the same on every draft. */
+export function asIetf(version) {
+    return isLite(version) ? undefined : version;
+}
+// Every draft newer than these counts leading ones, so a new version falls forward.
 function isLeadingOnes(version) {
-    return (version !== undefined &&
-        version !== Version.DRAFT_14 &&
-        version !== Version.DRAFT_15 &&
-        version !== Version.DRAFT_16);
+    switch (version) {
+        case Version.DRAFT_14:
+        case Version.DRAFT_15:
+        case Version.DRAFT_16:
+        case Lite.DRAFT_01:
+        case Lite.DRAFT_02:
+        case Lite.DRAFT_03:
+        case Lite.DRAFT_04:
+        case Lite.DRAFT_05:
+        case Lite.DRAFT_06:
+            return false;
+        default:
+            return true;
+    }
+}
+// Encode `hi`/`lo` into `dst` in the varint form `version` uses: QUIC up to 2^62-1, leading-ones up to 2^64-1.
+function encodeTo(dst, hi, lo, version) {
+    let buf;
+    if (isLeadingOnes(version)) {
+        buf = new Uint8Array(dst, 0, lengthLeadingOnes(hi, lo));
+        writeLeadingOnes(buf, hi, lo, buf.length);
+    }
+    else {
+        buf = new Uint8Array(dst, 0, lengthQuic(hi, lo));
+        writeQuic(buf, hi, lo, buf.length);
+    }
+    return buf;
+}
+/** Encode one varint in the form `version` uses, for a body written outside a {@link Writer}. */
+export function encodeVarint(v, version) {
+    const lo = split(v);
+    return encodeTo(new ArrayBuffer(9), parts.hi, lo, version);
 }
 export class Stream {
     reader;
     writer;
     constructor(props) {
-        const writer = props.writer ?? (props.writable && new Writer(props.writable, props.version));
-        const reader = props.reader ?? (props.readable && new Reader(props.readable, undefined, props.version));
+        const version = props.version;
+        const writer = props.writer ?? (props.writable && version !== undefined && new Writer(props.writable, version));
+        const reader = props.reader ?? (props.readable && version !== undefined && new Reader(props.readable, undefined, version));
         if (!writer || !reader)
             throw new Error("stream needs both halves");
         this.writer = writer;
@@ -74,11 +123,14 @@ export class Stream {
             void stream.writable.abort().catch(() => void 0);
             void stream.readable.cancel().catch(() => void 0);
         });
-        return new Stream({ readable, writable, version: options?.version });
+        return new Stream({ readable, writable, version: options.version });
     }
     close() {
         this.writer.close();
-        this.reader.stop(new Error("cancel"));
+        // A routine unsubscribe, so send CANCELLED. A bare Error would put 0 on the wire,
+        // which the stream registry reads as INTERNAL_ERROR: the peer would log a failure
+        // for every subscription we walk away from.
+        this.reader.stop(new StreamError(StreamCode.Cancel, { message: "cancel" }));
     }
     abort(reason) {
         this.writer.reset(reason);
@@ -88,10 +140,16 @@ export class Stream {
 // Reader wraps a stream and provides convience methods for reading pieces from a stream
 // Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet.
 export class Reader {
+    // Contiguous unread bytes, followed by chunks not yet joined onto it. Joining only once a
+    // read needs the bytes keeps a frame arriving in N chunks linear rather than quadratic.
     #buffer;
+    #chunks = [];
+    #chunked = 0; // bytes across #chunks
     #stream; // if undefined, the buffer is consumed then EOF
     #reader;
     #closed;
+    // The decode that last ran short and how far, so a retry can wait for those bytes.
+    #short;
     version;
     constructor(stream, buffer, version) {
         this.#buffer = buffer ?? new Uint8Array();
@@ -107,7 +165,7 @@ export class Reader {
         // Every read of this stream funnels through here, so decoding the peer's reset code
         // once is enough to keep the raw transport error out of every caller (and every app).
         const result = await this.#reader.read().catch((err) => {
-            throw fromTransport(err);
+            throw fromTransport(err, { version: asIetf(this.version) });
         });
         if (result.done) {
             return false;
@@ -115,16 +173,8 @@ export class Reader {
         if (result.value.byteLength === 0) {
             throw new Error("unexpected empty chunk");
         }
-        const buffer = new Uint8Array(result.value);
-        if (this.#buffer.byteLength === 0) {
-            this.#buffer = buffer;
-        }
-        else {
-            const temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength);
-            temp.set(this.#buffer);
-            temp.set(buffer, this.#buffer.byteLength);
-            this.#buffer = temp;
-        }
+        this.#chunks.push(result.value);
+        this.#chunked += result.value.byteLength;
         return true;
     }
     // Add more data to the buffer until it's at least size bytes.
@@ -132,11 +182,34 @@ export class Reader {
         if (size > MAX_READ_SIZE) {
             throw new Error(`read size ${size} exceeds max size ${MAX_READ_SIZE}`);
         }
-        while (this.#buffer.byteLength < size) {
+        if (this.#buffer.byteLength >= size)
+            return;
+        while (this.#buffer.byteLength + this.#chunked < size) {
             if (!(await this.#fill())) {
                 throw new Error("unexpected end of stream");
             }
         }
+        this.#join();
+    }
+    // Move every pending chunk into the buffer, copying only when there's more than one piece.
+    #join() {
+        if (this.#chunks.length === 0)
+            return;
+        if (this.#buffer.byteLength === 0 && this.#chunks.length === 1) {
+            this.#buffer = this.#chunks[0];
+        }
+        else {
+            const joined = new Uint8Array(this.#buffer.byteLength + this.#chunked);
+            joined.set(this.#buffer);
+            let offset = this.#buffer.byteLength;
+            for (const chunk of this.#chunks) {
+                joined.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            this.#buffer = joined;
+        }
+        this.#chunks = [];
+        this.#chunked = 0;
     }
     // Consumes the first size bytes of the buffer.
     #slice(size) {
@@ -144,135 +217,293 @@ export class Reader {
         this.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size, this.#buffer.byteLength - size);
         return result;
     }
+    /**
+     * Run a synchronous decode over the buffered bytes and consume what it read.
+     *
+     * Returns undefined and consumes nothing when the decode ran past the buffered bytes, so a
+     * caller can drain every complete message already here without waiting on the stream.
+     */
+    tryDecode(decode) {
+        const result = this.#try(decode);
+        return result instanceof Short ? undefined : result;
+    }
+    /** Run a synchronous decode, filling from the stream until it has the bytes it needs. */
+    async decode(decode) {
+        for (;;) {
+            const result = this.#try(decode);
+            if (!(result instanceof Short))
+                return result;
+            await this.#fillTo(result.need);
+        }
+    }
+    /** Like {@link decode}, but returns undefined if the stream ends cleanly first. */
+    async decodeMaybe(decode) {
+        if (await this.done())
+            return undefined;
+        return this.decode(decode);
+    }
+    #try(decode) {
+        // A retry of the decode that last ran short, before the bytes it needs have arrived,
+        // would only throw again. Every decode reads at least a byte, so none can succeed on
+        // an empty buffer either.
+        const available = this.#buffer.byteLength + this.#chunked;
+        if (available === 0)
+            return EMPTY;
+        if (decode === this.#short?.decode && available < this.#short.err.need)
+            return this.#short.err;
+        this.#join();
+        const cursor = new Cursor(this.#buffer, this.version);
+        try {
+            const result = decode(cursor);
+            this.#slice(cursor.offset);
+            this.#short = undefined;
+            return result;
+        }
+        catch (err) {
+            if (!(err instanceof Short))
+                throw err;
+            // Filling could never satisfy it, so retrying would spin.
+            if (err.need <= this.#buffer.byteLength)
+                throw new Error("decode ran short of bytes it already had");
+            this.#short = { decode, err };
+            return err;
+        }
+    }
     async read(size) {
         if (size === 0)
             return new Uint8Array();
-        await this.#fillTo(size);
-        return this.#slice(size);
+        return this.decode((c) => c.read(size));
     }
     async readAll() {
         while (await this.#fill()) {
             // keep going
         }
+        this.#join();
         return this.#slice(this.#buffer.byteLength);
     }
+    // Reads to the end of the stream, dropping every byte instead of buffering it.
+    async discard() {
+        this.#buffer = new Uint8Array();
+        do {
+            this.#chunks = [];
+            this.#chunked = 0;
+        } while (await this.#fill());
+    }
     async string() {
-        const length = await this.u53();
-        const buffer = await this.read(length);
-        return decodeUtf8(buffer);
+        return this.decode(STRING);
     }
     async bool() {
-        const v = await this.u8();
-        if (v === 0)
-            return false;
-        if (v === 1)
-            return true;
-        throw new Error("invalid bool value");
+        return this.decode(BOOL);
     }
     async u8() {
-        await this.#fillTo(1);
-        return this.#slice(1)[0];
+        return this.decode(U8);
     }
     async u16() {
-        await this.#fillTo(2);
-        const view = new DataView(this.#buffer.buffer, this.#buffer.byteOffset, 2);
-        const result = view.getUint16(0);
-        this.#slice(2);
-        return result;
+        return this.decode(U16);
     }
     // Returns a Number using 53-bits, the max Javascript can use for integer math.
     async u53() {
-        const v = await this.u62();
-        if (v > Varint.MAX_U53) {
-            throw new Error(`value larger than 53-bits: ${v.toString()}`);
-        }
-        return Number(v);
+        return this.decode(U53);
     }
     // NOTE: Returns a bigint instead of a number since it may be larger than 53-bits
     async u62() {
-        if (isLeadingOnes(this.version)) {
-            return this.#readLeadingOnes();
-        }
-        return this.#readQuicVarint();
-    }
-    async #readQuicVarint() {
-        await this.#fillTo(1);
-        const size = (this.#buffer[0] & 0xc0) >> 6;
-        if (size === 0) {
-            const first = this.#slice(1)[0];
-            return BigInt(first) & 0x3fn;
-        }
-        if (size === 1) {
-            await this.#fillTo(2);
-            const slice = this.#slice(2);
-            const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength);
-            return BigInt(view.getUint16(0)) & 0x3fffn;
-        }
-        if (size === 2) {
-            await this.#fillTo(4);
-            const slice = this.#slice(4);
-            const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength);
-            return BigInt(view.getUint32(0)) & 0x3fffffffn;
-        }
-        await this.#fillTo(8);
-        const slice = this.#slice(8);
-        const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength);
-        return view.getBigUint64(0) & 0x3fffffffffffffffn;
-    }
-    async #readLeadingOnes() {
-        await this.#fillTo(1);
-        const b = this.#buffer[0];
-        // Count leading 1-bits
-        let ones = 0;
-        for (let bit = 7; bit >= 0; bit--) {
-            if (b & (1 << bit))
-                ones++;
-            else
-                break;
-        }
-        // 1111110x is a 7-byte form. Draft-17 rejects it; draft-18+ allows it per #1595.
-        if (ones === 6 && this.version === Version.DRAFT_17) {
-            throw new Error("invalid leading-ones varint: 1111110x prefix is reserved on draft-17");
-        }
-        let totalSize;
-        if (ones <= 5)
-            totalSize = ones + 1;
-        else if (ones === 6)
-            totalSize = 7;
-        else if (ones === 7)
-            totalSize = 8;
-        else
-            totalSize = 9; // ones === 8
-        await this.#fillTo(totalSize);
-        const slice = this.#slice(totalSize);
-        const [value] = Varint.decodeLeadingOnes(slice);
-        return value;
+        return this.decode(U62);
+    }
+    async varint() {
+        return this.decode(VARINT);
     }
     // Returns false if there is more data to read, blocking if it hasn't been received yet.
     async done() {
-        if (this.#buffer.byteLength > 0)
+        if (this.#buffer.byteLength > 0 || this.#chunked > 0)
             return false;
         return !(await this.#fill());
     }
     stop(reason) {
-        this.#reader?.cancel(reason).catch(() => void 0);
+        this.#reader?.cancel(withCode(reason, this.version)).catch(() => void 0);
     }
     // Decoded like #fill: a caller racing this against a read must not get a different error
     // shape depending on which one won. Derived once, so racing it per frame doesn't allocate.
     get closed() {
         this.#closed ??= (this.#reader?.closed ?? Promise.resolve()).catch((err) => {
-            throw fromTransport(err);
+            throw fromTransport(err, { version: asIetf(this.version) });
         });
         return this.#closed;
     }
 }
+// Thrown by a Cursor read that runs past the buffered bytes, carrying how many bytes from the
+// start of the buffer the decode needs. Not an Error: it ends every chunk, so it must not
+// capture a stack.
+class Short {
+    need;
+    constructor(need) {
+        this.need = need;
+    }
+}
+const EMPTY = new Short(1);
+/**
+ * A synchronous view over a {@link Reader}'s buffered bytes, handed to {@link Reader.decode}.
+ *
+ * A read past the buffered bytes throws an internal signal that the Reader catches: it consumes
+ * nothing, fills, and runs the decode again from the start. A decode must therefore not mutate
+ * anything before its last read, must not swallow what it throws, and must read at least a byte.
+ */
+export class Cursor {
+    version;
+    #buffer;
+    #offset = 0;
+    // Resolved once, since every varint read branches on it.
+    #leadingOnes;
+    // First bytes below this are a whole 1-byte varint, and below this + 0x40 a 2-byte one whose
+    // value is the low 6 bits and the next byte. Both formats share that shape; only the bound moves.
+    #short;
+    // First bytes below this are a varint of at most 4 bytes: 0xc0 for QUIC, 0xf0 for leading-ones.
+    #word;
+    constructor(buffer, version) {
+        this.#buffer = buffer;
+        this.version = version;
+        this.#leadingOnes = isLeadingOnes(version);
+        this.#short = this.#leadingOnes ? 0x80 : 0x40;
+        this.#word = this.#leadingOnes ? 0xf0 : 0xc0;
+    }
+    /** How many bytes have been read. */
+    get offset() {
+        return this.#offset;
+    }
+    /** How many buffered bytes are left to read. */
+    get remaining() {
+        return this.#buffer.byteLength - this.#offset;
+    }
+    /**
+     * Decode the next `size` bytes on their own. Running past them, or leaving any unread, is
+     * malformed rather than a reason to wait for more.
+     */
+    exact(size, decode) {
+        const inner = new Cursor(this.read(size), this.version);
+        let result;
+        try {
+            result = decode(inner);
+        }
+        catch (err) {
+            if (err instanceof Short)
+                throw new Error(`message is shorter than its fields: ${size} bytes`);
+            throw err;
+        }
+        if (inner.remaining > 0)
+            throw new Error(`message has ${inner.remaining} unread bytes`);
+        return result;
+    }
+    #ensure(size) {
+        const need = this.#offset + size;
+        // Checked here too, and on the whole decode like the fill, since bytes that are already
+        // buffered never reach the fill.
+        if (need > MAX_READ_SIZE)
+            throw new Error(`read size ${need} exceeds max size ${MAX_READ_SIZE}`);
+        if (need > this.#buffer.byteLength)
+            throw new Short(need);
+    }
+    /** Read `size` bytes, as a view onto the buffer rather than a copy. */
+    read(size) {
+        this.#ensure(size);
+        const start = this.#offset;
+        this.#offset += size;
+        return this.#buffer.subarray(start, this.#offset);
+    }
+    string() {
+        return decodeUtf8(this.read(this.u53()));
+    }
+    bool() {
+        const v = this.u8();
+        if (v === 0)
+            return false;
+        if (v === 1)
+            return true;
+        throw new Error("invalid bool value");
+    }
+    u8() {
+        this.#ensure(1);
+        return this.#buffer[this.#offset++];
+    }
+    u16() {
+        this.#ensure(2);
+        const b = this.#buffer;
+        const o = this.#offset;
+        this.#offset += 2;
+        return (b[o] << 8) | b[o + 1];
+    }
+    /** Read a varint as a `number`, throwing if it is above `Number.MAX_SAFE_INTEGER`. */
+    u53() {
+        // Most varints are 1 or 2 bytes, which skip the general decode.
+        this.#ensure(1);
+        const b = this.#buffer;
+        const o = this.#offset;
+        const first = b[o];
+        if (first < this.#short) {
+            this.#offset = o + 1;
+            return first;
+        }
+        if (first < this.#short + 0x40) {
+            this.#ensure(2);
+            this.#offset = o + 2;
+            return ((first & 0x3f) << 8) | b[o + 1];
+        }
+        // Up to 4 bytes still fits 28 (leading-ones) or 30 (QUIC) bits, with no upper half.
+        if (first < this.#word) {
+            const size = this.#leadingOnes ? peekLeadingOnes(first) : 4;
+            this.#ensure(size);
+            this.#offset = o + size;
+            if (size === 3)
+                return ((first & 0x1f) << 16) | (b[o + 1] << 8) | b[o + 2];
+            return ((first & (this.#leadingOnes ? 0x0f : 0x3f)) << 24) | (b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3];
+        }
+        const lo = this.#varint();
+        return toNumber(parts.hi, lo);
+    }
+    /** Read a varint as a bigint. A leading-ones varint may exceed 62 bits. */
+    u62() {
+        const lo = this.#varint();
+        return toBigInt(parts.hi, lo);
+    }
+    /** Read a varint. */
+    varint() {
+        const lo = this.#varint();
+        return new U64(parts.hi, lo);
+    }
+    // Decode the next varint in the version's format, returning its lower half and leaving the upper in `parts`.
+    #varint() {
+        this.#ensure(1);
+        const b = this.#buffer;
+        const o = this.#offset;
+        let size;
+        if (this.#leadingOnes) {
+            size = peekLeadingOnes(b[o]);
+            // 1111110x is a 7-byte form. Draft-17 rejects it; draft-18+ allows it per #1595.
+            if (size === 7 && this.version === Version.DRAFT_17) {
+                throw new Error("invalid leading-ones varint: 1111110x prefix is reserved on draft-17");
+            }
+            this.#ensure(size);
+            this.#offset += size;
+            return readLeadingOnes(b, o, size);
+        }
+        size = peekQuic(b[o]);
+        this.#ensure(size);
+        this.#offset += size;
+        return readQuic(b, o, size);
+    }
+}
+// Shared decodes for the Reader's async primitives, so a read allocates no closure.
+const STRING = (c) => c.string();
+const BOOL = (c) => c.bool();
+const U8 = (c) => c.u8();
+const U16 = (c) => c.u16();
+const U53 = (c) => c.u53();
+const U62 = (c) => c.u62();
+const VARINT = (c) => c.varint();
 // Writer wraps a stream and writes chunks of data
 export class Writer {
     #writer;
     #stream;
     #closed;
-    // Scratch buffer for writing varints.
-    // Fixed at 9 bytes (leading-ones max).
+    // Scratch buffer for each primitive write, sized for the longest (a 9-byte leading-ones varint).
     #scratch;
     version;
     constructor(stream, version) {
@@ -298,6 +529,9 @@ export class Writer {
         await this.write(setUint8(this.#scratch, v ? 1 : 0));
     }
     async u8(v) {
+        if (!Number.isInteger(v) || v < 0 || v > 255) {
+            throw new RangeError(`invalid u8: ${v}`);
+        }
         await this.write(setUint8(this.#scratch, v));
     }
     async u16(v) {
@@ -307,38 +541,31 @@ export class Writer {
         if (Math.abs(v) > MAX_U31) {
             throw new Error(`overflow, value larger than 32-bits: ${v.toString()}`);
         }
-        // We don't use a VarInt, so it always takes 4 bytes.
+        // We don't use a varint, so it always takes 4 bytes.
         // This could be improved but nothing is standardized yet.
         await this.write(setInt32(this.#scratch, v));
     }
     async u53(v) {
-        if (v > Varint.MAX_U53) {
-            // Number values above 2^53-1 have already lost precision before reaching
-            // the wire, but downgrade overflow to warn so an upstream miscount
-            // doesn't tear down the whole stream. The encoded varint will reflect
-            // the truncated Number value.
-            console.warn(`value larger than 53-bits; use u62 instead (precision lost): ${v.toString()}`);
-        }
-        if (isLeadingOnes(this.version)) {
-            await this.write(Varint.encodeLeadingOnesTo(this.#scratch, v));
-        }
-        else {
-            await this.write(Varint.encodeTo(this.#scratch, v));
+        if (!Number.isSafeInteger(v) || v < 0) {
+            throw new RangeError(`invalid u53: ${v}`);
         }
+        await this.#varint(Math.floor(v / POW32), v >>> 0);
     }
     async u62(v) {
-        if (isLeadingOnes(this.version)) {
-            await this.write(Varint.encodeLeadingOnesTo(this.#scratch, v));
-        }
-        else {
-            await this.write(Varint.encodeTo(this.#scratch, v));
-        }
+        const lo = split(v);
+        await this.#varint(parts.hi, lo);
+    }
+    async varint(v) {
+        await this.#varint(v.hi, v.lo);
+    }
+    #varint(hi, lo) {
+        return this.write(encodeTo(this.#scratch, hi, lo, this.version));
     }
     async write(v) {
         // Mirrors Reader.#fill: every write funnels through here, so a STOP_SENDING from the
         // peer surfaces as a typed code rather than the transport's own error shape.
         await this.#writer.write(v).catch((err) => {
-            throw fromTransport(err);
+            throw fromTransport(err, { version: asIetf(this.version) });
         });
     }
     async string(str) {
@@ -353,12 +580,12 @@ export class Writer {
     // typed code it would get from a write.
     get closed() {
         this.#closed ??= this.#writer.closed.catch((err) => {
-            throw fromTransport(err);
+            throw fromTransport(err, { version: asIetf(this.version) });
         });
         return this.#closed;
     }
     reset(reason) {
-        this.#writer.abort(reason).catch(() => void 0);
+        this.#writer.abort(withCode(reason, this.version)).catch(() => void 0);
     }
     /**
      * Open an outgoing unidirectional stream.
@@ -368,7 +595,7 @@ export class Writer {
      */
     static async open(quic, options) {
         const writable = await openWithin(quic.createUnidirectionalStream(sendOptions(options)), options?.timeout ?? OPEN_TIMEOUT_MS, (stream) => void stream.abort().catch(() => void 0));
-        return new Writer(writable, options?.version);
+        return new Writer(writable, options.version);
     }
     /**
      * Like {@link Writer.open}, but gives up when `cancel` settles or `timeout` elapses,
@@ -379,25 +606,29 @@ export class Writer {
      * an over-limit open instead of rejecting it.
      */
     static async tryOpen(quic, options) {
-        // A rejected `cancel` (STOP_SENDING) means the peer is gone too, so both settle
-        // paths mean "give up" and neither is left unhandled. Built before the open, and
-        // raced ahead of it, so an already-cancelled caller wins even against a slot that
-        // is free right now.
-        const cancelled = options.cancel.then(() => undefined, () => undefined);
+        // Raced ahead of the open, so an already-cancelled caller wins even against a slot
+        // that is free right now. `race` rather than `Promise.race`: the caller shares one
+        // `cancel` across every group of a subscription, which must not gain a reaction per call.
         const open = Writer.open(quic, options);
+        // Resets a stream that opens after we gave up; a no-op if the open itself failed.
+        const abandon = () => {
+            const abandoned = new Error("abandoned waiting for a stream slot");
+            open.then((w) => w.reset(abandoned)).catch(() => void 0);
+        };
         try {
-            const stream = await Promise.race([cancelled, open]);
+            const stream = await race([options.cancel, open]);
             if (stream)
                 return stream;
         }
         catch (err) {
             // open already discarded the late stream on its way out.
-            if (!(err instanceof TimeoutError))
-                throw err;
-            return undefined;
+            if (err instanceof TimeoutError)
+                return undefined;
+            // A rejected `cancel` still leaves the open pending.
+            abandon();
+            throw err;
         }
-        const abandoned = new Error("abandoned waiting for a stream slot");
-        open.then((w) => w.reset(abandoned)).catch(() => void 0);
+        abandon();
         return undefined;
     }
 }