@open-core/ragemp-adapter 0.1.0

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

@@ -0,0 +1,122 @@
+"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.RageMPEntityServer = void 0;
+const tsyringe_1 = require("tsyringe");
+const server_1 = require("@open-core/framework/contracts/server");
+/**
+ * RAGE Multiplayer implementation of server-side entity operations.
+ *
+ * The framework handle maps to the RageMP entity.id (server-side integer ID).
+ */
+let RageMPEntityServer = class RageMPEntityServer extends server_1.IEntityServer {
+    doesExist(handle) {
+        return this.findEntity(handle) !== undefined;
+    }
+    getCoords(handle) {
+        const entity = this.findEntity(handle);
+        if (!entity)
+            return { x: 0, y: 0, z: 0 };
+        return { x: entity.position.x, y: entity.position.y, z: entity.position.z };
+    }
+    setPosition(handle, position, _options) {
+        // TODO: Handle options like keepAlive, clearArea, platformOpts and extract flags from platformOptions
+        const entity = this.findEntity(handle);
+        if (!entity)
+            return;
+        entity.position = new mp.Vector3(position.x, position.y, position.z);
+    }
+    /**
+     * @deprecated Use setPosition() for cross-platform compatibility.
+     */
+    setCoords(handle, x, y, z) {
+        this.setPosition(handle, { x, y, z });
+    }
+    getHeading(handle) {
+        const player = mp.players.at(handle);
+        return (player && mp.players.exists(player)) ? player.heading : 0;
+    }
+    setHeading(handle, heading) {
+        const player = mp.players.at(handle);
+        if (player && mp.players.exists(player)) {
+            player.heading = heading;
+        }
+    }
+    getModel(handle) {
+        return this.findEntity(handle)?.model ?? 0;
+    }
+    delete(handle) {
+        this.findEntity(handle)?.destroy();
+    }
+    setOrphanMode(_handle, _mode) {
+        // Not applicable in RageMP — entities are always managed by the server.
+    }
+    setDimension(handle, dimension) {
+        const entity = this.findEntity(handle);
+        if (entity)
+            entity.dimension = dimension;
+    }
+    getDimension(handle) {
+        return this.findEntity(handle)?.dimension ?? 0;
+    }
+    getStateBag(handle) {
+        const entity = this.findEntity(handle);
+        return {
+            set: (key, value) => {
+                entity?.setVariable(key, value);
+            },
+            get: (key) => {
+                return entity?.getVariable(key);
+            },
+        };
+    }
+    getHealth(handle) {
+        const player = mp.players.at(handle);
+        if (player && mp.players.exists(player))
+            return player.health;
+        return this.findEntity(handle)?.getVariable('health') ?? 200;
+    }
+    setHealth(handle, health) {
+        const player = mp.players.at(handle);
+        if (player && mp.players.exists(player)) {
+            player.health = health;
+            return;
+        }
+        this.findEntity(handle)?.setVariable('health', health);
+    }
+    getArmor(handle) {
+        const player = mp.players.at(handle);
+        if (player && mp.players.exists(player))
+            return player.armour;
+        return this.findEntity(handle)?.getVariable('armor') ?? 0;
+    }
+    setArmor(handle, armor) {
+        const player = mp.players.at(handle);
+        if (player && mp.players.exists(player)) {
+            player.armour = armor;
+            return;
+        }
+        this.findEntity(handle)?.setVariable('armor', armor);
+    }
+    findEntity(id) {
+        const player = mp.players.at(id);
+        if (player && mp.players.exists(player))
+            return player;
+        const vehicle = mp.vehicles.at(id);
+        if (vehicle && mp.vehicles.exists(vehicle))
+            return vehicle;
+        const ped = mp.peds.at(id);
+        if (ped && mp.peds.exists(ped))
+            return ped;
+        return undefined;
+    }
+};
+exports.RageMPEntityServer = RageMPEntityServer;
+exports.RageMPEntityServer = RageMPEntityServer = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPEntityServer);

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

