@open-core/framework 0.1.0-alpha.1 → 0.2.1-beta.1

package/dist/runtime/server/services/vehicle.service.js

@@ -0,0 +1,361 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VehicleService = void 0;
+const tsyringe_1 = require("tsyringe");
+const IEntityServer_1 = require("../../../adapters/contracts/IEntityServer");
+const IHasher_1 = require("../../../adapters/contracts/IHasher");
+const INetTransport_1 = require("../../../adapters/contracts/INetTransport");
+const IPlayerServer_1 = require("../../../adapters/contracts/IPlayerServer");
+const IVehicleServer_1 = require("../../../adapters/contracts/IVehicleServer");
+const logger_1 = require("../../../kernel/shared/logger");
+const vehicle_1 = require("../entities/vehicle");
+const player_directory_port_1 = require("./ports/player-directory.port");
+/**
+ * Server-side service for managing vehicle entities.
+ *
+ * This service is the central authority for all vehicle operations:
+ * - Creating vehicles server-side (prevents client-side spawning abuse)
+ * - Managing vehicle registry by Network ID
+ * - Validating permissions and positions
+ * - Synchronizing vehicle state across clients
+ *
+ * @remarks
+ * All vehicle creation MUST go through this service to ensure security.
+ * Uses CreateVehicleServerSetter for server-authoritative spawning.
+ */
+let VehicleService = class VehicleService {
+    constructor(playerDirectory, entityServer, vehicleServer, hasher, playerServer, netTransport) {
+        this.playerDirectory = playerDirectory;
+        this.entityServer = entityServer;
+        this.vehicleServer = vehicleServer;
+        this.hasher = hasher;
+        this.playerServer = playerServer;
+        this.netTransport = netTransport;
+        /**
+         * Internal registry of all managed vehicles indexed by Network ID
+         */
+        this.vehiclesByNetworkId = new Map();
+        this.vehicleAdapters = {
+            entityServer: this.entityServer,
+            vehicleServer: this.vehicleServer,
+        };
+    }
+    /**
+     * Creates a new vehicle on the server.
+     *
+     * This method uses CreateVehicleServerSetter to spawn the vehicle server-side,
+     * preventing client-side spawning exploits.
+     *
+     * @param options - Vehicle creation options
+     * @returns Spawn result with network ID and handle
+     */
+    async create(options) {
+        var _a;
+        try {
+            const { model, position, heading = 0, plate, primaryColor, secondaryColor, mods, persistent = false, ownership, metadata, routingBucket = 0, locked = false, fuel = 100.0, } = options;
+            const modelHash = typeof model === 'string' ? this.hasher.getHashKey(model) : model;
+            const vehicleType = 'automobile';
+            const handle = this.vehicleServer.createServerSetter(modelHash, vehicleType, position.x, position.y, position.z, heading);
+            if (!handle || handle === 0) {
+                logger_1.coreLogger.error('Failed to create vehicle', { model, position });
+                return {
+                    networkId: 0,
+                    handle: 0,
+                    success: false,
+                    error: 'Failed to create vehicle entity',
+                };
+            }
+            while (!this.entityServer.doesExist(handle)) {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            }
+            const networkId = this.vehicleServer.getNetworkIdFromEntity(handle);
+            const vehicleOwnership = {
+                clientID: ownership === null || ownership === void 0 ? void 0 : ownership.clientID,
+                accountID: ownership === null || ownership === void 0 ? void 0 : ownership.accountID,
+                type: (_a = ownership === null || ownership === void 0 ? void 0 : ownership.type) !== null && _a !== void 0 ? _a : 'temporary',
+            };
+            const vehicle = new vehicle_1.Vehicle(handle, networkId, vehicleOwnership, this.vehicleAdapters, persistent, routingBucket, model, modelHash);
+            // Server-side operations (these natives work on server)
+            if (plate) {
+                vehicle.setPlate(plate);
+            }
+            if (primaryColor !== undefined || secondaryColor !== undefined) {
+                vehicle.setColors(primaryColor, secondaryColor);
+            }
+            // Mods stored in state bag, applied client-side
+            if (mods) {
+                vehicle.setMods(mods);
+            }
+            if (metadata) {
+                for (const [key, value] of Object.entries(metadata)) {
+                    vehicle.setMetadata(key, value);
+                }
+            }
+            vehicle.setDoorsLocked(locked);
+            vehicle.setFuel(fuel);
+            if (routingBucket !== 0) {
+                vehicle.setRoutingBucket(routingBucket);
+            }
+            this.vehiclesByNetworkId.set(networkId, vehicle);
+            logger_1.coreLogger.info('Vehicle created', {
+                networkId,
+                model,
+                ownership: vehicleOwnership.type,
+                persistent,
+                totalVehicles: this.vehiclesByNetworkId.size,
+            });
+            this.netTransport.emitNet('opencore:vehicle:created', -1, vehicle.serialize());
+            return {
+                networkId,
+                handle,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorInfo = error instanceof Error
+                ? { message: error.message, name: error.name, stack: error.stack }
+                : { message: String(error) };
+            logger_1.coreLogger.error('Error creating vehicle', { error: errorInfo, options });
+            return {
+                networkId: 0,
+                handle: 0,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Creates a vehicle for a specific player.
+     *
+     * @param clientID - Client ID of the requesting player
+     * @param options - Vehicle creation options
+     * @returns Spawn result
+     */
+    async createForPlayer(clientID, options) {
+        const player = this.playerDirectory.getByClient(clientID);
+        if (!player) {
+            return {
+                networkId: 0,
+                handle: 0,
+                success: false,
+                error: 'Player not found',
+            };
+        }
+        const ownership = {
+            clientID,
+            accountID: player.accountID,
+            type: 'player',
+        };
+        const result = await this.create(Object.assign(Object.assign({}, options), { ownership }));
+        if (result.success) {
+            this.netTransport.emitNet('opencore:vehicle:warpInto', clientID, result.networkId, -1);
+        }
+        return result;
+    }
+    /**
+     * Retrieves a vehicle by its Network ID.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @returns Vehicle entity or undefined
+     */
+    getByNetworkId(networkId) {
+        return this.vehiclesByNetworkId.get(networkId);
+    }
+    /**
+     * Retrieves a vehicle by its entity handle.
+     *
+     * @param handle - Entity handle
+     * @returns Vehicle entity or undefined
+     */
+    getByHandle(handle) {
+        const networkId = this.vehicleServer.getNetworkIdFromEntity(handle);
+        return this.vehiclesByNetworkId.get(networkId);
+    }
+    /**
+     * Gets all vehicles owned by a specific player.
+     *
+     * @param clientID - Client ID of the owner
+     * @returns Array of vehicles
+     */
+    getPlayerVehicles(clientID) {
+        const vehicles = [];
+        for (const vehicle of this.vehiclesByNetworkId.values()) {
+            if (vehicle.ownership.clientID === clientID) {
+                vehicles.push(vehicle);
+            }
+        }
+        return vehicles;
+    }
+    /**
+     * Gets all vehicles in a specific routing bucket.
+     *
+     * @param bucket - Routing bucket ID
+     * @returns Array of vehicles
+     */
+    getVehiclesInBucket(bucket) {
+        const vehicles = [];
+        for (const vehicle of this.vehiclesByNetworkId.values()) {
+            if (vehicle.routingBucket === bucket) {
+                vehicles.push(vehicle);
+            }
+        }
+        return vehicles;
+    }
+    /**
+     * Gets all managed vehicles.
+     *
+     * @returns Array of all vehicles
+     */
+    getAll() {
+        return Array.from(this.vehiclesByNetworkId.values());
+    }
+    /**
+     * Deletes a vehicle from the server.
+     *
+     * @param networkId - Network ID of the vehicle to delete
+     * @param requestedBy - Optional client ID for permission validation
+     * @returns Success status
+     */
+    delete(networkId, requestedBy) {
+        const vehicle = this.vehiclesByNetworkId.get(networkId);
+        if (!vehicle) {
+            return false;
+        }
+        if (requestedBy !== undefined) {
+            if (vehicle.ownership.clientID !== requestedBy) {
+                logger_1.coreLogger.warn('Unauthorized vehicle deletion attempt', {
+                    networkId,
+                    requestedBy,
+                    owner: vehicle.ownership.clientID,
+                });
+                return false;
+            }
+        }
+        vehicle.delete();
+        this.vehiclesByNetworkId.delete(networkId);
+        logger_1.coreLogger.info('Vehicle deleted', {
+            networkId,
+            totalVehicles: this.vehiclesByNetworkId.size,
+        });
+        this.netTransport.emitNet('opencore:vehicle:deleted', -1, networkId);
+        return true;
+    }
+    /**
+     * Deletes all vehicles owned by a player.
+     * Useful when a player disconnects.
+     *
+     * @param clientID - Client ID of the owner
+     */
+    deletePlayerVehicles(clientID) {
+        const vehicles = this.getPlayerVehicles(clientID);
+        for (const vehicle of vehicles) {
+            this.delete(vehicle.networkId);
+        }
+    }
+    /**
+     * Validates if a player can perform an action on a vehicle.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param clientID - Client ID of the player
+     * @returns True if authorized
+     */
+    validateOwnership(networkId, clientID) {
+        const vehicle = this.vehiclesByNetworkId.get(networkId);
+        if (!vehicle)
+            return false;
+        if (vehicle.ownership.type === 'server' || vehicle.ownership.type === 'shared') {
+            return true;
+        }
+        return vehicle.ownership.clientID === clientID;
+    }
+    /**
+     * Validates if a player is near a vehicle.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param clientID - Client ID of the player
+     * @param maxDistance - Maximum distance in units
+     * @returns True if within range
+     */
+    validateProximity(networkId, clientID, maxDistance = 10.0) {
+        const vehicle = this.vehiclesByNetworkId.get(networkId);
+        if (!vehicle || !vehicle.exists)
+            return false;
+        const player = this.playerDirectory.getByClient(clientID);
+        if (!player)
+            return false;
+        const playerPed = this.playerServer.getPed(player.clientIDStr);
+        if (!playerPed || playerPed === 0)
+            return false;
+        const playerPos = this.entityServer.getCoords(playerPed);
+        const vehiclePos = vehicle.position;
+        const distance = Math.sqrt((playerPos.x - vehiclePos.x) ** 2 +
+            (playerPos.y - vehiclePos.y) ** 2 +
+            (playerPos.z - vehiclePos.z) ** 2);
+        return distance <= maxDistance;
+    }
+    /**
+     * Cleans up orphaned vehicles that no longer exist.
+     */
+    cleanup() {
+        const toDelete = [];
+        for (const [networkId, vehicle] of this.vehiclesByNetworkId.entries()) {
+            if (!vehicle.exists) {
+                toDelete.push(networkId);
+            }
+        }
+        for (const networkId of toDelete) {
+            this.vehiclesByNetworkId.delete(networkId);
+            logger_1.coreLogger.debug('Cleaned up orphaned vehicle', { networkId });
+        }
+        if (toDelete.length > 0) {
+            logger_1.coreLogger.info('Vehicle cleanup completed', {
+                cleaned: toDelete.length,
+                remaining: this.vehiclesByNetworkId.size,
+            });
+        }
+    }
+    /**
+     * Gets the total count of managed vehicles.
+     *
+     * @returns Vehicle count
+     */
+    getCount() {
+        return this.vehiclesByNetworkId.size;
+    }
+    /**
+     * Serializes all vehicles for data transfer.
+     *
+     * @returns Array of serialized vehicle data
+     */
+    serializeAll() {
+        return Array.from(this.vehiclesByNetworkId.values()).map((v) => v.serialize());
+    }
+};
+exports.VehicleService = VehicleService;
+exports.VehicleService = VehicleService = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(player_directory_port_1.PlayerDirectoryPort)),
+    __param(1, (0, tsyringe_1.inject)(IEntityServer_1.IEntityServer)),
+    __param(2, (0, tsyringe_1.inject)(IVehicleServer_1.IVehicleServer)),
+    __param(3, (0, tsyringe_1.inject)(IHasher_1.IHasher)),
+    __param(4, (0, tsyringe_1.inject)(IPlayerServer_1.IPlayerServer)),
+    __param(5, (0, tsyringe_1.inject)(INetTransport_1.INetTransport)),
+    __metadata("design:paramtypes", [player_directory_port_1.PlayerDirectoryPort,
+        IEntityServer_1.IEntityServer,
+        IVehicleServer_1.IVehicleServer,
+        IHasher_1.IHasher,
+        IPlayerServer_1.IPlayerServer,
+        INetTransport_1.INetTransport])
+], VehicleService);

package/dist/runtime/server/setup.d.ts

@@ -0,0 +1,10 @@
+import { ClassConstructor } from '../../kernel/di/index';
+import { PlayerPersistenceContract, PrincipalProviderContract } from './contracts';
+import { AuthProviderContract } from './contracts/auth-provider.contract';
+import { NetEventSecurityObserverContract } from './contracts/security/net-event-security-observer.contract';
+import { SecurityHandlerContract } from './contracts/security/security-handler.contract';
+export declare function setPrincipalProvider(provider: ClassConstructor<PrincipalProviderContract>): void;
+export declare function setAuthProvider(provider: ClassConstructor<AuthProviderContract>): void;
+export declare function setSecurityHandler(handler: ClassConstructor<SecurityHandlerContract>): void;
+export declare function setPersistenceProvider(provider: ClassConstructor<PlayerPersistenceContract>): void;
+export declare function setNetEventSecurityObserver(observer: ClassConstructor<NetEventSecurityObserverContract>): void;

package/dist/runtime/server/setup.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPrincipalProvider = setPrincipalProvider;
+exports.setAuthProvider = setAuthProvider;
+exports.setSecurityHandler = setSecurityHandler;
+exports.setPersistenceProvider = setPersistenceProvider;
+exports.setNetEventSecurityObserver = setNetEventSecurityObserver;
+const index_1 = require("../../kernel/di/index");
+const logger_1 = require("../../kernel/shared/logger");
+const contracts_1 = require("./contracts");
+const auth_provider_contract_1 = require("./contracts/auth-provider.contract");
+const net_event_security_observer_contract_1 = require("./contracts/security/net-event-security-observer.contract");
+const security_handler_contract_1 = require("./contracts/security/security-handler.contract");
+function setPrincipalProvider(provider) {
+    index_1.di.registerSingleton(contracts_1.PrincipalProviderContract, provider);
+    logger_1.loggers.bootstrap.info(`Principal Provider configured: ${provider.name}`);
+}
+function setAuthProvider(provider) {
+    index_1.di.registerSingleton(auth_provider_contract_1.AuthProviderContract, provider);
+    logger_1.loggers.bootstrap.info(`Auth Provider configured: ${provider.name}`);
+}
+function setSecurityHandler(handler) {
+    index_1.di.registerSingleton(security_handler_contract_1.SecurityHandlerContract, handler);
+    logger_1.loggers.bootstrap.info(`Security Handler configured: ${handler.name}`);
+}
+function setPersistenceProvider(provider) {
+    index_1.di.registerSingleton(contracts_1.PlayerPersistenceContract, provider);
+    logger_1.loggers.bootstrap.info(`Persistence Provider configured: ${provider.name}`);
+}
+function setNetEventSecurityObserver(observer) {
+    index_1.di.registerSingleton(net_event_security_observer_contract_1.NetEventSecurityObserverContract, observer);
+    logger_1.loggers.bootstrap.info(`NetEvent Security Observer configured: ${observer.name}`);
+}

package/dist/{server → runtime/server}/system/metadata-server.keys.d.ts

@@ -7,4 +7,6 @@ export declare const METADATA_KEYS: {
     FIVEM_EVENT: string;
     EXPORT: string;
     PUBLIC: string;
+    THROTTLE: string;
+    REQUIRES_STATE: string;
 };

package/dist/{server → runtime/server}/system/metadata-server.keys.js

@@ -10,4 +10,6 @@ exports.METADATA_KEYS = {
     FIVEM_EVENT: 'core:meta:fivem_event',
     EXPORT: 'core:meta:export',
     PUBLIC: 'core:meta:public',
+    THROTTLE: 'core:throttle',
+    REQUIRES_STATE: 'core:requires_state',
 };

package/dist/runtime/server/system/processors/command.processor.d.ts

@@ -0,0 +1,16 @@
+import { DecoratorProcessor } from '../../../../kernel/di/index';
+import { CommandMetadata } from '../../decorators/command';
+import { CommandExecutionPort } from '../../services/ports/command-execution.port';
+/**
+ * Processor for @Command decorator.
+ *
+ * @remarks
+ * Reads command metadata and registers handlers with CommandExecutionPort.
+ * The port implementation (local or remote) depends on runtime mode.
+ */
+export declare class CommandProcessor implements DecoratorProcessor {
+    private commandService;
+    readonly metadataKey: string;
+    constructor(commandService: CommandExecutionPort);
+    process(target: any, methodName: string, metadata: CommandMetadata): void;
+}

package/dist/runtime/server/system/processors/command.processor.js

@@ -0,0 +1,54 @@
+"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.CommandProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const command_execution_port_1 = require("../../services/ports/command-execution.port");
+const metadata_server_keys_1 = require("../metadata-server.keys");
+/**
+ * Processor for @Command decorator.
+ *
+ * @remarks
+ * Reads command metadata and registers handlers with CommandExecutionPort.
+ * The port implementation (local or remote) depends on runtime mode.
+ */
+let CommandProcessor = class CommandProcessor {
+    constructor(commandService) {
+        this.commandService = commandService;
+        this.metadataKey = metadata_server_keys_1.METADATA_KEYS.COMMAND;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        // Check if method has @Public decorator
+        const proto = Object.getPrototypeOf(target);
+        const isPublic = Reflect.getMetadata(metadata_server_keys_1.METADATA_KEYS.PUBLIC, proto, methodName);
+        // Collect security metadata from decorators
+        const guardOptions = Reflect.getMetadata('core:guard', proto, methodName);
+        const throttleOptions = Reflect.getMetadata(metadata_server_keys_1.METADATA_KEYS.THROTTLE, proto, methodName);
+        const requiresStateOptions = Reflect.getMetadata(metadata_server_keys_1.METADATA_KEYS.REQUIRES_STATE, proto, methodName);
+        // Build security metadata if any decorator is present
+        const security = guardOptions || throttleOptions || requiresStateOptions
+            ? {
+                guard: guardOptions,
+                throttle: throttleOptions,
+                requiresState: requiresStateOptions,
+            }
+            : undefined;
+        // Enrich metadata with isPublic flag and security
+        const enrichedMetadata = Object.assign(Object.assign({}, metadata), { isPublic: isPublic !== null && isPublic !== void 0 ? isPublic : false, security });
+        this.commandService.register(enrichedMetadata, handler);
+    }
+};
+exports.CommandProcessor = CommandProcessor;
+exports.CommandProcessor = CommandProcessor = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __metadata("design:paramtypes", [command_execution_port_1.CommandExecutionPort])
+], CommandProcessor);

