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

package/dist/runtime/client/ui-bridge.js

@@ -1,196 +1,4 @@
-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 { coreLogger, LogDomain } from '../../kernel/logger';
-const nuiLogger = coreLogger.child('NUI', LogDomain.CLIENT);
 /**
- * Type-safe NUI (Native UI) Bridge for client-server communication.
- *
- * Generic types allow for full type safety when sending/receiving messages.
- * Define your event maps and pass them as type parameters.
- *
- * @example
- * ```typescript
- * interface ClientToUI {
- *   'showMenu': { items: string[] }
- *   'hideMenu': void
- * }
- *
- * interface UIToClient {
- *   'menuItemSelected': { index: number }
- *   'menuClosed': void
- * }
- *
- * const nui = new NuiBridge<ClientToUI, UIToClient>()
- * nui.send('showMenu', { items: ['Option 1', 'Option 2'] })
- * nui.on('menuItemSelected', async (data) => console.log(data.index))
- * ```
+ * @deprecated Import from `./webview-bridge` instead.
  */
-let NuiBridge = class NuiBridge {
-    _isVisible = false;
-    _hasFocus = false;
-    _hasCursor = false;
-    /**
-     * Whether the NUI frame is currently visible
-     */
-    get isVisible() {
-        return this._isVisible;
-    }
-    /**
-     * Whether the NUI has input focus
-     */
-    get hasFocus() {
-        return this._hasFocus;
-    }
-    /**
-     * Whether the cursor is visible
-     */
-    get hasCursor() {
-        return this._hasCursor;
-    }
-    /**
-     * Send a message to the NUI (UI frame).
-     *
-     * @param action - The action/event name
-     * @param data - The data payload
-     */
-    send(action, data) {
-        SendNuiMessage(JSON.stringify({ action, data }));
-        nuiLogger.debug(`Sent message: ${action}`);
-    }
-    /**
-     * Send a raw message to the NUI without type checking.
-     *
-     * @param action - The action/event name
-     * @param data - The data payload
-     */
-    sendRaw(action, data) {
-        SendNuiMessage(JSON.stringify({ action, data }));
-        nuiLogger.debug(`Sent raw message: ${action}`);
-    }
-    /**
-     * Register a callback for NUI events from the UI.
-     *
-     * @param action - The action/event name to listen for
-     * @param handler - The callback handler
-     * @returns Cleanup function to unregister the callback
-     */
-    on(action, handler) {
-        RegisterNuiCallbackType(action);
-        on(`__cfx_nui:${action}`, async (data, cb) => {
-            try {
-                await handler(data);
-                cb({ ok: true });
-            }
-            catch (error) {
-                nuiLogger.error(`NUI callback error`, { action }, error);
-                cb({ ok: false, error: String(error) });
-            }
-        });
-        nuiLogger.debug(`Registered callback: ${action}`);
-    }
-    /**
-     * Register a callback that expects a return value.
-     *
-     * @param action - The action/event name to listen for
-     * @param handler - The callback handler that returns data
-     */
-    onWithResponse(action, handler) {
-        RegisterNuiCallbackType(action);
-        on(`__cfx_nui:${action}`, async (data, cb) => {
-            try {
-                const result = await handler(data);
-                cb({ ok: true, data: result });
-            }
-            catch (error) {
-                nuiLogger.error(`NUI callback error`, { action }, error);
-                cb({ ok: false, error: String(error) });
-            }
-        });
-        nuiLogger.debug(`Registered callback with response: ${action}`);
-    }
-    /**
-     * Set NUI focus state.
-     *
-     * @param hasFocus - Whether the NUI should have input focus
-     * @param hasCursor - Whether to show the cursor (defaults to hasFocus value)
-     */
-    focus(hasFocus, hasCursor) {
-        this._hasFocus = hasFocus;
-        this._hasCursor = hasCursor ?? hasFocus;
-        SetNuiFocus(this._hasFocus, this._hasCursor);
-        nuiLogger.debug(`Focus set: focus=${this._hasFocus}, cursor=${this._hasCursor}`);
-    }
-    /**
-     * Remove NUI focus (convenience method).
-     */
-    blur() {
-        this.focus(false, false);
-    }
-    /**
-     * Set NUI visibility state.
-     * Note: This only tracks state, you need to handle actual visibility in your UI.
-     *
-     * @param visible - Whether the NUI should be visible
-     */
-    setVisible(visible) {
-        this._isVisible = visible;
-        this.send('setVisible', { visible });
-        nuiLogger.debug(`Visibility set: ${visible}`);
-    }
-    /**
-     * Show the NUI and optionally set focus.
-     *
-     * @param withFocus - Whether to also set focus
-     * @param withCursor - Whether to show cursor (defaults to withFocus)
-     */
-    show(withFocus = true, withCursor) {
-        this.setVisible(true);
-        if (withFocus) {
-            this.focus(true, withCursor);
-        }
-    }
-    /**
-     * Hide the NUI and remove focus.
-     */
-    hide() {
-        this.setVisible(false);
-        this.blur();
-    }
-    /**
-     * Toggle NUI visibility.
-     *
-     * @param withFocus - Whether to set focus when showing
-     */
-    toggle(withFocus = true) {
-        if (this._isVisible) {
-            this.hide();
-        }
-        else {
-            this.show(withFocus);
-        }
-    }
-    /**
-     * Keep input focus but allow game input.
-     * Useful for HUDs that need to capture some keys but not all.
-     *
-     * @param keepInput - Whether to keep game input enabled
-     */
-    setKeepInput(keepInput) {
-        SetNuiFocusKeepInput(keepInput);
-        nuiLogger.debug(`Keep input set: ${keepInput}`);
-    }
-};
-NuiBridge = __decorate([
-    injectable()
-], NuiBridge);
-export { NuiBridge };
-/**
- * Default untyped NUI instance for quick usage.
- * For type-safe usage, create your own instance with proper generics.
- */
-export const NUI = new NuiBridge();
+export { NUI, NuiBridge, WebView, WebViewBridge } from './webview-bridge';

