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

package/dist/adapters/node/node-capabilities.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 { IPlatformContext } from '../contracts/IPlatformContext';
+import { IdentifierTypes } from '../contracts/types/identifier';
+/**
+ * Node.js mock platform context implementation.
+ * Used for testing and standalone development.
+ */
+let NodePlatformContext = class NodePlatformContext extends IPlatformContext {
+    platformName = 'node';
+    displayName = 'Node.js (Mock)';
+    identifierTypes = [
+        IdentifierTypes.STEAM,
+        IdentifierTypes.LICENSE,
+        IdentifierTypes.DISCORD,
+        IdentifierTypes.IP,
+    ];
+    maxPlayers = undefined;
+    gameProfile = 'common';
+    defaultSpawnModel = 'mp_m_freemode_01';
+    defaultVehicleType = 'automobile';
+    enableServerVehicleCreation = true;
+};
+NodePlatformContext = __decorate([
+    injectable()
+], NodePlatformContext);
+export { NodePlatformContext };
+/**
+ * @deprecated Use NodePlatformContext.
+ */
+export const NodeCapabilities = NodePlatformContext;

package/dist/adapters/node/node-engine-events.d.ts

@@ -0,0 +1,20 @@
+import { IEngineEvents } from '../contracts/IEngineEvents';
+/**
+ * Node.js implementation of IEngineEvents using EventEmitter.
+ * Suitable for testing and non-FiveM runtime environments.
+ *
+ * Note: In Node.js, there are no native engine events like FiveM's lifecycle events.
+ * This implementation provides a mock event system for testing purposes.
+ */
+export declare class NodeEngineEvents extends IEngineEvents {
+    private eventEmitter;
+    on(eventName: string, handler?: (...args: any[]) => void): void;
+    /**
+     * Utility method for testing: emit an engine event
+     */
+    emit(eventName: string, ...args: any[]): void;
+    /**
+     * Utility method for testing: clear all event listeners
+     */
+    clearListeners(): void;
+}

package/dist/adapters/node/node-engine-events.js

@@ -0,0 +1,41 @@
+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 { EventEmitter } from 'node:events';
+import { injectable } from 'tsyringe';
+import { IEngineEvents } from '../contracts/IEngineEvents';
+/**
+ * Node.js implementation of IEngineEvents using EventEmitter.
+ * Suitable for testing and non-FiveM runtime environments.
+ *
+ * Note: In Node.js, there are no native engine events like FiveM's lifecycle events.
+ * This implementation provides a mock event system for testing purposes.
+ */
+let NodeEngineEvents = class NodeEngineEvents extends IEngineEvents {
+    eventEmitter = new EventEmitter();
+    on(eventName, handler) {
+        if (handler)
+            this.eventEmitter.on(eventName, handler);
+        else
+            this.eventEmitter.on(eventName, () => { }); // empty handler
+    }
+    /**
+     * Utility method for testing: emit an engine event
+     */
+    emit(eventName, ...args) {
+        this.eventEmitter.emit(eventName, ...args);
+    }
+    /**
+     * Utility method for testing: clear all event listeners
+     */
+    clearListeners() {
+        this.eventEmitter.removeAllListeners();
+    }
+};
+NodeEngineEvents = __decorate([
+    injectable()
+], NodeEngineEvents);
+export { NodeEngineEvents };

package/dist/adapters/node/node-entity-server.d.ts

