seyfert 1.0.0 → 1.0.1

package/lib/api/api.d.ts

@@ -4,12 +4,17 @@ import type { ProxyRequestMethod } from './Router';
 import { Bucket } from './bucket';
 import { type ApiHandlerInternalOptions, type ApiHandlerOptions, type ApiRequestOptions, type HttpMethods, type RawFile, type RequestHeaders } from './shared';
 export declare class ApiHandler {
+    #private;
     options: ApiHandlerInternalOptions;
     globalBlock: boolean;
     ratelimits: Map<string, Bucket>;
     readyQueue: (() => void)[];
     cdn: CDN;
     debugger?: Logger;
+    workerPromises?: Map<string, {
+        resolve: (value: any) => any;
+        reject: (error: any) => any;
+    }>;
     constructor(options: ApiHandlerOptions);
     globalUnblock(): void;
     request<T = any>(method: HttpMethods, url: `/${string}`, { auth, ...request }?: ApiRequestOptions): Promise<T>;

package/lib/api/api.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiHandler = void 0;
 const magic_bytes_js_1 = require("magic-bytes.js");
+const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:timers/promises");
+const node_worker_threads_1 = require("node:worker_threads");
 const common_1 = require("../common");
 const functions_1 = require("../structures/extra/functions");
 const CDN_1 = require("./CDN");
@@ -16,8 +18,11 @@ class ApiHandler {
     readyQueue = [];
     cdn = new CDN_1.CDN();
     debugger;
+    workerPromises;
     constructor(options) {
         this.options = {
+            baseUrl: 'api/v10',
+            domain: 'https://discord.com',
             ...options,
             userAgent: shared_1.DefaultUserAgent,
         };
@@ -26,6 +31,10 @@ class ApiHandler {
                 name: '[API]',
             });
         }
+        if (options.workerProxy && !node_worker_threads_1.parentPort)
+            throw new Error('Cannot use workerProxy without a parent.');
+        if (options.workerProxy)
+            this.workerPromises = new Map();
     }
     globalUnblock() {
         this.globalBlock = false;
@@ -34,7 +43,34 @@ class ApiHandler {
             cb();
         }
     }