@@ -0,0 +1,7 @@
+import { IExports, IResourceInfo } from '@open-core/framework/contracts/server';
+export declare class RageMPExports extends IExports {
+    private readonly resourceInfo;
+    constructor(resourceInfo: IResourceInfo);
+    register(exportName: string, handler: (...args: readonly unknown[]) => unknown): void;
+    getResource<T = unknown>(resourceName: string): T | undefined;
+}

package/dist/server/ragemp-exports.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;
+};
+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.RageMPExports = void 0;
+const tsyringe_1 = require("tsyringe");
+const server_1 = require("@open-core/framework/contracts/server");
+const exports_registry_1 = require("../shared/exports-registry");
+let RageMPExports = class RageMPExports extends server_1.IExports {
+    constructor(resourceInfo) {
+        super();
+        this.resourceInfo = resourceInfo;
+    }
+    register(exportName, handler) {
+        exports_registry_1.exportsRegistry.register(this.resourceInfo.getCurrentResourceName(), exportName, handler);
+    }
+    getResource(resourceName) {
+        return exports_registry_1.exportsRegistry.resourceProxy(resourceName);
+    }
+};
+exports.RageMPExports = RageMPExports;
+exports.RageMPExports = RageMPExports = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(server_1.IResourceInfo)),
+    __metadata("design:paramtypes", [server_1.IResourceInfo])
+], RageMPExports);

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

@@ -0,0 +1,7 @@
+import { IHasher } from '@open-core/framework/contracts/server';
+/**
+ * Rage Multiplayer implementation of hash utilities.
+ */
+export declare class RageMPHasher extends IHasher {
+    getHashKey(str: string): number;
+}

package/dist/server/ragemp-hasher.js

@@ -0,0 +1,23 @@
+"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.RageMPHasher = void 0;
+const tsyringe_1 = require("tsyringe");
+const server_1 = require("@open-core/framework/contracts/server");
+/**
+ * Rage Multiplayer implementation of hash utilities.
+ */
+let RageMPHasher = class RageMPHasher extends server_1.IHasher {
+    getHashKey(str) {
+        return mp.joaat(str);
+    }
+};
+exports.RageMPHasher = RageMPHasher;
+exports.RageMPHasher = RageMPHasher = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPHasher);

package/dist/server/ragemp-npc-lifecycle-server.d.ts

@@ -0,0 +1,9 @@
+import { IEntityServer, INpcLifecycleServer, IPedServer } from '@open-core/framework/contracts/server';
+import type { CreateNpcServerRequest, CreateNpcServerResult, DeleteNpcServerRequest } from '@open-core/framework/contracts/server';
+export declare class RageMPNpcLifecycleServer extends INpcLifecycleServer {
+    private readonly pedServer;
+    private readonly entityServer;
+    constructor(pedServer: IPedServer, entityServer: IEntityServer);
+    create(request: CreateNpcServerRequest): CreateNpcServerResult;
+    delete(request: DeleteNpcServerRequest): void;
+}

package/dist/server/ragemp-npc-lifecycle-server.js

@@ -0,0 +1,51 @@
+"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.RageMPNpcLifecycleServer = void 0;
+const tsyringe_1 = require("tsyringe");
+const server_1 = require("@open-core/framework/contracts/server");
+let RageMPNpcLifecycleServer = class RageMPNpcLifecycleServer extends server_1.INpcLifecycleServer {
+    constructor(pedServer, entityServer) {
+        super();
+        this.pedServer = pedServer;
+        this.entityServer = entityServer;
+    }
+    create(request) {
+        const handle = this.pedServer.create(4, request.modelHash, request.position.x, request.position.y, request.position.z, request.heading, request.networked);
+        if (!Number.isFinite(handle) || handle < 0) {
+            throw new Error('Failed to create NPC ped entity');
+        }
+        if (request.routingBucket !== undefined) {
+            this.entityServer.setDimension(handle, request.routingBucket);
+        }
+        if (request.persistent) {
+            this.entityServer.setOrphanMode(handle, 2);
+        }
+        const netId = request.networked ? this.pedServer.getNetworkIdFromEntity(handle) : undefined;
+        return { handle, netId: netId && netId > 0 ? netId : undefined };
+    }
+    delete(request) {
+        if (!this.entityServer.doesExist(request.handle))
+            return;
+        this.pedServer.delete(request.handle);
+    }
+};
+exports.RageMPNpcLifecycleServer = RageMPNpcLifecycleServer;
+exports.RageMPNpcLifecycleServer = RageMPNpcLifecycleServer = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(server_1.IPedServer)),
+    __param(1, (0, tsyringe_1.inject)(server_1.IEntityServer)),
+    __metadata("design:paramtypes", [server_1.IPedServer,
+        server_1.IEntityServer])
+], RageMPNpcLifecycleServer);

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

