@open-core/framework 1.0.5-beta.1 → 1.0.5-beta.2

package/dist/runtime/server/apis/npcs.api.d.ts

@@ -1,6 +1,7 @@
 import { IHasher } from '../../../adapters/contracts/IHasher';
 import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
+import { INpcLifecycleServer } from '../../../adapters/contracts/server/npc-lifecycle/INpcLifecycleServer';
 import { IPedServer } from '../../../adapters/contracts/server/IPedServer';
 import { Vector3 } from '../../../kernel/utils/vector3';
 import { WorldContext } from '../../core/world';
@@ -20,6 +21,7 @@ import { NpcSpawnOptions, NpcSpawnResult, SerializedNpcData } from '../types/npc
 export declare class Npcs {
     private readonly world;
     private readonly entityServer;
+    private readonly npcLifecycle;
     private readonly pedServer;
     private readonly hasher;
     private readonly events;
@@ -27,7 +29,7 @@ export declare class Npcs {
     private readonly idByHandle;
     private readonly idByNetId;
     private readonly adapters;
-    constructor(world: WorldContext, entityServer: IEntityServer, pedServer: IPedServer, hasher: IHasher, events: EventsAPI<'server'>);
+    constructor(world: WorldContext, entityServer: IEntityServer, npcLifecycle: INpcLifecycleServer, pedServer: IPedServer, hasher: IHasher, events: EventsAPI<'server'>);
     /**
      * Spawn (create) a single NPC and register it into the runtime.
      *
@@ -206,8 +208,5 @@ export declare class Npcs {
      * @returns An array of serialized NPC data.
      */
     serializeAll(): SerializedNpcData[];
-    private resolveNetId;
     private removeFromRegistry;
-    private safeDeleteHandle;
-    private waitForSpawn;
 }

package/dist/runtime/server/apis/npcs.api.js

@@ -15,12 +15,11 @@ import { v4 as uuid } from 'uuid';
 import { IHasher } from '../../../adapters/contracts/IHasher';
 import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
+import { INpcLifecycleServer } from '../../../adapters/contracts/server/npc-lifecycle/INpcLifecycleServer';
 import { IPedServer } from '../../../adapters/contracts/server/IPedServer';
 import { coreLogger } from '../../../kernel/logger';
 import { WorldContext } from '../../core/world';
 import { NPC } from '../entities/npc';
-const DEFAULT_PED_TYPE = 4;
-const DEFAULT_SPAWN_TIMEOUT_MS = 2000;
 /**
  * Server-side API responsible for the full NPC (ped) lifecycle:
  * spawn, registry, queries, spatial search, serialization and deletion.
@@ -35,6 +34,7 @@ const DEFAULT_SPAWN_TIMEOUT_MS = 2000;
 let Npcs = class Npcs {
     world;
     entityServer;
+    npcLifecycle;
     pedServer;
     hasher;
     events;
@@ -42,15 +42,17 @@ let Npcs = class Npcs {
     idByHandle = new Map();
     idByNetId = new Map();
     adapters;
-    constructor(world, entityServer, pedServer, hasher, events) {
+    constructor(world, entityServer, npcLifecycle, pedServer, hasher, events) {
         this.world = world;
         this.entityServer = entityServer;
+        this.npcLifecycle = npcLifecycle;
         this.pedServer = pedServer;
         this.hasher = hasher;
         this.events = events;
         this.adapters = {
             entityServer: this.entityServer,
             pedServer: this.pedServer,
+            npcLifecycle: this.npcLifecycle,
         };
     }
     /**
@@ -67,7 +69,7 @@ let Npcs = class Npcs {
      * @returns An object containing a `result` (success/error) and the created `npc` on success.
      */
     async create(options) {
-        const { id, model, position, heading = 0, networked = true, pedType = DEFAULT_PED_TYPE, routingBucket = 0, persistent = false, metadata, } = options;
+        const { id, model, position, heading = 0, networked = true, routingBucket = 0, persistent = false, metadata, } = options;
         const npcId = id ?? uuid();
         if (this.npcById.has(npcId)) {
             return {
@@ -78,27 +80,29 @@ let Npcs = class Npcs {
             };
         }
         const modelHash = typeof model === 'string' ? this.hasher.getHashKey(model) : model;
-        const handle = this.pedServer.create(pedType, modelHash, position.x, position.y, position.z, heading, networked);
-        if (!handle || handle <= 0) {
-            return {
-                result: {
-                    success: false,
-                    error: 'Failed to create NPC ped entity',
-                },
-            };
+        let lifecycleResult;
+        try {
+            lifecycleResult = await Promise.resolve(this.npcLifecycle.create({
+                model: typeof model === 'string' ? model : String(model),
+                modelHash,
+                position,
+                heading,
+                networked,
+                routingBucket,
+                persistent,
+            }));
         }
-        const spawnOk = await this.waitForSpawn(handle);
-        if (!spawnOk) {
-            this.safeDeleteHandle(handle);
+        catch (error) {
             return {
                 result: {
                     success: false,
-                    error: `NPC spawn timed out after ${DEFAULT_SPAWN_TIMEOUT_MS}ms`,
+                    error: error instanceof Error ? error.message : 'Failed to create NPC ped entity',
                 },
             };
         }
+        const handle = lifecycleResult.handle;
         const resolvedModel = typeof model === 'string' ? model : modelHash.toString();
-        const netId = networked ? this.resolveNetId(handle) : undefined;
+        const netId = lifecycleResult.netId;
         const session = {
             id: npcId,
             handle,
@@ -110,12 +114,6 @@ let Npcs = class Npcs {
             createdAt: Date.now(),
         };
         const npc = new NPC(session, this.adapters);
-        if (routingBucket !== 0) {
-            npc.setRoutingBucket(routingBucket);
-        }
-        if (persistent) {
-            this.entityServer.setOrphanMode(handle, 2);
-        }
         if (metadata) {
             for (const [key, value] of Object.entries(metadata)) {
                 npc.setMeta(key, value);
@@ -410,10 +408,6 @@ let Npcs = class Npcs {
     serializeAll() {
         return Array.from(this.npcById.values()).map((npc) => npc.serialize());
     }
-    resolveNetId(handle) {
-        const netId = this.pedServer.getNetworkIdFromEntity(handle);
-        return netId > 0 ? netId : undefined;
-    }
     removeFromRegistry(npc) {
         this.npcById.delete(npc.npcId);
         this.idByHandle.delete(npc.getHandle());
@@ -422,44 +416,20 @@ let Npcs = class Npcs {
         }
         this.world.remove(npc.id);
     }
-    safeDeleteHandle(handle) {
-        try {
-            if (this.entityServer.doesExist(handle)) {
-                this.pedServer.delete(handle);
-            }
-        }
-        catch (error) {
-            coreLogger.warn('Failed to cleanup NPC handle after spawn failure', {
-                handle,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async waitForSpawn(handle, timeoutMs = DEFAULT_SPAWN_TIMEOUT_MS) {
-        const startedAt = Date.now();
-        while (!this.entityServer.doesExist(handle)) {
-            if (Date.now() - startedAt > timeoutMs) {
-                return false;
-            }
-            await sleep(0);
-        }
-        return true;
-    }
 };
 Npcs = __decorate([
     injectable(),
     __param(0, inject(WorldContext)),
     __param(1, inject(IEntityServer)),
-    __param(2, inject(IPedServer)),
-    __param(3, inject(IHasher)),
-    __param(4, inject(EventsAPI)),
+    __param(2, inject(INpcLifecycleServer)),
+    __param(3, inject(IPedServer)),
+    __param(4, inject(IHasher)),
+    __param(5, inject(EventsAPI)),
     __metadata("design:paramtypes", [WorldContext,
         IEntityServer,
+        INpcLifecycleServer,
         IPedServer,
         IHasher,
         EventsAPI])
 ], Npcs);
 export { Npcs };
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/dist/runtime/server/apis/vehicle-modification.api.d.ts

@@ -1,3 +1,4 @@
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { VehicleModificationOptions, VehicleMods } from '../types/vehicle.types';
 import { Vehicles } from './vehicles.api';
 /**
@@ -14,7 +15,8 @@ import { Vehicles } from './vehicles.api';
  */
 export declare class VehicleModification {
     private readonly vehicleService;
-    constructor(vehicleService: Vehicles);
+    private readonly events;
+    constructor(vehicleService: Vehicles, events: EventsAPI<'server'>);
     /**
      * Applies modifications to a vehicle with validation.
      *

package/dist/runtime/server/apis/vehicle-modification.api.js

@@ -11,6 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'tsyringe';
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { coreLogger } from '../../../kernel/logger';
 import { Vehicles } from './vehicles.api';
 /**
@@ -27,8 +28,10 @@ import { Vehicles } from './vehicles.api';
  */
 let VehicleModification = class VehicleModification {
     vehicleService;
-    constructor(vehicleService) {
+    events;
+    constructor(vehicleService, events) {
         this.vehicleService = vehicleService;
+        this.events = events;
     }
     /**
      * Applies modifications to a vehicle with validation.
@@ -70,7 +73,7 @@ let VehicleModification = class VehicleModification {
             requestedBy,
             mods: Object.keys(validatedMods),
         });
-        emitNet('opencore:vehicle:modified', -1, {
+        this.events.emit('opencore:vehicle:modified', 'all', {
             networkId,
             mods: validatedMods,
         });
@@ -197,7 +200,7 @@ let VehicleModification = class VehicleModification {
             windowTint: 0,
         };
         coreLogger.info('Vehicle modifications reset', { networkId, requestedBy });
-        emitNet('opencore:vehicle:modified', -1, {
+        this.events.emit('opencore:vehicle:modified', 'all', {
             networkId,
             mods: defaultMods,
         });
@@ -303,6 +306,8 @@ let VehicleModification = class VehicleModification {
 VehicleModification = __decorate([
     injectable(),
     __param(0, inject(Vehicles)),
-    __metadata("design:paramtypes", [Vehicles])
+    __param(1, inject(EventsAPI)),
+    __metadata("design:paramtypes", [Vehicles,
+        EventsAPI])
 ], VehicleModification);
 export { VehicleModification };

package/dist/runtime/server/apis/vehicles.api.d.ts

@@ -1,12 +1,17 @@
 import { IHasher } from '../../../adapters/contracts/IHasher';
-import { IPlatformCapabilities } from '../../../adapters/contracts/IPlatformCapabilities';
 import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
-import { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+import { IVehicleLifecycleServer } from '../../../adapters/contracts/server/vehicle-lifecycle/IVehicleLifecycleServer';
 import { IVehicleServer } from '../../../adapters/contracts/server/IVehicleServer';
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { Player } from '../entities/player';
 import { Vehicle } from '../entities/vehicle';
 import { SerializedVehicleData, VehicleCreateOptions, VehicleSpawnResult } from '../types/vehicle.types';
 import { Players } from '../ports/players.api-port';
+export interface VehicleCreateForPlayerOptions extends Omit<VehicleCreateOptions, 'position' | 'ownership'> {
+    offset?: Vector3;
+    seatIndex?: number;
+}
 /**
  * Server-side service for managing vehicle entities.
  *
@@ -24,9 +29,8 @@ export declare class Vehicles {
     private readonly playerDirectory;
     private readonly entityServer;
     private readonly vehicleServer;
-    private readonly platformCapabilities;
+    private readonly vehicleLifecycle;
     private readonly hasher;
-    private readonly playerServer;
     private readonly events;
     /**
      * Internal registry of all managed vehicles indexed by Network ID
@@ -36,7 +40,7 @@ export declare class Vehicles {
      * Cached adapters bundle for Vehicle instances
      */
     private readonly vehicleAdapters;
-    constructor(playerDirectory: Players, entityServer: IEntityServer, vehicleServer: IVehicleServer, platformCapabilities: IPlatformCapabilities, hasher: IHasher, playerServer: IPlayerServer, events: EventsAPI<'server'>);
+    constructor(playerDirectory: Players, entityServer: IEntityServer, vehicleServer: IVehicleServer, vehicleLifecycle: IVehicleLifecycleServer, hasher: IHasher, events: EventsAPI<'server'>);
     /**
      * Creates a new vehicle on the server.
      *
@@ -54,7 +58,9 @@ export declare class Vehicles {
      * @param options - Vehicle creation options
      * @returns Spawn result
      */
-    createForPlayer(clientID: number, options: VehicleCreateOptions): Promise<VehicleSpawnResult>;
+    createForPlayer(playerOrClientID: Player | number, options: VehicleCreateForPlayerOptions): Promise<VehicleSpawnResult>;
+    private resolvePlayer;
+    private getSpawnPositionForPlayer;
     /**
      * Retrieves a vehicle by its Network ID.
      *

package/dist/runtime/server/apis/vehicles.api.js

@@ -12,14 +12,14 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject, injectable } from 'tsyringe';
 import { IHasher } from '../../../adapters/contracts/IHasher';
-import { IPlatformCapabilities, PlatformFeatures, } from '../../../adapters/contracts/IPlatformCapabilities';
 import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
-import { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+import { IVehicleLifecycleServer } from '../../../adapters/contracts/server/vehicle-lifecycle/IVehicleLifecycleServer';
 import { IVehicleServer } from '../../../adapters/contracts/server/IVehicleServer';
 import { coreLogger } from '../../../kernel/logger';
 import { Vehicle } from '../entities/vehicle';
 import { Players } from '../ports/players.api-port';
+const DEFAULT_PLAYER_VEHICLE_OFFSET = { x: 0, y: 3, z: 0 };
 /**
  * Server-side service for managing vehicle entities.
  *
@@ -37,9 +37,8 @@ let Vehicles = class Vehicles {
     playerDirectory;
     entityServer;
     vehicleServer;
-    platformCapabilities;
+    vehicleLifecycle;
     hasher;
-    playerServer;
     events;
     /**
      * Internal registry of all managed vehicles indexed by Network ID
@@ -49,13 +48,12 @@ let Vehicles = class Vehicles {
      * Cached adapters bundle for Vehicle instances
      */
     vehicleAdapters;
-    constructor(playerDirectory, entityServer, vehicleServer, platformCapabilities, hasher, playerServer, events) {
+    constructor(playerDirectory, entityServer, vehicleServer, vehicleLifecycle, hasher, events) {
         this.playerDirectory = playerDirectory;
         this.entityServer = entityServer;
         this.vehicleServer = vehicleServer;
-        this.platformCapabilities = platformCapabilities;
+        this.vehicleLifecycle = vehicleLifecycle;
         this.hasher = hasher;
-        this.playerServer = playerServer;
         this.events = events;
         this.vehicleAdapters = {
             entityServer: this.entityServer,
@@ -75,20 +73,13 @@ let Vehicles = class Vehicles {
         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 serverVehicleCreationEnabled = this.platformCapabilities.getConfig('enableServerVehicleCreation') ??
-                this.platformCapabilities.isFeatureSupported(PlatformFeatures.SERVER_ENTITIES);
-            if (!serverVehicleCreationEnabled) {
-                const profile = this.platformCapabilities.getConfig('gameProfile') ?? 'unknown';
-                return {
-                    networkId: 0,
-                    handle: 0,
-                    success: false,
-                    error: `Server vehicle creation is disabled for profile '${profile}'`,
-                };
-            }
-            const vehicleType = this.platformCapabilities.getConfig('defaultVehicleType') ?? 'automobile';
-            const handle = this.vehicleServer.createServerSetter(modelHash, vehicleType, position.x, position.y, position.z, heading);
-            if (!handle || handle === 0) {
+            const { handle, networkId } = await this.vehicleLifecycle.create({
+                model: typeof model === 'string' ? model : String(model),
+                modelHash,
+                position,
+                heading,
+            });
+            if (!Number.isFinite(handle) || handle < 0) {
                 coreLogger.error('Failed to create vehicle', { model, position });
                 return {
                     networkId: 0,
@@ -100,7 +91,6 @@ let Vehicles = class Vehicles {
             while (!this.entityServer.doesExist(handle)) {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             }
-            const networkId = this.vehicleServer.getNetworkIdFromEntity(handle);
             const vehicleOwnership = {
                 clientID: ownership?.clientID,
                 accountID: ownership?.accountID,
@@ -129,10 +119,14 @@ let Vehicles = class Vehicles {
                 vehicle.setRoutingBucket(routingBucket);
             }
             this.vehiclesByNetworkId.set(networkId, vehicle);
+            let ownershipComp = vehicleOwnership.type;
+            if (vehicleOwnership.type === 'player') {
+                ownershipComp = `${vehicleOwnership.type}:${ownership?.clientID}`;
+            }
             coreLogger.info('Vehicle created', {
                 networkId,
                 model,
-                ownership: vehicleOwnership.type,
+                ownership: ownershipComp,
                 persistent,
                 totalVehicles: this.vehiclesByNetworkId.size,
             });
@@ -163,8 +157,8 @@ let Vehicles = class Vehicles {
      * @param options - Vehicle creation options
      * @returns Spawn result
      */
-    async createForPlayer(clientID, options) {
-        const player = this.playerDirectory.getByClient(clientID);
+    async createForPlayer(playerOrClientID, options) {
+        const player = this.resolvePlayer(playerOrClientID);
         if (!player) {
             return {
                 networkId: 0,
@@ -174,19 +168,42 @@ let Vehicles = class Vehicles {
             };
         }
         const ownership = {
-            clientID,
+            clientID: player.clientID,
             accountID: player.accountID,
             type: 'player',
         };
+        const spawnPosition = this.getSpawnPositionForPlayer(player, options.offset);
+        const spawnHeading = options.heading ?? player.getHeading();
         const result = await this.create({
             ...options,
+            position: spawnPosition,
+            heading: spawnHeading,
             ownership,
         });
         if (result.success) {
-            this.events.emit('opencore:vehicle:warpInto', clientID, result.networkId, -1);
+            const seatIndex = options.seatIndex ?? -1;
+            await Promise.resolve(this.vehicleLifecycle.warpPlayerIntoVehicle({
+                playerSrc: player.clientID.toString(),
+                networkId: result.networkId,
+                seatIndex,
+            }));
         }
         return result;
     }
+    resolvePlayer(playerOrClientID) {
+        return typeof playerOrClientID === 'number'
+            ? this.playerDirectory.getByClient(playerOrClientID)
+            : playerOrClientID;
+    }
+    getSpawnPositionForPlayer(player, offset = DEFAULT_PLAYER_VEHICLE_OFFSET) {
+        const position = player.getPosition();
+        const headingRadians = (player.getHeading() * Math.PI) / 180;
+        return {
+            x: position.x + Math.sin(headingRadians) * offset.y + Math.cos(headingRadians) * offset.x,
+            y: position.y + Math.cos(headingRadians) * offset.y - Math.sin(headingRadians) * offset.x,
+            z: position.z + offset.z,
+        };
+    }
     /**
      * Retrieves a vehicle by its Network ID.
      *
@@ -318,10 +335,7 @@ let Vehicles = class Vehicles {
         const player = this.playerDirectory.getByClient(clientID);
         if (!player)
             return false;
-        const playerPed = this.playerServer.getPed(player.clientID.toString());
-        if (!playerPed || playerPed === 0)
-            return false;
-        const playerPos = this.entityServer.getCoords(playerPed);
+        const playerPos = player.getPosition();
         const vehiclePos = vehicle.position;
         const distance = Math.sqrt((playerPos.x - vehiclePos.x) ** 2 +
             (playerPos.y - vehiclePos.y) ** 2 +
@@ -371,16 +385,14 @@ Vehicles = __decorate([
     __param(0, inject(Players)),
     __param(1, inject(IEntityServer)),
     __param(2, inject(IVehicleServer)),
-    __param(3, inject(IPlatformCapabilities)),
+    __param(3, inject(IVehicleLifecycleServer)),
     __param(4, inject(IHasher)),
-    __param(5, inject(IPlayerServer)),
-    __param(6, inject(EventsAPI)),
+    __param(5, inject(EventsAPI)),
     __metadata("design:paramtypes", [Players,
         IEntityServer,
         IVehicleServer,
-        IPlatformCapabilities,
+        IVehicleLifecycleServer,
         IHasher,
-        IPlayerServer,
         EventsAPI])
 ], Vehicles);
 export { Vehicles };

package/dist/runtime/server/bootstrap.js

@@ -1,8 +1,10 @@
-import { IEngineEvents } from '../../adapters';
-import { registerServerCapabilities } from '../../adapters/register-capabilities';
+import { IEngineEvents, IPlatformContext } from '../../adapters';
+import { IExports } from '../../adapters/contracts/IExports';
 import { EventsAPI } from '../../adapters/contracts/transport/events.api';
 import { GLOBAL_CONTAINER, MetadataScanner } from '../../kernel/di/index';
 import { getLogLevel, LogLevelLabels, loggers } from '../../kernel/logger';
+import { createNodeServerAdapter } from './adapter/node-server-adapter';
+import { installServerAdapter } from './adapter/registry';
 import { PrincipalProviderContract } from './contracts/index';
 import { getServerBinaryServiceRegistry } from './decorators/binaryService';
 import { getServerControllerRegistry } from './decorators/controller';
@@ -84,9 +86,13 @@ export async function initServer(options, plugins) {
         mode: ctx.mode,
         scope: getFrameworkModeScope(ctx.mode),
     });
-    // Register platform-specific capabilities (adapters)
-    await registerServerCapabilities();
-    loggers.bootstrap.debug('Platform capabilities registered');
+    // Register platform-specific capabilities through the selected server adapter.
+    await installServerAdapter(options.adapter ?? createNodeServerAdapter());
+    const platformContext = GLOBAL_CONTAINER.resolve(IPlatformContext);
+    loggers.bootstrap.debug('Loading server Adapter ', {
+        adapter: options.adapter?.name ?? 'node',
+        game: platformContext.gameProfile,
+    });
     const dependenciesToWaitFor = [];
     if (ctx.mode === 'RESOURCE') {
         loggers.bootstrap.info(`[WAIT] Standing by for Core '${ctx.coreResourceName}' to be ready...`);
@@ -183,6 +189,7 @@ function createCoreDependency(coreName) {
                 clearInterval(pollingInterval);
         };
         // 1. Register listener FIRST (before any requests)
+        const exportsService = GLOBAL_CONTAINER.resolve(IExports);
         const onReady = () => {
             if (!resolved) {
                 loggers.bootstrap.debug(`Core '${coreName}' detected via 'core:ready' event!`);
@@ -197,8 +204,9 @@ function createCoreDependency(coreName) {
             if (resolved)
                 return;
             try {
-                const globalExports = globalThis.exports;
-                const isReady = globalExports?.[coreName]?.isCoreReady?.();
+                const isReady = exportsService
+                    .getResource(coreName)
+                    ?.isCoreReady?.();
                 loggers.bootstrap.debug(`Polling isCoreReady export: ${isReady}`);
                 if (isReady === true) {
                     loggers.bootstrap.debug(`Core '${coreName}' detected via isCoreReady export!`);

package/dist/runtime/server/controllers/channel.controller.js

@@ -360,7 +360,7 @@ __decorate([
     __metadata("design:returntype", Array)
 ], ChannelExportController.prototype, "getAllChannels", null);
 __decorate([
-    OnRuntimeEvent('onServerResourceStop'),
+    OnRuntimeEvent(RUNTIME_EVENTS.serverResourceStop),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", void 0)
@@ -371,3 +371,4 @@ ChannelExportController = __decorate([
         Players])
 ], ChannelExportController);
 export { ChannelExportController };
+import { RUNTIME_EVENTS } from '../../../adapters/contracts/runtime';

package/dist/runtime/server/controllers/command-export.controller.js

@@ -267,7 +267,7 @@ let CommandExportController = class CommandExportController {
             if (!allowed) {
                 const errorMessage = message || `Rate limit exceeded for command: ${commandName}`;
                 if (onExceed === 'KICK') {
-                    DropPlayer(player.clientID.toString(), errorMessage);
+                    player.kick(errorMessage);
                 }
                 throw new SecurityError(onExceed || 'LOG', errorMessage, { clientID: player.clientID });
             }

package/dist/runtime/server/controllers/player-export.controller.js

@@ -13,6 +13,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { inject } from 'tsyringe';
 import { Controller } from '../decorators/controller';
 import { Export } from '../decorators/export';
+import { serializeServerPlayerData } from '../adapter/serialization';
 import { Players } from '../ports/players.api-port';
 /**
  * Exports player directory functionality for RESOURCE mode access.
@@ -37,18 +38,18 @@ let PlayerExportController = class PlayerExportController {
     }
     getPlayerData(clientID) {
         const player = this.playerService.getByClient(clientID);
-        return player?.serialize() ?? null;
+        return player ? serializeServerPlayerData(player) : null;
     }
     getManyData(clientIds) {
-        return this.playerService.getMany(clientIds).map((p) => p.serialize());
+        return this.playerService.getMany(clientIds).map((player) => serializeServerPlayerData(player));
     }
     getAllPlayersData() {
-        return this.playerService.getAll().map((p) => p.serialize());
+        return this.playerService.getAll().map((player) => serializeServerPlayerData(player));
     }
     getPlayerByAccountId(accountId) {
         const players = this.playerService.getAll();
         const player = players.find((p) => p.accountID === accountId);
-        return player?.serialize() ?? null;
+        return player ? serializeServerPlayerData(player) : null;
     }
     getPlayerCount() {
         return this.playerService.getAll().length;

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

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+import { RUNTIME_EVENTS } from '../../../adapters/contracts/runtime';
 import { inject } from 'tsyringe';
 import { loggers } from '../../../kernel/logger';
 import { emitFrameworkEvent } from '../bus/internal-event.bus';
@@ -60,13 +61,13 @@ let SessionController = class SessionController {
     }
 };
 __decorate([
-    OnRuntimeEvent('playerJoining'),
+    OnRuntimeEvent(RUNTIME_EVENTS.playerJoining),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Number, Object]),
     __metadata("design:returntype", Promise)
 ], SessionController.prototype, "onPlayerJoining", null);
 __decorate([
-    OnRuntimeEvent('playerDropped'),
+    OnRuntimeEvent(RUNTIME_EVENTS.playerDropped),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Number]),
     __metadata("design:returntype", Promise)

package/dist/runtime/server/controllers/vehicle.controller.d.ts

@@ -1,3 +1,4 @@
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { Player } from '../entities/player';
 import { Vehicles } from '../apis/vehicles.api';
 /**
@@ -8,7 +9,8 @@ import { Vehicles } from '../apis/vehicles.api';
  */
 export declare class VehicleController {
     private readonly vehicleService;
-    constructor(vehicleService: Vehicles);
+    private readonly events;
+    constructor(vehicleService: Vehicles, events: EventsAPI<'server'>);
     /**
      * Handles client request to get vehicle data.
      */