@open-core/ragemp-adapter 0.1.0

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

@@ -0,0 +1,479 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPPlatformBridge = exports.RageMPPedAppearanceClient = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+const kernel_1 = require("@open-core/framework/kernel");
+function getMp() {
+    return mp;
+}
+function getGame() {
+    return mp.game;
+}
+function toMpVector3(position) {
+    return new (getMp().Vector3)(position.x, position.y, position.z);
+}
+function toCoreVector3(position) {
+    return { x: position.x, y: position.y, z: position.z };
+}
+function tryGetPed(handle) {
+    const runtime = getMp();
+    try {
+        return runtime.players.atHandle(handle) ?? runtime.peds.atHandle(handle);
+    }
+    catch {
+        return undefined;
+    }
+}
+function tryGetEntity(handle) {
+    const runtime = getMp();
+    try {
+        return runtime.players.atHandle(handle);
+    }
+    catch {
+        try {
+            return runtime.vehicles.atHandle(handle);
+        }
+        catch {
+            try {
+                return runtime.peds.atHandle(handle);
+            }
+            catch {
+                try {
+                    return runtime.objects.atHandle(handle);
+                }
+                catch {
+                    return undefined;
+                }
+            }
+        }
+    }
+}
+let RageMPPedAppearanceClient = class RageMPPedAppearanceClient extends client_1.IGtaPedAppearanceBridge {
+    setComponentVariation(ped, componentId, drawableId, textureId) {
+        getGame().ped.setComponentVariation(ped, componentId, drawableId, textureId, 0);
+    }
+    setPropIndex(ped, propId, drawableId, textureId) {
+        getGame().ped.setPropIndex(ped, propId, drawableId, textureId, true);
+    }
+    clearProp(ped, propId) {
+        getGame().ped.clearProp(ped, propId);
+    }
+    setDefaultComponentVariation(ped) {
+        getGame().ped.setDefaultComponentVariation(ped);
+    }
+    setHeadBlendData(ped, data) {
+        getGame().ped.setHeadBlendData(ped, data.shapeFirst, data.shapeSecond, data.shapeThird ?? 0, data.skinFirst, data.skinSecond, data.skinThird ?? 0, data.shapeMix, data.skinMix, data.thirdMix ?? 0, false);
+    }
+    setFaceFeature(ped, index, scale) {
+        getGame().ped.setFaceFeature(ped, index, scale);
+    }
+    setHeadOverlay(ped, overlayId, index, opacity) {
+        getGame().ped.setHeadOverlay(ped, overlayId, index, opacity);
+    }
+    setHeadOverlayColor(ped, overlayId, colorType, colorId, secondColorId) {
+        getGame().ped.setHeadOverlayColor(ped, overlayId, colorType, colorId, secondColorId);
+    }
+    setHairColor(ped, colorId, highlightColorId) {
+        getGame().ped.setHairColor(ped, colorId, highlightColorId);
+    }
+    setEyeColor(ped, colorId) {
+        getGame().ped.setEyeColor(ped, colorId);
+    }
+    addDecoration(ped, collectionHash, overlayHash) {
+        getGame().ped.addDecorationFromHashes(ped, collectionHash, overlayHash);
+    }
+    clearDecorations(ped) {
+        getGame().ped.clearDecorations(ped);
+    }
+    getDrawableVariation(ped, componentId) {
+        return getGame().ped.getDrawableVariation(ped, componentId);
+    }
+    getTextureVariation(ped, componentId) {
+        return getGame().ped.getTextureVariation(ped, componentId);
+    }
+    getPropIndex(ped, propId) {
+        return getGame().ped.getPropIndex(ped, propId);
+    }
+    getPropTextureIndex(ped, propId) {
+        return getGame().ped.getPropTextureIndex(ped, propId);
+    }
+    getNumDrawableVariations(ped, componentId) {
+        return getGame().ped.getNumberOfDrawableVariations(ped, componentId);
+    }
+    getNumTextureVariations(ped, componentId, drawableId) {
+        return getGame().ped.getNumberOfTextureVariations(ped, componentId, drawableId);
+    }
+    getNumPropDrawableVariations(ped, propId) {
+        return getGame().ped.getNumberOfPropDrawableVariations(ped, propId);
+    }
+    getNumPropTextureVariations(ped, propId, drawableId) {
+        return getGame().ped.getNumberOfPropTextureVariations(ped, propId, drawableId);
+    }
+    getNumOverlayValues(overlayId) {
+        return getGame().ped.getNumHeadOverlayValues(overlayId);
+    }
+    getNumHairColors() {
+        return getGame().ped.getNumHairColors();
+    }
+    getNumMakeupColors() {
+        return getGame().ped.getNumMakeupColors();
+    }
+};
+exports.RageMPPedAppearanceClient = RageMPPedAppearanceClient;
+exports.RageMPPedAppearanceClient = RageMPPedAppearanceClient = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPPedAppearanceClient);
+let RageMPPlatformBridge = class RageMPPlatformBridge extends client_1.IClientPlatformBridge {
+    constructor() {
+        super();
+        this.playerReady = false;
+        mp.events.add('playerReady', () => {
+            this.playerReady = true;
+            kernel_1.loggers.spawn.debug('RageMP playerReady fired');
+        });
+    }
+    getHashKey(value) {
+        return getGame().joaat(value);
+    }
+    getLocalPlayerPed() {
+        return getMp().players.local.handle ?? 0;
+    }
+    getEntityCoords(entity) {
+        return toCoreVector3(getGame().entity.getCoords(entity, true));
+    }
+    getWorldPositionOfEntityBone(entity, bone) {
+        const ped = tryGetPed(entity);
+        if (!ped)
+            return this.getEntityCoords(entity);
+        return toCoreVector3(ped.getBoneCoords(bone, 0, 0, 0));
+    }
+    getGameplayCamCoords() {
+        return toCoreVector3(getGame().cam.getGameplayCoord());
+    }
+    worldToScreen(position) {
+        const result = getGame().graphics.getScreenCoordFromWorldCoord(position.x, position.y, position.z);
+        return { onScreen: result.result, x: result.screenX, y: result.screenY };
+    }
+    isModelInCdimage(hash) {
+        return getGame().streaming.isModelInCdimage(hash);
+    }
+    isModelValid(hash) {
+        return getGame().streaming.isModelValid(hash);
+    }
+    isModelAVehicle(hash) {
+        return getGame().streaming.isModelAVehicle(hash);
+    }
+    isModelAPed(hash) {
+        return getGame().streaming.isModelAPed(hash);
+    }
+    requestModel(hash) {
+        getGame().streaming.requestModel(hash);
+    }
+    hasModelLoaded(hash) {
+        return getGame().streaming.hasModelLoaded(hash);
+    }
+    setModelAsNoLongerNeeded(hash) {
+        getGame().streaming.setModelAsNoLongerNeeded(hash);
+    }
+    requestAnimDict(dict) {
+        getGame().streaming.requestAnimDict(dict);
+    }
+    hasAnimDictLoaded(dict) {
+        return getGame().streaming.hasAnimDictLoaded(dict);
+    }
+    removeAnimDict(dict) {
+        getGame().streaming.removeAnimDict(dict);
+    }
+    doesEntityExist(entity) {
+        return getGame().entity.doesExist(entity);
+    }
+    setEntityAsMissionEntity(entity, mission, scriptHostObject) {
+        getGame().entity.setAsMissionEntity(entity, mission, scriptHostObject);
+    }
+    setBlockingOfNonTemporaryEvents(ped, toggle) {
+        getGame().ped.setBlockingOfNonTemporaryEvents(ped, toggle);
+    }
+    setPedRelationshipGroupHash(ped, groupHash) {
+        getGame().ped.setRelationshipGroupHash(ped, groupHash);
+    }
+    createPed(pedType, modelHash, position, heading, networked, scriptHostPed) {
+        return getGame().ped.createPed(pedType, modelHash, position.x, position.y, position.z, heading, networked, scriptHostPed);
+    }
+    deletePed(ped) {
+        tryGetPed(ped)?.destroy();
+    }
+    createObject(modelHash, position, networked, dynamic, _placeOnGround) {
+        return getGame().object.createObject(modelHash, position.x, position.y, position.z, networked, false, dynamic);
+    }
+    deleteEntity(entity) {
+        tryGetEntity(entity)?.destroy();
+    }
+    attachEntityToEntity(entity, target, boneIndex, offset, rotation) {
+        getGame().entity.attachToEntity(entity, target, boneIndex, offset.x, offset.y, offset.z, rotation.x, rotation.y, rotation.z, false, false, false, false, 0, true);
+    }
+    getPedBoneIndex(ped, bone) {
+        return getGame().ped.getBoneIndex(ped, bone);
+    }
+    taskPlayAnim(ped, dict, anim, blendInSpeed, blendOutSpeed, duration, flags, playbackRate) {
+        tryGetPed(ped)?.taskPlayAnim(dict, anim, blendInSpeed, blendOutSpeed, duration, flags, playbackRate, false, false, false);
+    }
+    stopAnimTask(ped, dict, anim, blendOutSpeed) {
+        tryGetPed(ped)?.stopAnimTask(dict, anim, blendOutSpeed);
+    }
+    clearPedTasks(ped) {
+        tryGetPed(ped)?.clearTasks();
+    }
+    clearPedTasksImmediately(ped) {
+        tryGetPed(ped)?.clearTasksImmediately();
+    }
+    freezeEntityPosition(entity, toggle) {
+        getGame().entity.freezePosition(entity, toggle);
+    }
+    setEntityInvincible(entity, toggle) {
+        getGame().entity.setInvincible(entity, toggle);
+    }
+    giveWeaponToPed(ped, weaponHash, ammoCount, _hidden, forceInHand) {
+        tryGetPed(ped)?.giveWeapon(weaponHash, ammoCount, forceInHand);
+    }
+    removeAllPedWeapons(ped, _includeCurrentWeapon) {
+        tryGetPed(ped)?.removeAllWeapons();
+    }
+    getClosestPed(position, radius) {
+        const ped = getGame().ped.getClosestPed(position.x, position.y, position.z, radius, true, true, true, false, -1);
+        return ped !== 0 ? ped : null;
+    }
+    getNearbyPeds(position, radius, excludeEntity) {
+        return getMp()
+            .peds.toArray()
+            .filter((ped) => {
+            if (excludeEntity !== undefined && ped.handle === excludeEntity)
+                return false;
+            const coords = ped.position;
+            return this.getDistanceBetweenCoords(position, toCoreVector3(coords), true) <= radius;
+        })
+            .map((ped) => ped.handle);
+    }
+    taskLookAtEntity(ped, entity, duration) {
+        tryGetPed(ped)?.taskLookAt(entity, duration, 2048, 3);
+    }
+    taskLookAtCoord(ped, position, duration) {
+        getGame().task.lookAtCoord(ped, position.x, position.y, position.z, duration, 2048, 3);
+    }
+    taskGoStraightToCoord(ped, position, speed) {
+        tryGetPed(ped)?.taskGoStraightToCoord(position.x, position.y, position.z, speed, -1, 0, 0);
+    }
+    setPedCombatAttributes() { }
+    createVehicle(modelHash, position, heading, networked, scriptHostVehicle) {
+        return getGame().vehicle.createVehicle(modelHash, position.x, position.y, position.z, heading, networked, scriptHostVehicle, false);
+    }
+    deleteVehicle(vehicle) {
+        tryGetEntity(vehicle)?.destroy();
+    }
+    setVehicleOnGroundProperly(vehicle) {
+        getMp().vehicles.atHandle(vehicle).setOnGroundProperly();
+    }
+    getVehicleColours(vehicle) {
+        const colors = getGame().vehicle.getColours(vehicle);
+        return [colors.colorPrimary, colors.colorSecondary];
+    }
+    setVehicleColours(vehicle, primary, secondary) {
+        getGame().vehicle.setColours(vehicle, primary, secondary);
+    }
+    setVehicleNumberPlateText(vehicle, plateText) {
+        getGame().vehicle.setNumberPlateText(vehicle, plateText);
+    }
+    taskWarpPedIntoVehicle(ped, vehicle, seatIndex) {
+        getGame().task.taskEnterVehicle(ped, vehicle, -1, seatIndex, 2, 1, 0);
+    }
+    taskLeaveVehicle(ped, vehicle, flags) {
+        tryGetPed(ped)?.taskLeaveVehicle(vehicle, flags);
+    }
+    getClosestVehicle(position, radius) {
+        const vehicle = getGame().vehicle.getClosestVehicle(position.x, position.y, position.z, radius, 0, 71);
+        return vehicle !== 0 ? vehicle : null;
+    }
+    isPedInAnyVehicle(ped) {
+        return getGame().ped.isInAnyVehicle(ped, false);
+    }
+    getVehiclePedIsIn(ped, lastVehicle) {
+        const vehicle = getGame().ped.getVehicleIsIn(ped, lastVehicle);
+        return vehicle !== 0 ? vehicle : null;
+    }
+    getPedInVehicleSeat(vehicle, seatIndex) {
+        const ped = getGame().vehicle.getPedInSeat(vehicle, seatIndex, false);
+        return ped !== 0 ? ped : null;
+    }
+    getEntitySpeed(entity) {
+        return getGame().entity.getSpeed(entity);
+    }
+    networkGetNetworkIdFromEntity(entity) {
+        return getGame().network.getNetworkIdFromEntity(entity);
+    }
+    networkDoesEntityExistWithNetworkId(networkId) {
+        return getGame().network.doesEntityExistWithNetworkId(networkId);
+    }
+    networkGetEntityFromNetworkId(networkId) {
+        return getGame().network.netToEnt(networkId);
+    }
+    getEntityHeading(entity) {
+        return getGame().entity.getHeading(entity);
+    }
+    getEntityModel(entity) {
+        return getGame().entity.getModel(entity);
+    }
+    setVehicleModKit(vehicle, kit) {
+        getGame().vehicle.setModKit(vehicle, kit);
+    }
+    setVehicleMod(vehicle, modType, modIndex, customTires) {
+        getGame().vehicle.setMod(vehicle, modType, modIndex, customTires);
+    }
+    toggleVehicleMod(vehicle, modType, toggle) {
+        getGame().vehicle.toggleMod(vehicle, modType, toggle);
+    }
+    setVehicleWheelType(vehicle, wheelType) {
+        getGame().vehicle.setWheelType(vehicle, wheelType);
+    }
+    setVehicleWindowTint(vehicle, tint) {
+        getGame().vehicle.setWindowTint(vehicle, tint);
+    }
+    setVehicleLivery(vehicle, livery) {
+        getGame().vehicle.setLivery(vehicle, livery);
+    }
+    setVehicleNumberPlateTextIndex(vehicle, index) {
+        getGame().vehicle.setNumberPlateTextIndex(vehicle, index);
+    }
+    setVehicleNeonLightEnabled(vehicle, index, enabled) {
+        getGame().vehicle.setNeonLightEnabled(vehicle, index, enabled);
+    }
+    setVehicleNeonLightsColour(vehicle, r, g, b) {
+        getGame().vehicle.setNeonLightsColour(vehicle, r, g, b);
+    }
+    setVehicleExtra(vehicle, extraId, disable) {
+        getGame().vehicle.setExtra(vehicle, extraId, disable);
+    }
+    getVehicleExtraColours(vehicle) {
+        const colors = getGame().vehicle.getExtraColours(vehicle);
+        return [colors.pearlescentColor, colors.wheelColor];
+    }
+    setVehicleExtraColours(vehicle, pearl, wheel) {
+        getGame().vehicle.setExtraColours(vehicle, pearl, wheel);
+    }
+    setVehicleFixed(vehicle) {
+        getGame().vehicle.setFixed(vehicle);
+    }
+    setVehicleDeformationFixed(vehicle) {
+        getGame().vehicle.setDeformationFixed(vehicle);
+    }
+    setVehicleUndriveable(vehicle, toggle) {
+        getGame().vehicle.setUndriveable(vehicle, toggle);
+    }
+    setVehicleEngineOn(vehicle, value, instantly, disableAutoStart) {
+        getGame().vehicle.setEngineOn(vehicle, value, instantly, disableAutoStart);
+    }
+    setVehicleEngineHealth(vehicle, health) {
+        getGame().vehicle.setEngineHealth(vehicle, health);
+    }
+    setVehiclePetrolTankHealth(vehicle, health) {
+        getGame().vehicle.setPetrolTankHealth(vehicle, health);
+    }
+    setVehicleFuelLevel(_vehicle, _level) { }
+    getVehicleFuelLevel(_vehicle) {
+        return 0;
+    }
+    setVehicleDoorsLocked(vehicle, doorLockStatus) {
+        getGame().vehicle.setDoorsLocked(vehicle, doorLockStatus);
+    }
+    setEntityHeading(entity, heading) {
+        getGame().entity.setHeading(entity, heading);
+    }
+    setEntityCoords(entity, position) {
+        getGame().entity.setCoords(entity, position.x, position.y, position.z, false, false, false, true);
+    }
+    setEntityCoordsNoOffset(entity, position) {
+        getGame().entity.setCoordsNoOffset(entity, position.x, position.y, position.z, false, false, false);
+    }
+    setEntityHealth(entity, health) {
+        getGame().entity.setHealth(entity, health, 0);
+    }
+    getEntityMaxHealth(entity) {
+        return getGame().entity.getMaxHealth(entity);
+    }
+    setPedArmour(ped, armour) {
+        getGame().ped.setArmour(ped, armour);
+    }
+    networkIsSessionStarted() {
+        return this.playerReady;
+    }
+    isScreenFadedOut() {
+        return getGame().cam.isScreenFadedOut();
+    }
+    isScreenFadingOut() {
+        return getGame().cam.isScreenFadingOut();
+    }
+    doScreenFadeOut(ms) {
+        getGame().cam.doScreenFadeOut(ms);
+    }
+    isScreenFadedIn() {
+        return getGame().cam.isScreenFadedIn();
+    }
+    isScreenFadingIn() {
+        return getGame().cam.isScreenFadingIn();
+    }
+    doScreenFadeIn(ms) {
+        getGame().cam.doScreenFadeIn(ms);
+    }
+    networkResurrectLocalPlayer(position, heading) {
+        getMp().players.local.position = toMpVector3(position);
+        getMp().players.local.heading = heading;
+    }
+    playerId() {
+        return 0;
+    }
+    setPlayerModel(_playerId, modelHash) {
+        getGame().player.setModel(modelHash);
+    }
+    requestCollisionAtCoord(position) {
+        getGame().streaming.requestCollisionAtCoord(position.x, position.y, position.z);
+    }
+    shutdownLoadingScreen() {
+        getGame().script.setNoLoadingScreen(true);
+        getGame().script.shutdownLoadingScreen();
+    }
+    shutdownLoadingScreenNui() { }
+    hasCollisionLoadedAroundEntity(_entity) {
+        return true;
+    }
+    resetEntityAlpha(entity) {
+        tryGetEntity(entity)?.resetAlpha();
+    }
+    setEntityAlpha(entity, alphaLevel) {
+        tryGetEntity(entity)?.setAlpha(alphaLevel);
+    }
+    setEntityVisible(entity, toggle) {
+        getGame().entity.setVisible(entity, toggle, false);
+    }
+    setEntityCollision(entity, toggle) {
+        getGame().entity.setCollision(entity, toggle, true);
+    }
+    getVehicleNumberPlateText(vehicle) {
+        return getGame().vehicle.getNumberPlateText(vehicle);
+    }
+    requestScriptAudioBank(_bank, _networked) {
+        return false;
+    }
+};
+exports.RageMPPlatformBridge = RageMPPlatformBridge;
+exports.RageMPPlatformBridge = RageMPPlatformBridge = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __metadata("design:paramtypes", [])
+], RageMPPlatformBridge);

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

