rock-mod 0.20.0 → 0.22.0

package/dist/client/net/ccmp/events/CCMPInProcessEmitter.js

@@ -0,0 +1,133 @@
+const RENDER_EVENT = "rm::render";
+const RENDER_LISTENER_WARN_THRESHOLD_MS = 10;
+function getCCMPCallbackProfiler() {
+    return globalThis;
+}
+function profileLabel(event) {
+    return `rm internal "${event}"`;
+}
+function captureRegistrationSite() {
+    var _a;
+    const stack = String((_a = new Error().stack) !== null && _a !== void 0 ? _a : "");
+    const lines = stack
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    for (const line of lines) {
+        if (line === "Error" ||
+            line.includes("captureRegistrationSite") ||
+            line.includes("CCMPInProcessEmitter") ||
+            line.includes("getCCMPCallbackProfiler") ||
+            line.includes("profileLabel")) {
+            continue;
+        }
+        return line.replace(/^at\s+/, "");
+    }
+    return "<unknown>";
+}
+/**
+ * Тонкий внутренний event bus.
+ *
+ * RageMP даёт `mp.events.call(name, ...args)` для локальной шины поверх своего
+ * движка событий. У CCMP нативной внутренней шины нет — её роль выполняет этот
+ * класс. Используется только из `CCMPEventsManager` для `onInternal` /
+ * `offInternal` / `emitInternal` и из `CCMPEventsBridge` для синтезированных
+ * `rm::*` событий.
+ *
+ * Поддерживает "sticky" events (см. `emitSticky`) для one-shot lifecycle-
+ * сигналов (например `rm::playerReady`), которые могут эмититься до того,
+ * как поздние подписчики из DI-цепочки геймода успели зарегистрироваться.
+ * Sticky-кэш гарантирует, что любой `on()`-вызов после `emitSticky` получит
+ * последнее значение synchronously.
+ */
+export class CCMPInProcessEmitter {
+    constructor() {
+        this._listeners = new Map();
+        /** Кэш аргументов для sticky-events. См. `emitSticky` / `on`. */
+        this._stickyCache = new Map();
+    }
+    on(event, listener) {
+        var _a, _b;
+        let bucket = this._listeners.get(event);
+        if (!bucket) {
+            bucket = new Set();
+            this._listeners.set(event, bucket);
+        }
+        bucket.add(listener);
+        (_b = (_a = getCCMPCallbackProfiler()).__ccmp_registerCallbackProfile) === null || _b === void 0 ? void 0 : _b.call(_a, profileLabel(event), listener, captureRegistrationSite());
+        // Sticky replay: если событие уже было эмитнуто как sticky — сразу
+        // воспроизводим последнее значение новому подписчику. Это решает гонку
+        // "CCMPEventsBridge эмитит rm::playerReady до того, как геймод-адаптер
+        // успел подписаться" — типично для async DI-bootstrap'а.
+        const sticky = this._stickyCache.get(event);
+        if (sticky !== undefined) {
+            try {
+                this._callListener(event, listener, sticky);
+            }
+            catch (error) {
+                console.error(`[CCMPInProcessEmitter] sticky replay "${event}" failed for new subscriber:`, error);
+            }
+        }
+    }
+    off(event, listener) {
+        const bucket = this._listeners.get(event);
+        if (!bucket) {
+            return;
+        }
+        if (listener) {
+            bucket.delete(listener);
+            if (bucket.size === 0) {
+                this._listeners.delete(event);
+            }
+            return;
+        }
+        this._listeners.delete(event);
+    }
+    emit(event, ...args) {
+        const bucket = this._listeners.get(event);
+        if (!bucket || bucket.size === 0) {
+            return;
+        }
+        // Копия на случай, если хендлер изменит реестр во время итерации.
+        for (const listener of [...bucket]) {
+            try {
+                this._callListener(event, listener, args);
+            }
+            catch (error) {
+                console.error(`[CCMPInProcessEmitter] listener "${event}" failed:`, error);
+            }
+        }
+    }
+    /**
+     * Как `emit`, но дополнительно кэширует args, чтобы любой будущий
+     * `on(event, listener)` сразу получил воспроизведение последнего значения.
+     *
+     * Использовать только для one-shot lifecycle-событий (`rm::playerReady` и
+     * т.п.), где "позднее" подписавшийся обработчик всё равно должен получить
+     * сигнал. Для регулярных событий (`rm::playerConnected` на каждого нового
+     * игрока) sticky-кэш приведёт к нежелательному поведению — используйте
+     * обычный `emit`.
+     *
+     * Кэш переписывается на каждый последующий вызов с тем же event'ом, так
+     * что подписчики получат последнее значение, не цепочку историй.
+     */
+    emitSticky(event, ...args) {
+        this._stickyCache.set(event, args);
+        this.emit(event, ...args);
+    }
+    /**
+     * Удаляет sticky-кэш для события. Полезно на disconnect/reset, чтобы
+     * новые подписчики не получили устаревший local-player-stub.
+     */
+    clearSticky(event) {
+        this._stickyCache.delete(event);
+    }
+    _callListener(event, listener, args) {
+        const profiler = getCCMPCallbackProfiler().__ccmp_profileCallback;
+        if (profiler) {
+            profiler(profileLabel(event), listener, args, event === RENDER_EVENT ? RENDER_LISTENER_WARN_THRESHOLD_MS : undefined);
+            return;
+        }
+        listener(...args);
+    }
+}

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

