@open-core/framework 1.0.4-beta.1 → 1.0.5-beta.1

package/dist/runtime/client/services/vehicle.service.js

@@ -0,0 +1,293 @@
+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';
+/**
+ * Service for vehicle operations and management.
+ */
+let VehicleService = class VehicleService {
+    /**
+     * Spawn a vehicle at a position.
+     *
+     * @param options - Spawn options
+     * @returns The vehicle handle
+     */
+    async spawn(options) {
+        const { model, position, heading = 0, placeOnGround = true, warpIntoVehicle = false, seatIndex = -1, primaryColor, secondaryColor, plate, networked = true, } = options;
+        const modelHash = GetHashKey(model);
+        // Load the model
+        if (!IsModelInCdimage(modelHash) || !IsModelAVehicle(modelHash)) {
+            throw new Error(`Invalid vehicle model: ${model}`);
+        }
+        RequestModel(modelHash);
+        while (!HasModelLoaded(modelHash)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        // Create the vehicle
+        const vehicle = CreateVehicle(modelHash, position.x, position.y, position.z, heading, networked, false);
+        SetModelAsNoLongerNeeded(modelHash);
+        if (!vehicle || vehicle === 0) {
+            throw new Error('Failed to create vehicle');
+        }
+        // Place on ground
+        if (placeOnGround) {
+            SetVehicleOnGroundProperly(vehicle);
+        }
+        // Set colors
+        if (primaryColor !== undefined || secondaryColor !== undefined) {
+            const [currentPrimary, currentSecondary] = GetVehicleColours(vehicle);
+            SetVehicleColours(vehicle, primaryColor ?? currentPrimary, secondaryColor ?? currentSecondary);
+        }
+        // Set plate
+        if (plate) {
+            SetVehicleNumberPlateText(vehicle, plate);
+        }
+        // Warp player into vehicle
+        if (warpIntoVehicle) {
+            TaskWarpPedIntoVehicle(PlayerPedId(), vehicle, seatIndex);
+        }
+        return vehicle;
+    }
+    /**
+     * Delete a vehicle.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    delete(vehicle) {
+        if (DoesEntityExist(vehicle)) {
+            SetEntityAsMissionEntity(vehicle, true, true);
+            DeleteVehicle(vehicle);
+        }
+    }
+    /**
+     * Delete the vehicle the player is currently in.
+     */
+    deleteCurrentVehicle() {
+        const vehicle = this.getCurrentVehicle();
+        if (vehicle) {
+            TaskLeaveVehicle(PlayerPedId(), vehicle, 16);
+            setTimeout(() => this.delete(vehicle), 1000);
+        }
+    }
+    /**
+     * Repair a vehicle completely.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    repair(vehicle) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetVehicleFixed(vehicle);
+        SetVehicleDeformationFixed(vehicle);
+        SetVehicleUndriveable(vehicle, false);
+        SetVehicleEngineOn(vehicle, true, true, false);
+        SetVehicleEngineHealth(vehicle, 1000.0);
+        SetVehiclePetrolTankHealth(vehicle, 1000.0);
+    }
+    /**
+     * Set vehicle fuel level.
+     *
+     * @param vehicle - Vehicle handle
+     * @param level - Fuel level (0.0-100.0)
+     */
+    setFuel(vehicle, level) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetVehicleFuelLevel(vehicle, Math.max(0, Math.min(100, level * 100)));
+    }
+    /**
+     * Get vehicle fuel level.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Fuel level (0.0-1.0)
+     */
+    getFuel(vehicle) {
+        if (!DoesEntityExist(vehicle))
+            return 0;
+        return GetVehicleFuelLevel(vehicle) / 100;
+    }
+    /**
+     * Get the closest vehicle to the player.
+     *
+     * @param radius - Search radius
+     * @returns Vehicle handle or null
+     */
+    getClosest(radius = 10.0) {
+        const playerPed = PlayerPedId();
+        const [px, py, pz] = GetEntityCoords(playerPed, true);
+        const vehicle = GetClosestVehicle(px, py, pz, radius, 0, 71);
+        return vehicle !== 0 ? vehicle : null;
+    }
+    /**
+     * Check if the player is in a vehicle.
+     */
+    isPlayerInVehicle() {
+        return IsPedInAnyVehicle(PlayerPedId(), false);
+    }
+    /**
+     * Get the vehicle the player is currently in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getCurrentVehicle() {
+        const ped = PlayerPedId();
+        if (!IsPedInAnyVehicle(ped, false))
+            return null;
+        return GetVehiclePedIsIn(ped, false);
+    }
+    /**
+     * Get the last vehicle the player was in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getLastVehicle() {
+        const vehicle = GetVehiclePedIsIn(PlayerPedId(), true);
+        return vehicle !== 0 ? vehicle : null;
+    }
+    /**
+     * Check if player is the driver of their current vehicle.
+     */
+    isPlayerDriver() {
+        const vehicle = this.getCurrentVehicle();
+        if (!vehicle)
+            return false;
+        return GetPedInVehicleSeat(vehicle, -1) === PlayerPedId();
+    }
+    /**
+     * Apply modifications to a vehicle.
+     *
+     * @param vehicle - Vehicle handle
+     * @param mods - Modifications to apply
+     */
+    setMods(vehicle, mods) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetVehicleModKit(vehicle, 0);
+        if (mods.spoiler !== undefined)
+            SetVehicleMod(vehicle, 0, mods.spoiler, false);
+        if (mods.frontBumper !== undefined)
+            SetVehicleMod(vehicle, 1, mods.frontBumper, false);
+        if (mods.rearBumper !== undefined)
+            SetVehicleMod(vehicle, 2, mods.rearBumper, false);
+        if (mods.sideSkirt !== undefined)
+            SetVehicleMod(vehicle, 3, mods.sideSkirt, false);
+        if (mods.exhaust !== undefined)
+            SetVehicleMod(vehicle, 4, mods.exhaust, false);
+        if (mods.frame !== undefined)
+            SetVehicleMod(vehicle, 5, mods.frame, false);
+        if (mods.grille !== undefined)
+            SetVehicleMod(vehicle, 6, mods.grille, false);
+        if (mods.hood !== undefined)
+            SetVehicleMod(vehicle, 7, mods.hood, false);
+        if (mods.fender !== undefined)
+            SetVehicleMod(vehicle, 8, mods.fender, false);
+        if (mods.rightFender !== undefined)
+            SetVehicleMod(vehicle, 9, mods.rightFender, false);
+        if (mods.roof !== undefined)
+            SetVehicleMod(vehicle, 10, mods.roof, false);
+        if (mods.engine !== undefined)
+            SetVehicleMod(vehicle, 11, mods.engine, false);
+        if (mods.brakes !== undefined)
+            SetVehicleMod(vehicle, 12, mods.brakes, false);
+        if (mods.transmission !== undefined)
+            SetVehicleMod(vehicle, 13, mods.transmission, false);
+        if (mods.horns !== undefined)
+            SetVehicleMod(vehicle, 14, mods.horns, false);
+        if (mods.suspension !== undefined)
+            SetVehicleMod(vehicle, 15, mods.suspension, false);
+        if (mods.armor !== undefined)
+            SetVehicleMod(vehicle, 16, mods.armor, false);
+        if (mods.turbo !== undefined)
+            ToggleVehicleMod(vehicle, 18, mods.turbo);
+        if (mods.xenon !== undefined)
+            ToggleVehicleMod(vehicle, 22, mods.xenon);
+        if (mods.wheelType !== undefined)
+            SetVehicleWheelType(vehicle, mods.wheelType);
+        if (mods.wheels !== undefined)
+            SetVehicleMod(vehicle, 23, mods.wheels, false);
+        if (mods.windowTint !== undefined)
+            SetVehicleWindowTint(vehicle, mods.windowTint);
+        if (mods.livery !== undefined)
+            SetVehicleLivery(vehicle, mods.livery);
+        if (mods.plateStyle !== undefined)
+            SetVehicleNumberPlateTextIndex(vehicle, mods.plateStyle);
+    }
+    /**
+     * Set vehicle doors locked state.
+     *
+     * @param vehicle - Vehicle handle
+     * @param locked - Whether doors should be locked
+     */
+    setDoorsLocked(vehicle, locked) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetVehicleDoorsLocked(vehicle, locked ? 2 : 0);
+    }
+    /**
+     * Set vehicle engine state.
+     *
+     * @param vehicle - Vehicle handle
+     * @param running - Whether engine should be running
+     * @param instant - Whether to start instantly
+     */
+    setEngineRunning(vehicle, running, instant = false) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetVehicleEngineOn(vehicle, running, instant, true);
+    }
+    /**
+     * Set vehicle invincibility.
+     *
+     * @param vehicle - Vehicle handle
+     * @param invincible - Whether vehicle should be invincible
+     */
+    setInvincible(vehicle, invincible) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetEntityInvincible(vehicle, invincible);
+    }
+    /**
+     * Get vehicle speed in km/h.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    getSpeed(vehicle) {
+        if (!DoesEntityExist(vehicle))
+            return 0;
+        return GetEntitySpeed(vehicle) * 3.6; // Convert m/s to km/h
+    }
+    /**
+     * Set vehicle heading/rotation.
+     *
+     * @param vehicle - Vehicle handle
+     * @param heading - Heading in degrees
+     */
+    setHeading(vehicle, heading) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetEntityHeading(vehicle, heading);
+    }
+    /**
+     * Teleport a vehicle to a position.
+     *
+     * @param vehicle - Vehicle handle
+     * @param position - Target position
+     * @param heading - Optional heading
+     */
+    teleport(vehicle, position, heading) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetEntityCoords(vehicle, position.x, position.y, position.z, false, false, false, true);
+        if (heading !== undefined) {
+            SetEntityHeading(vehicle, heading);
+        }
+        SetVehicleOnGroundProperly(vehicle);
+    }
+};
+VehicleService = __decorate([
+    injectable()
+], VehicleService);
+export { VehicleService };