@@ -0,0 +1,8 @@
+import { IPedServer } from '@open-core/framework/contracts/server';
+export declare class RageMPPedServer extends IPedServer {
+    create(_pedType: number, modelHash: number, x: number, y: number, z: number, heading: number, _networked: boolean): number;
+    delete(handle: number): void;
+    getNetworkIdFromEntity(handle: number): number;
+    getEntityFromNetworkId(networkId: number): number;
+    networkIdExists(networkId: number): boolean;
+}

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

@@ -0,0 +1,37 @@
+"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.RageMPPedServer = void 0;
+const tsyringe_1 = require("tsyringe");
+const server_1 = require("@open-core/framework/contracts/server");
+let RageMPPedServer = class RageMPPedServer extends server_1.IPedServer {
+    create(_pedType, modelHash, x, y, z, heading, _networked) {
+        const ped = mp.peds.new(modelHash, new mp.Vector3(x, y, z), { heading });
+        return ped.id;
+    }
+    delete(handle) {
+        mp.peds.at(handle).destroy();
+    }
+    getNetworkIdFromEntity(handle) {
+        if (!mp.peds.exists(handle))
+            return 0;
+        return mp.peds.at(handle).id;
+    }
+    getEntityFromNetworkId(networkId) {
+        if (!mp.peds.exists(networkId))
+            return 0;
+        return mp.peds.at(networkId).id;
+    }
+    networkIdExists(networkId) {
+        return mp.peds.exists(networkId);
+    }
+};
+exports.RageMPPedServer = RageMPPedServer;
+exports.RageMPPedServer = RageMPPedServer = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPPedServer);

package/dist/server/ragemp-player-appearance-lifecycle-server.d.ts

@@ -0,0 +1,19 @@
+import { EventsAPI } from '@open-core/framework/contracts';
+import { Players } from '@open-core/framework/server';
+import { IPlayerServer } from '@open-core/framework/contracts/server';
+import { IPlayerAppearanceLifecycleServer } from '@open-core/framework/contracts/server';
+import type { PlayerAppearance } from '@open-core/framework';
+export declare class RageMPPlayerAppearanceLifecycleServer extends IPlayerAppearanceLifecycleServer {
+    private readonly events;
+    private readonly players;
+    private readonly playerServer;
+    constructor(events: EventsAPI<'server'>, players: Players, playerServer: IPlayerServer);
+    apply(playerSrc: string, appearance: PlayerAppearance): {
+        success: boolean;
+        appearance?: PlayerAppearance;
+        errors?: string[];
+    };
+    applyClothing(playerSrc: string, appearance: Pick<PlayerAppearance, 'components' | 'props'>): boolean;
+    reset(playerSrc: string): boolean;
+    private resolveTarget;
+}

package/dist/server/ragemp-player-appearance-lifecycle-server.js