@@ -0,0 +1,37 @@
+import { Vector3 } from '../../kernel/utils/vector3';
+import { type EntityStateBag, IEntityServer, type SetPositionOptions } from '../contracts/server/IEntityServer';
+/**
+ * Node.js mock implementation of server-side entity operations.
+ * Used for testing and standalone mode.
+ */
+export declare class NodeEntityServer extends IEntityServer {
+    private entities;
+    private stateBags;
+    doesExist(handle: number): boolean;
+    getCoords(handle: number): Vector3;
+    setPosition(handle: number, position: Vector3, _options?: SetPositionOptions): void;
+    /**
+     * @deprecated Use setPosition() for cross-platform compatibility.
+     */
+    setCoords(handle: number, x: number, y: number, z: number): void;
+    getHeading(handle: number): number;
+    setHeading(handle: number, heading: number): void;
+    getModel(handle: number): number;
+    delete(handle: number): void;
+    setOrphanMode(_handle: number, _mode: number): void;
+    setDimension(handle: number, bucket: number): void;
+    getDimension(handle: number): number;
+    getStateBag(handle: number): EntityStateBag;
+    getHealth(handle: number): number;
+    setHealth(handle: number, health: number): void;
+    getArmor(handle: number): number;
+    setArmor(handle: number, armor: number): void;
+    /**
+     * Create a mock entity for testing.
+     */
+    _createMockEntity(handle: number, model: number, coords: Vector3, heading?: number): void;
+    /**
+     * Clear all mock entities.
+     */
+    _clearAll(): void;
+}

package/dist/adapters/node/node-entity-server.js