@@ -0,0 +1,18 @@
+import { type CCMPEventsManager } from "./CCMPEventsManager";
+/**
+ * Per-frame событие `rm::render` под CCMP.
+ *
+ * У RageMP клиента есть нативный raw-event `render`, на котором завязаны
+ * декораторы `@Render` и `@Interval` в геймоде. Современный CCMP runtime
+ * эмитит coalesced native `ccmp.on("render")` из game loop; используем его,
+ * чтобы render не зависел от JS timer pump и не копился в очереди.
+ *
+ * `setInterval` остаётся только fallback'ом для старых runtime.
+ */
+export declare class CCMPRenderTicker {
+    private _emitter;
+    private _handle;
+    private _nativeRenderRegistered;
+    start(emitter: CCMPEventsManager): void;
+    stop(): void;
+}

package/dist/client/net/ccmp/events/CCMPRenderTicker.js

@@ -0,0 +1,74 @@
+import { ClientInternalEventName } from "../../common/events/types";
+const TARGET_FPS = 60;
+const TICK_INTERVAL_MS = Math.floor(1000 / TARGET_FPS);
+/**
+ * Достаём `setInterval` из global scope не вызывая ReferenceError.
+ *
+ * Под bare deno_core просто `setInterval` бросает `ReferenceError: setInterval
+ * is not defined` ещё до того как мы можем проверить `typeof`. `globalThis`
+ * безопасен — обращение к несуществующему свойству даёт `undefined`.
+ */
+function getSetInterval() {
+    const fn = globalThis.setInterval;
+    return typeof fn === "function" ? fn : null;
+}
+function getClearInterval() {
+    const fn = globalThis.clearInterval;
+    return typeof fn === "function" ? fn : null;
+}
+function getNativeRenderEventSource() {
+    const maybeCcmp = globalThis.ccmp;
+    return typeof (maybeCcmp === null || maybeCcmp === void 0 ? void 0 : maybeCcmp.on) === "function" ? maybeCcmp : null;
+}
+/**
+ * Per-frame событие `rm::render` под CCMP.
+ *
+ * У RageMP клиента есть нативный raw-event `render`, на котором завязаны
+ * декораторы `@Render` и `@Interval` в геймоде. Современный CCMP runtime
+ * эмитит coalesced native `ccmp.on("render")` из game loop; используем его,
+ * чтобы render не зависел от JS timer pump и не копился в очереди.
+ *
+ * `setInterval` остаётся только fallback'ом для старых runtime.
+ */
+export class CCMPRenderTicker {
+    constructor() {
+        this._emitter = null;
+        this._handle = null;
+        this._nativeRenderRegistered = false;
+    }
+    start(emitter) {
+        var _a;
+        this._emitter = emitter;
+        const nativeRender = getNativeRenderEventSource();
+        if (nativeRender) {
+            if (!this._nativeRenderRegistered) {
+                this._nativeRenderRegistered = true;
+                (_a = nativeRender.on) === null || _a === void 0 ? void 0 : _a.call(nativeRender, "render", () => {
+                    var _a;
+                    (_a = this._emitter) === null || _a === void 0 ? void 0 : _a.emitInternal(ClientInternalEventName.Render);
+                });
+            }
+            return;
+        }
+        if (this._handle !== null)
+            return;
+        const setIntervalFn = getSetInterval();
+        if (!setIntervalFn) {
+            console.warn('[CCMPRenderTicker] native `ccmp.on("render")` and `setInterval` are unavailable. ' +
+                "`rm::render` will not be emitted.");
+            return;
+        }
+        this._handle = setIntervalFn(() => {
+            var _a;
+            (_a = this._emitter) === null || _a === void 0 ? void 0 : _a.emitInternal(ClientInternalEventName.Render);
+        }, TICK_INTERVAL_MS);
+    }
+    stop() {
+        if (this._handle !== null) {
+            const clearIntervalFn = getClearInterval();
+            clearIntervalFn === null || clearIntervalFn === void 0 ? void 0 : clearIntervalFn(this._handle);
+            this._handle = null;
+        }
+        this._emitter = null;
+    }
+}

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

