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

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);
+        },
+    });
+}

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

@@ -0,0 +1,13 @@
+import { IVehicleLifecycleServer } from '../../../adapters/contracts/server/vehicle-lifecycle/IVehicleLifecycleServer';
+import type { CreateVehicleServerRequest, CreateVehicleServerResult, WarpPlayerIntoVehicleRequest } from '../../../adapters/contracts/server/vehicle-lifecycle/types';
+import { IPlatformContext } from '../../../adapters/contracts/IPlatformContext';
+import { IVehicleServer } from '../../../adapters/contracts/server/IVehicleServer';
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+export declare class NodeVehicleLifecycleServer extends IVehicleLifecycleServer {
+    private readonly vehicleServer;
+    private readonly platformContext;
+    private readonly events;
+    constructor(vehicleServer: IVehicleServer, platformContext: IPlatformContext, events: EventsAPI<'server'>);
+    create(request: CreateVehicleServerRequest): CreateVehicleServerResult;
+    warpPlayerIntoVehicle(request: WarpPlayerIntoVehicleRequest): void;
+}

package/dist/runtime/server/adapter/node-vehicle-lifecycle-server.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;
+};
+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 { IVehicleLifecycleServer } from '../../../adapters/contracts/server/vehicle-lifecycle/IVehicleLifecycleServer';
+import { IPlatformContext } from '../../../adapters/contracts/IPlatformContext';
+import { IVehicleServer } from '../../../adapters/contracts/server/IVehicleServer';
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+let NodeVehicleLifecycleServer = class NodeVehicleLifecycleServer extends IVehicleLifecycleServer {
+    vehicleServer;
+    platformContext;
+    events;
+    constructor(vehicleServer, platformContext, events) {
+        super();
+        this.vehicleServer = vehicleServer;
+        this.platformContext = platformContext;
+        this.events = events;
+    }
+    create(request) {
+        if (!this.platformContext.enableServerVehicleCreation) {
+            throw new Error(`Server vehicle creation is disabled for profile '${this.platformContext.gameProfile}'`);
+        }
+        const handle = this.vehicleServer.createServerSetter(request.modelHash, this.platformContext.defaultVehicleType, request.position.x, request.position.y, request.position.z, request.heading);
+        if (!handle || handle === 0) {
+            throw new Error('Failed to create vehicle entity');
+        }
+        return {
+            handle,
+            networkId: this.vehicleServer.getNetworkIdFromEntity(handle),
+        };
+    }
+    warpPlayerIntoVehicle(request) {
+        const clientId = Number(request.playerSrc);
+        if (Number.isNaN(clientId))
+            return;
+        this.events.emit('opencore:vehicle:warpInto', clientId, request.networkId, request.seatIndex);
+    }
+};
+NodeVehicleLifecycleServer = __decorate([
+    injectable(),
+    __param(0, inject(IVehicleServer)),
+    __param(1, inject(IPlatformContext)),
+    __param(2, inject(EventsAPI)),
+    __metadata("design:paramtypes", [IVehicleServer,
+        IPlatformContext,
+        EventsAPI])
+], NodeVehicleLifecycleServer);
+export { NodeVehicleLifecycleServer };

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

@@ -0,0 +1,28 @@
+import { PlayerAdapters, Player } from '../entities/player';
+import { PlayerSession } from '../types/player-session.types';
+import { SerializedPlayerData } from '../types/core-exports.types';
+/**
+ * Dependencies required to build server-side player instances.
+ */
+export type PlayerFactoryDeps = PlayerAdapters;
+/**
+ * Adapter hook for creating and hydrating Player instances.
+ */
+export interface ServerPlayerAdapter {
+    createLocal(session: PlayerSession, deps: PlayerFactoryDeps): Player;
+    createRemote(data: SerializedPlayerData, deps: PlayerFactoryDeps): Player;
+    serialize?(player: Player): Record<string, unknown> | undefined;
+    hydrate?(player: Player, payload: Record<string, unknown> | undefined): void;
+}
+/**
+ * Restores base state shared by all Player instances.
+ */
+export declare function hydrateBasePlayerState(player: Player, data: SerializedPlayerData): Player;
+/**
+ * Creates the framework default local Player instance.
+ */
+export declare function createDefaultLocalPlayer(session: PlayerSession, deps: PlayerFactoryDeps): Player;
+/**
+ * Creates the framework default remote Player instance.
+ */
+export declare function createDefaultRemotePlayer(data: SerializedPlayerData, deps: PlayerFactoryDeps): Player;

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