package/dist/runtime/client/system/metadata-client.keys.d.ts

@@ -0,0 +1,15 @@
+export declare const METADATA_KEYS: {
+    CONTROLLER: string;
+    KEY: string;
+    VIEW: string;
+    NET_EVENT: string;
+    NET_RPC: string;
+    TICK: string;
+    LOCAL_EVENT: string;
+    LIBRARY_EVENT: string;
+    INTERVAL: string;
+    EXPORT: string;
+    RESOURCE_START: string;
+    RESOURCE_STOP: string;
+    GAME_EVENT: string;
+};

package/dist/runtime/client/system/metadata-client.keys.js

@@ -0,0 +1,15 @@
+export const METADATA_KEYS = {
+    CONTROLLER: 'core:meta:controller',
+    KEY: 'core:meta:key',
+    VIEW: 'core:meta:view',
+    NET_EVENT: 'core:meta:onNet',
+    NET_RPC: 'core:meta:onRpc',
+    TICK: 'core:meta:tick',
+    LOCAL_EVENT: 'core:meta:localEvent',
+    LIBRARY_EVENT: 'core:meta:libraryEvent',
+    INTERVAL: 'core:meta:interval',
+    EXPORT: 'core:meta:export',
+    RESOURCE_START: 'core:meta:resourceStart',
+    RESOURCE_STOP: 'core:meta:resourceStop',
+    GAME_EVENT: 'core:meta:gameEvent',
+};