package/dist/runtime/client/webview-bridge.d.ts

@@ -0,0 +1,31 @@
+import { WebViewService } from './webview.service';
+export declare class WebViewBridge<TSend extends Record<string, any> = Record<string, any>, TReceive extends Record<string, any> = Record<string, any>> {
+    private readonly serviceResolver;
+    private readonly viewId;
+    constructor(serviceResolver: WebViewService | (() => WebViewService), viewId?: string);
+    private get service();
+    create(url: string, options?: {
+        visible?: boolean;
+        focused?: boolean;
+        cursor?: boolean;
+        inputPassthrough?: boolean;
+    }): void;
+    destroy(): void;
+    exists(): boolean;
+    send<K extends keyof TSend & string>(action: K, data: TSend[K]): void;
+    sendRaw(action: string, data: unknown): void;
+    on<K extends keyof TReceive & string>(action: K, handler: (data: TReceive[K]) => void | Promise<void>): () => void;
+    onWithResponse<K extends keyof TReceive & string, R = unknown>(action: K, handler: (data: TReceive[K]) => R | Promise<R>): () => void;
+    focus(hasFocus: boolean, hasCursor?: boolean): void;
+    blur(): void;
+    setVisible(visible: boolean): void;
+    show(withFocus?: boolean, withCursor?: boolean): void;
+    hide(): void;
+    toggle(withFocus?: boolean): void;
+    setInputPassthrough(enabled: boolean): void;
+    setKeepInput(keepInput: boolean): void;
+}
+export declare class NuiBridge<TSend extends Record<string, any> = Record<string, any>, TReceive extends Record<string, any> = Record<string, any>> extends WebViewBridge<TSend, TReceive> {
+}
+export declare const WebView: WebViewBridge<Record<string, any>, Record<string, any>>;
+export declare const NUI: WebViewBridge<Record<string, any>, Record<string, any>>;

package/dist/runtime/client/webview-bridge.js

@@ -0,0 +1,97 @@
+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);
+};
+import { injectable } from 'tsyringe';
+import { WebViewService } from './webview.service';
+import { di } from './client-container';
+let WebViewBridge = class WebViewBridge {
+    serviceResolver;
+    viewId;
+    constructor(serviceResolver, viewId = 'default') {
+        this.serviceResolver = serviceResolver;
+        this.viewId = viewId;
+    }
+    get service() {
+        return typeof this.serviceResolver === 'function'
+            ? this.serviceResolver()
+            : this.serviceResolver;
+    }
+    create(url, options = {}) {
+        this.service.create({ id: this.viewId, url, ...options });
+    }
+    destroy() {
+        this.service.destroy(this.viewId);
+    }
+    exists() {
+        return this.service.exists(this.viewId);
+    }
+    send(action, data) {
+        this.service.send(this.viewId, action, data);
+    }
+    sendRaw(action, data) {
+        this.service.send(this.viewId, action, data);
+    }
+    on(action, handler) {
+        return this.service.onMessage(async (message) => {
+            if (message.viewId !== this.viewId || message.event !== action)
+                return;
+            await handler(message.payload);
+        });
+    }
+    onWithResponse(action, handler) {
+        return this.on(action, handler);
+    }
+    focus(hasFocus, hasCursor) {
+        if (hasFocus) {
+            const options = { cursor: hasCursor ?? true };
+            this.service.focus(this.viewId, options);
+            return;
+        }
+        this.service.blur(this.viewId);
+    }
+    blur() {
+        this.service.blur(this.viewId);
+    }
+    setVisible(visible) {
+        visible ? this.service.show(this.viewId) : this.service.hide(this.viewId);
+    }
+    show(withFocus = true, withCursor) {
+        this.service.show(this.viewId);
+        if (withFocus)
+            this.focus(true, withCursor);
+    }
+    hide() {
+        this.service.hide(this.viewId);
+        this.blur();
+    }
+    toggle(withFocus = true) {
+        if (this.exists())
+            this.hide();
+        else
+            this.show(withFocus);
+    }
+    setInputPassthrough(enabled) {
+        this.service.focus(this.viewId, { inputPassthrough: enabled, cursor: true });
+    }
+    setKeepInput(keepInput) {
+        this.setInputPassthrough(keepInput);
+    }
+};
+WebViewBridge = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Object, Object])
+], WebViewBridge);
+export { WebViewBridge };
+export class NuiBridge extends WebViewBridge {
+}
+function resolveWebViewService() {
+    return di.resolve(WebViewService);
+}
+export const WebView = new WebViewBridge(resolveWebViewService);
+export const NUI = WebView;

