@open-core/ragemp-adapter 0.1.1 → 1.0.2

package/dist/client/ragemp-spawn-bridge.d.ts

@@ -1,13 +1,13 @@
-import { IClientSpawnBridge, type RespawnRequest, type SpawnRequest, type TeleportRequest } from '@open-core/framework/contracts/client';
+import { IClientSpawnPort, type RespawnRequest, type SpawnExecutionResult, type SpawnRequest, type TeleportRequest } from '@open-core/framework/contracts/client';
 import { IClientPlatformBridge, IClientRuntimeBridge } from '@open-core/framework/contracts/client';
-export declare class RageMPClientSpawnBridge extends IClientSpawnBridge {
+export declare class RageMPClientSpawnBridge extends IClientSpawnPort {
     private readonly platform;
     private readonly runtime;
     private playerReady;
     constructor(platform: IClientPlatformBridge, runtime: IClientRuntimeBridge);
     waitUntilReady(timeoutMs?: number): Promise<void>;
-    spawn(request: SpawnRequest): Promise<void>;
-    respawn(request: RespawnRequest): Promise<void>;
+    spawn(request: SpawnRequest): Promise<SpawnExecutionResult>;
+    respawn(request: RespawnRequest): Promise<SpawnExecutionResult>;
     teleport(request: TeleportRequest): Promise<void>;
     private closeLoadingScreens;
     private setPlayerModel;

package/dist/client/ragemp-spawn-bridge.js

@@ -20,7 +20,7 @@ const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const READY_TIMEOUT_MS = 15000;
 const PED_TIMEOUT_MS = 10000;
 const MODEL_LOAD_TIMEOUT_MS = 10000;
-let RageMPClientSpawnBridge = class RageMPClientSpawnBridge extends client_1.IClientSpawnBridge {
+let RageMPClientSpawnBridge = class RageMPClientSpawnBridge extends client_1.IClientSpawnPort {
     constructor(platform, runtime) {
         super();
         this.platform = platform;
@@ -42,14 +42,16 @@ let RageMPClientSpawnBridge = class RageMPClientSpawnBridge extends client_1.ICl
     async spawn(request) {
         this.closeLoadingScreens();
         await this.setPlayerModel(request.model);
-        await this.ensurePed();
+        const ped = await this.ensurePed();
         mp.players.local.position = new mp.Vector3(request.position.x, request.position.y, request.position.z);
         mp.players.local.heading = request.heading ?? 0;
+        return { localPlayerHandle: ped };
     }
     async respawn(request) {
-        await this.ensurePed();
+        const ped = await this.ensurePed();
         mp.players.local.position = new mp.Vector3(request.position.x, request.position.y, request.position.z);
         mp.players.local.heading = request.heading ?? 0;
+        return { localPlayerHandle: ped };
     }
     async teleport(request) {
         await this.ensurePed();

package/dist/client/ragemp-vehicle-port.d.ts

@@ -0,0 +1,34 @@
+import { type ClientVehicleMods, type ClientVehicleSpawnOptions, IClientLocalPlayerBridge, IClientPlatformBridge, IClientVehiclePort } from '@open-core/framework/contracts/client';
+import type { Vector3 } from '@open-core/framework/kernel';
+export declare class RageMPClientVehiclePort extends IClientVehiclePort {
+    private readonly platform;
+    private readonly localPlayer;
+    constructor(platform: IClientPlatformBridge, localPlayer: IClientLocalPlayerBridge);
+    spawn(options: ClientVehicleSpawnOptions): Promise<number>;
+    delete(vehicle: number): void;
+    repair(vehicle: number): void;
+    setFuel(vehicle: number, level: number): void;
+    getFuel(vehicle: number): number;
+    getClosest(radius?: number): number | null;
+    isLocalPlayerInVehicle(): boolean;
+    getCurrentForLocalPlayer(): number | null;
+    getLastForLocalPlayer(): number | null;
+    isLocalPlayerDriver(vehicle: number): boolean;
+    warpLocalPlayerInto(vehicle: number, seatIndex?: number): void;
+    leaveLocalPlayerVehicle(vehicle: number, flags?: number): void;
+    applyMods(vehicle: number, mods: ClientVehicleMods): void;
+    setDoorsLocked(vehicle: number, locked: boolean): void;
+    setEngineRunning(vehicle: number, running: boolean, instant?: boolean): void;
+    setInvincible(vehicle: number, invincible: boolean): void;
+    getSpeed(vehicle: number): number;
+    setHeading(vehicle: number, heading: number): void;
+    teleport(vehicle: number, position: Vector3, heading?: number): void;
+    exists(vehicle: number): boolean;
+    getNetworkId(vehicle: number): number;
+    getFromNetworkId(networkId: number): number;
+    getState<T = unknown>(vehicle: number, key: string): T | undefined;
+    getPosition(vehicle: number): Vector3 | null;
+    getHeading(vehicle: number): number;
+    getModel(vehicle: number): number;
+    getPlate(vehicle: number): string;
+}

package/dist/client/ragemp-vehicle-port.js

@@ -0,0 +1,272 @@
+"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.RageMPClientVehiclePort = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+let RageMPClientVehiclePort = class RageMPClientVehiclePort extends client_1.IClientVehiclePort {
+    constructor(platform, localPlayer) {
+        super();
+        this.platform = platform;
+        this.localPlayer = localPlayer;
+    }
+    async spawn(options) {
+        const { model, position, heading = 0, placeOnGround = true, warpIntoVehicle = false, seatIndex = -1, primaryColor, secondaryColor, plate, networked = true, } = options;
+        const modelHash = this.platform.getHashKey(model);
+        if (!this.platform.isModelInCdimage(modelHash) || !this.platform.isModelAVehicle(modelHash)) {
+            throw new Error(`Invalid vehicle model: ${model}`);
+        }
+        this.platform.requestModel(modelHash);
+        while (!this.platform.hasModelLoaded(modelHash)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        const vehicle = this.platform.createVehicle(modelHash, position, heading, networked, false);
+        this.platform.setModelAsNoLongerNeeded(modelHash);
+        if (!vehicle || vehicle === 0)
+            throw new Error('Failed to create vehicle');
+        if (placeOnGround)
+            this.platform.setVehicleOnGroundProperly(vehicle);
+        if (primaryColor !== undefined || secondaryColor !== undefined) {
+            const [currentPrimary, currentSecondary] = this.platform.getVehicleColours(vehicle);
+            this.platform.setVehicleColours(vehicle, primaryColor ?? currentPrimary, secondaryColor ?? currentSecondary);
+        }
+        if (plate)
+            this.platform.setVehicleNumberPlateText(vehicle, plate);
+        if (warpIntoVehicle)
+            this.warpLocalPlayerInto(vehicle, seatIndex);
+        return vehicle;
+    }
+    delete(vehicle) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.setEntityAsMissionEntity(vehicle, true, true);
+        this.platform.deleteVehicle(vehicle);
+    }
+    repair(vehicle) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.setVehicleFixed(vehicle);
+        this.platform.setVehicleDeformationFixed(vehicle);
+        this.platform.setVehicleUndriveable(vehicle, false);
+        this.platform.setVehicleEngineOn(vehicle, true, true, false);
+        this.platform.setVehicleEngineHealth(vehicle, 1000.0);
+        this.platform.setVehiclePetrolTankHealth(vehicle, 1000.0);
+    }
+    setFuel(vehicle, level) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.setVehicleFuelLevel(vehicle, Math.max(0, Math.min(100, level)));
+    }
+    getFuel(vehicle) {
+        if (!this.exists(vehicle))
+            return 0;
+        return this.platform.getVehicleFuelLevel(vehicle);
+    }
+    getClosest(radius = 10) {
+        return this.platform.getClosestVehicle(this.localPlayer.getPosition(), radius);
+    }
+    isLocalPlayerInVehicle() {
+        return this.platform.isPedInAnyVehicle(this.localPlayer.getHandle());
+    }
+    getCurrentForLocalPlayer() {
+        const ped = this.localPlayer.getHandle();
+        if (!this.platform.isPedInAnyVehicle(ped))
+            return null;
+        return this.platform.getVehiclePedIsIn(ped, false);
+    }
+    getLastForLocalPlayer() {
+        return this.platform.getVehiclePedIsIn(this.localPlayer.getHandle(), true);
+    }
+    isLocalPlayerDriver(vehicle) {
+        return this.platform.getPedInVehicleSeat(vehicle, -1) === this.localPlayer.getHandle();
+    }
+    warpLocalPlayerInto(vehicle, seatIndex = -1) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.taskWarpPedIntoVehicle(this.localPlayer.getHandle(), vehicle, seatIndex);
+    }
+    leaveLocalPlayerVehicle(vehicle, flags = 16) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.taskLeaveVehicle(this.localPlayer.getHandle(), vehicle, flags);
+    }
+    applyMods(vehicle, mods) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.setVehicleModKit(vehicle, 0);
+        if (mods.spoiler !== undefined)
+            this.platform.setVehicleMod(vehicle, 0, mods.spoiler, false);
+        if (mods.frontBumper !== undefined)
+            this.platform.setVehicleMod(vehicle, 1, mods.frontBumper, false);
+        if (mods.rearBumper !== undefined)
+            this.platform.setVehicleMod(vehicle, 2, mods.rearBumper, false);
+        if (mods.sideSkirt !== undefined)
+            this.platform.setVehicleMod(vehicle, 3, mods.sideSkirt, false);
+        if (mods.exhaust !== undefined)
+            this.platform.setVehicleMod(vehicle, 4, mods.exhaust, false);
+        if (mods.frame !== undefined)
+            this.platform.setVehicleMod(vehicle, 5, mods.frame, false);
+        if (mods.grille !== undefined)
+            this.platform.setVehicleMod(vehicle, 6, mods.grille, false);
+        if (mods.hood !== undefined)
+            this.platform.setVehicleMod(vehicle, 7, mods.hood, false);
+        if (mods.fender !== undefined)
+            this.platform.setVehicleMod(vehicle, 8, mods.fender, false);
+        if (mods.rightFender !== undefined)
+            this.platform.setVehicleMod(vehicle, 9, mods.rightFender, false);
+        if (mods.roof !== undefined)
+            this.platform.setVehicleMod(vehicle, 10, mods.roof, false);
+        if (mods.engine !== undefined)
+            this.platform.setVehicleMod(vehicle, 11, mods.engine, false);
+        if (mods.brakes !== undefined)
+            this.platform.setVehicleMod(vehicle, 12, mods.brakes, false);
+        if (mods.transmission !== undefined)
+            this.platform.setVehicleMod(vehicle, 13, mods.transmission, false);
+        if (mods.horns !== undefined)
+            this.platform.setVehicleMod(vehicle, 14, mods.horns, false);
+        if (mods.suspension !== undefined)
+            this.platform.setVehicleMod(vehicle, 15, mods.suspension, false);
+        if (mods.armor !== undefined)
+            this.platform.setVehicleMod(vehicle, 16, mods.armor, false);
+        if (mods.turbo !== undefined)
+            this.platform.toggleVehicleMod(vehicle, 18, mods.turbo);
+        if (mods.xenon !== undefined)
+            this.platform.toggleVehicleMod(vehicle, 22, mods.xenon);
+        if (mods.wheelType !== undefined)
+            this.platform.setVehicleWheelType(vehicle, mods.wheelType);
+        if (mods.wheels !== undefined)
+            this.platform.setVehicleMod(vehicle, 23, mods.wheels, false);
+        if (mods.windowTint !== undefined)
+            this.platform.setVehicleWindowTint(vehicle, mods.windowTint);
+        if (mods.livery !== undefined)
+            this.platform.setVehicleLivery(vehicle, mods.livery);
+        if (mods.plateStyle !== undefined)
+            this.platform.setVehicleNumberPlateTextIndex(vehicle, mods.plateStyle);
+        if (mods.neonEnabled !== undefined) {
+            this.platform.setVehicleNeonLightEnabled(vehicle, 0, mods.neonEnabled[0]);
+            this.platform.setVehicleNeonLightEnabled(vehicle, 1, mods.neonEnabled[1]);
+            this.platform.setVehicleNeonLightEnabled(vehicle, 2, mods.neonEnabled[2]);
+            this.platform.setVehicleNeonLightEnabled(vehicle, 3, mods.neonEnabled[3]);
+        }
+        if (mods.neonColor !== undefined) {
+            this.platform.setVehicleNeonLightsColour(vehicle, mods.neonColor[0], mods.neonColor[1], mods.neonColor[2]);
+        }
+        if (mods.extras) {
+            for (const [extraId, enabled] of Object.entries(mods.extras)) {
+                this.platform.setVehicleExtra(vehicle, Number(extraId), !enabled);
+            }
+        }
+        if (mods.pearlescentColor !== undefined || mods.wheelColor !== undefined) {
+            const [currentPearl, currentWheel] = this.platform.getVehicleExtraColours(vehicle);
+            this.platform.setVehicleExtraColours(vehicle, mods.pearlescentColor ?? currentPearl, mods.wheelColor ?? currentWheel);
+        }
+    }
+    setDoorsLocked(vehicle, locked) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.setVehicleDoorsLocked(vehicle, locked ? 2 : 0);
+    }
+    setEngineRunning(vehicle, running, instant = false) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.setVehicleEngineOn(vehicle, running, instant, true);
+    }
+    setInvincible(vehicle, invincible) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.setEntityInvincible(vehicle, invincible);
+    }
+    getSpeed(vehicle) {
+        if (!this.exists(vehicle))
+            return 0;
+        return this.platform.getEntitySpeed(vehicle);
+    }
+    setHeading(vehicle, heading) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.setEntityHeading(vehicle, heading);
+    }
+    teleport(vehicle, position, heading) {
+        if (!this.exists(vehicle))
+            return;
+        this.platform.setEntityCoords(vehicle, position);
+        if (heading !== undefined)
+            this.platform.setEntityHeading(vehicle, heading);
+        this.platform.setVehicleOnGroundProperly(vehicle);
+    }
+    exists(vehicle) {
+        return this.platform.doesEntityExist(vehicle);
+    }
+    getNetworkId(vehicle) {
+        if (!this.exists(vehicle))
+            return 0;
+        mp.vehicles.atHandle(vehicle);
+        try {
+            const runtimeVehicle = mp.vehicles.atHandle(vehicle);
+            const remoteId = runtimeVehicle?.remoteId ?? runtimeVehicle?.id;
+            if (typeof remoteId === 'number')
+                return remoteId;
+        }
+        catch { }
+        return this.platform.networkGetNetworkIdFromEntity(vehicle);
+    }
+    getFromNetworkId(networkId) {
+        try {
+            const byRemoteId = mp.vehicles.atRemoteId(networkId);
+            if (byRemoteId?.handle)
+                return byRemoteId.handle;
+            const vehicles = mp.vehicles.toArray() ?? [];
+            const match = vehicles.find((vehicle) => vehicle?.remoteId === networkId || vehicle?.id === networkId);
+            if (match?.handle)
+                return match.handle;
+        }
+        catch { }
+        if (!this.platform.networkDoesEntityExistWithNetworkId(networkId))
+            return 0;
+        return this.platform.networkGetEntityFromNetworkId(networkId);
+    }
+    getState(vehicle, key) {
+        if (!this.exists(vehicle))
+            return undefined;
+        return this.platform.getEntityState(vehicle, key);
+    }
+    getPosition(vehicle) {
+        if (!this.exists(vehicle))
+            return null;
+        return this.platform.getEntityCoords(vehicle);
+    }
+    getHeading(vehicle) {
+        if (!this.exists(vehicle))
+            return 0;
+        return this.platform.getEntityHeading(vehicle);
+    }
+    getModel(vehicle) {
+        if (!this.exists(vehicle))
+            return 0;
+        return this.platform.getEntityModel(vehicle);
+    }
+    getPlate(vehicle) {
+        if (!this.exists(vehicle))
+            return '';
+        return this.platform.getVehicleNumberPlateText(vehicle);
+    }
+};
+exports.RageMPClientVehiclePort = RageMPClientVehiclePort;
+exports.RageMPClientVehiclePort = RageMPClientVehiclePort = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(client_1.IClientPlatformBridge)),
+    __param(1, (0, tsyringe_1.inject)(client_1.IClientLocalPlayerBridge)),
+    __metadata("design:paramtypes", [client_1.IClientPlatformBridge,
+        client_1.IClientLocalPlayerBridge])
+], RageMPClientVehiclePort);