package/dist/runtime/client/system/processors/export.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+export declare class ClientExportProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        exportName: string;
+    }): void;
+}

package/dist/runtime/client/system/processors/export.processor.js

@@ -0,0 +1,34 @@
+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 { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { METADATA_KEYS } from '../metadata-client.keys';
+const clientExport = coreLogger.child('Export', LogDomain.CLIENT);
+let ClientExportProcessor = class ClientExportProcessor {
+    metadataKey = METADATA_KEYS.EXPORT;
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        globalThis.exports(metadata.exportName, async (...args) => {
+            try {
+                return await handler(...args);
+            }
+            catch (error) {
+                clientExport.error(`Export handler error`, {
+                    export: metadata.exportName,
+                    handler: handlerName,
+                }, error);
+                throw error;
+            }
+        });
+        clientExport.debug(`Registered export: ${metadata.exportName} -> ${handlerName}`);
+    }
+};
+ClientExportProcessor = __decorate([
+    injectable()
+], ClientExportProcessor);
+export { ClientExportProcessor };

package/dist/runtime/client/system/processors/gameEvent.processor.d.ts

@@ -0,0 +1,10 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+interface GameEventMetadata {
+    eventName: string;
+    autoParse: boolean;
+}
+export declare class GameEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: GameEventMetadata): void;
+}
+export {};

