seyfert 0.1.0 → 1.0.1

package/lib/structures/channels.d.ts

@@ -1,6 +1,8 @@
 import { ChannelType, VideoQualityMode, type APIDMChannel, type APIGuildCategoryChannel, type APIGuildForumChannel, type APIGuildMediaChannel, type APIGuildStageVoiceChannel, type APIGuildVoiceChannel, type APINewsChannel, type APITextChannel, type APIThreadChannel, type ThreadAutoArchiveDuration } from 'discord-api-types/v10';
 import type { BaseClient } from '../client/base';
 import type { APIChannelBase, APIGuildChannel, APIGuildForumDefaultReactionEmoji, APIGuildForumTag, EmojiResolvable, MessageCreateBodyRequest, MessageUpdateBodyRequest, MethodContext, ObjectToLower, RESTGetAPIChannelMessageReactionUsersQuery, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildChannelPositionsJSONBody, RESTPostAPIChannelWebhookJSONBody, RESTPostAPIGuildChannelJSONBody, SortOrderType, StringToNumber, ToClass } from '../common';
+import type { GuildMember } from './GuildMember';
+import type { GuildRole } from './GuildRole';
 import { Webhook } from './Webhook';
 import { DiscordBase } from './extra/DiscordBase';
 export declare class BaseChannel<T extends ChannelType> extends DiscordBase<APIChannelBase<ChannelType>> {
@@ -53,9 +55,46 @@ interface IChannelTypes {
     GuildCategory: CategoryChannel;
     GuildAnnouncement: NewsChannel;
 }
-export interface BaseGuildChannel extends ObjectToLower<APIGuildChannel<ChannelType>> {
+export interface BaseGuildChannel extends ObjectToLower<Omit<APIGuildChannel<ChannelType>, 'permission_overwrites'>> {
 }
 export declare class BaseGuildChannel extends BaseChannel<ChannelType> {
+    constructor(client: BaseClient, data: APIGuildChannel<ChannelType>);
+    permissionOverwrites: {
+        fetch: () => import("..").ReturnCache<{
+            type: number;
+            id: string;
+            deny: import("./extra/Permissions").PermissionsBitField;
+            allow: import("./extra/Permissions").PermissionsBitField;
+        }[] | undefined>;
+        values: () => {
+            type: number;
+            id: string;
+            deny: import("./extra/Permissions").PermissionsBitField;
+            allow: import("./extra/Permissions").PermissionsBitField;
+        }[][];
+    };
+    memberPermissions(member: GuildMember, checkAdmin?: boolean): Promise<import("./extra/Permissions").PermissionsBitField>;
+    rolePermissions(role: GuildRole, checkAdmin?: boolean): Promise<import("./extra/Permissions").PermissionsBitField>;
+    overwritesFor(member: GuildMember): Promise<{
+        everyone: {
+            type: number;
+            id: string;
+            deny: import("./extra/Permissions").PermissionsBitField;
+            allow: import("./extra/Permissions").PermissionsBitField;
+        } | undefined;
+        roles: {
+            type: number;
+            id: string;
+            deny: import("./extra/Permissions").PermissionsBitField;
+            allow: import("./extra/Permissions").PermissionsBitField;
+        }[];
+        member: {
+            type: number;
+            id: string;
+            deny: import("./extra/Permissions").PermissionsBitField;
+            allow: import("./extra/Permissions").PermissionsBitField;
+        } | undefined;
+    }>;
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
     get url(): string;
     setPosition(position: number, reason?: string): Promise<AllChannels>;
@@ -112,7 +151,7 @@ export declare class MessagesMethods extends DiscordBase {
     };
     static transformMessageBody<T>(body: MessageCreateBodyRequest | MessageUpdateBodyRequest): T;
 }
-export interface TextBaseGuildChannel extends ObjectToLower<Omit<APITextChannel, 'type'>>, MessagesMethods {
+export interface TextBaseGuildChannel extends ObjectToLower<Omit<APITextChannel, 'type' | 'permission_overwrites'>>, MessagesMethods {
 }
 export declare class TextBaseGuildChannel extends BaseGuildChannel {
 }
@@ -161,7 +200,7 @@ export declare class WebhookChannelMethods extends DiscordBase {
         create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<Webhook>;
     };
 }
-export interface TextGuildChannel extends ObjectToLower<Omit<APITextChannel, 'type'>>, BaseGuildChannel, TextBaseGuildChannel, WebhookChannelMethods {
+export interface TextGuildChannel extends ObjectToLower<Omit<APITextChannel, 'type' | 'permission_overwrites'>>, BaseGuildChannel, TextBaseGuildChannel, WebhookChannelMethods {
 }
 export declare class TextGuildChannel extends BaseGuildChannel {
     type: ChannelType.GuildText;
@@ -174,7 +213,7 @@ declare const DMChannel_base: ToClass<Omit<BaseChannel<ChannelType.DM>, "edit">,
 export declare class DMChannel extends DMChannel_base {
     type: ChannelType.DM;
 }
-export interface VoiceChannel extends ObjectToLower<APIGuildVoiceChannel>, Omit<TextGuildChannel, 'type'>, VoiceChannelMethods, WebhookChannelMethods {
+export interface VoiceChannel extends ObjectToLower<Omit<APIGuildVoiceChannel, 'permission_overwrites'>>, Omit<TextGuildChannel, 'type'>, VoiceChannelMethods, WebhookChannelMethods {
 }
 export declare class VoiceChannel extends BaseChannel<ChannelType.GuildVoice> {
     type: ChannelType.GuildVoice;
@@ -194,7 +233,7 @@ export interface ForumChannel extends ObjectToLower<APIGuildForumChannel>, Omit<
 export declare class ForumChannel extends BaseChannel<ChannelType.GuildForum> {
     type: ChannelType.GuildForum;
 }
-export interface ThreadChannel extends ObjectToLower<APIThreadChannel>, TextBaseGuildChannel {
+export interface ThreadChannel extends ObjectToLower<Omit<APIThreadChannel, 'permission_overwrites'>>, TextBaseGuildChannel {
 }
 export declare class ThreadChannel extends BaseChannel<ChannelType.PublicThread | ChannelType.AnnouncementThread | ChannelType.PrivateThread> {
     type: ChannelType.PublicThread | ChannelType.AnnouncementThread | ChannelType.PrivateThread;
@@ -211,7 +250,7 @@ export declare class ThreadChannel extends BaseChannel<ChannelType.PublicThread
     setInvitable(invitable?: boolean, reason?: string): Promise<AllChannels>;
     setLocked(locked?: boolean, reason?: string): Promise<AllChannels>;
 }
-export interface CategoryChannel extends ObjectToLower<APIGuildCategoryChannel> {
+export interface CategoryChannel extends ObjectToLower<Omit<APIGuildCategoryChannel, 'permission_overwrites'>> {
 }
 declare const CategoryChannel_base: ToClass<Omit<BaseGuildChannel, "type" | "setParent">, CategoryChannel>;
 export declare class CategoryChannel extends CategoryChannel_base {

package/lib/structures/channels.js

@@ -10,7 +10,6 @@ exports.DirectoryChannel = exports.NewsChannel = exports.CategoryChannel = expor
 const v10_1 = require("discord-api-types/v10");
 const ts_mixer_1 = require("ts-mixer");
 const builders_1 = require("../builders");
-const components_1 = require("../components");
 const Webhook_1 = require("./Webhook");
 const DiscordBase_1 = require("./extra/DiscordBase");
 const functions_1 = require("./extra/functions");
@@ -32,7 +31,10 @@ class BaseChannel extends DiscordBase_1.DiscordBase {
         return this.client.channels.delete(this.id, { reason });
     }
     edit(body, reason) {
-        return this.client.channels.edit(this.id, body, { reason });
+        return this.client.channels.edit(this.id, body, {
+            reason,
+            guildId: 'guildId' in this ? this.guildId : '@me',
+        });
     }
     toString() {
         return `<#${this.id}>`;
@@ -92,7 +94,24 @@ class BaseChannel extends DiscordBase_1.DiscordBase {
 }
 exports.BaseChannel = BaseChannel;
 class BaseGuildChannel extends BaseChannel {
-    async guild(force = false) {
+    constructor(client, data) {
+        const { permission_overwrites, ...rest } = data;
+        super(client, rest);
+    }
+    permissionOverwrites = {
+        fetch: () => this.client.cache.overwrites?.get(this.id),
+        values: () => (this.guildId ? this.client.cache.overwrites?.values(this.guildId) ?? [] : []),
+    };
+    memberPermissions(member, checkAdmin = true) {
+        return this.client.channels.overwrites.memberPermissions(this.id, member, checkAdmin);
+    }
+    rolePermissions(role, checkAdmin = true) {
+        return this.client.channels.overwrites.rolePermissions(this.id, role, checkAdmin);
+    }
+    overwritesFor(member) {
+        return this.client.channels.overwrites.overwritesFor(this.id, member);
+    }
+    guild(force = false) {
         return this.client.guilds.fetch(this.guildId, force);
     }
     get url() {
@@ -144,11 +163,8 @@ class MessagesMethods extends DiscordBase_1.DiscordBase {
     static transformMessageBody(body) {
         return {
             ...body,
-            components: body.components
-                ? (body?.components instanceof components_1.ComponentsListener ? body.components.components : body.components).map(x => 'toJSON' in x ? x.toJSON() : x)
-                : undefined,
+            components: body.components?.map(x => ('toJSON' in x ? x.toJSON() : x)) ?? undefined,
             embeds: body.embeds?.map(x => (x instanceof builders_1.Embed ? x.toJSON() : x)) ?? undefined,
-            //?
             attachments: body.attachments?.map((x, i) => ({ id: i, ...(0, builders_1.resolveAttachment)(x) })) ?? undefined,
         };
     }

package/lib/structures/extra/BitField.d.ts

@@ -1,14 +1,17 @@
 export type BitFieldResolvable<T extends object> = keyof T | number | bigint | (keyof T | number | bigint)[];
 export declare class BitField<T extends object> {
-    static None: number;
-    Flags: Partial<Record<string, bigint>>;
+    static None: bigint;
+    Flags: Record<string, bigint>;
     private bit;
     constructor(bitfields?: BitFieldResolvable<T>);
     set bits(bits: BitFieldResolvable<T>);
-    get bits(): number;
-    add(...bits: BitFieldResolvable<T>[]): number;
-    remove(...bits: BitFieldResolvable<T>[]): number;
+    get bits(): bigint;
+    add(...bits: BitFieldResolvable<T>[]): bigint;
+    remove(...bits: BitFieldResolvable<T>[]): bigint;
     has(...bits: BitFieldResolvable<T>[]): boolean;
+    missings(...bits: BitFieldResolvable<T>[]): bigint[];
     equals(other: BitFieldResolvable<T>): boolean;
-    resolve(bits?: BitFieldResolvable<T>): number;
+    resolve(bits?: BitFieldResolvable<T>): bigint;
+    keys(...bits: BitFieldResolvable<T>[]): string[];
+    values(...bits: BitFieldResolvable<T>[]): bigint[];
 }

package/lib/structures/extra/BitField.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BitField = void 0;
 class BitField {
-    static None = 0;
+    static None = 0n;
     Flags = {};
     bit;
     constructor(bitfields) {
@@ -32,17 +32,21 @@ class BitField {
         const bitsResolved = bits.map(bit => this.resolve(bit));
         return bitsResolved.every(bit => (this.bits & bit) === bit);
     }
+    missings(...bits) {
+        const bitsResolved = bits.map(bit => this.resolve(bit));
+        return bitsResolved.filter(bit => (this.bits & bit) !== bit);
+    }
     equals(other) {
         return this.bits === this.resolve(other);
     }
     resolve(bits) {
         switch (typeof bits) {
             case 'number':
-                return bits;
+                return BigInt(bits);
             case 'string':
                 return this.resolve(this.Flags[bits]);
             case 'bigint':
-                return Number(bits);
+                return bits;
             case 'object':
                 if (!Array.isArray(bits)) {
                     throw new TypeError(`Cannot resolve permission: ${bits}`);
@@ -52,5 +56,25 @@ class BitField {
                 throw new TypeError(`Cannot resolve permission: ${typeof bits === 'symbol' ? String(bits) : bits}`);
         }
     }
+    keys(...bits) {
+        const bitsResolved = bits.map(bit => BigInt(this.resolve(bit)));
+        return Object.entries(this.Flags).reduce((acc, value) => {
+            if (bitsResolved.some(bit => (bit & value[1]) === value[1])) {
+                acc.push(value[0]);
+                return acc;
+            }
+            return acc;
+        }, []);
+    }
+    values(...bits) {
+        const bitsResolved = bits.map(bit => BigInt(this.resolve(bit)));
+        return Object.entries(this.Flags).reduce((acc, value) => {
+            if (bitsResolved.some(bit => (bit & value[1]) === value[1])) {
+                acc.push(value[1]);
+                return acc;
+            }
+            return acc;
+        }, []);
+    }
 }
 exports.BitField = BitField;

package/lib/structures/extra/Permissions.d.ts

@@ -1,5 +1,6 @@
 import { PermissionFlagsBits } from 'discord-api-types/v10';
-import { BitField } from './BitField';
+import type { PermissionStrings } from '../../common';
+import { BitField, type BitFieldResolvable } from './BitField';
 export declare class PermissionsBitField extends BitField<typeof PermissionFlagsBits> {
     Flags: {
         readonly CreateInstantInvite: bigint;
@@ -51,4 +52,8 @@ export declare class PermissionsBitField extends BitField<typeof PermissionFlags
         readonly UseExternalSounds: bigint;
         readonly SendVoiceMessages: bigint;
     };
+    static All: bigint;
+    keys: (...bits: BitFieldResolvable<typeof PermissionFlagsBits>[]) => PermissionStrings;
+    has(...bits: BitFieldResolvable<typeof PermissionFlagsBits>[]): boolean;
+    strictHas(...bits: BitFieldResolvable<typeof PermissionFlagsBits>[]): boolean;
 }

package/lib/structures/extra/Permissions.js

@@ -5,5 +5,12 @@ const v10_1 = require("discord-api-types/v10");
 const BitField_1 = require("./BitField");
 class PermissionsBitField extends BitField_1.BitField {
     Flags = v10_1.PermissionFlagsBits;
+    static All = Object.values(v10_1.PermissionFlagsBits).reduce((acc, value) => acc | value, 0n);
+    has(...bits) {
+        return super.has(...bits) || super.has('Administrator');
+    }
+    strictHas(...bits) {
+        return super.has(...bits);
+    }
 }
 exports.PermissionsBitField = PermissionsBitField;

package/lib/websocket/constants/index.js

@@ -24,8 +24,6 @@ exports.ShardManagerDefaults = ShardManagerDefaults;
 const WorkerManagerDefaults = {
     ...ShardManagerDefaults,
     shardsPerWorker: 32,
-    handlePayload: (shardId, workerId, packet) => {
-        console.info(`Packet ${packet.t} on shard ${shardId} worker ${workerId}`);
-    },
+    handlePayload: (_shardId, _workerId, _packet) => { },
 };
 exports.WorkerManagerDefaults = WorkerManagerDefaults;

package/lib/websocket/discord/basesocket.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseSocket = void 0;
 const ws_1 = __importDefault(require("ws"));
-// import UWebSocket from 'uWebSockets.js';
 class BaseSocket {
     internal;
     constructor(kind, url) {

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

@@ -35,6 +35,7 @@ export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handleP
      * @default 32
      */
     shardsPerWorker?: number;
+    workerProxy?: boolean;
     path: string;
     handlePayload(shardId: number, workerId: number, packet: GatewayDispatchPayload): unknown;
 }
@@ -96,4 +97,5 @@ export interface WorkerData {
     shards: number[];
     workerId: number;
     debug: boolean;
+    workerProxy: boolean;
 }

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

@@ -1,3 +1,4 @@
+import type { ApiRequestOptions, HttpMethods } from '../..';
 import type { GatewayDispatchPayload } from '../../common';
 export interface WorkerShardInfo {
     open: boolean;
@@ -7,18 +8,16 @@ export interface WorkerShardInfo {
 }
 export type WorkerInfo = {
     shards: WorkerShardInfo[];
-    workerId: number;
 };
 type CreateWorkerMessage<T extends string, D extends object = {}> = {
     type: T;
+    workerId: number;
 } & D;
 export type WorkerRequestConnect = CreateWorkerMessage<'CONNECT_QUEUE', {
     shardId: number;
-    workerId: number;
 }>;
 export type WorkerReceivePayload = CreateWorkerMessage<'RECEIVE_PAYLOAD', {
     shardId: number;
-    workerId: number;
     payload: GatewayDispatchPayload;
 }>;
 export type WorkerSendResultPayload = CreateWorkerMessage<'RESULT_PAYLOAD', {
@@ -28,7 +27,6 @@ export type WorkerSendCacheRequest = CreateWorkerMessage<'CACHE_REQUEST', {
     nonce: string;
     method: 'scan' | 'get' | 'set' | 'patch' | 'values' | 'keys' | 'count' | 'remove' | 'contains' | 'getToRelationship' | 'bulkAddToRelationShip' | 'addToRelationship' | 'removeRelationship' | 'removeToRelationship';
     args: any[];
-    workerId: number;
 }>;
 export type WorkerSendShardInfo = CreateWorkerMessage<'SHARD_INFO', WorkerShardInfo & {
     nonce: string;
@@ -36,8 +34,26 @@ export type WorkerSendShardInfo = CreateWorkerMessage<'SHARD_INFO', WorkerShardI
 export type WorkerSendInfo = CreateWorkerMessage<'WORKER_INFO', WorkerInfo & {
     nonce: string;
 }>;
-export type WorkerReady = CreateWorkerMessage<'WORKER_READY', {
-    workerId: number;
+export type WorkerReady = CreateWorkerMessage<'WORKER_READY'>;
+export type WorkerSendApiRequest = CreateWorkerMessage<'WORKER_API_REQUEST', {
+    method: HttpMethods;
+    url: `/${string}`;
+    requestOptions: ApiRequestOptions;
+    nonce: string;
+}>;
+export type WorkerExecuteEval = CreateWorkerMessage<'EXECUTE_EVAL', {
+    func: string;
+    nonce: string;
+    toWorkerId: number;
+}>;
+export type WorkerSendEvalResponse = CreateWorkerMessage<'EVAL_RESPONSE', {
+    response: any;
+    nonce: string;
+}>;
+export type WorkerSendEval = CreateWorkerMessage<'EVAL', {
+    func: string;
+    nonce: string;
+    toWorkerId: number;
 }>;
-export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady;
+export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerSendApiRequest | WorkerExecuteEval | WorkerSendEvalResponse | WorkerSendEval;
 export {};

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

@@ -1,22 +1,35 @@
 /// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import { Worker } from 'node:worker_threads';
+import { ApiHandler } from '../..';
 import { type Adapter } from '../../cache';
-import { Logger, type GatewayPresenceUpdateData, type GatewaySendPayload } from '../../common';
+import { Logger, type GatewayPresenceUpdateData, type GatewaySendPayload, type MakePartial } from '../../common';
 import { ConnectQueue } from '../structures/timeout';
 import { MemberUpdateHandler } from './events/memberUpdate';
 import { PresenceUpdateHandler } from './events/presenceUpdate';
 import type { ShardOptions, WorkerData, WorkerManagerOptions } from './shared';
 import type { WorkerInfo, WorkerMessage, WorkerShardInfo } from './worker';
-export declare class WorkerManager extends Map<number, Worker> {
+export declare class WorkerManager extends Map<number, Worker & {
+    ready?: boolean;
+}> {
     options: Required<WorkerManagerOptions>;
     debugger?: Logger;
     connectQueue: ConnectQueue;
     cacheAdapter: Adapter;
-    promises: Map<string, (value: any) => void>;
+    promises: Map<string, {
+        resolve: (value: any) => void;
+        timeout: NodeJS.Timeout;
+    }>;
     memberUpdateHandler: MemberUpdateHandler;
     presenceUpdateHandler: PresenceUpdateHandler;
-    constructor(options: WorkerManagerOptions);
+    rest: ApiHandler;
+    constructor(options: MakePartial<WorkerManagerOptions, 'token' | 'intents' | 'info' | 'handlePayload'>);
     setCache(adapter: Adapter): void;
+    setRest(rest: ApiHandler): void;
     get remaining(): number;
     get concurrency(): number;
     get totalWorkers(): number;
@@ -65,5 +78,19 @@ export type ManagerSendCacheResult = CreateManagerMessage<'CACHE_RESULT', {
     result: any;
 }>;
 export type ManagerSendBotReady = CreateManagerMessage<'BOT_READY'>;
-export type ManagerMessages = ManagerAllowConnect | ManagerSpawnShards | ManagerSendPayload | ManagerRequestShardInfo | ManagerRequestWorkerInfo | ManagerSendCacheResult | ManagerSendBotReady;
+export type ManagerSendApiResponse = CreateManagerMessage<'API_RESPONSE', {
+    response: any;
+    error?: any;
+    nonce: string;
+}>;
+export type ManagerExecuteEval = CreateManagerMessage<'EXECUTE_EVAL', {
+    func: string;
+    nonce: string;
+    toWorkerId: number;
+}>;
+export type ManagerSendEvalResponse = CreateManagerMessage<'EVAL_RESPONSE', {
+    response: any;
+    nonce: string;
+}>;
+export type ManagerMessages = ManagerAllowConnect | ManagerSpawnShards | ManagerSendPayload | ManagerRequestShardInfo | ManagerRequestWorkerInfo | ManagerSendCacheResult | ManagerSendBotReady | ManagerSendApiResponse | ManagerSendEvalResponse | ManagerExecuteEval;
 export {};

package/lib/websocket/discord/workermanager.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerManager = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_worker_threads_1 = require("node:worker_threads");
+const __1 = require("../..");
 const cache_1 = require("../../cache");
+const base_1 = require("../../client/base");
 const common_1 = require("../../common");
 const constants_1 = require("../constants");
 const structures_1 = require("../structures");
@@ -18,28 +20,18 @@ class WorkerManager extends Map {
     promises = new Map();
     memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
     presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
+    rest;
     constructor(options) {
         super();
-        options.totalShards ??= options.info.shards;
         this.options = (0, common_1.MergeOptions)(constants_1.WorkerManagerDefaults, options);
-        this.options.workers ??= Math.ceil(this.options.totalShards / this.options.shardsPerWorker);
-        this.options.info.shards = options.totalShards;
-        options.shardEnd ??= options.totalShards;
-        options.shardStart ??= 0;
-        this.connectQueue = new timeout_1.ConnectQueue(5.5e3, this.concurrency);
-        if (this.options.debug) {
-            this.debugger = new common_1.Logger({
-                name: '[WorkerManager]',
-            });
-        }
-        if (this.totalShards / this.shardsPerWorker > this.workers) {
-            throw new Error(`Cannot create enough shards in the specified workers, minimum: ${Math.ceil(this.totalShards / this.shardsPerWorker)}`);
-        }
         this.cacheAdapter = new cache_1.MemoryAdapter();
     }
     setCache(adapter) {
         this.cacheAdapter = adapter;
     }
+    setRest(rest) {
+        this.rest = rest;
+    }
     get remaining() {
         return this.options.info.session_start_limit.remaining;
     }
@@ -104,6 +96,7 @@ class WorkerManager extends Map {
                     shards: shards[i],
                     intents: this.options.intents,
                     workerId: i,
+                    workerProxy: this.options.workerProxy,
                 });
                 this.set(i, worker);
             }
@@ -173,62 +166,112 @@ class WorkerManager extends Map {
                 break;
             case 'RESULT_PAYLOAD':
                 {
-                    const resolve = this.promises.get(message.nonce);
-                    if (!resolve) {
+                    const resultPayload = this.promises.get(message.nonce);
+                    if (!resultPayload) {
                         return;
                     }
                     this.promises.delete(message.nonce);
-                    resolve(true);
+                    clearTimeout(resultPayload.timeout);
+                    resultPayload.resolve(true);
                 }
                 break;
             case 'SHARD_INFO':
                 {
                     const { nonce, type, ...data } = message;
-                    const resolve = this.promises.get(nonce);
-                    if (!resolve) {
+                    const shardInfo = this.promises.get(nonce);
+                    if (!shardInfo) {
                         return;
                     }
                     this.promises.delete(nonce);
-                    resolve(data);
+                    clearTimeout(shardInfo.timeout);
+                    shardInfo.resolve(data);
                 }
                 break;
             case 'WORKER_INFO':
                 {
                     const { nonce, type, ...data } = message;
-                    const resolve = this.promises.get(nonce);
-                    if (!resolve) {
+                    const workerInfo = this.promises.get(nonce);
+                    if (!workerInfo) {
                         return;
                     }
                     this.promises.delete(nonce);
-                    resolve(data);
+                    clearTimeout(workerInfo.timeout);
+                    workerInfo.resolve(data);
                 }
                 break;
             case 'WORKER_READY':
                 {
-                    if (message.workerId === [...this.keys()].at(-1)) {
+                    this.get(message.workerId).ready = true;
+                    if ([...this.values()].every(w => w.ready)) {
                         this.get(this.keys().next().value)?.postMessage({
                             type: 'BOT_READY',
                         });
+                        this.forEach(w => {
+                            delete w.ready;
+                        });
+                    }
+                }
+                break;
+            case 'WORKER_API_REQUEST':
+                {
+                    const response = await this.rest.request(message.method, message.url, message.requestOptions);
+                    this.get(message.workerId).postMessage({
+                        nonce: message.nonce,
+                        response,
+                        type: 'API_RESPONSE',
+                    });
+                }
+                break;
+            case 'EVAL_RESPONSE':
+                {
+                    const { nonce, type, ...data } = message;
+                    const evalResponse = this.promises.get(nonce);
+                    if (!evalResponse) {
+                        return;
                     }
+                    this.promises.delete(nonce);
+                    clearTimeout(evalResponse.timeout);
+                    evalResponse.resolve(data.response);
+                }
+                break;
+            case 'EVAL':
+                {
+                    const nonce = this.generateNonce();
+                    this.get(message.toWorkerId).postMessage({
+                        nonce,
+                        func: message.func,
+                        type: 'EXECUTE_EVAL',
+                        toWorkerId: message.toWorkerId,
+                    });
+                    this.generateSendPromise(nonce, 'Eval timeout').then(val => this.get(message.workerId).postMessage({
+                        nonce: message.nonce,
+                        response: val,
+                        type: 'EVAL_RESPONSE',
+                    }));
                 }
                 break;
         }
     }
     generateNonce(large = true) {
-        const nonce = (0, node_crypto_1.randomUUID)();
-        return large ? nonce : nonce.split('-')[0];
+        const uuid = (0, node_crypto_1.randomUUID)();
+        const nonce = large ? uuid : uuid.split('-')[0];
+        if (this.promises.has(nonce))
+            return this.generateNonce(large);
+        return nonce;
     }
     generateSendPromise(nonce, message = 'Timeout') {
         let resolve = (_) => {
             /**/
         };
+        let timeout = -1;
         const promise = new Promise((res, rej) => {
             resolve = res;
-            setTimeout(() => {
+            timeout = setTimeout(() => {
+                this.promises.delete(nonce);
                 rej(new Error(message));
-            }, 3e3);
+            }, 60e3);
         });
-        this.promises.set(nonce, resolve);
+        this.promises.set(nonce, { resolve, timeout });
         return promise;
     }
     async send(data, shardId) {
@@ -266,6 +309,32 @@ class WorkerManager extends Map {
         return this.generateSendPromise(nonce, 'Get worker info timeout');
     }
     async start() {
+        const rc = await base_1.BaseClient.prototype.getRC();
+        this.options.debug ||= rc.debug;
+        this.options.intents ||= rc.intents ?? 0;
+        this.options.token ??= rc.token;
+        this.rest ??= new __1.ApiHandler({
+            token: this.options.token,
+            baseUrl: 'api/v10',
+            domain: 'https://discord.com',
+            debug: this.options.debug,
+        });
+        this.options.info ??= await new __1.Router(this.rest).createProxy().gateway.bot.get();
+        this.options.totalShards ??= this.options.info.shards;
+        this.options = (0, common_1.MergeOptions)(constants_1.WorkerManagerDefaults, this.options);
+        this.options.workers ??= Math.ceil(this.options.totalShards / this.options.shardsPerWorker);
+        this.options.info.shards = this.options.totalShards;
+        this.options.shardEnd ??= this.options.totalShards;
+        this.options.shardStart ??= 0;
+        this.connectQueue = new timeout_1.ConnectQueue(5.5e3, this.concurrency);
+        if (this.options.debug) {
+            this.debugger = new common_1.Logger({
+                name: '[WorkerManager]',
+            });
+        }
+        if (this.totalShards / this.shardsPerWorker > this.workers) {
+            throw new Error(`Cannot create enough shards in the specified workers, minimum: ${Math.ceil(this.totalShards / this.shardsPerWorker)}`);
+        }
         const spaces = this.prepareSpaces();
         await this.prepareWorkers(spaces);
     }