rock-mod 0.21.0 → 0.22.0

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

@@ -1,105 +1,183 @@
 /// <reference types="@classic-mp/types/client" />
-const EMPTY_VEHICLES = [];
-/**
- * Реализация `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'а.
- */
+import { RockMod } from "../../../RockMod";
+import { ClientInternalEventName } from "../../../net/common/events/types";
+import { CCMPVehicle } from "./CCMPVehicle";
 export class CCMPVehiclesManager {
     constructor() {
-        // -- IVehiclesManager -----------------------------------------------------
-        // Iterator реализован inline и возвращает пустые итераторы — hot path
-        // `VehiclePartsInteractionController.syncVehicleProximity` → `VehicleRepository.getNearby`
-        // теперь тихо деградирует вместо падения на каждом render-tick'е.
+        this._vehicles = new Map();
+        this._vehiclesByRemoteId = new Map();
         this._iterator = {
-            all: () => EMPTY_VEHICLES[Symbol.iterator](),
-            dimension: () => EMPTY_VEHICLES[Symbol.iterator](),
-            range2D: () => EMPTY_VEHICLES[Symbol.iterator](),
-            range3D: () => EMPTY_VEHICLES[Symbol.iterator](),
+            all: () => this._filter(() => true),
+            dimension: (value) => this._filter((vehicle) => vehicle.dimension === value),
+            range2D: (center, range) => this._filter((vehicle) => {
+                const position = vehicle.position;
+                const squaredDistance = (position.x - center.x) ** 2 + (position.y - center.y) ** 2;
+                return squaredDistance <= range * range;
+            }),
+            range3D: (center, range) => this._filter((vehicle) => vehicle.position.isInRange(center, range)),
         };
+        this._registerLifecycleEvents();
+        this.syncWithMpPool();
     }
     create(options) {
-        void options;
-        throw new Error("CCMPVehiclesManager.create: создание vehicles на client-side под CCMP не поддерживается. " +
-            "Используйте server-side `ccmp.vehicles.create` (см. server/entities/ccmp/vehicle/*), " +
-            "либо вызывайте `ccmp.natives.vehicle.createVehicle` напрямую для локального vehicle-handle.");
+        var _a;
+        const ccmpVehicle = (_a = this._getNativeVehiclesApi()) === null || _a === void 0 ? void 0 : _a.create(options.model, options.position, options.rotation, {
+            dimension: options.dimension,
+            engine: options.engine,
+            locked: options.locked,
+        });
+        if (!ccmpVehicle) {
+            throw new Error(`CCMPVehiclesManager.create: ccmp.vehicles.create failed for model "${options.model}"`);
+        }
+        return this._register(ccmpVehicle);
     }
     getDisplayNameFromVehicleModel(modelHash) {
         return ccmp.natives.vehicle.getDisplayNameFromVehicleModel(modelHash);
     }
-    // -- IEntitiesManager -----------------------------------------------------
     syncWithMpPool() {
-        // No-op: client-side vehicle pool под CCMP отсутствует, синхронизировать нечего.
+        this._pruneDestroyed();
+        const ccmpVehicles = this._getNativeVehiclesApi();
+        if (!ccmpVehicles)
+            return;
+        for (const ccmpVehicle of ccmpVehicles.all) {
+            this._register(ccmpVehicle);
+        }
     }
     registerById(id) {
-        throw new Error(`CCMPVehiclesManager.registerById(${id}): client-side vehicle pool под CCMP отсутствует, ` +
-            "регистрировать vehicle по id невозможно.");
+        var _a, _b;
+        const existingVehicle = this.findByID(id);
+        if (existingVehicle)
+            return existingVehicle;
+        const ccmpVehicle = (_b = (_a = this._getNativeVehiclesApi()) === null || _a === void 0 ? void 0 : _a.getById(id)) !== null && _b !== void 0 ? _b : null;
+        if (!ccmpVehicle) {
+            throw new Error(`CCMPVehiclesManager.registerById(${id}): vehicle not found.`);
+        }
+        return this._register(ccmpVehicle);
     }
     unregisterById(id) {
-        throw new Error(`CCMPVehiclesManager.unregisterById(${id}): client-side vehicle pool под CCMP отсутствует, ` +
-            "разрегистрировать vehicle по id невозможно.");
+        return this.deleteById(id);
     }
-    // -- IBaseObjectsManager / IWorldObjectsManager ---------------------------
     findByID(id) {
-        void id;
-        return null;
+        var _a, _b, _c;
+        const vehicle = (_a = this._vehicles.get(id)) !== null && _a !== void 0 ? _a : null;
+        if (vehicle && vehicle.isExists)
+            return vehicle;
+        if (vehicle)
+            this._unregister(vehicle);
+        const ccmpVehicle = (_c = (_b = this._getNativeVehiclesApi()) === null || _b === void 0 ? void 0 : _b.getById(id)) !== null && _c !== void 0 ? _c : null;
+        if (!ccmpVehicle)
+            return null;
+        return this._register(ccmpVehicle);
     }
     getByID(id) {
-        throw new Error(`CCMPVehiclesManager.getByID(${id}): vehicle не найден (пул пуст под CCMP).`);
+        const vehicle = this.findByID(id);
+        if (!vehicle) {
+            throw new Error(`CCMPVehiclesManager.getByID(${id}): vehicle not found.`);
+        }
+        return vehicle;
     }
     findByRemoteID(remoteId) {
-        void remoteId;
-        return null;
+        var _a, _b, _c;
+        const vehicle = (_a = this._vehiclesByRemoteId.get(remoteId)) !== null && _a !== void 0 ? _a : null;
+        if (vehicle && vehicle.isExists)
+            return vehicle;
+        if (vehicle)
+            this._unregister(vehicle);
+        const ccmpVehicle = (_c = (_b = this._getNativeVehiclesApi()) === null || _b === void 0 ? void 0 : _b.getByRemoteId(remoteId)) !== null && _c !== void 0 ? _c : null;
+        if (!ccmpVehicle)
+            return null;
+        return this._register(ccmpVehicle);
     }
     getByRemoteID(remoteId) {
-        throw new Error(`CCMPVehiclesManager.getByRemoteID(${remoteId}): vehicle не найден (пул пуст под CCMP).`);
+        const vehicle = this.findByRemoteID(remoteId);
+        if (!vehicle) {
+            throw new Error(`CCMPVehiclesManager.getByRemoteID(${remoteId}): vehicle not found.`);
+        }
+        return vehicle;
     }
     deleteById(id) {
-        throw new Error(`CCMPVehiclesManager.deleteById(${id}): vehicle не найден (пул пуст под CCMP).`);
+        const vehicle = this.getByID(id);
+        vehicle.destroy();
+        return vehicle;
     }
     get iterator() {
         return this._iterator;
     }
+    _register(ccmpVehicle) {
+        const existingVehicle = this._findRegistered(ccmpVehicle);
+        if (existingVehicle && existingVehicle.isExists)
+            return existingVehicle;
+        if (existingVehicle)
+            this._unregister(existingVehicle);
+        const vehicle = new CCMPVehicle(ccmpVehicle, (destroyedVehicle) => {
+            this._unregister(destroyedVehicle);
+        });
+        this._vehicles.set(vehicle.id, vehicle);
+        if (vehicle.remoteId !== null) {
+            this._vehiclesByRemoteId.set(vehicle.remoteId, vehicle);
+        }
+        return vehicle;
+    }
+    _unregister(vehicle) {
+        this._vehicles.delete(vehicle.id);
+        if (vehicle.remoteId !== null) {
+            this._vehiclesByRemoteId.delete(vehicle.remoteId);
+        }
+    }
+    _findRegistered(ccmpVehicle) {
+        var _a, _b, _c;
+        return ((_c = (_b = (ccmpVehicle.remoteId === null ? null : ((_a = this._vehiclesByRemoteId.get(ccmpVehicle.remoteId)) !== null && _a !== void 0 ? _a : null))) !== null && _b !== void 0 ? _b : this._vehicles.get(ccmpVehicle.id)) !== null && _c !== void 0 ? _c : null);
+    }
+    _registerLifecycleEvents() {
+        const eventsApi = ccmp;
+        eventsApi.on("vehicleCreated", (ccmpVehicle) => {
+            if (!ccmpVehicle)
+                return;
+            const vehicle = this._register(ccmpVehicle);
+            RockMod.instance.net.events.emitInternal(ClientInternalEventName.EntityCreated, vehicle);
+        });
+        eventsApi.on("vehicleDestroyed", (ccmpVehicle) => {
+            var _a;
+            if (!ccmpVehicle)
+                return;
+            const vehicle = (_a = this._findRegistered(ccmpVehicle)) !== null && _a !== void 0 ? _a : this._register(ccmpVehicle);
+            RockMod.instance.net.events.emitInternal(ClientInternalEventName.EntityDestroyed, vehicle);
+            this._unregister(vehicle);
+        });
+        eventsApi.on("vehicleStreamIn", (ccmpVehicle) => {
+            if (!ccmpVehicle)
+                return;
+            const vehicle = this._register(ccmpVehicle);
+            RockMod.instance.net.events.emitInternal(ClientInternalEventName.EntityStreamIn, vehicle);
+        });
+        eventsApi.on("vehicleStreamOut", (ccmpVehicle) => {
+            var _a;
+            if (!ccmpVehicle)
+                return;
+            const vehicle = (_a = this._findRegistered(ccmpVehicle)) !== null && _a !== void 0 ? _a : this._register(ccmpVehicle);
+            RockMod.instance.net.events.emitInternal(ClientInternalEventName.EntityStreamOut, vehicle);
+        });
+    }
+    *_filter(predicate) {
+        for (const vehicle of this._vehicles.values()) {
+            if (!vehicle.isExists) {
+                this._unregister(vehicle);
+                continue;
+            }
+            if (predicate(vehicle)) {
+                yield vehicle;
+            }
+        }
+    }
+    _pruneDestroyed() {
+        for (const vehicle of this._vehicles.values()) {
+            if (!vehicle.isExists) {
+                this._unregister(vehicle);
+            }
+        }
+    }
+    _getNativeVehiclesApi() {
+        var _a;
+        return (_a = ccmp.vehicles) !== null && _a !== void 0 ? _a : null;
+    }
 }