@@ -0,0 +1,66 @@
+"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.RageMPPlayerAppearanceLifecycleServer = void 0;
+const tsyringe_1 = require("tsyringe");
+const contracts_1 = require("@open-core/framework/contracts");
+const server_1 = require("@open-core/framework/server");
+const server_2 = require("@open-core/framework/contracts/server");
+const server_3 = require("@open-core/framework/contracts/server");
+let RageMPPlayerAppearanceLifecycleServer = class RageMPPlayerAppearanceLifecycleServer extends server_3.IPlayerAppearanceLifecycleServer {
+    constructor(events, players, playerServer) {
+        super();
+        this.events = events;
+        this.players = players;
+        this.playerServer = playerServer;
+    }
+    apply(playerSrc, appearance) {
+        const target = this.resolveTarget(playerSrc);
+        if (!target) {
+            return { success: false, errors: ['Player not found'] };
+        }
+        if (appearance.model) {
+            this.playerServer.setModel(playerSrc, appearance.model);
+        }
+        this.events.emit('opencore:appearance:apply', target, appearance);
+        return { success: true, appearance };
+    }
+    applyClothing(playerSrc, appearance) {
+        const target = this.resolveTarget(playerSrc);
+        if (!target)
+            return false;
+        this.events.emit('opencore:appearance:apply', target, appearance);
+        return true;
+    }
+    reset(playerSrc) {
+        const target = this.resolveTarget(playerSrc);
+        if (!target)
+            return false;
+        this.events.emit('opencore:appearance:reset', target);
+        return true;
+    }
+    resolveTarget(playerSrc) {
+        return this.players.getByClient(Number(playerSrc));
+    }
+};
+exports.RageMPPlayerAppearanceLifecycleServer = RageMPPlayerAppearanceLifecycleServer;
+exports.RageMPPlayerAppearanceLifecycleServer = RageMPPlayerAppearanceLifecycleServer = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(contracts_1.EventsAPI)),
+    __param(1, (0, tsyringe_1.inject)(server_1.Players)),
+    __param(2, (0, tsyringe_1.inject)(server_2.IPlayerServer)),
+    __metadata("design:paramtypes", [contracts_1.EventsAPI,
+        server_1.Players,
+        server_2.IPlayerServer])
+], RageMPPlayerAppearanceLifecycleServer);

package/dist/server/ragemp-player-lifecycle-server.d.ts

@@ -0,0 +1,7 @@
+import { IPlayerLifecycleServer, type RespawnPlayerRequest, type SpawnPlayerRequest, type TeleportPlayerRequest } from '@open-core/framework/contracts/server';
+export declare class RageMPPlayerLifecycleServer extends IPlayerLifecycleServer {
+    private player;
+    spawn(playerSrc: string, request: SpawnPlayerRequest): void;
+    teleport(playerSrc: string, request: TeleportPlayerRequest): void;
+    respawn(playerSrc: string, request: RespawnPlayerRequest): void;
+}

package/dist/server/ragemp-player-lifecycle-server.js

@@ -0,0 +1,40 @@
+"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.RageMPPlayerLifecycleServer = void 0;
+const tsyringe_1 = require("tsyringe");
+const server_1 = require("@open-core/framework/contracts/server");
+let RageMPPlayerLifecycleServer = class RageMPPlayerLifecycleServer extends server_1.IPlayerLifecycleServer {
+    player(playerSrc) {
+        return mp.players.at(Number(playerSrc));
+    }
+    spawn(playerSrc, request) {
+        const player = this.player(playerSrc);
+        if (request.model) {
+            player.model = mp.joaat(request.model);
+        }
+        player.spawn(new mp.Vector3(request.position.x, request.position.y, request.position.z));
+        if (typeof request.heading === 'number') {
+            player.heading = request.heading;
+        }
+    }
+    teleport(playerSrc, request) {
+        const player = this.player(playerSrc);
+        player.position = new mp.Vector3(request.position.x, request.position.y, request.position.z);
+        if (typeof request.heading === 'number') {
+            player.heading = request.heading;
+        }
+    }
+    respawn(playerSrc, request) {
+        this.spawn(playerSrc, request);
+    }
+};
+exports.RageMPPlayerLifecycleServer = RageMPPlayerLifecycleServer;
+exports.RageMPPlayerLifecycleServer = RageMPPlayerLifecycleServer = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPPlayerLifecycleServer);

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