@@ -0,0 +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;
+}
+/**
+ * Translates CCMP `streamSyncedMetaChange` into Rock-Mod's internal
+ * `rm::syncedMetaChange` for stream-synced base objects.
+ */
+export declare class CCMPSyncedMetaBridge {
+    private readonly _events;
+    private readonly _managers;
+    private _registered;
+    constructor(events: CCMPEventsManager, managers: ICCMPSyncedMetaBridgeManagers);
+    register(): void;
+    private _resolveObject;
+}

package/dist/client/net/ccmp/events/CCMPSyncedMetaBridge.js

@@ -0,0 +1,45 @@
+import { ClientInternalEventName } from "../../common/events/types";
+/**
+ * Translates CCMP `streamSyncedMetaChange` into Rock-Mod's internal
+ * `rm::syncedMetaChange` for stream-synced base objects.
+ */
+export class CCMPSyncedMetaBridge {
+    constructor(events, managers) {
+        this._registered = false;
+        this._events = events;
+        this._managers = managers;
+    }
+    register() {
+        if (this._registered) {
+            return;
+        }
+        this._registered = true;
+        ccmp.on("streamSyncedMetaChange", (payload) => {
+            const object = this._resolveObject(payload.entityType, payload.entityId);
+            if (!object) {
+                return;
+            }
+            this._events.emitInternal(ClientInternalEventName.SyncedMetaChange, object, payload.key, payload.newValue, payload.oldValue);
+        });
+    }
+    _resolveObject(entityType, entityId) {
+        switch (entityType) {
+            case ccmp.entities.ENTITY_TYPE.Player:
+                return this._managers.players.findByRemoteId(entityId);
+            case ccmp.entities.ENTITY_TYPE.Vehicle:
+                return this._managers.vehicles.findByRemoteID(entityId);
+            case ccmp.entities.ENTITY_TYPE.Object:
+                return this._managers.objects.findByRemoteID(entityId);
+            case ccmp.entities.ENTITY_TYPE.Ped:
+                return this._managers.peds.findByRemoteID(entityId);
+            case ccmp.entities.ENTITY_TYPE.Marker:
+                return this._managers.markers.findByRemoteID(entityId);
+            case ccmp.entities.ENTITY_TYPE.Blip:
+                return this._managers.blips.findByRemoteID(entityId);
+            case ccmp.entities.ENTITY_TYPE.Colshape:
+                return this._managers.colshapes.findByRemoteID(entityId);
+            default:
+                return null;
+        }
+    }
+}

package/dist/client/net/ccmp/rpc/CCMPRPCManager.d.ts

