@vaitosoi/minejs 0.5.0 → 0.6.0

package/src/binary/encoder.ts

@@ -1,8 +1,9 @@
-import { Vec3 } from "../physics/direction";
+import { BaseVec3 } from "../physics/direction";
 import { CONTINUATION_FLAG, CONTINUE_BIT, isFixedSizeTag, isTag, MAX_QUANTIZED_VALUE, SCALE_BITS, SEGMENT_BITS } from "./static";
 import { InvalidValue, NumberTooBig, UnexpectedValue } from "../base/error";
 import { FixedSizeTag, Tag } from "./static";
 
+/** @hidden */
 export function makeMovementFlag(onGround: boolean, pushingWall: boolean) {
     let flag = 0;
     if (onGround)
@@ -12,6 +13,9 @@ export function makeMovementFlag(onGround: boolean, pushingWall: boolean) {
     return flag;
 }
 
+/**
+ * Binary encoding helper
+ */
 export class BinaryEncoder {
     private buffer = Buffer.alloc(0);
 
@@ -159,7 +163,7 @@ export class BinaryEncoder {
      * 
      * @returns a Position
      */
-    public writePosition(position: Vec3) {
+    public writePosition(position: BaseVec3) {
         const val = BigInt(
             ((position.x & 0x3FFFFFF) << 38) |
             ((position.z & 0x3FFFFFF) << 12) |
@@ -215,7 +219,7 @@ export class BinaryEncoder {
      * 
      * Read this article for more information: https://minecraft.wiki/w/Java_Edition_protocol/Data_types#LpVec3
      */
-    public writeLpVec3(vec3: Vec3) {
+    public writeLpVec3(vec3: BaseVec3) {
         const maxCoordinate = Math.max(Math.abs(vec3.x), Math.max(Math.abs(vec3.y), Math.abs(vec3.z)));
 
         // Checking for NaN values in our maxCoordinate

package/src/client/client.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import { BlockManager, BlockState } from "../world/block";
+import { BlockGetter, BlockManager, BlockState } from "../world/block";
 import { EntitiesManager } from "../world/entity";
 import { Input, Player } from "../physics/player";
 import { TickLoop } from "../world/tick";
@@ -16,6 +16,7 @@ import { computeUUID } from "../base/math";
 import { HaveSignatureButNotIndex } from "../base/error";
 import { Sender } from "../packet/sender";
 import { CacheImplementation } from "../base/cache";
+import { Container, Slot } from "../world/container";
 
 export type ClientOption = Omit<TCPClientOption, "protocolVersion"> & {
     version: string,
@@ -103,12 +104,29 @@ export interface ClientEvents {
     actionBar: [message: string],
     /** The raw action bar */
     actionBarRaw: [textComponent: TextComponent],
+
+    // Container
+    /** When a container is opened */
+    openContainer: [container: Container],
+    /** When the opening container is closed */
+    closeContainer: [],
+    /** When the packet contain the content of the container is received */
+    containerContent: [container: Container, carryingItem: Slot],
+    /** When the packet contain the property of the container is received */
+    containerProperty: [container: Container],
+
+    /** 
+     * When tab list is updated
+     * 
+     * `{"text":""}` mean remove header or footer.
+     */
+    tablist: [newTablist: { header: { text: string, raw: TextComponent }, footer: { text: string, raw: TextComponent } }]
 }
 
 /**
  * High-level client.
  */
-export class Client<IsReady extends boolean = boolean> extends (EventEmitter as new () => TypedEmitter<ClientEvents>) {
+export class Client extends (EventEmitter as new () => TypedEmitter<ClientEvents>) {
     private static loadRegistry: boolean = false;
 
     private tickLoop: TickLoop;
@@ -118,7 +136,7 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
     private player: Player;
 
     private tcp: TCPClient;
-    private state: SharedState<IsReady>;
+    private state: SharedState;
     private packetListener: Listener;
     private packetSender: Sender;
 
@@ -182,7 +200,7 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
         this.tcp.on("destroy", () => this.emit("destroy"));
         this.on("loadChunk", (sx, sy, sz) => this.blocks.deleteChunkCache(sx, sy, sz));
         this.on("unloadChunk", (sx, sz) => {
-            for (let sy = 0; sy < 16; sy++) 
+            for (let sy = 0; sy < 16; sy++)
                 this.blocks.deleteChunkCache(sx, sy, sz);
         });
     }
@@ -287,10 +305,69 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
 
     /**
      * Rotate your face
+     * 
+     * @see https://minecraft.wiki/w/Java_Edition_protocol/Packets#Synchronize_Player_Position For Yaw and Pitch definition:
+     * 
+     * "Yaw is measured in degrees and does not follow classical trigonometry rules. 
+     * The unit circle of yaw on the XZ-plane starts at (0, 1) and turns counterclockwise, with 90 at (-1, 0), 180 at (0, -1) and 270 at (1, 0).
+     * 
+     * Pitch is measured in degrees, where 0 is looking straight ahead, -90 is looking straight up, and 90 is looking straight down."
+     * 
      * @param yaw In degree
      * @param pitch In degree
      */
     public lookAt(yaw: number, pitch: number) {
         this.player.setAngle(yaw, pitch);
     }
+
+    /**
+     * Get opening container.
+     * 
+     * Return `undefined` if not any is opening
+     */
+    public getOpeningContainer() { return this.state.openingContainer; }
+    /**
+     * Get carrying item.
+     * 
+     * Return `undefined` if not any is carried
+     */
+    public getCarryingItem() { return this.state.player?.carryingItem; }
+    /**
+     * Get player's inventory
+     */
+    public getInventory() { return this.state.player?.inventory; }
+
+    /**
+     * Open a block.
+     * 
+     * **NOTE** Not working for now
+     * 
+     * @returns `true` if the target block is a solid block, or else, return `false`
+     */
+    public openBlock(x: number, y: number, z: number): boolean;
+    public openBlock(position: BaseVec3): boolean;
+    public openBlock(a: BaseVec3 | number, b?: number, c?: number): boolean {
+        this.state.checkReady();
+        const vec3 = Vec3.loadArgs(a, b, c);
+        const clipResult = BlockGetter.clip(
+            new Vec3(this.state.player!.position),
+            new Vec3(vec3),
+            (pos) => this.blocks.at(pos)!.shape
+        )!;
+        console.log(clipResult);
+        if (clipResult.miss) return false;
+        this.packetSender.sendUseItemOn(
+            "main",
+            vec3,
+            clipResult.direction,
+            {
+                x: Math.abs(clipResult.location.x - vec3.x),
+                y: Math.abs(clipResult.location.y - vec3.y),
+                z: Math.abs(clipResult.location.z - vec3.z),
+            },
+            false,
+            false
+        );
+        return true;
+    }
 }

package/src/message/link.ts

@@ -1,3 +1,6 @@
+/**
+ * Represent a node in the linked-list of messages
+ */
 export class MessageLink {
     constructor (
         public index: number,

package/src/message/sigCache.ts

@@ -1,3 +1,8 @@
+/**
+ * Used for caching the message signature
+ * 
+ * Not used for now
+ */
 export class SignatureCache {
     private entries: Buffer[];
 

package/src/net/tcp.ts

@@ -11,10 +11,6 @@ import { EncodeResult } from "../version/codec";
 import { TextComponent } from "../base/typing";
 import { NotImplemented, SockerIsNotWritable, UnexpectedValue } from "../base/error";
 
-// Minecraft related typing
-
-
-
 // TCP related typing
 export interface TCPClientOption {
     /** Server host */
@@ -38,7 +34,11 @@ export interface TCPClientOption {
 
     debug?: {
         /** Log the incoming packet */
-        packetLogger: boolean
+        packetLogger: boolean,
+        /** Packet to ignore */
+        ignorePackets?: string[],
+        /** Ignore logs from TCP client (`packet X length Y`) */
+        ignoreTCPPacketLogs?: number[] | true
     },
 
     // For premium account
@@ -56,8 +56,8 @@ export interface Message {
     target: string | undefined,
     content: string,
     raw: {
-        sender: TextComponent,
-        target: TextComponent | undefined,
+        sender: string | TextComponent,
+        target: string | TextComponent | undefined,
         content: TextComponent | undefined
     }
 }
@@ -72,7 +72,7 @@ export interface Message {
 /**
  * Low-level client. You SHOULD NOT use this client unless you know what are you doing
  * 
- * @see https://minecraft.wiki/w/Java_Edition_protocol/Packets?oldid=3445844
+ * @see https://minecraft.wiki/w/Java_Edition_protocol/Packets
  */
 export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClientEvents>) {
     public readonly socket: Socket;
@@ -163,7 +163,7 @@ export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClient
                 if (dataLength === 0) {
                     packetID = decoder.readVarInt();
                 } else {
-                    const dataBuffer = this.bufferPool.subarray(decoder.offset, expectedPacketEnd);
+                    const dataBuffer = decoder.buffer.subarray(decoder.offset, expectedPacketEnd);
                     const decompressed = inflateSync(dataBuffer);
                     if (decompressed.length !== dataLength)
                         throw new UnexpectedValue("decompressed packet data", decompressed.length.toString(), dataLength.toString());
@@ -171,7 +171,14 @@ export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClient
                     packetID = decoder.readVarInt();
                 }
             }
-            if (this.state.clientOptions.debug?.packetLogger == true)
+            if (
+                this.state.clientOptions.debug &&
+                this.state.clientOptions.debug.packetLogger &&
+                (
+                    (Array.isArray(this.state.clientOptions.debug.ignoreTCPPacketLogs) && !this.state.clientOptions.debug.ignoreTCPPacketLogs.includes(packetID)) ||
+                    (!this.state.clientOptions.debug.ignoreTCPPacketLogs)
+                )
+            )
                 console.log("packet", packetID, "length", decoder.buffer.length);
             this.forwardPacket(packetID, decoder);
 

package/src/packet/listener.ts

@@ -12,11 +12,15 @@ import { AuthRelatedNotFound, HaveSignatureButNotIndex, MessageLinkNotFound, Not
 import { uuidToBuffer } from "../base/math";
 import { MessageLink } from "../message/link";
 import { Sender } from "./sender";
+import { Container, Slot } from "../world/container";
 
 function zodParse<Type extends zod.ZodType>(data: object, zod: Type): zod.infer<Type> {
     return zod.parse(data);
 }
 
+/**
+ * Packet listener
+ */
 export class Listener {
     private readonly mapping: Record<string, (data: object) => void>;
 
@@ -59,6 +63,13 @@ export class Listener {
             "play:remove_mob_effect": this.handleRemoveMobEffect,
             // "play:rotate_head": ,
             "play:set_entity_motion": this.handleSetEntityVelocity,
+
+            "play:open_screen": this.handleOpenScreen,
+            "play:container_close": this.handleCloseContainer,
+            "play:container_set_content": this.handleContainerContent,
+            "play:container_set_data": this.handleContainerProperty,
+
+            "play:tab_list": this.handleSetTablist
         };
     }
 
@@ -73,7 +84,11 @@ export class Listener {
     // Login
 
     private handleLoginDisconnect(data: object) {
-        const { reason } = zodParse(data, zod.object({ reason: zod.record(zod.string(), zod.any()) }));
+        const { reason } = zodParse(data, zod.object({ reason: zod.record(zod.string(), zod.any()).or(zod.string()) }));
+
+        if (typeof reason === "string")
+            return this.disconnect(reason);
+
         const text = getTextFromTextComponent(reason);
 
         this.disconnect(text, reason);
@@ -143,7 +158,9 @@ export class Listener {
                 yaw: 0,
                 pitch: 0,
             },
-            effects: {}
+            effects: {},
+            inventory: new Container(0, -1, {}),
+            carryingItem: undefined
         } satisfies ClientPlayer as any;
         this.sender.sendLoginAck();
     }
@@ -690,12 +707,16 @@ export class Listener {
             filter_type: zod.int(),
             filter_type_bits: zod.array(zod.bigint()).nullable(),
             chat_type: zod.int().or(zod.record(zod.string(), zod.any())),
-            sender_name: zod.record(zod.string(), zod.any()),
-            target_name: zod.record(zod.string(), zod.any()).nullable()
+            sender_name: zod.record(zod.string(), zod.any()).or(zod.string()),
+            target_name: zod.record(zod.string(), zod.any()).or(zod.string()).nullable()
         }));
 
-        const senderNameText = getTextFromTextComponent(sender_name).toString(),
-            targetNameText = target_name ? getTextFromTextComponent(target_name).toString() : undefined;
+        const senderNameText = typeof sender_name === "string" ? sender_name : getTextFromTextComponent(sender_name).toString(),
+            targetNameText = target_name
+                ? typeof target_name === "string"
+                    ? target_name
+                    : getTextFromTextComponent(target_name).toString()
+                : undefined;
 
         const emitObject = {
             sender: senderNameText,
@@ -831,4 +852,83 @@ export class Listener {
             }
         });
     }
+
+    // Container
+    private handleOpenScreen(data: object) {
+        const {
+            window_id,
+            window_type,
+            window_title
+        } = zodParse(data, zod.object({
+            window_id: zod.int(),
+            window_type: zod.int(),
+            window_title: zod.record(zod.string(), zod.any())
+        }));
+        this.state.enqueueMutation(state => {
+            state.openingContainer = new Container(window_id, window_type, window_title);
+            this.emit("openContainer", this.state.openingContainer!);
+        });
+    }
+
+    private handleCloseContainer(data: object) {
+        // Not used by vanilla client
+        const { window_id } = zodParse(data, zod.object({ window_id: zod.int() }));
+
+        this.state.enqueueMutation(state => {
+            state.openingContainer = undefined;
+            this.emit("closeContainer");
+        });
+    }
+
+    private handleContainerContent(data: object) {
+        const {
+            window_id,
+            state_id,
+            slot_data,
+            carried_item
+        } = zodParse(data, zod.object({
+            window_id: zod.int(),
+            state_id: zod.int(),
+            slot_data: zod.array(zod.any() as zod.ZodType<Slot>),
+            carried_item: zod.any() as zod.ZodType<Slot>,
+        }));
+        this.state.enqueueMutation(state => {
+            if (!state.openingContainer) return;
+            state.openingContainer.stateId = state_id;
+            state.openingContainer.slots = slot_data;
+            state.player!.carryingItem = carried_item;
+            this.emit("containerContent", state.openingContainer, state.player!.carryingItem);
+        });
+    }
+
+    private handleContainerProperty(data: object) {
+        const {
+            window_id,
+            property,
+            value
+        } = zodParse(data, zod.object({
+            window_id: zod.number(),
+            property: zod.number(),
+            value: zod.number(),
+        }));
+        this.state.enqueueMutation(state => {
+            if (!state.openingContainer) return;
+            state.openingContainer.setProperty(property, value);
+            this.emit("containerProperty", state.openingContainer);
+        });
+    }
+
+    private handleSetTablist(data: object) {
+        const { header, footer } = zodParse(data, zod.object({
+            header: zod.record(zod.string(), zod.any()),
+            footer: zod.record(zod.string(), zod.any()),
+        }));
+        this.emit(
+            "tablist",
+            {
+                header: { text: getTextFromTextComponent(header), raw: header },
+                footer: { text: getTextFromTextComponent(footer), raw: footer },
+            }
+        );
+    }
 }

package/src/packet/sender.ts

@@ -1,15 +1,19 @@
-import { createPublicKey, publicEncrypt, constants as crypto_constants, randomBytes } from "node:crypto";
+import { createPublicKey, publicEncrypt, constants as crypto_constants, randomBytes, randomInt } from "node:crypto";
 import { TypedEmmiter } from "../base/event";
 import { ClientEvents } from "../client/client";
 import { ProtocolVersionMapping } from "../version/registry";
 import { ClientStatus, ConnectionState, ServerKnownPack, SharedState } from "../world/state";
 import { sliceBuffer } from "../base/buffer";
 import { randomUUIDBytes } from "../base/math";
-import { Angle, BaseVec3 } from "../physics/direction";
+import { Angle, BaseVec3, Direction } from "../physics/direction";
 import { MessageTooLong, NotImplemented } from "../base/error";
 import BitSet from "../base/bitset";
 import { makeMovementFlag } from "../binary/encoder";
+import { BlockFace } from "../world/block";
 
+/**
+ * Packet sender
+ */
 export class Sender {
     constructor(
         private state: SharedState,
@@ -173,4 +177,27 @@ export class Sender {
         });
         this.state.messageCount = 0;
     }
+
+    public sendUseItemOn(
+        hand: "main" | "off",
+        position: BaseVec3,
+        face: BlockFace | Direction,
+        cursorPositionOnBlock: BaseVec3,
+        isInsideBlock: boolean,
+        worldBorderHit: boolean,
+        sequence: number = randomInt(1024),
+    ) {
+        const face_ = (face instanceof Direction ? face.index3D : face) as number;
+        this.sendPacket("use_item_on", {
+            hand: hand === "off" ? 1 : 0,
+            location: position,
+            face: face_,
+            cursor_position_x: cursorPositionOnBlock.x,
+            cursor_position_y: cursorPositionOnBlock.y,
+            cursor_position_z: cursorPositionOnBlock.z,
+            inside_block: isInsideBlock,
+            world_border_hit: worldBorderHit,
+            sequence
+        });
+    }
 }

package/src/physics/aabb.ts

@@ -14,6 +14,9 @@ export interface BaseAABB {
     maxZ: number;
 }
 
+/**
+ * Represent an axis-aligned bounding box
+ */
 export class AABB implements BaseAABB {
     public minX: number;
     public minY: number;
@@ -206,7 +209,7 @@ export class AABB implements BaseAABB {
      * Cliping math. Find smallest distance to reach a face of this AABB.
      */
     public static getDirection(aabb: BaseAABB, from: BaseVec3, delta: BaseVec3, direction_: Direction | null, scaleRef: [number]) {
-        let direction = structuredClone(direction_);
+        let direction = direction_;
         const { minX, maxX, minY, maxY, minZ, maxZ } = aabb;
         if (delta.x > Epsilon)
             direction = this.clipPoint(
@@ -214,7 +217,7 @@ export class AABB implements BaseAABB {
                 scaleRef,
                 { a: delta.x, b: delta.y, c: delta.z },
                 minX,
-                minY, maxX,
+                minY, maxY,
                 minZ, maxZ,
                 from.x, from.y, from.z
             );
@@ -224,7 +227,7 @@ export class AABB implements BaseAABB {
                 scaleRef,
                 { a: delta.x, b: delta.y, c: delta.z },
                 maxX,
-                minY, maxX,
+                minY, maxY,
                 minZ, maxZ,
                 from.x, from.y, from.z
             );
@@ -289,7 +292,7 @@ export class AABB implements BaseAABB {
         /**
          * `s` come from this equation:
          * ```
-         * fromA + s * deltaA = minA (or point here)
+         * fromA + s * deltaA = minA (or `point` here)
          * ```
          * Which find "how far the ray travels to reach a face of this bounding box".
          * 
@@ -302,7 +305,7 @@ export class AABB implements BaseAABB {
             pb = fromB + s * delta.b,
             pc = fromC + s * delta.c;
         if (
-            0 < s && s < scaleRef[0] &&
+            0 < s && s < scaleRef[0] + Epsilon &&
             minB - Epsilon < pb && pb < maxB + Epsilon &&
             minC - Epsilon < pc && pc < maxC + Epsilon
         ) {
@@ -596,9 +599,9 @@ export class VoxelShape {
                                 minZ: z,
                                 maxZ: z + 1
                             });
-                        else if (lastStartZ !== -1)
+                        else if (lastStartZ === -1)
                             lastStartZ = z;
-                    } else if (lastStartZ === -1) {
+                    } else if (lastStartZ !== -1) {
                         let endX = x,
                             endY = y;
                         shape.clearZStrip(lastStartZ, z, endX, endY);

package/src/physics/direction.ts

@@ -4,6 +4,9 @@ export interface BaseVec3 {
     z: number
 }
 
+/**
+ * Represent a vector which has 3 coords
+ */
 export class Vec3 implements BaseVec3 {
     public static readonly Zero = new Vec3(0, 0, 0);
     public static readonly XAxis = new Vec3(1, 0, 0);

package/src/physics/player.ts

@@ -41,6 +41,9 @@ export enum MoverType {
     SHULKER
 }
 
+/**
+ * Represent a player for calculating physics
+ */
 export class Player {
     private fallDistance: number = 0;
     private deltaMovement: Vec3 = Vec3.Zero;
@@ -470,11 +473,11 @@ export class Player {
             if (this.fallDistance != 0 && movement.length() >= 1) {
                 const checkDistance = Math.min(movement.length(), 8);
                 const checkTo = this.getPos().add(movement.normalize().scale(checkDistance));
-                const hitResult = BlockGetter.clip(this.getPos(), checkTo, {
-                    from: this.getPos(),
-                    to: checkTo,
-                    getBlockState: (position) => this.blocks.at(position)!.shape
-                });
+                const hitResult = BlockGetter.clip(
+                    this.getPos(), 
+                    checkTo,
+                    (position) => this.blocks.at(position)!.shape
+                );
                 if (hitResult?.miss !== false)
                     this.fallDistance = 0;
             }

package/src/version/codec.ts

@@ -6,6 +6,7 @@ import { FieldNode, PacketObject, PacketRegistry, VersionDefinitions } from "./r
 import { BinaryEncoder } from "../binary/encoder";
 import { BitSet } from "../base/bitset";
 
+/** @hidden */
 const TCPStateMapping: Record<ConnectionState, keyof z.infer<typeof VersionDefinitions> | null> = {
     [ConnectionState.Disconnected]: null,
     [ConnectionState.Handshake]: "handshaking",
@@ -14,11 +15,15 @@ const TCPStateMapping: Record<ConnectionState, keyof z.infer<typeof VersionDefin
     [ConnectionState.Play]: "play",
 };
 
+/** @hidden */
 export interface EncodeResult {
     buffer: Buffer,
     packet: z.infer<typeof PacketObject>,
 }
 
+/**
+ * A codec that help encode or decode packets
+ */
 export class VersionCodec {
     constructor(private readonly state: SharedState) { }
 
@@ -44,11 +49,14 @@ export class VersionCodec {
                     if (err instanceof NotImplemented) return;
                     throw err;
                 }
-        if (this.state.clientOptions.debug?.packetLogger)
+        if (this.state.clientOptions.debug &&
+            this.state.clientOptions.debug.packetLogger &&
+            (this.state.clientOptions.debug.ignorePackets &&
+                !this.state.clientOptions.debug.ignorePackets.includes(packet.name)))
             console.dir({
                 dir: "to client",
                 state: mappedState,
-                name,
+                name: packet.name,
                 data: resolvedObject,
             });
 
@@ -61,11 +69,15 @@ export class VersionCodec {
         const packet = PacketRegistry.getPacket(mappedState, "serverbound", packetId);
         if (!packet) throw new UnexpectedValue("valid serverbound packet id", packetId.toString());
 
-        if (this.state.clientOptions.debug?.packetLogger)
+        if (this.state.clientOptions.debug &&
+            this.state.clientOptions.debug.packetLogger &&
+            (this.state.clientOptions.debug.ignorePackets &&
+                !this.state.clientOptions.debug.ignorePackets.includes(packet.name)))
             console.dir({
                 dir: "to server",
                 state: mappedState,
-                id: packetId,
+                id: packet.id,
+                name: packet.name,
                 data,
             });
 
@@ -139,7 +151,17 @@ export class VersionCodec {
             case "chat_type_decoration": return decoder.readChatTypeDecoration();
             case "chat_type": return decoder.readChatType();
             case "enum": return this.readField(packetId, readObject, fieldName, field.subType, decoder);
-            case "json_text": return JSON.parse(decoder.readString());
+            case "json_text": {
+                const str = decoder.readString();
+                try {
+                    return JSON.parse(str);
+                } catch (err) {
+                    if (err instanceof SyntaxError)
+                        return str;
+                    else
+                        throw err;
+                }
+            }
             case "object": {
                 const obj: Record<string, any> = {};
                 for (const [key, type] of Object.entries(field.fields))
@@ -147,15 +169,7 @@ export class VersionCodec {
                 return obj;
             }
             case "game_profile": {
-                return {
-                    uuid: decoder.readUUID(),
-                    username: decoder.readString(),
-                    pproperties: decoder.readPrefixedArray((decoder) => ({
-                        name: decoder.readString(),
-                        value: decoder.readString(),
-                        signature: decoder.readPrefixedOptional((decoder) => decoder.readString())
-                    }))
-                };
+                return decoder.readProfile();
             }
             case "heightmap": {
                 return {
@@ -165,6 +179,7 @@ export class VersionCodec {
             }
             case "bitset": return decoder.readPrefixedArray((decoder) => decoder.readLong());
             case "teleport_flags": return decoder.readTeleportFlag();
+            case "slot": return decoder.readSlot();
             case "null": return null;
             case "not_implemented": {
                 if (field.skip_able === true)