@deffa5556/bail 1.0.6 → 1.0.9

package/cjs/lib/Discord/gateway/ShardManager.cjs

@@ -0,0 +1,344 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module ShardManager */
+const Shard_1 = __importDefault(require("./Shard.cjs"));
+const Dispatcher_1 = __importDefault(require("./Dispatcher.cjs"));
+const config_1 = __importDefault(require("./compression/config.cjs"));
+const Constants_1 = require("../Constants.cjs");
+const Collection_1 = __importDefault(require("../util/Collection.cjs"));
+const Errors_1 = require("../util/Errors.cjs");
+/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-assignment, unicorn/prefer-module */
+// @ts-ignore
+let Erlpack;
+try {
+    Erlpack = require("erlpack");
+}
+catch { }
+/* eslint-enable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-assignment, unicorn/prefer-module */
+/** A manager for all the client's shards. */
+class ShardManager extends Collection_1.default {
+    constructor(client, options = {}) {
+        var _a, _b, _c;
+        super();
+        this.connected = false;
+        Object.defineProperty(this, "client", {
+            value: client,
+            writable: false,
+            enumerable: false,
+            configurable: false
+        });
+        this._buckets = {};
+        this._connectQueue = [];
+        this._connectTimeout = null;
+        this.options = {
+            autoReconnect: options.autoReconnect ?? true,
+            compress: options.compress ?? false,
+            compressLibrary: options.compressLibrary ?? null,
+            connectionProperties: {
+                browser: options.connectionProperties?.browser ?? "Oceanic",
+                device: options.connectionProperties?.device ?? "Oceanic",
+                os: options.connectionProperties?.os ?? process.platform
+            },
+            concurrency: options.concurrency === "auto" || options.concurrency && options.concurrency < 1 ? -1 : options.concurrency ?? -1,
+            connectionTimeout: options.connectionTimeout ?? 30000,
+            dispatcher: {
+                blacklist: options.dispatcher?.blacklist === undefined ? null : options.dispatcher.blacklist,
+                whitelist: options.dispatcher?.whitelist === undefined ? null : options.dispatcher.whitelist
+            },
+            firstShardID: options.firstShardID && options.firstShardID < 0 ? 0 : options.firstShardID ?? 0,
+            getAllUsers: options.getAllUsers ?? false,
+            override: options.override ?? {
+                appendQuery: true,
+                gatewayURLIsResumeURL: false,
+                timeBetweenShardConnects: 5000
+            },
+            guildCreateTimeout: options.guildCreateTimeout ?? 2000,
+            intents: typeof options.intents === "number" ? options.intents : 0,
+            largeThreshold: options.largeThreshold ?? 250,
+            lastShardID: options.lastShardID ?? -1,
+            lookupDisallowedIntents: options.lookupDisallowedIntents ?? false,
+            maxReconnectAttempts: options.maxReconnectAttempts ?? Infinity,
+            maxResumeAttempts: options.maxResumeAttempts ?? 10,
+            maxShards: options.maxShards === "auto" || options.maxShards && options.maxShards < 1 ? -1 : options.maxShards ?? -1,
+            presence: {
+                activities: options.presence?.activities ?? [],
+                afk: options.presence?.afk ?? false,
+                status: options.presence?.status ?? "online"
+            },
+            reconnectDelay: options.reconnectDelay ?? ((lastDelay, attempts) => Math.pow(attempts + 1, 0.7) * 20000),
+            removeDisallowedIntents: options.removeDisallowedIntents ?? false,
+            seedVoiceConnections: options.seedVoiceConnections ?? false,
+            shardIDs: options.shardIDs ?? [],
+            ws: options.ws ?? {}
+        };
+        if (this.options.compress) {
+            const types = Object.keys(config_1.default);
+            if (!types.includes(this.options.compress)) {
+                throw new Error(`Invalid compress type: ${this.options.compress}`);
+            }
+            if (this.options.compressLibrary) {
+                const config = config_1.default[this.options.compress].find(cnf => cnf.name === this.options.compressLibrary);
+                if (!config) {
+                    throw new Error(`Invalid library "${this.options.compressLibrary}" for ${this.options.compress}`);
+                }
+                if (!config.check(client)) {
+                    throw config.getError();
+                }
+            }
+            else {
+                const available = config_1.default[this.options.compress] ?? [];
+                const usable = available.find(av => av.check(client));
+                if (!usable) {
+                    throw new Errors_1.DependencyError(`Unable to find a usable ${this.options.compress} compressor`);
+                }
+                this.options.compressLibrary = usable.name;
+            }
+        }
+        (_a = this.options.override).appendQuery ?? (_a.appendQuery = this.options.override.getBot === undefined && this.options.override.url === undefined);
+        (_b = this.options.override).gatewayURLIsResumeURL ?? (_b.gatewayURLIsResumeURL = this.options.override.getBot !== undefined || this.options.override.url !== undefined);
+        (_c = this.options.override).timeBetweenShardConnects ?? (_c.timeBetweenShardConnects = 5000);
+        if (this.options.lastShardID === -1 && this.options.maxShards !== -1) {
+            this.options.lastShardID = this.options.maxShards - 1;
+        }
+        if (!Array.isArray(this.options.shardIDs)) {
+            this.options.shardIDs = [];
+        }
+        if (Object.hasOwn(options, "intents")) {
+            if (Array.isArray(options.intents)) {
+                let bitmask = 0;
+                for (const intent of options.intents) {
+                    if (typeof intent === "number") {
+                        bitmask |= intent;
+                    }
+                    else if (Constants_1.Intents[intent]) {
+                        bitmask |= Constants_1.Intents[intent];
+                    }
+                    else {
+                        if (intent === "ALL") {
+                            bitmask = Constants_1.AllIntents;
+                            break;
+                        }
+                        else if (intent === "ALL_NON_PRIVILEGED") {
+                            bitmask = Constants_1.AllNonPrivilegedIntents;
+                            continue;
+                        }
+                        client.emit("warn", `Unknown intent: ${intent}`);
+                    }
+                }
+                this.options.intents = bitmask;
+            }
+        }
+        else {
+            this.options.intents = Constants_1.AllNonPrivilegedIntents;
+        }
+        if (this.options.getAllUsers && !(this.options.intents & Constants_1.Intents.GUILD_MEMBERS)) {
+            throw new TypeError("Guild members cannot be requested without the GUILD_MEMBERS intent");
+        }
+        Object.defineProperty(this, "dispatcher", {
+            value: new Dispatcher_1.default(this),
+            writable: false,
+            enumerable: false,
+            configurable: false
+        });
+    }
+    _connect(shard) {
+        this._connectQueue.push(shard);
+        this.tryConnect();
+    }
+    _forGuild(guild) {
+        if (this.options.maxShards === -1) {
+            return undefined;
+        }
+        return this.get((this.client.guildShardMap.get(guild) ?? Number((BigInt(guild) >> 22n) % BigInt(this.options.maxShards))));
+    }
+    async _gatewayURLForShard(shard) {
+        if (this.options.override.url !== undefined) {
+            return this.options.override.url(shard, this.options.shardIDs.length);
+        }
+        if (this._gatewayURL) {
+            return this._gatewayURL;
+        }
+        // how did we manage to get all the way to connecting without gatewayURL being set?
+        return (this._gatewayURL = (await (this.options.override.getBot?.() ?? this.client.rest.getBotGateway())).url);
+    }
+    _ready(id) {
+        const mod = id % this.options.concurrency;
+        const rateLimitKey = isNaN(mod) ? 0 : mod;
+        this._buckets[rateLimitKey] = Date.now();
+        this.tryConnect();
+    }
+    _resetConnectQueue() {
+        this._connectQueue = [];
+    }
+    async connect() {
+        if (this.connected) {
+            throw new Error("Already connected.");
+        }
+        let url, data;
+        const overrideURL = (this.options.override.getBot || this.options.override.url) !== undefined;
+        try {
+            if (this.options.maxShards === -1 || this.options.concurrency === -1) {
+                data = await (this.options.override.getBot?.() ?? this.client.rest.getBotGateway());
+                url = data.url;
+            }
+            else {
+                url = overrideURL ? null : (await this.client.rest.getGateway()).url;
+            }
+        }
+        catch (err) {
+            throw new TypeError("Failed to get gateway information.", { cause: err });
+        }
+        if (url && this.options.override.appendQuery) {
+            if (url.includes("?")) {
+                url = url.slice(0, url.indexOf("?"));
+            }
+            if (!url.endsWith("/")) {
+                url += "/";
+            }
+        }
+        /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+        if (this.options.removeDisallowedIntents && Constants_1.PrivilegedIntentMapping.some(([intent]) => (this.options.intents & intent) === intent)) {
+            const { flags } = await this.client.rest.applications.getCurrent();
+            const check = (intent, allowed) => {
+                if ((this.options.intents & intent) === intent && !allowed.some(flag => (flags & flag) === flag)) {
+                    this.client.emit("warn", `removeDisallowedIntents is enabled, and ${Constants_1.Intents[intent]} was included but not found to be allowed. It has been removed.`);
+                    this.options.intents &= ~intent;
+                }
+            };
+            for (const [intent, allowed] of Constants_1.PrivilegedIntentMapping) {
+                check(intent, allowed);
+            }
+        }
+        /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */
+        if (url && this.options.override.appendQuery) {
+            url += `?v=${Constants_1.GATEWAY_VERSION}&encoding=${Erlpack ? "etf" : "json"}`;
+            if (this.options.compress) {
+                const type = this.options.compress === "zstd-stream" ? "zstd-stream" : "zlib-stream";
+                url += `&compress=${type}`;
+            }
+            this._gatewayURL = url;
+        }
+        if (this.options.maxShards === -1) {
+            if (!data || !data.shards) {
+                throw new TypeError("AutoSharding failed, missing required information from Discord.");
+            }
+            this.options.maxShards = data.shards;
+            if (this.options.lastShardID === -1) {
+                this.options.lastShardID = data.shards - 1;
+            }
+        }
+        if (this.options.concurrency === -1) {
+            if (!data) {
+                throw new TypeError("AutoConcurrency failed, missing required information from Discord.");
+            }
+            this.options.concurrency = data.sessionStartLimit.maxConcurrency;
+        }
+        if (this.options.shardIDs.length === 0 && this.options.firstShardID !== undefined && this.options.lastShardID !== undefined) {
+            for (let i = this.options.firstShardID; i <= this.options.lastShardID; i++) {
+                this.options.shardIDs.push(i);
+            }
+        }
+        this.connected = true;
+        for (const id of this.options.shardIDs) {
+            this.spawn(id);
+        }
+    }
+    /**
+     * Disconnect all shards.
+     * @param reconnect If shards should be reconnected. Defaults to {@link Types/Gateway~GatewayOptions#autoReconnect | GatewayOptions#autoReconnect}
+     */
+    disconnect(reconnect = this.options.autoReconnect) {
+        if (!reconnect) {
+            this.connected = false;
+        }
+        this.client.ready = false;
+        for (const [, shard] of this)
+            shard.disconnect(reconnect);
+        this.client.time.reset();
+        this._resetConnectQueue();
+    }
+    spawn(id) {
+        let shard = this.get(id);
+        if (!shard) {
+            shard = new Shard_1.default(id, this);
+            this.set(id, shard);
+            shard
+                .on("ready", () => {
+                this.client.time.set("ready", Date.now());
+                this.client.emit("shardReady", id);
+                if (this.client.ready) {
+                    return;
+                }
+                for (const other of this.values()) {
+                    if (!other.ready) {
+                        return;
+                    }
+                }
+                this.client.ready = true;
+                this.client.emit("ready");
+            })
+                .on("resume", () => {
+                this.client.time.set("resume", Date.now());
+                this.client.emit("shardResume", id);
+                if (this.client.ready) {
+                    return;
+                }
+                for (const other of this.values()) {
+                    if (!other.ready) {
+                        return;
+                    }
+                }
+                this.client.ready = true;
+                this.client.emit("ready");
+            })
+                .on("disconnect", error => {
+                this.client.time.set("disconnect", Date.now());
+                this.client.emit("shardDisconnect", error, id);
+                for (const other of this.values()) {
+                    if (other.ready) {
+                        return;
+                    }
+                }
+                this.client.ready = false;
+                this.client.emit("disconnect");
+            })
+                .on("preReady", () => {
+                this.client.time.set("preReady", Date.now());
+                this.client.emit("shardPreReady", id);
+            });
+        }
+        if (shard.status === "disconnected") {
+            this._connect(shard);
+        }
+    }
+    tryConnect() {
+        if (this._connectQueue.length === 0) {
+            return;
+        }
+        for (const shard of this._connectQueue) {
+            const mod = shard.id % this.options.concurrency;
+            const rateLimitKey = isNaN(mod) ? 0 : mod;
+            const lastConnect = this._buckets[rateLimitKey] ?? 0;
+            if (!shard.sessionID && Date.now() - lastConnect < this.options.override.timeBetweenShardConnects) {
+                continue;
+            }
+            if (this.some(s => s.connecting && ((s.id % this.options.concurrency) || 0) === rateLimitKey)) {
+                continue;
+            }
+            this.client.time.set("connect", Date.now());
+            void shard.connect();
+            this._buckets[rateLimitKey] = Date.now();
+            this._connectQueue.splice(this._connectQueue.findIndex(s => s.id === shard.id), 1);
+        }
+        if (!this._connectTimeout && this._connectQueue.length !== 0) {
+            this._connectTimeout = setTimeout(() => {
+                this._connectTimeout = null;
+                this.tryConnect();
+            }, 500);
+        }
+    }
+}
+exports.default = ShardManager;

