seyfert 1.5.0 → 2.1.0

package/lib/websocket/SharedTypes.d.ts

@@ -1,6 +1,6 @@
-import { type APIAuditLogEntry, type APIAutoModerationRule, type APIChannel, type APIEntitlement, type APIGuild, type APIGuildMember, type APIGuildScheduledEvent, type APIStageInstance, type APIUser, type GatewayActivity, type GatewayAutoModerationActionExecutionDispatchData, type GatewayChannelPinsUpdateDispatchData, type GatewayChannelUpdateDispatchData, GatewayDispatchEvents, type GatewayGuildBanAddDispatchData, type GatewayGuildBanRemoveDispatchData, type GatewayGuildCreateDispatchData, type GatewayGuildDeleteDispatchData, type GatewayGuildEmojisUpdateDispatchData, type GatewayGuildIntegrationsUpdateDispatchData, type GatewayGuildMemberRemoveDispatchData, type GatewayGuildMemberUpdateDispatchData, type GatewayGuildMembersChunkDispatchData, type GatewayGuildRoleCreateDispatchData, type GatewayGuildRoleDeleteDispatchData, type GatewayGuildRoleUpdateDispatchData, type GatewayGuildScheduledEventUserRemoveDispatchData, type GatewayGuildStickersUpdateDispatchData, type GatewayIntegrationCreateDispatchData, type GatewayIntegrationDeleteDispatchData, type GatewayInteractionCreateDispatchData, type GatewayInviteCreateDispatchData, type GatewayInviteDeleteDispatchData, type GatewayMessageCreateDispatchData, type GatewayMessageDeleteBulkDispatchData, type GatewayMessageDeleteDispatchData, type GatewayMessageReactionAddDispatchData, type GatewayMessageReactionRemoveAllDispatchData, type GatewayMessageReactionRemoveDispatchData, type GatewayMessageReactionRemoveEmojiDispatchData, type GatewayMessageUpdateDispatchData, type GatewayPresenceUpdateData, type GatewayPresenceUpdateDispatchData, type GatewayReadyDispatchData, type GatewayRequestGuildMembersDataWithQuery, type GatewayRequestGuildMembersDataWithUserIds, type GatewayThreadCreateDispatchData, type GatewayThreadDeleteDispatchData, type GatewayThreadListSyncDispatchData, type GatewayThreadMemberUpdateDispatchData, type GatewayThreadMembersUpdateDispatchData, type GatewayTypingStartDispatchData, type GatewayUserUpdateDispatchData, type GatewayVoiceServerUpdateDispatchData, type GatewayVoiceStateUpdateData, type GatewayWebhooksUpdateDispatchData, type PresenceUpdateStatus, type GatewayMessagePollVoteDispatchData } from 'discord-api-types/v10';
 import type { RestToKeys } from '../common';
