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

package/dist/runtime/core/library/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Unique name used to identify a library.
+ */
+export type LibraryName = string;
+/**
+ * Namespace used to build external event names.
+ *
+ * @example
+ * `opencore:characters`
+ */
+export type LibraryNamespace = string;
+/**
+ * Internal or external event name segment.
+ *
+ * @example
+ * `created`
+ */
+export type LibraryEventName = string;
+/**
+ * Canonical library event identifier.
+ *
+ * @example
+ * `characters:session:created`
+ */
+export type LibraryEventId = string;
+/**
+ * Generic handler used by the internal library bus.
+ */
+export type LibraryEventHandler<TPayload = unknown> = (payload?: TPayload) => void;
+/**
+ * Metadata attached to runtime library event notifications.
+ */
+export interface LibraryEventMetadata {
+    libraryName: LibraryName;
+    eventName: LibraryEventName;
+    eventId: LibraryEventId;
+    namespace: LibraryNamespace;
+    side: 'server' | 'client';
+}
+/**
+ * Runtime notification envelope emitted by library wrappers.
+ */
+export interface LibraryEventEnvelope<TPayload = unknown> {
+    payload?: TPayload;
+    meta: LibraryEventMetadata;
+}
+/**
+ * Lightweight internal event bus for library-local communication.
+ *
+ * @remarks
+ * This bus is pure TypeScript and does not use FiveM or network events.
+ */
+export interface LibraryBus {
+    /**
+     * Subscribe to an internal event.
+     */
+    on<TPayload = unknown>(event: LibraryEventName, handler: LibraryEventHandler<TPayload>): void;
+    /**
+     * Subscribe to an internal event only once.
+     */
+    once<TPayload = unknown>(event: LibraryEventName, handler: LibraryEventHandler<TPayload>): void;
+    /**
+     * Remove an internal event handler.
+     */
+    off<TPayload = unknown>(event: LibraryEventName, handler: LibraryEventHandler<TPayload>): void;
+    /**
+     * Emit an internal event to handlers in this library.
+     */
+    emit<TPayload = unknown>(event: LibraryEventName, payload?: TPayload): void;
+}
+/**
+ * Shared base contract for OpenCore libraries.
+ *
+ * @remarks
+ * Includes only library-local event operations and event name composition.
+ * External bridge behavior is added by server/client wrappers.
+ */
+export interface OpenCoreLibraryBase extends LibraryBus {
+    /**
+     * Library identifier.
+     */
+    name: LibraryName;
+    /**
+     * Event namespace used by the external bridge.
+     */
+    namespace: LibraryNamespace;
+    /**
+     * Builds a namespaced external event name.
+     *
+     * @example
+     * `opencore:characters:created`
+     */
+    buildEventName(eventName: LibraryEventName): string;
+}
+/**
+ * Minimal config accessor used by library wrappers.
+ */
+export interface OpenCoreLibraryConfigAccessor<TConfig = Record<string, unknown>> {
+    /**
+     * Namespace of the library config segment.
+     */
+    namespace: LibraryNamespace;
+    /**
+     * Gets a value by key from the namespaced config source.
+     */
+    get<TKey extends keyof TConfig>(key: TKey): TConfig[TKey] | undefined;
+}
+/**
+ * Server library API.
+ *
+ * @remarks
+ * Adds a FiveM-based external bridge on top of the internal library bus.
+ */
+export interface OpenCoreServerLibrary extends OpenCoreLibraryBase {
+    side: 'server';
+    emitExternal<TPayload = unknown>(eventName: LibraryEventName, payload?: TPayload): void;
+    emitNetExternal<TPayload = unknown>(eventName: LibraryEventName, target: number, payload?: TPayload): void;
+    getLogger(): {
+        trace(message: string, context?: Record<string, unknown>): void;
+        debug(message: string, context?: Record<string, unknown>): void;
+        info(message: string, context?: Record<string, unknown>): void;
+        warn(message: string, context?: Record<string, unknown>): void;
+        error(message: string, context?: Record<string, unknown>, error?: Error): void;
+        fatal(message: string, context?: Record<string, unknown>, error?: Error): void;
+    };
+    getConfig<TConfig = Record<string, unknown>>(): OpenCoreLibraryConfigAccessor<TConfig>;
+}
+/**
+ * Client library API.
+ *
+ * @remarks
+ * Adds a client-to-server external bridge on top of the internal library bus.
+ */
+export interface OpenCoreClientLibrary extends OpenCoreLibraryBase {
+    side: 'client';
+    emitServer<TPayload = unknown>(eventName: LibraryEventName, payload?: TPayload): void;
+    getLogger(): {
+        trace(message: string, context?: Record<string, unknown>): void;
+        debug(message: string, context?: Record<string, unknown>): void;
+        info(message: string, context?: Record<string, unknown>): void;
+        warn(message: string, context?: Record<string, unknown>): void;
+        error(message: string, context?: Record<string, unknown>, error?: Error): void;
+        fatal(message: string, context?: Record<string, unknown>, error?: Error): void;
+    };
+    getConfig<TConfig = Record<string, unknown>>(): OpenCoreLibraryConfigAccessor<TConfig>;
+}