@@ -0,0 +1,20 @@
+import { IPlayerServer } from '@open-core/framework/contracts/server';
+import { type PlayerIdentifier } from '@open-core/framework/contracts';
+/**
+ * Rage Multiplayer implementation of server-side player operations.
+ */
+export declare class RageMPPlayerServer extends IPlayerServer {
+    private player;
+    getPed(playerSrc: string): number;
+    drop(playerSrc: string, reason: string): void;
+    setModel(playerSrc: string, model: string): void;
+    getIdentifier(playerSrc: string, identifierType: string): string | undefined;
+    getPlayerIdentifiers(playerSrc: string): PlayerIdentifier[];
+    getNumIdentifiers(playerSrc: string): number;
+    getName(playerSrc: string): string;
+    getPing(playerSrc: string): number;
+    getEndpoint(playerSrc: string): string;
+    setDimension(playerSrc: string, dimension: number): void;
+    getDimension(playerSrc: string): number;
+    getConnectedPlayers(): string[];
+}

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

@@ -0,0 +1,89 @@
+"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.RageMPPlayerServer = void 0;
+const tsyringe_1 = require("tsyringe");
+const server_1 = require("@open-core/framework/contracts/server");
+const contracts_1 = require("@open-core/framework/contracts");
+/**
+ * Rage Multiplayer implementation of server-side player operations.
+ */
+let RageMPPlayerServer = class RageMPPlayerServer extends server_1.IPlayerServer {
+    player(playerSrc) {
+        return mp.players.at(Number(playerSrc));
+    }
+    getPed(playerSrc) {
+        return this.player(playerSrc).id;
+    }
+    drop(playerSrc, reason) {
+        this.player(playerSrc).kick(reason);
+    }
+    setModel(playerSrc, model) {
+        this.player(playerSrc).model = mp.joaat(model);
+    }
+    getIdentifier(playerSrc, identifierType) {
+        const player = this.player(playerSrc);
+        switch (identifierType) {
+            case contracts_1.IdentifierTypes.ROCKSTAR:
+                return player.rgscId ? `rockstar:${player.rgscId}` : undefined;
+            case contracts_1.IdentifierTypes.IP:
+                return player.ip ? `ip:${player.ip}` : undefined;
+            case contracts_1.IdentifierTypes.HWID:
+                return player.serial ? `hwid:${player.serial}` : undefined;
+            default:
+                return undefined;
+        }
+    }
+    getPlayerIdentifiers(playerSrc) {
+        const player = this.player(playerSrc);
+        const identifiers = [];
+        if (player.rgscId) {
+            identifiers.push({
+                type: contracts_1.IdentifierTypes.ROCKSTAR,
+                value: player.rgscId,
+                raw: `rockstar:${player.rgscId}`,
+            });
+        }
+        if (player.ip) {
+            identifiers.push({ type: contracts_1.IdentifierTypes.IP, value: player.ip, raw: `ip:${player.ip}` });
+        }
+        if (player.serial) {
+            identifiers.push({
+                type: contracts_1.IdentifierTypes.HWID,
+                value: player.serial,
+                raw: `hwid:${player.serial}`,
+            });
+        }
+        return identifiers;
+    }
+    getNumIdentifiers(playerSrc) {
+        return this.getPlayerIdentifiers(playerSrc).length;
+    }
+    getName(playerSrc) {
+        return this.player(playerSrc).name || 'Unknown';
+    }
+    getPing(playerSrc) {
+        return this.player(playerSrc).ping;
+    }
+    getEndpoint(playerSrc) {
+        return this.player(playerSrc).ip || '';
+    }
+    setDimension(playerSrc, dimension) {
+        this.player(playerSrc).dimension = dimension;
+    }
+    getDimension(playerSrc) {
+        return this.player(playerSrc).dimension;
+    }
+    getConnectedPlayers() {
+        return mp.players.toArray().map((p) => String(p.id));
+    }
+};
+exports.RageMPPlayerServer = RageMPPlayerServer;
+exports.RageMPPlayerServer = RageMPPlayerServer = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPPlayerServer);

