@open-core/ragemp-adapter 0.1.0

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

@@ -0,0 +1,15 @@
+import { IClientSpawnBridge, type RespawnRequest, 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 {
+    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>;
+    teleport(request: TeleportRequest): Promise<void>;
+    private closeLoadingScreens;
+    private setPlayerModel;
+    private ensurePed;
+}

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

@@ -0,0 +1,107 @@
+"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.RageMPClientSpawnBridge = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+const client_2 = require("@open-core/framework/contracts/client");
+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 {
+    constructor(platform, runtime) {
+        super();
+        this.platform = platform;
+        this.runtime = runtime;
+        this.playerReady = false;
+        mp.events.add('playerReady', () => {
+            this.playerReady = true;
+        });
+    }
+    async waitUntilReady(timeoutMs = READY_TIMEOUT_MS) {
+        const started = this.runtime.getGameTimer();
+        while (!this.playerReady) {
+            if (this.runtime.getGameTimer() - started > timeoutMs) {
+                throw new Error('PLAYER_READY_TIMEOUT');
+            }
+            await delay(0);
+        }
+    }
+    async spawn(request) {
+        this.closeLoadingScreens();
+        await this.setPlayerModel(request.model);
+        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;
+    }
+    async respawn(request) {
+        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;
+    }
+    async teleport(request) {
+        await this.ensurePed();
+        mp.players.local.position = new mp.Vector3(request.position.x, request.position.y, request.position.z);
+        if (typeof request.heading === 'number') {
+            mp.players.local.heading = request.heading;
+        }
+    }
+    closeLoadingScreens() {
+        try {
+            this.platform.shutdownLoadingScreen();
+        }
+        catch { }
+        try {
+            this.platform.shutdownLoadingScreenNui();
+        }
+        catch { }
+    }
+    async setPlayerModel(model) {
+        const modelHash = this.platform.getHashKey(model);
+        if (!this.platform.isModelInCdimage(modelHash) || !this.platform.isModelValid(modelHash)) {
+            throw new Error('MODEL_INVALID');
+        }
+        this.platform.requestModel(modelHash);
+        const started = this.runtime.getGameTimer();
+        while (!this.platform.hasModelLoaded(modelHash)) {
+            if (this.runtime.getGameTimer() - started > MODEL_LOAD_TIMEOUT_MS) {
+                throw new Error('MODEL_LOAD_TIMEOUT');
+            }
+            await delay(0);
+        }
+        this.platform.setPlayerModel(this.platform.playerId(), modelHash);
+        this.platform.setModelAsNoLongerNeeded(modelHash);
+    }
+    async ensurePed() {
+        const started = this.runtime.getGameTimer();
+        let ped = this.platform.getLocalPlayerPed();
+        while (ped === 0) {
+            if (this.runtime.getGameTimer() - started > PED_TIMEOUT_MS) {
+                throw new Error('PED_TIMEOUT');
+            }
+            await delay(0);
+            ped = this.platform.getLocalPlayerPed();
+        }
+        return ped;
+    }
+};
+exports.RageMPClientSpawnBridge = RageMPClientSpawnBridge;
+exports.RageMPClientSpawnBridge = RageMPClientSpawnBridge = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(client_2.IClientPlatformBridge)),
+    __param(1, (0, tsyringe_1.inject)(client_2.IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [client_2.IClientPlatformBridge,
+        client_2.IClientRuntimeBridge])
+], RageMPClientSpawnBridge);

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

@@ -0,0 +1,22 @@
+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 handlers;
+    private eventRegistered;
+    getCapabilities(): WebViewCapabilities;
+    create(definition: WebViewDefinition): void;
+    destroy(viewId: string): void;
+    exists(viewId: string): boolean;
+    show(viewId: string): void;
+    hide(viewId: string): void;
+    focus(viewId: string, options?: WebViewFocusOptions): void;
+    blur(viewId: string): void;
+    send(viewId: string, event: string, payload: unknown): void;
+    onMessage(handler: (message: WebViewMessage) => void | Promise<void>): () => void;
+    markAsChat(viewId: string): void;
+    execute(viewId: string, code: string): void;
+    call(viewId: string, eventName: string, ...args: unknown[]): void;
+    callProc<T = unknown>(viewId: string, procName: string, ...args: unknown[]): Promise<T | undefined>;
+    private ensureEventsRegistered;
+}

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