@@ -0,0 +1,22 @@
+import { type IRPCManager } from "../../common/rpc/IRPCManager";
+import { type IClientRPCList, type IServerRPCList } from "../../../../shared/net/common/rpc/types";
+type UIHandler = (...args: unknown[]) => unknown;
+/**
+ * CCMP implementation of the rock-mod client RPC registry.
+ *
+ * The current gamemod routes UI RPC through the event bridge:
+ * `window.ccmp.emitClient(...)` -> `ccmp.on(...)` -> NetworkRPCService.
+ * `register` therefore keeps the same public contract as RageMP's
+ * `mp.events.addProc` without emitting noisy startup warnings.
+ *
+ * Native client->server RPC is still intentionally unsupported here. The
+ * gamemod uses its correlation-id protocol over `net.events` for that path.
+ */
+export declare class CCMPRPCManager implements IRPCManager {
+    private readonly _uiHandlers;
+    register<K extends keyof IClientRPCList>(rpcName: K, handler: (...args: Parameters<IClientRPCList[K]>) => ReturnType<IClientRPCList[K]>): void;
+    unregister<K extends keyof IClientRPCList>(rpcName: K): void;
+    emitServer<K extends keyof IServerRPCList>(rpcName: K, ...args: Parameters<IServerRPCList[K]>): Promise<ReturnType<IServerRPCList[K]>>;
+    getHandler(name: string): UIHandler | undefined;
+}
+export {};

package/dist/client/net/ccmp/rpc/CCMPRPCManager.js

@@ -0,0 +1,31 @@
+/**
+ * CCMP implementation of the rock-mod client RPC registry.
+ *
+ * The current gamemod routes UI RPC through the event bridge:
+ * `window.ccmp.emitClient(...)` -> `ccmp.on(...)` -> NetworkRPCService.
+ * `register` therefore keeps the same public contract as RageMP's
+ * `mp.events.addProc` without emitting noisy startup warnings.
+ *
+ * Native client->server RPC is still intentionally unsupported here. The
+ * gamemod uses its correlation-id protocol over `net.events` for that path.
+ */
+export class CCMPRPCManager {
+    constructor() {
+        this._uiHandlers = new Map();
+    }
+    register(rpcName, handler) {
+        this._uiHandlers.set(String(rpcName), handler);
+    }
+    unregister(rpcName) {
+        this._uiHandlers.delete(String(rpcName));
+    }
+    emitServer(rpcName, ...args) {
+        void args;
+        return Promise.reject(new Error(`CCMPRPCManager.emitServer(${String(rpcName)}): native client→server ` +
+            `RPC не реализован под CCMP. Используй net.events с собственным ` +
+            `correlationId-протоколом (как делает rock-mod-rpc-caller.adapter).`));
+    }
+    getHandler(name) {
+        return this._uiHandlers.get(name);
+    }
+}

package/dist/client/net/common/dataHandler/IDataHandler.d.ts

@@ -1,4 +1,4 @@
-import { type IEntity } from "../../../entities";
+import { type IBaseObject } from "../../../entities";
 export interface IDataHandler {
-    addDataHandler(key: string, callback: (entity: IEntity, value: unknown, oldValue?: unknown) => void): void;
+    addDataHandler(key: string, callback: (object: IBaseObject, value: unknown, oldValue?: unknown) => void): void;
 }

package/dist/client/net/common/events/types.d.ts