-import type { GatewayGuildMemberAddDispatchDataFixed } from '../structures';
+import type { GatewayActivity, PresenceUpdateStatus, GatewayPresenceUpdateData, GatewayRequestGuildMembersDataWithQuery, GatewayRequestGuildMembersDataWithUserIds, APIGuildMember, APIUser, GatewayReadyDispatchData, GatewayChannelUpdateDispatchData, GatewayAutoModerationActionExecutionDispatchData, GatewayThreadCreateDispatchData, GatewayThreadDeleteDispatchData, GatewayThreadListSyncDispatchData, GatewayThreadMemberUpdateDispatchData, GatewayThreadMembersUpdateDispatchData, GatewayChannelPinsUpdateDispatchData, GatewayGuildCreateDispatchData, APIGuild, GatewayGuildDeleteDispatchData, APIAuditLogEntry, GatewayGuildBanAddDispatchData, GatewayGuildBanRemoveDispatchData, GatewayGuildEmojisUpdateDispatchData, GatewayGuildStickersUpdateDispatchData, GatewayGuildIntegrationsUpdateDispatchData, GatewayGuildMemberAddDispatchData, GatewayGuildMemberRemoveDispatchData, GatewayGuildMemberUpdateDispatchData, GatewayGuildMembersChunkDispatchData, GatewayGuildRoleCreateDispatchData, GatewayGuildRoleUpdateDispatchData, GatewayGuildRoleDeleteDispatchData, GatewayIntegrationDeleteDispatchData, GatewayInviteCreateDispatchData, GatewayInviteDeleteDispatchData, GatewayMessageCreateDispatchData, GatewayMessageUpdateDispatchData, GatewayMessageDeleteDispatchData, GatewayMessageDeleteBulkDispatchData, GatewayMessageReactionAddDispatchData, GatewayMessageReactionRemoveDispatchData, GatewayMessageReactionRemoveAllDispatchData, GatewayMessageReactionRemoveEmojiDispatchData, GatewayPresenceUpdateDispatchData, GatewayTypingStartDispatchData, GatewayUserUpdateDispatchData, GatewayVoiceStateUpdateData, GatewayVoiceServerUpdateDispatchData, GatewayWebhooksUpdateDispatchData, GatewayInteractionCreateDispatchData, APIStageInstance, GatewayMessagePollVoteDispatchData, GatewayIntegrationCreateDispatchData, GatewayGuildScheduledEventUserRemoveDispatchData, APIGuildScheduledEvent, APIChannel, APIAutoModerationRule, APIEntitlement, GatewayVoiceChannelEffectSendDispachData, APISubscription, GatewayEntitlementCreateDispatchData } from '../types';
+import { GatewayDispatchEvents } from '../types';
 /** https://discord.com/developers/docs/topics/gateway-events#update-presence */
 export interface StatusUpdate {
     /** The user's activities */
@@ -55,7 +55,7 @@ export interface Events {
     [GatewayDispatchEvents.GuildEmojisUpdate]: GatewayGuildEmojisUpdateDispatchData;
     [GatewayDispatchEvents.GuildStickersUpdate]: GatewayGuildStickersUpdateDispatchData;
     [GatewayDispatchEvents.GuildIntegrationsUpdate]: GatewayGuildIntegrationsUpdateDispatchData;
-    [GatewayDispatchEvents.GuildMemberAdd]: GatewayGuildMemberAddDispatchDataFixed<boolean>;
+    [GatewayDispatchEvents.GuildMemberAdd]: GatewayGuildMemberAddDispatchData;
     [GatewayDispatchEvents.GuildMemberRemove]: GatewayGuildMemberRemoveDispatchData;
     [GatewayDispatchEvents.GuildMemberUpdate]: GatewayGuildMemberUpdateDispatchData;
     [GatewayDispatchEvents.GuildMembersChunk]: GatewayGuildMembersChunkDispatchData;
@@ -76,10 +76,12 @@ export interface Events {
     [GatewayDispatchEvents.PresenceUpdate]: GatewayPresenceUpdateDispatchData;
     [GatewayDispatchEvents.TypingStart]: GatewayTypingStartDispatchData;
     [GatewayDispatchEvents.UserUpdate]: GatewayUserUpdateDispatchData;
+    [GatewayDispatchEvents.VoiceChannelEffectSend]: GatewayVoiceChannelEffectSendDispachData;
     [GatewayDispatchEvents.VoiceStateUpdate]: GatewayVoiceStateUpdateData;
     [GatewayDispatchEvents.VoiceServerUpdate]: GatewayVoiceServerUpdateDispatchData;
     [GatewayDispatchEvents.WebhooksUpdate]: GatewayWebhooksUpdateDispatchData;
     [GatewayDispatchEvents.InteractionCreate]: GatewayInteractionCreateDispatchData;
+    [GatewayDispatchEvents.EntitlementCreate]: GatewayEntitlementCreateDispatchData;
 }
 export type StageSameEvents = RestToKeys<[
     APIStageInstance,
@@ -122,11 +124,16 @@ export type AutoModetaractionRuleEvents = RestToKeys<[
 ]>;
 export type EntitlementEvents = RestToKeys<[
     APIEntitlement,
-    GatewayDispatchEvents.EntitlementCreate,
     GatewayDispatchEvents.EntitlementDelete,
     GatewayDispatchEvents.EntitlementUpdate
 ]>;
-export type NormalizeEvents = Events & AutoModetaractionRuleEvents & ChannelSameEvents & GuildScheduledSameEvents & GuildScheduledUserSameEvents & IntegrationSameEvents & EntitlementEvents & PollVoteSameEvents & StageSameEvents & {
+export type SubscriptionEvents = RestToKeys<[
+    APISubscription,
+    GatewayDispatchEvents.SubscriptionCreate,
+    GatewayDispatchEvents.SubscriptionDelete,
+    GatewayDispatchEvents.SubscriptionUpdate
+]>;
+export type NormalizeEvents = Events & AutoModetaractionRuleEvents & ChannelSameEvents & GuildScheduledSameEvents & GuildScheduledUserSameEvents & IntegrationSameEvents & EntitlementEvents & PollVoteSameEvents & StageSameEvents & SubscriptionEvents & {
     RAW: GatewayDispatchEvents;
 };
 export type GatewayEvents = {

package/lib/websocket/SharedTypes.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const v10_1 = require("discord-api-types/v10");
+const types_1 = require("../types");

package/lib/websocket/constants/index.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" />
+import type { DeepPartial } from '../../common';
 import type { ShardManagerOptions, WorkerManagerOptions } from '../discord';
 declare const COMPRESS = false;
 declare const properties: {
@@ -6,8 +6,8 @@ declare const properties: {
     browser: string;
     device: string;
 };
-declare const ShardManagerDefaults: Partial<ShardManagerOptions>;
-declare const WorkerManagerDefaults: Partial<WorkerManagerOptions>;
+declare const ShardManagerDefaults: DeepPartial<ShardManagerOptions>;
+declare const WorkerManagerDefaults: DeepPartial<WorkerManagerOptions>;
 export interface IdentifyProperties {
     /**
      * Operating system the shard runs on.

package/lib/websocket/constants/index.js

@@ -20,11 +20,21 @@ const ShardManagerDefaults = {
     handlePayload: (shardId, packet) => {
         console.info(`Packet ${packet.t} on shard ${shardId}`);
     },
+    resharding: {
+        interval: 8 * 60 * 60 * 1e3, // 8h
+        percentage: 80,
+        reloadGuilds() {
+            throw new Error('Unexpected to run <reloadGuilds>');
+        },
+        onGuild() {
+            throw new Error('Unexpected to run <onGuild>');
+        },
+    },
 };
 exports.ShardManagerDefaults = ShardManagerDefaults;
 const WorkerManagerDefaults = {
     ...ShardManagerDefaults,
-    shardsPerWorker: 32,
+    shardsPerWorker: 16,
     handlePayload: (_shardId, _workerId, _packet) => { },
 };
 exports.WorkerManagerDefaults = WorkerManagerDefaults;

package/lib/websocket/discord/basesocket.d.ts

@@ -1,13 +1,13 @@
-import NodeWebSocket from 'ws';
+import { SeyfertWebSocket } from './socket/custom';
 export declare class BaseSocket {
     private internal;
+    ping?: () => Promise<number>;
     constructor(kind: 'ws' | 'bun', url: string);
-    set onopen(callback: NodeWebSocket['onopen']);
-    set onmessage(callback: NodeWebSocket['onmessage']);
-    set onclose(callback: NodeWebSocket['onclose']);
-    set onerror(callback: NodeWebSocket['onerror']);
+    set onopen(callback: SeyfertWebSocket['onopen']);
+    set onmessage(callback: SeyfertWebSocket['onmessage']);
+    set onclose(callback: SeyfertWebSocket['onclose']);
+    set onerror(callback: SeyfertWebSocket['onerror']);
     send(data: string): void;
-    close(...args: Parameters<NodeWebSocket['close']>): void;
-    ping(): Promise<number>;
+    close(...args: Parameters<SeyfertWebSocket['close']>): void;
     get readyState(): number;
 }

package/lib/websocket/discord/basesocket.js

@@ -1,15 +1,44 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseSocket = void 0;
 const node_crypto_1 = require("node:crypto");
-const ws_1 = __importDefault(require("ws"));
+const custom_1 = require("./socket/custom");
 class BaseSocket {
     internal;
+    ping;
     constructor(kind, url) {
-        this.internal = kind === 'ws' ? new ws_1.default(url) : new WebSocket(url);
+        this.internal = kind === 'ws' ? new custom_1.SeyfertWebSocket(url) : new WebSocket(url);
+        if (kind === 'ws') {
+            const ws = this.internal;
+            this.ping = ws.waitPing.bind(ws);
+            ws.onpong = data => {
+                const promise = ws.__promises.get(data);
+                if (promise) {
+                    ws.__promises.delete(data);
+                    promise?.resolve();
+                }
+            };
+        }
+        else {
+            const ws = this.internal;
+            this.ping = () => {
+                return new Promise(res => {
+                    const nonce = (0, node_crypto_1.randomUUID)();
+                    const start = performance.now();
+                    const listener = (data) => {
+                        if (data.toString() !== nonce)
+                            return;
+                        //@ts-expect-error
+                        ws.removeListener('pong', listener);
+                        res(performance.now() - start);
+                    };
+                    //@ts-expect-error
+                    ws.on('pong', listener);
+                    //@ts-expect-error
+                    ws.ping(nonce);
+                });
+            };
+        }
     }
     set onopen(callback) {
         this.internal.onopen = callback;
@@ -27,25 +56,8 @@ class BaseSocket {
         return this.internal.send(data);
     }
     close(...args) {
-        // @ts-expect-error
         return this.internal.close(...args);
     }
-    async ping() {
-        if (!('ping' in this.internal))
-            throw new Error('Unexpected: Method ping not implemented');
-        return new Promise(res => {
-            const nonce = (0, node_crypto_1.randomUUID)();
-            const start = performance.now();
-            const listener = (data) => {
-                if (data.toString() !== nonce)
-                    return;
-                this.internal.removeListener('pong', listener);
-                res(performance.now() - start);
-            };
-            this.internal.on('pong', listener);
-            this.internal.ping(nonce);
-        });
-    }
     get readyState() {
         return this.internal.readyState;
     }

package/lib/websocket/discord/events/memberUpdate.d.ts

@@ -1,9 +1,4 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { APIUser, GatewayGuildMemberUpdateDispatchData } from 'discord-api-types/v10';
+import type { APIUser, GatewayGuildMemberUpdateDispatchData } from '../../../types';
 export declare class MemberUpdateHandler {
     guildMemberUpdate: Map<string, {
         timeout: NodeJS.Timeout;

package/lib/websocket/discord/events/memberUpdate.js

@@ -25,7 +25,8 @@ class MemberUpdateHandler {
         });
     }
     membersEquals(old, member) {
-        return (old.joined_at === member.joined_at &&
+        return (old.guild_id === member.guild_id &&
+            old.joined_at === member.joined_at &&
             old.nick === member.nick &&
             old.avatar === member.avatar &&
             old.pending === member.pending &&

package/lib/websocket/discord/events/presenceUpdate.d.ts

@@ -1,24 +1,11 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { APIUser, GatewayActivity, GatewayPresenceUpdateDispatchData } from 'discord-api-types/v10';
-type FixedGatewayPresenceUpdateDispatchData = (Omit<GatewayPresenceUpdateDispatchData, 'user'> & {
-    user_id: string;
-    user: undefined;
-}) | (Omit<GatewayPresenceUpdateDispatchData, 'user'> & {
-    user: Partial<APIUser> & Pick<APIUser, 'id'>;
-    user_id: undefined;
-});
+import type { GatewayActivity, GatewayPresenceUpdateDispatchData } from '../../../types';
 export declare class PresenceUpdateHandler {
     presenceUpdate: Map<string, {
         timeout: NodeJS.Timeout;
-        presence: FixedGatewayPresenceUpdateDispatchData;
+        presence: GatewayPresenceUpdateDispatchData;
     }>;
-    check(presence: FixedGatewayPresenceUpdateDispatchData): boolean;
-    setPresence(presence: FixedGatewayPresenceUpdateDispatchData): void;
-    presenceEquals(oldPresence: FixedGatewayPresenceUpdateDispatchData, newPresence: FixedGatewayPresenceUpdateDispatchData): boolean | undefined;
+    check(presence: GatewayPresenceUpdateDispatchData): boolean;
+    setPresence(presence: GatewayPresenceUpdateDispatchData): void;
+    presenceEquals(oldPresence: GatewayPresenceUpdateDispatchData, newPresence: GatewayPresenceUpdateDispatchData): boolean | undefined;
     activityEquals(oldActivity: GatewayActivity, newActivity: GatewayActivity): boolean;
 }
-export {};

package/lib/websocket/discord/events/presenceUpdate.js

@@ -4,11 +4,11 @@ exports.PresenceUpdateHandler = void 0;
 class PresenceUpdateHandler {
     presenceUpdate = new Map();
     check(presence) {
-        if (!this.presenceUpdate.has(presence.user?.id ?? presence.user_id)) {
+        if (!this.presenceUpdate.has(presence.user.id)) {
             this.setPresence(presence);
             return true;
         }
-        const data = this.presenceUpdate.get(presence.user?.id ?? presence.user_id);
+        const data = this.presenceUpdate.get(presence.user.id);
         if (this.presenceEquals(data.presence, presence)) {
             return false;
         }
@@ -17,16 +17,15 @@ class PresenceUpdateHandler {
         return true;
     }
     setPresence(presence) {
-        this.presenceUpdate.set(presence.user?.id ?? presence.user_id, {
+        this.presenceUpdate.set(presence.user.id, {
             presence,
             timeout: setTimeout(() => {
-                this.presenceUpdate.delete(presence.user?.id ?? presence.user_id);
+                this.presenceUpdate.delete(presence.user.id);
             }, 1.5e3),
         });
     }
     presenceEquals(oldPresence, newPresence) {
-        return (newPresence &&
-            oldPresence.status === newPresence.status &&
+        return (oldPresence.status === newPresence.status &&
             oldPresence.activities?.length === newPresence.activities?.length &&
             oldPresence.activities?.every((activity, index) => this.activityEquals(activity, newPresence.activities?.[index])) &&
             oldPresence.client_status?.web === newPresence.client_status?.web &&

package/lib/websocket/discord/shard.d.ts

@@ -1,12 +1,9 @@
-/// <reference types="node" />
-import type { GatewayReceivePayload, GatewaySendPayload } from 'discord-api-types/v10';
-import type WS from 'ws';
-import { type CloseEvent } from 'ws';
-import type { Logger } from '../../common';
+import { Logger, type MakeRequired } from '../../common';
 import { DynamicBucket } from '../structures';
 import { ConnectTimeout } from '../structures/timeout';
 import { BaseSocket } from './basesocket';
 import type { ShardData, ShardOptions } from './shared';
+import { type GatewaySendPayload, type GatewayReceivePayload } from '../../types';
 export interface ShardHeart {
     interval: number;
     nodeInterval?: NodeJS.Timeout;
@@ -16,7 +13,7 @@ export interface ShardHeart {
 }
 export declare class Shard {
     id: number;
-    options: ShardOptions;
+    logger: Logger;
     debugger?: Logger;
     data: Partial<ShardData> | ShardData;
     websocket: BaseSocket | null;
@@ -24,6 +21,7 @@ export declare class Shard {
     heart: ShardHeart;
     bucket: DynamicBucket;
     offlineSendQueue: ((_?: unknown) => void)[];
+    options: MakeRequired<ShardOptions, 'properties' | 'ratelimitOptions'>;
     constructor(id: number, options: ShardOptions);
     get latency(): number;
     get isOpen(): boolean;
@@ -40,9 +38,12 @@ export declare class Shard {
     disconnect(): Promise<void>;
     reconnect(): Promise<void>;
     onpacket(packet: GatewayReceivePayload): Promise<void>;
-    protected handleClosed(close: CloseEvent): Promise<void>;
+    protected handleClosed(close: {
+        code: number;
+        reason: string;
+    }): Promise<void>;
     close(code: number, reason: string): Promise<void>;
-    protected handleMessage({ data }: WS.MessageEvent): Promise<void>;
+    protected handleMessage(data: string | Buffer): Promise<void> | undefined;
     checkOffline(force: boolean): Promise<unknown>;
     calculateSafeRequests(): number;
 }

package/lib/websocket/discord/shard.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Shard = void 0;
-const v10_1 = require("discord-api-types/v10");
 const node_zlib_1 = require("node:zlib");
-const ws_1 = require("ws");
+const common_1 = require("../../common");
 const constants_1 = require("../constants");
 const structures_1 = require("../structures");
 const timeout_1 = require("../structures/timeout");
 const basesocket_1 = require("./basesocket");
 const shared_1 = require("./shared");
+const types_1 = require("../../types");
 class Shard {
     id;
-    options;
+    logger;
     debugger;
     data = {
-        resumeSeq: null,
+        resume_seq: null,
     };
     websocket = null;
     connectTimeout = new timeout_1.ConnectTimeout();
@@ -24,13 +24,20 @@ class Shard {
     };
     bucket;
     offlineSendQueue = [];
+    options;
     constructor(id, options) {
         this.id = id;
-        this.options = options;
-        this.options.ratelimitOptions ??= {
-            rateLimitResetInterval: 60_000,
-            maxRequestsPerRateLimitTick: 120,
-        };
+        this.options = (0, common_1.MergeOptions)(options, {
+            properties: constants_1.properties,
+            ratelimitOptions: {
+                rateLimitResetInterval: 60_000,
+                maxRequestsPerRateLimitTick: 120,
+            },
+        });
+        this.logger = new common_1.Logger({
+            name: `[Shard #${id}]`,
+            logLevel: common_1.LogLevels.Info,
+        });
         if (options.debugger)
             this.debugger = options.debugger;
         const safe = this.calculateSafeRequests();
@@ -42,7 +49,7 @@ class Shard {
             : Number.POSITIVE_INFINITY;
     }
     get isOpen() {
-        return this.websocket?.readyState === ws_1.WebSocket.OPEN;
+        return this.websocket?.readyState === 1 /*WebSocket.open*/;
     }
     get gatewayURL() {
         return this.options.info.url;
@@ -58,27 +65,31 @@ class Shard {
     ping() {
         if (!this.websocket)
             return Promise.resolve(Number.POSITIVE_INFINITY);
+        //@ts-expect-error
         return this.websocket.ping();
     }
     async connect() {
         await this.connectTimeout.wait();
         if (this.isOpen) {
-            this.debugger?.debug(`[Shard #${this.id}] attempted to connect while open`);
+            this.debugger?.debug(`[Shard #${this.id}] Attempted to connect while open`);
             return;
         }
+        clearTimeout(this.heart.nodeInterval);
         this.debugger?.debug(`[Shard #${this.id}] Connecting to ${this.currentGatewayURL}`);
         // @ts-expect-error @types/bun cause erros in compile
         // biome-ignore lint/correctness/noUndeclaredVariables: /\ bun lol
         this.websocket = new basesocket_1.BaseSocket(typeof Bun === 'undefined' ? 'ws' : 'bun', this.currentGatewayURL);
-        this.websocket.onmessage = (event) => this.handleMessage(event);
+        this.websocket.onmessage = ({ data }) => {
+            this.handleMessage(data);
+        };
         this.websocket.onclose = (event) => this.handleClosed(event);
-        this.websocket.onerror = (event) => this.debugger?.error(event);
+        this.websocket.onerror = (event) => this.logger.error(event);
         this.websocket.onopen = () => {
             this.heart.ack = true;
         };
     }
     async send(force, message) {
-        this.debugger?.info(`[Shard #${this.id}] Sending: ${v10_1.GatewayOpcodes[message.op]} ${JSON.stringify(message.d, (_, value) => {
+        this.debugger?.info(`[Shard #${this.id}] Sending: ${types_1.GatewayOpcodes[message.op]} ${JSON.stringify(message.d, (_, value) => {
             if (typeof value === 'string')
                 return value.replaceAll(this.options.token, v => {
                     const split = v.split('.');
@@ -93,11 +104,11 @@ class Shard {
     }
     async identify() {
         await this.send(true, {
-            op: v10_1.GatewayOpcodes.Identify,
+            op: types_1.GatewayOpcodes.Identify,
             d: {
                 token: `Bot ${this.options.token}`,
                 compress: this.options.compress,
-                properties: this.options.properties ?? constants_1.properties,
+                properties: this.options.properties,
                 shard: [this.id, this.options.info.shards],
                 intents: this.options.intents,
                 presence: this.options.presence,
@@ -105,13 +116,13 @@ class Shard {
         });
     }
     get resumable() {
-        return !!(this.data.resume_gateway_url && this.data.session_id && this.data.resumeSeq !== null);
+        return !!(this.data.resume_gateway_url && this.data.session_id && this.data.resume_seq !== null);
     }
     async resume() {
         await this.send(true, {
-            op: v10_1.GatewayOpcodes.Resume,
+            op: types_1.GatewayOpcodes.Resume,
             d: {
-                seq: this.data.resumeSeq,
+                seq: this.data.resume_seq,
                 session_id: this.data.session_id,
                 token: `Bot ${this.options.token}`,
             },
@@ -128,8 +139,8 @@ class Shard {
         }
         this.heart.lastBeat = Date.now();
         this.websocket.send(JSON.stringify({
-            op: v10_1.GatewayOpcodes.Heartbeat,
-            d: this.data.resumeSeq ?? null,
+            op: types_1.GatewayOpcodes.Heartbeat,
+            d: this.data.resume_seq ?? null,
         }));
     }
     async disconnect() {
@@ -143,11 +154,11 @@ class Shard {
     }
     async onpacket(packet) {
         if (packet.s !== null) {
-            this.data.resumeSeq = packet.s;
+            this.data.resume_seq = packet.s;
         }
-        this.debugger?.debug(`[Shard #${this.id}]`, packet.t ? packet.t : v10_1.GatewayOpcodes[packet.op], this.data.resumeSeq);
+        this.debugger?.debug(`[Shard #${this.id}]`, packet.t ? packet.t : types_1.GatewayOpcodes[packet.op], this.data.resume_seq);
         switch (packet.op) {
-            case v10_1.GatewayOpcodes.Hello:
+            case types_1.GatewayOpcodes.Hello:
                 {
                     clearInterval(this.heart.nodeInterval);
                     this.heart.interval = packet.d.heartbeat_interval;
@@ -159,37 +170,37 @@ class Shard {
                     await this.identify();
                 }
                 break;
-            case v10_1.GatewayOpcodes.HeartbeatAck:
+            case types_1.GatewayOpcodes.HeartbeatAck:
                 this.heart.ack = true;
                 this.heart.lastAck = Date.now();
                 break;
-            case v10_1.GatewayOpcodes.Heartbeat:
+            case types_1.GatewayOpcodes.Heartbeat:
                 this.heartbeat(true);
                 break;
-            case v10_1.GatewayOpcodes.Reconnect:
+            case types_1.GatewayOpcodes.Reconnect:
                 await this.reconnect();
                 break;
-            case v10_1.GatewayOpcodes.InvalidSession:
+            case types_1.GatewayOpcodes.InvalidSession:
                 if (packet.d) {
                     if (!this.resumable) {
-                        return this.debugger?.fatal(`[Shard #${this.id}] This is a completely unexpected error message.`);
+                        return this.logger.fatal('This is a completely unexpected error message.');
                     }
                     await this.resume();
                 }
                 else {
-                    this.data.resumeSeq = 0;
+                    this.data.resume_seq = 0;
                     this.data.session_id = undefined;
                     await this.identify();
                 }
                 break;
-            case v10_1.GatewayOpcodes.Dispatch:
+            case types_1.GatewayOpcodes.Dispatch:
                 {
                     switch (packet.t) {
-                        case v10_1.GatewayDispatchEvents.Resumed:
+                        case types_1.GatewayDispatchEvents.Resumed:
                             this.offlineSendQueue.map((resolve) => resolve());
                             this.options.handlePayload(this.id, packet);
                             break;
-                        case v10_1.GatewayDispatchEvents.Ready: {
+                        case types_1.GatewayDispatchEvents.Ready: {
                             this.data.resume_gateway_url = packet.d.resume_gateway_url;
                             this.data.session_id = packet.d.session_id;
                             this.offlineSendQueue.map((resolve) => resolve());
@@ -206,51 +217,66 @@ class Shard {
     }
     async handleClosed(close) {
         clearInterval(this.heart.nodeInterval);
-        this.debugger?.warn(`[Shard #${this.id}] ${shared_1.ShardSocketCloseCodes[close.code] ?? v10_1.GatewayCloseCodes[close.code] ?? close.code} (${close.code})`);
+        this.logger.warn(`${shared_1.ShardSocketCloseCodes[close.code] ?? types_1.GatewayCloseCodes[close.code] ?? close.code} (${close.code})`, close.reason);
         switch (close.code) {
             case shared_1.ShardSocketCloseCodes.Shutdown:
+                //Force disconnect, ignore
                 break;
             case 1000:
+            case types_1.GatewayCloseCodes.UnknownOpcode:
+            case types_1.GatewayCloseCodes.InvalidSeq:
+            case types_1.GatewayCloseCodes.SessionTimedOut:
+                this.data.resume_seq = 0;
+                this.data.session_id = undefined;
+                this.data.resume_gateway_url = undefined;
+                await this.reconnect();
+                break;
             case 1001:
             case 1006:
             case shared_1.ShardSocketCloseCodes.ZombiedConnection:
-            case v10_1.GatewayCloseCodes.UnknownError:
-            case v10_1.GatewayCloseCodes.UnknownOpcode:
-            case v10_1.GatewayCloseCodes.DecodeError:
-            case v10_1.GatewayCloseCodes.NotAuthenticated:
-            case v10_1.GatewayCloseCodes.AlreadyAuthenticated:
-            case v10_1.GatewayCloseCodes.InvalidSeq:
-            case v10_1.GatewayCloseCodes.RateLimited:
-            case v10_1.GatewayCloseCodes.SessionTimedOut:
-                this.debugger?.info(`[Shard #${this.id}] Trying to reconnect`);
+            case types_1.GatewayCloseCodes.UnknownError:
+            case types_1.GatewayCloseCodes.DecodeError:
+            case types_1.GatewayCloseCodes.NotAuthenticated:
+            case types_1.GatewayCloseCodes.AlreadyAuthenticated:
+            case types_1.GatewayCloseCodes.RateLimited:
+                this.logger.info('Trying to reconnect');
                 await this.reconnect();
                 break;
-            case v10_1.GatewayCloseCodes.AuthenticationFailed:
-            case v10_1.GatewayCloseCodes.DisallowedIntents:
-            case v10_1.GatewayCloseCodes.InvalidAPIVersion:
-            case v10_1.GatewayCloseCodes.InvalidIntents:
-            case v10_1.GatewayCloseCodes.InvalidShard:
-            case v10_1.GatewayCloseCodes.ShardingRequired:
-                this.debugger?.fatal(`[Shard #${this.id}] cannot reconnect`);
+            case types_1.GatewayCloseCodes.AuthenticationFailed:
+            case types_1.GatewayCloseCodes.DisallowedIntents:
+            case types_1.GatewayCloseCodes.InvalidAPIVersion:
+            case types_1.GatewayCloseCodes.InvalidIntents:
+            case types_1.GatewayCloseCodes.InvalidShard:
+            case types_1.GatewayCloseCodes.ShardingRequired:
+                this.logger.fatal('Cannot reconnect');
                 break;
             default:
-                this.debugger?.warn(`[Shard #${this.id}] Unknown close code, trying to reconnect anyways`);
+                this.logger.warn('Unknown close code, trying to reconnect anyways');
                 await this.reconnect();
                 break;
         }
     }
     async close(code, reason) {
-        if (this.websocket?.readyState !== ws_1.WebSocket.OPEN) {
+        clearInterval(this.heart.nodeInterval);
+        if (!this.isOpen) {
             return this.debugger?.warn(`[Shard #${this.id}] Is not open`);
         }
-        this.debugger?.warn(`[Shard #${this.id}] Called close`);
+        this.debugger?.debug(`[Shard #${this.id}] Called close`);
         this.websocket?.close(code, reason);
     }
-    handleMessage({ data }) {
-        if (data instanceof Buffer) {
-            data = (0, node_zlib_1.inflateSync)(data);
+    handleMessage(data) {
+        let packet;
+        try {
+            if (data instanceof Buffer) {
+                data = (0, node_zlib_1.inflateSync)(data);
+            }
+            packet = JSON.parse(data);
+        }
+        catch (e) {
+            this.logger.error(e);
+            return;
         }
-        return this.onpacket(JSON.parse(data));
+        return this.onpacket(packet);
     }
     checkOffline(force) {
         if (!this.isOpen) {

package/lib/websocket/discord/sharder.d.ts

@@ -1,11 +1,12 @@
-import { type GatewaySendPayload, type GatewayUpdatePresence, type GatewayVoiceStateUpdate } from 'discord-api-types/v10';
-import { Logger, type ObjectToLower } from '../../common';
+import { Logger, type MakeRequired } from '../../common';
+import { type GatewayUpdatePresence, type GatewayVoiceStateUpdate, type GatewaySendPayload } from '../../types';
+import { ShardManagerDefaults } from '../constants';
 import { ConnectQueue } from '../structures/timeout';
-import { Shard } from './shard.js';
+import { Shard } from './shard';
 import type { ShardManagerOptions } from './shared';
 export declare class ShardManager extends Map<number, Shard> {
     connectQueue: ConnectQueue;
-    options: ShardManagerOptions;
+    options: MakeRequired<ShardManagerOptions, keyof typeof ShardManagerDefaults>;
     debugger?: Logger;
     constructor(options: ShardManagerOptions);
     get totalShards(): number;
@@ -23,7 +24,7 @@ export declare class ShardManager extends Map<number, Shard> {
     disconnectAll(): Promise<unknown>;
     setShardPresence(shardId: number, payload: GatewayUpdatePresence['d']): void;
     setPresence(payload: GatewayUpdatePresence['d']): Promise<void>;
-    joinVoice(guild_id: string, channel_id: string, options: ObjectToLower<Pick<GatewayVoiceStateUpdate['d'], 'self_deaf' | 'self_mute'>>): void;
+    joinVoice(guild_id: string, channel_id: string, options: Pick<GatewayVoiceStateUpdate['d'], 'self_deaf' | 'self_mute'>): void;
     leaveVoice(guild_id: string): void;
     send<T extends GatewaySendPayload>(shardId: number, payload: T): void;
 }