package/cjs/lib/Discord/gateway/compression/base.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Compressor {
+    constructor(shard) {
+        Object.defineProperty(this, "shard", {
+            value: shard,
+            configurable: false,
+            enumerable: false,
+            writable: false
+        });
+    }
+}
+exports.default = Compressor;

package/cjs/lib/Discord/gateway/compression/config.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Errors_1 = require("../../util/Errors.cjs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_zlib_1 = __importDefault(require("node:zlib"));
+/* eslint-disable @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-unused-vars, @typescript-eslint/no-var-requires, unicorn/prefer-module */
+const CompressionConfigs = {
+    "zlib-stream": [
+        {
+            name: "zlib-sync",
+            check: (client) => client.util._isModuleInstalled("zlib-sync"),
+            getClass: () => require(node_path_1.default.join(__dirname, "zlib-sync")).default,
+            getError: () => new Errors_1.DependencyError("zlib-sync based zlib-stream compression is not available: zlib-sync is not installed")
+        },
+        {
+            name: "pako",
+            check: (client) => client.util._isModuleInstalled("pako"),
+            getClass: () => require(node_path_1.default.join(__dirname, "pako")).default,
+            getError: () => new Errors_1.DependencyError("pako based zlib-stream compression is not available: pako is not installed")
+        },
+        {
+            name: "native",
+            check: (_client) => "createInflate" in node_zlib_1.default,
+            getClass: () => require(node_path_1.default.join(__dirname, "zlib-native")).default,
+            getError: () => new Errors_1.DependencyError("native zlib-stream compression is not available: zlib.createInflate does not exist")
+        }
+    ],
+    "zstd-stream": [
+        {
+            name: "zstd-napi",
+            check: (client) => client.util._isModuleInstalled("zstd-napi"),
+            getClass: () => require(node_path_1.default.join(__dirname, "zstd-napi")).default,
+            getError: () => new Errors_1.DependencyError("zstd-napi based zstd-stream compression is not available: zstd-napi is not installed")
+        },
+        {
+            name: "native",
+            check: (_client) => "createZstdDecompress" in node_zlib_1.default,
+            getClass: () => require(node_path_1.default.join(__dirname, "zstd-native")).default,
+            getError: () => new Errors_1.DependencyError("native zstd-stream compression is not available: zlib.createZstdDecompress does not exist")
+        }
+    ]
+};
+/* eslint-enable @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-unused-vars */
+exports.default = CompressionConfigs;

package/cjs/lib/Discord/gateway/compression/pako.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base.cjs"));
+const Errors_1 = require("../../util/Errors.cjs");
+const pako_1 = require("pako");
+class PakoCompression extends base_1.default {
+    constructor(shard) {
+        super(shard);
+        this._sharedZLib = new pako_1.Inflate({ chunkSize: 128 * 1024 });
+    }
+    async decompress(data) {
+        if (data.length >= 4 && data.readUInt32BE(data.length - 4) === 0xFFFF) {
+            // store the current pointer for slicing buffers after pushing.
+            const currentPointer = this._sharedZLib.strm?.next_out;
+            this._sharedZLib.push(data, pako_1.constants.Z_SYNC_FLUSH);
+            if (this._sharedZLib.err) {
+                this.shard.client.emit("error", new Errors_1.GatewayError(`zlib error ${this._sharedZLib.err}: ${this._sharedZLib.msg ?? ""}`, 0));
+                return null;
+            }
+            if (this._sharedZLib.chunks.length === 0) {
+                // The current buffer hasn't been flushed
+                data = Buffer.from(this._sharedZLib.strm.output.slice(currentPointer));
+            }
+            else {
+                // Buffers have been flushed one or more times
+                data = Buffer.concat([
+                    this._sharedZLib.chunks[0].slice(currentPointer),
+                    ...this._sharedZLib.chunks.slice(1),
+                    this._sharedZLib.strm.output
+                ]);
+                this._sharedZLib.chunks = [];
+            }
+            return data;
+        }
+        else {
+            this._sharedZLib.push(data, false);
+            return null;
+        }
+    }
+}
+exports.default = PakoCompression;

package/cjs/lib/Discord/gateway/compression/zlib-native.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base.cjs"));
+const Errors_1 = require("../../util/Errors.cjs");
+const node_zlib_1 = require("node:zlib");
+class ZlibNativeCompressor extends base_1.default {
+    constructor(shard) {
+        super(shard);
+        this._chunks = [];
+        this._decompressQueue = Promise.resolve();
+        this.stream = (0, node_zlib_1.createInflate)();
+        this.stream.on("error", err => {
+            this.shard.client.emit("error", new Errors_1.GatewayError(`zlib error: ${String(err)}`, 0));
+        });
+    }
+    async decompress(data) {
+        const isComplete = data.length >= 4 && data.readUInt32BE(data.length - 4) === 0xFFFF;
+        let result = null;
+        this._decompressQueue = this._decompressQueue.then(async () => new Promise(resolve => {
+            // eslint-disable-next-line unicorn/consistent-function-scoping
+            const onData = (chunk) => {
+                this._chunks.push(chunk);
+            };
+            this.stream.on("data", onData);
+            this.stream.write(data, error => {
+                this.stream.off("data", onData);
+                if (error) {
+                    this.shard.client.emit("error", new Errors_1.GatewayError(`Failed to decompress zlib: ${String(error)}`, 0));
+                    result = null;
+                    resolve();
+                    return;
+                }
+                if (isComplete) {
+                    result = this._chunks.length === 0 ? null : Buffer.concat(this._chunks);
+                    this._chunks = [];
+                }
+                resolve();
+            });
+        }));
+        await this._decompressQueue;
+        return result;
+    }
+}
+exports.default = ZlibNativeCompressor;

package/cjs/lib/Discord/gateway/compression/zlib-sync.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base.cjs"));
+const Errors_1 = require("../../util/Errors.cjs");
+const zlib_sync_1 = __importDefault(require("zlib-sync"));
+class ZlibSyncCompressor extends base_1.default {
+    constructor(shard) {
+        super(shard);
+        this._sharedZLib = new zlib_sync_1.default.Inflate({ chunkSize: 128 * 1024 });
+    }
+    async decompress(data) {
+        if (data.length >= 4 && data.readUInt32BE(data.length - 4) === 0xFFFF) {
+            // store the current pointer for slicing buffers after pushing.
+            this._sharedZLib.push(data, zlib_sync_1.default.Z_SYNC_FLUSH);
+            if (this._sharedZLib.err) {
+                this.shard.client.emit("error", new Errors_1.GatewayError(`zlib error ${this._sharedZLib.err}: ${this._sharedZLib.msg ?? ""}`, 0));
+                return null;
+            }
+            data = Buffer.isBuffer(this._sharedZLib.result) ? this._sharedZLib.result : Buffer.from(this._sharedZLib.result ?? "");
+            return data;
+        }
+        else {
+            this._sharedZLib.push(data, false);
+            return null;
+        }
+    }
+}
+exports.default = ZlibSyncCompressor;

package/cjs/lib/Discord/gateway/compression/zstd-napi.cjs

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function () { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function (o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function (o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function (o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o)
+                if (Object.prototype.hasOwnProperty.call(o, k))
+                    ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+                if (k[i] !== "default")
+                    __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base.cjs"));
+const Errors_1 = require("../../util/Errors.cjs");
+const zstd = __importStar(require("zstd-napi"));
+class ZstdCompressor extends base_1.default {
+    constructor(shard) {
+        super(shard);
+        this._decompressQueue = Promise.resolve();
+        this.stream = new zstd.DecompressStream();
+    }
+    async decompress(data) {
+        let result = null;
+        this._decompressQueue = this._decompressQueue.then(async () => await new Promise(resolve => {
+            const chunks = [];
+            const onData = (chunk) => {
+                chunks.push(chunk);
+            };
+            this.stream.on("data", onData);
+            this.stream.write(data, "binary", error => {
+                this.stream.off("data", onData);
+                if (error) {
+                    this.shard.client.emit("error", new Errors_1.GatewayError(`Failed to decompress zstd: ${String(error)}`, 0));
+                    result = null;
+                    resolve();
+                    return;
+                }
+                result = chunks.length === 0 ? null : Buffer.concat(chunks);
+                resolve();
+            });
+        }));
+        await this._decompressQueue;
+        return result;
+    }
+}
+exports.default = ZstdCompressor;

package/cjs/lib/Discord/gateway/compression/zstd-native.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access */
+const base_1 = __importDefault(require("./base.cjs"));
+const Errors_1 = require("../../util/Errors.cjs");
+// @ts-ignore only in node >=22.15.0
+const node_zlib_1 = require("node:zlib");
+class ZstdNativeCompressor extends base_1.default {
+    constructor(shard) {
+        super(shard);
+        this._decompressQueue = Promise.resolve();
+        this.stream = (0, node_zlib_1.createZstdDecompress)({ chunkSize: 65535 });
+        // @ts-ignore only in node >=22.15.0
+        this.stream.on("error", err => {
+            this.shard.client.emit("error", new Errors_1.GatewayError(`zstd error: ${String(err)}`, 0));
+        });
+    }
+    async decompress(data) {
+        let result = null;
+        this._decompressQueue = this._decompressQueue.then(async () => await new Promise(resolve => {
+            const chunks = [];
+            const onData = (chunk) => {
+                chunks.push(chunk);
+            };
+            this.stream.on("data", onData);
+            // @ts-ignore only in node >=22.15.0
+            this.stream.write(data, "binary", error => {
+                this.stream.off("data", onData);
+                if (error) {
+                    this.shard.client.emit("error", new Errors_1.GatewayError(`Failed to decompress zstd: ${String(error)}`, 0));
+                    result = null;
+                    resolve();
+                    return;
+                }
+                result = chunks.length === 0 ? null : Buffer.concat(chunks);
+                resolve();
+            });
+        }));
+        await this._decompressQueue;
+        return result;
+    }
+}
+exports.default = ZstdNativeCompressor;