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

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

@@ -0,0 +1,173 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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';
+let ProgressService = class ProgressService {
+    platform;
+    runtime;
+    state = null;
+    tickHandle = null;
+    callback = null;
+    propHandle = null;
+    constructor(platform, runtime) {
+        this.platform = platform;
+        this.runtime = runtime;
+    }
+    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();
+        });
+    }
+    cancel() {
+        if (!this.state?.active)
+            return;
+        this.cleanup(false);
+    }
+    isActive() {
+        return this.state?.active ?? false;
+    }
+    getProgress() {
+        return this.state?.progress ?? 0;
+    }
+    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));
+        }
+    }
+};
+ProgressService = __decorate([
+    injectable(),
+    __param(0, inject(IClientPlatformBridge)),
+    __param(1, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientPlatformBridge,
+        IClientRuntimeBridge])
+], ProgressService);
+export { ProgressService };

package/dist/runtime/client/services/session-bridge.service.d.ts

@@ -0,0 +1,15 @@
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+/**
+ * Registers lightweight client session listeners owned by the active adapter.
+ */
+export declare class ClientSessionBridgeService {
+    private readonly events;
+    private readonly runtime;
+    private readonly localPlayer;
+    private playerId;
+    constructor(events: EventsAPI<'client'>, runtime: IClientRuntimeBridge, localPlayer: IClientLocalPlayerBridge);
+    init(): void;
+    getPlayerId(): string | undefined;
+}

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