package/dist/client/entities/common/baseObject/IBaseObject.d.ts

@@ -5,7 +5,8 @@ export interface IBaseObjectOptions {
 }
 export interface IBaseObject {
     get id(): number;
-    get remoteId(): number;
+    /** Server/network id for remote objects; null for client-only objects. */
+    get remoteId(): number | null;
     get type(): BaseObjectType;
     get isExists(): boolean;
     get handle(): number;

package/dist/client/entities/ragemp/entity/RageEntity.d.ts

@@ -31,4 +31,8 @@ export declare abstract class RageEntity<T extends EntityMp> extends RageWorldOb
     detach(useDetachVelocity: boolean, collision: boolean): void;
     getSpeed(): number;
     isPlayingAnim(dictionary: string, name: string, taskFlag: number): boolean;
+    private _getNativeRotation;
+    private _getEntityRotationProperty;
+    private _hasValidHandle;
+    private _isVectorLike;
 }

package/dist/client/entities/ragemp/entity/RageEntity.js

@@ -5,8 +5,8 @@ export class RageEntity extends RageWorldObject {
         return this.mpEntity.model;
     }
     get rotation() {
-        const { x, y, z } = this.mpEntity.rotation;
-        return new Vector3D(x, y, z);
+        var _a, _b;
+        return (_b = (_a = this._getNativeRotation()) !== null && _a !== void 0 ? _a : this._getEntityRotationProperty()) !== null && _b !== void 0 ? _b : new Vector3D(0, 0, this.heading);
     }
     constructor(options) {
         super(options);
@@ -22,6 +22,9 @@ export class RageEntity extends RageWorldObject {
     }
     setRotation(value) {
         this.mpEntity.rotation = new mp.Vector3(value);
+        if (this._hasValidHandle()) {
+            mp.game.entity.setRotation(this.handle, value.x, value.y, value.z, 2, true);
+        }
     }
     get forwardVector() {
         const vector = this.mpEntity.getForwardVector();
@@ -88,4 +91,33 @@ export class RageEntity extends RageWorldObject {
     isPlayingAnim(dictionary, name, taskFlag) {
         return mp.game.entity.isPlayingAnim(this.handle, dictionary, name, taskFlag);
     }
+    _getNativeRotation() {
+        if (!this._hasValidHandle())
+            return null;
+        try {
+            const rotation = mp.game.entity.getRotation(this.handle, 2);
+            if (!this._isVectorLike(rotation))
+                return null;
+            return new Vector3D(rotation.x, rotation.y, rotation.z);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    _getEntityRotationProperty() {
+        const rotation = this.mpEntity.rotation;
+        if (!this._isVectorLike(rotation))
+            return null;
+        return new Vector3D(rotation.x, rotation.y, rotation.z);
+    }
+    _hasValidHandle() {
+        return typeof this.handle === "number" && this.handle > 0;
+    }
+    _isVectorLike(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            typeof value.x === "number" &&
+            typeof value.y === "number" &&
+            typeof value.z === "number");
+    }
 }

package/dist/client/factories/ccmp/CCMPManagersFactory.d.ts

@@ -1,16 +1,18 @@
 import { type IManagersFactory } from "../common/IManagersFactory";
 type ManagerReturn<K extends keyof IManagersFactory> = IManagersFactory[K] extends (...args: never[]) => infer R ? R : never;
 export declare class CCMPManagersFactory implements IManagersFactory {
-    /**
-     * Сохраняем созданный `CCMPNetManager` потому что другим менеджерам
-     * (например, `CCMPPlayersManager`) нужен доступ к его событиям. Порядок
-     * создания в `RockMod` гарантирует, что `createNetManager` вызывается
-     * первым — мы можем безопасно полагаться на наличие `_netManager` в
-     * последующих фабричных методах.
-     */
     private _netManager;
+    private _blipsManager;
+    private _colshapesManager;
+    private _markersManager;
+    private _objectsManager;
+    private _pedsManager;
+    private _playersManager;
+    private _vehiclesManager;
+    private _syncedMetaBridgeRegistered;
     createNetManager(): ManagerReturn<"createNetManager">;
     private _requireNetManager;
+    private _registerSyncedMetaBridgeIfReady;
     createBlipsManager(): ManagerReturn<"createBlipsManager">;
     createColshapesManager(): ManagerReturn<"createColshapesManager">;
     createMarkersManager(): ManagerReturn<"createMarkersManager">;

package/dist/client/factories/ccmp/CCMPManagersFactory.js

@@ -8,6 +8,10 @@ import { CCMPControlsManager } from "../../game/ccmp/controls/CCMPControlsManage
 import { CCMPPlayersManager } from "../../entities/ccmp/player/CCMPPlayersManager";
 import { CCMPPedsManager } from "../../entities/ccmp/ped/CCMPPedsManager";
 import { CCMPVehiclesManager } from "../../entities/ccmp/vehicle/CCMPVehiclesManager";
+import { CCMPObjectsManager } from "../../entities/ccmp/object/CCMPObjectsManager";
+import { CCMPMarkersManager } from "../../entities/ccmp/marker/CCMPMarkersManager";
+import { CCMPBlipsManager } from "../../entities/ccmp/blip/CCMPBlipsManager";
+import { CCMPColshapesManager } from "../../entities/ccmp/colshape/CCMPColshapesManager";
 import { CCMPUtilsManager } from "../../utils/ccmp/CCMPUtilsManager";
 import { CCMPGraphicsManager } from "../../game/ccmp/graphics/CCMPGraphicsManager";
 import { CCMPUiManager } from "../../game/ccmp/ui/CCMPUiManager";
@@ -25,14 +29,15 @@ import { CCMPGameplayManager } from "../../game/ccmp/gameplay/CCMPGameplayManage
 import { createNotImplementedProxy } from "./createNotImplementedProxy";
 export class CCMPManagersFactory {
     constructor() {
-        /**
-         * Сохраняем созданный `CCMPNetManager` потому что другим менеджерам
-         * (например, `CCMPPlayersManager`) нужен доступ к его событиям. Порядок
-         * создания в `RockMod` гарантирует, что `createNetManager` вызывается
-         * первым — мы можем безопасно полагаться на наличие `_netManager` в
-         * последующих фабричных методах.
-         */
         this._netManager = null;
+        this._blipsManager = null;
+        this._colshapesManager = null;
+        this._markersManager = null;
+        this._objectsManager = null;
+        this._pedsManager = null;
+        this._playersManager = null;
+        this._vehiclesManager = null;
+        this._syncedMetaBridgeRegistered = false;
     }
     createNetManager() {
         this._netManager = new CCMPNetManager();
@@ -41,41 +46,76 @@ export class CCMPManagersFactory {
     _requireNetManager(forMethod) {
         if (!this._netManager) {
             throw new Error(`CCMPManagersFactory.${forMethod}: ` +
-                "createNetManager() ещё не вызывался. Это нарушение контракта порядка " +
-                "фабричных методов в RockMod-конструкторе.");
+                "createNetManager() was not called yet. This violates RockMod manager factory order.");
         }
         return this._netManager;
     }
+    _registerSyncedMetaBridgeIfReady() {
+        if (this._syncedMetaBridgeRegistered ||
+            !this._netManager ||
+            !this._blipsManager ||
+            !this._colshapesManager ||
+            !this._markersManager ||
+            !this._objectsManager ||
+            !this._pedsManager ||
+            !this._playersManager ||
+            !this._vehiclesManager) {
+            return;
+        }
+        new CCMPSyncedMetaBridge(this._netManager.events, {
+            blips: this._blipsManager,
+            colshapes: this._colshapesManager,
+            markers: this._markersManager,
+            objects: this._objectsManager,
+            peds: this._pedsManager,
+            players: this._playersManager,
+            vehicles: this._vehiclesManager,
+        }).register();
+        this._syncedMetaBridgeRegistered = true;
+    }
     createBlipsManager() {
-        return createNotImplementedProxy("CCMPBlipsManager");
+        const netManager = this._requireNetManager("createBlipsManager");
+        this._blipsManager = new CCMPBlipsManager(netManager.events);
+        this._registerSyncedMetaBridgeIfReady();
+        return this._blipsManager;
     }
     createColshapesManager() {
-        return createNotImplementedProxy("CCMPColshapesManager");
+        const netManager = this._requireNetManager("createColshapesManager");
+        this._colshapesManager = new CCMPColshapesManager(netManager.events);
+        this._registerSyncedMetaBridgeIfReady();
+        return this._colshapesManager;
     }
     createMarkersManager() {
-        return createNotImplementedProxy("CCMPMarkersManager");
+        const netManager = this._requireNetManager("createMarkersManager");
+        this._markersManager = new CCMPMarkersManager(netManager.events);
+        this._registerSyncedMetaBridgeIfReady();
+        return this._markersManager;
     }
     createObjectsManager() {
-        return createNotImplementedProxy("CCMPObjectsManager");
+        const netManager = this._requireNetManager("createObjectsManager");
+        this._objectsManager = new CCMPObjectsManager(netManager.events);
+        this._registerSyncedMetaBridgeIfReady();
+        return this._objectsManager;
     }
     createPedsManager() {
-        return new CCMPPedsManager();
+        const netManager = this._requireNetManager("createPedsManager");
+        this._pedsManager = new CCMPPedsManager(netManager.events);
+        this._registerSyncedMetaBridgeIfReady();
+        return this._pedsManager;
     }
     createPlayersManager() {
         const netManager = this._requireNetManager("createPlayersManager");
-        const playersManager = new CCMPPlayersManager(netManager.events);
-        // Bridge для `streamSyncedMetaChange` создаётся здесь — ему нужен
-        // players manager для резолва `entityId → CCMPPlayer`, а events bus
-        // — для эмиссии `rm::syncedMetaChange` (на который уже подписан
-        // `CCMPDataHandler`, инстанцированный в `CCMPNetManager`).
-        new CCMPSyncedMetaBridge(netManager.events, playersManager).register();
-        return playersManager;
+        this._playersManager = new CCMPPlayersManager(netManager.events);
+        this._registerSyncedMetaBridgeIfReady();
+        return this._playersManager;
     }
     createUtilsManager() {
         return new CCMPUtilsManager();
     }
     createVehiclesManager() {
-        return new CCMPVehiclesManager();
+        this._vehiclesManager = new CCMPVehiclesManager();
+        this._registerSyncedMetaBridgeIfReady();
+        return this._vehiclesManager;
     }
     createBrowserManager() {
         return new CCMPBrowserManager();

package/dist/client/game/ccmp/storage/CCMPStorageManager.d.ts

@@ -1,23 +1,5 @@
 import { type IStorageManager } from "../../common/storage/IStorageManager";
-/**
- * In-memory реализация `IStorageManager` под CCMP.
- *
- * RageMP даёт `mp.storage.data` — персистентное JSON-K/V на диске между
- * сессиями. У CCMP нативного аналога client-side storage пока нет. Этот
- * MVP — обычный `Map` в памяти процесса:
- *  - Данные доступны в рамках одной сессии.
- *  - Не переживают переподключение/перезапуск игры.
- *
- * Этого достаточно для `CacheController` геймода: пустой кэш заставит
- * перезапросить данные с сервера, чуть менее эффективно но функционально.
- *
- * Долгосрочно: добавить persistent storage в CCMP-клиент (Rust) — файл в
- * `%APPDATA%/ccmp/storage/<server>.json` через `Deno.core.ops`, тогда
- * заменить этот класс на адаптер к ops.
- */
 export declare class CCMPStorageManager implements IStorageManager {
-    private readonly _data;
-    constructor();
     getData<T>(key: string): T | null;
     setData<T>(key: string, value: T): void;
     removeData(key: string): void;

package/dist/client/game/ccmp/storage/CCMPStorageManager.js

@@ -1,46 +1,14 @@
-/**
- * In-memory реализация `IStorageManager` под CCMP.
- *
- * RageMP даёт `mp.storage.data` — персистентное JSON-K/V на диске между
- * сессиями. У CCMP нативного аналога client-side storage пока нет. Этот
- * MVP — обычный `Map` в памяти процесса:
- *  - Данные доступны в рамках одной сессии.
- *  - Не переживают переподключение/перезапуск игры.
- *
- * Этого достаточно для `CacheController` геймода: пустой кэш заставит
- * перезапросить данные с сервера, чуть менее эффективно но функционально.
- *
- * Долгосрочно: добавить persistent storage в CCMP-клиент (Rust) — файл в
- * `%APPDATA%/ccmp/storage/<server>.json` через `Deno.core.ops`, тогда
- * заменить этот класс на адаптер к ops.
- */
 export class CCMPStorageManager {
-    constructor() {
-        this._data = new Map();
-        console.warn("[rock-mod] CCMPStorageManager uses in-memory storage; data will not persist between sessions");
-    }
     getData(key) {
-        var _a;
-        if (!this._data.has(key)) {
-            return null;
-        }
-        return (_a = this._data.get(key)) !== null && _a !== void 0 ? _a : null;
+        return ccmp.storage.getItem(key);
     }
     setData(key, value) {
-        this._data.set(key, value);
+        ccmp.storage.setItem(key, value);
     }
     removeData(key) {
-        this._data.delete(key);
+        ccmp.storage.removeItem(key);
     }
     clearData(prefix) {
-        if (!prefix) {
-            this._data.clear();
-            return;
-        }
-        for (const key of [...this._data.keys()]) {
-            if (key.startsWith(prefix)) {
-                this._data.delete(key);
-            }
-        }
+        ccmp.storage.clear(prefix);
     }
 }

package/dist/client/net/ccmp/CCMPNetManager.js

@@ -44,7 +44,7 @@ export class CCMPNetManager {
         this._rpcManager = new CCMPRPCManager();
         // DataHandler сначала, чтобы он успел подписаться на internal-bus до
         // первых эмиссий `rm::syncedMetaChange` от `CCMPSyncedMetaBridge`
-        // (создаётся позже в `CCMPManagersFactory.createPlayersManager`).
+        // (registers later, when all stream-synced base-object managers are ready).
         this._dataHandler = new CCMPDataHandler(this._eventsManager);
         this._bridge = new CCMPEventsBridge(this._eventsManager);
         this._renderTicker = new CCMPRenderTicker();

package/dist/client/net/ccmp/dataHandler/CCMPDataHandler.d.ts

@@ -1,7 +1,7 @@
-import { type IEntity } from "../../../entities";
+import { type IBaseObject } from "../../../entities";
 import { type IDataHandler } from "../../common/dataHandler/IDataHandler";
 import { type CCMPEventsManager } from "../events/CCMPEventsManager";
-type DataHandlerCallback = (entity: IEntity, value: unknown, oldValue?: unknown) => void;
+type DataHandlerCallback = (object: IBaseObject, value: unknown, oldValue?: unknown) => void;
 /**
  * Реализация `IDataHandler` под CCMP поверх `rm::syncedMetaChange`.
  *

package/dist/client/net/ccmp/dataHandler/CCMPDataHandler.js

@@ -16,14 +16,14 @@ export class CCMPDataHandler {
     constructor(events) {
         this._handlers = new Map();
         events.onInternal({
-            [ClientInternalEventName.SyncedMetaChange]: (entity, key, value, oldValue) => {
+            [ClientInternalEventName.SyncedMetaChange]: (object, key, value, oldValue) => {
                 const callbacks = this._handlers.get(key);
                 if (!callbacks || callbacks.length === 0) {
                     return;
                 }
                 for (const callback of [...callbacks]) {
                     try {
-                        callback(entity, value, oldValue);
+                        callback(object, value, oldValue);
                     }
                     catch (error) {
                         console.error(`[CCMPDataHandler] callback for key "${key}" failed:`, error);

package/dist/client/net/ccmp/events/CCMPSyncedMetaBridge.d.ts

@@ -1,24 +1,29 @@
+import { type CCMPBlipsManager } from "../../../entities/ccmp/blip/CCMPBlipsManager";
+import { type CCMPColshapesManager } from "../../../entities/ccmp/colshape/CCMPColshapesManager";
+import { type CCMPMarkersManager } from "../../../entities/ccmp/marker/CCMPMarkersManager";
+import { type CCMPObjectsManager } from "../../../entities/ccmp/object/CCMPObjectsManager";
+import { type CCMPPedsManager } from "../../../entities/ccmp/ped/CCMPPedsManager";
 import { type CCMPPlayersManager } from "../../../entities/ccmp/player/CCMPPlayersManager";
+import { type CCMPVehiclesManager } from "../../../entities/ccmp/vehicle/CCMPVehiclesManager";
 import { type CCMPEventsManager } from "./CCMPEventsManager";
+export interface ICCMPSyncedMetaBridgeManagers {
+    blips: CCMPBlipsManager;
+    colshapes: CCMPColshapesManager;
+    markers: CCMPMarkersManager;
+    objects: CCMPObjectsManager;
+    peds: CCMPPedsManager;
+    players: CCMPPlayersManager;
+    vehicles: CCMPVehiclesManager;
+}
 /**
- * Переводит нативное CCMP-событие `streamSyncedMetaChange` в internal-bus
- * `rm::syncedMetaChange`.
- *
- * Вынесено в отдельный класс от `CCMPEventsBridge` из-за порядка
- * инстанцирования: bridge'у нужна ссылка на `CCMPPlayersManager` чтобы
- * резолвить `payload.entityId → CCMPPlayer`, а players manager создаётся
- * в `CCMPManagersFactory` **после** `CCMPNetManager` (внутри которого
- * живёт `CCMPEventsBridge`). Поэтому этот bridge создаётся вторым
- * шагом из `createPlayersManager`, когда обе зависимости уже доступны.
- *
- * Сейчас обслуживается только `entityType === Player` (=0) — на клиенте
- * rock-mod-CCMP других сущностей пока нет. Остальные типы тихо
- * игнорируем (snapshot прилетает на каждом stream-in, для несуществующих
- * на клиенте сущностей это нормально).
+ * Translates CCMP `streamSyncedMetaChange` into Rock-Mod's internal
+ * `rm::syncedMetaChange` for stream-synced base objects.
  */
 export declare class CCMPSyncedMetaBridge {
     private readonly _events;
-    private readonly _playersManager;
-    constructor(events: CCMPEventsManager, playersManager: CCMPPlayersManager);
+    private readonly _managers;
+    private _registered;
+    constructor(events: CCMPEventsManager, managers: ICCMPSyncedMetaBridgeManagers);
     register(): void;
+    private _resolveObject;
 }