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

package/dist/adapters/contracts/IEngineEvents.d.ts

@@ -1,3 +1,4 @@
+import { type RuntimeEventMap, type RuntimeEventName } from './runtime';
 export declare abstract class IEngineEvents {
     /**
      * Registers a handler for a local (server-side) event.
@@ -6,6 +7,8 @@ export declare abstract class IEngineEvents {
      * @param handler - The callback to invoke when the event is emitted
      */
     abstract on(eventName: string, handler?: (...args: any[]) => void): void;
+    onRuntime(eventName: RuntimeEventName, handler?: (...args: any[]) => void): void;
+    getRuntimeEventMap(): RuntimeEventMap;
     /**
      * Emits a local event.
      *

package/dist/adapters/contracts/IEngineEvents.js

@@ -1,2 +1,9 @@
+import { DEFAULT_RUNTIME_EVENT_MAP } from './runtime';
 export class IEngineEvents {
+    onRuntime(eventName, handler) {
+        this.on(this.getRuntimeEventMap()[eventName] ?? eventName, handler);
+    }
+    getRuntimeEventMap() {
+        return DEFAULT_RUNTIME_EVENT_MAP;
+    }
 }

package/dist/adapters/contracts/IPlatformContext.d.ts

@@ -0,0 +1,43 @@
+export type platforms = 'node' | 'fivem' | 'ragemp' | 'redm';
+/**
+ * Platform context contract.
+ *
+ * Keeps the stable runtime information the framework actually uses across
+ * platforms, without exposing a generic feature registry.
+ */
+export declare abstract class IPlatformContext {
+    /**
+     * Unique platform identifier.
+     * @example 'node', 'fivem', 'ragemp', 'redm'
+     */
+    abstract readonly platformName: platforms | string;
+    /**
+     * Human-readable display name.
+     */
+    abstract readonly displayName: string;
+    /**
+     * Supported identifier types for this platform.
+     */
+    abstract readonly identifierTypes: readonly string[];
+    /**
+     * Maximum number of players supported by the platform.
+     * Returns undefined if unlimited or unknown.
+     */
+    abstract readonly maxPlayers: number | undefined;
+    /**
+     * Coarse game profile used by the framework.
+     */
+    abstract readonly gameProfile: 'gta5' | 'rdr3' | 'common';
+    /**
+     * Default player model used when no explicit model is provided.
+     */
+    abstract readonly defaultSpawnModel: string;
+    /**
+     * Default vehicle type used for server-side spawning.
+     */
+    abstract readonly defaultVehicleType: string;
+    /**
+     * Whether server-side vehicle creation should be enabled.
+     */
+    abstract readonly enableServerVehicleCreation: boolean;
+}

package/dist/adapters/contracts/IPlatformContext.js

@@ -0,0 +1,8 @@
+/**
+ * Platform context contract.
+ *
+ * Keeps the stable runtime information the framework actually uses across
+ * platforms, without exposing a generic feature registry.
+ */
+export class IPlatformContext {
+}

package/dist/adapters/contracts/client/IClientLocalPlayerBridge.d.ts

@@ -0,0 +1,4 @@
+import type { Vector3 } from '../../../kernel/utils/vector3';
+export declare abstract class IClientLocalPlayerBridge {
+    abstract setPosition(position: Vector3, heading?: number): void;
+}

package/dist/adapters/contracts/client/IClientLocalPlayerBridge.js

@@ -0,0 +1,2 @@
+export class IClientLocalPlayerBridge {
+}

package/dist/adapters/contracts/client/IClientLogConsole.d.ts

@@ -0,0 +1,13 @@
+export interface ClientLogConsoleCapabilities {
+    supportsColors: boolean;
+    supportsStructuredData: boolean;
+    supportsRichFormatting: boolean;
+}
+export declare abstract class IClientLogConsole {
+    abstract getCapabilities(): ClientLogConsoleCapabilities;
+    abstract trace(message: string, details?: unknown): void;
+    abstract debug(message: string, details?: unknown): void;
+    abstract info(message: string, details?: unknown): void;
+    abstract warn(message: string, details?: unknown): void;
+    abstract error(message: string, details?: unknown): void;
+}

package/dist/adapters/contracts/client/IClientLogConsole.js

@@ -0,0 +1,2 @@
+export class IClientLogConsole {
+}

package/dist/adapters/contracts/client/IClientPlatformBridge.d.ts

@@ -0,0 +1,195 @@
+import type { Vector3 } from '../../../kernel/utils/vector3';
+export interface TextDrawOptions {
+    font?: number;
+    scale?: number;
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    alignment?: number;
+    dropShadow?: boolean;
+    outline?: boolean;
+    wrapStart?: number;
+    wrapEnd?: number;
+    center?: boolean;
+}
+export declare class IClientPlatformBridge {
+    getLocalPlayerPed(): number;
+    getEntityCoords(_entity: number): Vector3;
+    getWorldPositionOfEntityBone(_entity: number, _bone: number): Vector3;
+    getGameplayCamCoords(): Vector3;
+    getDistanceBetweenCoords(a: Vector3, b: Vector3, useZ?: boolean): number;
+    worldToScreen(_position: Vector3): {
+        onScreen: boolean;
+        x: number;
+        y: number;
+    };
+    getHashKey(value: string): number;
+    isModelInCdimage(_hash: number): boolean;
+    isModelValid(_hash: number): boolean;
+    isModelAVehicle(_hash: number): boolean;
+    isModelAPed(_hash: number): boolean;
+    requestModel(_hash: number): void;
+    hasModelLoaded(_hash: number): boolean;
+    setModelAsNoLongerNeeded(_hash: number): void;
+    requestAnimDict(_dict: string): void;
+    hasAnimDictLoaded(_dict: string): boolean;
+    removeAnimDict(_dict: string): void;
+    requestNamedPtfxAsset(_asset: string): void;
+    hasNamedPtfxAssetLoaded(_asset: string): boolean;
+    removeNamedPtfxAsset(_asset: string): void;
+    useParticleFxAssetNextCall(_asset: string): void;
+    startParticleFxLoopedAtCoord(_effectName: string, _position: Vector3, _rotation: Vector3, _scale: number): number;
+    startParticleFxNonLoopedAtCoord(_effectName: string, _position: Vector3, _rotation: Vector3, _scale: number): number;
+    stopParticleFxLooped(_handle: number, _stop: boolean): void;
+    requestStreamedTextureDict(_dict: string, _persistent: boolean): void;
+    hasStreamedTextureDictLoaded(_dict: string): boolean;
+    setStreamedTextureDictAsNoLongerNeeded(_dict: string): void;
+    requestScriptAudioBank(_bank: string, _networked: boolean): boolean;
+    releaseScriptAudioBank(_bank: string): void;
+    doesEntityExist(_entity: number): boolean;
+    setEntityAsMissionEntity(_entity: number, _mission: boolean, _scriptHostObject: boolean): void;
+    setBlockingOfNonTemporaryEvents(_ped: number, _toggle: boolean): void;
+    setPedRelationshipGroupHash(_ped: number, _groupHash: number): void;
+    createPed(_pedType: number, _modelHash: number, _position: Vector3, _heading: number, _networked: boolean, _scriptHostPed: boolean): number;
+    deletePed(_ped: number): void;
+    createObject(_modelHash: number, _position: Vector3, _networked: boolean, _dynamic: boolean, _placeOnGround: boolean): number;
+    deleteEntity(_entity: number): void;
+    attachEntityToEntity(_entity: number, _target: number, _boneIndex: number, _offset: Vector3, _rotation: Vector3): void;
+    getPedBoneIndex(_ped: number, bone: number): number;
+    taskPlayAnim(_ped: number, _dict: string, _anim: string, _blendInSpeed: number, _blendOutSpeed: number, _duration: number, _flags: number, _playbackRate: number): void;
+    stopAnimTask(_ped: number, _dict: string, _anim: string, _blendOutSpeed: number): void;
+    clearPedTasks(_ped: number): void;
+    clearPedTasksImmediately(_ped: number): void;
+    freezeEntityPosition(_entity: number, _toggle: boolean): void;
+    setEntityInvincible(_entity: number, _toggle: boolean): void;
+    giveWeaponToPed(_ped: number, _weaponHash: number, _ammoCount: number, _hidden: boolean, _forceInHand: boolean): void;
+    removeAllPedWeapons(_ped: number, _includeCurrentWeapon: boolean): void;
+    getClosestPed(_position: Vector3, _radius: number): number | null;
+    getNearbyPeds(_position: Vector3, _radius: number, _excludeEntity?: number): number[];
+    taskLookAtEntity(_ped: number, _entity: number, _duration: number): void;
+    taskLookAtCoord(_ped: number, _position: Vector3, _duration: number): void;
+    taskGoStraightToCoord(_ped: number, _position: Vector3, _speed: number): void;
+    setPedCombatAttributes(_ped: number, _attributeIndex: number, _enabled: boolean): void;
+    createVehicle(_modelHash: number, _position: Vector3, _heading: number, _networked: boolean, _scriptHostVehicle: boolean): number;
+    deleteVehicle(_vehicle: number): void;
+    setVehicleOnGroundProperly(_vehicle: number): void;
+    getVehicleColours(_vehicle: number): [number, number];
+    setVehicleColours(_vehicle: number, _primary: number, _secondary: number): void;
+    setVehicleNumberPlateText(_vehicle: number, _plateText: string): void;
+    taskWarpPedIntoVehicle(_ped: number, _vehicle: number, _seatIndex: number): void;
+    taskLeaveVehicle(_ped: number, _vehicle: number, _flags: number): void;
+    getClosestVehicle(_position: Vector3, _radius: number): number | null;
+    isPedInAnyVehicle(_ped: number): boolean;
+    getVehiclePedIsIn(_ped: number, _lastVehicle: boolean): number | null;
+    getPedInVehicleSeat(_vehicle: number, _seatIndex: number): number | null;
+    getEntitySpeed(_entity: number): number;
+    networkGetNetworkIdFromEntity(_entity: number): number;
+    networkDoesEntityExistWithNetworkId(_networkId: number): boolean;
+    networkGetEntityFromNetworkId(_networkId: number): number;
+    getEntityHeading(_entity: number): number;
+    getEntityModel(_entity: number): number;
+    getVehicleNumberPlateText(_vehicle: number): string;
+    setVehicleModKit(_vehicle: number, _kit: number): void;
+    setVehicleMod(_vehicle: number, _modType: number, _modIndex: number, _customTires: boolean): void;
+    toggleVehicleMod(_vehicle: number, _modType: number, _toggle: boolean): void;
+    setVehicleWheelType(_vehicle: number, _wheelType: number): void;
+    setVehicleWindowTint(_vehicle: number, _tint: number): void;
+    setVehicleLivery(_vehicle: number, _livery: number): void;
+    setVehicleNumberPlateTextIndex(_vehicle: number, _index: number): void;
+    setVehicleNeonLightEnabled(_vehicle: number, _index: number, _enabled: boolean): void;
+    setVehicleNeonLightsColour(_vehicle: number, _r: number, _g: number, _b: number): void;
+    setVehicleExtra(_vehicle: number, _extraId: number, _disable: boolean): void;
+    getVehicleExtraColours(_vehicle: number): [number, number];
+    setVehicleExtraColours(_vehicle: number, _pearl: number, _wheel: number): void;
+    setVehicleFixed(_vehicle: number): void;
+    setVehicleDeformationFixed(_vehicle: number): void;
+    setVehicleUndriveable(_vehicle: number, _toggle: boolean): void;
+    setVehicleEngineOn(_vehicle: number, _value: boolean, _instantly: boolean, _disableAutoStart: boolean): void;
+    setVehicleEngineHealth(_vehicle: number, _health: number): void;
+    setVehiclePetrolTankHealth(_vehicle: number, _health: number): void;
+    setVehicleFuelLevel(_vehicle: number, _level: number): void;
+    getVehicleFuelLevel(_vehicle: number): number;
+    setVehicleDoorsLocked(_vehicle: number, _doorLockStatus: number): void;
+    setEntityHeading(_entity: number, _heading: number): void;
+    setEntityCoords(_entity: number, _position: Vector3): void;
+    setEntityCoordsNoOffset(_entity: number, _position: Vector3): void;
+    setEntityHealth(_entity: number, _health: number): void;
+    getEntityMaxHealth(_entity: number): number;
+    setPedArmour(_ped: number, _armour: number): void;
+    isScreenFadedOut(): boolean;
+    isScreenFadingOut(): boolean;
+    doScreenFadeOut(_ms: number): void;
+    isScreenFadedIn(): boolean;
+    isScreenFadingIn(): boolean;
+    doScreenFadeIn(_ms: number): void;
+    networkIsSessionStarted(): boolean;
+    networkResurrectLocalPlayer(_position: Vector3, _heading: number): void;
+    playerId(): number;
+    setPlayerModel(_playerId: number, _modelHash: number): void;
+    requestCollisionAtCoord(_position: Vector3): void;
+    hasCollisionLoadedAroundEntity(_entity: number): boolean;
+    resetEntityAlpha(_entity: number): void;
+    setEntityAlpha(_entity: number, _alphaLevel: number): void;
+    setEntityVisible(_entity: number, _toggle: boolean): void;
+    setEntityCollision(_entity: number, _toggle: boolean): void;
+    shutdownLoadingScreen(): void;
+    shutdownLoadingScreenNui(): void;
+    addTextComponentString(_text: string): void;
+    addTextComponentSubstringPlayerName(_text: string): void;
+    beginTextCommandDisplayHelp(_type: string): void;
+    endTextCommandDisplayHelp(_shape: number, _loop: boolean, _beep: boolean, _duration: number): void;
+    clearAllHelpMessages(): void;
+    beginTextCommandPrint(_type: string): void;
+    endTextCommandPrint(_duration: number, _drawImmediately: boolean): void;
+    clearPrints(): void;
+    setFloatingHelpTextWorldPosition(_style: number, _position: Vector3): void;
+    setFloatingHelpTextStyle(_style: number, _hudColor: number, _alpha: number, _p3: number, _arrowDirection: number, _p5: number): void;
+    setTextFont(_fontType: number): void;
+    setTextScale(_scale: number): void;
+    setTextColour(_color: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }): void;
+    setTextJustification(_justifyType: number): void;
+    setTextDropshadow(_distance: number, _r: number, _g: number, _b: number, _a: number): void;
+    setTextDropShadow(): void;
+    setTextOutline(): void;
+    setTextWrap(_start: number, _end: number): void;
+    setTextRightJustify(_toggle: boolean): void;
+    beginTextCommandDisplayText(_type: string): void;
+    endTextCommandDisplayText(_x: number, _y: number): void;
+    setTextCentre(_toggle: boolean): void;
+    beginTextCommandBusyspinnerOn(_type: string): void;
+    endTextCommandBusyspinnerOn(_busySpinnerType: number): void;
+    busyspinnerOff(): void;
+    disableAllControlActions(_padIndex: number): void;
+    disableControlAction(_padIndex: number, _control: number, _disable: boolean): void;
+    isControlJustPressed(_padIndex: number, _control: number): boolean;
+    drawRect(_x: number, _y: number, _width: number, _height: number, _r: number, _g: number, _b: number, _a: number): void;
+    displayHud(_toggle: boolean): void;
+    displayRadar(_toggle: boolean): void;
+    clearTimecycleModifier(): void;
+    setTimecycleModifier(_modifierName: string): void;
+    setTimecycleModifierStrength(_strength: number): void;
+    createCam(_camName: string, _active: boolean): number;
+    setCamActive(_cam: number, _active: boolean): void;
+    renderScriptCams(_render: boolean, _ease: boolean, _easeTimeMs: number, _p3: boolean, _p4: boolean): void;
+    destroyCam(_cam: number, _destroy: boolean): void;
+    destroyAllCams(_destroy: boolean): void;
+    setCamCoord(_cam: number, _position: Vector3): void;
+    setCamRot(_cam: number, _rotation: Vector3, _rotationOrder: number): void;
+    setCamFov(_cam: number, _fov: number): void;
+    pointCamAtCoord(_cam: number, _position: Vector3): void;
+    pointCamAtEntity(_cam: number, _entity: number, _offset: Vector3): void;
+    stopCamPointing(_cam: number): void;
+    setCamActiveWithInterp(_toCam: number, _fromCam: number, _durationMs: number, _easeLocation: number, _easeRotation: number): void;
+    shakeCam(_cam: number, _type: string, _amplitude: number): void;
+    stopCamShaking(_cam: number, _stopImmediately: boolean): void;
+    onLocalPlayerStateChange(_key: string, _handler: (value: unknown) => void): () => void;
+    getEntityState<T>(_entity: number, _key: string): T | undefined;
+}

