seyfert 5.1.0 → 5.1.1-dev-34481657717.0

package/lib/client/plugins/registry.js

@@ -30,6 +30,7 @@ exports.installPluginMiddlewares = installPluginMiddlewares;
 exports.resolveGatewayIntent = resolveGatewayIntent;
 exports.unknownGatewayIntentBits = unknownGatewayIntentBits;
 exports.validatePluginRequirements = validatePluginRequirements;
+const utils_1 = require("../../common/it/utils");
 const types_1 = require("../../types");
 const api_1 = require("./api");
 const errors_1 = require("./errors");
@@ -105,7 +106,7 @@ function createPluginRuntimeRegistry(plugins = []) {
 function runPluginRegister(record, registry) {
     try {
         const result = record.plugin.register?.((0, api_1.createPluginApi)(record, registry));
-        if (isPromiseLike(result)) {
+        if ((0, utils_1.isPromiseLike)(result)) {
             Promise.resolve(result).catch(() => undefined);
             throw (0, errors_1.createPluginConflictError)(record.plugin.name, 'register', record.index, 'register(api) must be synchronous.', record.plugin.instanceId);
         }
@@ -860,9 +861,3 @@ const reservedContextKeys = new Set([
 function capitalize(value) {
     return value[0]?.toUpperCase() + value.slice(1);
 }
-function isPromiseLike(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'then' in value &&
-        typeof value.then === 'function');
-}

package/lib/client/workerclient.d.ts

@@ -39,7 +39,7 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
     get workerData(): WorkerData;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
     loadEvents(dir?: string): Promise<void>;
-    postMessage(body: WorkerMessages | ClientHeartbeaterMessages): unknown;
+    postMessage(body: WorkerMessages | ClientHeartbeaterMessages): Promise<unknown>;
     handleManagerMessages(data: ManagerMessages | WorkerHeartbeaterMessages): Promise<any>;
     calculateShardId(guildId: string): number;
     /**
@@ -51,6 +51,7 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
     private sendGatewayPayloadOnShard;
     private generateNonce;
     private generateSendPromise;
+    private sendRequest;
     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' | 'properties'>): Shard;

package/lib/client/workerclient.js

@@ -49,9 +49,6 @@ class WorkerClient extends base_1.BaseClient {
     resharding = new Map();
     constructor(options) {
         super(options);
-        if (options?.postMessage) {
-            this.postMessage = options.postMessage;
-        }
         if (this.options.handleManagerMessages) {
             const oldFn = this.handleManagerMessages.bind(this);
             this.handleManagerMessages = async (message) => {
@@ -102,7 +99,11 @@ class WorkerClient extends base_1.BaseClient {
             manager = worker_threads?.parentPort;
         }
         if (workerData.mode !== 'custom')
-            (manager ?? process).on('message', (data) => this.handleManagerMessages(data));
+            (manager ?? process).on('message', (data) => {
+                void this.handleManagerMessages(data).catch(error => {
+                    this.logger.error('Worker manager message handling failed', error);
+                });
+            });
         this.configureLogger({ name: `[Worker #${workerData.workerId}]` }, this.options.logger);
         if (workerData.debug) {
             this.debugger = new __1.Logger({
@@ -123,7 +124,7 @@ class WorkerClient extends base_1.BaseClient {
         this.rest.workerData = workerData;
         await super.start(options);
         workerData.intents = this.resolvePluginGatewayIntents(workerData.intents);
-        this.postMessage({
+        await this.postMessage({
             type: workerData.resharding ? 'WORKER_START_RESHARDING' : 'WORKER_START',
             workerId: workerData.workerId,
         });
@@ -138,15 +139,24 @@ class WorkerClient extends base_1.BaseClient {
         }
         await (0, plugins_1.runPluginHooks)(this, 'events:afterLoad', this, dir);
     }
-    postMessage(body) {
+    async postMessage(body) {
+        if (this.options.postMessage)
+            return this.options.postMessage.call(this, body);
         if (manager)
             return manager.postMessage(body);
-        return process.send(body);
+        return new Promise((resolve, reject) => {
+            process.send(body, error => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+        });
     }
     async handleManagerMessages(data) {
         switch (data.type) {
             case 'HEARTBEAT':
-                this.postMessage({
+                await this.postMessage({
                     type: 'ACK_HEARTBEAT',
                     workerId: workerData.workerId,
                 });
@@ -170,7 +180,7 @@ class WorkerClient extends base_1.BaseClient {
                         this.logger.fatal(`Worker trying to send payload by non-existent shard (#${data.shardId})`);
                         return;
                     }
-                    this.postMessage({
+                    await this.postMessage({
                         type: 'RESULT_PAYLOAD',
                         nonce: data.nonce,
                         workerId: this.workerId,
@@ -225,15 +235,19 @@ class WorkerClient extends base_1.BaseClient {
                                 if (payload.t !== types_1.GatewayDispatchEvents.GuildsReady)
                                     return;
                                 if (++shardsConnected === workerData.shards.length) {
-                                    self.postMessage({
+                                    void self
+                                        .postMessage({
                                         type: 'WORKER_READY_RESHARDING',
                                         workerId: workerData.workerId,
+                                    })
+                                        .catch(error => {
+                                        self.logger.error('Failed to send WORKER_READY_RESHARDING to the worker manager', error);
                                     });
                                 }
                             },
                         });
                         this.resharding.set(id, shard);
-                        this.postMessage({
+                        await this.postMessage({
                             type: 'CONNECT_QUEUE_RESHARDING',
                             shardId: id,
                             workerId: workerData.workerId,
@@ -251,7 +265,7 @@ class WorkerClient extends base_1.BaseClient {
                         }
                         const shard = this.createShard(id, data);
                         this.shards.set(id, shard);
-                        this.postMessage({
+                        await this.postMessage({
                             type: 'CONNECT_QUEUE',
                             shardId: id,
                             workerId: workerData.workerId,
@@ -266,7 +280,7 @@ class WorkerClient extends base_1.BaseClient {
                         this.logger.fatal(`Worker trying to get non-existent shard (#${data.shardId})`);
                         return;
                     }
-                    this.postMessage({
+                    await this.postMessage({
                         ...generateShardInfo(shard),
                         nonce: data.nonce,
                         type: 'SHARD_INFO',
@@ -276,7 +290,7 @@ class WorkerClient extends base_1.BaseClient {
                 break;
             case 'WORKER_INFO':
                 {
-                    this.postMessage({
+                    await this.postMessage({
                         shards: [...this.shards.values()].map(generateShardInfo),
                         workerId: workerData.workerId,
                         type: 'WORKER_INFO',
@@ -310,7 +324,7 @@ class WorkerClient extends base_1.BaseClient {
                     catch (e) {
                         result = e;
                     }
-                    this.postMessage({
+                    await this.postMessage({
                         type: 'EVAL_RESPONSE',
                         response: result,
                         workerId: workerData.workerId,
@@ -330,7 +344,7 @@ class WorkerClient extends base_1.BaseClient {
                 break;
             case 'WORKER_ALREADY_EXISTS_RESHARDING':
                 {
-                    this.postMessage({
+                    await this.postMessage({
                         type: 'WORKER_START_RESHARDING',
                         workerId: workerData.workerId,
                     });
@@ -341,7 +355,7 @@ class WorkerClient extends base_1.BaseClient {
                     for (const i of this.shards.values()) {
                         await i.disconnect(websocket_1.ShardSocketCloseCodes.Resharding);
                     }
-                    this.postMessage({
+                    await this.postMessage({
                         type: 'DISCONNECTED_ALL_SHARDS_RESHARDING',
                         workerId: workerData.workerId,
                     });
@@ -407,17 +421,31 @@ class WorkerClient extends base_1.BaseClient {
             this.promises.set(nonce, { resolve: res, timeout });
         });
     }
-    tellWorker(workerId, func, vars) {
+    async sendRequest(nonce, operation, send) {
+        const response = this.generateSendPromise(nonce, operation);
+        try {
+            const [result] = await Promise.all([response, send()]);
+            return result;
+        }
+        catch (error) {
+            const pending = this.promises.get(nonce);
+            if (pending) {
+                this.promises.delete(nonce);
+                clearTimeout(pending.timeout);
+            }
+            throw error;
+        }
+    }
+    async tellWorker(workerId, func, vars) {
         const nonce = this.generateNonce();
-        this.postMessage({
+        return this.sendRequest(nonce, 'Worker request', () => this.postMessage({
             type: 'EVAL_TO_WORKER',
             func: func.toString(),
             toWorkerId: workerId,
             workerId: workerData.workerId,
             nonce,
             vars: JSON.stringify(vars),
-        });
-        return this.generateSendPromise(nonce);
+        }));
     }
     tellWorkers(func, vars) {
         const promises = [];
@@ -446,13 +474,18 @@ class WorkerClient extends base_1.BaseClient {
             async handlePayload(shardId, payload) {
                 await handlePayload?.(shardId, payload);
                 const pluginPacket = await onPacket(payload, shardId);
-                if (self.options.sendPayloadToParent && pluginPacket !== null)
-                    self.postMessage({
+                if (self.options.sendPayloadToParent && pluginPacket !== null) {
+                    void self
+                        .postMessage({
                         workerId: workerData.workerId,
                         shardId,
                         type: 'RECEIVE_PAYLOAD',
                         payload: pluginPacket,
+                    })
+                        .catch(error => {
+                        self.logger.error('Failed to send RECEIVE_PAYLOAD to the worker manager', error);
                     });
+                }
             },
         });
         return shard;
@@ -522,9 +555,11 @@ class WorkerClient extends base_1.BaseClient {
                         this.applicationId = packet.d.application.id;
                         this.me = transformers_1.Transformers.ClientUser(this, packet.d.user, packet.d.application);
                         if ([...this.shards.values()].every(shard => shard.data.session_id)) {
-                            this.postMessage({
+                            void this.postMessage({
                                 type: 'WORKER_SHARDS_CONNECTED',
                                 workerId: this.workerId,
+                            }).catch(error => {
+                                this.logger.error('Failed to send WORKER_SHARDS_CONNECTED to the worker manager', error);
                             });
                             await this.events.runEvent('WORKER_SHARDS_CONNECTED', this, this.me, -1);
                         }
@@ -535,9 +570,11 @@ class WorkerClient extends base_1.BaseClient {
                     case types_1.GatewayDispatchEvents.GuildsReady:
                         {
                             if ([...this.shards.values()].every(shard => shard.isReady)) {
-                                this.postMessage({
+                                void this.postMessage({
                                     type: 'WORKER_READY',
                                     workerId: this.workerId,
+                                }).catch(error => {
+                                    this.logger.error('Failed to send WORKER_READY to the worker manager', error);
                                 });
                                 await this.events.runEvent('WORKER_READY', this, this.me, -1);
                             }

package/lib/common/it/utils.d.ts

@@ -1,7 +1,9 @@
 import type { Cache } from '../../cache';
 import { type APIPartialEmoji, GatewayIntentBits } from '../../types';
+import type { ColorResolvable, EmojiResolvable } from '../types/resolvables';
+import type { ObjectToLower, ObjectToSnake, TypeArray } from '../types/util';
+import type { Logger } from './logger';
 export { type FakePromiseResult, fakePromise } from './fake-promise';
-import { type ColorResolvable, type EmojiResolvable, type Logger, type ObjectToLower, type ObjectToSnake, type TypeArray } from '..';
 /**
  * Calculates the shard ID for a guild based on its ID.
  * @param guildId The ID of the guild.
@@ -28,6 +30,7 @@ export declare function delay<T>(time: number, result?: T): Promise<T>;
  * @returns `true` if the value is an object, otherwise `false`.
  */
 export declare function isObject(o: any): o is Record<string, unknown>;
+export declare function isPromiseLike<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
 /**
  * Merges multiple options objects together, deeply extending objects.
  * @param defaults The default options object.

package/lib/common/it/utils.js

@@ -5,6 +5,7 @@ exports.calculateShardId = calculateShardId;
 exports.resolveColor = resolveColor;
 exports.delay = delay;
 exports.isObject = isObject;
+exports.isPromiseLike = isPromiseLike;
 exports.MergeOptions = MergeOptions;
 exports.filterSplit = filterSplit;
 exports.toSnakeCase = toSnakeCase;
@@ -24,9 +25,10 @@ exports.assertString = assertString;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const types_1 = require("../../types");
+const constants_1 = require("./constants");
+const error_1 = require("./error");
 var fake_promise_1 = require("./fake-promise");
 Object.defineProperty(exports, "fakePromise", { enumerable: true, get: function () { return fake_promise_1.fakePromise; } });
-const __1 = require("..");
 /**
  * Calculates the shard ID for a guild based on its ID.
  * @param guildId The ID of the guild.
@@ -39,7 +41,7 @@ function calculateShardId(guildId, shards) {
 // It is used for resolve color for better performance
 const ColorLookup = {
     Random: -1, // Special value for random color
-    ...__1.EmbedColors,
+    ...constants_1.EmbedColors,
 };
 /**
  * Resolves the color to a numeric representation.
@@ -50,7 +52,7 @@ function resolveColor(color) {
     const type = typeof color;
     if (type === 'number') {
         if (!Number.isInteger(color) || color < 0)
-            throw new __1.SeyfertError('INTERNAL_ERROR', { metadata: { detail: `Invalid color: ${color}` } });
+            throw new error_1.SeyfertError('INTERNAL_ERROR', { metadata: { detail: `Invalid color: ${color}` } });
         return color;
     }
     if (type === 'string') {
@@ -61,14 +63,14 @@ function resolveColor(color) {
         if (color.startsWith('#')) {
             const hex = color.slice(1);
             if (!/^[\da-f]+$/i.test(hex))
-                throw new __1.SeyfertError('INTERNAL_ERROR', { metadata: { detail: `Invalid color: ${color}` } });
+                throw new error_1.SeyfertError('INTERNAL_ERROR', { metadata: { detail: `Invalid color: ${color}` } });
             return Number.parseInt(hex, 16);
         }
-        return __1.EmbedColors.Default;
+        return constants_1.EmbedColors.Default;
     }
     return Array.isArray(color) && color.length >= 3
         ? (color[0] << 16) | (color[1] << 8) | color[2]
-        : __1.EmbedColors.Default;
+        : constants_1.EmbedColors.Default;
 }
 /**
  * Delays the resolution of a Promise by the specified time.
@@ -87,6 +89,10 @@ function delay(time, result) {
 function isObject(o) {
     return o && typeof o === 'object' && !Array.isArray(o);
 }
+function isPromiseLike(value) {
+    return (((typeof value === 'object' && value !== null) || typeof value === 'function') &&
+        typeof value.then === 'function');
+}
 function isPlainObject(o) {
     if (!o || typeof o !== 'object')
         return false;
@@ -301,7 +307,7 @@ function isCloudflareWorker() {
  * @returns The unix millisecond timestamp.
  */
 function snowflakeToTimestamp(id) {
-    return Number((BigInt(id) >> 22n) + __1.DiscordEpoch);
+    return Number((BigInt(id) >> 22n) + constants_1.DiscordEpoch);
 }
 function resolvePartialEmoji(emoji) {
     if (typeof emoji === 'string') {
@@ -383,6 +389,6 @@ function toBuffer(arrayBuffer) {
 }
 function assertString(value, message) {
     if (!(typeof value === 'string' && value !== '')) {
-        throw new __1.SeyfertError('INTERNAL_ERROR', { metadata: { detail: message ?? 'Value is not a string' } });
+        throw new error_1.SeyfertError('INTERNAL_ERROR', { metadata: { detail: message ?? 'Value is not a string' } });
     }
 }

package/lib/langs/handler.js

@@ -4,9 +4,6 @@ exports.LangsHandler = void 0;
 const node_path_1 = require("node:path");
 const common_1 = require("../common");
 const router_1 = require("./router");
-function isPromiseLike(value) {
-    return !!value && typeof value.then === 'function';
-}
 class LangsHandler extends common_1.BaseHandler {
     values = {};
     __paths = {};
@@ -46,7 +43,7 @@ class LangsHandler extends common_1.BaseHandler {
     parse(file) {
         const oldLocale = file.name.split('.').slice(0, -1).join('.') || file.name;
         const result = this.onFile(oldLocale, file);
-        if (isPromiseLike(result))
+        if ((0, common_1.isPromiseLike)(result))
             return result.then(value => this.applyParsedFile(file, value));
         this.applyParsedFile(file, result);
         return;

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

@@ -1,8 +1,8 @@
-import cluster, { type Worker as ClusterWorker } from 'node:cluster';
+import { type Worker as ClusterWorker } from 'node:cluster';
 import type { Worker as WorkerThreadsWorker } from 'node:worker_threads';
 import { ApiHandler, type CustomWorkerManagerEvents, Logger, type UsingClient, type WorkerClient } from '../..';
 import { type Adapter } from '../../cache';
-import { type Identify, type PickPartial } from '../../common';
+import { type Awaitable, type Identify, type PickPartial } from '../../common';
 import type { GatewayPresenceUpdateData, GatewaySendPayload } from '../../types';
 import { ConnectQueue } from '../structures/timeout';
 import { Heartbeater, type WorkerHeartbeaterMessages } from './heartbeater';
@@ -23,13 +23,18 @@ type WorkerManagerCustomRuntimeOptionalKeys = 'handleWorkerMessage' | 'handlePay
 type WorkerManagerRuntimeOptions = PickPartial<Required<WorkerManagerNativeOptions>, WorkerManagerRuntimeOptionalKeys> | (PickPartial<Required<Omit<WorkerManagerCustomOptions, 'path'>>, WorkerManagerCustomRuntimeOptionalKeys> & {
     path?: string;
 });
-export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerThreadsWorker | {
-    ready?: boolean;
-}) & {
+type WorkerState = {
     ready?: boolean;
     disconnected?: boolean;
     resharded?: boolean;
-}> {
+};
+type CustomWorker = {
+    ready?: boolean;
+} & WorkerState;
+type ManagedWorker = (ClusterWorker | WorkerThreadsWorker | {
+    ready?: boolean;
+}) & WorkerState;
+export declare class WorkerManager extends Map<number, ManagedWorker> {
     static prepareSpaces(options: {
         shardStart: number;
         shardEnd: number;
@@ -38,17 +43,19 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerTh
     options: WorkerManagerRuntimeOptions;
     debugger?: Logger;
     connectQueue: ConnectQueue;
-    workerQueue: (() => void)[];
+    workerQueue: (() => Awaitable<void>)[];
     cacheAdapter: Adapter;
     promises: Map<string, {
         resolve: (value: any) => void;
         timeout: NodeJS.Timeout;
     }>;
     rest: ApiHandler;
-    reshardingWorkerQueue: (() => void)[];
+    reshardingWorkerQueue: (() => Awaitable<void>)[];
     private _info?;
     heartbeater: Heartbeater;
     constructor(options: WorkerManagerConstructorOptions);
+    private reportError;
+    private observe;
     setCache(adapter: Adapter): void;
     setRest(rest: ApiHandler): void;
     get remaining(): number;
@@ -68,19 +75,25 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerTh
     calculateShardId(guildId: string): number;
     private createWorkerNotFoundError;
     calculateWorkerId(shardId: number): number;
-    postMessage(id: number, body: ManagerMessages | WorkerHeartbeaterMessages): void;
+    postMessage(id: number, body: ManagerMessages | WorkerHeartbeaterMessages): Promise<void>;
     prepareWorkers(shards: number[][], rawResharding?: boolean): void;
-    createWorker(workerData: WorkerData): WorkerThreadsWorker | ({
-        ready?: boolean;
-    } & {
-        ready?: boolean;
-        disconnected?: boolean;
-        resharded?: boolean;
-    }) | cluster.Worker;
-    spawn(workerId: number, shardId: number, resharding?: boolean): void;
+    createWorker(workerData: WorkerData & {
+        mode: 'threads';
+    }): WorkerThreadsWorker;
+    createWorker(workerData: WorkerData & {
+        mode: 'clusters';
+    }): ClusterWorker;
+    createWorker(workerData: WorkerData & {
+        mode: 'custom';
+    }): Awaitable<CustomWorker>;
+    createWorker(workerData: WorkerData): Awaitable<ManagedWorker>;
+    private createWorkerAsync;
+    private createWorkerInternal;
+    spawn(workerId: number, shardId: number, resharding?: boolean): Promise<void>;
     handleWorkerMessage(message: WorkerMessages): Promise<void>;
     private generateNonce;
     private generateSendPromise;
+    private sendRequest;
     send(data: GatewaySendPayload, shardId: number): Promise<boolean>;
     private resolveSendPayload;
     getShardInfo(shardId: number): Promise<WorkerShardInfo>;

package/lib/websocket/discord/workermanager.js

@@ -51,7 +51,23 @@ class WorkerManager extends Map {
                 return oldFn(message);
             };
         }
-        this.heartbeater = new heartbeater_1.Heartbeater(this.postMessage.bind(this), options.heartbeaterInterval ?? 15e3);
+        this.heartbeater = new heartbeater_1.Heartbeater((workerId, message) => {
+            this.observe(() => this.postMessage(workerId, message), `[Worker #${workerId}] heartbeat sending failed`);
+        }, options.heartbeaterInterval ?? 15e3);
+    }
+    reportError(message, error) {
+        this.debugger ??= new __1.Logger({ name: '[WorkerManager]' });
+        this.debugger.error(message, error);
+    }
+    observe(operation, message) {
+        try {
+            void Promise.resolve(operation()).catch(error => {
+                this.reportError(message, error);
+            });
+        }
+        catch (error) {
+            this.reportError(message, error);
+        }
     }
     setCache(adapter) {
         this.cacheAdapter = adapter;
@@ -118,21 +134,37 @@ class WorkerManager extends Map {
         }
         return Math.floor((shardId - minimumShardId) / this.shardsPerWorker);
     }
-    postMessage(id, body) {
+    async postMessage(id, body) {
         const worker = this.get(id);
         if (!worker)
-            return this.debugger?.error(`Worker ${id} does not exists.`);
+            throw this.createWorkerNotFoundError(id);
         switch (this.options.mode) {
-            case 'clusters':
-                if (worker.isConnected())
-                    worker.send(body);
-                break;
+            case 'clusters': {
+                const clusterWorker = worker;
+                if (!clusterWorker.isConnected()) {
+                    throw new common_1.SeyfertError('INTERNAL_ERROR', {
+                        metadata: {
+                            workerId: id,
+                            mode: this.options.mode,
+                            detail: `Cannot send to disconnected worker #${id}.`,
+                        },
+                    });
+                }
+                await new Promise((resolve, reject) => {
+                    clusterWorker.send(body, error => {
+                        if (error)
+                            reject(error);
+                        else
+                            resolve();
+                    });
+                });
+                return;
+            }
             case 'threads':
                 worker.postMessage(body);
-                break;
+                return;
             case 'custom':
-                this.options.adapter.postMessage(id, body);
-                break;
+                await this.options.adapter.postMessage(id, body);
         }
     }
     prepareWorkers(shards, rawResharding = false) {
@@ -142,8 +174,8 @@ class WorkerManager extends Map {
                 metadata: { detail: 'Cannot prepare workers without worker_threads.' },
             });
         for (let i = 0; i < shards.length; i++) {
-            const registerWorker = (resharding) => {
-                const worker = this.createWorker({
+            const registerWorker = async (resharding) => {
+                const worker = await this.createWorkerAsync({
                     path: this.options.path ?? '',
                     debug: this.options.debug,
                     token: this.options.token,
@@ -168,25 +200,39 @@ class WorkerManager extends Map {
                 this.heartbeater.register(workerId, deadWorkerId => {
                     this.heartbeater.unregister(deadWorkerId);
                     this.delete(deadWorkerId);
-                    registerWorkerHeartbeat(registerWorker(resharding), resharding);
+                    this.observe(() => registerWorker(resharding).then(newWorkerId => registerWorkerHeartbeat(newWorkerId, resharding)), `[Worker #${deadWorkerId}] replacement failed`);
                 });
             };
             const workerExists = this.has(i);
             if (rawResharding || !workerExists) {
-                this[rawResharding ? 'reshardingWorkerQueue' : 'workerQueue'].push(() => {
-                    registerWorkerHeartbeat(registerWorker(rawResharding), rawResharding);
+                this[rawResharding ? 'reshardingWorkerQueue' : 'workerQueue'].push(async () => {
+                    registerWorkerHeartbeat(await registerWorker(rawResharding), rawResharding);
                 });
             }
         }
     }
     createWorker(workerData) {
+        return this.createWorkerInternal(workerData);
+    }
+    createWorkerAsync(workerData) {
+        return Promise.resolve(this.createWorkerInternal(workerData));
+    }
+    createWorkerInternal(workerData) {
+        if (workerData.mode !== this.options.mode) {
+            throw new common_1.SeyfertError('INTERNAL_ERROR', {
+                metadata: {
+                    workerId: workerData.workerId,
+                    detail: `Worker mode ${workerData.mode} does not match manager mode ${this.options.mode}.`,
+                },
+            });
+        }
         if (this.has(workerData.workerId)) {
+            const worker = this.get(workerData.workerId);
             if (workerData.resharding) {
-                this.postMessage(workerData.workerId, {
+                this.observe(() => this.postMessage(workerData.workerId, {
                     type: 'WORKER_ALREADY_EXISTS_RESHARDING',
-                });
+                }), `[Worker #${workerData.workerId}] resharding restart message sending failed`);
             }
-            const worker = this.get(workerData.workerId);
             return worker;
         }
         const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
@@ -209,7 +255,7 @@ class WorkerManager extends Map {
                 const worker = new worker_threads.Worker(workerData.path, {
                     env: { ...process.env, ...env },
                 });
-                worker.on('message', data => this.handleWorkerMessage(data));
+                worker.on('message', data => this.observe(() => this.handleWorkerMessage(data), `[Worker #${workerData.workerId}] message handling failed`));
                 worker.on('error', err => {
                     this.debugger?.error(`[Worker #${workerData.workerId}]`, err);
                 });
@@ -220,28 +266,46 @@ class WorkerManager extends Map {
                     exec: workerData.path,
                 });
                 const worker = node_cluster_1.default.fork(env);
-                worker.on('message', data => this.handleWorkerMessage(data));
+                worker.on('message', data => this.observe(() => this.handleWorkerMessage(data), `[Worker #${workerData.workerId}] message handling failed`));
                 return worker;
             }
             case 'custom': {
-                this.options.adapter.spawn(workerData, env);
-                return {
+                const worker = {
                     ready: false,
                 };
+                this.set(workerData.workerId, worker);
+                try {
+                    const spawnResult = this.options.adapter.spawn(workerData, env);
+                    if (!(0, common_1.isPromiseLike)(spawnResult))
+                        return worker;
+                    return Promise.resolve(spawnResult).then(() => worker, error => {
+                        if (this.get(workerData.workerId) === worker)
+                            this.delete(workerData.workerId);
+                        throw error;
+                    });
+                }
+                catch (error) {
+                    if (this.get(workerData.workerId) === worker)
+                        this.delete(workerData.workerId);
+                    throw error;
+                }
             }
         }
     }
     spawn(workerId, shardId, resharding = false) {
-        this.connectQueue.push(() => {
-            const worker = this.has(workerId);
-            if (!worker) {
-                this.debugger?.fatal(`Trying ${resharding ? 'reshard' : 'spawn'} with worker that doesn't exist`);
-                return;
-            }
-            this.postMessage(workerId, {
-                type: resharding ? 'ALLOW_CONNECT_RESHARDING' : 'ALLOW_CONNECT',
-                shardId,
-                presence: this.options.presence?.(shardId, workerId),
+        return new Promise((resolve, reject) => {
+            this.connectQueue.push(() => {
+                if (!this.has(workerId)) {
+                    const error = this.createWorkerNotFoundError(workerId);
+                    this.debugger?.fatal(`Trying ${resharding ? 'reshard' : 'spawn'} with worker that doesn't exist`);
+                    reject(error);
+                    return;
+                }
+                void this.postMessage(workerId, {
+                    type: resharding ? 'ALLOW_CONNECT_RESHARDING' : 'ALLOW_CONNECT',
+                    shardId,
+                    presence: this.options.presence?.(shardId, workerId),
+                }).then(resolve, reject);
             });
         });
     }
@@ -255,7 +319,7 @@ class WorkerManager extends Map {
                     this.get(message.workerId).resharded = true;
                     if (!this.reshardingWorkerQueue.length && [...this.values()].every(w => w.resharded)) {
                         for (const [id] of this.entries()) {
-                            this.postMessage(id, {
+                            await this.postMessage(id, {
                                 type: 'DISCONNECT_ALL_SHARDS_RESHARDING',
                             });
                         }
@@ -267,7 +331,7 @@ class WorkerManager extends Map {
                         const nextWorker = this.reshardingWorkerQueue.shift();
                         if (nextWorker) {
                             this.debugger?.info('Spawning next worker to reshard');
-                            nextWorker();
+                            this.observe(nextWorker, 'Resharding worker spawn failed');
                         }
                         else {
                             this.debugger?.info('No more workers to reshard left');
@@ -284,7 +348,7 @@ class WorkerManager extends Map {
                         this.options.workers = this.size;
                         delete this._info;
                         for (const [id] of this.entries()) {
-                            this.postMessage(id, {
+                            await this.postMessage(id, {
                                 type: 'CONNECT_ALL_SHARDS_RESHARDING',
                                 totalShards: this.options.totalShards,
                             });
@@ -297,7 +361,7 @@ class WorkerManager extends Map {
                 break;
             case 'WORKER_START_RESHARDING':
                 {
-                    this.postMessage(message.workerId, {
+                    await this.postMessage(message.workerId, {
                         type: 'SPAWN_SHARDS_RESHARDING',
                         compress: this.options.compress ?? false,
                         info: {
@@ -313,7 +377,7 @@ class WorkerManager extends Map {
                 break;
             case 'WORKER_START':
                 {
-                    this.postMessage(message.workerId, {
+                    await this.postMessage(message.workerId, {
                         type: 'SPAWN_SHARDS',
                         compress: this.options.compress ?? false,
                         info: {
@@ -328,10 +392,10 @@ class WorkerManager extends Map {
                 }
                 break;
             case 'CONNECT_QUEUE_RESHARDING':
-                this.spawn(message.workerId, message.shardId, true);
+                this.observe(() => this.spawn(message.workerId, message.shardId, true), `[Worker #${message.workerId}] resharding shard connection failed`);
                 break;
             case 'CONNECT_QUEUE':
-                this.spawn(message.workerId, message.shardId);
+                await this.spawn(message.workerId, message.shardId);
                 break;
             case 'CACHE_REQUEST':
                 {
@@ -350,7 +414,7 @@ class WorkerManager extends Map {
                     catch (error) {
                         response = { type: 'CACHE_RESULT', nonce: message.nonce, error: (0, worker_errors_1.serializeWorkerError)(error) };
                     }
-                    this.postMessage(message.workerId, response);
+                    await this.postMessage(message.workerId, response);
                 }
                 break;
             case 'RECEIVE_PAYLOAD':
@@ -395,7 +459,7 @@ class WorkerManager extends Map {
                 {
                     this.get(message.workerId).ready = true;
                     if (this.size === this.totalWorkers && [...this.values()].every(w => w.ready)) {
-                        this.postMessage(this.keys().next().value, {
+                        await this.postMessage(this.keys().next().value, {
                             type: 'BOT_READY',
                         });
                         this.forEach(w => {
@@ -409,7 +473,7 @@ class WorkerManager extends Map {
                     const nextWorker = this.workerQueue.shift();
                     if (nextWorker) {
                         this.debugger?.info('Spawning next worker');
-                        nextWorker();
+                        await nextWorker();
                     }
                     else {
                         this.debugger?.info('No more workers to spawn left');
@@ -429,7 +493,7 @@ class WorkerManager extends Map {
                     const response = await this.rest.request(message.method, message.url, message.requestOptions);
                     const encodedResponse = response instanceof ArrayBuffer ? Array.from(new Uint8Array(response)) : response;
                     const responseType = response instanceof ArrayBuffer ? 'arrayBuffer' : undefined;
-                    this.postMessage(message.workerId, {
+                    await this.postMessage(message.workerId, {
                         nonce: message.nonce,
                         response: encodedResponse,
                         responseType,
@@ -452,18 +516,18 @@ class WorkerManager extends Map {
             case 'EVAL_TO_WORKER':
                 {
                     const nonce = this.generateNonce();
-                    this.postMessage(message.toWorkerId, {
+                    const response = await this.sendRequest(nonce, 'Worker evaluation', () => this.postMessage(message.toWorkerId, {
                         nonce,
                         func: message.func,
                         type: 'EXECUTE_EVAL_TO_WORKER',
                         toWorkerId: message.toWorkerId,
                         vars: message.vars,
-                    });
-                    this.generateSendPromise(nonce, 'Worker evaluation').then(val => this.postMessage(message.workerId, {
+                    }));
+                    await this.postMessage(message.workerId, {
                         nonce: message.nonce,
-                        response: val,
+                        response,
                         type: 'EVAL_RESPONSE',
-                    }));
+                    });
                 }
                 break;
         }
@@ -485,6 +549,21 @@ class WorkerManager extends Map {
             this.promises.set(nonce, { resolve: res, timeout });
         });
     }
+    async sendRequest(nonce, operation, send) {
+        const response = this.generateSendPromise(nonce, operation);
+        try {
+            const [result] = await Promise.all([response, send()]);
+            return result;
+        }
+        catch (error) {
+            const pending = this.promises.get(nonce);
+            if (pending) {
+                this.promises.delete(nonce);
+                clearTimeout(pending.timeout);
+            }
+            throw error;
+        }
+    }
     async send(data, shardId) {
         const workerId = this.calculateWorkerId(shardId);
         const worker = this.has(workerId);
@@ -495,13 +574,12 @@ class WorkerManager extends Map {
         if (!payload)
             return false;
         const nonce = this.generateNonce();
-        this.postMessage(workerId, {
+        return this.sendRequest(nonce, 'Shard payload send', () => this.postMessage(workerId, {
             type: 'SEND_PAYLOAD',
             shardId,
             nonce,
             ...payload,
-        });
-        return this.generateSendPromise(nonce, 'Shard payload send');
+        }));
     }
     async resolveSendPayload(shardId, payload) {
         const result = await this.options.handleSendPayload?.(shardId, payload);
@@ -516,8 +594,7 @@ class WorkerManager extends Map {
             throw this.createWorkerNotFoundError(workerId);
         }
         const nonce = this.generateNonce();
-        this.postMessage(workerId, { shardId, nonce, type: 'SHARD_INFO' });
-        return this.generateSendPromise(nonce, 'Shard info request');
+        return this.sendRequest(nonce, 'Shard info request', () => this.postMessage(workerId, { shardId, nonce, type: 'SHARD_INFO' }));
     }
     async getWorkerInfo(workerId) {
         const worker = this.has(workerId);
@@ -525,18 +602,16 @@ class WorkerManager extends Map {
             throw this.createWorkerNotFoundError(workerId);
         }
         const nonce = this.generateNonce();
-        this.postMessage(workerId, { nonce, type: 'WORKER_INFO' });
-        return this.generateSendPromise(nonce, 'Worker info request');
+        return this.sendRequest(nonce, 'Worker info request', () => this.postMessage(workerId, { nonce, type: 'WORKER_INFO' }));
     }
-    tellWorker(workerId, func, vars) {
+    async tellWorker(workerId, func, vars) {
         const nonce = this.generateNonce();
-        this.postMessage(workerId, {
+        return this.sendRequest(nonce, 'Worker request', () => this.postMessage(workerId, {
             type: 'EXECUTE_EVAL',
             func: func.toString(),
             nonce,
             vars: JSON.stringify(vars),
-        });
-        return this.generateSendPromise(nonce);
+        }));
     }
     tellWorkers(func, vars) {
         const promises = [];
@@ -583,7 +658,7 @@ class WorkerManager extends Map {
         }, this.debugger);
         this.prepareWorkers(spaces);
         // Start workers queue
-        this.workerQueue.shift()();
+        await this.workerQueue.shift()();
         await this.startResharding();
     }
     async startResharding() {
@@ -610,7 +685,9 @@ class WorkerManager extends Map {
                 shardStart: 0,
             }, this.debugger);
             this.prepareWorkers(spaces, true);
-            return this.reshardingWorkerQueue.shift()();
+            const firstWorker = this.reshardingWorkerQueue.shift();
+            if (firstWorker)
+                this.observe(firstWorker, 'Resharding worker spawn failed');
         }, this.options.resharding.interval);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "seyfert",
-	"version": "5.1.0",
+	"version": "5.1.1-dev-34481657717.0",
 	"description": "The most advanced framework for discord bots",
 	"packageManager": "pnpm@11.11.0",
 	"workspaces": [