rock-mod 0.21.0 → 0.22.0

package/dist/client/entities/ccmp/player/CCMPPlayersManager.d.ts

@@ -9,9 +9,10 @@ import { CCMPPlayer } from "./CCMPPlayer";
  *
  * ### Хранилище
  *
- * `Map<id, CCMPPlayer>`. У CCMP нет отдельных `id`/`remoteId` как в RageMP:
- * один числовой `id` приходит от сервера, и он же используется везде.
- * `findByID`/`findByRemoteID`/`findByRemoteId` маппятся на один lookup.
+ * `Map<id, CCMPPlayer>`. For CCMP players only, `id` and `remoteId` still
+ * mean the same server/network id. Non-player CCMP wrappers have a separate
+ * client-local `id` and nullable server `remoteId`.
+ * `findByID`/`findByRemoteID`/`findByRemoteId` map to one lookup for players.
  *
  * ### Жизненный цикл local player'а
  *

package/dist/client/entities/ccmp/player/CCMPPlayersManager.js

@@ -7,9 +7,10 @@ import { CCMPPlayer } from "./CCMPPlayer";
  *
  * ### Хранилище
  *
- * `Map<id, CCMPPlayer>`. У CCMP нет отдельных `id`/`remoteId` как в RageMP:
- * один числовой `id` приходит от сервера, и он же используется везде.
- * `findByID`/`findByRemoteID`/`findByRemoteId` маппятся на один lookup.
+ * `Map<id, CCMPPlayer>`. For CCMP players only, `id` and `remoteId` still
+ * mean the same server/network id. Non-player CCMP wrappers have a separate
+ * client-local `id` and nullable server `remoteId`.
+ * `findByID`/`findByRemoteID`/`findByRemoteId` map to one lookup for players.
  *
  * ### Жизненный цикл local player'а
  *
@@ -62,16 +63,28 @@ export class CCMPPlayersManager {
             [ClientInternalEventName.PlayerReady]: (player) => {
                 // Если кто-то ещё эмитнул rm::playerReady (например, cooperation
                 // fallback в будущем) — синхронизируем своё состояние.
-                this._ensurePlayer(player.remoteId, player.name, /* isLocal */ true);
+                const remoteId = player.remoteId;
+                if (remoteId === null) {
+                    return;
+                }
+                this._ensurePlayer(remoteId, player.name, /* isLocal */ true);
             },
             [ClientInternalEventName.PlayerConnected]: (player) => {
-                this._ensurePlayer(player.remoteId, player.name, /* isLocal */ false);
+                const remoteId = player.remoteId;
+                if (remoteId === null) {
+                    return;
+                }
+                this._ensurePlayer(remoteId, player.name, /* isLocal */ false);
             },
             [ClientInternalEventName.PlayerDisconnected]: (player) => {
-                const existing = this._players.get(player.remoteId);
+                const remoteId = player.remoteId;
+                if (remoteId === null) {
+                    return;
+                }
+                const existing = this._players.get(remoteId);
                 if (existing) {
                     existing.markRemoved();
-                    this._players.delete(player.remoteId);
+                    this._players.delete(remoteId);
                 }
             },
         });

package/dist/client/entities/ccmp/vehicle/CCMPVehicle.d.ts