package/dist/adapters/contracts/client/IClientPlatformBridge.js

@@ -0,0 +1,282 @@
+export class IClientPlatformBridge {
+    getLocalPlayerPed() {
+        return 0;
+    }
+    getEntityCoords(_entity) {
+        return { x: 0, y: 0, z: 0 };
+    }
+    getWorldPositionOfEntityBone(_entity, _bone) {
+        return { x: 0, y: 0, z: 0 };
+    }
+    getGameplayCamCoords() {
+        return { x: 0, y: 0, z: 0 };
+    }
+    getDistanceBetweenCoords(a, b, useZ = true) {
+        const dz = useZ ? a.z - b.z : 0;
+        return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2 + dz ** 2);
+    }
+    worldToScreen(_position) {
+        return { onScreen: false, x: 0, y: 0 };
+    }
+    getHashKey(value) {
+        let hash = 0;
+        const key = value.toLowerCase();
+        for (let i = 0; i < key.length; i += 1) {
+            hash += key.charCodeAt(i);
+            hash += hash << 10;
+            hash ^= hash >>> 6;
+        }
+        hash += hash << 3;
+        hash ^= hash >>> 11;
+        hash += hash << 15;
+        return hash >>> 0;
+    }
+    isModelInCdimage(_hash) {
+        return false;
+    }
+    isModelValid(_hash) {
+        return false;
+    }
+    isModelAVehicle(_hash) {
+        return false;
+    }
+    isModelAPed(_hash) {
+        return false;
+    }
+    requestModel(_hash) { }
+    hasModelLoaded(_hash) {
+        return false;
+    }
+    setModelAsNoLongerNeeded(_hash) { }
+    requestAnimDict(_dict) { }
+    hasAnimDictLoaded(_dict) {
+        return false;
+    }
+    removeAnimDict(_dict) { }
+    requestNamedPtfxAsset(_asset) { }
+    hasNamedPtfxAssetLoaded(_asset) {
+        return false;
+    }
+    removeNamedPtfxAsset(_asset) { }
+    useParticleFxAssetNextCall(_asset) { }
+    startParticleFxLoopedAtCoord(_effectName, _position, _rotation, _scale) {
+        return 0;
+    }
+    startParticleFxNonLoopedAtCoord(_effectName, _position, _rotation, _scale) {
+        return 0;
+    }
+    stopParticleFxLooped(_handle, _stop) { }
+    requestStreamedTextureDict(_dict, _persistent) { }
+    hasStreamedTextureDictLoaded(_dict) {
+        return false;
+    }
+    setStreamedTextureDictAsNoLongerNeeded(_dict) { }
+    requestScriptAudioBank(_bank, _networked) {
+        return false;
+    }
+    releaseScriptAudioBank(_bank) { }
+    doesEntityExist(_entity) {
+        return false;
+    }
+    setEntityAsMissionEntity(_entity, _mission, _scriptHostObject) { }
+    setBlockingOfNonTemporaryEvents(_ped, _toggle) { }
+    setPedRelationshipGroupHash(_ped, _groupHash) { }
+    createPed(_pedType, _modelHash, _position, _heading, _networked, _scriptHostPed) {
+        return 0;
+    }
+    deletePed(_ped) { }
+    createObject(_modelHash, _position, _networked, _dynamic, _placeOnGround) {
+        return 0;
+    }
+    deleteEntity(_entity) { }
+    attachEntityToEntity(_entity, _target, _boneIndex, _offset, _rotation) { }
+    getPedBoneIndex(_ped, bone) {
+        return bone;
+    }
+    taskPlayAnim(_ped, _dict, _anim, _blendInSpeed, _blendOutSpeed, _duration, _flags, _playbackRate) { }
+    stopAnimTask(_ped, _dict, _anim, _blendOutSpeed) { }
+    clearPedTasks(_ped) { }
+    clearPedTasksImmediately(_ped) { }
+    freezeEntityPosition(_entity, _toggle) { }
+    setEntityInvincible(_entity, _toggle) { }
+    giveWeaponToPed(_ped, _weaponHash, _ammoCount, _hidden, _forceInHand) { }
+    removeAllPedWeapons(_ped, _includeCurrentWeapon) { }
+    getClosestPed(_position, _radius) {
+        return null;
+    }
+    getNearbyPeds(_position, _radius, _excludeEntity) {
+        return [];
+    }
+    taskLookAtEntity(_ped, _entity, _duration) { }
+    taskLookAtCoord(_ped, _position, _duration) { }
+    taskGoStraightToCoord(_ped, _position, _speed) { }
+    setPedCombatAttributes(_ped, _attributeIndex, _enabled) { }
+    createVehicle(_modelHash, _position, _heading, _networked, _scriptHostVehicle) {
+        return 0;
+    }
+    deleteVehicle(_vehicle) { }
+    setVehicleOnGroundProperly(_vehicle) { }
+    getVehicleColours(_vehicle) {
+        return [0, 0];
+    }
+    setVehicleColours(_vehicle, _primary, _secondary) { }
+    setVehicleNumberPlateText(_vehicle, _plateText) { }
+    taskWarpPedIntoVehicle(_ped, _vehicle, _seatIndex) { }
+    taskLeaveVehicle(_ped, _vehicle, _flags) { }
+    getClosestVehicle(_position, _radius) {
+        return null;
+    }
+    isPedInAnyVehicle(_ped) {
+        return false;
+    }
+    getVehiclePedIsIn(_ped, _lastVehicle) {
+        return null;
+    }
+    getPedInVehicleSeat(_vehicle, _seatIndex) {
+        return null;
+    }
+    getEntitySpeed(_entity) {
+        return 0;
+    }
+    networkGetNetworkIdFromEntity(_entity) {
+        return 0;
+    }
+    networkDoesEntityExistWithNetworkId(_networkId) {
+        return false;
+    }
+    networkGetEntityFromNetworkId(_networkId) {
+        return 0;
+    }
+    getEntityHeading(_entity) {
+        return 0;
+    }
+    getEntityModel(_entity) {
+        return 0;
+    }
+    getVehicleNumberPlateText(_vehicle) {
+        return '';
+    }
+    setVehicleModKit(_vehicle, _kit) { }
+    setVehicleMod(_vehicle, _modType, _modIndex, _customTires) { }
+    toggleVehicleMod(_vehicle, _modType, _toggle) { }
+    setVehicleWheelType(_vehicle, _wheelType) { }
+    setVehicleWindowTint(_vehicle, _tint) { }
+    setVehicleLivery(_vehicle, _livery) { }
+    setVehicleNumberPlateTextIndex(_vehicle, _index) { }
+    setVehicleNeonLightEnabled(_vehicle, _index, _enabled) { }
+    setVehicleNeonLightsColour(_vehicle, _r, _g, _b) { }
+    setVehicleExtra(_vehicle, _extraId, _disable) { }
+    getVehicleExtraColours(_vehicle) {
+        return [0, 0];
+    }
+    setVehicleExtraColours(_vehicle, _pearl, _wheel) { }
+    setVehicleFixed(_vehicle) { }
+    setVehicleDeformationFixed(_vehicle) { }
+    setVehicleUndriveable(_vehicle, _toggle) { }
+    setVehicleEngineOn(_vehicle, _value, _instantly, _disableAutoStart) { }
+    setVehicleEngineHealth(_vehicle, _health) { }
+    setVehiclePetrolTankHealth(_vehicle, _health) { }
+    setVehicleFuelLevel(_vehicle, _level) { }
+    getVehicleFuelLevel(_vehicle) {
+        return 0;
+    }
+    setVehicleDoorsLocked(_vehicle, _doorLockStatus) { }
+    setEntityHeading(_entity, _heading) { }
+    setEntityCoords(_entity, _position) { }
+    setEntityCoordsNoOffset(_entity, _position) { }
+    setEntityHealth(_entity, _health) { }
+    getEntityMaxHealth(_entity) {
+        return 200;
+    }
+    setPedArmour(_ped, _armour) { }
+    isScreenFadedOut() {
+        return false;
+    }
+    isScreenFadingOut() {
+        return false;
+    }
+    doScreenFadeOut(_ms) { }
+    isScreenFadedIn() {
+        return true;
+    }
+    isScreenFadingIn() {
+        return false;
+    }
+    doScreenFadeIn(_ms) { }
+    networkIsSessionStarted() {
+        return true;
+    }
+    networkResurrectLocalPlayer(_position, _heading) { }
+    playerId() {
+        return 0;
+    }
+    setPlayerModel(_playerId, _modelHash) { }
+    requestCollisionAtCoord(_position) { }
+    hasCollisionLoadedAroundEntity(_entity) {
+        return true;
+    }
+    resetEntityAlpha(_entity) { }
+    setEntityAlpha(_entity, _alphaLevel) { }
+    setEntityVisible(_entity, _toggle) { }
+    setEntityCollision(_entity, _toggle) { }
+    shutdownLoadingScreen() { }
+    shutdownLoadingScreenNui() { }
+    addTextComponentString(_text) { }
+    addTextComponentSubstringPlayerName(_text) { }
+    beginTextCommandDisplayHelp(_type) { }
+    endTextCommandDisplayHelp(_shape, _loop, _beep, _duration) { }
+    clearAllHelpMessages() { }
+    beginTextCommandPrint(_type) { }
+    endTextCommandPrint(_duration, _drawImmediately) { }
+    clearPrints() { }
+    setFloatingHelpTextWorldPosition(_style, _position) { }
+    setFloatingHelpTextStyle(_style, _hudColor, _alpha, _p3, _arrowDirection, _p5) { }
+    setTextFont(_fontType) { }
+    setTextScale(_scale) { }
+    setTextColour(_color) { }
+    setTextJustification(_justifyType) { }
+    setTextDropshadow(_distance, _r, _g, _b, _a) { }
+    setTextDropShadow() { }
+    setTextOutline() { }
+    setTextWrap(_start, _end) { }
+    setTextRightJustify(_toggle) { }
+    beginTextCommandDisplayText(_type) { }
+    endTextCommandDisplayText(_x, _y) { }
+    setTextCentre(_toggle) { }
+    beginTextCommandBusyspinnerOn(_type) { }
+    endTextCommandBusyspinnerOn(_busySpinnerType) { }
+    busyspinnerOff() { }
+    disableAllControlActions(_padIndex) { }
+    disableControlAction(_padIndex, _control, _disable) { }
+    isControlJustPressed(_padIndex, _control) {
+        return false;
+    }
+    drawRect(_x, _y, _width, _height, _r, _g, _b, _a) { }
+    displayHud(_toggle) { }
+    displayRadar(_toggle) { }
+    clearTimecycleModifier() { }
+    setTimecycleModifier(_modifierName) { }
+    setTimecycleModifierStrength(_strength) { }
+    createCam(_camName, _active) {
+        return 0;
+    }
+    setCamActive(_cam, _active) { }
+    renderScriptCams(_render, _ease, _easeTimeMs, _p3, _p4) { }
+    destroyCam(_cam, _destroy) { }
+    destroyAllCams(_destroy) { }
+    setCamCoord(_cam, _position) { }
+    setCamRot(_cam, _rotation, _rotationOrder) { }
+    setCamFov(_cam, _fov) { }
+    pointCamAtCoord(_cam, _position) { }
+    pointCamAtEntity(_cam, _entity, _offset) { }
+    stopCamPointing(_cam) { }
+    setCamActiveWithInterp(_toCam, _fromCam, _durationMs, _easeLocation, _easeRotation) { }
+    shakeCam(_cam, _type, _amplitude) { }
+    stopCamShaking(_cam, _stopImmediately) { }
+    onLocalPlayerStateChange(_key, _handler) {
+        return () => { };
+    }
+    getEntityState(_entity, _key) {
+        return undefined;
+    }
+}

