@open-core/framework 1.0.2-beta.1 → 1.0.4-beta.1

package/dist/client/services/spawn.service.js

@@ -0,0 +1,261 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpawnService = void 0;
+const tsyringe_1 = require("tsyringe");
+const shared_1 = require("../../shared");
+const appearance_service_1 = require("./appearance.service");
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const NETWORK_TIMEOUT_MS = 15000;
+const PED_TIMEOUT_MS = 10000;
+const COLLISION_TIMEOUT_MS = 7000;
+/**
+ * Handles all player spawning logic on the client.
+ *
+ * This service manages the complete lifecycle of a player spawn:
+ * - Waiting for the network session
+ * - Loading and applying the player model
+ * - Ensuring collision and world data is ready
+ * - Resurrecting the player cleanly
+ * - Applying default ped components for freemode models
+ * - Fading the screen in/out during transitions
+ *
+ * The service is designed to be robust, predictable, and safe for any gamemode.
+ */
+let SpawnService = class SpawnService {
+    constructor(appearanceService) {
+        this.appearanceService = appearanceService;
+        this.spawned = false;
+        this.spawning = false;
+    }
+    async init() {
+        shared_1.loggers.spawn.debug('SpawnService initialized');
+    }
+    /**
+     * Performs the first spawn of the player.
+     *
+     * This method handles:
+     * - Fade out
+     * - Closing loading screens
+     * - Setting the player model
+     * - Ensuring the ped exists
+     * - Ensuring collision is loaded
+     * - Resurrecting the player
+     * - Preparing the ped for gameplay
+     * - Placing the player at the desired position
+     * - Fade in
+     *
+     * It should only be called once when the player joins.
+     */
+    async spawn(position, model, heading = 0.0, options) {
+        if (this.spawning) {
+            shared_1.loggers.spawn.warn('Spawn requested while a spawn is already in progress');
+            return;
+        }
+        this.spawning = true;
+        try {
+            await this.ensureNetworkReady();
+            if (!IsScreenFadedOut() && !IsScreenFadingOut()) {
+                DoScreenFadeOut(500);
+                while (!IsScreenFadedOut()) {
+                    await delay(0);
+                }
+            }
+            this.closeLoadingScreens();
+            await this.setPlayerModel(model);
+            const ped = await this.ensurePed();
+            await this.applyAppearanceIfNeeded(ped, options === null || options === void 0 ? void 0 : options.appearance);
+            await this.ensureCollisionAt(position, ped);
+            NetworkResurrectLocalPlayer(position.x, position.y, position.z, heading, 0, false);
+            const finalPed = await this.ensurePed();
+            await this.setupPedForGameplay(finalPed);
+            await this.placePed(finalPed, position, heading);
+            this.spawned = true;
+            if (!IsScreenFadedIn() && !IsScreenFadingIn()) {
+                DoScreenFadeIn(500);
+            }
+            shared_1.loggers.spawn.info('Player spawned successfully (first spawn)', {
+                position: { x: position.x, y: position.y, z: position.z },
+                model,
+            });
+        }
+        catch (err) {
+            shared_1.loggers.spawn.error('Failed to spawn player', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
+        finally {
+            this.spawning = false;
+        }
+    }
+    /**
+     * Teleports the player instantly to a new position.
+     * Does not change the model or resurrect the player.
+     * Safe for gameplay use.
+     */
+    async teleportTo(position, heading) {
+        const ped = await this.ensurePed();
+        await this.ensureCollisionAt(position, ped);
+        FreezeEntityPosition(ped, true);
+        SetEntityCoordsNoOffset(ped, position.x, position.y, position.z, false, false, false);
+        if (heading !== undefined) {
+            SetEntityHeading(ped, heading);
+        }
+        FreezeEntityPosition(ped, false);
+        shared_1.loggers.spawn.debug('Teleported', {
+            position: { x: position.x, y: position.y, z: position.z },
+            heading,
+        });
+    }
+    /**
+     * Respawns the player after death or a gameplay event.
+     * Restores health, resurrects the player, loads collision,
+     * prepares the ped and teleports them to the desired location.
+     */
+    async respawn(position, heading = 0.0) {
+        const ped = await this.ensurePed();
+        await this.ensureCollisionAt(position, ped);
+        ClearPedTasksImmediately(ped);
+        SetEntityHealth(ped, GetEntityMaxHealth(ped));
+        NetworkResurrectLocalPlayer(position.x, position.y, position.z, heading, 0, false);
+        const finalPed = await this.ensurePed();
+        await this.setupPedForGameplay(finalPed);
+        await this.teleportTo(position, heading);
+        shared_1.loggers.spawn.info('Player respawned', {
+            position: { x: position.x, y: position.y, z: position.z },
+            heading,
+        });
+    }
+    /**
+     * Returns whether the player has completed their first spawn.
+     */
+    isSpawned() {
+        return this.spawned;
+    }
+    /**
+     * Allows other systems to wait until the player is fully spawned.
+     */
+    async waitUntilSpawned() {
+        while (!this.spawned) {
+            await delay(0);
+        }
+    }
+    async ensureNetworkReady() {
+        const start = GetGameTimer();
+        while (!NetworkIsSessionStarted()) {
+            if (GetGameTimer() - start > NETWORK_TIMEOUT_MS) {
+                shared_1.loggers.spawn.error('Network session did not start in time');
+                throw new Error('NETWORK_TIMEOUT');
+            }
+            await delay(0);
+        }
+    }
+    closeLoadingScreens() {
+        try {
+            ShutdownLoadingScreen();
+        }
+        catch (_a) { }
+        try {
+            ShutdownLoadingScreenNui();
+        }
+        catch (_b) { }
+    }
+    async setPlayerModel(model) {
+        const modelHash = GetHashKey(model);
+        if (!IsModelInCdimage(modelHash) || !IsModelValid(modelHash)) {
+            shared_1.loggers.spawn.error('Invalid model requested', { model });
+            throw new Error('MODEL_INVALID');
+        }
+        RequestModel(modelHash);
+        while (!HasModelLoaded(modelHash)) {
+            await delay(0);
+        }
+        SetPlayerModel(PlayerId(), modelHash);
+        SetModelAsNoLongerNeeded(modelHash);
+        const ped = PlayerPedId();
+        if (ped !== 0) {
+            SetPedDefaultComponentVariation(ped);
+        }
+        shared_1.loggers.spawn.debug('Player model set', { model, modelHash });
+    }
+    async ensurePed() {
+        const start = GetGameTimer();
+        let ped = PlayerPedId();
+        while (ped === 0) {
+            if (GetGameTimer() - start > PED_TIMEOUT_MS) {
+                shared_1.loggers.spawn.error('PlayerPedId() did not become valid in time');
+                throw new Error('PED_TIMEOUT');
+            }
+            await delay(0);
+            ped = PlayerPedId();
+        }
+        return ped;
+    }
+    async ensureCollisionAt(position, ped) {
+        RequestCollisionAtCoord(position.x, position.y, position.z);
+        const start = GetGameTimer();
+        while (!HasCollisionLoadedAroundEntity(ped)) {
+            if (GetGameTimer() - start > COLLISION_TIMEOUT_MS) {
+                shared_1.loggers.spawn.warn('Collision did not fully load around entity in time', {
+                    x: position.x,
+                    y: position.y,
+                    z: position.z,
+                });
+                break;
+            }
+            await delay(0);
+        }
+    }
+    async setupPedForGameplay(ped) {
+        SetEntityAsMissionEntity(ped, true, true);
+        ClearPedTasksImmediately(ped);
+        RemoveAllPedWeapons(ped, true);
+        ResetEntityAlpha(ped);
+        await delay(0);
+        SetEntityAlpha(ped, 255, false);
+        SetEntityVisible(ped, true, false);
+        SetEntityCollision(ped, true, true);
+        SetEntityInvincible(ped, false);
+        shared_1.loggers.spawn.debug('Ped prepared for gameplay', { ped });
+    }
+    async placePed(ped, position, heading) {
+        FreezeEntityPosition(ped, true);
+        SetEntityCoordsNoOffset(ped, position.x, position.y, position.z, false, false, false);
+        SetEntityHeading(ped, heading);
+        await delay(0);
+        FreezeEntityPosition(ped, false);
+    }
+    async applyAppearanceIfNeeded(ped, appearance) {
+        if (!appearance) {
+            SetPedDefaultComponentVariation(ped);
+            return;
+        }
+        if (!this.appearanceService.validateAppearance(appearance)) {
+            SetPedDefaultComponentVariation(ped);
+            return;
+        }
+        try {
+            await this.appearanceService.applyAppearance(ped, appearance);
+        }
+        catch (error) {
+            shared_1.loggers.spawn.error('Failed to apply appearance, using default variation', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            SetPedDefaultComponentVariation(ped);
+        }
+    }
+};
+exports.SpawnService = SpawnService;
+exports.SpawnService = SpawnService = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __metadata("design:paramtypes", [appearance_service_1.AppearanceService])
+], SpawnService);

package/dist/client/services/{ui/textui.service.d.ts → textui.service.d.ts}

@@ -1,4 +1,4 @@
-import type { Vector3 } from '../../../utils';
+import type { Vector3 } from '../../utils';
 export interface TextUIOptions {
     /** Font (0-8) */
     font?: number;

package/dist/client/services/{world/vehicle.service.d.ts → vehicle.service.d.ts}

@@ -1,4 +1,4 @@
-import type { Vector3 } from '../../../utils';
+import type { Vector3 } from '../../utils';
 export interface VehicleSpawnOptions {
     /** Model name or hash */
     model: string;

package/dist/client/system/processors/export.processor.js

@@ -18,7 +18,7 @@ let ClientExportProcessor = class ClientExportProcessor {
     process(target, methodName, metadata) {
         const handler = target[methodName].bind(target);
         const handlerName = `${target.constructor.name}.${methodName}`;
-        exports(metadata.exportName, async (...args) => {
+        globalThis.exports(metadata.exportName, async (...args) => {
             try {
                 return await handler(...args);
             }

package/dist/index.d.ts

@@ -3,5 +3,3 @@ export * as Utils from './utils';
 export * as Shared from './shared';
 export * as Server from './server';
 export * as Client from './client';
-export { LoggerService, LogLevel, LogDomain } from './shared/logger';
-export type { LogTransport, LogContext, LogEntry, LoggerConfig } from './shared/logger';

package/dist/index.js

@@ -33,14 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogDomain = exports.LogLevel = exports.LoggerService = exports.Client = exports.Server = exports.Shared = exports.Utils = void 0;
+exports.Client = exports.Server = exports.Shared = exports.Utils = void 0;
 require("reflect-metadata");
 exports.Utils = __importStar(require("./utils"));
 exports.Shared = __importStar(require("./shared"));
 exports.Server = __importStar(require("./server"));
 exports.Client = __importStar(require("./client"));
-// Re-export logger at root level for convenience
-var logger_1 = require("./shared/logger");
-Object.defineProperty(exports, "LoggerService", { enumerable: true, get: function () { return logger_1.LoggerService; } });
-Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_1.LogLevel; } });
-Object.defineProperty(exports, "LogDomain", { enumerable: true, get: function () { return logger_1.LogDomain; } });

package/dist/server/controllers/session.controller.d.ts

@@ -0,0 +1,9 @@
+import { PlayerService } from '../services';
+import { PlayerPersistenceService } from '../services/persistence.service';
+export declare class SessionController {
+    private readonly playerManager;
+    private readonly persistance;
+    constructor(playerManager: PlayerService, persistance: PlayerPersistenceService);
+    onPlayerJoining(): Promise<void>;
+    onPlayerDropped(): Promise<void>;
+}

package/dist/server/controllers/session.controller.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionController = void 0;
+const shared_1 = require("../../shared");
+const core_event_bus_1 = require("../bus/core-event-bus");
+const decorators_1 = require("../decorators");
+const onFiveMEvent_1 = require("../decorators/onFiveMEvent");
+const services_1 = require("../services");
+const persistence_service_1 = require("../services/persistence.service");
+let SessionController = class SessionController {
+    constructor(playerManager, persistance) {
+        this.playerManager = playerManager;
+        this.persistance = persistance;
+    }
+    async onPlayerJoining() {
+        var _a;
+        const clientId = source;
+        const license = (_a = GetPlayerIdentifier(clientId.toString(), 0)) !== null && _a !== void 0 ? _a : undefined;
+        const player = this.playerManager.bind(clientId, { license });
+        shared_1.loggers.session.info(`Player session created`, {
+            clientId,
+            license: license !== null && license !== void 0 ? license : 'none',
+        });
+        await this.persistance.handleSessionLoad(player);
+        (0, core_event_bus_1.emitCoreEvent)('core:playerSessionCreated', { clientId, license });
+        setImmediate(() => {
+            const currentPlayer = this.playerManager.getByClient(clientId);
+            if (!currentPlayer)
+                return;
+            (0, core_event_bus_1.emitCoreEvent)('core:playerFullyConnected', { clientId, license });
+        });
+    }
+    async onPlayerDropped() {
+        const clientId = Number(source);
+        const player = this.playerManager.getByClient(clientId);
+        if (player) {
+            await this.persistance.handleSessionSave(player);
+        }
+        this.playerManager.unbindByClient(clientId);
+        (0, core_event_bus_1.emitCoreEvent)('core:playerSessionDestroyed', { clientId });
+        shared_1.loggers.session.info(`Player session destroyed`, { clientId });
+    }
+};
+exports.SessionController = SessionController;
+__decorate([
+    (0, onFiveMEvent_1.OnFiveMEvent)('playerJoining'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SessionController.prototype, "onPlayerJoining", null);
+__decorate([
+    (0, onFiveMEvent_1.OnFiveMEvent)('playerDropped'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SessionController.prototype, "onPlayerDropped", null);
+exports.SessionController = SessionController = __decorate([
+    (0, decorators_1.Controller)(),
+    __metadata("design:paramtypes", [services_1.PlayerService,
+        persistence_service_1.PlayerPersistenceService])
+], SessionController);

package/dist/server/database/adapters/oxmysql.adapter.js

@@ -15,7 +15,7 @@ const database_contract_1 = require("../database.contract");
  * Get the oxmysql export from FiveM
  */
 function getOxMySQL() {
-    const ox = global.exports['oxmysql'];
+    const ox = exports['oxmysql'];
     if (!ox) {
         throw new Error('[OpenCore] oxmysql is not available. Make sure oxmysql resource is started before your resource.');
     }

package/dist/server/decorators/index.d.ts

@@ -1,7 +1,7 @@
 export * from './bind';
 export * from './utils';
 export { Command, CommandConfig } from './command';
-export * from './coreEvent';
+export * from './onFrameworkEvent';
 export * from './onNet';
 export * from './onTick';
 export { Controller } from './controller';

package/dist/server/decorators/index.js

@@ -19,7 +19,7 @@ __exportStar(require("./bind"), exports);
 __exportStar(require("./utils"), exports);
 var command_1 = require("./command");
 Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
-__exportStar(require("./coreEvent"), exports);
+__exportStar(require("./onFrameworkEvent"), exports);
 __exportStar(require("./onNet"), exports);
 __exportStar(require("./onTick"), exports);
 var controller_1 = require("./controller");

package/dist/server/decorators/onFiveMEvent.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Listen to FiveM events server-side, check the list below
+ *
+ * https://docs.fivem.net/docs/scripting-reference/events/server-events/
+ */
+export declare function OnFiveMEvent(event: string): (target: any, propertyKey: string) => void;

package/dist/server/decorators/onFiveMEvent.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnFiveMEvent = OnFiveMEvent;
+const metadata_server_keys_1 = require("../system/metadata-server.keys");
+/**
+ * Listen to FiveM events server-side, check the list below
+ *
+ * https://docs.fivem.net/docs/scripting-reference/events/server-events/
+ */
+function OnFiveMEvent(event) {
+    return (target, propertyKey) => {
+        Reflect.defineMetadata(metadata_server_keys_1.METADATA_KEYS.FIVEM_EVENT, { event }, target, propertyKey);
+    };
+}

package/dist/server/decorators/{coreEvent.d.ts → onFrameworkEvent.d.ts}

@@ -12,11 +12,11 @@ import type { CoreEventMap } from '../types/core-events';
  * @Server.Controller()
  * export class SystemController {
  *
- *   @OnCoreEvent('server:ready')
+ *   @OnFrameworkEvent('server:ready')
  *   public onServerStart() {
  *     console.log('OpenCore Framework is ready!')
  *   }
  * }
  * ```
  */
-export declare function OnCoreEvent<K extends keyof CoreEventMap>(event: K): (target: any, propertyKey: string) => void;
+export declare function OnFrameworkEvent<K extends keyof CoreEventMap>(event: K): (target: any, propertyKey: string) => void;

package/dist/server/decorators/{coreEvent.js → onFrameworkEvent.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnCoreEvent = OnCoreEvent;
+exports.OnFrameworkEvent = OnFrameworkEvent;
 const metadata_server_keys_1 = require("../system/metadata-server.keys");
 /**
  * Method decorator used to register a method as a listener for an internal OpenCore framework event.
@@ -15,14 +15,14 @@ const metadata_server_keys_1 = require("../system/metadata-server.keys");
  * @Server.Controller()
  * export class SystemController {
  *
- *   @OnCoreEvent('server:ready')
+ *   @OnFrameworkEvent('server:ready')
  *   public onServerStart() {
  *     console.log('OpenCore Framework is ready!')
  *   }
  * }
  * ```
  */
-function OnCoreEvent(event) {
+function OnFrameworkEvent(event) {
     return (target, propertyKey) => {
         Reflect.defineMetadata(metadata_server_keys_1.METADATA_KEYS.CORE_EVENT, { event }, target, propertyKey);
     };

package/dist/server/entities/player.js

@@ -95,7 +95,7 @@ class Player {
      * @param vector - The target coordinates (x, y, z).
      */
     teleportClient(vector) {
-        this.emit('core:spawner:teleport', vector);
+        this.emit('opencore:spawner:teleport', vector);
     }
     /**
      * Disconnects the player from the server.

package/dist/server/helpers/resolve-method.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveMethod(instance: Record<string, any>, methodName: string, errorMessage: string): {
+    handler: Function;
+    handlerName: string;
+    proto: any;
+} | undefined;

package/dist/server/helpers/resolve-method.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMethod = resolveMethod;
+const logger_1 = require("../../shared/logger");
+function resolveMethod(instance, methodName, errorMessage) {
+    const proto = Object.getPrototypeOf(instance);
+    const method = instance[methodName];
+    if (typeof method !== 'function') {
+        logger_1.loggers.scanner.error(errorMessage, {
+            className: instance.constructor.name,
+            methodName,
+        });
+        return;
+    }
+    const handler = method.bind(instance);
+    const handlerName = `${instance.constructor.name}.${methodName}`;
+    return { handler, handlerName, proto };
+}

package/dist/server/index.js

@@ -27,3 +27,5 @@ __exportStar(require("./setup"), exports);
 // Controllers
 require("./controllers/command.controller");
 require("./controllers/chat.controller");
+const container_1 = require("./container");
+globalThis.oc_container = container_1.di;

package/dist/server/loaders/playerSession.loader.js

@@ -11,9 +11,9 @@ const playerSessionLoader = () => {
     const persistenceService = tsyringe_1.container.resolve(persistence_service_1.PlayerPersistenceService);
     // Initialize persistence service (resolves provider if configured)
     persistenceService.initialize();
-    on('playerJoining', async (source) => {
+    on('playerJoining', async () => {
         var _a;
-        const clientId = Number(source);
+        const clientId = source;
         const license = (_a = GetPlayerIdentifier(clientId.toString(), 0)) !== null && _a !== void 0 ? _a : undefined;
         const player = playerManager.bind(clientId, { license });
         logger_1.loggers.session.info(`Player session created`, {
@@ -26,9 +26,18 @@ const playerSessionLoader = () => {
             clientId,
             license,
         });
+        setImmediate(() => {
+            const currentPlayer = playerManager.getByClient(clientId);
+            if (!currentPlayer)
+                return;
+            (0, core_event_bus_1.emitCoreEvent)('core:playerFullyConnected', {
+                clientId,
+                license,
+            });
+        });
     });
-    on('playerDropped', async () => {
-        const clientId = Number(global.source);
+    on('playerDropped', async (source) => {
+        const clientId = Number(source);
         const player = playerManager.getByClient(clientId);
         // Save player data before destroying session
         if (player) {

package/dist/server/system/metadata-server.keys.d.ts

@@ -4,6 +4,7 @@ export declare const METADATA_KEYS: {
     NET_EVENT: string;
     TICK: string;
     CORE_EVENT: string;
+    FIVEM_EVENT: string;
     EXPORT: string;
     PUBLIC: string;
 };

package/dist/server/system/metadata-server.keys.js

@@ -7,6 +7,7 @@ exports.METADATA_KEYS = {
     NET_EVENT: 'core:meta:net_event',
     TICK: 'core:meta:tick',
     CORE_EVENT: 'core:meta:core_event',
+    FIVEM_EVENT: 'core:meta:fivem_event',
     EXPORT: 'core:meta:export',
     PUBLIC: 'core:meta:public',
 };

package/dist/server/system/processors/coreEvent.processor.d.ts

@@ -1,7 +1,7 @@
 import { DecoratorProcessor } from '../../../system/decorator-processor';
 export declare class CoreEventProcessor implements DecoratorProcessor {
     readonly metadataKey: string;
-    process(target: any, methodName: string, metadata: {
+    process(instance: any, methodName: string, metadata: {
         event: string;
     }): void;
 }

package/dist/server/system/processors/coreEvent.processor.js

@@ -11,13 +11,16 @@ const tsyringe_1 = require("tsyringe");
 const core_event_bus_1 = require("../../bus/core-event-bus");
 const metadata_server_keys_1 = require("../metadata-server.keys");
 const logger_1 = require("../../../shared/logger");
+const resolve_method_1 = require("../../helpers/resolve-method");
 let CoreEventProcessor = class CoreEventProcessor {
     constructor() {
         this.metadataKey = metadata_server_keys_1.METADATA_KEYS.CORE_EVENT;
     }
-    process(target, methodName, metadata) {
-        const handler = target[methodName].bind(target);
-        const handlerName = `${target.constructor.name}.${methodName}`;
+    process(instance, methodName, metadata) {
+        const result = (0, resolve_method_1.resolveMethod)(instance, methodName, `[CoreEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler, handlerName } = result;
         (0, core_event_bus_1.onCoreEvent)(metadata.event, (payload) => {
             try {
                 handler(payload);

package/dist/server/system/processors/export.processor.d.ts

@@ -1,7 +1,7 @@
 import { DecoratorProcessor } from '../../../system/decorator-processor';
 export declare class ExportProcessor implements DecoratorProcessor {
     readonly metadataKey: string;
-    process(target: any, methodName: string, metadata: {
+    process(instance: any, methodName: string, metadata: {
         exportName: string;
     }): void;
 }

package/dist/server/system/processors/export.processor.js

@@ -10,13 +10,17 @@ exports.ExportProcessor = void 0;
 const tsyringe_1 = require("tsyringe");
 const metadata_server_keys_1 = require("../metadata-server.keys");
 const logger_1 = require("../../../shared/logger");
+const resolve_method_1 = require("../../helpers/resolve-method");
 let ExportProcessor = class ExportProcessor {
     constructor() {
         this.metadataKey = metadata_server_keys_1.METADATA_KEYS.EXPORT;
     }
-    process(target, methodName, metadata) {
-        const handler = target[methodName].bind(target);
-        exports(metadata.exportName, handler);
+    process(instance, methodName, metadata) {
+        const result = (0, resolve_method_1.resolveMethod)(instance, methodName, `[ExportEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler } = result;
+        globalThis.exports(metadata.exportName, handler);
         logger_1.loggers.exports.debug(`Registered: ${metadata.exportName}`);
     }
 };

package/dist/server/system/processors/fivemEvent.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class FiveMEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(instance: any, methodName: string, metadata: {
+        event: string;
+    }): void;
+}