package/dist/runtime/client/system/processors/gameEvent.processor.js

@@ -0,0 +1,53 @@
+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 { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { GameEventParsers } from '../../types/game-events';
+import { METADATA_KEYS } from '../metadata-client.keys';
+const clientGameEvent = coreLogger.child('GameEvent', LogDomain.CLIENT);
+// Map of event names to their parser functions
+const parserMap = {
+    CEventNetworkEntityDamage: GameEventParsers.parseEntityDamage,
+    CEventNetworkPlayerEnteredVehicle: GameEventParsers.parsePlayerEnteredVehicle,
+    CEventNetworkPlayerLeftVehicle: GameEventParsers.parsePlayerLeftVehicle,
+    CEventShockingSeenPedKilled: GameEventParsers.parseSeenPedKilled,
+    CEventNetworkVehicleUndrivable: GameEventParsers.parseVehicleUndrivable,
+    CEventGunShot: GameEventParsers.parseGunShot,
+};
+let GameEventProcessor = class GameEventProcessor {
+    metadataKey = METADATA_KEYS.GAME_EVENT;
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        const { eventName, autoParse } = metadata;
+        on('gameEventTriggered', async (name, args) => {
+            if (name !== eventName)
+                return;
+            try {
+                // Auto-parse if enabled and parser exists
+                if (autoParse && parserMap[eventName]) {
+                    const parsed = parserMap[eventName](args);
+                    await handler(parsed);
+                }
+                else {
+                    await handler(args);
+                }
+            }
+            catch (error) {
+                clientGameEvent.error(`Game event handler error`, {
+                    event: eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientGameEvent.debug(`Registered game event: ${eventName} -> ${handlerName}`);
+    }
+};
+GameEventProcessor = __decorate([
+    injectable()
+], GameEventProcessor);
+export { GameEventProcessor };

package/dist/runtime/client/system/processors/interval.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+export declare class IntervalProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        interval: number;
+    }): void;
+}

package/dist/runtime/client/system/processors/interval.processor.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 { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { METADATA_KEYS } from '../metadata-client.keys';
+const clientInterval = coreLogger.child('Interval', LogDomain.CLIENT);
+let IntervalProcessor = class IntervalProcessor {
+    metadataKey = METADATA_KEYS.INTERVAL;
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        let lastRun = 0;
+        setTick(async () => {
+            const now = GetGameTimer();
+            if (now - lastRun < metadata.interval)
+                return;
+            lastRun = now;
+            try {
+                await handler();
+            }
+            catch (error) {
+                clientInterval.error(`Interval handler error`, {
+                    handler: handlerName,
+                    interval: metadata.interval,
+                }, error);
+            }
+        });
+        clientInterval.debug(`Registered: ${handlerName} (every ${metadata.interval}ms)`);
+    }
+};
+IntervalProcessor = __decorate([
+    injectable()
+], IntervalProcessor);
+export { IntervalProcessor };

package/dist/runtime/client/system/processors/key.processor.d.ts

@@ -0,0 +1,8 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+export declare class KeyMappingProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        key: string;
+        description?: string;
+    }): void;
+}

package/dist/runtime/client/system/processors/key.processor.js

@@ -0,0 +1,22 @@
+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 { METADATA_KEYS } from '../metadata-client.keys';
+let KeyMappingProcessor = class KeyMappingProcessor {
+    metadataKey = METADATA_KEYS.KEY;
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const commandName = `+${methodName}`;
+        RegisterCommand(commandName, handler, false);
+        RegisterKeyMapping(commandName, metadata.description ?? 'none', 'keyboard', metadata.key);
+        RegisterCommand(`-${methodName}`, () => { }, false);
+    }
+};
+KeyMappingProcessor = __decorate([
+    injectable()
+], KeyMappingProcessor);
+export { KeyMappingProcessor };