package/dist/adapters/contracts/client/IClientRuntimeBridge.d.ts

@@ -0,0 +1,18 @@
+export declare abstract class IClientRuntimeBridge {
+    abstract getCurrentResourceName(): string;
+    abstract on(eventName: string, handler: (...args: any[]) => void | Promise<void>): void;
+    abstract registerCommand(commandName: string, handler: (...args: any[]) => void, restricted: boolean): void;
+    abstract registerKeyMapping(commandName: string, description: string, inputMapper: string, key: string): void;
+    abstract setTick(handler: () => void | Promise<void>): unknown;
+    abstract clearTick(handle: unknown): void;
+    abstract getGameTimer(): number;
+    registerWebViewCallback(eventName: string, handler: (data: any, cb: (response: unknown) => void) => void | Promise<void>): void;
+    sendWebViewMessage(message: string): void;
+    setWebViewFocus(hasFocus: boolean, hasCursor: boolean): void;
+    setWebViewInputPassthrough(enabled: boolean): void;
+    abstract registerNuiCallback(eventName: string, handler: (data: any, cb: (response: unknown) => void) => void | Promise<void>): void;
+    abstract sendNuiMessage(message: string): void;
+    abstract setNuiFocus(hasFocus: boolean, hasCursor: boolean): void;
+    abstract setNuiFocusKeepInput(keepInput: boolean): void;
+    abstract registerExport(exportName: string, handler: (...args: any[]) => any): void;
+}

