@open-core/framework 1.0.5-beta.2 → 1.0.6

package/dist/runtime/client/adapter/node-client-adapter.js

@@ -5,20 +5,29 @@ import { NodeClientLocalPlayerBridge } from './node-local-player-bridge';
 import { NodeClientNotificationBridge } from './node-notification-bridge';
 import { IClientLogConsole } from '../../../adapters/contracts/client/IClientLogConsole';
 import { IClientSpawnBridge } from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
+import { IClientSpawnPort } from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
 import { IClientBlipBridge } from '../../../adapters/contracts/client/ui/IClientBlipBridge';
 import { IClientMarkerBridge } from '../../../adapters/contracts/client/ui/IClientMarkerBridge';
 import { IClientNotificationBridge } from '../../../adapters/contracts/client/ui/IClientNotificationBridge';
 import { IClientWebViewBridge } from '../../../adapters/contracts/client/ui/webview/IClientWebViewBridge';
 import { installNodeClientLogConsole, NodeClientLogConsole } from './node-log-console';
 import { NodeClientBlipBridge } from './node-blip-bridge';
+import { NodeClientCameraPort } from './node-camera-port';
 import { NodeClientMarkerBridge } from './node-marker-bridge';
+import { NodeClientPedPort } from './node-ped-port';
 import { NodeClientPlatformBridge } from './node-platform-bridge';
+import { NodeClientProgressPort } from './node-progress-port';
 import { NodeClientSpawnBridge } from './node-spawn-bridge';
+import { NodeClientVehiclePort } from './node-vehicle-port';
 import { NodeClientWebViewBridge } from './node-webview-bridge';
 import { IClientPlatformBridge } from './platform-bridge';
 import { NodeClientRuntimeBridge } from './node-runtime-bridge';
 import { defineClientAdapter } from './client-adapter';
 import { IClientRuntimeBridge } from './runtime-bridge';
+import { IClientCameraPort } from '../../../adapters/contracts/client/camera/IClientCameraPort';
+import { IClientPedPort } from '../../../adapters/contracts/client/ped/IClientPedPort';
+import { IClientProgressPort } from '../../../adapters/contracts/client/progress/IClientProgressPort';
+import { IClientVehiclePort } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
 /**
  * Default client adapter used when no runtime adapter is provided.
  */