package/dist/runtime/client/webview.service.d.ts

@@ -0,0 +1,14 @@
+import type { WebViewCapabilities, WebViewDefinition, WebViewFocusOptions, WebViewMessage } from '../../adapters/contracts/client/ui/webview/types';
+export declare class WebViewService {
+    private get bridge();
+    getCapabilities(): WebViewCapabilities;
+    create(definition: WebViewDefinition): void;
+    destroy(viewId: string): void;
+    exists(viewId: string): boolean;
+    show(viewId: string): void;
+    hide(viewId: string): void;
+    focus(viewId: string, options?: WebViewFocusOptions): void;
+    blur(viewId: string): void;
+    send(viewId: string, event: string, payload: unknown): void;
+    onMessage(handler: (message: WebViewMessage) => void | Promise<void>): () => void;
+}

package/dist/runtime/client/webview.service.js

@@ -0,0 +1,98 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'tsyringe';
+import { coreLogger, LogDomain } from '../../kernel/logger';
+import { IClientWebViewBridge } from '../../adapters/contracts/client/ui/webview/IClientWebViewBridge';
+import { IClientRuntimeBridge } from './adapter/runtime-bridge';
+import { di } from './client-container';
+const webViewLogger = coreLogger.child('WebView', LogDomain.CLIENT);
+const FALLBACK_CAPABILITIES = {
+    supportsFocus: true,
+    supportsCursor: true,
+    supportsInputPassthrough: true,
+    supportsBidirectionalMessaging: true,
+    supportsExecute: false,
+    supportsHeadless: false,
+};
+function createFallbackBridge() {
+    const runtime = di.resolve(IClientRuntimeBridge);
+    const handlers = new Set();
+    let registered = false;
+    return {
+        getCapabilities: () => FALLBACK_CAPABILITIES,
+        create: () => { },
+        destroy: () => { },
+        exists: () => true,
+        show: () => { },
+        hide: () => { },
+        focus: (_viewId, options) => {
+            runtime.setWebViewFocus(true, options?.cursor ?? true);
+            runtime.setWebViewInputPassthrough(options?.inputPassthrough ?? false);
+        },
+        blur: () => runtime.setWebViewFocus(false, false),
+        send: (viewId, event, payload) => {
+            runtime.sendWebViewMessage(JSON.stringify({ __opencoreWebView: true, viewId, action: event, data: payload }));
+        },
+        onMessage: (handler) => {
+            if (!registered) {
+                registered = true;
+                runtime.registerWebViewCallback('__opencore:webview:message', async (data, cb) => {
+                    const message = data;
+                    for (const item of handlers)
+                        await item(message);
+                    cb({ ok: true });
+                });
+            }
+            handlers.add(handler);
+            return () => handlers.delete(handler);
+        },
+    };
+}
+let WebViewService = class WebViewService {
+    get bridge() {
+        if (di.isRegistered(IClientWebViewBridge)) {
+            return di.resolve(IClientWebViewBridge);
+        }
+        return createFallbackBridge();
+    }
+    getCapabilities() {
+        return this.bridge.getCapabilities();
+    }
+    create(definition) {
+        this.bridge.create(definition);
+        webViewLogger.debug('Created webview', { id: definition.id, url: definition.url });
+    }
+    destroy(viewId) {
+        this.bridge.destroy(viewId);
+        webViewLogger.debug('Destroyed webview', { id: viewId });
+    }
+    exists(viewId) {
+        return this.bridge.exists(viewId);
+    }
+    show(viewId) {
+        this.bridge.show(viewId);
+    }
+    hide(viewId) {
+        this.bridge.hide(viewId);
+    }
+    focus(viewId, options) {
+        this.bridge.focus(viewId, options);
+    }
+    blur(viewId) {
+        this.bridge.blur(viewId);
+    }
+    send(viewId, event, payload) {
+        this.bridge.send(viewId, event, payload);
+    }
+    onMessage(handler) {
+        return this.bridge.onMessage(handler);
+    }
+};
+WebViewService = __decorate([
+    injectable()
+], WebViewService);
+export { WebViewService };

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