package/dist/adapters/contracts/client/IClientRuntimeBridge.js

@@ -0,0 +1,14 @@
+export class IClientRuntimeBridge {
+    registerWebViewCallback(eventName, handler) {
+        this.registerNuiCallback(eventName, handler);
+    }
+    sendWebViewMessage(message) {
+        this.sendNuiMessage(message);
+    }
+    setWebViewFocus(hasFocus, hasCursor) {
+        this.setNuiFocus(hasFocus, hasCursor);
+    }
+    setWebViewInputPassthrough(enabled) {
+        this.setNuiFocusKeepInput(enabled);
+    }
+}

package/dist/adapters/contracts/client/IGtaPedAppearanceBridge.d.ts

@@ -0,0 +1,26 @@
+import { HeadBlendData } from '../../../kernel/shared/player-appearance.types';
+export declare abstract class IGtaPedAppearanceBridge {
+    abstract setComponentVariation(ped: number, componentId: number, drawable: number, texture: number, palette: number): void;
+    abstract setPropIndex(ped: number, propId: number, drawable: number, texture: number, attach: boolean): void;
+    abstract clearProp(ped: number, propId: number): void;
+    abstract setDefaultComponentVariation(ped: number): void;
+    abstract setHeadBlendData(ped: number, data: HeadBlendData): void;
+    abstract setFaceFeature(ped: number, index: number, scale: number): void;
+    abstract setHeadOverlay(ped: number, overlayId: number, index: number, opacity: number): void;
+    abstract setHeadOverlayColor(ped: number, overlayId: number, colorType: number, colorId: number, secondColorId: number): void;
+    abstract setHairColor(ped: number, colorId: number, highlightColorId: number): void;
+    abstract setEyeColor(ped: number, index: number): void;
+    abstract addDecoration(ped: number, collectionHash: number, overlayHash: number): void;
+    abstract clearDecorations(ped: number): void;
+    abstract getDrawableVariation(ped: number, componentId: number): number;
+    abstract getTextureVariation(ped: number, componentId: number): number;
+    abstract getPropIndex(ped: number, propId: number): number;
+    abstract getPropTextureIndex(ped: number, propId: number): number;
+    abstract getNumDrawableVariations(ped: number, componentId: number): number;
+    abstract getNumTextureVariations(ped: number, componentId: number, drawable: number): number;
+    abstract getNumPropDrawableVariations(ped: number, propId: number): number;
+    abstract getNumPropTextureVariations(ped: number, propId: number, drawable: number): number;
+    abstract getNumOverlayValues(overlayId: number): number;
+    abstract getNumHairColors(): number;
+    abstract getNumMakeupColors(): number;
+}