package/dist/client/ragemp-webview-bridge.d.ts

@@ -2,8 +2,11 @@ import { IClientWebViewBridge } from '@open-core/framework/contracts/client';
 import type { WebViewCapabilities, WebViewDefinition, WebViewFocusOptions, WebViewMessage } from '@open-core/framework/contracts/client';
 export declare class RageMPClientWebViewBridge extends IClientWebViewBridge {
     private readonly views;
+    private readonly browserViewIds;
+    private readonly chatModeViews;
     private readonly handlers;
     private eventRegistered;
+    private domReadyRegistered;
     getCapabilities(): WebViewCapabilities;
     create(definition: WebViewDefinition): void;
     destroy(viewId: string): void;
@@ -19,4 +22,6 @@ export declare class RageMPClientWebViewBridge extends IClientWebViewBridge {
     call(viewId: string, eventName: string, ...args: unknown[]): void;
     callProc<T = unknown>(viewId: string, procName: string, ...args: unknown[]): Promise<T | undefined>;
     private ensureEventsRegistered;
+    private ensureBrowserReadyRegistered;
+    private injectBridge;
 }

package/dist/client/ragemp-webview-bridge.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageMPClientWebViewBridge = void 0;
 const tsyringe_1 = require("tsyringe");
 const client_1 = require("@open-core/framework/contracts/client");
+const native_chat_1 = require("./native-chat");
 const RAGEMP_WEBVIEW_EVENT = '__opencore:webview:message';
 const RAGEMP_WEBVIEW_CAPABILITIES = {
     supportsFocus: true,
@@ -17,6 +18,7 @@ const RAGEMP_WEBVIEW_CAPABILITIES = {
     supportsBidirectionalMessaging: true,
     supportsExecute: true,
     supportsHeadless: true,
+    supportsChatMode: true,
 };
 function js(value) {
     return JSON.stringify(value);
@@ -25,37 +27,52 @@ let RageMPClientWebViewBridge = class RageMPClientWebViewBridge extends client_1
     constructor() {
         super(...arguments);
         this.views = new Map();
+        this.browserViewIds = new Map();
+        this.chatModeViews = new Set();
         this.handlers = new Set();
         this.eventRegistered = false;
+        this.domReadyRegistered = false;
     }
     getCapabilities() { return RAGEMP_WEBVIEW_CAPABILITIES; }
     create(definition) {
         const existing = this.views.get(definition.id);
-        if (existing)
+        if (existing) {
+            this.chatModeViews.delete(definition.id);
+            (0, native_chat_1.releaseRageMPNativeChat)(definition.id);
+            this.browserViewIds.delete(existing);
             existing.destroy();
+        }
+        if (definition.chatMode) {
+            try {
+                mp.gui.chat.activate(false);
+                mp.gui.chat.show(false);
+            }
+            catch {
+                // Ignore if native chat is not ready yet.
+            }
+        }
         const browser = mp.browsers.new(definition.url);
         browser.active = definition.visible ?? false;
         browser.inputEnabled = definition.focused ?? false;
         browser.mouseInputEnabled = definition.cursor ?? false;
         this.views.set(definition.id, browser);
+        this.browserViewIds.set(browser, definition.id);
         this.ensureEventsRegistered();
-        mp.events.add('browserDomReady', (readyBrowser) => {
-            if (readyBrowser !== browser)
-                return;
-            browser.execute(`window.__OpenCoreWebView = {
-        emit: function(event, payload) {
-          if (typeof mp !== 'undefined' && typeof mp.trigger === 'function') {
-            mp.trigger(${js(RAGEMP_WEBVIEW_EVENT)}, ${js(definition.id)}, event, JSON.stringify(payload ?? null));
-          }
+        this.ensureBrowserReadyRegistered();
+        if (definition.chatMode) {
+            this.chatModeViews.add(definition.id);
+            (0, native_chat_1.suppressRageMPNativeChat)(definition.id);
+            browser.markAsChat();
         }
-      };`);
-        });
     }
     destroy(viewId) {
         const browser = this.views.get(viewId);
         if (!browser)
             return;
         browser.destroy();
+        this.chatModeViews.delete(viewId);
+        (0, native_chat_1.releaseRageMPNativeChat)(viewId);
+        this.browserViewIds.delete(browser);
         this.views.delete(viewId);
     }
     exists(viewId) { return this.views.has(viewId); }
@@ -99,7 +116,12 @@ let RageMPClientWebViewBridge = class RageMPClientWebViewBridge extends client_1
         return () => this.handlers.delete(handler);
     }
     markAsChat(viewId) {
-        this.views.get(viewId)?.markAsChat();
+        const browser = this.views.get(viewId);
+        if (!browser)
+            return;
+        this.chatModeViews.add(viewId);
+        (0, native_chat_1.suppressRageMPNativeChat)(viewId);
+        browser.markAsChat();
     }
     execute(viewId, code) {
         this.views.get(viewId)?.execute(code);
@@ -124,6 +146,26 @@ let RageMPClientWebViewBridge = class RageMPClientWebViewBridge extends client_1
             }
         });
     }