@@ -0,0 +1,30 @@
+import { IClientRuntimeBridge } from '@open-core/framework/contracts/client';
+type CommandHandler = (...args: readonly unknown[]) => void;
+type RuntimeHandler = (...args: readonly unknown[]) => void | Promise<void>;
+type RuntimeExport = (...args: readonly unknown[]) => unknown;
+/**
+ * RAGE Multiplayer implementation of the client runtime bridge.
+ *
+ * RageMP does not have NUI, key mappings, or resource exports in the same
+ * way as FiveM. Methods that have no direct equivalent are no-ops or fall
+ * back to sensible alternatives.
+ */
+export declare class RageMPRuntimeBridge extends IClientRuntimeBridge {
+    private readonly tickHandles;
+    private readonly commandHandlers;
+    private tickSeq;
+    private executeRegisteredCommand;
+    getCurrentResourceName(): string;
+    on(eventName: string, handler: RuntimeHandler): void;
+    registerCommand(commandName: string, handler: CommandHandler, _restricted: boolean): void;
+    registerKeyMapping(commandName: string, _description: string, inputMapper: string, key: string): void;
+    setTick(handler: () => void | Promise<void>): unknown;
+    clearTick(handle: unknown): void;
+    getGameTimer(): number;
+    registerNuiCallback(_eventName: string, _handler: (data: unknown, cb: (response: unknown) => void) => void | Promise<void>): void;
+    sendNuiMessage(_message: string): void;
+    setNuiFocus(_hasFocus: boolean, _hasCursor: boolean): void;
+    setNuiFocusKeepInput(_keepInput: boolean): void;
+    registerExport(exportName: string, handler: RuntimeExport): void;
+}
+export {};

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