@@ -1,4 +1,4 @@
-import { type IBaseObject, type IEntity, type IPlayer, type IVehicle } from "../../../entities";
+import { type IBaseObject, type IPlayer, type IVehicle } from "../../../entities";
 import { type IVector3D } from "../../../../shared/common/utils";
 export declare enum ClientInternalEventName {
     PlayerConnected = "rm::playerConnected",
@@ -15,7 +15,8 @@ export declare enum ClientInternalEventName {
     PlayerSpawn = "rm::playerSpawn",
     PlayerWeaponShot = "rm::playerWeaponShot",
     Render = "rm::render",
-    Click = "rm::click"
+    Click = "rm::click",
+    SyncedMetaChange = "rm::syncedMetaChange"
 }
 export interface IClickOptions {
     absoluteX: number;
@@ -34,8 +35,8 @@ export interface IClientInternalEvents {
     [ClientInternalEventName.EntityDestroyed]: (object: IBaseObject) => void;
     [ClientInternalEventName.PlayerReady]: (localPlayer: IPlayer) => void;
     [ClientInternalEventName.BrowserDomReady]: () => void;
-    [ClientInternalEventName.EntityStreamIn]: (entity: IEntity) => void;
-    [ClientInternalEventName.EntityStreamOut]: (entity: IEntity) => void;
+    [ClientInternalEventName.EntityStreamIn]: (object: IBaseObject) => void;
+    [ClientInternalEventName.EntityStreamOut]: (object: IBaseObject) => void;
     [ClientInternalEventName.PlayerEnterVehicle]: (vehicle: IVehicle, seat: number) => void;
     [ClientInternalEventName.PlayerLeaveVehicle]: (vehicle: IVehicle, seat: number) => void;
     [ClientInternalEventName.PlayerDeath]: (player: IPlayer) => void;
@@ -43,4 +44,5 @@ export interface IClientInternalEvents {
     [ClientInternalEventName.PlayerWeaponShot]: () => void;
     [ClientInternalEventName.Render]: () => void;
     [ClientInternalEventName.Click]: (options: IClickOptions) => void;
+    [ClientInternalEventName.SyncedMetaChange]: (object: IBaseObject, key: string, value: unknown, oldValue: unknown) => void;
 }

package/dist/client/net/common/events/types.js

@@ -15,4 +15,5 @@ export var ClientInternalEventName;
     ClientInternalEventName["PlayerWeaponShot"] = "rm::playerWeaponShot";
     ClientInternalEventName["Render"] = "rm::render";
     ClientInternalEventName["Click"] = "rm::click";
+    ClientInternalEventName["SyncedMetaChange"] = "rm::syncedMetaChange";
 })(ClientInternalEventName || (ClientInternalEventName = {}));

package/dist/client/net/ragemp/dataHandler/RageDataHandler.d.ts

@@ -1,7 +1,7 @@
-import { type IEntity, type IEntityPoolRouter } from "../../../entities";
+import { type IBaseObject, type IEntityPoolRouter } from "../../../entities";
 import { type IDataHandler } from "../../../net/common/dataHandler/IDataHandler";
 export declare class RageDataHandler implements IDataHandler {
     private readonly _entityPoolRouter;
     constructor(entityPoolRouter: IEntityPoolRouter);
-    addDataHandler(key: string, callback: (entity: IEntity, value: unknown, oldValue?: unknown) => void): void;
+    addDataHandler(key: string, callback: (object: IBaseObject, value: unknown, oldValue?: unknown) => void): void;
 }

package/dist/client/utils/ccmp/CCMPUtilsManager.d.ts

@@ -0,0 +1,18 @@
+import { type IUtilsManager } from "../common/IUtilsManager";
+/**
+ * Реализация `IUtilsManager` под CCMP.
+ *
+ * `hash(value)` — обёртка вокруг `ccmp.natives.misc.getHashKey(value)`,
+ * который вызывает GTA V натив `GET_HASH_KEY` (joaat). Алгоритм идентичен
+ * RageMP'шному `mp.game.joaat(value)`, так что результат бит-в-бит совпадает —
+ * хеши моделей/нативов из shared-кода (`@shared/common/enums/Model`,
+ * `WeaponHash.*`, etc.) валидны в обеих интеграциях.
+ *
+ * **Hot path:** `hash(weaponName)` вызывается каждый render-tick из
+ * `WeaponAmmoDisplayService.renderAmmo` для резолва hash'а текущего оружия.
+ * Это синхронный V8-op без аллокаций, стоимость — единицы микросекунд. JS-side
+ * кешировать не нужно: натив сам кеширует на стороне Rust-рантайма.
+ */
+export declare class CCMPUtilsManager implements IUtilsManager {
+    hash(value: string): number;
+}

package/dist/client/utils/ccmp/CCMPUtilsManager.js

@@ -0,0 +1,20 @@
+/// <reference types="@classic-mp/types/client" />
+/**
+ * Реализация `IUtilsManager` под CCMP.
+ *
+ * `hash(value)` — обёртка вокруг `ccmp.natives.misc.getHashKey(value)`,
+ * который вызывает GTA V натив `GET_HASH_KEY` (joaat). Алгоритм идентичен
+ * RageMP'шному `mp.game.joaat(value)`, так что результат бит-в-бит совпадает —
+ * хеши моделей/нативов из shared-кода (`@shared/common/enums/Model`,
+ * `WeaponHash.*`, etc.) валидны в обеих интеграциях.
+ *
+ * **Hot path:** `hash(weaponName)` вызывается каждый render-tick из
+ * `WeaponAmmoDisplayService.renderAmmo` для резолва hash'а текущего оружия.
+ * Это синхронный V8-op без аллокаций, стоимость — единицы микросекунд. JS-side
+ * кешировать не нужно: натив сам кеширует на стороне Rust-рантайма.
+ */
+export class CCMPUtilsManager {
+    hash(value) {
+        return ccmp.natives.misc.getHashKey(value);
+    }
+}

package/dist/server/RockMod.d.ts

@@ -3,7 +3,7 @@ import { type IBlipsManager, type IColshapesManager, type IMarkersManager, type
 import { type IUtilsManager } from "./utils";
 import { type IManagersFactory } from "./factories/common/IManagersFactory";
 import { type IWorldManager } from "./world";
-type MultiplayerType = "RageMP" | "AltV" | "Mock";
+type MultiplayerType = "RageMP" | "AltV" | "Mock" | "CCMP";
 export interface RockModOptions {
     multiplayer: MultiplayerType;
 }

package/dist/server/RockMod.js

@@ -55,6 +55,10 @@ class RockMod {
                 const { MockManagersFactory } = await Promise.resolve().then(() => __importStar(require("./factories/mock/MockManagersFactory")));
                 return new MockManagersFactory();
             }
+            case "CCMP": {
+                const { CCMPManagersFactory } = await Promise.resolve().then(() => __importStar(require("./factories/ccmp/CCMPManagersFactory")));
+                return new CCMPManagersFactory();
+            }
         }
     }
     _net;