+    ensureBrowserReadyRegistered() {
+        if (this.domReadyRegistered)
+            return;
+        this.domReadyRegistered = true;
+        mp.events.add('browserDomReady', (browser) => {
+            const viewId = this.browserViewIds.get(browser);
+            if (!viewId)
+                return;
+            this.injectBridge(browser, viewId);
+        });
+    }
+    injectBridge(browser, viewId) {
+        browser.execute(`window.__OpenCoreWebView = {
+      emit: function(event, payload) {
+        if (typeof mp !== 'undefined' && typeof mp.trigger === 'function') {
+          mp.trigger(${js(RAGEMP_WEBVIEW_EVENT)}, ${js(viewId)}, event, JSON.stringify(payload ?? null));
+        }
+      }
+    };`);
+    }
 };
 exports.RageMPClientWebViewBridge = RageMPClientWebViewBridge;
 exports.RageMPClientWebViewBridge = RageMPClientWebViewBridge = __decorate([

package/dist/server/ragemp-engine-events.d.ts

@@ -1,11 +1,8 @@
 import { IEngineEvents, type RuntimeEventMap, type RuntimeEventName } from '@open-core/framework/contracts/server';
-type EngineHandler = (...args: readonly unknown[]) => void;
 export declare class RageMPEngineEvents extends IEngineEvents {
-    constructor();
     getRuntimeEventMap(): RuntimeEventMap;
-    onRuntime(eventName: RuntimeEventName, handler?: EngineHandler): void;
-    on(eventName: string, handler?: EngineHandler): void;
+    onRuntime<TArgs extends readonly unknown[]>(eventName: RuntimeEventName, handler?: (...args: TArgs) => void): void;
+    on<TArgs extends readonly unknown[]>(eventName: string, handler?: (...args: TArgs) => void): void;
     emit(eventName: string, ...args: readonly unknown[]): void;
 }
 export declare function resolveSharedEngineEvents(): RageMPEngineEvents;
-export {};

package/dist/server/ragemp-engine-events.js

@@ -11,21 +11,9 @@ const EVENT_MAP = {
 function isPlayerMp(value) {
     return typeof value === 'object' && value !== null && 'id' in value;
 }
-// TODO: Refactor runtime event handling to use a single engine listener per event.
 // The listener should forward events to an internal dispatcher/event bus so that
 // multiple framework handlers do not register duplicate mp.events listeners.
 class RageMPEngineEvents extends server_1.IEngineEvents {
-    constructor() {
-        super();
-        this.onRuntime(server_1.RUNTIME_EVENTS.playerCommand, (player, command) => {
-            if (!isPlayerMp(player) || typeof command !== 'string')
-                return;
-            const [commandName, ...args] = command.trim().split(/\s+/);
-            if (!commandName)
-                return;
-            this.emit('core:execute-command', player, commandName, args);
-        });
-    }
     getRuntimeEventMap() {
         return EVENT_MAP;
     }
@@ -36,14 +24,14 @@ class RageMPEngineEvents extends server_1.IEngineEvents {
         mp.events.add(mpEvent, (player, ...args) => {
             const license = player.rgscId;
             if (eventName === server_1.RUNTIME_EVENTS.playerJoining) {
-                handler(player.id, { license });
+                handler(...[player.id, { license }]);
                 return;
             }
             if (eventName === server_1.RUNTIME_EVENTS.playerDropped) {
-                handler(player.id);
+                handler(...[player.id]);
                 return;
             }
-            handler(player, ...args);
+            handler(...[player, ...args]);
         });
     }
     on(eventName, handler) {

package/dist/server/ragemp-entity-server.js

@@ -51,7 +51,20 @@ let RageMPEntityServer = class RageMPEntityServer extends server_1.IEntityServer
         return this.findEntity(handle)?.model ?? 0;
     }
     delete(handle) {
-        this.findEntity(handle)?.destroy();
+        const vehicle = mp.vehicles.at(handle);
+        if (vehicle && mp.vehicles.exists(vehicle) && typeof vehicle.destroy === 'function') {
+            vehicle.destroy();
+            return;
+        }
+        const ped = mp.peds.at(handle);
+        if (ped && mp.peds.exists(ped) && typeof ped.destroy === 'function') {
+            ped.destroy();
+            return;
+        }
+        const entity = this.findEntity(handle);
+        if (entity && typeof entity.destroy === 'function') {
+            entity.destroy();
+        }
     }
     setOrphanMode(_handle, _mode) {
         // Not applicable in RageMP — entities are always managed by the server.

package/dist/server/ragemp-exports.d.ts

@@ -1,7 +1,58 @@
 import { IExports, IResourceInfo } from '@open-core/framework/contracts/server';
 export declare class RageMPExports extends IExports {
     private readonly resourceInfo;
+    private readonly currentResourceName;
+    private readonly requestEventName;
+    private readonly responseEventName;
+    private readonly pendingRequests;
+    private readonly localHandlers;
     constructor(resourceInfo: IResourceInfo);
     register(exportName: string, handler: (...args: readonly unknown[]) => unknown): void;
+    /**
+     * Resolves exports through the local registry shared by the current adapter runtime.
+     */
     getResource<T = unknown>(resourceName: string): T | undefined;
+    /**
+     * Returns an async proxy that forwards method calls to another server resource.
+     *
+     * @remarks
+     * The proxy intentionally ignores Promise-like properties (`then`, `catch`, `finally`)
+     * so `await` does not accidentally treat the proxy itself as a thenable.
+     */
+    getRemoteResource<T = unknown>(resourceName: string): T;
+    /**
+     * Invokes a remote export by sending a server-side RageMP event to the target resource.
+     */
+    callRemoteExport<TResult = unknown>(resourceName: string, exportName: string, ...args: unknown[]): Promise<TResult>;
+    /**
+     * Waits for a remote resource to expose a matching export before returning the async proxy.
+     */
+    waitForRemoteResource<T = unknown>(resourceName: string, options?: {
+        exportName?: string;
+        timeoutMs?: number;
+        intervalMs?: number;
+    }): Promise<T>;
+    /**
+     * Installs the request/response listeners used by the optional remote export helper layer.
+     *
+     * @remarks
+     * The listeners reject payloads that look like player-originated server events so clients
+     * cannot invoke server resource exports through this transport.
+     */
+    private registerTransportListeners;
+    /**
+     * Executes one remote export request against handlers registered in the current resource.
+     */
+    private handleExportRequest;
+    /**
+     * Resolves or rejects the pending promise associated with a remote export response.
+     */
+    private handleExportResponse;
+    /**
+     * Executes an export from the current resource without going back through the shared registry.
+     */
+    private executeLocalExport;
+    private createRequestId;
+    private serializeError;
+    private deserializeError;
 }