@@ -0,0 +1,28 @@
+import { Player } from '../entities/player';
+/**
+ * Restores base state shared by all Player instances.
+ */
+export function hydrateBasePlayerState(player, data) {
+    for (const state of data.states) {
+        player.addState(state);
+    }
+    return player;
+}
+/**
+ * Creates the framework default local Player instance.
+ */
+export function createDefaultLocalPlayer(session, deps) {
+    return new Player(session, deps);
+}
+/**
+ * Creates the framework default remote Player instance.
+ */
+export function createDefaultRemotePlayer(data, deps) {
+    const player = new Player({
+        clientID: data.clientID,
+        accountID: data.accountID,
+        identifiers: data.identifiers,
+        meta: data.meta,
+    }, deps);
+    return hydrateBasePlayerState(player, data);
+}

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

@@ -0,0 +1,26 @@
+import { Player } from '../entities/player';
+import { SerializedPlayerData } from '../types/core-exports.types';
+import { PlayerSession } from '../types/player-session.types';
+import { type PlayerFactoryDeps } from './player-adapter';
+import { type OpenCoreServerAdapter } from './server-adapter';
+/**
+ * Installs the active server adapter for the current bootstrap.
+ */
+export declare function installServerAdapter(adapter: OpenCoreServerAdapter): Promise<void>;
+/**
+ * Returns the currently active server adapter name.
+ */
+export declare function getActiveServerAdapterName(): string | undefined;
+/**
+ * Builds a local Player through the active adapter.
+ */
+export declare function createLocalServerPlayer(session: PlayerSession, deps: PlayerFactoryDeps): Player;
+/**
+ * Builds a remote Player through the active adapter.
+ */
+export declare function createRemoteServerPlayer(data: SerializedPlayerData, deps: PlayerFactoryDeps): Player;
+/**
+ * Serializes adapter-specific player payload.
+ */
+export declare function serializeServerPlayerAdapterPayload(player: Player): SerializedPlayerData['adapter'] | undefined;
+export declare function __resetServerAdapterRegistryForTests(): void;

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

@@ -0,0 +1,101 @@
+import { GLOBAL_CONTAINER } from '../../../kernel/di/container';
+import { createDefaultLocalPlayer, createDefaultRemotePlayer, } from './player-adapter';
+import { bindTransportInstances, } from './server-adapter';
+const DEFAULT_PLAYER_ADAPTER = {
+    createLocal: createDefaultLocalPlayer,
+    createRemote: createDefaultRemotePlayer,
+};
+let activeServerAdapter = null;
+function assertTokenAvailable(container, token, adapterName) {
+    if (container.isRegistered(token)) {
+        throw new Error(`[OpenCore] Adapter '${adapterName}' cannot bind an already registered token.`);
+    }
+}
+function createAdapterContext(adapterName) {
+    let playerAdapterConfigured = false;
+    return {
+        adapterName,
+        container: GLOBAL_CONTAINER,
+        isRegistered(token) {
+            return GLOBAL_CONTAINER.isRegistered(token);
+        },
+        bindSingleton(token, implementation) {
+            assertTokenAvailable(GLOBAL_CONTAINER, token, adapterName);
+            GLOBAL_CONTAINER.registerSingleton(token, implementation);
+        },
+        bindInstance(token, value) {
+            assertTokenAvailable(GLOBAL_CONTAINER, token, adapterName);
+            GLOBAL_CONTAINER.registerInstance(token, value);
+        },
+        bindFactory(token, factory) {
+            assertTokenAvailable(GLOBAL_CONTAINER, token, adapterName);
+            GLOBAL_CONTAINER.register(token, { useFactory: factory });
+        },
+        bindMessagingTransport(transport) {
+            bindTransportInstances(this, transport);
+        },
+        usePlayerAdapter(adapter) {
+            if (playerAdapterConfigured) {
+                throw new Error(`[OpenCore] Adapter '${adapterName}' already configured a Player adapter.`);
+            }
+            activeServerAdapter = {
+                name: adapterName,
+                playerAdapter: adapter,
+            };
+            playerAdapterConfigured = true;
+        },
+    };
+}
+/**
+ * Installs the active server adapter for the current bootstrap.
+ */
+export async function installServerAdapter(adapter) {
+    activeServerAdapter = {
+        name: adapter.name,
+        playerAdapter: DEFAULT_PLAYER_ADAPTER,
+    };
+    const context = createAdapterContext(adapter.name);
+    await adapter.register(context);
+}
+/**
+ * Returns the currently active server adapter name.
+ */
+export function getActiveServerAdapterName() {
+    return activeServerAdapter?.name;
+}
+/**
+ * Builds a local Player through the active adapter.
+ */
+export function createLocalServerPlayer(session, deps) {
+    return (activeServerAdapter?.playerAdapter ?? DEFAULT_PLAYER_ADAPTER).createLocal(session, deps);
+}
+/**
+ * Builds a remote Player through the active adapter.
+ */
+export function createRemoteServerPlayer(data, deps) {
+    if (data.adapter?.name &&
+        activeServerAdapter?.name &&
+        data.adapter.name !== activeServerAdapter.name) {
+        throw new Error(`[OpenCore] Cannot hydrate Player for adapter '${data.adapter.name}' with active adapter '${activeServerAdapter.name}'.`);
+    }
+    const playerAdapter = activeServerAdapter?.playerAdapter ?? DEFAULT_PLAYER_ADAPTER;
+    const player = playerAdapter.createRemote(data, deps);
+    playerAdapter.hydrate?.(player, data.adapter?.payload);
+    return player;
+}
+/**
+ * Serializes adapter-specific player payload.
+ */
+export function serializeServerPlayerAdapterPayload(player) {
+    const payload = activeServerAdapter?.playerAdapter.serialize?.(player);
+    if (!activeServerAdapter || payload === undefined) {
+        return undefined;
+    }
+    return {
+        name: activeServerAdapter.name,
+        payload,
+    };
+}
+export function __resetServerAdapterRegistryForTests() {
+    activeServerAdapter = null;
+}

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