@@ -0,0 +1,61 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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 { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+const clientSession = coreLogger.child('Session', LogDomain.CLIENT);
+/**
+ * Registers lightweight client session listeners owned by the active adapter.
+ */
+let ClientSessionBridgeService = class ClientSessionBridgeService {
+    events;
+    runtime;
+    localPlayer;
+    playerId;
+    constructor(events, runtime, localPlayer) {
+        this.events = events;
+        this.runtime = runtime;
+        this.localPlayer = localPlayer;
+    }
+    init() {
+        const currentResource = this.runtime.getCurrentResourceName();
+        this.runtime.on('onClientResourceStart', (resourceName) => {
+            if (resourceName !== currentResource)
+                return;
+            clientSession.debug('Client session bridge initialized');
+        });
+        this.events.on('core:playerSessionInit', (_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.localPlayer.setPosition(Vec3.create(x, y, z), heading);
+        });
+    }
+    getPlayerId() {
+        return this.playerId;
+    }
+};
+ClientSessionBridgeService = __decorate([
+    injectable(),
+    __param(0, inject(EventsAPI)),
+    __param(1, inject(IClientRuntimeBridge)),
+    __param(2, inject(IClientLocalPlayerBridge)),
+    __metadata("design:paramtypes", [EventsAPI,
+        IClientRuntimeBridge,
+        IClientLocalPlayerBridge])
+], ClientSessionBridgeService);
+export { ClientSessionBridgeService };

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

@@ -0,0 +1,23 @@
+import { PlayerAppearance } from '../../../kernel';
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { AppearanceService } from './appearance.service';
+import { IClientSpawnBridge } from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
+interface SpawnOptions {
+    appearance?: PlayerAppearance;
+}
+export declare class SpawnService {
+    private readonly appearanceService;
+    private readonly spawnBridge;
+    private readonly platform;
+    private spawned;
+    private spawning;
+    constructor(appearanceService: AppearanceService, spawnBridge: IClientSpawnBridge, platform: IClientPlatformBridge);
+    init(): Promise<void>;
+    spawn(position: Vector3, model: string, heading?: number, options?: SpawnOptions): Promise<void>;
+    teleportTo(position: Vector3, heading?: number): Promise<void>;
+    respawn(position: Vector3, heading?: number): Promise<void>;
+    isSpawned(): boolean;
+    waitUntilSpawned(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,98 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { loggers } from '../../../kernel';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { AppearanceService } from './appearance.service';
+import { IClientSpawnBridge } from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
+let SpawnService = class SpawnService {
+    appearanceService;
+    spawnBridge;
+    platform;
+    spawned = false;
+    spawning = false;
+    constructor(appearanceService, spawnBridge, platform) {
+        this.appearanceService = appearanceService;
+        this.spawnBridge = spawnBridge;
+        this.platform = platform;
+    }
+    async init() {
+        loggers.spawn.debug('SpawnService initialized');
+    }
+    async spawn(position, model, heading = 0.0, options) {
+        if (this.spawning) {
+            loggers.spawn.warn('Spawn requested while a spawn is already in progress');
+            return;
+        }
+        this.spawning = true;
+        try {
+            loggers.spawn.debug('Waiting for spawn bridge readiness');
+            await this.spawnBridge.waitUntilReady();
+            loggers.spawn.debug('Spawn bridge ready, executing spawn', { position, model, heading });
+            await this.spawnBridge.spawn({ position, model, heading });
+            const ped = this.platform.getLocalPlayerPed();
+            if (ped !== 0) {
+                if (options?.appearance) {
+                    loggers.spawn.debug('Applying post-spawn appearance', { ped });
+                    await this.appearanceService.applyAppearance(ped, options.appearance);
+                }
+                else {
+                    this.appearanceService.setDefaultAppearance(ped);
+                }
+            }
+            this.spawned = true;
+            loggers.spawn.info('Player spawned successfully', {
+                position: { x: position.x, y: position.y, z: position.z },
+                model,
+            });
+        }
+        catch (err) {
+            loggers.spawn.error('Failed to spawn player', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
+        finally {
+            this.spawning = false;
+        }
+    }
+    async teleportTo(position, heading) {
+        await this.spawnBridge.teleport({ position, heading });
+    }
+    async respawn(position, heading = 0.0) {
+        await this.spawnBridge.waitUntilReady();
+        await this.spawnBridge.respawn({ position, heading });
+        this.spawned = true;
+        loggers.spawn.info('Player respawned', {
+            position: { x: position.x, y: position.y, z: position.z },
+            heading,
+        });
+    }
+    isSpawned() {
+        return this.spawned;
+    }
+    async waitUntilSpawned() {
+        while (!this.spawned) {
+            await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+    }
+};
+SpawnService = __decorate([
+    injectable(),
+    __param(1, inject(IClientSpawnBridge)),
+    __param(2, inject(IClientPlatformBridge)),
+    __metadata("design:paramtypes", [AppearanceService,
+        IClientSpawnBridge,
+        IClientPlatformBridge])
+], SpawnService);
+export { SpawnService };

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

@@ -0,0 +1,44 @@
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+export interface StreamingRequest {
+    type: 'model' | 'animDict' | 'ptfx' | 'texture' | 'audio';
+    asset: string;
+    loaded: boolean;
+    hash?: number;
+}
+export declare class StreamingService {
+    private readonly platform;
+    private readonly runtime;
+    private loadedAssets;
+    constructor(platform: IClientPlatformBridge, runtime: IClientRuntimeBridge);
+    requestModel(model: string | number, timeout?: number): Promise<boolean>;
+    isModelLoaded(model: string | number): boolean;
+    releaseModel(model: string | number): void;
+    isModelValid(model: string | number): boolean;
+    isModelVehicle(model: string | number): boolean;
+    isModelPed(model: string | number): boolean;
+    requestAnimDict(dict: string, timeout?: number): Promise<boolean>;
+    isAnimDictLoaded(dict: string): boolean;
+    releaseAnimDict(dict: string): void;
+    requestPtfxAsset(asset: string, timeout?: number): Promise<boolean>;
+    isPtfxAssetLoaded(asset: string): boolean;
+    releasePtfxAsset(asset: string): void;
+    startParticleEffect(asset: string, effectName: string, position: {
+        x: number;
+        y: number;
+        z: number;
+    }, rotation?: {
+        x: number;
+        y: number;
+        z: number;
+    }, scale?: number, looped?: boolean): Promise<number>;
+    stopParticleEffect(handle: number): void;
+    requestTextureDict(dict: string, timeout?: number): Promise<boolean>;
+    isTextureDictLoaded(dict: string): boolean;
+    releaseTextureDict(dict: string): void;
+    requestAudioBank(audioBank: string, networked?: boolean, _timeout?: number): Promise<boolean>;
+    releaseAudioBank(audioBank: string): void;
+    getLoadedAssets(): StreamingRequest[];
+    releaseAll(): void;
+    getHash(str: string): number;
+}

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

@@ -0,0 +1,186 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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';
+let StreamingService = class StreamingService {
+    platform;
+    runtime;
+    loadedAssets = new Map();
+    constructor(platform, runtime) {
+        this.platform = platform;
+        this.runtime = runtime;
+    }
+    async requestModel(model, timeout = 10000) {
+        const hash = typeof model === 'string' ? this.platform.getHashKey(model) : model;
+        const key = `model:${hash}`;
+        if (this.loadedAssets.get(key)?.loaded)
+            return true;
+        if (!this.platform.isModelInCdimage(hash) || !this.platform.isModelValid(hash))
+            return false;
+        this.platform.requestModel(hash);
+        const startTime = this.runtime.getGameTimer();
+        while (!this.platform.hasModelLoaded(hash)) {
+            if (this.runtime.getGameTimer() - startTime > timeout)
+                return false;
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        this.loadedAssets.set(key, { type: 'model', asset: String(model), loaded: true, hash });
+        return true;
+    }
+    isModelLoaded(model) {
+        const hash = typeof model === 'string' ? this.platform.getHashKey(model) : model;
+        return this.platform.hasModelLoaded(hash);
+    }
+    releaseModel(model) {
+        const hash = typeof model === 'string' ? this.platform.getHashKey(model) : model;
+        this.platform.setModelAsNoLongerNeeded(hash);
+        this.loadedAssets.delete(`model:${hash}`);
+    }
+    isModelValid(model) {
+        const hash = typeof model === 'string' ? this.platform.getHashKey(model) : model;
+        return this.platform.isModelInCdimage(hash) && this.platform.isModelValid(hash);
+    }
+    isModelVehicle(model) {
+        const hash = typeof model === 'string' ? this.platform.getHashKey(model) : model;
+        return this.platform.isModelAVehicle(hash);
+    }
+    isModelPed(model) {
+        const hash = typeof model === 'string' ? this.platform.getHashKey(model) : model;
+        return this.platform.isModelAPed(hash);
+    }
+    async requestAnimDict(dict, timeout = 10000) {
+        const key = `anim:${dict}`;
+        if (this.loadedAssets.get(key)?.loaded)
+            return true;
+        this.platform.requestAnimDict(dict);
+        const startTime = this.runtime.getGameTimer();
+        while (!this.platform.hasAnimDictLoaded(dict)) {
+            if (this.runtime.getGameTimer() - startTime > timeout)
+                return false;
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        this.loadedAssets.set(key, { type: 'animDict', asset: dict, loaded: true });
+        return true;
+    }
+    isAnimDictLoaded(dict) {
+        return this.platform.hasAnimDictLoaded(dict);
+    }
+    releaseAnimDict(dict) {
+        this.platform.removeAnimDict(dict);
+        this.loadedAssets.delete(`anim:${dict}`);
+    }
+    async requestPtfxAsset(asset, timeout = 10000) {
+        const key = `ptfx:${asset}`;
+        if (this.loadedAssets.get(key)?.loaded)
+            return true;
+        this.platform.requestNamedPtfxAsset(asset);
+        const startTime = this.runtime.getGameTimer();
+        while (!this.platform.hasNamedPtfxAssetLoaded(asset)) {
+            if (this.runtime.getGameTimer() - startTime > timeout)
+                return false;
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        this.loadedAssets.set(key, { type: 'ptfx', asset, loaded: true });
+        return true;
+    }
+    isPtfxAssetLoaded(asset) {
+        return this.platform.hasNamedPtfxAssetLoaded(asset);
+    }
+    releasePtfxAsset(asset) {
+        this.platform.removeNamedPtfxAsset(asset);
+        this.loadedAssets.delete(`ptfx:${asset}`);
+    }
+    async startParticleEffect(asset, effectName, position, rotation = { x: 0, y: 0, z: 0 }, scale = 1.0, looped = false) {
+        await this.requestPtfxAsset(asset);
+        this.platform.useParticleFxAssetNextCall(asset);
+        return looped
+            ? this.platform.startParticleFxLoopedAtCoord(effectName, position, rotation, scale)
+            : this.platform.startParticleFxNonLoopedAtCoord(effectName, position, rotation, scale);
+    }
+    stopParticleEffect(handle) {
+        this.platform.stopParticleFxLooped(handle, false);
+    }
+    async requestTextureDict(dict, timeout = 10000) {
+        const key = `texture:${dict}`;
+        if (this.loadedAssets.get(key)?.loaded)
+            return true;
+        this.platform.requestStreamedTextureDict(dict, true);
+        const startTime = this.runtime.getGameTimer();
+        while (!this.platform.hasStreamedTextureDictLoaded(dict)) {
+            if (this.runtime.getGameTimer() - startTime > timeout)
+                return false;
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        this.loadedAssets.set(key, { type: 'texture', asset: dict, loaded: true });
+        return true;
+    }
+    isTextureDictLoaded(dict) {
+        return this.platform.hasStreamedTextureDictLoaded(dict);
+    }
+    releaseTextureDict(dict) {
+        this.platform.setStreamedTextureDictAsNoLongerNeeded(dict);
+        this.loadedAssets.delete(`texture:${dict}`);
+    }
+    async requestAudioBank(audioBank, networked = false, _timeout = 10000) {
+        const key = `audio:${audioBank}`;
+        if (this.loadedAssets.get(key)?.loaded)
+            return true;
+        const success = this.platform.requestScriptAudioBank(audioBank, networked);
+        if (!success)
+            return false;
+        this.loadedAssets.set(key, { type: 'audio', asset: audioBank, loaded: true });
+        return true;
+    }
+    releaseAudioBank(audioBank) {
+        this.platform.releaseScriptAudioBank(audioBank);
+        this.loadedAssets.delete(`audio:${audioBank}`);
+    }
+    getLoadedAssets() {
+        return Array.from(this.loadedAssets.values());
+    }
+    releaseAll() {
+        for (const asset of this.loadedAssets.values()) {
+            switch (asset.type) {
+                case 'model':
+                    if (asset.hash)
+                        this.platform.setModelAsNoLongerNeeded(asset.hash);
+                    break;
+                case 'animDict':
+                    this.platform.removeAnimDict(asset.asset);
+                    break;
+                case 'ptfx':
+                    this.platform.removeNamedPtfxAsset(asset.asset);
+                    break;
+                case 'texture':
+                    this.platform.setStreamedTextureDictAsNoLongerNeeded(asset.asset);
+                    break;
+                case 'audio':
+                    this.platform.releaseScriptAudioBank(asset.asset);
+                    break;
+            }
+        }
+        this.loadedAssets.clear();
+    }
+    getHash(str) {
+        return this.platform.getHashKey(str);
+    }
+};
+StreamingService = __decorate([
+    injectable(),
+    __param(0, inject(IClientPlatformBridge)),
+    __param(1, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientPlatformBridge,
+        IClientRuntimeBridge])
+], StreamingService);
+export { StreamingService };

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

@@ -0,0 +1,42 @@
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+export interface TextUIOptions {
+    font?: number;
+    scale?: number;
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    alignment?: number;
+    dropShadow?: boolean;
+    outline?: boolean;
+    wrapWidth?: number;
+}
+export interface Text3DOptions extends TextUIOptions {
+    background?: boolean;
+    backgroundColor?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    backgroundPadding?: number;
+}
+export declare class TextUIService {
+    private readonly platform;
+    private readonly runtime;
+    private activeTextUI;
+    private tickHandle;
+    constructor(platform: IClientPlatformBridge, runtime: IClientRuntimeBridge);
+    show(text: string, options?: TextUIOptions): void;
+    hide(): void;
+    isVisible(): boolean;
+    drawText(text: string, x: number, y: number, options?: TextUIOptions): void;
+    drawText3D(position: Vector3, text: string, options?: Text3DOptions): void;
+    getTextWidth(text: string, _font: number, scale: number): number;
+    private ensureTickRunning;
+    private stopTick;
+}