@@ -0,0 +1,119 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { type IRGB, type IVector3D, Vector3D } from "../../../../shared/common/utils";
+import { type IBaseObject } from "../../common/baseObject/IBaseObject";
+import { type ILightState, type IVehicle } from "../../common/vehicle/IVehicle";
+export interface ICCMPNativeVehicle {
+    readonly id: number;
+    readonly remoteId: number | null;
+    readonly isRemote: boolean;
+    readonly handle: number;
+    readonly model: number;
+    readonly dimension: number;
+    readonly isAlive: boolean;
+    readonly isExists?: boolean;
+    readonly position: IVector3D;
+    readonly rotation: IVector3D;
+    readonly heading: number;
+    readonly numberPlateText: string;
+    readonly numberPlate: string;
+    destroy(): boolean;
+}
+export declare class CCMPVehicle implements IVehicle {
+    private readonly _ccmpVehicle;
+    private readonly _onDestroy;
+    private _destroyed;
+    constructor(_ccmpVehicle: ICCMPNativeVehicle, _onDestroy?: (vehicle: CCMPVehicle) => void);
+    get id(): number;
+    get remoteId(): number | null;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get handle(): number;
+    destroy(): void;
+    get position(): Vector3D;
+    get dimension(): number;
+    setPosition(_value: IVector3D): void;
+    setDimension(_value: number): void;
+    setCoords(_xPos: number, _yPos: number, _zPos: number, _xAxis: boolean, _yAxis: boolean, _zAxis: boolean, _clearArea: boolean): void;
+    get model(): number;
+    get heading(): number;
+    setHeading(_heading: number): void;
+    setModel(_value: string): void;
+    get rotation(): Vector3D;
+    get forwardVector(): Vector3D;
+    setRotation(_value: IVector3D): void;
+    freezePosition(_freeze: boolean): void;
+    setCollision(_collision: boolean, _keepPhysics: boolean): void;
+    setInvincible(_invincible: boolean): void;
+    setVisible(_visible: boolean): void;
+    setAlpha(alpha: number): void;
+    get alpha(): number;
+    resetAlpha(): void;
+    getOffsetFromInWorldCoords(offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    getBoneIndexByName(boneName: string): number;
+    getWorldPositionOfBone(boneIndex: number): IVector3D;
+    getVariable(name: string): unknown | null;
+    getSyncedMeta(key: string): unknown | undefined;
+    hasSyncedMeta(key: string): boolean;
+    getSyncedMetaKeys(): readonly string[];
+    attachToEntity(_target: IBaseObject, _boneIndex: number, _offset: IVector3D, _rotation: IVector3D, _p9: boolean, _useSoftPinning: boolean, _collision: boolean, _isPed: boolean, _vertexIndex: number, _fixedRot: boolean): void;
+    detach(_useDetachVelocity: boolean, _collision: boolean): void;
+    getSpeed(): number;
+    isPlayingAnim(_dictionary: string, _name: string, _taskFlag: number): boolean;
+    get bodyHealth(): number;
+    get engineHealth(): number;
+    get numberPlate(): string;
+    get isDead(): boolean;
+    setBodyHealth(_value: number): void;
+    setEngineHealth(_value: number): void;
+    setNumberPlate(_value: string): void;
+    explode(): void;
+    getPedInSeat(seat: number): number;
+    setUndriveable(_toggle: boolean): void;
+    get maxNumberOfPassengers(): number;
+    get gear(): number;
+    get speed(): number;
+    get isEngineRunning(): boolean;
+    setEngineOn(_toggle: boolean, _instantly: boolean, _otherwise: boolean): void;
+    get lightsState(): ILightState;
+    get isLocked(): boolean;
+    setIsLocked(_value: boolean): void;
+    setCustomPrimaryColour(color: IRGB): void;
+    setCustomSecondaryColour(color: IRGB): void;
+    get customPrimaryColour(): IRGB;
+    get customSecondaryColour(): IRGB;
+    setMod(modType: number, modIndex: number): void;
+    getMod(modType: number): number;
+    getNumMods(modType: number): number;
+    setNeonLightEnabled(index: number, toggle: boolean): void;
+    setNeonLightsColour(color: IRGB): void;
+    setWindowTint(tintType: number): void;
+    get windowTint(): number;
+    setWheelType(wheelType: number): void;
+    get wheelType(): number;
+    setNumberPlateTextIndex(_index: number): void;
+    get numberPlateTextIndex(): number;
+    setDoorOpen(_doorIndex: number, _loose: boolean, _openInstantly: boolean): void;
+    setDoorShut(_doorIndex: number, _instantly: boolean): void;
+    setHandling(_field: string, _value: number): void;
+    getHandling(_field: string): number;
+    setEnginePowerMultiplier(_value: number): void;
+    setEngineTorqueMultiplier(_value: number): void;
+    modifyTopSpeed(_value: number): void;
+    setCheatPowerIncrease(_value: number): void;
+    toggleMod(modType: number, toggle: boolean): void;
+    setTyreSmokeColor(r: number, g: number, b: number): void;
+    setModColor1(paintType: number, color: number, p3: number): void;
+    setExtraColours(_pearlescentColor: number, _wheelColor: number): void;
+    setHeadlightColor(colorIndex: number): void;
+    setDashboardColor(colorIndex: number): void;
+    setInteriorColor(colorIndex: number): void;
+    getMaxBraking(): number;
+    getAcceleration(): number;
+    getMaxTraction(): number;
+    getModelMaxSpeed(): number;
+    private _withHandle;
+    private _withHandleVoid;
+    private _setModKit;
+    private _getRemoteVehicleExists;
+    private _getOffsetFromCachedTransform;
+}

package/dist/client/entities/ccmp/vehicle/CCMPVehicle.js

@@ -0,0 +1,392 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+const notImplemented = (memberName) => {
+    throw new Error(`CCMPVehicle.${memberName}: not implemented`);
+};
+export class CCMPVehicle {
+    constructor(_ccmpVehicle, _onDestroy = () => { }) {
+        this._ccmpVehicle = _ccmpVehicle;
+        this._onDestroy = _onDestroy;
+        this._destroyed = false;
+    }
+    get id() {
+        return this._ccmpVehicle.id;
+    }
+    get remoteId() {
+        return this._ccmpVehicle.remoteId;
+    }
+    get type() {
+        return BaseObjectType.Vehicle;
+    }
+    get isExists() {
+        var _a;
+        if (this._destroyed)
+            return false;
+        if (this._ccmpVehicle.isRemote) {
+            return this._getRemoteVehicleExists();
+        }
+        return !this._destroyed && ((_a = this._ccmpVehicle.isExists) !== null && _a !== void 0 ? _a : this._ccmpVehicle.isAlive);
+    }
+    get handle() {
+        const handle = Number(this._ccmpVehicle.handle);
+        return Number.isFinite(handle) && handle > 0 ? Math.trunc(handle) : 0;
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._ccmpVehicle.destroy();
+        this._onDestroy(this);
+    }
+    get position() {
+        const { x, y, z } = this._ccmpVehicle.position;
+        return new Vector3D(x, y, z);
+    }
+    get dimension() {
+        return this._ccmpVehicle.dimension;
+    }
+    setPosition(_value) {
+        notImplemented("setPosition");
+    }
+    setDimension(_value) {
+        notImplemented("setDimension");
+    }
+    setCoords(_xPos, _yPos, _zPos, _xAxis, _yAxis, _zAxis, _clearArea) {
+        notImplemented("setCoords");
+    }
+    get model() {
+        return this._ccmpVehicle.model;
+    }
+    get heading() {
+        return this._ccmpVehicle.heading;
+    }
+    setHeading(_heading) {
+        notImplemented("setHeading");
+    }
+    setModel(_value) {
+        notImplemented("setModel");
+    }
+    get rotation() {
+        const { x, y, z } = this._ccmpVehicle.rotation;
+        return new Vector3D(x, y, z);
+    }
+    get forwardVector() {
+        const headingRad = (this.heading * Math.PI) / 180;
+        return new Vector3D(-Math.sin(headingRad), Math.cos(headingRad), 0);
+    }
+    setRotation(_value) {
+        notImplemented("setRotation");
+    }
+    freezePosition(_freeze) {
+        notImplemented("freezePosition");
+    }
+    setCollision(_collision, _keepPhysics) {
+        notImplemented("setCollision");
+    }
+    setInvincible(_invincible) {
+        notImplemented("setInvincible");
+    }
+    setVisible(_visible) {
+        notImplemented("setVisible");
+    }
+    setAlpha(alpha) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.setEntityAlpha(handle, alpha, false);
+        });
+    }
+    get alpha() {
+        return this._withHandle(255, (handle) => ccmp.natives.entity.getEntityAlpha(handle));
+    }
+    resetAlpha() {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.resetEntityAlpha(handle);
+        });
+    }
+    getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ) {
+        return this._withHandle(this._getOffsetFromCachedTransform(offsetX, offsetY, offsetZ), (handle) => {
+            const { x, y, z } = ccmp.natives.entity.getOffsetFromEntityInWorldCoords(handle, offsetX, offsetY, offsetZ);
+            return new Vector3D(x, y, z);
+        });
+    }
+    getBoneIndexByName(boneName) {
+        return this._withHandle(-1, (handle) => ccmp.natives.entity.getEntityBoneIndexByName(handle, boneName));
+    }
+    getWorldPositionOfBone(boneIndex) {
+        return this._withHandle(this.position, (handle) => {
+            const { x, y, z } = ccmp.natives.entity.getWorldPositionOfEntityBone(handle, boneIndex);
+            return new Vector3D(x, y, z);
+        });
+    }
+    getVariable(name) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return null;
+        }
+        const value = ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId, name);
+        return value === undefined ? null : value;
+    }
+    getSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return undefined;
+        }
+        return ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId, key);
+    }
+    hasSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return false;
+        }
+        return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId, key);
+    }
+    getSyncedMetaKeys() {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return [];
+        }
+        return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId);
+    }
+    attachToEntity(_target, _boneIndex, _offset, _rotation, _p9, _useSoftPinning, _collision, _isPed, _vertexIndex, _fixedRot) {
+        notImplemented("attachToEntity");
+    }
+    detach(_useDetachVelocity, _collision) {
+        notImplemented("detach");
+    }
+    getSpeed() {
+        return notImplemented("getSpeed");
+    }
+    isPlayingAnim(_dictionary, _name, _taskFlag) {
+        return notImplemented("isPlayingAnim");
+    }
+    get bodyHealth() {
+        return notImplemented("bodyHealth");
+    }
+    get engineHealth() {
+        return notImplemented("engineHealth");
+    }
+    get numberPlate() {
+        var _a;
+        return (_a = this._ccmpVehicle.numberPlate) !== null && _a !== void 0 ? _a : this._ccmpVehicle.numberPlateText;
+    }
+    get isDead() {
+        return !this.isExists;
+    }
+    setBodyHealth(_value) {
+        notImplemented("setBodyHealth");
+    }
+    setEngineHealth(_value) {
+        notImplemented("setEngineHealth");
+    }
+    setNumberPlate(_value) {
+        notImplemented("setNumberPlate");
+    }
+    explode() {
+        notImplemented("explode");
+    }
+    getPedInSeat(seat) {
+        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getPedInVehicleSeat(handle, seat, false));
+    }
+    setUndriveable(_toggle) {
+        notImplemented("setUndriveable");
+    }
+    get maxNumberOfPassengers() {
+        return notImplemented("maxNumberOfPassengers");
+    }
+    get gear() {
+        return notImplemented("gear");
+    }
+    get speed() {
+        return notImplemented("speed");
+    }
+    get isEngineRunning() {
+        return notImplemented("isEngineRunning");
+    }
+    setEngineOn(_toggle, _instantly, _otherwise) {
+        notImplemented("setEngineOn");
+    }
+    get lightsState() {
+        return notImplemented("lightsState");
+    }
+    get isLocked() {
+        return notImplemented("isLocked");
+    }
+    setIsLocked(_value) {
+        notImplemented("setIsLocked");
+    }
+    setCustomPrimaryColour(color) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleCustomPrimaryColour(handle, color.r, color.g, color.b);
+        });
+    }
+    setCustomSecondaryColour(color) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleCustomSecondaryColour(handle, color.r, color.g, color.b);
+        });
+    }
+    get customPrimaryColour() {
+        return this._withHandle({ r: 0, g: 0, b: 0 }, (handle) => ccmp.natives.vehicle.getVehicleCustomPrimaryColour(handle));
+    }
+    get customSecondaryColour() {
+        return this._withHandle({ r: 0, g: 0, b: 0 }, (handle) => ccmp.natives.vehicle.getVehicleCustomSecondaryColour(handle));
+    }
+    setMod(modType, modIndex) {
+        this._withHandleVoid((handle) => {
+            this._setModKit(handle);
+            ccmp.natives.vehicle.setVehicleMod(handle, modType, modIndex, false);
+        });
+    }
+    getMod(modType) {
+        return this._withHandle(-1, (handle) => ccmp.natives.vehicle.getVehicleMod(handle, modType));
+    }
+    getNumMods(modType) {
+        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getNumVehicleMods(handle, modType));
+    }
+    setNeonLightEnabled(index, toggle) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleNeonEnabled(handle, index, toggle);
+        });
+    }
+    setNeonLightsColour(color) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleNeonColour(handle, color.r, color.g, color.b);
+        });
+    }
+    setWindowTint(tintType) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleWindowTint(handle, tintType);
+        });
+    }
+    get windowTint() {
+        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getVehicleWindowTint(handle));
+    }
+    setWheelType(wheelType) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleWheelType(handle, wheelType);
+        });
+    }
+    get wheelType() {
+        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getVehicleWheelType(handle));
+    }
+    setNumberPlateTextIndex(_index) {
+        notImplemented("setNumberPlateTextIndex");
+    }
+    get numberPlateTextIndex() {
+        return notImplemented("numberPlateTextIndex");
+    }
+    setDoorOpen(_doorIndex, _loose, _openInstantly) {
+        notImplemented("setDoorOpen");
+    }
+    setDoorShut(_doorIndex, _instantly) {
+        notImplemented("setDoorShut");
+    }
+    setHandling(_field, _value) {
+        notImplemented("setHandling");
+    }
+    getHandling(_field) {
+        return notImplemented("getHandling");
+    }
+    setEnginePowerMultiplier(_value) {
+        notImplemented("setEnginePowerMultiplier");
+    }
+    setEngineTorqueMultiplier(_value) {
+        notImplemented("setEngineTorqueMultiplier");
+    }
+    modifyTopSpeed(_value) {
+        notImplemented("modifyTopSpeed");
+    }
+    setCheatPowerIncrease(_value) {
+        notImplemented("setCheatPowerIncrease");
+    }
+    toggleMod(modType, toggle) {
+        this._withHandleVoid((handle) => {
+            this._setModKit(handle);
+            ccmp.natives.vehicle.toggleVehicleMod(handle, modType, toggle);
+        });
+    }
+    setTyreSmokeColor(r, g, b) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleTyreSmokeColor(handle, r, g, b);
+        });
+    }
+    setModColor1(paintType, color, p3) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleModColor1(handle, paintType, color, p3);
+        });
+    }
+    setExtraColours(_pearlescentColor, _wheelColor) {
+        notImplemented("setExtraColours");
+    }
+    setHeadlightColor(colorIndex) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleXenonLightColorIndex(handle, colorIndex);
+        });
+    }
+    setDashboardColor(colorIndex) {
+        this._withHandleVoid((handle) => {
+            var _a;
+            const vehicleNatives = ccmp.natives.vehicle;
+            const setDashboardColor = (_a = vehicleNatives.setVehicleDashboardColor) !== null && _a !== void 0 ? _a : vehicleNatives.setVehicleDashboardColour;
+            if (!setDashboardColor)
+                return;
+            setDashboardColor(handle, colorIndex);
+        });
+    }
+    setInteriorColor(colorIndex) {
+        this._withHandleVoid((handle) => {
+            var _a;
+            const vehicleNatives = ccmp.natives.vehicle;
+            const setInteriorColor = (_a = vehicleNatives.setVehicleInteriorColor) !== null && _a !== void 0 ? _a : vehicleNatives.setVehicleInteriorColour;
+            if (!setInteriorColor)
+                return;
+            setInteriorColor(handle, colorIndex);
+        });
+    }
+    getMaxBraking() {
+        return notImplemented("getMaxBraking");
+    }
+    getAcceleration() {
+        return notImplemented("getAcceleration");
+    }
+    getMaxTraction() {
+        return notImplemented("getMaxTraction");
+    }
+    getModelMaxSpeed() {
+        return notImplemented("getModelMaxSpeed");
+    }
+    _withHandle(fallback, callback) {
+        const handle = this.handle;
+        if (!handle) {
+            return fallback;
+        }
+        return callback(handle);
+    }
+    _withHandleVoid(callback) {
+        const handle = this.handle;
+        if (!handle) {
+            return;
+        }
+        callback(handle);
+    }
+    _setModKit(handle) {
+        ccmp.natives.vehicle.setVehicleModKit(handle, 0);
+    }
+    _getRemoteVehicleExists() {
+        var _a;
+        try {
+            return (_a = this._ccmpVehicle.isExists) !== null && _a !== void 0 ? _a : true;
+        }
+        catch (_b) {
+            return true;
+        }
+    }
+    _getOffsetFromCachedTransform(offsetX, offsetY, offsetZ) {
+        const position = this.position;
+        const headingRad = (this.heading * Math.PI) / 180;
+        const rightX = Math.cos(headingRad);
+        const rightY = Math.sin(headingRad);
+        const forwardX = -Math.sin(headingRad);
+        const forwardY = Math.cos(headingRad);
+        return new Vector3D(position.x + rightX * offsetX + forwardX * offsetY, position.y + rightY * offsetX + forwardY * offsetY, position.z + offsetZ);
+    }
+}

