@jsprismarine/protocol 0.14.2 → 0.15.0-unstable-20261024032303

package/CHANGELOG.md

@@ -1,5 +1,126 @@
 # @jsprismarine/protocol
 
+## 0.15.0-unstable-20261024032303
+
+### Minor Changes
+
+- [#2577](https://github.com/JSPrismarine/JSPrismarine/pull/2577) [`74722e8`](https://github.com/JSPrismarine/JSPrismarine/commit/74722e8b07e5865ca42b04ff81503f2a0559bd0b) Thanks [@filiphsps](https://github.com/filiphsps)! - Add the batch layer to `@jsprismarine/protocol`, and a socketless RakNet pair to `@jsprismarine/raknet`.
+  
+  **`BatchCodec` and `CompressionCodec`.** The outermost Minecraft layer - `0xFE`, an optional algorithm byte, then length-prefixed packets - as something both sides of a connection can use, and which knows nothing about what a packet *is*. A batch is a list of opaque buffers, which is what lets it serve a client, a server and a proxy alike.
+  
+  The distinction it draws that the server's `BatchPacket` does not: the algorithm byte is present if and only if compression has been *negotiated*, which is not the same as this batch being compressed. `RequestNetworkSettings` and `NetworkSettings` carry no prefix; from the next packet onward every batch carries one, and a peer may set it to `0xff` whenever compressing would not pay. Those are two codecs - `BatchCodec.uncompressed()` and `BatchCodec.compressed()` - rather than one boolean.
+  
+  Three things fall out of writing it as a codec rather than a packet:
+  
+  - **A compression threshold**, so a small payload goes out uncompressed and says so, instead of deflate reliably making it larger. Mojang's threshold of 0 means "never compress"; read as a plain `byteLength >= threshold` it would have meant the exact opposite.
+  - **Bounded inflation.** A batch arrives inside one RakNet message, so the compressed bytes are bounded at roughly 2.8 MiB by reassembly - what they *expand* to was bounded by nothing, and both a client and a server read compressed bytes from a peer they have not authenticated. zlib now enforces a ceiling itself.
+  - **Strict splitting.** Every declared length is checked against what actually remains, and the error says at which offset the batch went wrong. An empty batch yields no packets: the `do/while` this replaces always ran once and read a varint out of nothing.
+  
+  `BatchCodecInterop.test.ts` in `@jsprismarine/prismarine` pins the two implementations together, byte for byte in both directions. They will not be swapped for one another in a single commit - the client is built on the codec while the server still runs `BatchPacket` - so for as long as both exist, a disagreement between them is a client that cannot talk to this server.
+  
+  **`LoopbackSocket`.** A connected RakNet pair with no sockets under it, for running a server in the same process as its client. The server keeps talking to a `RakNetSession` and cannot tell it is not on a wire.
+  
+  Framing, ordering, acknowledgement, reassembly and the connected handshake are the ordinary `Session`, unmodified - the alternative, handing frames across directly, would have meant reimplementing `Session.handlePacket`, and single player would then run *similar* code to multiplayer rather than the same code. What is skipped is the offline exchange, which exists only to discover a path MTU and a guid across a network that is not there.
+  
+  Two details it has to get right: delivery goes through a microtask, so a packet answered inline does not nest a second delivery inside the first; and the MTU is 8 KiB rather than "as large as possible", because `Frame` writes its content length *in bits* into an unsigned 16 bit field and anything past 8191 bytes silently wraps it. That is still five and a half times what a real connection negotiates, so a chunk batch that fragments seventeen ways on the wire fragments three ways here.
+  
+  `Loopback.test.ts` runs the same five scenarios twice, once over real sockets and once in memory, and asserts the two agree.
+
+- [#2577](https://github.com/JSPrismarine/JSPrismarine/pull/2577) [`5cd4d0a`](https://github.com/JSPrismarine/JSPrismarine/commit/5cd4d0aaf1b101135135157e9f11c55c4c73a5f9) Thanks [@filiphsps](https://github.com/filiphsps)! - A load-testing harness: N synthetic players against a server, and the numbers they produce.
+  
+  `Fleet` connects a fleet at a configured rate, ticks each bot's behaviours at the server's own twenty per second, and reports what happened - login latency percentiles, RakNet round trip, bytes and packets per direction, how many of the requested bots actually got in, and what each refusal was. A bot that fails to connect is recorded and left out rather than aborting the run, because "how many of five hundred got in" is usually the question being asked.
+  
+  Everything random comes from one seed, derived per bot rather than shared. `Math.random` cannot be seeded, and a run that cannot be repeated is not a measurement: two runs against the same server have to differ because the *server* behaved differently. A single generator handed to five hundred bots would have them take turns drawing from one sequence, so what each did would depend on how the others were scheduled - which is the non-determinism the seed exists to remove.
+  
+  Four behaviours, deliberately separable, because a load test is a question and the question is usually about one kind of traffic: `walk` (chunk streaming and entity tracking), `look` (the broadcast path, without touching streaming), `chat` (fan-out - two hundred bots speaking once each is forty thousand deliveries), and `break` (the three-step action sequence a real client sends).
+  
+  It lives in `packages/client/src/bot/` rather than in a package of its own: it is under a thousand lines, it depends only on the client, and nothing will ever depend on it.
+  
+  **A command line, `jsp-client`**, in the same package and for the same reason - the command line is a way of driving the client, not a separate product.
+  
+  ```
+  jsp-client bot   --host <address> --count <n> [--behaviour walk,chat,break]
+                   [--duration 10m] [--ramp 5/s] [--seed 1234] [--view-distance 4]
+                   [--report report.json]
+  jsp-client connect --host <address> [--name Steve]
+  jsp-client ping    --host <address>
+  ```
+  
+  Built on `node:util.parseArgs` rather than a dependency: the repository has no argument library anywhere, Node 21 is already the engine requirement, and a binary that has to stay `bun build --compile`-able has every reason not to grow a dependency tree for five flags. A bare `--duration 60` means sixty *seconds*, because the alternative reading wastes an afternoon. It exits 2 for a command line it cannot read and 1 when any bot failed to get in, so it works as a CI gate and not only as something to read.
+  
+  **Five more packets migrated to `NetworkPacket<T>`** - `MovePlayer`, `PlayerAction`, `RequestChunkRadius`, `ChunkRadiusUpdated` and `LevelChunk` - each pinned against the server's own class byte for byte. Two carry traps worth naming: `MovePlayer`'s length depends on one of its own bytes, since the teleport fields exist only for a teleport, and `PlayerAction` writes its block positions with an *unsigned* y, so writing all three signed encodes every height above 63 one byte differently and the reader takes the block face out of the middle of a coordinate. `LevelChunk` reads its envelope and hands the terrain over unparsed, which is what lets a bot skip the expensive half of the packet that makes up most of a server's output.
+  
+  Two more bugs the real binary found that the tests could not:
+  
+  - **Nothing kept the process alive.** Every handle the client owns is `unref`ed so a library never holds its host process open, which in a process whose only job *is* that client leaves nothing holding the event loop. Node exited between the first await and the answer: `ping` printed nothing, the fleet connected nobody, and both returned zero. Invisible under a test runner, which keeps the loop alive by itself.
+  - **The report's round-trip time was always `-`.** A report is produced after the run ends, and the RTT lived only on a session that had already been torn down, so the number no report ever saw was the one the harness existed to measure. The transport keeps the last live measurement now.
+  
+  **`ClientSocket.kill` closed its socket one tick too early.** `disconnect` queues a DISCONNECTION_NOTIFICATION and `dgram.send` is asynchronous however immediate the priority was, so closing the handle in the same tick dropped the datagram and the goodbye was never sent. The server then held the session until it timed out - ten seconds counting against the player limit - and a fleet that reconnected found the server full of clients that had already left. Found by the harness itself, on the fifth fleet of a test run.
+
+- [#2577](https://github.com/JSPrismarine/JSPrismarine/pull/2577) [`5cd4d0a`](https://github.com/JSPrismarine/JSPrismarine/commit/5cd4d0aaf1b101135135157e9f11c55c4c73a5f9) Thanks [@filiphsps](https://github.com/filiphsps)! - The client can log in. `@jsprismarine/client` connects to a Bedrock server, completes the handshake and stands in the world - proved by a test that boots a real `Server` in-process and joins it with nothing mocked in between.
+  
+  **`@jsprismarine/auth`, new.** The login identity: the JWT chain, the client data blob, and the P-384 key both are signed with. A package of its own because the proxy shares it - it needs to *verify* an incoming chain when acting as a server in online mode, which a client never does. A provider is chosen at the edge of the application, so which one is in play is a deployment decision rather than a build-time one. `OfflineAuthProvider` signs the single self-signed chain link a real client sends when it is not signed in, and generates its key per instance, because the key *is* the identity: five hundred bots under one name still need five hundred of them.
+  
+  The default skin is generated from flat colour blocks laid over the regions the classic humanoid geometry samples. Mojang's textures cannot be redistributed and a client that refused to log in without one would be useless. It is also not optional in the way it looks: the server builds a `Skin` out of the client data and dereferences eighteen fields without checking any of them, so a client that omits one crashes the login handler rather than being refused.
+  
+  **Ten packets migrated to `NetworkPacket<T>`** - the ones a join cannot do without. `Login` is among them, and is encodable for the first time: `LoginPacket.encodePayload` had been a commented-out block with a hardcoded chain in it since it was written. `StartGame` is deliberately partial, reading the fields a client cannot function without and stopping; the rest is positional and would have to be modelled in full before any of it could be read. Stopping early is safe because a batch length-delimits each packet.
+  
+  **`@jsprismarine/client`, rebuilt.** It was a 230-line proof of concept that could not finish a handshake - it hardcoded RakNet protocol 10 against this repository's own 11, drove a *server* session by passing itself as `this as any`, and sent a Login that encoded nothing. It is now a transport seam, a packet registry with no `Server` in the signature, a batching session and a login state machine, and it depends on `@jsprismarine/protocol` rather than on the server.
+  
+  Three bugs found by pointing it at a real server:
+  
+  - **Inbound batches were dispatched out of order.** Decoding is asynchronous because inflating runs on libuv's thread pool, so a batch takes as long as its *size* says, and a large one was overtaken by every small one that arrived while it was still inflating. A 37 KiB `StartGame` surfacing after the `PlayStatus` that was meant to follow it is not a slow `StartGame`, it is a missing one - the login failed with "the server spawned us without ever sending StartGame" while the packet was still inflating. Inbound is now a chain, the receiving mirror of the one `MinecraftSession` already kept on the way out.
+  - **`ResourcePackResponsePacket.encodePayload` could not be read by its own `decodePayload`**: a spare `writeUnsignedShortLE(0)` sat in front of the count. Latent while only the server handled this packet, which decodes and never writes one.
+  - **`World.getPlayerData` raised "Player has no XUID"** for every unauthenticated player - a case `LoginHandler` explicitly permits, `savePlayerData` has always written a file for, and the very next line already had a fallback for. It logged as an error on every offline join. Reader and writer now share one key.
+
+- [#2577](https://github.com/JSPrismarine/JSPrismarine/pull/2577) [`aeaf717`](https://github.com/JSPrismarine/JSPrismarine/commit/aeaf7171f271b7c6b03df42a6152d1f63b82826b) Thanks [@filiphsps](https://github.com/filiphsps)! - Protocol 2193: Minecraft 1.26.50 and 1.26.51.
+  
+  Everything that was captured for 1.26.40 was captured again from a Bedrock Dedicated Server 1.26.51.1 - the item table (2076 items), the block palette (1477 blocks, 22079 states: 98 new wool and concrete stairs and slabs, a `minecraft:corner` on every stair, four connection states on every fence, pane and bar) and the recipes (1967) - and three things a 2193 client will not get into the world without were captured for the first time: the jigsaw structure rules, sent as `JigsawStructureDataPacket` before `StartGame` because the client disconnects with `MissingStructureData` otherwise; the definitions of the ninety-eight vanilla blocks that 1.26.50 defines in data, which `StartGamePacket` now declares the way a real server does; and the biome definitions, whose packet stopped being two loose lists and became a map of biome data plus a shared string table - a client reaches the world-generation screen with an empty one and gives up, so the real payload is now replayed. `packages/client/tools/capture-server-data.mjs` records all of them in one login.
+  
+  This was found the only way it could be: a retail 1.26.51 client reaching the world-generation screen and stalling. The same client also confirmed that, faced with a server that answers NetherNet's `GET /v1/join` signaling probe with a 404, it falls back to a direct RakNet connection - which is the transport this server speaks.
+  
+  The `LevelChunkPacket` payload wrote its biome sections with the wrong palette header. Each biome sub chunk is a paletted store like the block ones, and its header is `(bitsPerBlock << 1) | networkFlag`; the server wrote `bitsPerBlock 0` but left the network flag clear (`0` instead of `1`), which tells the client the palette is the *persistent* on-disk kind whose entries are NBT compounds. The client then reads the biome value varint as the start of a tag, the whole column decodes to nonsense, and it drops the join at world generation - the last thing standing between a real client and spawning. The section is now `01` (single value, network flag set) plus the biome value per sub chunk, one sub chunk for every one of the client's twenty-four, then the border byte, checked by decoding the packet the server sends and confirming it is consumed to the last byte. This too was invisible to the server's own client, which never deserialized terrain.
+  
+  **The packets the client actually sends were wrong at 2168, and are right now.** The 2168 work was checked with this repository's own client, which reads `StartGame` partially, moves with `MovePlayerPacket` and never touches an inventory - so nothing exercised the paths a real client takes, and several of those had drifted years earlier:
+  
+  - `StartGamePacket` still wrote a movement mode in front of the movement settings. That field left the protocol at 1.21.90, when client authoritative movement was retired, and every field after it went out one byte late. The full layout is now modelled in `@jsprismarine/protocol` and checked by decoding the packet BDS 1.26.51 sends and writing it back byte for byte.
+  - A real client moves with `PlayerAuthInputPacket`, every tick, and has since 1.21.80; the server had no decoder for it, so a real player could not move, and neither could they break a block, because a survival break rides in that packet's block actions. Both are read now and go through the same code as `MovePlayer` and `PlayerAction` do.
+  - `InventoryTransactionPacket` was read in its 748 layout: no presence byte before the legacy slot list, window ids and flags inferred rather than read, and no `Hand`, which 2193 added. `ItemStackRequestPacket` likewise: an action's selector, the four fixed bytes of a stack net id, the client's own descriptor form for auto-craft ingredients. `ItemStackResponsePacket` wrote none of its three optionals. All three follow gophertunnel's 2193 encoding now, with tests that write the bytes by hand.
+  - Block positions in `PlayerActionPacket` were read with an unsigned y, the layout up to 1.26.0; a block below sea level came out in the billions.
+  
+  `PlaySoundPacket` gained the loop count, the range bypass and the two optionals 1.26.50 added, and can be encoded at all. `BuildPlatform` lost its retired members, `UWP` among them: BDS validates a login against the list now and refuses the value the client used to report, so it reports `WIN32`.
+  
+  **The datagen reads Mojang's new publications.** `enums.html` is gone; a release is a `metadata.zip` of JSON schemas attached to a GitHub release, and the schemas list an enum's members without their values. `import-schemas.js` pins two releases - the target for the members, the first later preview whose schemas carry `x-enum-binary-value` for the numbers - into `snapshot/enums.json`, which `generate-enums.js` prefers over the old HTML dump wherever the schemas describe an enum. `DisconnectReason` and `PlayerAuthInputData` are generated from them. The recipe generator reads the `.brarchive` files a 1.26.50 server packs its behaviour packs into, and the palette capture places every block in four settings so that none pops before the save.
+  
+  One thing this release cannot fix: BDS 1.26.51 defaults to `transport=nethernet` and prints that RakNet is no longer a supported transport for players. This server speaks RakNet only. Whether a 1.26.51 client still connects to a RakNet server by address is not something this repository can test.
+
+### Patch Changes
+
+- [#2577](https://github.com/JSPrismarine/JSPrismarine/pull/2577) [`6b60a88`](https://github.com/JSPrismarine/JSPrismarine/commit/6b60a88e40ad9751ea177f4273779869486de7e0) Thanks [@filiphsps](https://github.com/filiphsps)! - Move JSBinaryUtils into the monorepo as `@jsprismarine/binaryutils`.
+  
+  It was developed in its own repository and consumed here as a pinned npm dependency, which meant a
+  change to the binary stream needed a release there before it could be used here. It now lives in
+  `packages/binaryutils` and every consumer resolves it through the workspace, so it builds, typechecks
+  and tests together with the packages that use it.
+  
+  The published name changes: `@jsprismarine/jsbinaryutils` is deprecated on npm and its last release
+  re-exports this package, so existing installs keep working. The API is unchanged.
+  
+  Two things came along with the jump from the pinned 5.5.3 to current: `write()` accepted a
+  `Uint8Array` in its signature but called `Buffer#copy` on it, so anything not already a `Buffer`
+  threw at runtime — it now uses `set`. And the single internal `buffer` field is split into a read and
+  a write buffer, so code reaching past the public API to assign `.buffer` no longer populates the read
+  side; use `setReadBuffer()`.
+  
+  `@jsprismarine/protocol` also gained the dependency in its manifest — it imported the package while
+  relying on it being hoisted into the root `node_modules`.
+
+- [#2579](https://github.com/JSPrismarine/JSPrismarine/pull/2579) [`ff8648e`](https://github.com/JSPrismarine/JSPrismarine/commit/ff8648e6f92e87f702a1fefc09d306db3307da8a) Thanks [@filiphsps](https://github.com/filiphsps)! - Build declaration files with TypeScript 7 through `tsc-ts`. JSON data exports are now typed structurally (`string`, `number`) instead of as literal values.
+- Updated dependencies [[`6b60a88`](https://github.com/JSPrismarine/JSPrismarine/commit/6b60a88e40ad9751ea177f4273779869486de7e0), [`b6c3d73`](https://github.com/JSPrismarine/JSPrismarine/commit/b6c3d73168fa0397205e20fcbf3cc19c4d0bac36), [`60e9e6f`](https://github.com/JSPrismarine/JSPrismarine/commit/60e9e6f981cce46edf2bb2ee0b7b1eea3b7360ee), [`aeaf717`](https://github.com/JSPrismarine/JSPrismarine/commit/aeaf7171f271b7c6b03df42a6152d1f63b82826b), [`ff8648e`](https://github.com/JSPrismarine/JSPrismarine/commit/ff8648e6f92e87f702a1fefc09d306db3307da8a)]:
+  - @jsprismarine/binaryutils@0.15.0-unstable-20261024032303
+  - @jsprismarine/nbt@0.15.0-unstable-20261024032303
+  - @jsprismarine/minecraft@0.15.0-unstable-20261024032303
+
 ## 0.14.2
 
 ### Patch Changes

package/dist/BatchCodec.cjs.cjs

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs.cjs");
+const require_CompressionCodec = require("./CompressionCodec.cjs.cjs");
+let _jsprismarine_binaryutils = require("@jsprismarine/binaryutils");
+_jsprismarine_binaryutils = require_runtime.__toESM(_jsprismarine_binaryutils, 1);
+let _jsprismarine_minecraft = require("@jsprismarine/minecraft");
+// src/BatchCodec.ts
+/** The id every batch carries, and the only packet id RakNet ever sees from Minecraft. */
+var BATCH_PACKET_ID = 254;
+/**
+* A batch: the outermost Minecraft layer, sitting directly inside a RakNet frame.
+*
+* ```
+* 0xFE │ [algorithm byte] │ ⟨varint len, packet⟩ ⟨varint len, packet⟩ …
+* ```
+*
+* The algorithm byte is present if and only if compression has been *negotiated* - which is
+* not the same as this batch being compressed, and conflating the two is the trap here. A
+* connection sends `RequestNetworkSettings` and receives `NetworkSettings` with no prefix at
+* all; from the packet after that one, every batch carries a prefix, and a peer is free to
+* make it {@link UNCOMPRESSED_BATCH} whenever compressing would not pay. So the two states
+* are two codecs - {@link BatchCodec.uncompressed} and {@link BatchCodec.compressed} - and a
+* connection replaces one with the other exactly once.
+*
+* Nothing here knows what a packet *is*: a batch is a list of opaque buffers. That is what
+* lets a proxy route on ids it has no definition for, and what keeps this usable from both
+* sides of a connection.
+*/
+var BatchCodec = class BatchCodec {
+	compression;
+	constructor(compression) {
+		this.compression = compression;
+	}
+	/**
+	* The pre-negotiation form, carrying no algorithm byte. Only `RequestNetworkSettings`
+	* and `NetworkSettings` itself travel this way.
+	*/
+	static uncompressed() {
+		return new BatchCodec(null);
+	}
+	/** The post-negotiation form: every batch carries an algorithm byte. */
+	static compressed(settings) {
+		return new BatchCodec(settings instanceof require_CompressionCodec.CompressionCodec ? settings : new require_CompressionCodec.CompressionCodec(settings));
+	}
+	/** Whether compression has been negotiated, i.e. whether batches carry a prefix byte. */
+	isCompressionEnabled() {
+		return this.compression !== null;
+	}
+	encode(packets) {
+		const payload = BatchCodec.joinPackets(packets);
+		if (this.compression === null) return Buffer.concat([Buffer.from([254]), payload]);
+		const algorithm = this.compression.algorithmFor(payload.byteLength);
+		return BatchCodec.frame(algorithm, this.compression.compress(payload));
+	}
+	/** The same, with the deflate handed to zlib's asynchronous API. */
+	async encodeAsync(packets) {
+		const payload = BatchCodec.joinPackets(packets);
+		if (this.compression === null) return Buffer.concat([Buffer.from([254]), payload]);
+		const algorithm = this.compression.algorithmFor(payload.byteLength);
+		return BatchCodec.frame(algorithm, await this.compression.compressAsync(payload));
+	}
+	decode(batch) {
+		const { algorithm, body } = this.split(batch);
+		return BatchCodec.splitPackets(this.compression === null ? body : this.compression.decompress(algorithm, body));
+	}
+	/** The same, with the inflate handed to zlib's asynchronous API. */
+	async decodeAsync(batch) {
+		const { algorithm, body } = this.split(batch);
+		return BatchCodec.splitPackets(this.compression === null ? body : await this.compression.decompressAsync(algorithm, body));
+	}
+	static frame(algorithm, body) {
+		return Buffer.concat([Buffer.from([254, require_CompressionCodec.CompressionCodec.toPrefix(algorithm)]), body]);
+	}
+	/** Strips the id and, when compression is on, the algorithm byte. */
+	split(batch) {
+		if (batch.byteLength < 1 || batch[0] !== 254) throw new Error(`Not a batch: expected id 0x${254 .toString(16)}, got 0x${batch[0]?.toString(16)}`);
+		if (this.compression === null) return {
+			algorithm: _jsprismarine_minecraft.PacketCompressionAlgorithm.NONE,
+			body: batch.subarray(1)
+		};
+		if (batch.byteLength < 2) throw new Error("Truncated batch: compression is negotiated but the algorithm byte is missing");
+		return {
+			algorithm: require_CompressionCodec.CompressionCodec.fromPrefix(batch[1]),
+			body: batch.subarray(2)
+		};
+	}
+	static joinPackets(packets) {
+		const stream = new _jsprismarine_binaryutils.default();
+		for (const packet of packets) {
+			stream.writeUnsignedVarInt(packet.byteLength);
+			stream.write(packet);
+		}
+		return stream.getBuffer();
+	}
+	/**
+	* Splits the decompressed payload back into packets.
+	*
+	* A manual cursor rather than a `BinaryStream`, for the offsets: every length here is
+	* peer-controlled and has to be checked against what is actually left, and saying
+	* *where* a batch went wrong is most of the value of noticing. An empty payload yields
+	* no packets rather than throwing - the `do/while` this replaced always ran once and
+	* tried to read a varint out of nothing.
+	*/
+	static splitPackets(payload) {
+		const packets = [];
+		let cursor = 0;
+		while (cursor < payload.byteLength) {
+			const start = cursor;
+			const { value: length, next } = BatchCodec.readUnsignedVarInt(payload, cursor);
+			cursor = next;
+			if (length === 0) throw new Error(`Malformed batch: zero length packet at offset ${start}`);
+			if (length > payload.byteLength - cursor) throw new Error(`Malformed batch: packet at offset ${start} declares ${length} bytes, ${payload.byteLength - cursor} remain`);
+			packets.push(payload.subarray(cursor, cursor + length));
+			cursor += length;
+		}
+		return packets;
+	}
+	/** LEB128, matching `BinaryStream.readUnsignedVarInt` including its over-long rejection. */
+	static readUnsignedVarInt(buffer, offset) {
+		let value = 0;
+		let cursor = offset;
+		for (let shift = 0; shift <= 28; shift += 7) {
+			if (cursor >= buffer.byteLength) throw new Error(`Malformed batch: varint at offset ${offset} runs past the end of the payload`);
+			const byte = buffer[cursor++];
+			value |= (byte & 127) << shift;
+			if ((byte & 128) === 0) {
+				if (shift === 28 && (byte & 112) !== 0) throw new Error(`Malformed batch: varint at offset ${offset} overflows 32 bits`);
+				return {
+					value: value >>> 0,
+					next: cursor
+				};
+			}
+		}
+		throw new Error(`Malformed batch: varint at offset ${offset} did not terminate after 5 bytes`);
+	}
+};
+exports.BATCH_PACKET_ID = BATCH_PACKET_ID;
+exports.BatchCodec = BatchCodec;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"BatchCodec.cjs.cjs","names":["CompressionCodec","PacketCompressionAlgorithm","BinaryStream"],"sources":["../src/BatchCodec.ts"],"sourcesContent":["import BinaryStream from '@jsprismarine/binaryutils';\nimport { PacketCompressionAlgorithm } from '@jsprismarine/minecraft';\nimport type { CompressionSettings } from './CompressionCodec';\nimport { CompressionCodec } from './CompressionCodec';\n\n/** The id every batch carries, and the only packet id RakNet ever sees from Minecraft. */\nexport const BATCH_PACKET_ID = 0xfe;\n\n/**\n * A batch: the outermost Minecraft layer, sitting directly inside a RakNet frame.\n *\n * ```\n * 0xFE │ [algorithm byte] │ ⟨varint len, packet⟩ ⟨varint len, packet⟩ …\n * ```\n *\n * The algorithm byte is present if and only if compression has been *negotiated* - which is\n * not the same as this batch being compressed, and conflating the two is the trap here. A\n * connection sends `RequestNetworkSettings` and receives `NetworkSettings` with no prefix at\n * all; from the packet after that one, every batch carries a prefix, and a peer is free to\n * make it {@link UNCOMPRESSED_BATCH} whenever compressing would not pay. So the two states\n * are two codecs - {@link BatchCodec.uncompressed} and {@link BatchCodec.compressed} - and a\n * connection replaces one with the other exactly once.\n *\n * Nothing here knows what a packet *is*: a batch is a list of opaque buffers. That is what\n * lets a proxy route on ids it has no definition for, and what keeps this usable from both\n * sides of a connection.\n */\nexport class BatchCodec {\n    private constructor(private readonly compression: CompressionCodec | null) {}\n\n    /**\n     * The pre-negotiation form, carrying no algorithm byte. Only `RequestNetworkSettings`\n     * and `NetworkSettings` itself travel this way.\n     */\n    public static uncompressed(): BatchCodec {\n        return new BatchCodec(null);\n    }\n\n    /** The post-negotiation form: every batch carries an algorithm byte. */\n    public static compressed(settings: CompressionSettings | CompressionCodec): BatchCodec {\n        return new BatchCodec(settings instanceof CompressionCodec ? settings : new CompressionCodec(settings));\n    }\n\n    /** Whether compression has been negotiated, i.e. whether batches carry a prefix byte. */\n    public isCompressionEnabled(): boolean {\n        return this.compression !== null;\n    }\n\n    public encode(packets: readonly Buffer[]): Buffer {\n        const payload = BatchCodec.joinPackets(packets);\n\n        if (this.compression === null) {\n            return Buffer.concat([Buffer.from([BATCH_PACKET_ID]), payload]);\n        }\n\n        const algorithm = this.compression.algorithmFor(payload.byteLength);\n        return BatchCodec.frame(algorithm, this.compression.compress(payload));\n    }\n\n    /** The same, with the deflate handed to zlib's asynchronous API. */\n    public async encodeAsync(packets: readonly Buffer[]): Promise<Buffer> {\n        const payload = BatchCodec.joinPackets(packets);\n\n        if (this.compression === null) {\n            return Buffer.concat([Buffer.from([BATCH_PACKET_ID]), payload]);\n        }\n\n        const algorithm = this.compression.algorithmFor(payload.byteLength);\n        return BatchCodec.frame(algorithm, await this.compression.compressAsync(payload));\n    }\n\n    public decode(batch: Buffer): Buffer[] {\n        const { algorithm, body } = this.split(batch);\n\n        return BatchCodec.splitPackets(this.compression === null ? body : this.compression.decompress(algorithm, body));\n    }\n\n    /** The same, with the inflate handed to zlib's asynchronous API. */\n    public async decodeAsync(batch: Buffer): Promise<Buffer[]> {\n        const { algorithm, body } = this.split(batch);\n\n        return BatchCodec.splitPackets(\n            this.compression === null ? body : await this.compression.decompressAsync(algorithm, body)\n        );\n    }\n\n    private static frame(algorithm: PacketCompressionAlgorithm, body: Buffer): Buffer {\n        return Buffer.concat([Buffer.from([BATCH_PACKET_ID, CompressionCodec.toPrefix(algorithm)]), body]);\n    }\n\n    /** Strips the id and, when compression is on, the algorithm byte. */\n    private split(batch: Buffer): { algorithm: PacketCompressionAlgorithm; body: Buffer } {\n        if (batch.byteLength < 1 || batch[0] !== BATCH_PACKET_ID) {\n            throw new Error(\n                `Not a batch: expected id 0x${BATCH_PACKET_ID.toString(16)}, got 0x${batch[0]?.toString(16)}`\n            );\n        }\n\n        if (this.compression === null) {\n            return { algorithm: PacketCompressionAlgorithm.NONE, body: batch.subarray(1) };\n        }\n\n        if (batch.byteLength < 2) {\n            throw new Error('Truncated batch: compression is negotiated but the algorithm byte is missing');\n        }\n\n        return { algorithm: CompressionCodec.fromPrefix(batch[1]!), body: batch.subarray(2) };\n    }\n\n    private static joinPackets(packets: readonly Buffer[]): Buffer {\n        const stream = new BinaryStream();\n        for (const packet of packets) {\n            stream.writeUnsignedVarInt(packet.byteLength);\n            stream.write(packet);\n        }\n\n        return stream.getBuffer();\n    }\n\n    /**\n     * Splits the decompressed payload back into packets.\n     *\n     * A manual cursor rather than a `BinaryStream`, for the offsets: every length here is\n     * peer-controlled and has to be checked against what is actually left, and saying\n     * *where* a batch went wrong is most of the value of noticing. An empty payload yields\n     * no packets rather than throwing - the `do/while` this replaced always ran once and\n     * tried to read a varint out of nothing.\n     */\n    private static splitPackets(payload: Buffer): Buffer[] {\n        const packets: Buffer[] = [];\n        let cursor = 0;\n\n        while (cursor < payload.byteLength) {\n            const start = cursor;\n            const { value: length, next } = BatchCodec.readUnsignedVarInt(payload, cursor);\n            cursor = next;\n\n            if (length === 0) {\n                throw new Error(`Malformed batch: zero length packet at offset ${start}`);\n            }\n            if (length > payload.byteLength - cursor) {\n                throw new Error(\n                    `Malformed batch: packet at offset ${start} declares ${length} bytes, ${\n                        payload.byteLength - cursor\n                    } remain`\n                );\n            }\n\n            packets.push(payload.subarray(cursor, cursor + length));\n            cursor += length;\n        }\n\n        return packets;\n    }\n\n    /** LEB128, matching `BinaryStream.readUnsignedVarInt` including its over-long rejection. */\n    private static readUnsignedVarInt(buffer: Buffer, offset: number): { value: number; next: number } {\n        let value = 0;\n        let cursor = offset;\n\n        for (let shift = 0; shift <= 28; shift += 7) {\n            if (cursor >= buffer.byteLength) {\n                throw new Error(`Malformed batch: varint at offset ${offset} runs past the end of the payload`);\n            }\n\n            const byte = buffer[cursor++]!;\n            value |= (byte & 0x7f) << shift;\n\n            if ((byte & 0x80) === 0) {\n                // Bits above the 32nd would otherwise be shifted off and discarded, so an\n                // over-long encoding such as `ff ff ff ff 7f` would decode to the same\n                // value as the canonical `ff ff ff ff 0f`.\n                if (shift === 28 && (byte & 0x70) !== 0) {\n                    throw new Error(`Malformed batch: varint at offset ${offset} overflows 32 bits`);\n                }\n\n                // `>>> 0` because the accumulator is int32: without it everything from 2^31\n                // up comes back negative.\n                return { value: value >>> 0, next: cursor };\n            }\n        }\n\n        throw new Error(`Malformed batch: varint at offset ${offset} did not terminate after 5 bytes`);\n    }\n}\n"],"mappings":"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"}

package/dist/BatchCodec.d.ts

@@ -0,0 +1,59 @@
+import type { CompressionSettings } from './CompressionCodec';
+import { CompressionCodec } from './CompressionCodec';
+/** The id every batch carries, and the only packet id RakNet ever sees from Minecraft. */
+export declare const BATCH_PACKET_ID = 254;
+/**
+ * A batch: the outermost Minecraft layer, sitting directly inside a RakNet frame.
+ *
+ * ```
+ * 0xFE │ [algorithm byte] │ ⟨varint len, packet⟩ ⟨varint len, packet⟩ …
+ * ```
+ *
+ * The algorithm byte is present if and only if compression has been *negotiated* - which is
+ * not the same as this batch being compressed, and conflating the two is the trap here. A
+ * connection sends `RequestNetworkSettings` and receives `NetworkSettings` with no prefix at
+ * all; from the packet after that one, every batch carries a prefix, and a peer is free to
+ * make it {@link UNCOMPRESSED_BATCH} whenever compressing would not pay. So the two states
+ * are two codecs - {@link BatchCodec.uncompressed} and {@link BatchCodec.compressed} - and a
+ * connection replaces one with the other exactly once.
+ *
+ * Nothing here knows what a packet *is*: a batch is a list of opaque buffers. That is what
+ * lets a proxy route on ids it has no definition for, and what keeps this usable from both
+ * sides of a connection.
+ */
+export declare class BatchCodec {
+    private readonly compression;
+    private constructor();
+    /**
+     * The pre-negotiation form, carrying no algorithm byte. Only `RequestNetworkSettings`
+     * and `NetworkSettings` itself travel this way.
+     */
+    static uncompressed(): BatchCodec;
+    /** The post-negotiation form: every batch carries an algorithm byte. */
+    static compressed(settings: CompressionSettings | CompressionCodec): BatchCodec;
+    /** Whether compression has been negotiated, i.e. whether batches carry a prefix byte. */
+    isCompressionEnabled(): boolean;
+    encode(packets: readonly Buffer[]): Buffer;
+    /** The same, with the deflate handed to zlib's asynchronous API. */
+    encodeAsync(packets: readonly Buffer[]): Promise<Buffer>;
+    decode(batch: Buffer): Buffer[];
+    /** The same, with the inflate handed to zlib's asynchronous API. */
+    decodeAsync(batch: Buffer): Promise<Buffer[]>;
+    private static frame;
+    /** Strips the id and, when compression is on, the algorithm byte. */
+    private split;
+    private static joinPackets;
+    /**
+     * Splits the decompressed payload back into packets.
+     *
+     * A manual cursor rather than a `BinaryStream`, for the offsets: every length here is
+     * peer-controlled and has to be checked against what is actually left, and saying
+     * *where* a batch went wrong is most of the value of noticing. An empty payload yields
+     * no packets rather than throwing - the `do/while` this replaced always ran once and
+     * tried to read a varint out of nothing.
+     */
+    private static splitPackets;
+    /** LEB128, matching `BinaryStream.readUnsignedVarInt` including its over-long rejection. */
+    private static readUnsignedVarInt;
+}
+//# sourceMappingURL=BatchCodec.d.ts.map

package/dist/BatchCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BatchCodec.d.ts","sourceRoot":"","sources":["../src/BatchCodec.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,0FAA0F;AAC1F,eAAO,MAAM,eAAe,MAAO,CAAC;AAEpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,UAAU;IACC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAAhD,OAAO,eAAsE;IAE7E;;;OAGG;IACH,OAAc,YAAY,IAAI,UAAU,CAEvC;IAED,wEAAwE;IACxE,OAAc,UAAU,CAAC,QAAQ,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,UAAU,CAErF;IAED,yFAAyF;IAClF,oBAAoB,IAAI,OAAO,CAErC;IAEM,MAAM,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAShD;IAED,oEAAoE;IACvD,WAAW,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CASpE;IAEM,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAIrC;IAED,oEAAoE;IACvD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAMzD;IAED,OAAO,CAAC,MAAM,CAAC,KAAK;IAIpB,qEAAqE;IACrE,OAAO,CAAC,KAAK;IAkBb,OAAO,CAAC,MAAM,CAAC,WAAW;IAU1B;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IA2B3B,4FAA4F;IAC5F,OAAO,CAAC,MAAM,CAAC,kBAAkB;CA4BpC"}

package/dist/BatchCodec.es.js

@@ -0,0 +1,136 @@
+import { CompressionCodec } from "./CompressionCodec.es.js";
+import BinaryStream from "@jsprismarine/binaryutils";
+import { PacketCompressionAlgorithm } from "@jsprismarine/minecraft";
+// src/BatchCodec.ts
+/** The id every batch carries, and the only packet id RakNet ever sees from Minecraft. */
+var BATCH_PACKET_ID = 254;
+/**
+* A batch: the outermost Minecraft layer, sitting directly inside a RakNet frame.
+*
+* ```
+* 0xFE │ [algorithm byte] │ ⟨varint len, packet⟩ ⟨varint len, packet⟩ …
+* ```
+*
+* The algorithm byte is present if and only if compression has been *negotiated* - which is
+* not the same as this batch being compressed, and conflating the two is the trap here. A
+* connection sends `RequestNetworkSettings` and receives `NetworkSettings` with no prefix at
+* all; from the packet after that one, every batch carries a prefix, and a peer is free to
+* make it {@link UNCOMPRESSED_BATCH} whenever compressing would not pay. So the two states
+* are two codecs - {@link BatchCodec.uncompressed} and {@link BatchCodec.compressed} - and a
+* connection replaces one with the other exactly once.
+*
+* Nothing here knows what a packet *is*: a batch is a list of opaque buffers. That is what
+* lets a proxy route on ids it has no definition for, and what keeps this usable from both
+* sides of a connection.
+*/
+var BatchCodec = class BatchCodec {
+	compression;
+	constructor(compression) {
+		this.compression = compression;
+	}
+	/**
+	* The pre-negotiation form, carrying no algorithm byte. Only `RequestNetworkSettings`
+	* and `NetworkSettings` itself travel this way.
+	*/
+	static uncompressed() {
+		return new BatchCodec(null);
+	}
+	/** The post-negotiation form: every batch carries an algorithm byte. */
+	static compressed(settings) {
+		return new BatchCodec(settings instanceof CompressionCodec ? settings : new CompressionCodec(settings));
+	}
+	/** Whether compression has been negotiated, i.e. whether batches carry a prefix byte. */
+	isCompressionEnabled() {
+		return this.compression !== null;
+	}
+	encode(packets) {
+		const payload = BatchCodec.joinPackets(packets);
+		if (this.compression === null) return Buffer.concat([Buffer.from([254]), payload]);
+		const algorithm = this.compression.algorithmFor(payload.byteLength);
+		return BatchCodec.frame(algorithm, this.compression.compress(payload));
+	}
+	/** The same, with the deflate handed to zlib's asynchronous API. */
+	async encodeAsync(packets) {
+		const payload = BatchCodec.joinPackets(packets);
+		if (this.compression === null) return Buffer.concat([Buffer.from([254]), payload]);
+		const algorithm = this.compression.algorithmFor(payload.byteLength);
+		return BatchCodec.frame(algorithm, await this.compression.compressAsync(payload));
+	}
+	decode(batch) {
+		const { algorithm, body } = this.split(batch);
+		return BatchCodec.splitPackets(this.compression === null ? body : this.compression.decompress(algorithm, body));
+	}
+	/** The same, with the inflate handed to zlib's asynchronous API. */
+	async decodeAsync(batch) {
+		const { algorithm, body } = this.split(batch);
+		return BatchCodec.splitPackets(this.compression === null ? body : await this.compression.decompressAsync(algorithm, body));
+	}
+	static frame(algorithm, body) {
+		return Buffer.concat([Buffer.from([254, CompressionCodec.toPrefix(algorithm)]), body]);
+	}
+	/** Strips the id and, when compression is on, the algorithm byte. */
+	split(batch) {
+		if (batch.byteLength < 1 || batch[0] !== 254) throw new Error(`Not a batch: expected id 0x${254 .toString(16)}, got 0x${batch[0]?.toString(16)}`);
+		if (this.compression === null) return {
+			algorithm: PacketCompressionAlgorithm.NONE,
+			body: batch.subarray(1)
+		};
+		if (batch.byteLength < 2) throw new Error("Truncated batch: compression is negotiated but the algorithm byte is missing");
+		return {
+			algorithm: CompressionCodec.fromPrefix(batch[1]),
+			body: batch.subarray(2)
+		};
+	}
+	static joinPackets(packets) {
+		const stream = new BinaryStream();
+		for (const packet of packets) {
+			stream.writeUnsignedVarInt(packet.byteLength);
+			stream.write(packet);
+		}
+		return stream.getBuffer();
+	}
+	/**
+	* Splits the decompressed payload back into packets.
+	*
+	* A manual cursor rather than a `BinaryStream`, for the offsets: every length here is
+	* peer-controlled and has to be checked against what is actually left, and saying
+	* *where* a batch went wrong is most of the value of noticing. An empty payload yields
+	* no packets rather than throwing - the `do/while` this replaced always ran once and
+	* tried to read a varint out of nothing.
+	*/
+	static splitPackets(payload) {
+		const packets = [];
+		let cursor = 0;
+		while (cursor < payload.byteLength) {
+			const start = cursor;
+			const { value: length, next } = BatchCodec.readUnsignedVarInt(payload, cursor);
+			cursor = next;
+			if (length === 0) throw new Error(`Malformed batch: zero length packet at offset ${start}`);
+			if (length > payload.byteLength - cursor) throw new Error(`Malformed batch: packet at offset ${start} declares ${length} bytes, ${payload.byteLength - cursor} remain`);
+			packets.push(payload.subarray(cursor, cursor + length));
+			cursor += length;
+		}
+		return packets;
+	}
+	/** LEB128, matching `BinaryStream.readUnsignedVarInt` including its over-long rejection. */
+	static readUnsignedVarInt(buffer, offset) {
+		let value = 0;
+		let cursor = offset;
+		for (let shift = 0; shift <= 28; shift += 7) {
+			if (cursor >= buffer.byteLength) throw new Error(`Malformed batch: varint at offset ${offset} runs past the end of the payload`);
+			const byte = buffer[cursor++];
+			value |= (byte & 127) << shift;
+			if ((byte & 128) === 0) {
+				if (shift === 28 && (byte & 112) !== 0) throw new Error(`Malformed batch: varint at offset ${offset} overflows 32 bits`);
+				return {
+					value: value >>> 0,
+					next: cursor
+				};
+			}
+		}
+		throw new Error(`Malformed batch: varint at offset ${offset} did not terminate after 5 bytes`);
+	}
+};
+export { BATCH_PACKET_ID, BatchCodec };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"BatchCodec.es.js","names":[],"sources":["../src/BatchCodec.ts"],"sourcesContent":["import BinaryStream from '@jsprismarine/binaryutils';\nimport { PacketCompressionAlgorithm } from '@jsprismarine/minecraft';\nimport type { CompressionSettings } from './CompressionCodec';\nimport { CompressionCodec } from './CompressionCodec';\n\n/** The id every batch carries, and the only packet id RakNet ever sees from Minecraft. */\nexport const BATCH_PACKET_ID = 0xfe;\n\n/**\n * A batch: the outermost Minecraft layer, sitting directly inside a RakNet frame.\n *\n * ```\n * 0xFE │ [algorithm byte] │ ⟨varint len, packet⟩ ⟨varint len, packet⟩ …\n * ```\n *\n * The algorithm byte is present if and only if compression has been *negotiated* - which is\n * not the same as this batch being compressed, and conflating the two is the trap here. A\n * connection sends `RequestNetworkSettings` and receives `NetworkSettings` with no prefix at\n * all; from the packet after that one, every batch carries a prefix, and a peer is free to\n * make it {@link UNCOMPRESSED_BATCH} whenever compressing would not pay. So the two states\n * are two codecs - {@link BatchCodec.uncompressed} and {@link BatchCodec.compressed} - and a\n * connection replaces one with the other exactly once.\n *\n * Nothing here knows what a packet *is*: a batch is a list of opaque buffers. That is what\n * lets a proxy route on ids it has no definition for, and what keeps this usable from both\n * sides of a connection.\n */\nexport class BatchCodec {\n    private constructor(private readonly compression: CompressionCodec | null) {}\n\n    /**\n     * The pre-negotiation form, carrying no algorithm byte. Only `RequestNetworkSettings`\n     * and `NetworkSettings` itself travel this way.\n     */\n    public static uncompressed(): BatchCodec {\n        return new BatchCodec(null);\n    }\n\n    /** The post-negotiation form: every batch carries an algorithm byte. */\n    public static compressed(settings: CompressionSettings | CompressionCodec): BatchCodec {\n        return new BatchCodec(settings instanceof CompressionCodec ? settings : new CompressionCodec(settings));\n    }\n\n    /** Whether compression has been negotiated, i.e. whether batches carry a prefix byte. */\n    public isCompressionEnabled(): boolean {\n        return this.compression !== null;\n    }\n\n    public encode(packets: readonly Buffer[]): Buffer {\n        const payload = BatchCodec.joinPackets(packets);\n\n        if (this.compression === null) {\n            return Buffer.concat([Buffer.from([BATCH_PACKET_ID]), payload]);\n        }\n\n        const algorithm = this.compression.algorithmFor(payload.byteLength);\n        return BatchCodec.frame(algorithm, this.compression.compress(payload));\n    }\n\n    /** The same, with the deflate handed to zlib's asynchronous API. */\n    public async encodeAsync(packets: readonly Buffer[]): Promise<Buffer> {\n        const payload = BatchCodec.joinPackets(packets);\n\n        if (this.compression === null) {\n            return Buffer.concat([Buffer.from([BATCH_PACKET_ID]), payload]);\n        }\n\n        const algorithm = this.compression.algorithmFor(payload.byteLength);\n        return BatchCodec.frame(algorithm, await this.compression.compressAsync(payload));\n    }\n\n    public decode(batch: Buffer): Buffer[] {\n        const { algorithm, body } = this.split(batch);\n\n        return BatchCodec.splitPackets(this.compression === null ? body : this.compression.decompress(algorithm, body));\n    }\n\n    /** The same, with the inflate handed to zlib's asynchronous API. */\n    public async decodeAsync(batch: Buffer): Promise<Buffer[]> {\n        const { algorithm, body } = this.split(batch);\n\n        return BatchCodec.splitPackets(\n            this.compression === null ? body : await this.compression.decompressAsync(algorithm, body)\n        );\n    }\n\n    private static frame(algorithm: PacketCompressionAlgorithm, body: Buffer): Buffer {\n        return Buffer.concat([Buffer.from([BATCH_PACKET_ID, CompressionCodec.toPrefix(algorithm)]), body]);\n    }\n\n    /** Strips the id and, when compression is on, the algorithm byte. */\n    private split(batch: Buffer): { algorithm: PacketCompressionAlgorithm; body: Buffer } {\n        if (batch.byteLength < 1 || batch[0] !== BATCH_PACKET_ID) {\n            throw new Error(\n                `Not a batch: expected id 0x${BATCH_PACKET_ID.toString(16)}, got 0x${batch[0]?.toString(16)}`\n            );\n        }\n\n        if (this.compression === null) {\n            return { algorithm: PacketCompressionAlgorithm.NONE, body: batch.subarray(1) };\n        }\n\n        if (batch.byteLength < 2) {\n            throw new Error('Truncated batch: compression is negotiated but the algorithm byte is missing');\n        }\n\n        return { algorithm: CompressionCodec.fromPrefix(batch[1]!), body: batch.subarray(2) };\n    }\n\n    private static joinPackets(packets: readonly Buffer[]): Buffer {\n        const stream = new BinaryStream();\n        for (const packet of packets) {\n            stream.writeUnsignedVarInt(packet.byteLength);\n            stream.write(packet);\n        }\n\n        return stream.getBuffer();\n    }\n\n    /**\n     * Splits the decompressed payload back into packets.\n     *\n     * A manual cursor rather than a `BinaryStream`, for the offsets: every length here is\n     * peer-controlled and has to be checked against what is actually left, and saying\n     * *where* a batch went wrong is most of the value of noticing. An empty payload yields\n     * no packets rather than throwing - the `do/while` this replaced always ran once and\n     * tried to read a varint out of nothing.\n     */\n    private static splitPackets(payload: Buffer): Buffer[] {\n        const packets: Buffer[] = [];\n        let cursor = 0;\n\n        while (cursor < payload.byteLength) {\n            const start = cursor;\n            const { value: length, next } = BatchCodec.readUnsignedVarInt(payload, cursor);\n            cursor = next;\n\n            if (length === 0) {\n                throw new Error(`Malformed batch: zero length packet at offset ${start}`);\n            }\n            if (length > payload.byteLength - cursor) {\n                throw new Error(\n                    `Malformed batch: packet at offset ${start} declares ${length} bytes, ${\n                        payload.byteLength - cursor\n                    } remain`\n                );\n            }\n\n            packets.push(payload.subarray(cursor, cursor + length));\n            cursor += length;\n        }\n\n        return packets;\n    }\n\n    /** LEB128, matching `BinaryStream.readUnsignedVarInt` including its over-long rejection. */\n    private static readUnsignedVarInt(buffer: Buffer, offset: number): { value: number; next: number } {\n        let value = 0;\n        let cursor = offset;\n\n        for (let shift = 0; shift <= 28; shift += 7) {\n            if (cursor >= buffer.byteLength) {\n                throw new Error(`Malformed batch: varint at offset ${offset} runs past the end of the payload`);\n            }\n\n            const byte = buffer[cursor++]!;\n            value |= (byte & 0x7f) << shift;\n\n            if ((byte & 0x80) === 0) {\n                // Bits above the 32nd would otherwise be shifted off and discarded, so an\n                // over-long encoding such as `ff ff ff ff 7f` would decode to the same\n                // value as the canonical `ff ff ff ff 0f`.\n                if (shift === 28 && (byte & 0x70) !== 0) {\n                    throw new Error(`Malformed batch: varint at offset ${offset} overflows 32 bits`);\n                }\n\n                // `>>> 0` because the accumulator is int32: without it everything from 2^31\n                // up comes back negative.\n                return { value: value >>> 0, next: cursor };\n            }\n        }\n\n        throw new Error(`Malformed batch: varint at offset ${offset} did not terminate after 5 bytes`);\n    }\n}\n"],"mappings":"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"}