@@ -0,0 +1,6 @@
+import type { Player } from '../entities/player';
+import type { SerializedPlayerData } from '../types/core-exports.types';
+/**
+ * Serializes a Player using the active server adapter payload hooks.
+ */
+export declare function serializeServerPlayerData(player: Player): SerializedPlayerData;

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

@@ -0,0 +1,9 @@
+import { serializeServerPlayerAdapterPayload } from './registry';
+/**
+ * Serializes a Player using the active server adapter payload hooks.
+ */
+export function serializeServerPlayerData(player) {
+    const base = player.serialize();
+    const adapter = serializeServerPlayerAdapterPayload(player);
+    return adapter ? { ...base, adapter } : base;
+}

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

@@ -0,0 +1,28 @@
+import type { DependencyContainer, InjectionToken } from 'tsyringe';
+import { MessagingTransport } from '../../../adapters/contracts/transport/messaging.transport';
+import { ServerPlayerAdapter } from './player-adapter';
+/**
+ * Public contract implemented by external server adapters.
+ */
+export interface OpenCoreServerAdapter {
+    readonly name: string;
+    register(context: ServerAdapterContext): void | Promise<void>;
+}
+/**
+ * Registration helpers exposed to server adapters.
+ */
+export interface ServerAdapterContext {
+    readonly adapterName: string;
+    readonly container: DependencyContainer;
+    isRegistered<T>(token: InjectionToken<T>): boolean;
+    bindSingleton<T>(token: InjectionToken<T>, implementation: InjectionToken<T>): void;
+    bindInstance<T>(token: InjectionToken<T>, value: T): void;
+    bindFactory<T>(token: InjectionToken<T>, factory: () => T): void;
+    bindMessagingTransport(transport: MessagingTransport): void;
+    usePlayerAdapter(adapter: ServerPlayerAdapter): void;
+}
+/**
+ * Helper for strongly typed adapter declarations.
+ */
+export declare function defineServerAdapter(adapter: OpenCoreServerAdapter): OpenCoreServerAdapter;
+export declare function bindTransportInstances(context: Pick<ServerAdapterContext, 'bindInstance'>, transport: MessagingTransport): void;

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

@@ -0,0 +1,14 @@
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { MessagingTransport } from '../../../adapters/contracts/transport/messaging.transport';
+import { RpcAPI } from '../../../adapters/contracts/transport/rpc.api';
+/**
+ * Helper for strongly typed adapter declarations.
+ */
+export function defineServerAdapter(adapter) {
+    return adapter;
+}
+export function bindTransportInstances(context, transport) {
+    context.bindInstance(MessagingTransport, transport);
+    context.bindInstance(EventsAPI, transport.events);
+    context.bindInstance(RpcAPI, transport.rpc);
+}