package/dist/server/entities/ccmp/baseObject/CCMPBaseObject.d.ts

@@ -0,0 +1,8 @@
+import { type IBaseObject } from "../../common/baseObject/IBaseObject";
+import { type BaseObjectType } from "../../../../shared";
+export declare abstract class CCMPBaseObject implements IBaseObject {
+    get id(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    destroy(): void;
+}

package/dist/server/entities/ccmp/baseObject/CCMPBaseObject.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPBaseObject = void 0;
+const notImplemented = (name) => {
+    throw new Error(`Not implemented yet: ${name}`);
+};
+class CCMPBaseObject {
+    get id() {
+        return notImplemented("CCMPBaseObject.id");
+    }
+    get type() {
+        return notImplemented("CCMPBaseObject.type");
+    }
+    get isExists() {
+        return notImplemented("CCMPBaseObject.isExists");
+    }
+    destroy() {
+        notImplemented("CCMPBaseObject.destroy");
+    }
+}
+exports.CCMPBaseObject = CCMPBaseObject;

package/dist/server/entities/ccmp/baseObject/CCMPBaseObjectsIterator.d.ts

@@ -0,0 +1,8 @@
+import { type IBaseObjectsIterator } from "../../common/baseObject/IBaseObjectsIterator";
+import { type CCMPBaseObject } from "./CCMPBaseObject";
+export declare class CCMPBaseObjectsIterator<T extends CCMPBaseObject> implements IBaseObjectsIterator<T> {
+    private readonly _baseObjects;
+    constructor(baseObjects: ReadonlyMap<number, T>);
+    protected get baseObjects(): ReadonlyMap<number, T>;
+    all(): IterableIterator<T>;
+}

package/dist/server/entities/ccmp/baseObject/CCMPBaseObjectsIterator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPBaseObjectsIterator = void 0;
+class CCMPBaseObjectsIterator {
+    _baseObjects;
+    constructor(baseObjects) {
+        this._baseObjects = baseObjects;
+    }
+    get baseObjects() {
+        return this._baseObjects;
+    }
+    all() {
+        return this._baseObjects.values();
+    }
+}
+exports.CCMPBaseObjectsIterator = CCMPBaseObjectsIterator;

package/dist/server/entities/ccmp/baseObject/CCMPBaseObjectsManager.d.ts

@@ -0,0 +1,19 @@
+import { type IBaseObjectsManager, type IBaseObjectsManagerOptions } from "../../common/baseObject/IBaseObjectsManager";
+import { type CCMPBaseObject } from "./CCMPBaseObject";
+import { CCMPBaseObjectsIterator } from "./CCMPBaseObjectsIterator";
+import { type BaseObjectType } from "../../../../shared";
+export interface ICCMPBaseObjectsManagerOptions extends IBaseObjectsManagerOptions {
+}
+export declare abstract class CCMPBaseObjectsManager<T extends CCMPBaseObject> implements IBaseObjectsManager<T> {
+    private readonly _baseObjects;
+    private readonly _baseObjectsType;
+    protected readonly _iterator: CCMPBaseObjectsIterator<T>;
+    protected get baseObjects(): ReadonlyMap<number, T>;
+    protected get baseObjectsType(): `${BaseObjectType}`;
+    get iterator(): CCMPBaseObjectsIterator<T>;
+    protected constructor(options: ICCMPBaseObjectsManagerOptions);
+    getByID(id: number): T;
+    findByID(id: number): T | null;
+    protected registerBaseObject(baseObject: T): void;
+    protected unregisterBaseObject(baseObject: T): void;
+}

package/dist/server/entities/ccmp/baseObject/CCMPBaseObjectsManager.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPBaseObjectsManager = void 0;
+const CCMPBaseObjectsIterator_1 = require("./CCMPBaseObjectsIterator");
+const RockMod_1 = require("../../../RockMod");
+const types_1 = require("../../../net/common/events/types");
+class CCMPBaseObjectsManager {
+    _baseObjects;
+    _baseObjectsType;
+    _iterator;
+    get baseObjects() {
+        return this._baseObjects;
+    }
+    get baseObjectsType() {
+        return this._baseObjectsType;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    constructor(options) {
+        this._baseObjects = new Map();
+        this._baseObjectsType = options.baseObjectsType;
+        this._iterator = new CCMPBaseObjectsIterator_1.CCMPBaseObjectsIterator(this._baseObjects);
+    }
+    getByID(id) {
+        const baseObject = this.findByID(id);
+        if (!baseObject) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${id} not found`);
+        }
+        return baseObject;
+    }
+    findByID(id) {
+        return this._baseObjects.get(id) ?? null;
+    }
+    registerBaseObject(baseObject) {
+        if (this._baseObjects.has(baseObject.id)) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} already exists`);
+        }
+        this._baseObjects.set(baseObject.id, baseObject);
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.EntityCreated, baseObject);
+    }
+    unregisterBaseObject(baseObject) {
+        if (!this._baseObjects.delete(baseObject.id)) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} not found`);
+        }
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.EntityDestroyed, baseObject);
+    }
+}
+exports.CCMPBaseObjectsManager = CCMPBaseObjectsManager;

package/dist/server/entities/ccmp/blip/CCMPBlip.d.ts

@@ -0,0 +1,36 @@
+import { CCMPWorldObject } from "../worldObject/CCMPWorldObject";
+import { type IBlip } from "../../common/blip/IBlip";
+import { BaseObjectType, type IBlipColor, type IBlipSprite } from "../../../../shared";
+import { type IVector3D } from "../../../../shared/common/utils/math/Vectors";
+import type { Blip as CcmpBlip } from "@classic-mp/types/server";
+export interface ICCMPBlipOptions {
+    ccmpBlip: CcmpBlip;
+    onDestroy: (blip: CCMPBlip) => void;
+}
+export declare class CCMPBlip extends CCMPWorldObject implements IBlip {
+    private readonly _ccmpBlip;
+    private readonly _onDestroy;
+    get id(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get position(): IVector3D;
+    get dimension(): number;
+    get name(): string;
+    get sprite(): IBlipSprite;
+    get color(): number;
+    get alpha(): number;
+    get scale(): number;
+    get drawDistance(): number;
+    get shortRange(): boolean;
+    get rotation(): number;
+    constructor(options: ICCMPBlipOptions);
+    destroy(): void;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+    getNetData(name: string): unknown;
+    setNetData(name: string, value: unknown): void;
+    setName(value: string): void;
+    setSprite(value: IBlipSprite): void;
+    setColor(value: IBlipColor): void;
+    setAlpha(value: number): void;
+}