@@ -0,0 +1,131 @@
+"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;
+};
+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 RAGEMP_WEBVIEW_EVENT = '__opencore:webview:message';
+const RAGEMP_WEBVIEW_CAPABILITIES = {
+    supportsFocus: true,
+    supportsCursor: true,
+    supportsInputPassthrough: true,
+    supportsBidirectionalMessaging: true,
+    supportsExecute: true,
+    supportsHeadless: true,
+};
+function js(value) {
+    return JSON.stringify(value);
+}
+let RageMPClientWebViewBridge = class RageMPClientWebViewBridge extends client_1.IClientWebViewBridge {
+    constructor() {
+        super(...arguments);
+        this.views = new Map();
+        this.handlers = new Set();
+        this.eventRegistered = false;
+    }
+    getCapabilities() { return RAGEMP_WEBVIEW_CAPABILITIES; }
+    create(definition) {
+        const existing = this.views.get(definition.id);
+        if (existing)
+            existing.destroy();
+        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.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));
+          }
+        }
+      };`);
+        });
+    }
+    destroy(viewId) {
+        const browser = this.views.get(viewId);
+        if (!browser)
+            return;
+        browser.destroy();
+        this.views.delete(viewId);
+    }
+    exists(viewId) { return this.views.has(viewId); }
+    show(viewId) {
+        const browser = this.views.get(viewId);
+        if (!browser)
+            return;
+        browser.active = true;
+    }
+    hide(viewId) {
+        const browser = this.views.get(viewId);
+        if (!browser)
+            return;
+        browser.active = false;
+    }
+    focus(viewId, options = {}) {
+        const browser = this.views.get(viewId);
+        if (!browser)
+            return;
+        browser.inputEnabled = true;
+        browser.mouseInputEnabled = options.cursor ?? true;
+        mp.gui.cursor.show(true, options.cursor ?? true);
+    }
+    blur(viewId) {
+        const browser = this.views.get(viewId);
+        if (!browser)
+            return;
+        browser.inputEnabled = false;
+        browser.mouseInputEnabled = false;
+        mp.gui.cursor.show(false, false);
+    }
+    send(viewId, event, payload) {
+        const browser = this.views.get(viewId);
+        if (!browser)
+            return;
+        browser.execute(`window.postMessage({ __opencoreWebView: true, action: ${js(event)}, data: ${js(payload)} }, '*');`);
+    }
+    onMessage(handler) {
+        this.ensureEventsRegistered();
+        this.handlers.add(handler);
+        return () => this.handlers.delete(handler);
+    }
+    markAsChat(viewId) {
+        this.views.get(viewId)?.markAsChat();
+    }
+    execute(viewId, code) {
+        this.views.get(viewId)?.execute(code);
+    }
+    call(viewId, eventName, ...args) {
+        this.views.get(viewId)?.call(eventName, ...args);
+    }
+    callProc(viewId, procName, ...args) {
+        const browser = this.views.get(viewId);
+        if (!browser)
+            return Promise.resolve(undefined);
+        return browser.callProc(procName, ...args);
+    }
+    ensureEventsRegistered() {
+        if (this.eventRegistered)
+            return;
+        this.eventRegistered = true;
+        mp.events.add(RAGEMP_WEBVIEW_EVENT, async (viewId, event, payloadJson) => {
+            const payload = payloadJson ? JSON.parse(payloadJson) : null;
+            for (const handler of this.handlers) {
+                await handler({ viewId, event, payload });
+            }
+        });
+    }
+};
+exports.RageMPClientWebViewBridge = RageMPClientWebViewBridge;
+exports.RageMPClientWebViewBridge = RageMPClientWebViewBridge = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPClientWebViewBridge);

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './shared/transport/adapter';
+export * from './shared/transport/ragemp.events';
+export * from './shared/transport/ragemp.rpc';
+export * from './shared/exports-registry';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./shared/transport/adapter"), exports);
+__exportStar(require("./shared/transport/ragemp.events"), exports);
+__exportStar(require("./shared/transport/ragemp.rpc"), exports);
+__exportStar(require("./shared/exports-registry"), exports);

package/dist/server/create-ragemp-server-adapter.d.ts

@@ -0,0 +1,9 @@
+import { type OpenCoreServerAdapter } from '@open-core/framework/server';
+/**
+ * Creates the external RAGE Multiplayer server adapter.
+ */
+export declare function RageMPServerAdapter(): OpenCoreServerAdapter;
+/**
+ * Backward-compatible factory name for external consumers.
+ */
+export declare const createRageMPServerAdapter: typeof RageMPServerAdapter;

package/dist/server/create-ragemp-server-adapter.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRageMPServerAdapter = void 0;
+exports.RageMPServerAdapter = RageMPServerAdapter;
+const server_1 = require("@open-core/framework/server");
+const adapter_1 = require("../shared/transport/adapter");
+const ragemp_capabilities_1 = require("./ragemp-capabilities");
+const ragemp_engine_events_1 = require("./ragemp-engine-events");
+const ragemp_entity_server_1 = require("./ragemp-entity-server");
+const ragemp_exports_1 = require("./ragemp-exports");
+const ragemp_hasher_1 = require("./ragemp-hasher");
+const ragemp_npc_lifecycle_server_1 = require("./ragemp-npc-lifecycle-server");
+const ragemp_ped_server_1 = require("./ragemp-ped-server");
+const ragemp_player_appearance_lifecycle_server_1 = require("./ragemp-player-appearance-lifecycle-server");
+const ragemp_player_lifecycle_server_1 = require("./ragemp-player-lifecycle-server");
+const ragemp_playerinfo_1 = require("./ragemp-playerinfo");
+const ragemp_player_state_sync_server_1 = require("./ragemp-player-state-sync-server");
+const ragemp_player_server_1 = require("./ragemp-player-server");
+const ragemp_resourceinfo_1 = require("./ragemp-resourceinfo");
+const ragemp_tick_1 = require("./ragemp-tick");
+const ragemp_vehicle_lifecycle_server_1 = require("./ragemp-vehicle-lifecycle-server");
+const ragemp_vehicle_server_1 = require("./ragemp-vehicle-server");
+const server_2 = require("@open-core/framework/contracts/server");
+/**
+ * Creates the external RAGE Multiplayer server adapter.
+ */
+function RageMPServerAdapter() {
+    return (0, server_1.defineServerAdapter)({
+        name: 'ragemp',
+        register(ctx) {
+            ctx.bindMessagingTransport(new adapter_1.RageMPMessagingTransport());
+            ctx.bindSingleton(server_2.IPlatformContext, ragemp_capabilities_1.RageMPPlatformContext);
+            ctx.bindInstance(server_2.IEngineEvents, (0, ragemp_engine_events_1.resolveSharedEngineEvents)());
+            ctx.bindSingleton(server_2.IExports, ragemp_exports_1.RageMPExports);
+            ctx.bindSingleton(server_2.IResourceInfo, ragemp_resourceinfo_1.RageMPResourceInfo);
+            ctx.bindSingleton(server_2.ITick, ragemp_tick_1.RageMPTick);
+            ctx.bindSingleton(server_2.IPlayerInfo, ragemp_playerinfo_1.RageMPPlayerInfo);
+            ctx.bindSingleton(server_2.IEntityServer, ragemp_entity_server_1.RageMPEntityServer);
+            ctx.bindSingleton(server_2.IPedServer, ragemp_ped_server_1.RageMPPedServer);
+            ctx.bindSingleton(server_2.INpcLifecycleServer, ragemp_npc_lifecycle_server_1.RageMPNpcLifecycleServer);
+            ctx.bindSingleton(server_2.IPlayerAppearanceLifecycleServer, ragemp_player_appearance_lifecycle_server_1.RageMPPlayerAppearanceLifecycleServer);
+            ctx.bindSingleton(server_2.IPlayerStateSyncServer, ragemp_player_state_sync_server_1.RageMPPlayerStateSyncServer);
+            ctx.bindSingleton(server_2.IVehicleServer, ragemp_vehicle_server_1.RageMPVehicleServer);
+            ctx.bindSingleton(server_2.IVehicleLifecycleServer, ragemp_vehicle_lifecycle_server_1.RageMPVehicleLifecycleServer);
+            ctx.bindSingleton(server_2.IPlayerLifecycleServer, ragemp_player_lifecycle_server_1.RageMPPlayerLifecycleServer);
+            ctx.bindSingleton(server_2.IPlayerServer, ragemp_player_server_1.RageMPPlayerServer);
+            ctx.bindSingleton(server_2.IHasher, ragemp_hasher_1.RageMPHasher);
+        },
+    });
+}
+/**
+ * Backward-compatible factory name for external consumers.
+ */
+exports.createRageMPServerAdapter = RageMPServerAdapter;

package/dist/server/index.d.ts

@@ -0,0 +1,11 @@
+export * from './create-ragemp-server-adapter';
+export * from './ragemp-capabilities';
+export * from './ragemp-engine-events';
+export * from './ragemp-entity-server';
+export * from './ragemp-exports';
+export * from './ragemp-hasher';
+export * from './ragemp-playerinfo';
+export * from './ragemp-player-server';
+export * from './ragemp-resourceinfo';
+export * from './ragemp-tick';
+export * from './ragemp-vehicle-server';

package/dist/server/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./create-ragemp-server-adapter"), exports);
+__exportStar(require("./ragemp-capabilities"), exports);
+__exportStar(require("./ragemp-engine-events"), exports);
+__exportStar(require("./ragemp-entity-server"), exports);
+__exportStar(require("./ragemp-exports"), exports);
+__exportStar(require("./ragemp-hasher"), exports);
+__exportStar(require("./ragemp-playerinfo"), exports);
+__exportStar(require("./ragemp-player-server"), exports);
+__exportStar(require("./ragemp-resourceinfo"), exports);
+__exportStar(require("./ragemp-tick"), exports);
+__exportStar(require("./ragemp-vehicle-server"), exports);

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

@@ -0,0 +1,14 @@
+import { IPlatformContext } from '@open-core/framework/contracts/server';
+/**
+ * RAGE Multiplayer platform context implementation.
+ */
+export declare class RageMPPlatformContext extends IPlatformContext {
+    readonly platformName = "ragemp";
+    readonly displayName = "RAGE Multiplayer";
+    readonly identifierTypes: readonly ["ip", "socialclub", "hwid"];
+    readonly maxPlayers = 5000;
+    readonly gameProfile = "gta5";
+    readonly defaultSpawnModel = "mp_m_freemode_01";
+    readonly defaultVehicleType = "sultan";
+    readonly enableServerVehicleCreation = true;
+}

package/dist/server/ragemp-capabilities.js

@@ -0,0 +1,36 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPPlatformContext = void 0;
+const contracts_1 = require("@open-core/framework/contracts");
+const server_1 = require("@open-core/framework/contracts/server");
+const tsyringe_1 = require("tsyringe");
+/**
+ * RAGE Multiplayer platform context implementation.
+ */
+let RageMPPlatformContext = class RageMPPlatformContext extends server_1.IPlatformContext {
+    constructor() {
+        super(...arguments);
+        this.platformName = 'ragemp';
+        this.displayName = 'RAGE Multiplayer';
+        this.identifierTypes = [
+            contracts_1.IdentifierTypes.IP,
+            contracts_1.IdentifierTypes.SOCIAL_CLUB,
+            contracts_1.IdentifierTypes.HWID,
+        ];
+        this.maxPlayers = 5000;
+        this.gameProfile = 'gta5';
+        this.defaultSpawnModel = 'mp_m_freemode_01';
+        this.defaultVehicleType = 'sultan';
+        this.enableServerVehicleCreation = true;
+    }
+};
+exports.RageMPPlatformContext = RageMPPlatformContext;
+exports.RageMPPlatformContext = RageMPPlatformContext = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPPlatformContext);

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

@@ -0,0 +1,11 @@
+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;
+    emit(eventName: string, ...args: readonly unknown[]): void;
+}
+export declare function resolveSharedEngineEvents(): RageMPEngineEvents;
+export {};

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPEngineEvents = void 0;
+exports.resolveSharedEngineEvents = resolveSharedEngineEvents;
+const server_1 = require("@open-core/framework/contracts/server");
+const EVENT_MAP = {
+    ...server_1.DEFAULT_RUNTIME_EVENT_MAP,
+    [server_1.RUNTIME_EVENTS.playerJoining]: 'playerJoin',
+    [server_1.RUNTIME_EVENTS.playerDropped]: 'playerQuit',
+};
+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;
+    }
+    onRuntime(eventName, handler) {
+        if (!handler)
+            return;
+        const mpEvent = this.getRuntimeEventMap()[eventName] ?? eventName;
+        mp.events.add(mpEvent, (player, ...args) => {
+            const license = player.rgscId;
+            if (eventName === server_1.RUNTIME_EVENTS.playerJoining) {
+                handler(player.id, { license });
+                return;
+            }
+            if (eventName === server_1.RUNTIME_EVENTS.playerDropped) {
+                handler(player.id);
+                return;
+            }
+            handler(player, ...args);
+        });
+    }
+    on(eventName, handler) {
+        if (!handler)
+            return;
+        mp.events.add(eventName, (...args) => {
+            handler(...args);
+        });
+    }
+    emit(eventName, ...args) {
+        mp.events.call(eventName, ...args);
+    }
+}
+exports.RageMPEngineEvents = RageMPEngineEvents;
+// In RageMP every package runs as an independent bundle in the same Node.js
+// process. Each bundle would instantiate its own RageMPEngineEvents, causing
+// listeners like `playerCommand` to be registered multiple times.
+// Storing the instance on `global` ensures a single shared instance.
+const ENGINE_EVENTS_GLOBAL_KEY = '__opencore_engine_events__';
+function resolveSharedEngineEvents() {
+    const globalContext = global;
+    if (!globalContext[ENGINE_EVENTS_GLOBAL_KEY]) {
+        globalContext[ENGINE_EVENTS_GLOBAL_KEY] = new RageMPEngineEvents();
+    }
+    return globalContext[ENGINE_EVENTS_GLOBAL_KEY];
+}

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

@@ -0,0 +1,29 @@
+import { type EntityStateBag, IEntityServer, type SetPositionOptions } from '@open-core/framework/contracts/server';
+import { Vector3 } from '@open-core/framework/kernel';
+/**
+ * RAGE Multiplayer implementation of server-side entity operations.
+ *
+ * The framework handle maps to the RageMP entity.id (server-side integer ID).
+ */
+export declare class RageMPEntityServer extends IEntityServer {
+    doesExist(handle: number): boolean;
+    getCoords(handle: number): Vector3;
+    setPosition(handle: number, position: Vector3, _options?: SetPositionOptions): void;
+    /**
+     * @deprecated Use setPosition() for cross-platform compatibility.
+     */
+    setCoords(handle: number, x: number, y: number, z: number): void;
+    getHeading(handle: number): number;
+    setHeading(handle: number, heading: number): void;
+    getModel(handle: number): number;
+    delete(handle: number): void;
+    setOrphanMode(_handle: number, _mode: number): void;
+    setDimension(handle: number, dimension: number): void;
+    getDimension(handle: number): number;
+    getStateBag(handle: number): EntityStateBag;
+    getHealth(handle: number): number;
+    setHealth(handle: number, health: number): void;
+    getArmor(handle: number): number;
+    setArmor(handle: number, armor: number): void;
+    private findEntity;
+}