package/dist/runtime/server/api.d.ts

@@ -1,8 +1,9 @@
 export { onFrameworkEvent } from './bus/internal-event.bus';
-export { init } from './core';
+export { init, useAdapter } from './core';
 export * from './apis';
 export * from './decorators';
 export * from './library';
+export * from './adapter';
 export * from './contracts';
 export * from './ports/players.api-port';
 export * from './ports/authorization.api-port';

package/dist/runtime/server/api.js

@@ -1,10 +1,11 @@
 // Framework functions
 export { onFrameworkEvent } from './bus/internal-event.bus';
-export { init } from './core';
+export { init, useAdapter } from './core';
 // API
 export * from './apis';
 export * from './decorators';
 export * from './library';
+export * from './adapter';
 export * from './contracts';
 export * from './ports/players.api-port';
 export * from './ports/authorization.api-port';

package/dist/runtime/server/apis/appearance.api.d.ts

@@ -1,11 +1,13 @@
 import { AppearanceService } from '../services';
+import { IPlayerAppearanceLifecycleServer } from '../../../adapters/contracts/server/player-appearance/IPlayerAppearanceLifecycleServer';
 import { AppearanceValidationResult, PlayerAppearance } from '../../..';
 import { Player } from '../entities/player';
 type PlayerRef = Player | number | string;
 type Clothes = Pick<PlayerAppearance, 'components' | 'props'>;
 export declare class Appearance {
     private readonly appearance;
-    constructor(appearance: AppearanceService);
+    private readonly lifecycle;
+    constructor(appearance: AppearanceService, lifecycle: IPlayerAppearanceLifecycleServer);
     /**
      * Apply full appearance to a player.
      *
@@ -25,11 +27,11 @@ export declare class Appearance {
      *
      * Useful for quick outfit swaps without touching face / tattoos.
      */
-    applyClothing(player: PlayerRef, appearance: Clothes): boolean;
+    applyClothing(player: PlayerRef, appearance: Clothes): Promise<boolean>;
     /**
      * Reset player appearance to default.
      */
-    reset(player: PlayerRef): boolean;
+    reset(player: PlayerRef): Promise<boolean>;
     /**
      * Validate appearance data without applying it.
      *

package/dist/runtime/server/apis/appearance.api.js

@@ -7,12 +7,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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 { injectable } from 'tsyringe';
+import { inject } from 'tsyringe';
 import { AppearanceService } from '../services';
+import { IPlayerAppearanceLifecycleServer } from '../../../adapters/contracts/server/player-appearance/IPlayerAppearanceLifecycleServer';
 let Appearance = class Appearance {
     appearance;
-    constructor(appearance) {
+    lifecycle;
+    constructor(appearance, lifecycle) {
         this.appearance = appearance;
+        this.lifecycle = lifecycle;
     }
     /**
      * Apply full appearance to a player.
@@ -24,24 +31,28 @@ let Appearance = class Appearance {
      * - Returns validated appearance for persistence
      */
     async apply(player, appearance) {
+        const validation = this.appearance.validateAppearance(appearance);
+        if (!validation.valid) {
+            return { success: false, errors: validation.errors };
+        }
         const src = this.resolveSource(player);
-        return this.appearance.applyAppearance(src, appearance);
+        return this.lifecycle.apply(src, appearance);
     }
     /**
      * Apply only clothing (components + props).
      *
      * Useful for quick outfit swaps without touching face / tattoos.
      */
-    applyClothing(player, appearance) {
+    async applyClothing(player, appearance) {
         const src = this.resolveSource(player);
-        return this.appearance.applyClothing(src, appearance);
+        return await Promise.resolve(this.lifecycle.applyClothing(src, appearance));
     }
     /**
      * Reset player appearance to default.
      */
-    reset(player) {
+    async reset(player) {
         const src = this.resolveSource(player);
-        return this.appearance.resetAppearance(src);
+        return await Promise.resolve(this.lifecycle.reset(src));
     }
     /**
      * Validate appearance data without applying it.
@@ -61,6 +72,8 @@ let Appearance = class Appearance {
 };
 Appearance = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [AppearanceService])
+    __param(1, inject(IPlayerAppearanceLifecycleServer)),
+    __metadata("design:paramtypes", [AppearanceService,
+        IPlayerAppearanceLifecycleServer])
 ], Appearance);
 export { Appearance };