package/dist/runtime/core/nativehandle.d.ts

@@ -0,0 +1,3 @@
+export interface NativeHandle {
+    getHandle(): number;
+}

package/dist/runtime/core/spatial.d.ts

@@ -0,0 +1,7 @@
+import { Vector3 } from '../../kernel/utils/vector3';
+export interface Spatial {
+    getPosition(): Vector3;
+    setPosition(v: Vector3): void;
+    getHeading(): number;
+    setHeading(heading: number): void;
+}

package/dist/runtime/core/world.d.ts

@@ -0,0 +1,13 @@
+import { BaseEntity, EntityId } from './entity';
+export declare class WorldContext {
+    private entities;
+    private readonly kindIndex;
+    add(entity: BaseEntity): void;
+    remove(id: EntityId): void;
+    get<T extends BaseEntity = BaseEntity>(id: EntityId): T | undefined;
+    find<T extends BaseEntity>(predicate: (e: BaseEntity) => e is T): T[];
+    find(predicate: (e: BaseEntity) => boolean): BaseEntity[];
+    all(): BaseEntity[];
+    size(): number;
+    sizeBy(kind: string): number;
+}

package/dist/runtime/core/world.js

@@ -0,0 +1,57 @@
+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';
+function getKind(id) {
+    const i = id.indexOf(':');
+    return i === -1 ? id : id.slice(0, i);
+}
+let WorldContext = class WorldContext {
+    entities = new Map();
+    kindIndex = new Map();
+    add(entity) {
+        // If replacing, remove first to keep index consistent
+        const prev = this.entities.get(entity.id);
+        if (prev)
+            this.remove(entity.id);
+        this.entities.set(entity.id, entity);
+        const kind = getKind(entity.id);
+        this.kindIndex.set(kind, (this.kindIndex.get(kind) ?? 0) + 1);
+    }
+    remove(id) {
+        const entity = this.entities.get(id);
+        if (!entity)
+            return;
+        const kind = getKind(id);
+        const n = this.kindIndex.get(kind);
+        if (n !== undefined) {
+            if (n <= 1)
+                this.kindIndex.delete(kind);
+            else
+                this.kindIndex.set(kind, n - 1);
+        }
+        this.entities.delete(id);
+    }
+    get(id) {
+        return this.entities.get(id);
+    }
+    find(predicate) {
+        return [...this.entities.values()].filter(predicate);
+    }
+    all() {
+        return [...this.entities.values()];
+    }
+    size() {
+        return this.entities.size;
+    }
+    sizeBy(kind) {
+        return this.kindIndex.get(kind) ?? 0;
+    }
+};
+WorldContext = __decorate([
+    injectable()
+], WorldContext);
+export { WorldContext };

package/dist/runtime/server/.opencore/autoload.server.controllers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/server/adapter/index.d.ts

@@ -0,0 +1,5 @@
+export * from './node-server-adapter';
+export * from './player-adapter';
+export * from './registry';
+export * from './serialization';
+export * from './server-adapter';

package/dist/runtime/server/adapter/index.js

@@ -0,0 +1,5 @@
+export * from './node-server-adapter';
+export * from './player-adapter';
+export * from './registry';
+export * from './serialization';
+export * from './server-adapter';

package/dist/runtime/server/adapter/node-npc-lifecycle-server.d.ts