package/dist/server/ragemp-player-state-sync-server.d.ts

@@ -0,0 +1,7 @@
+import { IPlayerStateSyncServer } from '@open-core/framework/contracts/server';
+export declare class RageMPPlayerStateSyncServer extends IPlayerStateSyncServer {
+    getHealth(playerSrc: string): number;
+    setHealth(playerSrc: string, health: number): void;
+    getArmor(playerSrc: string): number;
+    setArmor(playerSrc: string, armor: number): void;
+}

package/dist/server/ragemp-player-state-sync-server.js

@@ -0,0 +1,29 @@
+"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.RageMPPlayerStateSyncServer = void 0;
+const tsyringe_1 = require("tsyringe");
+const server_1 = require("@open-core/framework/contracts/server");
+let RageMPPlayerStateSyncServer = class RageMPPlayerStateSyncServer extends server_1.IPlayerStateSyncServer {
+    getHealth(playerSrc) {
+        return mp.players.at(Number(playerSrc)).health;
+    }
+    setHealth(playerSrc, health) {
+        mp.players.at(Number(playerSrc)).health = health;
+    }
+    getArmor(playerSrc) {
+        return mp.players.at(Number(playerSrc)).armour;
+    }
+    setArmor(playerSrc, armor) {
+        mp.players.at(Number(playerSrc)).armour = armor;
+    }
+};
+exports.RageMPPlayerStateSyncServer = RageMPPlayerStateSyncServer;
+exports.RageMPPlayerStateSyncServer = RageMPPlayerStateSyncServer = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPPlayerStateSyncServer);

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

@@ -0,0 +1,6 @@
+import { IPlayerInfo } from '@open-core/framework/contracts/server';
+import { Vector3 } from '@open-core/framework/kernel';
+export declare class RageMPPlayerInfo implements IPlayerInfo {
+    getPlayerName(clientId: number): string | null;
+    getPlayerPosition(clientId: number): Vector3;
+}

package/dist/server/ragemp-playerinfo.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPPlayerInfo = void 0;
+class RageMPPlayerInfo {
+    getPlayerName(clientId) {
+        const player = mp.players.at(clientId);
+        if (!player || !mp.players.exists(player))
+            return null;
+        return player.name ?? null;
+    }
+    getPlayerPosition(clientId) {
+        const player = mp.players.at(clientId);
+        if (!player || !mp.players.exists(player))
+            return { x: 0, y: 0, z: 0 };
+        const pos = player.position;
+        return { x: pos.x, y: pos.y, z: pos.z };
+    }
+}
+exports.RageMPPlayerInfo = RageMPPlayerInfo;

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

@@ -0,0 +1,5 @@
+import { IResourceInfo } from '@open-core/framework/contracts/server';
+export declare class RageMPResourceInfo extends IResourceInfo {
+    getCurrentResourceName(): string;
+    getCurrentResourcePath(): string;
+}

package/dist/server/ragemp-resourceinfo.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPResourceInfo = void 0;
+const server_1 = require("@open-core/framework/contracts/server");
+class RageMPResourceInfo extends server_1.IResourceInfo {
+    getCurrentResourceName() {
+        if (typeof __dirname !== 'string')
+            return 'default';
+        const normalized = __dirname.replace(/\\/g, '/');
+        const parts = normalized.split('/');
+        // RageMP server scripts live under packages/<resourceName>/...
+        const packagesIndex = parts.lastIndexOf('packages');
+        if (packagesIndex !== -1 && parts[packagesIndex + 1]) {
+            return parts[packagesIndex + 1];
+        }
+        // fallback: last folder segment
+        return parts[parts.length - 1] || 'default';
+    }
+    getCurrentResourcePath() {
+        if (typeof __dirname === 'string')
+            return __dirname;
+        return process.cwd();
+    }
+}
+exports.RageMPResourceInfo = RageMPResourceInfo;