@@ -0,0 +1,118 @@
+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 { IEntityServer, } from '../contracts/server/IEntityServer';
+/**
+ * Node.js mock implementation of server-side entity operations.
+ * Used for testing and standalone mode.
+ */
+let NodeEntityServer = class NodeEntityServer extends IEntityServer {
+    entities = new Map();
+    stateBags = new Map();
+    doesExist(handle) {
+        return this.entities.has(handle);
+    }
+    getCoords(handle) {
+        return this.entities.get(handle)?.coords ?? { x: 0, y: 0, z: 0 };
+    }
+    setPosition(handle, position, _options) {
+        const entity = this.entities.get(handle);
+        if (entity) {
+            entity.coords = { ...position };
+        }
+    }
+    /**
+     * @deprecated Use setPosition() for cross-platform compatibility.
+     */
+    setCoords(handle, x, y, z) {
+        const entity = this.entities.get(handle);
+        if (entity) {
+            entity.coords = { x, y, z };
+        }
+    }
+    getHeading(handle) {
+        return this.entities.get(handle)?.heading ?? 0;
+    }
+    setHeading(handle, heading) {
+        const entity = this.entities.get(handle);
+        if (entity) {
+            entity.heading = heading;
+        }
+    }
+    getModel(handle) {
+        return this.entities.get(handle)?.model ?? 0;
+    }
+    delete(handle) {
+        this.entities.delete(handle);
+        this.stateBags.delete(handle);
+    }
+    setOrphanMode(_handle, _mode) {
+        // No-op in Node
+    }
+    setDimension(handle, bucket) {
+        const entity = this.entities.get(handle);
+        if (entity) {
+            entity.bucket = bucket;
+        }
+    }
+    getDimension(handle) {
+        return this.entities.get(handle)?.bucket ?? 0;
+    }
+    getStateBag(handle) {
+        if (!this.stateBags.has(handle)) {
+            this.stateBags.set(handle, new Map());
+        }
+        const bag = this.stateBags.get(handle);
+        if (!bag) {
+            throw new Error(`[OpenCore] NodeEntityServer state bag missing for handle ${handle}`);
+        }
+        return {
+            set: (key, value) => {
+                bag.set(key, value);
+            },
+            get: (key) => {
+                return bag.get(key);
+            },
+        };
+    }
+    getHealth(handle) {
+        const bag = this.getStateBag(handle);
+        return bag.get('health') ?? 200;
+    }
+    setHealth(handle, health) {
+        const bag = this.getStateBag(handle);
+        bag.set('health', health, true);
+    }
+    getArmor(handle) {
+        const bag = this.getStateBag(handle);
+        return bag.get('armor') ?? 0;
+    }
+    setArmor(handle, armor) {
+        const bag = this.getStateBag(handle);
+        bag.set('armor', armor, true);
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Test Helpers
+    // ─────────────────────────────────────────────────────────────────
+    /**
+     * Create a mock entity for testing.
+     */
+    _createMockEntity(handle, model, coords, heading = 0) {
+        this.entities.set(handle, { coords, heading, model, bucket: 0 });
+    }
+    /**
+     * Clear all mock entities.
+     */
+    _clearAll() {
+        this.entities.clear();
+        this.stateBags.clear();
+    }
+};
+NodeEntityServer = __decorate([
+    injectable()
+], NodeEntityServer);
+export { NodeEntityServer };

package/dist/adapters/node/node-exports.d.ts

@@ -0,0 +1,26 @@
+import { IExports } from '../contracts/IExports';
+/**
+ * Node.js implementation of IExports using in-memory registry.
+ * Suitable for testing and non-FiveM runtime environments.
+ */
+export declare class NodeExports implements IExports {
+    private exports;
+    register(exportName: string, handler: (...args: any[]) => any): void;
+    getResource(resourceName: string): any;
+    /**
+     * Get all registered exports as an object
+     */
+    private getExportsObject;
+    /**
+     * Get the current resource name (stub for Node environment)
+     */
+    private getCurrentResourceName;
+    /**
+     * Utility method for testing: get a specific export
+     */
+    getExport(exportName: string): ((...args: any[]) => any) | undefined;
+    /**
+     * Utility method for testing: clear all exports
+     */
+    clearExports(): void;
+}

package/dist/adapters/node/node-exports.js

@@ -0,0 +1,58 @@
+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';
+/**
+ * Node.js implementation of IExports using in-memory registry.
+ * Suitable for testing and non-FiveM runtime environments.
+ */
+let NodeExports = class NodeExports {
+    exports = new Map();
+    register(exportName, handler) {
+        this.exports.set(exportName, handler);
+    }
+    getResource(resourceName) {
+        // In Node.js environment, cross-resource access is not supported
+        // This is a stub that returns an object with the current resource's exports
+        if (resourceName === this.getCurrentResourceName()) {
+            return this.getExportsObject();
+        }
+        throw new Error(`Cross-resource exports not supported in Node.js runtime. ` +
+            `Attempted to access resource: ${resourceName}`);
+    }
+    /**
+     * Get all registered exports as an object
+     */
+    getExportsObject() {
+        const obj = {};
+        this.exports.forEach((handler, name) => {
+            obj[name] = handler;
+        });
+        return obj;
+    }
+    /**
+     * Get the current resource name (stub for Node environment)
+     */
+    getCurrentResourceName() {
+        return process.env.RESOURCE_NAME || 'default';
+    }
+    /**
+     * Utility method for testing: get a specific export
+     */
+    getExport(exportName) {
+        return this.exports.get(exportName);
+    }
+    /**
+     * Utility method for testing: clear all exports
+     */
+    clearExports() {
+        this.exports.clear();
+    }
+};
+NodeExports = __decorate([
+    injectable()
+], NodeExports);
+export { NodeExports };

package/dist/adapters/node/node-hasher.d.ts

@@ -0,0 +1,12 @@
+import { IHasher } from '../contracts/IHasher';
+/**
+ * Node.js implementation of hash utilities.
+ * Implements joaat hash algorithm.
+ */
+export declare class NodeHasher extends IHasher {
+    /**
+     * Gets the hash key for a string using joaat algorithm.
+     * This is the same algorithm FiveM uses for GetHashKey.
+     */
+    getHashKey(str: string): number;
+}

package/dist/adapters/node/node-hasher.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 { IHasher } from '../contracts/IHasher';
+/**
+ * Node.js implementation of hash utilities.
+ * Implements joaat hash algorithm.
+ */
+let NodeHasher = class NodeHasher extends IHasher {
+    /**
+     * Gets the hash key for a string using joaat algorithm.
+     * This is the same algorithm FiveM uses for GetHashKey.
+     */
+    getHashKey(str) {
+        const key = str.toLowerCase();
+        let hash = 0;
+        for (let i = 0; i < key.length; i++) {
+            hash += key.charCodeAt(i);
+            hash += hash << 10;
+            hash ^= hash >>> 6;
+        }
+        hash += hash << 3;
+        hash ^= hash >>> 11;
+        hash += hash << 15;
+        // Convert to unsigned 32-bit integer
+        return hash >>> 0;
+    }
+};
+NodeHasher = __decorate([
+    injectable()
+], NodeHasher);
+export { NodeHasher };

package/dist/adapters/node/node-ped-appearance-client.d.ts

@@ -0,0 +1,34 @@
+import { HeadBlendData } from '../../kernel/shared';
+import { IGtaPedAppearanceBridge } from '../contracts/client/IGtaPedAppearanceBridge';
+/**
+ * Node.js stub implementation of client-side ped appearance adapter.
+ *
+ * @remarks
+ * This is a no-op implementation for testing in Node.js environment.
+ * All methods return default values or do nothing.
+ */
+export declare class NodePedAppearanceClient extends IGtaPedAppearanceBridge {
+    setComponentVariation(): void;
+    setPropIndex(): void;
+    clearProp(): void;
+    setDefaultComponentVariation(): void;
+    setHeadBlendData(_ped: number, _data: HeadBlendData): void;
+    setFaceFeature(): void;
+    setHeadOverlay(): void;
+    setHeadOverlayColor(): void;
+    setHairColor(): void;
+    setEyeColor(): void;
+    addDecoration(): void;
+    clearDecorations(): void;
+    getDrawableVariation(): number;
+    getTextureVariation(): number;
+    getPropIndex(): number;
+    getPropTextureIndex(): number;
+    getNumDrawableVariations(): number;
+    getNumTextureVariations(): number;
+    getNumPropDrawableVariations(): number;
+    getNumPropTextureVariations(): number;
+    getNumOverlayValues(): number;
+    getNumHairColors(): number;
+    getNumMakeupColors(): number;
+}

package/dist/adapters/node/node-ped-appearance-client.js

@@ -0,0 +1,55 @@
+import { IGtaPedAppearanceBridge } from '../contracts/client/IGtaPedAppearanceBridge';
+/**
+ * Node.js stub implementation of client-side ped appearance adapter.
+ *
+ * @remarks
+ * This is a no-op implementation for testing in Node.js environment.
+ * All methods return default values or do nothing.
+ */
+export class NodePedAppearanceClient extends IGtaPedAppearanceBridge {
+    setComponentVariation() { }
+    setPropIndex() { }
+    clearProp() { }
+    setDefaultComponentVariation() { }
+    setHeadBlendData(_ped, _data) { }
+    setFaceFeature() { }
+    setHeadOverlay() { }
+    setHeadOverlayColor() { }
+    setHairColor() { }
+    setEyeColor() { }
+    addDecoration() { }
+    clearDecorations() { }
+    getDrawableVariation() {
+        return 0;
+    }
+    getTextureVariation() {
+        return 0;
+    }
+    getPropIndex() {
+        return -1;
+    }
+    getPropTextureIndex() {
+        return 0;
+    }
+    getNumDrawableVariations() {
+        return 0;
+    }
+    getNumTextureVariations() {
+        return 0;
+    }
+    getNumPropDrawableVariations() {
+        return 0;
+    }
+    getNumPropTextureVariations() {
+        return 0;
+    }
+    getNumOverlayValues() {
+        return 0;
+    }
+    getNumHairColors() {
+        return 0;
+    }
+    getNumMakeupColors() {
+        return 0;
+    }
+}

package/dist/adapters/node/node-ped-appearance-server.d.ts

@@ -0,0 +1,14 @@
+import { IPedAppearanceServer } from '../contracts/server/IPedAppearanceServer';
+/**
+ * Node.js stub implementation of server-side ped appearance adapter.
+ *
+ * @remarks
+ * This is a no-op implementation for testing in Node.js environment.
+ * All methods do nothing.
+ */
+export declare class NodePedAppearanceServer extends IPedAppearanceServer {
+    setComponentVariation(): void;
+    setPropIndex(): void;
+    clearProp(): void;
+    setDefaultComponentVariation(): void;
+}

package/dist/adapters/node/node-ped-appearance-server.js

@@ -0,0 +1,14 @@
+import { IPedAppearanceServer } from '../contracts/server/IPedAppearanceServer';
+/**
+ * Node.js stub implementation of server-side ped appearance adapter.
+ *
+ * @remarks
+ * This is a no-op implementation for testing in Node.js environment.
+ * All methods do nothing.
+ */
+export class NodePedAppearanceServer extends IPedAppearanceServer {
+    setComponentVariation() { }
+    setPropIndex() { }
+    clearProp() { }
+    setDefaultComponentVariation() { }
+}

package/dist/adapters/node/node-ped-server.d.ts

@@ -0,0 +1,13 @@
+import { IPedServer } from '../contracts/server/IPedServer';
+/** Node.js mock implementation of server-side ped operations. */
+export declare class NodePedServer extends IPedServer {
+    private readonly byHandle;
+    private readonly byNetworkId;
+    private nextHandle;
+    private nextNetworkId;
+    create(_pedType: number, _modelHash: number, _x: number, _y: number, _z: number, _heading: number, networked: boolean): number;
+    delete(handle: number): void;
+    getNetworkIdFromEntity(handle: number): number;
+    getEntityFromNetworkId(networkId: number): number;
+    networkIdExists(networkId: number): boolean;
+}

package/dist/adapters/node/node-ped-server.js

@@ -0,0 +1,45 @@
+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 { IPedServer } from '../contracts/server/IPedServer';
+/** Node.js mock implementation of server-side ped operations. */
+let NodePedServer = class NodePedServer extends IPedServer {
+    byHandle = new Map();
+    byNetworkId = new Map();
+    nextHandle = 2000;
+    nextNetworkId = 5000;
+    create(_pedType, _modelHash, _x, _y, _z, _heading, networked) {
+        const handle = this.nextHandle++;
+        this.byHandle.set(handle, 0);
+        if (networked) {
+            const netId = this.nextNetworkId++;
+            this.byHandle.set(handle, netId);
+            this.byNetworkId.set(netId, handle);
+        }
+        return handle;
+    }
+    delete(handle) {
+        const netId = this.byHandle.get(handle);
+        if (netId && netId > 0) {
+            this.byNetworkId.delete(netId);
+        }
+        this.byHandle.delete(handle);
+    }
+    getNetworkIdFromEntity(handle) {
+        return this.byHandle.get(handle) ?? 0;
+    }
+    getEntityFromNetworkId(networkId) {
+        return this.byNetworkId.get(networkId) ?? 0;
+    }
+    networkIdExists(networkId) {
+        return this.byNetworkId.has(networkId);
+    }
+};
+NodePedServer = __decorate([
+    injectable()
+], NodePedServer);
+export { NodePedServer };

package/dist/adapters/node/node-platform.d.ts

@@ -0,0 +1,5 @@
+import type { PlatformAdapter } from '../platform/platform-registry';
+/**
+ * Node.js mock platform adapter for testing and standalone development.
+ */
+export declare const NodePlatform: PlatformAdapter;

package/dist/adapters/node/node-platform.js

@@ -0,0 +1,76 @@
+import { IEngineEvents } from '../contracts/IEngineEvents';
+import { IExports } from '../contracts/IExports';
+import { IHasher } from '../contracts/IHasher';
+import { IPlatformContext } from '../contracts/IPlatformContext';
+import { IPlayerInfo } from '../contracts/IPlayerInfo';
+import { IResourceInfo } from '../contracts/IResourceInfo';
+import { ITick } from '../contracts/ITick';
+import { IEntityServer } from '../contracts/server/IEntityServer';
+import { IPedServer } from '../contracts/server/IPedServer';
+import { IPedAppearanceServer } from '../contracts/server/IPedAppearanceServer';
+import { IPlayerServer } from '../contracts/server/IPlayerServer';
+import { IVehicleServer } from '../contracts/server/IVehicleServer';
+import { EventsAPI } from '../contracts/transport/events.api';
+import { MessagingTransport } from '../contracts/transport/messaging.transport';
+import { RpcAPI } from '../contracts/transport/rpc.api';
+/**
+ * Node.js mock platform adapter for testing and standalone development.
+ */
+export const NodePlatform = {
+    name: 'node',
+    priority: 0, // Lowest priority - fallback platform
+    detect() {
+        // Node is the fallback platform when no other platform is detected
+        // It should only match if we're running in pure Node.js
+        return typeof process !== 'undefined' && process.versions?.node !== undefined;
+    },
+    async register(container) {
+        // Dynamically import Node.js mock implementations
+        const [{ NodeMessagingTransport }, { NodeEngineEvents }, { NodeExports }, { NodeResourceInfo }, { NodeTick }, { NodePlayerInfo }, { NodeEntityServer }, { NodePedServer }, { NodeVehicleServer }, { NodePlayerServer }, { NodeHasher }, { NodePedAppearanceServer }, { NodePlatformContext },] = await Promise.all([
+            import('./transport/adapter'),
+            import('./node-engine-events'),
+            import('./node-exports'),
+            import('./node-resourceinfo'),
+            import('./node-tick'),
+            import('./node-playerinfo'),
+            import('./node-entity-server'),
+            import('./node-ped-server'),
+            import('./node-vehicle-server'),
+            import('./node-player-server'),
+            import('./node-hasher'),
+            import('./node-ped-appearance-server'),
+            import('./node-capabilities'),
+        ]);
+        // Register all Node.js mock implementations
+        if (!container.isRegistered(IPlatformContext))
+            container.registerSingleton(IPlatformContext, NodePlatformContext);
+        if (!container.isRegistered(MessagingTransport)) {
+            const transport = new NodeMessagingTransport('server');
+            container.registerInstance(MessagingTransport, transport);
+            container.registerInstance(EventsAPI, transport.events);
+            container.registerInstance(RpcAPI, transport.rpc);
+        }
+        if (!container.isRegistered(IEngineEvents))
+            container.registerSingleton(IEngineEvents, NodeEngineEvents);
+        if (!container.isRegistered(IExports))
+            container.registerSingleton(IExports, NodeExports);
+        if (!container.isRegistered(IResourceInfo))
+            container.registerSingleton(IResourceInfo, NodeResourceInfo);
+        if (!container.isRegistered(ITick))
+            container.registerSingleton(ITick, NodeTick);
+        if (!container.isRegistered(IPlayerInfo))
+            container.registerSingleton(IPlayerInfo, NodePlayerInfo);
+        if (!container.isRegistered(IEntityServer))
+            container.registerSingleton(IEntityServer, NodeEntityServer);
+        if (!container.isRegistered(IPedServer))
+            container.registerSingleton(IPedServer, NodePedServer);
+        if (!container.isRegistered(IVehicleServer))
+            container.registerSingleton(IVehicleServer, NodeVehicleServer);
+        if (!container.isRegistered(IPlayerServer))
+            container.registerSingleton(IPlayerServer, NodePlayerServer);
+        if (!container.isRegistered(IHasher))
+            container.registerSingleton(IHasher, NodeHasher);
+        if (!container.isRegistered(IPedAppearanceServer))
+            container.registerSingleton(IPedAppearanceServer, NodePedAppearanceServer);
+    },
+};