@@ -0,0 +1,12 @@
+import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
+import { INpcLifecycleServer } from '../../../adapters/contracts/server/npc-lifecycle/INpcLifecycleServer';
+import type { CreateNpcServerRequest, CreateNpcServerResult, DeleteNpcServerRequest } from '../../../adapters/contracts/server/npc-lifecycle/types';
+import { IPedServer } from '../../../adapters/contracts/server/IPedServer';
+export declare class NodeNpcLifecycleServer extends INpcLifecycleServer {
+    private readonly pedServer;
+    private readonly entityServer;
+    constructor(pedServer: IPedServer, entityServer: IEntityServer);
+    create(request: CreateNpcServerRequest): CreateNpcServerResult;
+    delete(request: DeleteNpcServerRequest): void;
+    private resolveNetId;
+}

package/dist/runtime/server/adapter/node-npc-lifecycle-server.js

@@ -0,0 +1,52 @@
+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 { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
+import { INpcLifecycleServer } from '../../../adapters/contracts/server/npc-lifecycle/INpcLifecycleServer';
+import { IPedServer } from '../../../adapters/contracts/server/IPedServer';
+let NodeNpcLifecycleServer = class NodeNpcLifecycleServer extends INpcLifecycleServer {
+    pedServer;
+    entityServer;
+    constructor(pedServer, entityServer) {
+        super();
+        this.pedServer = pedServer;
+        this.entityServer = entityServer;
+    }
+    create(request) {
+        const handle = this.pedServer.create(4, request.modelHash, request.position.x, request.position.y, request.position.z, request.heading, request.networked);
+        if (!handle || handle <= 0) {
+            throw new Error('Failed to create NPC ped entity');
+        }
+        return {
+            handle,
+            netId: request.networked ? this.resolveNetId(handle) : undefined,
+        };
+    }
+    delete(request) {
+        if (!this.entityServer.doesExist(request.handle))
+            return;
+        this.pedServer.delete(request.handle);
+    }
+    resolveNetId(handle) {
+        const netId = this.pedServer.getNetworkIdFromEntity(handle);
+        return netId > 0 ? netId : undefined;
+    }
+};
+NodeNpcLifecycleServer = __decorate([
+    injectable(),
+    __param(0, inject(IPedServer)),
+    __param(1, inject(IEntityServer)),
+    __metadata("design:paramtypes", [IPedServer,
+        IEntityServer])
+], NodeNpcLifecycleServer);
+export { NodeNpcLifecycleServer };

package/dist/runtime/server/adapter/node-player-appearance-lifecycle-server.d.ts

@@ -0,0 +1,22 @@
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { IPedAppearanceServer } from '../../../adapters/contracts/server/IPedAppearanceServer';
+import { IPlayerAppearanceLifecycleServer } from '../../../adapters/contracts/server/player-appearance/IPlayerAppearanceLifecycleServer';
+import { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+import { Players } from '../ports/players.api-port';
+import { PlayerAppearance } from '../../../kernel/shared';
+export declare class NodePlayerAppearanceLifecycleServer extends IPlayerAppearanceLifecycleServer {
+    private readonly pedAdapter;
+    private readonly playerServer;
+    private readonly events;
+    private readonly players;
+    constructor(pedAdapter: IPedAppearanceServer, playerServer: IPlayerServer, events: EventsAPI<'server'>, players: Players);
+    apply(playerSrc: string, appearance: PlayerAppearance): Promise<{
+        success: boolean;
+        appearance?: PlayerAppearance;
+        errors?: string[];
+    }>;
+    applyClothing(playerSrc: string, appearance: Pick<PlayerAppearance, 'components' | 'props'>): boolean;
+    reset(playerSrc: string): boolean;
+    private resolveTarget;
+    private applyServerSideAppearance;
+}

package/dist/runtime/server/adapter/node-player-appearance-lifecycle-server.js

@@ -0,0 +1,94 @@
+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 { IPedAppearanceServer } from '../../../adapters/contracts/server/IPedAppearanceServer';
+import { IPlayerAppearanceLifecycleServer } from '../../../adapters/contracts/server/player-appearance/IPlayerAppearanceLifecycleServer';
+import { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+import { Players } from '../ports/players.api-port';
+let NodePlayerAppearanceLifecycleServer = class NodePlayerAppearanceLifecycleServer extends IPlayerAppearanceLifecycleServer {
+    pedAdapter;
+    playerServer;
+    events;
+    players;
+    constructor(pedAdapter, playerServer, events, players) {
+        super();
+        this.pedAdapter = pedAdapter;
+        this.playerServer = playerServer;
+        this.events = events;
+        this.players = players;
+    }
+    async apply(playerSrc, appearance) {
+        const ped = this.playerServer.getPed(playerSrc);
+        if (ped === 0) {
+            return { success: false, errors: ['Player ped not found'] };
+        }
+        this.applyServerSideAppearance(ped, appearance);
+        const target = this.resolveTarget(playerSrc);
+        if (!target) {
+            return { success: false, errors: ['Player not found'] };
+        }
+        this.events.emit('opencore:appearance:apply', target, appearance);
+        return { success: true, appearance };
+    }
+    applyClothing(playerSrc, appearance) {
+        const ped = this.playerServer.getPed(playerSrc);
+        if (ped === 0)
+            return false;
+        this.applyServerSideAppearance(ped, appearance);
+        return true;
+    }
+    reset(playerSrc) {
+        const ped = this.playerServer.getPed(playerSrc);
+        if (ped === 0)
+            return false;
+        this.pedAdapter.setDefaultComponentVariation(ped);
+        const target = this.resolveTarget(playerSrc);
+        if (!target)
+            return false;
+        this.events.emit('opencore:appearance:reset', target);
+        return true;
+    }
+    resolveTarget(playerSrc) {
+        return this.players.getByClient(Number(playerSrc));
+    }
+    applyServerSideAppearance(ped, appearance) {
+        if (appearance.components) {
+            for (const [componentId, data] of Object.entries(appearance.components)) {
+                this.pedAdapter.setComponentVariation(ped, parseInt(componentId, 10), data.drawable, data.texture, 2);
+            }
+        }
+        if (appearance.props) {
+            for (const [propId, data] of Object.entries(appearance.props)) {
+                if (data.drawable === -1) {
+                    this.pedAdapter.clearProp(ped, parseInt(propId, 10));
+                }
+                else {
+                    this.pedAdapter.setPropIndex(ped, parseInt(propId, 10), data.drawable, data.texture, true);
+                }
+            }
+        }
+    }
+};
+NodePlayerAppearanceLifecycleServer = __decorate([
+    injectable(),
+    __param(0, inject(IPedAppearanceServer)),
+    __param(1, inject(IPlayerServer)),
+    __param(2, inject(EventsAPI)),
+    __param(3, inject(Players)),
+    __metadata("design:paramtypes", [IPedAppearanceServer,
+        IPlayerServer,
+        EventsAPI,
+        Players])
+], NodePlayerAppearanceLifecycleServer);
+export { NodePlayerAppearanceLifecycleServer };

package/dist/runtime/server/adapter/node-player-lifecycle-server.d.ts

@@ -0,0 +1,11 @@
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { IPlayerLifecycleServer } from '../../../adapters/contracts/server/player-lifecycle/IPlayerLifecycleServer';
+import type { RespawnPlayerRequest, SpawnPlayerRequest, TeleportPlayerRequest } from '../../../adapters/contracts/server/player-lifecycle/types';
+export declare class NodePlayerLifecycleServer extends IPlayerLifecycleServer {
+    private readonly events;
+    constructor(events: EventsAPI<'server'>);
+    spawn(playerSrc: string, request: SpawnPlayerRequest): void;
+    teleport(playerSrc: string, request: TeleportPlayerRequest): void;
+    respawn(playerSrc: string, request: RespawnPlayerRequest): void;
+    private resolveTarget;
+}

package/dist/runtime/server/adapter/node-player-lifecycle-server.js

@@ -0,0 +1,55 @@
+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 { IPlayerLifecycleServer } from '../../../adapters/contracts/server/player-lifecycle/IPlayerLifecycleServer';
+let NodePlayerLifecycleServer = class NodePlayerLifecycleServer extends IPlayerLifecycleServer {
+    events;
+    constructor(events) {
+        super();
+        this.events = events;
+    }
+    spawn(playerSrc, request) {
+        const target = this.resolveTarget(playerSrc);
+        if (!target)
+            return;
+        this.events.emit('opencore:spawner:spawn', target, {
+            position: request.position,
+            model: request.model,
+            heading: request.heading,
+            appearance: request.appearance,
+        });
+    }
+    teleport(playerSrc, request) {
+        const target = this.resolveTarget(playerSrc);
+        if (!target)
+            return;
+        this.events.emit('opencore:spawner:teleport', target, request.position, request.heading);
+    }
+    respawn(playerSrc, request) {
+        const target = this.resolveTarget(playerSrc);
+        if (!target)
+            return;
+        this.events.emit('opencore:spawner:respawn', target, request.position, request.heading);
+    }
+    resolveTarget(playerSrc) {
+        const clientId = Number(playerSrc);
+        return Number.isFinite(clientId) && clientId > 0 ? clientId : undefined;
+    }
+};
+NodePlayerLifecycleServer = __decorate([
+    injectable(),
+    __param(0, inject(EventsAPI)),
+    __metadata("design:paramtypes", [EventsAPI])
+], NodePlayerLifecycleServer);
+export { NodePlayerLifecycleServer };

package/dist/runtime/server/adapter/node-player-state-sync-server.d.ts

@@ -0,0 +1,12 @@
+import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
+import { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+import { IPlayerStateSyncServer } from '../../../adapters/contracts/server/player-state/IPlayerStateSyncServer';
+export declare class NodePlayerStateSyncServer extends IPlayerStateSyncServer {
+    private readonly playerServer;
+    private readonly entityServer;
+    constructor(playerServer: IPlayerServer, entityServer: IEntityServer);
+    getHealth(playerSrc: string): number;
+    setHealth(playerSrc: string, health: number): void;
+    getArmor(playerSrc: string): number;
+    setArmor(playerSrc: string, armor: number): void;
+}

package/dist/runtime/server/adapter/node-player-state-sync-server.js

@@ -0,0 +1,49 @@
+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 { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
+import { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+import { IPlayerStateSyncServer } from '../../../adapters/contracts/server/player-state/IPlayerStateSyncServer';
+let NodePlayerStateSyncServer = class NodePlayerStateSyncServer extends IPlayerStateSyncServer {
+    playerServer;
+    entityServer;
+    constructor(playerServer, entityServer) {
+        super();
+        this.playerServer = playerServer;
+        this.entityServer = entityServer;
+    }
+    getHealth(playerSrc) {
+        return this.entityServer.getHealth(this.playerServer.getPed(playerSrc));
+    }
+    setHealth(playerSrc, health) {
+        const ped = this.playerServer.getPed(playerSrc);
+        this.entityServer.setHealth(ped, health);
+        this.entityServer.getStateBag(ped).set('health', health, true);
+    }
+    getArmor(playerSrc) {
+        return this.entityServer.getArmor(this.playerServer.getPed(playerSrc));
+    }
+    setArmor(playerSrc, armor) {
+        const ped = this.playerServer.getPed(playerSrc);
+        this.entityServer.setArmor(ped, armor);
+        this.entityServer.getStateBag(ped).set('armor', armor, true);
+    }
+};
+NodePlayerStateSyncServer = __decorate([
+    injectable(),
+    __param(0, inject(IPlayerServer)),
+    __param(1, inject(IEntityServer)),
+    __metadata("design:paramtypes", [IPlayerServer,
+        IEntityServer])
+], NodePlayerStateSyncServer);
+export { NodePlayerStateSyncServer };

package/dist/runtime/server/adapter/node-server-adapter.d.ts

@@ -0,0 +1,5 @@
+import { type OpenCoreServerAdapter } from './server-adapter';
+/**
+ * Default server adapter used when no runtime adapter is provided.
+ */
+export declare function createNodeServerAdapter(): OpenCoreServerAdapter;

package/dist/runtime/server/adapter/node-server-adapter.js

@@ -0,0 +1,67 @@
+import { IEngineEvents } from '../../../adapters/contracts/IEngineEvents';
+import { IExports } from '../../../adapters/contracts/IExports';
+import { IHasher } from '../../../adapters/contracts/IHasher';
+import { IPlatformContext } from '../../../adapters/contracts/IPlatformContext';
+import { IPlayerInfo } from '../../../adapters/contracts/IPlayerInfo';
+import { IResourceInfo } from '../../../adapters/contracts/IResourceInfo';
+import { ITick } from '../../../adapters/contracts/ITick';
+import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
+import { INpcLifecycleServer } from '../../../adapters/contracts/server/npc-lifecycle/INpcLifecycleServer';
+import { IPedAppearanceServer } from '../../../adapters/contracts/server/IPedAppearanceServer';
+import { IPedServer } from '../../../adapters/contracts/server/IPedServer';
+import { IPlayerAppearanceLifecycleServer } from '../../../adapters/contracts/server/player-appearance/IPlayerAppearanceLifecycleServer';
+import { IPlayerLifecycleServer } from '../../../adapters/contracts/server/player-lifecycle/IPlayerLifecycleServer';
+import { IPlayerStateSyncServer } from '../../../adapters/contracts/server/player-state/IPlayerStateSyncServer';
+import { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+import { IVehicleLifecycleServer } from '../../../adapters/contracts/server/vehicle-lifecycle/IVehicleLifecycleServer';
+import { IVehicleServer } from '../../../adapters/contracts/server/IVehicleServer';
+import { defineServerAdapter } from './server-adapter';
+/**
+ * Default server adapter used when no runtime adapter is provided.
+ */
+export function createNodeServerAdapter() {
+    return defineServerAdapter({
+        name: 'node',
+        async register(ctx) {
+            const [{ NodeMessagingTransport }, { NodeEngineEvents }, { NodeExports }, { NodeResourceInfo }, { NodeTick }, { NodePlayerInfo }, { NodeEntityServer }, { NodePedServer }, { NodeVehicleServer }, { NodePlayerServer }, { NodeHasher }, { NodePedAppearanceServer }, { NodePlatformContext }, { NodePlayerLifecycleServer }, { NodeVehicleLifecycleServer }, { NodeNpcLifecycleServer }, { NodePlayerAppearanceLifecycleServer }, { NodePlayerStateSyncServer },] = await Promise.all([
+                import('../../../adapters/node/transport/adapter'),
+                import('../../../adapters/node/node-engine-events'),
+                import('../../../adapters/node/node-exports'),
+                import('../../../adapters/node/node-resourceinfo'),
+                import('../../../adapters/node/node-tick'),
+                import('../../../adapters/node/node-playerinfo'),
+                import('../../../adapters/node/node-entity-server'),
+                import('../../../adapters/node/node-ped-server'),
+                import('../../../adapters/node/node-vehicle-server'),
+                import('../../../adapters/node/node-player-server'),
+                import('../../../adapters/node/node-hasher'),
+                import('../../../adapters/node/node-ped-appearance-server'),
+                import('../../../adapters/node/node-capabilities'),
+                import('./node-player-lifecycle-server'),
+                import('./node-vehicle-lifecycle-server'),
+                import('./node-npc-lifecycle-server'),
+                import('./node-player-appearance-lifecycle-server'),
+                import('./node-player-state-sync-server'),
+            ]);
+            ctx.bindSingleton(IPlatformContext, NodePlatformContext);
+            const transport = new NodeMessagingTransport('server');
+            ctx.bindMessagingTransport(transport);
+            ctx.bindSingleton(IEngineEvents, NodeEngineEvents);
+            ctx.bindSingleton(IExports, NodeExports);
+            ctx.bindSingleton(IResourceInfo, NodeResourceInfo);
+            ctx.bindSingleton(ITick, NodeTick);
+            ctx.bindSingleton(IPlayerInfo, NodePlayerInfo);
+            ctx.bindSingleton(IEntityServer, NodeEntityServer);
+            ctx.bindSingleton(INpcLifecycleServer, NodeNpcLifecycleServer);
+            ctx.bindSingleton(IPedServer, NodePedServer);
+            ctx.bindSingleton(IVehicleServer, NodeVehicleServer);
+            ctx.bindSingleton(IVehicleLifecycleServer, NodeVehicleLifecycleServer);
+            ctx.bindSingleton(IPlayerServer, NodePlayerServer);
+            ctx.bindSingleton(IPlayerAppearanceLifecycleServer, NodePlayerAppearanceLifecycleServer);
+            ctx.bindSingleton(IPlayerStateSyncServer, NodePlayerStateSyncServer);
+            ctx.bindSingleton(IPlayerLifecycleServer, NodePlayerLifecycleServer);
+            ctx.bindSingleton(IHasher, NodeHasher);
+            ctx.bindSingleton(IPedAppearanceServer, NodePedAppearanceServer);
+        },
+    });
+}