package/dist/runtime/client/system/processors/libraryEvent.processor.d.ts

@@ -0,0 +1,6 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { LibraryEventDecoratorMetadata } from '../../decorators/onLibraryEvent';
+export declare class ClientLibraryEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: LibraryEventDecoratorMetadata): void;
+}

package/dist/runtime/client/system/processors/libraryEvent.processor.js

@@ -0,0 +1,36 @@
+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 { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { onLibraryEvent } from '../../bus/library-event.bus';
+import { METADATA_KEYS } from '../metadata-client.keys';
+const clientLibraryEvent = coreLogger.child('LibraryEvent', LogDomain.CLIENT);
+let ClientLibraryEventProcessor = class ClientLibraryEventProcessor {
+    metadataKey = METADATA_KEYS.LIBRARY_EVENT;
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        onLibraryEvent(metadata.eventId, async (event) => {
+            try {
+                await handler(event.payload, event.meta);
+            }
+            catch (error) {
+                clientLibraryEvent.error(`Handler error in library event`, {
+                    eventId: metadata.eventId,
+                    libraryName: metadata.libraryName,
+                    eventName: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientLibraryEvent.debug(`Registered: ${metadata.eventId} -> ${handlerName}`);
+    }
+};
+ClientLibraryEventProcessor = __decorate([
+    injectable()
+], ClientLibraryEventProcessor);
+export { ClientLibraryEventProcessor };

package/dist/runtime/client/system/processors/localEvent.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+export declare class LocalEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        eventName: string;
+    }): void;
+}

package/dist/runtime/client/system/processors/localEvent.processor.js

@@ -0,0 +1,33 @@
+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 { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { METADATA_KEYS } from '../metadata-client.keys';
+const clientLocalEvent = coreLogger.child('LocalEvent', LogDomain.CLIENT);
+let LocalEventProcessor = class LocalEventProcessor {
+    metadataKey = METADATA_KEYS.LOCAL_EVENT;
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        on(metadata.eventName, async (...args) => {
+            try {
+                await handler(...args);
+            }
+            catch (error) {
+                clientLocalEvent.error(`Handler error in local event`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientLocalEvent.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);
+    }
+};
+LocalEventProcessor = __decorate([
+    injectable()
+], LocalEventProcessor);
+export { LocalEventProcessor };

package/dist/runtime/client/system/processors/netEvent.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+export declare class ClientNetEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        eventName: string;
+    }): void;
+}

package/dist/runtime/client/system/processors/netEvent.processor.js

@@ -0,0 +1,33 @@
+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 { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { METADATA_KEYS } from '../metadata-client.keys';
+const clientNetEvent = coreLogger.child('NetEvent', LogDomain.CLIENT);
+let ClientNetEventProcessor = class ClientNetEventProcessor {
+    metadataKey = METADATA_KEYS.NET_EVENT;
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        onNet(metadata.eventName, async (...args) => {
+            try {
+                await handler(...args);
+            }
+            catch (error) {
+                clientNetEvent.error(`Handler error in event`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientNetEvent.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);
+    }
+};
+ClientNetEventProcessor = __decorate([
+    injectable()
+], ClientNetEventProcessor);
+export { ClientNetEventProcessor };

package/dist/runtime/client/system/processors/onRpc.processor.d.ts

@@ -0,0 +1,9 @@
+import { RpcAPI } from '../../../../adapters/contracts/transport/rpc.api';
+import { type DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import type { ClientRpcHandlerOptions } from '../../decorators/onRPC';
+export declare class ClientOnRpcProcessor implements DecoratorProcessor {
+    private readonly rpc;
+    readonly metadataKey: string;
+    constructor(rpc: RpcAPI<'client'>);
+    process(target: any, methodName: string, metadata: ClientRpcHandlerOptions): void;
+}