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

package/dist/runtime/client/services/camera.js

@@ -11,18 +11,16 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'tsyringe';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientCameraPort, } from '../../../adapters/contracts/client/camera/IClientCameraPort';
 let Camera = class Camera {
-    platform;
+    cameras;
     activeCam = null;
     rendering = false;
-    constructor(platform) {
-        this.platform = platform;
+    constructor(cameras) {
+        this.cameras = cameras;
     }
     create(options = {}) {
-        const cam = this.platform.createCam(options.camName ?? 'DEFAULT_SCRIPTED_CAMERA', options.active ?? false);
-        if (options.transform)
-            this.setTransform(cam, options.transform);
+        const cam = this.cameras.create(options);
         if (options.active)
             this.activeCam = cam;
         return cam;
@@ -31,62 +29,58 @@ let Camera = class Camera {
         return this.activeCam;
     }
     setActive(cam, active) {
-        this.platform.setCamActive(cam, active);
+        this.cameras.setActive(cam, active);
         if (active)
             this.activeCam = cam;
         else if (this.activeCam === cam)
             this.activeCam = null;
     }
     render(enable, options = {}) {
-        this.platform.renderScriptCams(enable, options.ease ?? false, options.easeTimeMs ?? 0, true, true);
+        this.cameras.render(enable, options);
         this.rendering = enable;
     }
     isRendering() {
         return this.rendering;
     }
     destroy(cam, destroyActiveCam = false) {
-        this.platform.destroyCam(cam, destroyActiveCam);
+        this.cameras.destroy(cam, destroyActiveCam);
         if (this.activeCam === cam)
             this.activeCam = null;
     }
     destroyAll(destroyActiveCam = false) {
-        this.platform.destroyAllCams(destroyActiveCam);
+        this.cameras.destroyAll(destroyActiveCam);
         this.activeCam = null;
     }
     setPosition(cam, position) {
-        this.platform.setCamCoord(cam, position);
+        this.cameras.setPosition(cam, position);
     }
     setRotation(cam, rotation, rotationOrder = 2) {
-        this.platform.setCamRot(cam, rotation, rotationOrder);
+        this.cameras.setRotation(cam, rotation, rotationOrder);
     }
     setFov(cam, fov) {
-        this.platform.setCamFov(cam, fov);
+        this.cameras.setFov(cam, fov);
     }
     setTransform(cam, transform) {
-        this.setPosition(cam, transform.position);
-        if (transform.rotation)
-            this.setRotation(cam, transform.rotation);
-        if (typeof transform.fov === 'number')
-            this.setFov(cam, transform.fov);
+        this.cameras.setTransform(cam, transform);
     }
     pointAtCoords(cam, position) {
-        this.platform.pointCamAtCoord(cam, position);
+        this.cameras.pointAtCoords(cam, position);
     }
     pointAtEntity(cam, entity, offset = { x: 0, y: 0, z: 0 }) {
-        this.platform.pointCamAtEntity(cam, entity, offset);
+        this.cameras.pointAtEntity(cam, entity, offset);
     }
     stopPointing(cam) {
-        this.platform.stopCamPointing(cam);
+        this.cameras.stopPointing(cam);
     }
     interpolate(fromCam, toCam, durationMs, easeLocation = true, easeRotation = true) {
-        this.platform.setCamActiveWithInterp(toCam, fromCam, durationMs, easeLocation ? 1 : 0, easeRotation ? 1 : 0);
+        this.cameras.interpolate(fromCam, toCam, durationMs, easeLocation, easeRotation);
         this.activeCam = toCam;
     }
     shake(cam, options) {
-        this.platform.shakeCam(cam, options.type, options.amplitude);
+        this.cameras.shake(cam, options);
     }
     stopShaking(cam, stopImmediately = true) {
-        this.platform.stopCamShaking(cam, stopImmediately);
+        this.cameras.stopShaking(cam, stopImmediately);
     }
     reset(options = {}) {
         if (this.rendering)
@@ -96,7 +90,7 @@ let Camera = class Camera {
 };
 Camera = __decorate([
     injectable(),
-    __param(0, inject(IClientPlatformBridge)),
-    __metadata("design:paramtypes", [IClientPlatformBridge])
+    __param(0, inject(IClientCameraPort)),
+    __metadata("design:paramtypes", [IClientCameraPort])
 ], Camera);
 export { Camera };

package/dist/runtime/client/services/notification.service.d.ts

@@ -1,5 +1,5 @@
 import { IClientNotificationBridge, type ClientNotificationDefinition } from '../../../adapters/contracts/client/ui/IClientNotificationBridge';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 export type NotificationType = 'info' | 'success' | 'warning' | 'error';
 export interface AdvancedNotificationOptions {
     title: string;
@@ -11,8 +11,8 @@ export interface AdvancedNotificationOptions {
 }
 export declare class NotificationService {
     private readonly notifications;
-    private readonly platform;
-    constructor(notifications: IClientNotificationBridge, platform: IClientPlatformBridge);
+    private readonly localPlayer;
+    constructor(notifications: IClientNotificationBridge, localPlayer: IClientLocalPlayerBridge);
     show(message: string, blink?: boolean): void;
     showWithType(message: string, type?: NotificationType): void;
     showAdvanced(options: AdvancedNotificationOptions): void;

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

@@ -12,13 +12,13 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject, injectable } from 'tsyringe';
 import { IClientNotificationBridge, } from '../../../adapters/contracts/client/ui/IClientNotificationBridge';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 let NotificationService = class NotificationService {
     notifications;
-    platform;
-    constructor(notifications, platform) {
+    localPlayer;
+    constructor(notifications, localPlayer) {
         this.notifications = notifications;
-        this.platform = platform;
+        this.localPlayer = localPlayer;
     }
     show(message, blink = false) {
         this.notifications.show({ kind: 'feed', message, blink, saveToBrief: true });
@@ -53,7 +53,7 @@ let NotificationService = class NotificationService {
         this.notifications.show({
             kind: 'floating',
             message,
-            worldPosition: this.platform.getEntityCoords(this.platform.getLocalPlayerPed()),
+            worldPosition: this.localPlayer.getPosition(),
         });
     }
     showRaw(definition) {
@@ -63,8 +63,8 @@ let NotificationService = class NotificationService {
 NotificationService = __decorate([
     injectable(),
     __param(0, inject(IClientNotificationBridge)),
-    __param(1, inject(IClientPlatformBridge)),
+    __param(1, inject(IClientLocalPlayerBridge)),
     __metadata("design:paramtypes", [IClientNotificationBridge,
-        IClientPlatformBridge])
+        IClientLocalPlayerBridge])
 ], NotificationService);
 export { NotificationService };

package/dist/runtime/client/services/ped.service.d.ts

@@ -1,23 +1,7 @@
 import { Vector3 } from '../../../kernel/utils/vector3';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
-export interface PedSpawnOptions {
-    model: string;
-    position: Vector3;
-    heading?: number;
-    networked?: boolean;
-    missionEntity?: boolean;
-    relationshipGroup?: string;
-    blockEvents?: boolean;
-}
-export interface PedAnimationOptions {
-    dict: string;
-    anim: string;
-    blendInSpeed?: number;
-    blendOutSpeed?: number;
-    duration?: number;
-    flags?: number;
-    playbackRate?: number;
-}
+import { type ClientPedAnimationOptions as PedAnimationOptions, type ClientPedSpawnOptions as PedSpawnOptions, IClientPedPort } from '../../../adapters/contracts/client/ped/IClientPedPort';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
+export type { PedSpawnOptions, PedAnimationOptions };
 export interface ManagedPed {
     id: string;
     handle: number;
@@ -25,10 +9,11 @@ export interface ManagedPed {
     position: Vector3;
 }
 export declare class PedService {
-    private readonly platform;
+    private readonly pedsPort;
+    private readonly localPlayer;
     private peds;
     private idCounter;
-    constructor(platform: IClientPlatformBridge);
+    constructor(pedsPort: IClientPedPort, localPlayer: IClientLocalPlayerBridge);
     spawn(options: PedSpawnOptions): Promise<{
         id: string;
         handle: number;

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

@@ -11,53 +11,35 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'tsyringe';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientPedPort, } from '../../../adapters/contracts/client/ped/IClientPedPort';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 let PedService = class PedService {
-    platform;
+    pedsPort;
+    localPlayer;
     peds = new Map();
     idCounter = 0;
-    constructor(platform) {
-        this.platform = platform;
+    constructor(pedsPort, localPlayer) {
+        this.pedsPort = pedsPort;
+        this.localPlayer = localPlayer;
     }
     async spawn(options) {
-        const { model, position, heading = 0, networked = false, missionEntity = true, blockEvents = true, } = options;
-        const modelHash = this.platform.getHashKey(model);
-        if (!this.platform.isModelInCdimage(modelHash) || !this.platform.isModelValid(modelHash)) {
-            throw new Error(`Invalid ped model: ${model}`);
-        }
-        this.platform.requestModel(modelHash);
-        while (!this.platform.hasModelLoaded(modelHash)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-        const ped = this.platform.createPed(4, modelHash, position, heading, networked, true);
-        this.platform.setModelAsNoLongerNeeded(modelHash);
+        const ped = await this.pedsPort.spawn(options);
         if (!ped || ped === 0)
             throw new Error('Failed to create ped');
-        if (missionEntity)
-            this.platform.setEntityAsMissionEntity(ped, true, true);
-        if (blockEvents)
-            this.platform.setBlockingOfNonTemporaryEvents(ped, true);
-        this.platform.setPedRelationshipGroupHash(ped, this.platform.getHashKey('CIVMALE'));
         const id = `ped_${++this.idCounter}`;
-        this.peds.set(id, { id, handle: ped, model, position });
+        this.peds.set(id, { id, handle: ped, model: options.model, position: options.position });
         return { id, handle: ped };
     }
     delete(id) {
         const ped = this.peds.get(id);
         if (!ped)
             return false;
-        if (this.platform.doesEntityExist(ped.handle)) {
-            this.platform.setEntityAsMissionEntity(ped.handle, true, true);
-            this.platform.deletePed(ped.handle);
-        }
+        this.pedsPort.delete(ped.handle);
         this.peds.delete(id);
         return true;
     }
     deleteByHandle(handle) {
-        if (this.platform.doesEntityExist(handle)) {
-            this.platform.setEntityAsMissionEntity(handle, true, true);
-            this.platform.deletePed(handle);
-        }
+        this.pedsPort.delete(handle);
         for (const [id, ped] of this.peds) {
             if (ped.handle === handle) {
                 this.peds.delete(id);
@@ -67,56 +49,34 @@ let PedService = class PedService {
     }
     deleteAll() {
         for (const ped of this.peds.values()) {
-            if (this.platform.doesEntityExist(ped.handle)) {
-                this.platform.setEntityAsMissionEntity(ped.handle, true, true);
-                this.platform.deletePed(ped.handle);
-            }
+            this.pedsPort.delete(ped.handle);
         }
         this.peds.clear();
     }
     async playAnimation(handle, options) {
-        const { dict, anim, blendInSpeed = 8.0, blendOutSpeed = -8.0, duration = -1, flags = 1, playbackRate = 0.0, } = options;
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.requestAnimDict(dict);
-        while (!this.platform.hasAnimDictLoaded(dict)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-        this.platform.taskPlayAnim(handle, dict, anim, blendInSpeed, blendOutSpeed, duration, flags, playbackRate);
+        await this.pedsPort.playAnimation(handle, options);
     }
     stopAnimation(handle) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.clearPedTasks(handle);
+        this.pedsPort.stopAnimation(handle);
     }
     stopAnimationImmediately(handle) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.clearPedTasksImmediately(handle);
+        this.pedsPort.stopAnimationImmediately(handle);
     }
     freeze(handle, freeze) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.freezeEntityPosition(handle, freeze);
+        this.pedsPort.freeze(handle, freeze);
     }
     setInvincible(handle, invincible) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.setEntityInvincible(handle, invincible);
+        this.pedsPort.setInvincible(handle, invincible);
     }
     giveWeapon(handle, weapon, ammo = 100, hidden = false, forceInHand = true) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.giveWeaponToPed(handle, this.platform.getHashKey(weapon), ammo, hidden, forceInHand);
+        this.pedsPort.giveWeapon(handle, weapon, ammo, hidden, forceInHand);
     }
     removeAllWeapons(handle) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.removeAllPedWeapons(handle, true);
+        this.pedsPort.removeAllWeapons(handle);
     }
     getClosest(radius = 10.0, excludePlayer = true) {
-        const playerPed = this.platform.getLocalPlayerPed();
-        const handle = this.platform.getClosestPed(this.platform.getEntityCoords(playerPed), radius);
+        const playerPed = this.localPlayer.getHandle();
+        const handle = this.pedsPort.getClosest(radius, excludePlayer);
         if (!handle)
             return null;
         if (excludePlayer && handle === playerPed)
@@ -124,28 +84,19 @@ let PedService = class PedService {
         return handle;
     }
     getNearby(position, radius, excludePlayer = true) {
-        return this.platform.getNearbyPeds(position, radius, excludePlayer ? this.platform.getLocalPlayerPed() : undefined);
+        return this.pedsPort.getNearby(position, radius, excludePlayer ? this.localPlayer.getHandle() : undefined);
     }
     lookAtEntity(handle, entity, duration = -1) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.taskLookAtEntity(handle, entity, duration);
+        this.pedsPort.lookAtEntity(handle, entity, duration);
     }
     lookAtCoords(handle, position, duration = -1) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.taskLookAtCoord(handle, position, duration);
+        this.pedsPort.lookAtCoords(handle, position, duration);
     }
     walkTo(handle, position, speed = 1.0) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.taskGoStraightToCoord(handle, position, speed);
+        this.pedsPort.walkTo(handle, position, speed);
     }
     setCombatAttributes(handle, canFight, canUseCover = true) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.setPedCombatAttributes(handle, 46, canFight);
-        this.platform.setPedCombatAttributes(handle, 0, canUseCover);
+        this.pedsPort.setCombatAttributes(handle, canFight, canUseCover);
     }
     get(id) {
         return this.peds.get(id);
@@ -155,12 +106,14 @@ let PedService = class PedService {
     }
     exists(id) {
         const ped = this.peds.get(id);
-        return ped ? this.platform.doesEntityExist(ped.handle) : false;
+        return ped ? this.pedsPort.exists(ped.handle) : false;
     }
 };
 PedService = __decorate([
     injectable(),
-    __param(0, inject(IClientPlatformBridge)),
-    __metadata("design:paramtypes", [IClientPlatformBridge])
+    __param(0, inject(IClientPedPort)),
+    __param(1, inject(IClientLocalPlayerBridge)),
+    __metadata("design:paramtypes", [IClientPedPort,
+        IClientLocalPlayerBridge])
 ], PedService);
 export { PedService };

package/dist/runtime/client/services/progress.service.d.ts

@@ -1,57 +1,11 @@
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
-import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
-export interface ProgressOptions {
-    label: string;
-    duration: number;
-    useCircular?: boolean;
-    canCancel?: boolean;
-    disableControls?: boolean;
-    disableMovement?: boolean;
-    disableCombat?: boolean;
-    animation?: {
-        dict: string;
-        anim: string;
-        flags?: number;
-    };
-    prop?: {
-        model: string;
-        bone: number;
-        offset: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        rotation: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    };
-}
-export interface ProgressState {
-    active: boolean;
-    progress: number;
-    label: string;
-    startTime: number;
-    duration: number;
-    options: ProgressOptions;
-}
+import { type ClientProgressOptions as ProgressOptions, type ClientProgressState as ProgressState, IClientProgressPort } from '../../../adapters/contracts/client/progress/IClientProgressPort';
+export type { ProgressOptions, ProgressState };
 export declare class ProgressService {
-    private readonly platform;
-    private readonly runtime;
-    private state;
-    private tickHandle;
-    private callback;
-    private propHandle;
-    constructor(platform: IClientPlatformBridge, runtime: IClientRuntimeBridge);
+    private readonly progressPort;
+    constructor(progressPort: IClientProgressPort);
     start(options: ProgressOptions): Promise<boolean>;
     cancel(): void;
     isActive(): boolean;
     getProgress(): number;
     getState(): ProgressState | null;
-    private startProgress;
-    private drawProgressBar;
-    private cleanup;
-    private loadAnimDict;
-    private loadModel;
 }

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

@@ -11,163 +11,31 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'tsyringe';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
-import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+import { IClientProgressPort, } from '../../../adapters/contracts/client/progress/IClientProgressPort';
 let ProgressService = class ProgressService {
-    platform;
-    runtime;
-    state = null;
-    tickHandle = null;
-    callback = null;
-    propHandle = null;
-    constructor(platform, runtime) {
-        this.platform = platform;
-        this.runtime = runtime;
+    progressPort;
+    constructor(progressPort) {
+        this.progressPort = progressPort;
     }
     async start(options) {
-        if (this.state?.active)
-            return false;
-        return new Promise((resolve) => {
-            this.state = {
-                active: true,
-                progress: 0,
-                label: options.label,
-                startTime: this.runtime.getGameTimer(),
-                duration: options.duration,
-                options,
-            };
-            this.callback = resolve;
-            void this.startProgress();
-        });
+        return this.progressPort.start(options);
     }
     cancel() {
-        if (!this.state?.active)
-            return;
-        this.cleanup(false);
+        this.progressPort.cancel();
     }
     isActive() {
-        return this.state?.active ?? false;
+        return this.progressPort.isActive();
     }
     getProgress() {
-        return this.state?.progress ?? 0;
+        return this.progressPort.getProgress();
     }
     getState() {
-        return this.state;
-    }
-    async startProgress() {
-        if (!this.state)
-            return;
-        const { options } = this.state;
-        const ped = this.platform.getLocalPlayerPed();
-        if (options.animation) {
-            await this.loadAnimDict(options.animation.dict);
-            this.platform.taskPlayAnim(ped, options.animation.dict, options.animation.anim, 8.0, -8.0, options.duration, options.animation.flags ?? 1, 0.0);
-        }
-        if (options.prop) {
-            await this.loadModel(options.prop.model);
-            const propHash = this.platform.getHashKey(options.prop.model);
-            const coords = this.platform.getEntityCoords(ped);
-            this.propHandle = this.platform.createObject(propHash, coords, true, true, true);
-            this.platform.attachEntityToEntity(this.propHandle, ped, this.platform.getPedBoneIndex(ped, options.prop.bone), options.prop.offset, options.prop.rotation);
-        }
-        this.tickHandle = this.runtime.setTick(() => {
-            if (!this.state)
-                return;
-            const elapsed = this.runtime.getGameTimer() - this.state.startTime;
-            this.state.progress = Math.min((elapsed / this.state.duration) * 100, 100);
-            if (options.disableControls) {
-                this.platform.disableAllControlActions(0);
-            }
-            else {
-                if (options.disableMovement) {
-                    this.platform.disableControlAction(0, 30, true);
-                    this.platform.disableControlAction(0, 31, true);
-                    this.platform.disableControlAction(0, 21, true);
-                    this.platform.disableControlAction(0, 22, true);
-                }
-                if (options.disableCombat) {
-                    this.platform.disableControlAction(0, 24, true);
-                    this.platform.disableControlAction(0, 25, true);
-                    this.platform.disableControlAction(0, 47, true);
-                    this.platform.disableControlAction(0, 58, true);
-                    this.platform.disableControlAction(0, 263, true);
-                    this.platform.disableControlAction(0, 264, true);
-                }
-            }
-            if (options.canCancel && this.platform.isControlJustPressed(0, 200)) {
-                this.cancel();
-                return;
-            }
-            this.drawProgressBar();
-            if (elapsed >= this.state.duration)
-                this.cleanup(true);
-        });
-    }
-    drawProgressBar() {
-        if (!this.state)
-            return;
-        const { label, progress, options } = this.state;
-        if (options.useCircular) {
-            this.platform.beginTextCommandBusyspinnerOn('STRING');
-            this.platform.addTextComponentString(label);
-            this.platform.endTextCommandBusyspinnerOn(4);
-            return;
-        }
-        const barWidth = 0.15;
-        const barHeight = 0.015;
-        const x = 0.5 - barWidth / 2;
-        const y = 0.88;
-        this.platform.drawRect(0.5, y + barHeight / 2, barWidth, barHeight, 0, 0, 0, 180);
-        const fillWidth = (barWidth * progress) / 100;
-        this.platform.drawRect(x + fillWidth / 2, y + barHeight / 2, fillWidth, barHeight, 255, 255, 255, 255);
-        this.platform.setTextFont(4);
-        this.platform.setTextScale(0.35);
-        this.platform.setTextColour({ r: 255, g: 255, b: 255, a: 255 });
-        this.platform.setTextCentre(true);
-        this.platform.beginTextCommandDisplayText('STRING');
-        this.platform.addTextComponentString(`${label} (${Math.floor(progress)}%)`);
-        this.platform.endTextCommandDisplayText(0.5, y - 0.03);
-    }
-    cleanup(completed) {
-        const ped = this.platform.getLocalPlayerPed();
-        if (this.state?.options.animation) {
-            this.platform.stopAnimTask(ped, this.state.options.animation.dict, this.state.options.animation.anim, 1.0);
-        }
-        if (this.propHandle) {
-            this.platform.deleteEntity(this.propHandle);
-            this.propHandle = null;
-        }
-        if (this.tickHandle !== null) {
-            this.runtime.clearTick(this.tickHandle);
-            this.tickHandle = null;
-        }
-        if (this.state?.options.useCircular)
-            this.platform.busyspinnerOff();
-        this.state = null;
-        if (this.callback) {
-            this.callback(completed);
-            this.callback = null;
-        }
-    }
-    async loadAnimDict(dict) {
-        this.platform.requestAnimDict(dict);
-        while (!this.platform.hasAnimDictLoaded(dict)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-    }
-    async loadModel(model) {
-        const hash = this.platform.getHashKey(model);
-        this.platform.requestModel(hash);
-        while (!this.platform.hasModelLoaded(hash)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
+        return this.progressPort.getState();
     }
 };
 ProgressService = __decorate([
     injectable(),
-    __param(0, inject(IClientPlatformBridge)),
-    __param(1, inject(IClientRuntimeBridge)),
-    __metadata("design:paramtypes", [IClientPlatformBridge,
-        IClientRuntimeBridge])
+    __param(0, inject(IClientProgressPort)),
+    __metadata("design:paramtypes", [IClientProgressPort])
 ], ProgressService);
 export { ProgressService };

package/dist/runtime/client/services/session-bridge.service.js

@@ -14,6 +14,7 @@ import { inject, injectable } from 'tsyringe';
 import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { coreLogger, LogDomain } from '../../../kernel/logger';
 import { Vec3 } from '../../../kernel/utils/vector3';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
 import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
 const clientSession = coreLogger.child('Session', LogDomain.CLIENT);
@@ -37,11 +38,11 @@ let ClientSessionBridgeService = class ClientSessionBridgeService {
                 return;
             clientSession.debug('Client session bridge initialized');
         });
-        this.events.on('core:playerSessionInit', (_ctx, data) => {
+        this.events.on(SYSTEM_EVENTS.session.playerInit, (_ctx, data) => {
             this.playerId = data.playerId;
             clientSession.info('Player session initialized', { playerId: data.playerId });
         });
-        this.events.on('core:teleportTo', (_ctx, x, y, z, heading) => {
+        this.events.on(SYSTEM_EVENTS.session.teleportTo, (_ctx, x, y, z, heading) => {
             this.localPlayer.setPosition(Vec3.create(x, y, z), heading);
         });
     }