@@ -0,0 +1,119 @@
+"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.RageMPRuntimeBridge = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+const exports_registry_1 = require("../shared/exports-registry");
+const key_maps_1 = require("./key-maps");
+/**
+ * RAGE Multiplayer implementation of the client runtime bridge.
+ *
+ * RageMP does not have NUI, key mappings, or resource exports in the same
+ * way as FiveM. Methods that have no direct equivalent are no-ops or fall
+ * back to sensible alternatives.
+ */
+let RageMPRuntimeBridge = class RageMPRuntimeBridge extends client_1.IClientRuntimeBridge {
+    constructor() {
+        super(...arguments);
+        this.tickHandles = new Map();
+        this.commandHandlers = new Map();
+        this.tickSeq = 0;
+    }
+    executeRegisteredCommand(commandName, ...args) {
+        const handler = this.commandHandlers.get(commandName);
+        if (!handler)
+            return;
+        handler(...args);
+    }
+    getCurrentResourceName() {
+        // RageMP does not provide an equivalent to FiveM's GetCurrentResourceName().
+        // Client scripts are executed from the compiled bundle inside the resource
+        // folder (usually under `client_packages/<resourceName>/...`).
+        // To emulate FiveM behaviour in the adapter layer, we infer the resource
+        // name by parsing `__dirname` and extracting the folder located directly
+        // after `client_packages`. If the structure cannot be detected, we fall
+        // back to the last directory name.
+        if (typeof __dirname !== 'string')
+            return 'default';
+        const normalized = __dirname.replace(/\\/g, '/');
+        const parts = normalized.split('/');
+        const clientPackageLastIndex = parts.lastIndexOf('client_packages');
+        if (clientPackageLastIndex !== -1 && parts[clientPackageLastIndex + 1]) {
+            return parts[clientPackageLastIndex + 1];
+        }
+        // fallback: last folder name
+        return parts[parts.length - 1] || 'default';
+    }
+    on(eventName, handler) {
+        mp.events.add(eventName, (...args) => {
+            void handler(...args);
+        });
+    }
+    registerCommand(commandName, handler, _restricted) {
+        if (commandName.startsWith('+') || commandName.startsWith('-')) {
+            this.commandHandlers.set(commandName, handler);
+            return;
+        }
+        // RageMP does not support registering chat/console commands from the client.
+    }
+    registerKeyMapping(commandName, _description, inputMapper, key) {
+        let keyCode;
+        if (inputMapper === 'keyboard') {
+            keyCode = key_maps_1.KEYBOARD_KEY_MAP[key.toUpperCase()];
+        }
+        else if (inputMapper === 'mouse_button') {
+            keyCode = key_maps_1.MOUSE_KEY_MAP[key.toUpperCase()];
+        }
+        if (keyCode === undefined)
+            return;
+        mp.keys.bind(keyCode, true, () => {
+            this.executeRegisteredCommand(commandName);
+        });
+        mp.keys.bind(keyCode, false, () => {
+            this.executeRegisteredCommand(commandName.startsWith('+') ? `-${commandName.slice(1)}` : `-${commandName}`);
+        });
+    }
+    setTick(handler) {
+        const handle = ++this.tickSeq;
+        const interval = setInterval(() => {
+            void handler();
+        }, 0);
+        this.tickHandles.set(handle, interval);
+        return handle;
+    }
+    clearTick(handle) {
+        const interval = this.tickHandles.get(handle);
+        if (interval !== undefined) {
+            clearInterval(interval);
+            this.tickHandles.delete(handle);
+        }
+    }
+    getGameTimer() {
+        return mp.game.misc.getGameTimer();
+    }
+    registerNuiCallback(_eventName, _handler) {
+        // TODO: Still looking for a good way to implement this.
+    }
+    sendNuiMessage(_message) {
+        // TODO: Still looking for a good way to implement this.
+    }
+    setNuiFocus(_hasFocus, _hasCursor) {
+        // TODO: Still looking for a good way to implement this.
+    }
+    setNuiFocusKeepInput(_keepInput) {
+        // TODO: Still looking for a good way to implement this.
+    }
+    registerExport(exportName, handler) {
+        exports_registry_1.exportsRegistry.register(this.getCurrentResourceName(), exportName, handler);
+    }
+};
+exports.RageMPRuntimeBridge = RageMPRuntimeBridge;
+exports.RageMPRuntimeBridge = RageMPRuntimeBridge = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPRuntimeBridge);