package/dist/adapters/contracts/client/IGtaPedAppearanceBridge.js

@@ -0,0 +1,2 @@
+export class IGtaPedAppearanceBridge {
+}

package/dist/adapters/contracts/client/index.d.ts

@@ -0,0 +1,7 @@
+export * from './IClientLogConsole';
+export * from './IClientLocalPlayerBridge';
+export * from './IClientPlatformBridge';
+export * from './IClientRuntimeBridge';
+export * from './IGtaPedAppearanceBridge';
+export * from './spawn';
+export * from './ui';

package/dist/adapters/contracts/client/index.js

@@ -0,0 +1,7 @@
+export * from './IClientLogConsole';
+export * from './IClientLocalPlayerBridge';
+export * from './IClientPlatformBridge';
+export * from './IClientRuntimeBridge';
+export * from './IGtaPedAppearanceBridge';
+export * from './spawn';
+export * from './ui';

package/dist/adapters/contracts/client/spawn/IClientSpawnBridge.d.ts

@@ -0,0 +1,7 @@
+import type { RespawnRequest, SpawnRequest, TeleportRequest } from './types';
+export declare abstract class IClientSpawnBridge {
+    abstract waitUntilReady(timeoutMs?: number): Promise<void>;
+    abstract spawn(request: SpawnRequest): Promise<void>;
+    abstract respawn(request: RespawnRequest): Promise<void>;
+    abstract teleport(request: TeleportRequest): Promise<void>;
+}