package/dist/{server → runtime/server}/system/processors/coreEvent.processor.d.ts

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

package/dist/{server → runtime/server}/system/processors/coreEvent.processor.js

@@ -8,10 +8,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoreEventProcessor = void 0;
 const tsyringe_1 = require("tsyringe");
+const logger_1 = require("../../../../kernel/shared/logger");
 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");
+const metadata_server_keys_1 = require("../metadata-server.keys");
 let CoreEventProcessor = class CoreEventProcessor {
     constructor() {
         this.metadataKey = metadata_server_keys_1.METADATA_KEYS.CORE_EVENT;
@@ -21,7 +21,7 @@ let CoreEventProcessor = class CoreEventProcessor {
         if (!result)
             return;
         const { handler, handlerName } = result;
-        (0, core_event_bus_1.onCoreEvent)(metadata.event, (payload) => {
+        (0, core_event_bus_1.onFrameworkEvent)(metadata.event, (payload) => {
             try {
                 handler(payload);
             }

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

@@ -0,0 +1,10 @@
+import { IExports } from '../../../../adapters/contracts/IExports';
+import { type DecoratorProcessor } from '../../../../kernel/di/index';
+export declare class ExportProcessor implements DecoratorProcessor {
+    private exportsService;
+    readonly metadataKey: string;
+    constructor(exportsService: IExports);
+    process(instance: any, methodName: string, metadata: {
+        exportName: string;
+    }): void;
+}

package/dist/{server → runtime/server}/system/processors/export.processor.js

@@ -5,14 +5,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 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 IExports_1 = require("../../../../adapters/contracts/IExports");
+const logger_1 = require("../../../../kernel/shared/logger");
 const resolve_method_1 = require("../../helpers/resolve-method");
+const metadata_server_keys_1 = require("../metadata-server.keys");
 let ExportProcessor = class ExportProcessor {
-    constructor() {
+    constructor(exportsService) {
+        this.exportsService = exportsService;
         this.metadataKey = metadata_server_keys_1.METADATA_KEYS.EXPORT;
     }
     process(instance, methodName, metadata) {
@@ -20,11 +28,13 @@ let ExportProcessor = class ExportProcessor {
         if (!result)
             return;
         const { handler } = result;
-        globalThis.exports(metadata.exportName, handler);
+        this.exportsService.register(metadata.exportName, handler);
         logger_1.loggers.exports.debug(`Registered: ${metadata.exportName}`);
     }
 };
 exports.ExportProcessor = ExportProcessor;
 exports.ExportProcessor = ExportProcessor = __decorate([
-    (0, tsyringe_1.injectable)()
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(IExports_1.IExports)),
+    __metadata("design:paramtypes", [IExports_1.IExports])
 ], ExportProcessor);

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

@@ -0,0 +1,10 @@
+import { IEngineEvents } from '../../../../adapters/contracts/IEngineEvents';
+import { type DecoratorProcessor } from '../../../../kernel/di/index';
+export declare class FiveMEventProcessor implements DecoratorProcessor {
+    private readonly engineEvents;
+    readonly metadataKey: string;
+    constructor(engineEvents: IEngineEvents);
+    process(instance: any, methodName: string, metadata: {
+        event: string;
+    }): void;
+}

package/dist/{server → runtime/server}/system/processors/fivemEvent.processor.js

@@ -5,14 +5,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FiveMEventProcessor = void 0;
 const tsyringe_1 = require("tsyringe");
-const metadata_server_keys_1 = require("../metadata-server.keys");
-const logger_1 = require("../../../shared/logger");
+const IEngineEvents_1 = require("../../../../adapters/contracts/IEngineEvents");
+const logger_1 = require("../../../../kernel/shared/logger");
 const resolve_method_1 = require("../../helpers/resolve-method");
+const metadata_server_keys_1 = require("../metadata-server.keys");
 let FiveMEventProcessor = class FiveMEventProcessor {
-    constructor() {
+    constructor(engineEvents) {
+        this.engineEvents = engineEvents;
         this.metadataKey = metadata_server_keys_1.METADATA_KEYS.FIVEM_EVENT;
     }
     process(instance, methodName, metadata) {
@@ -20,7 +28,7 @@ let FiveMEventProcessor = class FiveMEventProcessor {
         if (!result)
             return;
         const { handler, handlerName } = result;
-        on(metadata.event, (...args) => {
+        this.engineEvents.on(metadata.event, (...args) => {
             try {
                 handler(...args);
             }
@@ -36,5 +44,7 @@ let FiveMEventProcessor = class FiveMEventProcessor {
 };
 exports.FiveMEventProcessor = FiveMEventProcessor;
 exports.FiveMEventProcessor = FiveMEventProcessor = __decorate([
-    (0, tsyringe_1.injectable)()
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(IEngineEvents_1.IEngineEvents)),
+    __metadata("design:paramtypes", [IEngineEvents_1.IEngineEvents])
 ], FiveMEventProcessor);

package/dist/runtime/server/system/processors/netEvent.processor.d.ts

@@ -0,0 +1,23 @@
+import { INetTransport } from '../../../../adapters/contracts/INetTransport';
+import { type DecoratorProcessor } from '../../../../kernel/di/index';
+import { NetEventSecurityObserverContract } from '../../contracts/security/net-event-security-observer.contract';
+import { SecurityHandlerContract } from '../../contracts/security/security-handler.contract';
+import { NetEventOptions } from '../../decorators';
+import { PlayerDirectoryPort } from '../../services/ports/player-directory.port';
+export declare class NetEventProcessor implements DecoratorProcessor {
+    private playerService;
+    private securityHandler;
+    private netEventObserver;
+    private netTransport;
+    readonly metadataKey: string;
+    private readonly INVALID_COUNTS_META_KEY;
+    constructor(playerService: PlayerDirectoryPort, securityHandler: SecurityHandlerContract, netEventObserver: NetEventSecurityObserverContract, netTransport: INetTransport);
+    process(instance: any, methodName: string, metadata: NetEventOptions): void;
+    private safeHandleViolation;
+    private reasonFromSecurityError;
+    private handleInvalidPayload;
+    private incrementInvalidCount;
+    private summarizeZodError;
+    private safeObserve;
+    private getExpectedArgsCount;
+}