package/dist/client/entities/ccmp/vehicle/CCMPVehiclesManager.d.ts

@@ -1,54 +1,11 @@
 import { type IVehicle } from "../../common/vehicle/IVehicle";
 import { type IVehicleCreateOptions, type IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
 import { type IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
-/**
- * Реализация `IVehiclesManager` под CCMP — **пустой пул** + native helper.
- *
- * ### Почему пусто
- *
- * RageMP даёт `mp.vehicles.toArray()`/`mp.vehicles.at(id)` — JS-side pool из
- * stream'нутых-в-радиус транспортных средств, заполняемый рантаймом. CCMP
- * такого пула на client-side не экспонирует:
- *  - `ccmp.natives.vehicle.createVehicle` создаёт локальный handle без id /
- *    replication / managed lifecycle.
- *  - `ccmp.vehicles.*` (server-side) спавнит реплицируемые vehicle-сущности,
- *    но клиент видит их данные через game state, а не как managed-IVehicle-
- *    инстансы в JS-pool'е.
- *
- * Поэтому iterator всегда пустой, `find*` возвращает null, `get*` и `deleteById` кидают.
- *
- * ### Hot path: `iterator.all()` на каждый render-tick
- *
- * Геймод-консьюмер `VehiclePartsInteractionController.syncVehicleProximity` →
- * `VehiclePartsInteractionService.syncState` → `VehicleService.getNearbyVehicles`
- * → `VehicleRepository.getNearby` → `VehicleRepository.getAll` → `iterator.all()`.
- * До этой реализации `VehiclesManager` был `createNotImplementedProxy`, и каждый
- * frame падал `CCMPVehiclesManager.iterator.all: not implemented yet`. Теперь
- * iterator возвращает пустой итератор — interaction-сервис тихо деградирует
- * (нет vehicles в радиусе → нет UI-хинтов / интеракций).
- *
- * ### `create(...)` под CCMP
- *
- * Не реализован осознанно: `VehicleRepository.create(...)` в геймоде ожидает
- * `IRockModVehicle` с id/remoteId/position/etc, а CCMP-натив `createVehicle`
- * возвращает только handle без id-mapping'а. Для корректной поддержки нужен
- * полноценный `CCMPVehicle`-класс и интеграция с server-side `ccmp.vehicles.*`
- * — отдельная задача. Сейчас бросаем понятную ошибку.
- *
- * ### `getDisplayNameFromVehicleModel`
- *
- * Этот метод **реализован** — натив `getDisplayNameFromVehicleModel`
- * (`0xB215AAC32D25D019`) экспонирован в `ccmp.natives.vehicle.*` и работает
- * без vehicle-pool'а (принимает только modelHash, возвращает GXT-ключ или
- * "CARNOTFOUND" для unknown-моделей).
- *
- * TODO: когда понадобится spawning vehicles из клиента (миссии, тестовые
- * объекты) — реализовать через `ccmp.natives.vehicle.createVehicle` + локальный
- * id-counter + `CCMPVehicle`-обёртку. Для синхронизированных vehicles нужна
- * server-side фабрика с `ccmp.vehicles.create` и net-events для распространения
- * id-mapping'а.
- */
 export declare class CCMPVehiclesManager implements IVehiclesManager {
+    private readonly _vehicles;
+    private readonly _vehiclesByRemoteId;
+    private readonly _iterator;
+    constructor();
     create(options: IVehicleCreateOptions): IVehicle;
     getDisplayNameFromVehicleModel(modelHash: number): string;
     syncWithMpPool(): void;
@@ -60,5 +17,11 @@ export declare class CCMPVehiclesManager implements IVehiclesManager {
     getByRemoteID(remoteId: number): IVehicle;
     deleteById(id: number): IVehicle;
     get iterator(): IWorldObjectsIterator<IVehicle>;
-    private readonly _iterator;
+    private _register;
+    private _unregister;
+    private _findRegistered;
+    private _registerLifecycleEvents;
+    private _filter;
+    private _pruneDestroyed;
+    private _getNativeVehiclesApi;
 }