package/dist/client/ragemp-runtime-globals.d.ts

@@ -0,0 +1,5 @@
+export declare function tryGetRageMP(): Mp | undefined;
+export declare function hasRageMPRuntime(): boolean;
+export declare function getRageMP(): Mp;
+export declare function getRageMPGame(): GameMp;
+export declare function waitForRageMPRuntime(timeoutMs?: number, intervalMs?: number): Promise<Mp>;

package/dist/client/ragemp-runtime-globals.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryGetRageMP = tryGetRageMP;
+exports.hasRageMPRuntime = hasRageMPRuntime;
+exports.getRageMP = getRageMP;
+exports.getRageMPGame = getRageMPGame;
+exports.waitForRageMPRuntime = waitForRageMPRuntime;
+let cachedRuntime;
+function resolveFromDirectGlobal() {
+    try {
+        return Function('return typeof mp !== "undefined" ? mp : undefined')();
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveFromObject(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value.mp;
+    return candidate && typeof candidate === 'object' ? candidate : undefined;
+}
+function tryGetRageMP() {
+    if (cachedRuntime)
+        return cachedRuntime;
+    const resolved = resolveFromDirectGlobal() ??
+        resolveFromObject(globalThis) ??
+        resolveFromObject(globalThis.global) ??
+        resolveFromObject(globalThis.window);
+    if (resolved) {
+        cachedRuntime = resolved;
+    }
+    return resolved;
+}
+function hasRageMPRuntime() {
+    return tryGetRageMP() !== undefined;
+}
+function getRageMP() {
+    const runtime = tryGetRageMP();
+    if (!runtime) {
+        throw new Error('RageMP client runtime `mp` is not available in this environment.');
+    }
+    return runtime;
+}
+function getRageMPGame() {
+    return getRageMP().game;
+}
+async function waitForRageMPRuntime(timeoutMs = 3000, intervalMs = 25) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        const runtime = tryGetRageMP();
+        if (runtime)
+            return runtime;
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new Error('RageMP client runtime `mp` did not become available in time.');
+}