seyfert 2.1.1-dev-11767975974.0 → 2.1.1-dev-11842640994.0

package/lib/api/api.d.ts

@@ -19,6 +19,7 @@ export declare class ApiHandler {
     }>;
     onRatelimit?: OnRatelimitCallback;
     constructor(options: ApiHandlerOptions);
+    set debug(active: boolean);
     get proxy(): APIRoutes;
     globalUnblock(): void;
     request<T = unknown>(method: HttpMethods, url: `/${string}`, { auth, ...request }?: ApiRequestOptions): Promise<T>;

package/lib/api/api.js

@@ -20,16 +20,13 @@ class ApiHandler {
     constructor(options) {
         this.options = {
             baseUrl: 'api/v10',
-            domain: 'https://discord.com',
+            domain: common_1.BASE_HOST,
             type: 'Bot',
             ...options,
             userAgent: shared_1.DefaultUserAgent,
         };
-        if (options.debug) {
-            this.debugger = new common_1.Logger({
-                name: '[API]',
-            });
-        }
+        if (options.debug)
+            this.debug = true;
         const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
         if (options.workerProxy && !worker_threads?.parentPort)
             throw new Error('Cannot use workerProxy without a parent.');
@@ -41,6 +38,13 @@ class ApiHandler {
                 parentPort = worker_threads.parentPort;
         }
     }
+    set debug(active) {
+        this.debugger = active
+            ? new common_1.Logger({
+                name: '[API]',
+            })
+            : undefined;
+    }
     get proxy() {
         return (this._proxy_ ??= new Router_1.Router(this).createProxy());
     }

package/lib/cache/index.d.ts

@@ -34,7 +34,6 @@ export type DisabledCache = {
 export declare class Cache {
     intents: number;
     adapter: Adapter;
-    readonly disabledCache: DisabledCache;
     users?: Users;
     guilds?: Guilds;
     members?: Members;
@@ -49,7 +48,8 @@ export declare class Cache {
     messages?: Messages;
     bans?: Bans;
     __logger__?: Logger;
-    constructor(intents: number, adapter: Adapter, disabledCache?: DisabledCache, client?: UsingClient);
+    constructor(intents: number, adapter: Adapter, disabledCache: DisabledCache, client: UsingClient);
+    buildCache(disabledCache: DisabledCache, client: UsingClient): void;
     flush(): ReturnCache<void>;
     hasIntent(intent: keyof typeof GatewayIntentBits): boolean;
     get hasGuildsIntent(): boolean;
@@ -76,7 +76,6 @@ export declare class Cache {
         members: import("..").GuildMember[];
         users: import("..").User[];
         channels: NonNullable<ReturnCache<import("..").AllChannels | undefined>>[];
-        messages: import("..").Message[];
         voiceStates: import("..").VoiceState[];
         presences: (Omit<import("../types").GatewayPresenceUpdate, "user"> & {
             id: string;
@@ -94,6 +93,7 @@ export declare class Cache {
             allow: import("../structures/extra/Permissions").PermissionsBitField;
             guildId: string;
         }[][];
+        messages: import("..").Message[];
         bans: import("../structures/GuildBan").GuildBan[];
     }>>;
     bulkPatch(keys: (readonly [
@@ -117,6 +117,7 @@ export declare class Cache {
         string
     ])[]): Promise<void>;
     onPacket(event: GatewayDispatchPayload): Promise<void>;
+    protected onPacketDefault(event: GatewayDispatchPayload): Promise<void>;
     testAdapter(): Promise<void>;
     private testUsersAndMembers;
     private testChannelsAndOverwrites;

package/lib/cache/index.js

@@ -40,7 +40,6 @@ __exportStar(require("./adapters/index"), exports);
 class Cache {
     intents;
     adapter;
-    disabledCache;
     // non-guild based
     users;
     guilds;
@@ -58,74 +57,33 @@ class Cache {
     messages;
     bans;
     __logger__;
-    constructor(intents, adapter, disabledCache = {}, client) {
+    constructor(intents, adapter, disabledCache, client) {
         this.intents = intents;
         this.adapter = adapter;
-        this.disabledCache = disabledCache;
+        this.buildCache(disabledCache, client);
+    }
+    buildCache(disabledCache, client) {
         // non-guild based
-        if (!this.disabledCache.users) {
-            this.users = new users_1.Users(this, client);
-        }
-        if (!this.disabledCache.guilds) {
-            this.guilds = new guilds_1.Guilds(this, client);
-        }
+        this.users = disabledCache.users ? undefined : new users_1.Users(this, client);
+        this.guilds = disabledCache.guilds ? undefined : new guilds_1.Guilds(this, client);
         // guild related
-        if (!this.disabledCache.members) {
-            this.members = new members_1.Members(this, client);
-        }
-        if (!this.disabledCache.voiceStates) {
-            this.voiceStates = new voice_states_1.VoiceStates(this, client);
-        }
+        this.members = disabledCache.members ? undefined : new members_1.Members(this, client);
+        this.voiceStates = disabledCache.voiceStates ? undefined : new voice_states_1.VoiceStates(this, client);
         // guild based
-        if (!this.disabledCache.roles) {
-            this.roles = new roles_1.Roles(this, client);
-        }
-        if (!this.disabledCache.overwrites) {
-            this.overwrites = new overwrites_1.Overwrites(this, client);
-        }
-        if (!this.disabledCache.channels) {
-            this.channels = new channels_1.Channels(this, client);
-        }
-        if (!this.disabledCache.emojis) {
-            this.emojis = new emojis_1.Emojis(this, client);
-        }
-        if (!this.disabledCache.stickers) {
-            this.stickers = new stickers_1.Stickers(this, client);
-        }
-        if (!this.disabledCache.presences) {
-            this.presences = new presence_1.Presences(this, client);
-        }
-        if (!this.disabledCache.stageInstances) {
-            this.stageInstances = new stage_instances_1.StageInstances(this, client);
-        }
-        if (!this.disabledCache.messages) {
-            this.messages = new messages_1.Messages(this, client);
-        }
-        if (!this.disabledCache.bans) {
-            this.bans = new bans_1.Bans(this, client);
-        }
-        if (this.disabledCache.onPacket) {
-            //@ts-expect-error
-            this.onPacket = () => {
-                // disable cache
-            };
-        }
-    }
-    /** @internal */
-    __setClient(client) {
-        this.users?.__setClient(client);
-        this.guilds?.__setClient(client);
-        this.members?.__setClient(client);
-        this.voiceStates?.__setClient(client);
-        this.roles?.__setClient(client);
-        this.overwrites?.__setClient(client);
-        this.channels?.__setClient(client);
-        this.emojis?.__setClient(client);
-        this.stickers?.__setClient(client);
-        this.presences?.__setClient(client);
-        this.stageInstances?.__setClient(client);
-        this.messages?.__setClient(client);
-        this.bans?.__setClient(client);
+        this.roles = disabledCache.roles ? undefined : new roles_1.Roles(this, client);
+        this.overwrites = disabledCache.overwrites ? undefined : new overwrites_1.Overwrites(this, client);
+        this.channels = disabledCache.channels ? undefined : new channels_1.Channels(this, client);
+        this.emojis = disabledCache.emojis ? undefined : new emojis_1.Emojis(this, client);
+        this.stickers = disabledCache.stickers ? undefined : new stickers_1.Stickers(this, client);
+        this.presences = disabledCache.presences ? undefined : new presence_1.Presences(this, client);
+        this.stageInstances = disabledCache.stageInstances ? undefined : new stage_instances_1.StageInstances(this, client);
+        this.messages = disabledCache.messages ? undefined : new messages_1.Messages(this, client);
+        this.bans = disabledCache.bans ? undefined : new bans_1.Bans(this, client);
+        this.onPacket = disabledCache.onPacket
+            ? (() => {
+                //
+            })
+            : this.onPacketDefault.bind(this);
     }
     flush() {
         return this.adapter.flush();
@@ -353,7 +311,10 @@ class Cache {
         await this.adapter.bulkAddToRelationShip(relationshipsData);
         await this.adapter.bulkSet(allData);
     }
-    async onPacket(event) {
+    onPacket(event) {
+        return this.onPacketDefault(event);
+    }
+    async onPacketDefault(event) {
         switch (event.t) {
             case 'READY':
                 await this.users?.set(event.d.user.id, event.d.user);

package/lib/cache/resources/default/base.d.ts

@@ -3,9 +3,9 @@ import type { GatewayIntentBits } from '../../../types';
 import type { Cache, ReturnCache } from '../../index';
 export declare class BaseResource<T = any, S = any> {
     protected cache: Cache;
-    client: UsingClient;
+    readonly client: UsingClient;
     namespace: string;
-    constructor(cache: Cache, client?: UsingClient);
+    constructor(cache: Cache, client: UsingClient);
     filter(data: any, id: string): boolean;
     get adapter(): import("../../index").Adapter;
     removeIfNI(intent: keyof typeof GatewayIntentBits, id: string): import("../../../common").Awaitable<void>;

package/lib/cache/resources/default/base.js

@@ -8,12 +8,6 @@ class BaseResource {
     namespace = 'base';
     constructor(cache, client) {
         this.cache = cache;
-        if (client) {
-            this.client = client;
-        }
-    }
-    /** @internal */
-    __setClient(client) {
         this.client = client;
     }
     //@ts-expect-error

package/lib/cache/resources/default/guild-based.d.ts

@@ -3,9 +3,9 @@ import type { GatewayIntentBits } from '../../../types';
 import type { Cache, ReturnCache } from '../../index';
 export declare class GuildBasedResource<T = any, S = any> {
     protected cache: Cache;
-    client: UsingClient;
+    readonly client: UsingClient;
     namespace: string;
-    constructor(cache: Cache, client?: UsingClient);
+    constructor(cache: Cache, client: UsingClient);
     filter(data: any, id: string, guild_id: string): boolean;
     parse(data: any, id: string, guild_id: string): any;
     get adapter(): import("../../index").Adapter;

package/lib/cache/resources/default/guild-based.js

@@ -8,12 +8,6 @@ class GuildBasedResource {
     namespace = 'base';
     constructor(cache, client) {
         this.cache = cache;
-        if (client) {
-            this.client = client;
-        }
-    }
-    /** @internal */
-    __setClient(client) {
         this.client = client;
     }
     //@ts-expect-error

package/lib/cache/resources/default/guild-related.d.ts

@@ -3,9 +3,9 @@ import type { GatewayIntentBits } from '../../../types';
 import type { Cache, ReturnCache } from '../../index';
 export declare class GuildRelatedResource<T = any, S = any> {
     protected cache: Cache;
-    client: UsingClient;
+    readonly client: UsingClient;
     namespace: string;
-    constructor(cache: Cache, client?: UsingClient);
+    constructor(cache: Cache, client: UsingClient);
     filter(data: any, id: string, guild_id?: string): boolean;
     parse(data: any, id: string, guild_id: string): any;
     get adapter(): import("../../index").Adapter;

package/lib/cache/resources/default/guild-related.js

@@ -8,12 +8,6 @@ class GuildRelatedResource {
     namespace = 'base';
     constructor(cache, client) {
         this.cache = cache;
-        if (client) {
-            this.client = client;
-        }
-    }
-    /** @internal */
-    __setClient(client) {
         this.client = client;
     }
     //@ts-expect-error

package/lib/client/base.d.ts

@@ -1,5 +1,5 @@
 import { ApiHandler } from '../api';
-import type { Adapter } from '../cache';
+import type { Adapter, DisabledCache } from '../cache';
 import { Cache } from '../cache';
 import type { Command, CommandContext, ContextMenuCommand, ExtendedRC, ExtendedRCLocations, ExtraProps, MenuCommandContext, RegisteredMiddlewares, SubCommand, UsingClient } from '../commands';
 import { type InferWithPrefix, type MiddlewareContext } from '../commands/applications/shared';
@@ -155,7 +155,7 @@ export interface ServicesOptions {
     rest?: ApiHandler;
     cache?: {
         adapter?: Adapter;
-        disabledCache?: boolean | Cache['disabledCache'] | ((cacheType: keyof Cache['disabledCache']) => boolean);
+        disabledCache?: boolean | DisabledCache | ((cacheType: keyof DisabledCache) => boolean);
     };
     langs?: {
         default?: string;

package/lib/client/base.js

@@ -14,8 +14,8 @@ const voiceStates_1 = require("../common/shorters/voiceStates");
 const handler_2 = require("../components/handler");
 const handler_3 = require("../langs/handler");
 class BaseClient {
-    rest;
-    cache;
+    rest = new api_1.ApiHandler({ token: 'INVALID' });
+    cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), {}, this);
     applications = new common_1.ApplicationShorter(this);
     users = new common_1.UsersShorter(this);
     channels = new common_1.ChannelShorter(this);
@@ -122,6 +122,7 @@ class BaseClient {
     }
     setServices({ rest, cache, langs, middlewares, handleCommand }) {
         if (rest) {
+            rest.onRatelimit ??= this.rest.onRatelimit?.bind(rest);
             this.rest = rest;
         }
         if (cache) {
@@ -141,7 +142,7 @@ class BaseClient {
                 'users',
                 'voiceStates',
             ];
-            let disabledCache = this.cache?.disabledCache ?? {};
+            let disabledCache = {};
             if (typeof cache.disabledCache === 'boolean') {
                 for (const i of caches) {
                     disabledCache[i] = cache.disabledCache;
@@ -155,7 +156,10 @@ class BaseClient {
             else if (typeof cache.disabledCache === 'object') {
                 disabledCache = cache.disabledCache;
             }
-            this.cache = new cache_1.Cache(this.cache?.intents ?? 0, cache?.adapter ?? this.cache?.adapter ?? new cache_1.MemoryAdapter(), disabledCache, this);
+            if (cache.adapter)
+                this.cache.adapter = cache.adapter;
+            if (cache.disabledCache)
+                this.cache.buildCache(disabledCache, this);
         }
         if (middlewares) {
             this.middlewares = middlewares;
@@ -190,21 +194,10 @@ class BaseClient {
         await this.loadComponents(options.componentsDir);
         const { token: tokenRC, debug } = await this.getRC();
         const token = options?.token ?? tokenRC;
-        if (!this.rest) {
-            BaseClient.assertString(token, 'token is not a string');
-            this.rest = new api_1.ApiHandler({
-                token,
-                baseUrl: 'api/v10',
-                domain: 'https://discord.com',
-                debug,
-            });
-        }
-        if (this.cache) {
-            this.cache.__setClient(this);
-        }
-        else {
-            this.cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), {}, this);
-        }
+        BaseClient.assertString(token, 'token is not a string');
+        if (this.rest.options.token === 'INVALID')
+            this.rest.options.token = token;
+        this.rest.debug = debug;
         if (!this.handleCommand)
             this.handleCommand = new handle_1.HandleCommand(this);
         // The reason of this method is so for adapters that need to connect somewhere, have time to connect.
@@ -223,7 +216,6 @@ class BaseClient {
         });
     }
     syncCachePath(cachePath) {
-        this.logger.debug('Syncing commands cache');
         return node_fs_1.promises.writeFile(cachePath, JSON.stringify(this.commands.values.filter(cmd => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash).map(x => x.toJSON())));
     }
     async uploadCommands({ applicationId, cachePath } = {}) {

package/lib/client/client.js

@@ -68,6 +68,7 @@ class Client extends base_1.BaseClient {
         const { token: tokenRC, intents: intentsRC, debug: debugRC } = await this.getRC();
         const token = options?.token ?? tokenRC;
         const intents = options?.connection?.intents ?? intentsRC;
+        this.cache.intents = intents;
         if (!this.gateway) {
             base_1.BaseClient.assertString(token, 'token is not a string');
             this.gateway = new websocket_1.ShardManager({
@@ -95,7 +96,6 @@ class Client extends base_1.BaseClient {
                 },
             });
         }
-        this.cache.intents = this.gateway.options.intents;
         if (execute) {
             await this.execute(options.connection);
         }
@@ -109,7 +109,6 @@ class Client extends base_1.BaseClient {
             this.collectors.run('RAW', packet, this),
         ]); //ignore promise
         switch (packet.t) {
-            // Cases where we must obtain the old data before updating
             case 'GUILD_MEMBER_UPDATE':
                 {
                     if (!this.memberUpdateHandler.check(packet.d)) {

package/lib/client/workerclient.d.ts

@@ -1,14 +1,15 @@
-import { type DeepPartial, type When } from '../common';
+import { type DeepPartial, type MakeRequired, type When } from '../common';
 import { EventHandler } from '../events';
 import type { GatewayDispatchPayload } from '../types';
 import { Shard, type ShardManagerOptions, type WorkerData } from '../websocket';
 import type { WorkerMessage, WorkerShardInfo } from '../websocket/discord/worker';
-import type { ManagerMessages } from '../websocket/discord/workermanager';
+import type { ManagerMessages, ManagerSpawnShards } from '../websocket/discord/workermanager';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 import type { Client, ClientOptions } from './client';
 import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
 import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
+import type { ShardData } from '../websocket/discord/shared';
 import { Collectors } from './collectors';
 import { type ClientUserStructure } from './transformers';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
@@ -40,8 +41,10 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
     handleManagerMessages(data: ManagerMessages): Promise<any>;
     private generateNonce;
     private generateSendPromise;
-    tellWorker<R>(workerId: number, func: (_: this) => R): Promise<R>;
-    tellWorkers<R>(func: (_: this) => R): Promise<Awaited<R>[]>;
+    tellWorker<R, V extends Record<string, unknown>>(workerId: number, func: (_: this, vars: V) => R, vars: V): Promise<R>;
+    tellWorkers<R, V extends Record<string, unknown>>(func: (_: this, vars: V) => R, vars: V): Promise<Awaited<R>[]>;
+    createShard(id: number, data: Pick<ManagerSpawnShards, 'info' | 'compress'>): Shard;
+    resumeShard(shardId: number, shardData: MakeRequired<ShardData>): Promise<unknown>;
     protected onPacket(packet: GatewayDispatchPayload, shardId: number): Promise<void>;
 }
 export declare function generateShardInfo(shard: Shard): WorkerShardInfo;

package/lib/client/workerclient.js

@@ -20,7 +20,7 @@ try {
         debug: process.env.SEYFERT_WORKER_DEBUG === 'true',
         intents: Number(process.env.SEYFERT_WORKER_INTENTS),
         path: process.env.SEYFERT_WORKER_PATH,
-        shards: process.env.SEYFERT_WORKER_SHARDS.split(',').map(id => Number(id)),
+        shards: JSON.parse(process.env.SEYFERT_WORKER_SHARDS),
         token: process.env.SEYFERT_WORKER_TOKEN,
         workerId: Number(process.env.SEYFERT_WORKER_WORKERID),
         workerProxy: process.env.SEYFERT_WORKER_WORKERPROXY === 'true',
@@ -28,6 +28,8 @@ try {
         mode: process.env.SEYFERT_WORKER_MODE,
         resharding: process.env.SEYFERT_WORKER_RESHARDING === 'true',
         totalWorkers: Number(process.env.SEYFERT_WORKER_TOTALWORKERS),
+        info: JSON.parse(process.env.SEYFERT_WORKER_INFO),
+        compress: process.env.SEYFERT_WORKER_COMPRESS === 'true',
     };
 }
 catch {
@@ -62,7 +64,7 @@ class WorkerClient extends base_1.BaseClient {
     }
     setServices(rest) {
         super.setServices(rest);
-        if (rest.cache) {
+        if (rest.cache?.adapter) {
             this.__setServicesCache = true;
         }
     }
@@ -82,13 +84,8 @@ class WorkerClient extends base_1.BaseClient {
         this.logger = new __1.Logger({
             name: `[Worker #${workerData.workerId}]`,
         });
-        if (this.__setServicesCache) {
-            this.setServices({
-                cache: {
-                    disabledCache: this.cache.disabledCache,
-                },
-            });
-        }
+        if (this.__setServicesCache)
+            delete this.__setServicesCache;
         else {
             const adapter = new cache_1.WorkerAdapter(workerData);
             if (this.options.postMessage) {
@@ -97,11 +94,9 @@ class WorkerClient extends base_1.BaseClient {
             this.setServices({
                 cache: {
                     adapter,
-                    disabledCache: this.cache.disabledCache,
                 },
             });
         }
-        delete this.__setServicesCache;
         if (workerData.debug) {
             this.debugger = new __1.Logger({
                 name: `[Worker #${workerData.workerId}]`,
@@ -117,6 +112,7 @@ class WorkerClient extends base_1.BaseClient {
                 }),
             });
         }
+        this.cache.intents = workerData.intents;
         this.postMessage({
             type: workerData.resharding ? 'WORKER_START_RESHARDING' : 'WORKER_START',
             workerId: workerData.workerId,
@@ -126,7 +122,6 @@ class WorkerClient extends base_1.BaseClient {
         }
         await super.start(options);
         await this.loadEvents(options.eventsDir);
-        this.cache.intents = workerData.intents;
     }
     async loadEvents(dir) {
         dir ??= await this.getRC().then(x => ('events' in x.locations ? x.locations.events : undefined));
@@ -250,37 +245,13 @@ class WorkerClient extends base_1.BaseClient {
                 break;
             case 'SPAWN_SHARDS':
                 {
-                    const onPacket = this.onPacket.bind(this);
-                    const handlePayload = this.options?.handlePayload?.bind(this);
-                    const self = this;
                     for (const id of workerData.shards) {
                         const existsShard = this.shards.has(id);
                         if (existsShard) {
                             this.logger.warn(`Trying to spawn existing shard #${id}`);
                             continue;
                         }
-                        const shard = new websocket_1.Shard(id, {
-                            token: workerData.token,
-                            intents: workerData.intents,
-                            info: data.info,
-                            compress: data.compress,
-                            debugger: this.debugger,
-                            properties: {
-                                ...websocket_1.properties,
-                                ...this.options.gateway?.properties,
-                            },
-                            async handlePayload(shardId, payload) {
-                                await handlePayload?.(shardId, payload);
-                                await onPacket(payload, shardId);
-                                if (self.options.sendPayloadToParent)
-                                    self.postMessage({
-                                        workerId: workerData.workerId,
-                                        shardId,
-                                        type: 'RECEIVE_PAYLOAD',
-                                        payload,
-                                    });
-                            },
-                        });
+                        const shard = this.createShard(id, data);
                         this.shards.set(id, shard);
                         this.postMessage({
                             type: 'CONNECT_QUEUE',
@@ -335,7 +306,7 @@ class WorkerClient extends base_1.BaseClient {
                     let result;
                     try {
                         result = await eval(`
-					(${data.func})(this)
+					(${data.func})(this, ${data.vars})
 					`);
                     }
                     catch (e) {
@@ -410,7 +381,7 @@ class WorkerClient extends base_1.BaseClient {
             this.promises.set(nonce, { resolve: res, timeout });
         });
     }
-    tellWorker(workerId, func) {
+    tellWorker(workerId, func, vars) {
         const nonce = this.generateNonce();
         this.postMessage({
             type: 'EVAL_TO_WORKER',
@@ -418,23 +389,67 @@ class WorkerClient extends base_1.BaseClient {
             toWorkerId: workerId,
             workerId: workerData.workerId,
             nonce,
+            vars: JSON.stringify(vars),
         });
         return this.generateSendPromise(nonce);
     }
-    tellWorkers(func) {
+    tellWorkers(func, vars) {
         const promises = [];
         for (let i = 0; i < workerData.totalWorkers; i++) {
-            promises.push(this.tellWorker(i, func));
+            promises.push(this.tellWorker(i, func, vars));
         }
         return Promise.all(promises);
     }
+    createShard(id, data) {
+        const onPacket = this.onPacket.bind(this);
+        const handlePayload = this.options?.handlePayload?.bind(this);
+        const self = this;
+        const shard = new websocket_1.Shard(id, {
+            token: workerData.token,
+            intents: workerData.intents,
+            info: data.info,
+            compress: data.compress,
+            debugger: this.debugger,
+            properties: {
+                ...websocket_1.properties,
+                ...this.options.gateway?.properties,
+            },
+            async handlePayload(shardId, payload) {
+                await handlePayload?.(shardId, payload);
+                await onPacket(payload, shardId);
+                if (self.options.sendPayloadToParent)
+                    self.postMessage({
+                        workerId: workerData.workerId,
+                        shardId,
+                        type: 'RECEIVE_PAYLOAD',
+                        payload,
+                    });
+            },
+        });
+        return shard;
+    }
+    async resumeShard(shardId, shardData) {
+        const exists = (await this.tellWorkers((r, vars) => r.shards.has(vars.shardId), { shardId })).some(x => x);
+        if (exists)
+            throw new Error('Cannot override existing shard');
+        const shard = this.createShard(shardId, {
+            info: this.workerData.info,
+            compress: this.workerData.compress,
+        });
+        shard.data = shardData;
+        this.shards.set(shardId, shard);
+        return this.postMessage({
+            workerId: this.workerId,
+            shardId,
+            type: 'CONNECT_QUEUE',
+        });
+    }
     async onPacket(packet, shardId) {
         Promise.allSettled([
             this.events?.runEvent('RAW', this, packet, shardId, false),
             this.collectors.run('RAW', packet, this),
         ]); //ignore promise
         switch (packet.t) {
-            //// Cases where we must obtain the old data before updating
             case 'GUILD_MEMBER_UPDATE':
                 {
                     if (!this.memberUpdateHandler.check(packet.d)) {

package/lib/commands/applications/menu.d.ts

@@ -39,8 +39,8 @@ export declare abstract class ContextMenuCommand {
     reload(): Promise<void>;
     abstract run?(context: MenuCommandContext<any>): any;
     onAfterRun?(context: MenuCommandContext<any>, error: unknown | undefined): any;
-    onRunError(context: MenuCommandContext<any, never>, error: unknown): any;
-    onMiddlewaresError(context: MenuCommandContext<any, never>, error: string): any;
-    onBotPermissionsFail(context: MenuCommandContext<any, never>, permissions: PermissionStrings): any;
-    onInternalError(client: UsingClient, command: ContextMenuCommand, error?: unknown): any;
+    onRunError?(context: MenuCommandContext<any, never>, error: unknown): any;
+    onMiddlewaresError?(context: MenuCommandContext<any, never>, error: string): any;
+    onBotPermissionsFail?(context: MenuCommandContext<any, never>, permissions: PermissionStrings): any;
+    onInternalError?(client: UsingClient, command: ContextMenuCommand, error?: unknown): any;
 }

package/lib/commands/applications/menu.js

@@ -39,17 +39,5 @@ class ContextMenuCommand {
         const __tempCommand = await (0, common_1.magicImport)(this.__filePath).then(x => x.default ?? x);
         Object.setPrototypeOf(this, __tempCommand.prototype);
     }
-    onRunError(context, error) {
-        context.client.logger.fatal(`${this.name}.<onRunError>`, context.author.id, error);
-    }
-    onMiddlewaresError(context, error) {
-        context.client.logger.fatal(`${this.name}.<onMiddlewaresError>`, context.author.id, error);
-    }
-    onBotPermissionsFail(context, permissions) {
-        context.client.logger.fatal(`${this.name}.<onBotPermissionsFail>`, context.author.id, permissions);
-    }
-    onInternalError(client, command, error) {
-        client.logger.fatal(command.name, error);
-    }
 }
 exports.ContextMenuCommand = ContextMenuCommand;

package/lib/commands/handle.js

@@ -40,7 +40,7 @@ class HandleCommand {
         if (context.guildId && command.botPermissions) {
             const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
             if (permissions)
-                return command.onBotPermissionsFail(context, permissions);
+                return command.onBotPermissionsFail?.(context, permissions);
         }
         const resultGlobal = await this.runGlobalMiddlewares(command, context);
         if (typeof resultGlobal === 'boolean')
@@ -54,13 +54,13 @@ class HandleCommand {
                 await command.onAfterRun?.(context, undefined);
             }
             catch (error) {
-                await command.onRunError(context, error);
+                await command.onRunError?.(context, error);
                 await command.onAfterRun?.(context, error);
             }
         }
         catch (error) {
             try {
-                await command.onInternalError(this.client, command, error);
+                await command.onInternalError?.(this.client, command, error);
             }
             catch {
                 // pass

package/lib/commands/handler.js

@@ -448,15 +448,9 @@ class CommandHandler extends common_1.BaseHandler {
         if (!(commandInstance instanceof menu_1.ContextMenuCommand))
             return false;
         commandInstance.onAfterRun ??= this.client.options.commands?.defaults?.onAfterRun;
-        //@ts-expect-error magic.
         commandInstance.onBotPermissionsFail ??= this.client.options.commands?.defaults?.onBotPermissionsFail;
-        //@ts-expect-error magic.
         commandInstance.onInternalError ??= this.client.options.commands?.defaults?.onInternalError;
-        //@ts-expect-error magic.
         commandInstance.onMiddlewaresError ??= this.client.options.commands?.defaults?.onMiddlewaresError;
-        //@ts-expect-error magic.
-        commandInstance.onPermissionsFail ??= this.client.options.commands?.defaults?.onPermissionsFail;
-        //@ts-expect-error magic.
         commandInstance.onRunError ??= this.client.options.commands?.defaults?.onRunError;
         return commandInstance;
     }

package/lib/components/modalcontext.d.ts

@@ -3,6 +3,7 @@ import type { GuildMemberStructure, GuildStructure } from '../client/transformer
 import type { CommandMetadata, ExtendContext, GlobalMetadata, RegisteredMiddlewares, UsingClient } from '../commands';
 import { BaseContext } from '../commands/basecontext';
 import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, MakeRequired, ModalCreateBodyRequest, UnionToTuple } from '../common';
+import type { Interaction } from '../structures/Interaction';
 export interface ModalContext extends BaseContext, ExtendContext {
 }
 /**
@@ -67,7 +68,7 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
      * @returns A promise that resolves when the response is deleted.
      */
     deleteResponse(): Promise<void | undefined>;
-    modal(body: ModalCreateBodyRequest): any;
+    modal(body: ModalCreateBodyRequest): ReturnType<Interaction['modal']>;
     /**
      * Gets the channel of the interaction.
      * @param mode - The mode to fetch the channel.

package/lib/events/handler.js

@@ -192,20 +192,20 @@ class EventHandler extends common_1.BaseHandler {
     async runCustom(name, ...args) {
         const Event = this.values[name];
         if (!Event) {
-            // @ts-expect-error working with non-existent types is hard
+            // @ts-expect-error
             return this.client.collectors.run(name, args, this.client);
         }
         try {
             if (Event.data.once && Event.fired) {
-                // @ts-expect-error working with non-existent types is hard
+                // @ts-expect-error
                 return this.client.collectors.run(name, args, this.client);
             }
             Event.fired = true;
             this.logger.debug(`executed a custom event [${name}]`, Event.data.once ? 'once' : '');
             await Promise.all([
-                // @ts-expect-error working with non-existent types is hard
+                // @ts-expect-error
                 Event.run(...args, this.client),
-                // @ts-expect-error working with non-existent types is hard
+                // @ts-expect-error
                 this.client.collectors.run(name, args, this.client),
             ]);
         }

package/lib/websocket/discord/shard.js

@@ -75,8 +75,8 @@ class Shard {
         }
         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
+        // @ts-expect-error Use native websocket when using Bun
+        // biome-ignore lint/correctness/noUndeclaredVariables: /\
         this.websocket = new basesocket_1.BaseSocket(typeof Bun === 'undefined' ? 'ws' : 'bun', this.currentGatewayURL);
         this.websocket.onmessage = ({ data }) => {
             this.handleMessage(data);

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

@@ -117,6 +117,8 @@ export interface WorkerData {
     workerId: number;
     debug: boolean;
     workerProxy: boolean;
+    info: APIGatewayBotInfo;
+    compress: boolean;
     __USING_WATCHER__?: boolean;
     resharding: boolean;
 }

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

@@ -57,6 +57,7 @@ export type WorkerSendEvalResponse = CreateWorkerMessage<'EVAL_RESPONSE', {
 export type WorkerSendToWorkerEval = CreateWorkerMessage<'EVAL_TO_WORKER', {
     func: string;
     nonce: string;
+    vars: string;
     toWorkerId: number;
 }>;
 export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerShardsConnected | WorkerSendApiRequest | WorkerSendEvalResponse | WorkerSendToWorkerEval | WorkerStart | WorkerStartResharding | WorkerRequestConnectResharding | WorkerReadyResharding | WorkerDisconnectedAllShardsResharding;

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

@@ -68,8 +68,8 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerTh
     send(data: GatewaySendPayload, shardId: number): Promise<true>;
     getShardInfo(shardId: number): Promise<WorkerShardInfo>;
     getWorkerInfo(workerId: number): Promise<WorkerInfo>;
-    tellWorker<R>(workerId: number, func: (_: WorkerClient & UsingClient) => R): Promise<R>;
-    tellWorkers<R>(func: (_: WorkerClient & UsingClient) => R): Promise<Awaited<R>[]>;
+    tellWorker<R, V extends Record<string, unknown>>(workerId: number, func: (_: WorkerClient & UsingClient, vars: V) => R, vars: V): Promise<R>;
+    tellWorkers<R, V extends Record<string, unknown>>(func: (_: WorkerClient & UsingClient, vars: V) => R, vars: V): Promise<Awaited<R>[]>;
     start(): Promise<void>;
     startResharding(): Promise<void>;
 }
@@ -113,10 +113,12 @@ export type ManagerSendApiResponse = CreateManagerMessage<'API_RESPONSE', {
 export type ManagerExecuteEvalToWorker = CreateManagerMessage<'EXECUTE_EVAL_TO_WORKER', {
     func: string;
     nonce: string;
+    vars: string;
     toWorkerId: number;
 }>;
 export type ManagerExecuteEval = CreateManagerMessage<'EXECUTE_EVAL', {
     func: string;
+    vars: string;
     nonce: string;
 }>;
 export type ManagerSendEvalResponse = CreateManagerMessage<'EVAL_RESPONSE', {

package/lib/websocket/discord/workermanager.js

@@ -124,6 +124,11 @@ class WorkerManager extends Map {
                         mode: this.options.mode,
                         resharding,
                         totalWorkers: shards.length,
+                        info: {
+                            ...this.options.info,
+                            shards: this.totalShards,
+                        },
+                        compress: this.options.compress,
                     });
                     this.set(i, worker);
                 });
@@ -149,7 +154,8 @@ class WorkerManager extends Map {
         if (workerData.resharding)
             env.SEYFERT_WORKER_RESHARDING = 'true';
         for (const i in workerData) {
-            env[`SEYFERT_WORKER_${i.toUpperCase()}`] = workerData[i];
+            const data = workerData[i];
+            env[`SEYFERT_WORKER_${i.toUpperCase()}`] = typeof data === 'object' && data ? JSON.stringify(data) : data;
         }
         switch (this.options.mode) {
             case 'threads': {
@@ -381,6 +387,7 @@ class WorkerManager extends Map {
                         func: message.func,
                         type: 'EXECUTE_EVAL_TO_WORKER',
                         toWorkerId: message.toWorkerId,
+                        vars: message.vars,
                     });
                     this.generateSendPromise(nonce, 'Eval timeout').then(val => this.postMessage(message.workerId, {
                         nonce: message.nonce,
@@ -440,19 +447,20 @@ class WorkerManager extends Map {
         this.postMessage(workerId, { nonce, type: 'WORKER_INFO' });
         return this.generateSendPromise(nonce, 'Get worker info timeout');
     }
-    tellWorker(workerId, func) {
+    tellWorker(workerId, func, vars) {
         const nonce = this.generateNonce();
         this.postMessage(workerId, {
             type: 'EXECUTE_EVAL',
             func: func.toString(),
             nonce,
+            vars: JSON.stringify(vars),
         });
         return this.generateSendPromise(nonce);
     }
-    tellWorkers(func) {
+    tellWorkers(func, vars) {
         const promises = [];
         for (const i of this.keys()) {
-            promises.push(this.tellWorker(i, func));
+            promises.push(this.tellWorker(i, func, vars));
         }
         return Promise.all(promises);
     }
@@ -464,7 +472,7 @@ class WorkerManager extends Map {
         this.rest ??= new __1.ApiHandler({
             token: this.options.token,
             baseUrl: 'api/v10',
-            domain: 'https://discord.com',
+            domain: common_1.BASE_HOST,
             debug: this.options.debug,
         });
         this.options.info ??= await this.rest.proxy.gateway.bot.get();
@@ -487,7 +495,7 @@ class WorkerManager extends Map {
             shardEnd: this.shardEnd,
             shardsPerWorker: this.shardsPerWorker,
         }, this.debugger);
-        await this.prepareWorkers(spaces);
+        this.prepareWorkers(spaces);
         // Start workers queue
         this.workerQueue.shift()();
         await this.startResharding();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "seyfert",
-	"version": "2.1.1-dev-11767975974.0",
+	"version": "2.1.1-dev-11842640994.0",
 	"description": "The most advanced framework for discord bots",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",