@@ -38,7 +47,12 @@ export function createNodeClientAdapter() {
             ctx.bindSingleton(IClientRuntimeBridge, NodeClientRuntimeBridge);
             ctx.bindSingleton(IClientLocalPlayerBridge, NodeClientLocalPlayerBridge);
             ctx.bindSingleton(IClientPlatformBridge, NodeClientPlatformBridge);
-            ctx.bindSingleton(IClientSpawnBridge, NodeClientSpawnBridge);
+            ctx.bindSingleton(IClientCameraPort, NodeClientCameraPort);
+            ctx.bindSingleton(IClientVehiclePort, NodeClientVehiclePort);
+            ctx.bindSingleton(IClientPedPort, NodeClientPedPort);
+            ctx.bindSingleton(IClientProgressPort, NodeClientProgressPort);
+            ctx.bindSingleton(IClientSpawnPort, NodeClientSpawnBridge);
+            ctx.bindFactory(IClientSpawnBridge, () => ctx.container.resolve(IClientSpawnPort));
             ctx.bindSingleton(IClientBlipBridge, NodeClientBlipBridge);
             ctx.bindSingleton(IClientMarkerBridge, NodeClientMarkerBridge);
             ctx.bindSingleton(IClientNotificationBridge, NodeClientNotificationBridge);

package/dist/runtime/client/adapter/node-local-player-bridge.d.ts

@@ -4,5 +4,8 @@ import { IClientLocalPlayerBridge } from './local-player-bridge';
  * Node fallback local player bridge.
  */
 export declare class NodeClientLocalPlayerBridge extends IClientLocalPlayerBridge {
+    getHandle(): number;
+    getPosition(): Vector3;
+    getHeading(): number;
     setPosition(_position: Vector3, _heading?: number): void;
 }

package/dist/runtime/client/adapter/node-local-player-bridge.js

@@ -10,6 +10,15 @@ import { IClientLocalPlayerBridge } from './local-player-bridge';
  * Node fallback local player bridge.
  */
 let NodeClientLocalPlayerBridge = class NodeClientLocalPlayerBridge extends IClientLocalPlayerBridge {
+    getHandle() {
+        return 0;
+    }
+    getPosition() {
+        return { x: 0, y: 0, z: 0 };
+    }
+    getHeading() {
+        return 0;
+    }
     setPosition(_position, _heading) { }
 };
 NodeClientLocalPlayerBridge = __decorate([

package/dist/runtime/client/adapter/node-log-console.js

@@ -17,26 +17,26 @@ let NodeClientLogConsole = class NodeClientLogConsole extends IClientLogConsole
         return NODE_CLIENT_LOG_CAPABILITIES;
     }
     trace(message, details) {
-        this.write(console.debug, message, details);
+        this.write('debug', message, details);
     }
     debug(message, details) {
-        this.write(console.debug, message, details);
+        this.write('debug', message, details);
     }
     info(message, details) {
-        this.write(console.info, message, details);
+        this.write('info', message, details);
     }
     warn(message, details) {
-        this.write(console.warn, message, details);
+        this.write('warn', message, details);
     }
     error(message, details) {
-        this.write(console.error, message, details);
+        this.write('error', message, details);
     }
-    write(method, message, details) {
+    write(level, message, details) {
         if (details === undefined) {
-            method(message);
+            console[level](message);
             return;
         }
-        method(message, details);
+        console[level](message, details);
     }
 };
 NodeClientLogConsole = __decorate([

package/dist/runtime/client/adapter/node-ped-port.d.ts

@@ -0,0 +1,20 @@
+import { type ClientPedAnimationOptions, type ClientPedSpawnOptions, IClientPedPort } from '../../../adapters/contracts/client/ped/IClientPedPort';
+import type { Vector3 } from '../../../kernel/utils/vector3';
+export declare class NodeClientPedPort extends IClientPedPort {
+    spawn(_options: ClientPedSpawnOptions): Promise<number>;
+    delete(_handle: number): void;
+    exists(_handle: number): boolean;
+    playAnimation(_handle: number, _options: ClientPedAnimationOptions): Promise<void>;
+    stopAnimation(_handle: number): void;
+    stopAnimationImmediately(_handle: number): void;
+    freeze(_handle: number, _freeze: boolean): void;
+    setInvincible(_handle: number, _invincible: boolean): void;
+    giveWeapon(_handle: number, _weapon: string, _ammo?: number, _hidden?: boolean, _forceInHand?: boolean): void;
+    removeAllWeapons(_handle: number): void;
+    getClosest(_radius?: number, _excludeLocalPlayer?: boolean): number | null;
+    getNearby(_position: Vector3, _radius: number, _excludeEntity?: number): number[];
+    lookAtEntity(_handle: number, _entity: number, _duration?: number): void;
+    lookAtCoords(_handle: number, _position: Vector3, _duration?: number): void;
+    walkTo(_handle: number, _position: Vector3, _speed?: number): void;
+    setCombatAttributes(_handle: number, _canFight: boolean, _canUseCover?: boolean): void;
+}

package/dist/runtime/client/adapter/node-ped-port.js

@@ -0,0 +1,38 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IClientPedPort, } from '../../../adapters/contracts/client/ped/IClientPedPort';
+let NodeClientPedPort = class NodeClientPedPort extends IClientPedPort {
+    async spawn(_options) {
+        return 0;
+    }
+    delete(_handle) { }
+    exists(_handle) {
+        return false;
+    }
+    async playAnimation(_handle, _options) { }
+    stopAnimation(_handle) { }
+    stopAnimationImmediately(_handle) { }
+    freeze(_handle, _freeze) { }
+    setInvincible(_handle, _invincible) { }
+    giveWeapon(_handle, _weapon, _ammo = 100, _hidden = false, _forceInHand = true) { }
+    removeAllWeapons(_handle) { }
+    getClosest(_radius = 10, _excludeLocalPlayer = true) {
+        return null;
+    }
+    getNearby(_position, _radius, _excludeEntity) {
+        return [];
+    }
+    lookAtEntity(_handle, _entity, _duration = -1) { }
+    lookAtCoords(_handle, _position, _duration = -1) { }
+    walkTo(_handle, _position, _speed = 1) { }
+    setCombatAttributes(_handle, _canFight, _canUseCover = true) { }
+};
+NodeClientPedPort = __decorate([
+    injectable()
+], NodeClientPedPort);
+export { NodeClientPedPort };

package/dist/runtime/client/adapter/node-progress-port.d.ts

@@ -0,0 +1,8 @@
+import { type ClientProgressOptions, type ClientProgressState, IClientProgressPort } from '../../../adapters/contracts/client/progress/IClientProgressPort';
+export declare class NodeClientProgressPort extends IClientProgressPort {
+    start(_options: ClientProgressOptions): Promise<boolean>;
+    cancel(): void;
+    isActive(): boolean;
+    getProgress(): number;
+    getState(): ClientProgressState | null;
+}

package/dist/runtime/client/adapter/node-progress-port.js

@@ -0,0 +1,27 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IClientProgressPort, } from '../../../adapters/contracts/client/progress/IClientProgressPort';
+let NodeClientProgressPort = class NodeClientProgressPort extends IClientProgressPort {
+    start(_options) {
+        return Promise.resolve(true);
+    }
+    cancel() { }
+    isActive() {
+        return false;
+    }
+    getProgress() {
+        return 0;
+    }
+    getState() {
+        return null;
+    }
+};
+NodeClientProgressPort = __decorate([
+    injectable()
+], NodeClientProgressPort);
+export { NodeClientProgressPort };

package/dist/runtime/client/adapter/node-runtime-bridge.d.ts

@@ -1,7 +1,5 @@
 import { IClientRuntimeBridge } from './runtime-bridge';
-type RuntimeHandler = (...args: readonly unknown[]) => void | Promise<void>;
 type WebViewCallback = (data: unknown, cb: (response: unknown) => void) => void | Promise<void>;
-type RuntimeExport = (...args: readonly unknown[]) => unknown;
 /**
  * Node fallback runtime bridge used in tests and standalone execution.
  */
@@ -9,7 +7,7 @@ export declare class NodeClientRuntimeBridge extends IClientRuntimeBridge {
     private readonly events;
     private readonly tickHandles;
     getCurrentResourceName(): string;
-    on(eventName: string, handler: RuntimeHandler): void;
+    on<TArgs extends readonly unknown[]>(eventName: string, handler: (...args: TArgs) => void | Promise<void>): void;
     registerCommand(_commandName: string, _handler: (...args: readonly unknown[]) => void, _restricted: boolean): void;
     registerKeyMapping(_commandName: string, _description: string, _inputMapper: string, _key: string): void;
     setTick(handler: () => void | Promise<void>): unknown;
@@ -19,6 +17,6 @@ export declare class NodeClientRuntimeBridge extends IClientRuntimeBridge {
     sendNuiMessage(_message: string): void;
     setNuiFocus(_hasFocus: boolean, _hasCursor: boolean): void;
     setNuiFocusKeepInput(_keepInput: boolean): void;
-    registerExport(exportName: string, handler: RuntimeExport): void;
+    registerExport<TArgs extends readonly unknown[], TResult = unknown>(exportName: string, handler: (...args: TArgs) => TResult): void;
 }
 export {};

package/dist/runtime/client/adapter/node-spawn-bridge.d.ts

@@ -1,8 +1,8 @@
-import { IClientSpawnBridge } from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
-import type { RespawnRequest, SpawnRequest, TeleportRequest } from '../../../adapters/contracts/client/spawn/types';
-export declare class NodeClientSpawnBridge extends IClientSpawnBridge {
+import { IClientSpawnPort } from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
+import type { RespawnRequest, SpawnExecutionResult, SpawnRequest, TeleportRequest } from '../../../adapters/contracts/client/spawn/types';
+export declare class NodeClientSpawnBridge extends IClientSpawnPort {
     waitUntilReady(_timeoutMs?: number): Promise<void>;
-    spawn(_request: SpawnRequest): Promise<void>;
-    respawn(_request: RespawnRequest): Promise<void>;
+    spawn(_request: SpawnRequest): Promise<SpawnExecutionResult>;
+    respawn(_request: RespawnRequest): Promise<SpawnExecutionResult>;
     teleport(_request: TeleportRequest): Promise<void>;
 }

package/dist/runtime/client/adapter/node-spawn-bridge.js

@@ -5,11 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { injectable } from 'tsyringe';
-import { IClientSpawnBridge } from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
-let NodeClientSpawnBridge = class NodeClientSpawnBridge extends IClientSpawnBridge {
+import { IClientSpawnPort } from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
+let NodeClientSpawnBridge = class NodeClientSpawnBridge extends IClientSpawnPort {
     async waitUntilReady(_timeoutMs) { }
-    async spawn(_request) { }
-    async respawn(_request) { }
+    async spawn(_request) {
+        return {};
+    }
+    async respawn(_request) {
+        return {};
+    }
     async teleport(_request) { }
 };
 NodeClientSpawnBridge = __decorate([

package/dist/runtime/client/adapter/node-vehicle-port.d.ts

@@ -0,0 +1,31 @@
+import { type ClientVehicleMods, type ClientVehicleSpawnOptions, IClientVehiclePort } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
+import type { Vector3 } from '../../../kernel/utils/vector3';
+export declare class NodeClientVehiclePort extends IClientVehiclePort {
+    spawn(_options: ClientVehicleSpawnOptions): Promise<number>;
+    delete(_vehicle: number): void;
+    repair(_vehicle: number): void;
+    setFuel(_vehicle: number, _level: number): void;
+    getFuel(_vehicle: number): number;
+    getClosest(_radius?: number): number | null;
+    isLocalPlayerInVehicle(): boolean;
+    getCurrentForLocalPlayer(): number | null;
+    getLastForLocalPlayer(): number | null;
+    isLocalPlayerDriver(_vehicle: number): boolean;
+    warpLocalPlayerInto(_vehicle: number, _seatIndex?: number): void;
+    leaveLocalPlayerVehicle(_vehicle: number, _flags?: number): void;
+    applyMods(_vehicle: number, _mods: ClientVehicleMods): void;
+    setDoorsLocked(_vehicle: number, _locked: boolean): void;
+    setEngineRunning(_vehicle: number, _running: boolean, _instant?: boolean): void;
+    setInvincible(_vehicle: number, _invincible: boolean): void;
+    getSpeed(_vehicle: number): number;
+    setHeading(_vehicle: number, _heading: number): void;
+    teleport(_vehicle: number, _position: Vector3, _heading?: number): void;
+    exists(_vehicle: number): boolean;
+    getNetworkId(_vehicle: number): number;
+    getFromNetworkId(_networkId: number): number;
+    getState<T = unknown>(_vehicle: number, _key: string): T | undefined;
+    getPosition(_vehicle: number): Vector3 | null;
+    getHeading(_vehicle: number): number;
+    getModel(_vehicle: number): number;
+    getPlate(_vehicle: number): string;
+}

package/dist/runtime/client/adapter/node-vehicle-port.js

@@ -0,0 +1,73 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IClientVehiclePort, } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
+let NodeClientVehiclePort = class NodeClientVehiclePort extends IClientVehiclePort {
+    async spawn(_options) {
+        return 0;
+    }
+    delete(_vehicle) { }
+    repair(_vehicle) { }
+    setFuel(_vehicle, _level) { }
+    getFuel(_vehicle) {
+        return 0;
+    }
+    getClosest(_radius = 10) {
+        return null;
+    }
+    isLocalPlayerInVehicle() {
+        return false;
+    }
+    getCurrentForLocalPlayer() {
+        return null;
+    }
+    getLastForLocalPlayer() {
+        return null;
+    }
+    isLocalPlayerDriver(_vehicle) {
+        return false;
+    }
+    warpLocalPlayerInto(_vehicle, _seatIndex = -1) { }
+    leaveLocalPlayerVehicle(_vehicle, _flags = 16) { }
+    applyMods(_vehicle, _mods) { }
+    setDoorsLocked(_vehicle, _locked) { }
+    setEngineRunning(_vehicle, _running, _instant = false) { }
+    setInvincible(_vehicle, _invincible) { }
+    getSpeed(_vehicle) {
+        return 0;
+    }
+    setHeading(_vehicle, _heading) { }
+    teleport(_vehicle, _position, _heading) { }
+    exists(_vehicle) {
+        return false;
+    }
+    getNetworkId(_vehicle) {
+        return 0;
+    }
+    getFromNetworkId(_networkId) {
+        return 0;
+    }
+    getState(_vehicle, _key) {
+        return undefined;
+    }
+    getPosition(_vehicle) {
+        return null;
+    }
+    getHeading(_vehicle) {
+        return 0;
+    }
+    getModel(_vehicle) {
+        return 0;
+    }
+    getPlate(_vehicle) {
+        return '';
+    }
+};
+NodeClientVehiclePort = __decorate([
+    injectable()
+], NodeClientVehiclePort);
+export { NodeClientVehiclePort };

package/dist/runtime/client/adapter/node-webview-bridge.d.ts

@@ -10,6 +10,7 @@ export declare class NodeClientWebViewBridge extends IClientWebViewBridge {
     hide(_viewId: string): void;
     focus(_viewId: string, _options?: WebViewFocusOptions): void;
     blur(_viewId: string): void;
+    markAsChat(_viewId: string): void;
     send(_viewId: string, _event: string, _payload: unknown): void;
     onMessage(_handler: (message: WebViewMessage) => void | Promise<void>): () => void;
 }

package/dist/runtime/client/adapter/node-webview-bridge.js

@@ -13,6 +13,7 @@ const NODE_WEBVIEW_CAPABILITIES = {
     supportsBidirectionalMessaging: false,
     supportsExecute: false,
     supportsHeadless: false,
+    supportsChatMode: false,
 };
 let NodeClientWebViewBridge = class NodeClientWebViewBridge extends IClientWebViewBridge {
     views = new Set();
@@ -32,6 +33,7 @@ let NodeClientWebViewBridge = class NodeClientWebViewBridge extends IClientWebVi
     hide(_viewId) { }
     focus(_viewId, _options) { }
     blur(_viewId) { }
+    markAsChat(_viewId) { }
     send(_viewId, _event, _payload) { }
     onMessage(_handler) {
         return () => { };

package/dist/runtime/client/controllers/appearance.controller.d.ts

@@ -1,10 +1,10 @@
 import { PlayerAppearance } from '../../../kernel/shared';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 import { AppearanceService } from '../services/appearance.service';
 export declare class AppearanceTestClientController {
     private readonly appearanceService;
-    private readonly platform;
-    constructor(appearanceService: AppearanceService, platform: IClientPlatformBridge);
+    private readonly localPlayer;
+    constructor(appearanceService: AppearanceService, localPlayer: IClientLocalPlayerBridge);
     onApply(appearance: PlayerAppearance): Promise<void>;
     onReset(): void;
 }

package/dist/runtime/client/controllers/appearance.controller.js

@@ -11,39 +11,40 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject } from 'tsyringe';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
 import { Controller, OnNet } from '../decorators';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 import { AppearanceService } from '../services/appearance.service';
 import { loggers } from '../../../kernel/logger';
 let AppearanceTestClientController = class AppearanceTestClientController {
     appearanceService;
-    platform;
-    constructor(appearanceService, platform) {
+    localPlayer;
+    constructor(appearanceService, localPlayer) {
         this.appearanceService = appearanceService;
-        this.platform = platform;
+        this.localPlayer = localPlayer;
     }
     async onApply(appearance) {
         loggers.netEvent.debug('appearance:apply received', {
             appearance,
         });
-        const ped = this.platform.getLocalPlayerPed();
+        const ped = this.localPlayer.getHandle();
         await this.appearanceService.applyAppearance(ped, appearance);
     }
     onReset() {
         loggers.netEvent.debug('appearance:reset received');
-        const ped = this.platform.getLocalPlayerPed();
+        const ped = this.localPlayer.getHandle();
         this.appearanceService.setDefaultAppearance(ped);
         this.appearanceService.clearTattoos(ped);
     }
 };
 __decorate([
-    OnNet('opencore:appearance:apply'),
+    OnNet(SYSTEM_EVENTS.appearance.apply),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], AppearanceTestClientController.prototype, "onApply", null);
 __decorate([
-    OnNet('opencore:appearance:reset'),
+    OnNet(SYSTEM_EVENTS.appearance.reset),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
@@ -51,8 +52,8 @@ __decorate([
 AppearanceTestClientController = __decorate([
     Controller(),
     __param(0, inject(AppearanceService)),
-    __param(1, inject(IClientPlatformBridge)),
+    __param(1, inject(IClientLocalPlayerBridge)),
     __metadata("design:paramtypes", [AppearanceService,
-        IClientPlatformBridge])
+        IClientLocalPlayerBridge])
 ], AppearanceTestClientController);
 export { AppearanceTestClientController };

package/dist/runtime/client/controllers/spawner.controller.js

@@ -8,6 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { loggers } from '../../../kernel/logger';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
 import { Controller, OnNet } from '../decorators';
 import { SpawnService } from '../services';
 let SpawnerController = class SpawnerController {
@@ -27,19 +28,19 @@ let SpawnerController = class SpawnerController {
     }
 };
 __decorate([
-    OnNet('opencore:spawner:spawn'),
+    OnNet(SYSTEM_EVENTS.spawner.spawn),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], SpawnerController.prototype, "handleSpawn", null);
 __decorate([
-    OnNet('opencore:spawner:respawn'),
+    OnNet(SYSTEM_EVENTS.spawner.respawn),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], SpawnerController.prototype, "handleRespawn", null);
 __decorate([
-    OnNet('opencore:spawner:teleport'),
+    OnNet(SYSTEM_EVENTS.spawner.teleport),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Number]),
     __metadata("design:returntype", Promise)

package/dist/runtime/client/services/camera.d.ts

@@ -1,33 +1,11 @@
 import { Vector3 } from '../../../kernel/utils/vector3';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
-export interface CameraRotation {
-    x: number;
-    y: number;
-    z: number;
-}
-export interface CameraTransform {
-    position: Vector3;
-    rotation?: CameraRotation;
-    fov?: number;
-}
-export interface CameraCreateOptions {
-    camName?: string;
-    active?: boolean;
-    transform?: CameraTransform;
-}
-export interface CameraRenderOptions {
-    ease?: boolean;
-    easeTimeMs?: number;
-}
-export interface CameraShakeOptions {
-    type: string;
-    amplitude: number;
-}
+import { type ClientCameraCreateOptions as CameraCreateOptions, type ClientCameraRenderOptions as CameraRenderOptions, type ClientCameraRotation as CameraRotation, type ClientCameraShakeOptions as CameraShakeOptions, type ClientCameraTransform as CameraTransform, IClientCameraPort } from '../../../adapters/contracts/client/camera/IClientCameraPort';
+export type { CameraCreateOptions, CameraRenderOptions, CameraRotation, CameraShakeOptions, CameraTransform, };
 export declare class Camera {
-    private readonly platform;
+    private readonly cameras;
     private activeCam;
     private rendering;
-    constructor(platform: IClientPlatformBridge);
+    constructor(cameras: IClientCameraPort);
     create(options?: CameraCreateOptions): number;
     getActiveCam(): number | null;
     setActive(cam: number, active: boolean): void;