+    #randomUUID() {
+        const uuid = (0, node_crypto_1.randomUUID)();
+        if (this.workerPromises.has(uuid))
+            return this.#randomUUID();
+        return uuid;
+    }
     async request(method, url, { auth = true, ...request } = {}) {
+        if (this.options.workerProxy) {
+            const nonce = this.#randomUUID();
+            node_worker_threads_1.parentPort.postMessage({
+                method,
+                url,
+                type: 'WORKER_API_REQUEST',
+                workerId: node_worker_threads_1.workerData.workerId,
+                nonce,
+                requestOptions: { auth, ...request },
+            }, request.files
+                ?.filter(x => !['string', 'boolean', 'number'].includes(typeof x.data))
+                .map(x => x.data));
+            let resolve = (_value) => { };
+            let reject = () => { };
+            const promise = new Promise((res, rej) => {
+                resolve = res;
+                reject = rej;
+            });
+            this.workerPromises.set(nonce, { reject, resolve });
+            return promise;
+        }
         const route = request.route || this.routefy(url, method);
         let attempts = 0;
         const callback = async (next, resolve, reject) => {

package/lib/api/shared.d.ts

@@ -1,17 +1,19 @@
 /// <reference types="node" />
+import type { MakeRequired } from '../common';
 export * from './api';
 export * from './utils/constants';
 export * from './utils/types';
 export { calculateUserDefaultAvatarIndex } from './utils/utils';
 export interface ApiHandlerOptions {
-    baseUrl: string;
-    domain: string;
+    baseUrl?: string;
+    domain?: string;
     token: string;
     debug?: boolean;
     agent?: string;
     smartBucket?: boolean;
+    workerProxy?: boolean;
 }
-export interface ApiHandlerInternalOptions extends ApiHandlerOptions {
+export interface ApiHandlerInternalOptions extends MakeRequired<ApiHandlerOptions, 'baseUrl' | 'domain'> {
     userAgent: string;
 }
 export interface RawFile {

package/lib/builders/Button.d.ts

@@ -1,4 +1,4 @@
-import { type APIButtonComponent, type APIButtonComponentWithCustomId, type APIButtonComponentWithURL, type ButtonStyle, type EmojiResolvable, type When } from '../common';
+import { type APIButtonComponentWithCustomId, type APIButtonComponentWithURL, type ButtonStyle, type EmojiResolvable, type When } from '../common';
 export type ButtonStylesForID = Exclude<ButtonStyle, ButtonStyle.Link>;
 /**
  * Represents a button component.
@@ -46,5 +46,5 @@ export declare class Button<Type extends boolean = boolean> {
      * Converts the Button instance to its JSON representation.
      * @returns The JSON representation of the Button instance.
      */
-    toJSON(): APIButtonComponent;
+    toJSON(): When<Type, APIButtonComponentWithCustomId, APIButtonComponentWithURL>;
 }

package/lib/cache/adapters/default.d.ts

@@ -1,5 +1,6 @@
 import type { Adapter } from './types';
 export declare class MemoryAdapter implements Adapter {
+    isAsync: boolean;
     readonly storage: Map<string, string>;
     readonly relationships: Map<string, string[]>;
     scan(query: string, keys?: false): any[];

package/lib/cache/adapters/default.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryAdapter = void 0;
 class MemoryAdapter {
+    isAsync = false;
     storage = new Map();
     relationships = new Map();
     scan(query, keys = false) {

package/lib/cache/adapters/redis.d.ts

@@ -4,6 +4,7 @@ interface RedisAdapterOptions {
     namespace?: string;
 }
 export declare class RedisAdapter implements Adapter {
+    isAsync: boolean;
     client: import('ioredis').Redis;
     namespace: string;
     constructor(data: ({

package/lib/cache/adapters/redis.js

@@ -9,6 +9,7 @@ catch {
     // potocuit > seyfert
 }
 class RedisAdapter {
+    isAsync = true;
     client;
     namespace;
     constructor(data) {

package/lib/cache/adapters/types.d.ts

@@ -1,4 +1,5 @@
 export interface Adapter {
+    isAsync: boolean;
     scan(query: string, keys?: false): RPV<any[]>;
     scan(query: string, keys: true): RPV<string[]>;
     scan(query: string, keys?: boolean): RPV<(any | string)[]>;

package/lib/cache/adapters/workeradapter.d.ts

@@ -9,6 +9,7 @@ import type { WorkerSendCacheRequest } from '../../websocket/discord/worker';
 import type { Adapter } from './types';
 export declare class WorkerAdapter implements Adapter {
     readonly parent: MessagePort;
+    isAsync: boolean;
     promises: Map<string, {
         resolve: (value: unknown) => void;
         timeout: NodeJS.Timeout;

package/lib/cache/adapters/workeradapter.js

@@ -5,6 +5,7 @@ const node_crypto_1 = require("node:crypto");
 const node_worker_threads_1 = require("node:worker_threads");
 class WorkerAdapter {
     parent;
+    isAsync = true;
     promises = new Map();
     constructor(parent) {
         this.parent = parent;

package/lib/cache/index.d.ts

@@ -27,7 +27,6 @@ export type CachedEvents = 'READY' | 'GUILD_CREATE' | 'GUILD_UPDATE' | 'GUILD_DE
 export declare class Cache {
     intents: number;
     adapter: Adapter;
-    asyncCache: boolean;
     readonly disabledCache: (NonGuildBased | GuildBased | GuildRelated)[];
     users?: Users;
     guilds?: Guilds;
@@ -41,7 +40,7 @@ export declare class Cache {
     presences?: Presences;
     voiceStates?: VoiceStates;
     stageInstances?: StageInstances;
-    constructor(intents: number, adapter: Adapter, asyncCache?: boolean, disabledCache?: (NonGuildBased | GuildBased | GuildRelated)[], client?: BaseClient);
+    constructor(intents: number, adapter: Adapter, disabledCache?: (NonGuildBased | GuildBased | GuildRelated)[], client?: BaseClient);
     hasIntent(intent: keyof typeof GatewayIntentBits): boolean;
     get hasGuildsIntent(): boolean;
     get hasRolesIntent(): boolean;

package/lib/cache/index.js

@@ -32,7 +32,6 @@ __exportStar(require("./adapters/index"), exports);
 class Cache {
     intents;
     adapter;
-    asyncCache;
     disabledCache;
     // non-guild based
     users;
@@ -49,10 +48,9 @@ class Cache {
     presences;
     voiceStates;
     stageInstances;
-    constructor(intents, adapter, asyncCache = false, disabledCache = [], client) {
+    constructor(intents, adapter, disabledCache = [], client) {
         this.intents = intents;
         this.adapter = adapter;
-        this.asyncCache = asyncCache;
         this.disabledCache = disabledCache;
         // non-guild based
         if (!this.disabledCache.includes('users')) {

package/lib/client/base.d.ts

@@ -266,7 +266,6 @@ export type ServicesOptions = {
     cache?: {
         adapter: Adapter;
         disabledCache?: Cache['disabledCache'];
-        asyncCache?: boolean;
     };
     langs?: {
         default?: string;

package/lib/client/base.js

@@ -66,7 +66,7 @@ class BaseClient {
             this.rest = rest;
         }
         if (cache) {
-            this.cache = new cache_1.Cache(this.cache?.intents ?? 0, cache.adapter, cache.asyncCache ?? this.cache?.asyncCache, cache.disabledCache ?? this.cache?.disabledCache, this);
+            this.cache = new cache_1.Cache(this.cache?.intents ?? 0, cache.adapter, cache.disabledCache ?? this.cache?.disabledCache, this);
         }
         if (langs) {
             if (langs.default)
@@ -108,7 +108,7 @@ class BaseClient {
             });
         }
         if (!this.cache) {
-            this.cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), false, [], this);
+            this.cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), [], this);
         }
         else {
             this.cache.__setClient(this);

package/lib/client/client.d.ts

@@ -1,5 +1,5 @@
 import type { Command, CommandContext, Message, SubCommand } from '..';
-import type { DeepPartial, GatewayDispatchPayload, GatewayPresenceUpdateData, If } from '../common';
+import { type DeepPartial, type GatewayDispatchPayload, type GatewayPresenceUpdateData, type If } from '../common';
 import { EventHandler } from '../events';
 import { ClientUser } from '../structures';
 import { ShardManager, type ShardManagerOptions } from '../websocket';

package/lib/client/client.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
 const node_worker_threads_1 = require("node:worker_threads");
+const common_1 = require("../common");
 const events_1 = require("../events");
 const structures_1 = require("../structures");
 const websocket_1 = require("../websocket");
@@ -11,7 +12,7 @@ const base_1 = require("./base");
 const oninteractioncreate_1 = require("./oninteractioncreate");
 const onmessagecreate_1 = require("./onmessagecreate");
 class Client extends base_1.BaseClient {
-    __handleGuilds;
+    __handleGuilds = new Set();
     gateway;
     events = new events_1.EventHandler(this.logger);
     me;
@@ -21,7 +22,6 @@ class Client extends base_1.BaseClient {
         super(options);
     }
     setServices({ gateway, ...rest }) {
-        this.__handleGuilds = new Set();
         super.setServices(rest);
         if (gateway) {
             const onPacket = this.onPacket.bind(this);
@@ -123,25 +123,23 @@ class Client extends base_1.BaseClient {
                         this.botId = packet.d.user.id;
                         this.applicationId = packet.d.application.id;
                         this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
-                        if (!this.__handleGuilds?.size) {
-                            if ([...this.gateway.values()].every(shard => shard.data.session_id) &&
-                                this.events.values.BOT_READY &&
-                                (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
+                        if (!this.__handleGuilds?.size ||
+                            !((this.gateway.options.intents & common_1.GatewayIntentBits.Guilds) === common_1.GatewayIntentBits.Guilds)) {
+                            if ([...this.gateway.values()].every(shard => shard.data.session_id)) {
                                 await this.events.runEvent('BOT_READY', this, this.me, -1);
-                                delete this.__handleGuilds;
                             }
+                            delete this.__handleGuilds;
                         }
                         this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
                         break;
                     case 'GUILD_CREATE': {
                         if (this.__handleGuilds?.has(packet.d.id)) {
                             this.__handleGuilds.delete(packet.d.id);
-                            if (!this.__handleGuilds.size &&
-                                [...this.gateway.values()].every(shard => shard.data.session_id) &&
-                                this.events.values.BOT_READY &&
-                                (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
+                            if (!this.__handleGuilds.size && [...this.gateway.values()].every(shard => shard.data.session_id)) {
                                 await this.events.runEvent('BOT_READY', this, this.me, -1);
                             }
+                            if (!this.__handleGuilds.size)
+                                delete this.__handleGuilds;
                             return;
                         }
                         break;

package/lib/client/oninteractioncreate.js

@@ -178,8 +178,8 @@ async function onInteractionCreate(self, body, shardId, __reply) {
         case v10_1.InteractionType.MessageComponent:
             {
                 const interaction = structures_1.BaseInteraction.from(self, body, __reply);
-                if (self.components.hasComponent([body.message.id, body.id], interaction.customId)) {
-                    await self.components.onComponent([body.message.id, body.id], interaction);
+                if (self.components.hasComponent(body.message.id, interaction.customId)) {
+                    await self.components.onComponent(body.message.id, interaction);
                 }
                 else {
                     await self.components.executeComponent(interaction);

package/lib/client/workerclient.d.ts

@@ -1,3 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import type { Cache } from '../cache';
 import type { GatewayDispatchPayload, When } from '../common';
 import { Logger, type DeepPartial } from '../common';
@@ -14,13 +19,21 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
     logger: Logger;
     events: EventHandler;
     me: When<Ready, ClientUser>;
+    promises: Map<string, {
+        resolve: (value: any) => void;
+        timeout: NodeJS.Timeout;
+    }>;
     shards: Map<number, Shard>;
     options: WorkerClientOptions | undefined;
     constructor(options?: WorkerClientOptions);
     get workerId(): number;
+    get latency(): number;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
     loadEvents(dir?: string): Promise<void>;
-    protected handleManagerMessages(data: ManagerMessages): Promise<void>;
+    protected handleManagerMessages(data: ManagerMessages): Promise<any>;
+    private generateNonce;
+    private generateSendPromise;
+    tellWorker(workerId: number, func: (_: this) => {}): Promise<unknown>;
     protected onPacket(packet: GatewayDispatchPayload, shardId: number): Promise<void>;
 }
 export declare function generateShardInfo(shard: Shard): WorkerShardInfo;

package/lib/client/workerclient.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateShardInfo = exports.WorkerClient = 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 common_1 = require("../common");
 const events_1 = require("../events");
@@ -12,16 +14,16 @@ const oninteractioncreate_1 = require("./oninteractioncreate");
 const onmessagecreate_1 = require("./onmessagecreate");
 const workerData = node_worker_threads_1.workerData;
 class WorkerClient extends base_1.BaseClient {
-    __handleGuilds;
+    __handleGuilds = new Set();
     logger = new common_1.Logger({
         name: `[Worker #${workerData.workerId}]`,
     });
     events = new events_1.EventHandler(this.logger);
     me;
+    promises = new Map();
     shards = new Map();
     constructor(options) {
         super(options);
-        this.__handleGuilds = new Set();
         if (!node_worker_threads_1.parentPort) {
             throw new Error('WorkerClient cannot spawn without manager');
         }
@@ -38,10 +40,24 @@ class WorkerClient extends base_1.BaseClient {
                 logLevel: common_1.LogLevels.Debug,
             });
         }
+        if (workerData.workerProxy) {
+            this.setServices({
+                rest: new __1.ApiHandler({
+                    token: workerData.token,
+                    workerProxy: true,
+                    debug: workerData.debug,
+                }),
+            });
+        }
     }
     get workerId() {
         return workerData.workerId;
     }
+    get latency() {
+        let acc = 0;
+        this.shards.forEach(s => (acc += s.latency));
+        return acc / this.shards.size;
+    }
     async start(options = {}) {
         await super.start(options);
         await this.loadEvents(options.eventsDir);
@@ -77,6 +93,7 @@ class WorkerClient extends base_1.BaseClient {
                     node_worker_threads_1.parentPort.postMessage({
                         type: 'RESULT_PAYLOAD',
                         nonce: data.nonce,
+                        workerId: this.workerId,
                     });
                 }
                 break;
@@ -138,6 +155,7 @@ class WorkerClient extends base_1.BaseClient {
                         ...generateShardInfo(shard),
                         nonce: data.nonce,
                         type: 'SHARD_INFO',
+                        workerId: this.workerId,
                     });
                 }
                 break;
@@ -152,13 +170,84 @@ class WorkerClient extends base_1.BaseClient {
                 }
                 break;
             case 'BOT_READY':
-                if (this.events.values.BOT_READY &&
-                    (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
-                    await this.events.runEvent('BOT_READY', this, this.me, -1);
+                await this.events.runEvent('BOT_READY', this, this.me, -1);
+                break;
+            case 'API_RESPONSE':
+                {
+                    const promise = this.rest.workerPromises.get(data.nonce);
+                    if (!promise)
+                        return;
+                    this.rest.workerPromises.delete(data.nonce);
+                    if (data.error)
+                        return promise.reject(data.error);
+                    promise.resolve(data.response);
+                }
+                break;
+            case 'EXECUTE_EVAL':
+                {
+                    let result;
+                    try {
+                        // biome-ignore lint/security/noGlobalEval: yes
+                        result = await eval(`
+					(${data.func})(this)
+					`);
+                    }
+                    catch (e) {
+                        result = e;
+                    }
+                    node_worker_threads_1.parentPort.postMessage({
+                        type: 'EVAL_RESPONSE',
+                        response: result,
+                        workerId: workerData.workerId,
+                        nonce: data.nonce,
+                    });
+                }
+                break;
+            case 'EVAL_RESPONSE':
+                {
+                    const evalResponse = this.promises.get(data.nonce);
+                    if (!evalResponse)
+                        return;
+                    this.promises.delete(data.nonce);
+                    clearTimeout(evalResponse.timeout);
+                    evalResponse.resolve(data.response);
                 }
                 break;
         }
     }
+    generateNonce(large = true) {
+        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;
+            timeout = setTimeout(() => {
+                this.promises.delete(nonce);
+                rej(new Error(message));
+            }, 60e3);
+        });
+        this.promises.set(nonce, { resolve, timeout });
+        return promise;
+    }
+    tellWorker(workerId, func) {
+        const nonce = this.generateNonce();
+        node_worker_threads_1.parentPort.postMessage({
+            type: 'EVAL',
+            func: func.toString(),
+            toWorkerId: workerId,
+            workerId: workerData.workerId,
+            nonce,
+        });
+        return this.generateSendPromise(nonce);
+    }
     async onPacket(packet, shardId) {
         await this.events.execute('RAW', packet, this, shardId);
         switch (packet.t) {
@@ -181,17 +270,16 @@ class WorkerClient extends base_1.BaseClient {
                             this.botId = packet.d.user.id;
                             this.applicationId = packet.d.application.id;
                             this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
-                            if (!this.__handleGuilds?.size) {
-                                if ([...this.shards.values()].every(shard => shard.data.session_id) &&
-                                    this.events.values.WORKER_READY &&
-                                    (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
+                            if (!this.__handleGuilds?.size ||
+                                !((workerData.intents & common_1.GatewayIntentBits.Guilds) === common_1.GatewayIntentBits.Guilds)) {
+                                if ([...this.shards.values()].every(shard => shard.data.session_id)) {
                                     node_worker_threads_1.parentPort.postMessage({
                                         type: 'WORKER_READY',
                                         workerId: this.workerId,
                                     });
                                     await this.events.runEvent('WORKER_READY', this, this.me, -1);
-                                    delete this.__handleGuilds;
                                 }
+                                delete this.__handleGuilds;
                             }
                             this.debugger?.debug(`#${shardId} [${packet.d.user.username}](${this.botId}) is online...`);
                             break;
@@ -204,16 +292,15 @@ class WorkerClient extends base_1.BaseClient {
                         case 'GUILD_CREATE': {
                             if (this.__handleGuilds?.has(packet.d.id)) {
                                 this.__handleGuilds.delete(packet.d.id);
-                                if (!this.__handleGuilds.size &&
-                                    [...this.shards.values()].every(shard => shard.data.session_id) &&
-                                    this.events.values.WORKER_READY &&
-                                    (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
+                                if (!this.__handleGuilds.size && [...this.shards.values()].every(shard => shard.data.session_id)) {
                                     node_worker_threads_1.parentPort.postMessage({
                                         type: 'WORKER_READY',
                                         workerId: this.workerId,
                                     });
                                     await this.events.runEvent('WORKER_READY', this, this.me, -1);
                                 }
+                                if (!this.__handleGuilds.size)
+                                    delete this.__handleGuilds;
                                 return;
                             }
                         }

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

@@ -1,5 +1,5 @@
 import { MenuCommandContext, User, type AllChannels, type Guild, type InferWithPrefix, type MessageCommandInteraction, type ReturnCache, type UserCommandInteraction, type WebhookMessage } from '../..';
-import { type When, type If, type UnionToTuple } from '../../common';
+import { type If, type UnionToTuple, type When } from '../../common';
 import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest } from '../../common/types/write';
 import { Message, type ChatInputCommandInteraction, type GuildMember, type InteractionGuildMember } from '../../structures';
 import type { RegisteredMiddlewares } from '../decorators';

package/lib/commands/applications/chatcontext.js

@@ -69,22 +69,22 @@ class CommandContext {
     }
     channel(mode = 'cache') {
         if (this.interaction?.channel && mode === 'cache')
-            return this.client.cache.asyncCache ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
+            return this.client.cache.adapter.isAsync ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
         switch (mode) {
             case 'cache':
                 return (this.client.cache.channels?.get(this.channelId) ||
-                    (this.client.cache.asyncCache ? Promise.resolve() : undefined));
+                    (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined));
             default:
                 return this.client.channels.fetch(this.channelId, mode === 'rest');
         }
     }
     me(mode = 'cache') {
         if (!this.guildId)
-            return mode === 'cache' ? (this.client.cache.asyncCache ? Promise.resolve() : undefined) : Promise.resolve();
+            return mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve();
         switch (mode) {
             case 'cache':
                 return (this.client.cache.members?.get(this.client.botId, this.guildId) ||
-                    (this.client.cache.asyncCache ? Promise.resolve() : undefined));
+                    (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined));
             default:
                 return this.client.members.fetch(this.guildId, this.client.botId, mode === 'rest');
         }
@@ -92,14 +92,14 @@ class CommandContext {
     guild(mode = 'cache') {
         if (!this.guildId)
             return (mode === 'cache'
-                ? this.client.cache.asyncCache
+                ? this.client.cache.adapter.isAsync
                     ? Promise.resolve()
                     : undefined
                 : Promise.resolve());
         switch (mode) {
             case 'cache':
                 return (this.client.cache.guilds?.get(this.guildId) ||
-                    (this.client.cache.asyncCache ? Promise.resolve() : undefined));
+                    (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined));
             default:
                 return this.client.guilds.fetch(this.guildId, mode === 'rest');
         }

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

@@ -1,5 +1,5 @@
-import { CommandContext, type WebhookMessage, type ReturnCache } from '../..';
-import { type When, type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type UnionToTuple } from '../../common';
+import { CommandContext, type ReturnCache, type WebhookMessage } from '../..';
+import { type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type UnionToTuple, type When } from '../../common';
 import { Message, User, type AllChannels, type Guild, type GuildMember, type MessageCommandInteraction, type UserCommandInteraction } from '../../structures';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';

package/lib/commands/applications/menucontext.js

@@ -57,12 +57,12 @@ class MenuCommandContext {
     }
     channel(mode = 'cache') {
         if (this.interaction?.channel && mode === 'cache')
-            return this.client.cache.asyncCache ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
+            return this.client.cache.adapter.isAsync ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
         return this.client.channels.fetch(this.channelId, mode === 'rest');
     }
     me(mode = 'cache') {
         if (!this.guildId)
-            return mode === 'cache' ? (this.client.cache.asyncCache ? Promise.resolve() : undefined) : Promise.resolve();
+            return mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve();
         switch (mode) {
             case 'cache':
                 return this.client.cache.members?.get(this.client.botId, this.guildId);
@@ -72,7 +72,7 @@ class MenuCommandContext {
     }
     guild(mode = 'cache') {
         if (!this.guildId)
-            return (mode === 'cache' ? (this.client.cache.asyncCache ? Promise.resolve() : undefined) : Promise.resolve());
+            return (mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve());
         switch (mode) {
             case 'cache':
                 return this.client.cache.guilds?.get(this.guildId);

package/lib/common/types/util.d.ts

@@ -3,7 +3,7 @@ export type ToClass<T, This> = new (...args: any[]) => {
     [K in keyof T]: T[K] extends (...args: any[]) => any ? ReturnType<T[K]> extends Promise<T> ? (...args: Parameters<T[K]>) => Promise<This> : ReturnType<T[K]> extends T ? (...args: Parameters<T[K]>) => This : T[K] : T[K];
 };
 export type StringToNumber<T extends string> = T extends `${infer N extends number}` ? N : never;
-export type MakePartial<T, K extends keyof T> = T & {
+export type MakePartial<T, K extends keyof T> = Omit<T, K> & {
     [P in K]?: T[P];
 };
 export type DeepPartial<T> = {

package/lib/components/handler.d.ts

@@ -26,8 +26,8 @@ export declare class ComponentHandler extends BaseHandler {
         run: (customId: string, callback: ComponentCallback) => any;
         stop: (reason?: string) => void;
     };
-    onComponent(ids: [string, string], interaction: ComponentInteraction): Promise<void>;
-    hasComponent(ids: [string, string], customId: string): boolean;
+    onComponent(id: string, interaction: ComponentInteraction): Promise<void>;
+    hasComponent(id: string, customId: string): ComponentCallback | undefined;
     resetTimeouts(id: string): void;
     hasModal(interaction: ModalSubmitInteraction): boolean;
     onModalSubmit(interaction: ModalSubmitInteraction): any;

package/lib/components/handler.js

@@ -55,28 +55,25 @@ class ComponentHandler extends common_1.BaseHandler {
             },
         };
     }
-    async onComponent(ids, interaction) {
-        for (const id of ids) {
-            const row = this.values.get(id);
-            const component = row?.components?.[interaction.customId];
-            if (!component)
-                continue;
-            if (row.options?.filter) {
-                if (!(await row.options.filter(interaction)))
-                    return;
-            }
-            row.idle?.refresh();
-            await component(interaction, reason => {
-                row.options?.onStop?.(reason ?? 'stop');
-                this.deleteValue(id);
-            }, () => {
-                this.resetTimeouts(id);
-            });
-            break;
+    async onComponent(id, interaction) {
+        const row = this.values.get(id);
+        const component = row?.components?.[interaction.customId];
+        if (!component)
+            return;
+        if (row.options?.filter) {
+            if (!(await row.options.filter(interaction)))
+                return;
         }
+        row.idle?.refresh();
+        await component(interaction, reason => {
+            row.options?.onStop?.(reason ?? 'stop');
+            this.deleteValue(id);
+        }, () => {
+            this.resetTimeouts(id);
+        });
     }
-    hasComponent(ids, customId) {
-        return ids.some(id => this.values.get(id)?.components?.[customId]);
+    hasComponent(id, customId) {
+        return this.values.get(id)?.components?.[customId];
     }
     resetTimeouts(id) {
         const listener = this.values.get(id);

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/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

@@ -5,14 +5,17 @@
 /// <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;
@@ -23,8 +26,10 @@ export declare class WorkerManager extends Map<number, Worker> {
     }>;
     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;
@@ -73,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,46 +166,88 @@ class WorkerManager extends Map {
                 break;
             case 'RESULT_PAYLOAD':
                 {
-                    const cacheData = this.promises.get(message.nonce);
-                    if (!cacheData) {
+                    const resultPayload = this.promises.get(message.nonce);
+                    if (!resultPayload) {
                         return;
                     }
                     this.promises.delete(message.nonce);
-                    clearTimeout(cacheData.timeout);
-                    cacheData.resolve(true);
+                    clearTimeout(resultPayload.timeout);
+                    resultPayload.resolve(true);
                 }
                 break;
             case 'SHARD_INFO':
                 {
                     const { nonce, type, ...data } = message;
-                    const cacheData = this.promises.get(nonce);
-                    if (!cacheData) {
+                    const shardInfo = this.promises.get(nonce);
+                    if (!shardInfo) {
                         return;
                     }
                     this.promises.delete(nonce);
-                    clearTimeout(cacheData.timeout);
-                    cacheData.resolve(data);
+                    clearTimeout(shardInfo.timeout);
+                    shardInfo.resolve(data);
                 }
                 break;
             case 'WORKER_INFO':
                 {
                     const { nonce, type, ...data } = message;
-                    const cacheData = this.promises.get(nonce);
-                    if (!cacheData) {
+                    const workerInfo = this.promises.get(nonce);
+                    if (!workerInfo) {
                         return;
                     }
                     this.promises.delete(nonce);
-                    clearTimeout(cacheData.timeout);
-                    cacheData.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;
         }
@@ -234,7 +269,7 @@ class WorkerManager extends Map {
             timeout = setTimeout(() => {
                 this.promises.delete(nonce);
                 rej(new Error(message));
-            }, 3e3);
+            }, 60e3);
         });
         this.promises.set(nonce, { resolve, timeout });
         return promise;
@@ -274,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);
     }

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "seyfert",
-	"version": "1.0.0",
+	"version": "1.0.1",
+	"description": "The most advanced framework for discord bots",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",
 	"types": "./lib/index.d.ts",
@@ -68,4 +69,4 @@
 			"url": "https://github.com/socram03"
 		}
 	]
-}
+}