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

package/dist/runtime/server/runtime.js

@@ -0,0 +1,211 @@
+const FEATURE_NAMES = [
+    'players',
+    'netEvents',
+    'runtimeEvents',
+    'commands',
+    'exports',
+    'chat',
+    'principal',
+    'sessionLifecycle',
+];
+const FEATURE_ALLOWED_SCOPES = {
+    players: ['core', 'resource', 'standalone'],
+    netEvents: ['core', 'resource', 'standalone'],
+    runtimeEvents: ['core', 'resource', 'standalone'],
+    commands: ['core', 'resource', 'standalone'],
+    exports: ['core', 'resource', 'standalone'],
+    chat: ['core', 'resource', 'standalone'],
+    principal: ['core', 'resource', 'standalone'],
+    sessionLifecycle: ['core', 'standalone'],
+};
+let runtimeContext = null;
+export function setRuntimeContext(ctx) {
+    runtimeContext = ctx;
+}
+export function getRuntimeContext() {
+    if (!runtimeContext) {
+        throw new Error('[OpenCore] RuntimeContext is not initialized. Call Server.init({ mode, ... }) before using the framework.');
+    }
+    return runtimeContext;
+}
+export function getFrameworkModeScope(mode) {
+    if (mode === 'CORE')
+        return 'core';
+    if (mode === 'RESOURCE')
+        return 'resource';
+    return 'standalone';
+}
+function createDefaultFeatures(mode) {
+    const scope = getFrameworkModeScope(mode);
+    // Provider logic:
+    // - CORE/STANDALONE: All features use 'local' (run locally)
+    // - RESOURCE: Identity/Command features delegate to CORE ('core'), others run locally ('local')
+    const remoteProvider = mode === 'RESOURCE' ? 'core' : 'local';
+    const isResource = mode === 'RESOURCE';
+    const isCore = mode === 'CORE';
+    return {
+        players: {
+            enabled: true,
+            provider: remoteProvider,
+            export: isCore,
+            scope,
+            required: true,
+        },
+        netEvents: {
+            enabled: true,
+            provider: 'local',
+            export: false,
+            scope,
+            required: true,
+        },
+        runtimeEvents: {
+            enabled: true,
+            provider: 'local',
+            export: false,
+            scope,
+            required: false,
+        },
+        commands: {
+            enabled: true,
+            provider: remoteProvider,
+            export: isCore,
+            scope,
+            required: true,
+        },
+        exports: {
+            enabled: true,
+            provider: 'local',
+            export: false,
+            scope,
+            required: isCore,
+        },
+        chat: {
+            enabled: true,
+            provider: 'local',
+            export: isCore,
+            scope,
+            required: false,
+        },
+        principal: {
+            enabled: true,
+            provider: remoteProvider,
+            export: isCore,
+            scope,
+            required: false,
+        },
+        sessionLifecycle: {
+            enabled: !isResource,
+            provider: 'local',
+            export: false,
+            scope,
+            required: false,
+            recoveryOnRestart: true,
+        },
+    };
+}
+export function resolveRuntimeOptions(options) {
+    const features = createDefaultFeatures(options.mode);
+    if (options.features?.disabled) {
+        for (const name of options.features.disabled) {
+            if (features[name]) {
+                features[name].enabled = false;
+            }
+        }
+    }
+    return {
+        mode: options.mode,
+        features,
+        coreResourceName: options.coreResourceName ?? 'core',
+        devMode: options.devMode,
+        onDependency: options.onDependency,
+    };
+}
+function assertFeatureKeys(features) {
+    if (!features) {
+        throw new Error('[OpenCore] Runtime options are missing features configuration');
+    }
+    const keys = Object.keys(features);
+    for (const key of keys) {
+        if (!FEATURE_NAMES.includes(key)) {
+            throw new Error(`[OpenCore] Unknown feature: '${key}'`);
+        }
+    }
+}
+export function validateRuntimeOptions(options) {
+    const { mode, features } = options;
+    assertFeatureKeys(features);
+    // If in RESOURCE mode, must have coreResourceName
+    if (mode === 'RESOURCE' && !options.coreResourceName) {
+        throw new Error('[OpenCore] RESOURCE mode requires coreResourceName to be specified');
+    }
+    // Determine which features need CORE exports in RESOURCE mode
+    const needsCoreExports = mode === 'RESOURCE' &&
+        (features.players.provider === 'core' ||
+            features.commands.provider === 'core' ||
+            features.principal.provider === 'core');
+    // Validate coreResourceName exists if needed
+    if (mode === 'RESOURCE') {
+        const { coreResourceName } = options;
+        if (needsCoreExports) {
+            const core = globalThis.exports?.[coreResourceName];
+            if (!core) {
+                throw new Error(`[OpenCore] CORE resource '${coreResourceName}' not found. Ensure it is started before RESOURCE mode resources.`);
+            }
+        }
+    }
+    const scope = getFrameworkModeScope(mode);
+    for (const name of FEATURE_NAMES) {
+        const f = features[name];
+        if (!f.enabled) {
+            if (f.required) {
+                throw new Error(`[OpenCore] Feature '${name}' is required but disabled`);
+            }
+            continue;
+        }
+        const allowedScopes = FEATURE_ALLOWED_SCOPES[name];
+        if (!allowedScopes.includes(scope)) {
+            throw new Error(`[OpenCore] Feature '${name}' is not allowed in scope '${scope}' (allowed: ${allowedScopes.join(', ')})`);
+        }
+        if (f.scope !== scope) {
+            throw new Error(`[OpenCore] Invalid scope for feature '${name}': expected '${scope}' for mode '${mode}', received '${f.scope}'`);
+        }
+        if (f.export && !features.exports.enabled) {
+            throw new Error(`[OpenCore] Feature '${name}' cannot be exported when 'exports' is disabled`);
+        }
+        // Validate provider combinations
+        if (mode === 'CORE' && f.provider === 'core') {
+            throw new Error(`[OpenCore] Feature '${name}' cannot use provider='core' in CORE mode (use 'local' instead)`);
+        }
+        if (mode === 'RESOURCE' && f.provider === 'core' && f.export) {
+            throw new Error(`[OpenCore] Feature '${name}' cannot set export=true when provider='core' in RESOURCE mode`);
+        }
+    }
+    // Feature-specific validations
+    if (features.players.enabled && mode === 'RESOURCE' && features.players.provider !== 'core') {
+        throw new Error(`[OpenCore] Feature 'players' must use provider 'core' in RESOURCE mode`);
+    }
+    if (features.principal.enabled && mode === 'RESOURCE' && features.principal.provider !== 'core') {
+        throw new Error(`[OpenCore] Feature 'principal' must use provider 'core' in RESOURCE mode`);
+    }
+    if (features.commands.enabled && mode === 'RESOURCE' && features.commands.provider !== 'core') {
+        throw new Error(`[OpenCore] Feature 'commands' must use provider 'core' in RESOURCE mode`);
+    }
+    // Commands export validation
+    if (features.commands.export && mode !== 'CORE') {
+        throw new Error(`[OpenCore] Feature 'commands' can only be exported in CORE mode (current mode: '${mode}')`);
+    }
+    // Validate dependencies
+    if (features.commands.enabled && !features.players.enabled) {
+        throw new Error(`[OpenCore] Feature 'commands' requires 'players' to be enabled`);
+    }
+    if (features.netEvents.enabled && !features.players.enabled) {
+        throw new Error(`[OpenCore] Feature 'netEvents' requires 'players' to be enabled`);
+    }
+    if (features.chat.enabled && !features.players.enabled) {
+        throw new Error(`[OpenCore] Feature 'chat' requires 'players' to be enabled`);
+    }
+}
+/**
+ * @deprecated Use validateRuntimeOptions instead
+ */
+export const validateRuntimeContextOrThrow = validateRuntimeOptions;

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

@@ -0,0 +1,7 @@
+import * as BaseServerApi from './api';
+import type { ServerPluginApi } from './library/plugin/server-plugin-api';
+export type ServerApi = typeof BaseServerApi & ServerPluginApi & {
+    registerApiExtension(key: string, value: unknown): void;
+};
+export declare function createServerRuntime(): ServerApi;
+export declare const Server: ServerApi;

package/dist/runtime/server/server.runtime.js

@@ -0,0 +1,34 @@
+import * as BaseServerApi from './api';
+const RESERVED_SERVER_API_KEYS = new Set([
+    'registerApiExtension',
+    '__proto__',
+    'prototype',
+    'constructor',
+]);
+function assertExtensionKey(key) {
+    if (!key || key.trim().length === 0) {
+        throw new Error('Server API extension key must be a non-empty string');
+    }
+    if (RESERVED_SERVER_API_KEYS.has(key)) {
+        throw new Error(`Server API extension key "${key}" is reserved`);
+    }
+}
+function attachApiExtensionRuntime(runtime) {
+    const dynamicApi = {};
+    runtime.registerApiExtension = (key, value) => {
+        assertExtensionKey(key);
+        if (Object.hasOwn(dynamicApi, key) || key in runtime) {
+            throw new Error(`Server API "${key}" already registered`);
+        }
+        dynamicApi[key] = value;
+        runtime[key] = value;
+    };
+    return runtime;
+}
+export function createServerRuntime() {
+    const runtime = {
+        ...BaseServerApi,
+    };
+    return attachApiExtensionRuntime(runtime);
+}
+export const Server = attachApiExtensionRuntime(BaseServerApi);

package/dist/runtime/server/services/appearance.service.d.ts

@@ -0,0 +1,99 @@
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { IPedAppearanceServer } from '../../../adapters/contracts/server/IPedAppearanceServer';
+import { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+import { AppearanceValidationResult, PlayerAppearance } from '../../../kernel/shared';
+/**
+ * Server-side appearance management service.
+ *
+ * @remarks
+ * Handles validating and applying ped appearance data on the server.
+ * Provides security validation and server-authoritative appearance control.
+ *
+ * **Security Model:**
+ * - All appearance changes should be validated server-side
+ * - Server applies components/props directly (available natives)
+ * - Server emits events to client for client-only natives (headBlend, overlays, tattoos)
+ * - Client never sends appearance data directly to other clients
+ *
+ * **Persistence:**
+ * The framework does NOT handle persistence internally.
+ * After calling `applyAppearance`, you receive the validated data back.
+ * You decide when and where to save it (persistent storage, file, etc.).
+ *
+ * @example
+ * ```typescript
+ * // Apply appearance to a player
+ * const result = await appearanceService.applyAppearance(playerSrc, appearanceData)
+ * if (result.success) {
+ *   // Save to your storage
+ *   await myStorage.saveAppearance(playerId, result.appearance)
+ * }
+ *
+ * // Validate appearance without applying
+ * const validation = appearanceService.validateAppearance(appearanceData)
+ * if (!validation.valid) {
+ *   console.log('Errors:', validation.errors)
+ * }
+ * ```
+ */
+export declare class AppearanceService {
+    private readonly pedAdapter;
+    private readonly playerServer;
+    private readonly events;
+    constructor(pedAdapter: IPedAppearanceServer, playerServer: IPlayerServer, events: EventsAPI<'server'>);
+    /**
+     * Applies validated appearance to a player.
+     *
+     * @remarks
+     * This method:
+     * 1. Validates the appearance data
+     * 2. Applies server-side natives (components, props)
+     * 3. Emits event to client for client-only natives
+     * 4. Returns the validated appearance for persistence
+     *
+     * @param playerSrc - Player source/client ID
+     * @param appearance - Appearance data to apply
+     * @returns Result with success status and validated appearance
+     */
+    applyAppearance(playerSrc: string, appearance: PlayerAppearance): Promise<{
+        success: boolean;
+        appearance?: PlayerAppearance;
+        errors?: string[];
+    }>;
+    /**
+     * Applies only components and props (server-side available natives).
+     *
+     * @remarks
+     * Use this for quick clothing changes without full appearance update.
+     *
+     * @param playerSrc - Player source/client ID
+     * @param appearance - Partial appearance with components/props only
+     * @returns Success status
+     */
+    applyClothing(playerSrc: string, appearance: Pick<PlayerAppearance, 'components' | 'props'>): boolean;
+    /**
+     * Resets a player's appearance to default.
+     *
+     * @param playerSrc - Player source/client ID
+     * @returns Success status
+     */
+    resetAppearance(playerSrc: string): boolean;
+    /**
+     * Validates appearance data without applying it.
+     *
+     * @remarks
+     * Use this to validate appearance data before storing or applying.
+     * All validation rules are enforced to prevent invalid/malicious data.
+     *
+     * @param appearance - Appearance data to validate
+     * @returns Validation result with errors if any
+     */
+    validateAppearance(appearance: Partial<PlayerAppearance>): AppearanceValidationResult;
+    /**
+     * Applies server-side appearance natives (components and props only).
+     *
+     * @param ped - Ped entity handle
+     * @param appearance - Appearance data
+     */
+    private applyServerSideAppearance;
+}

package/dist/runtime/server/services/appearance.service.js

@@ -0,0 +1,307 @@
+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 { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+/**
+ * Server-side appearance management service.
+ *
+ * @remarks
+ * Handles validating and applying ped appearance data on the server.
+ * Provides security validation and server-authoritative appearance control.
+ *
+ * **Security Model:**
+ * - All appearance changes should be validated server-side
+ * - Server applies components/props directly (available natives)
+ * - Server emits events to client for client-only natives (headBlend, overlays, tattoos)
+ * - Client never sends appearance data directly to other clients
+ *
+ * **Persistence:**
+ * The framework does NOT handle persistence internally.
+ * After calling `applyAppearance`, you receive the validated data back.
+ * You decide when and where to save it (persistent storage, file, etc.).
+ *
+ * @example
+ * ```typescript
+ * // Apply appearance to a player
+ * const result = await appearanceService.applyAppearance(playerSrc, appearanceData)
+ * if (result.success) {
+ *   // Save to your storage
+ *   await myStorage.saveAppearance(playerId, result.appearance)
+ * }
+ *
+ * // Validate appearance without applying
+ * const validation = appearanceService.validateAppearance(appearanceData)
+ * if (!validation.valid) {
+ *   console.log('Errors:', validation.errors)
+ * }
+ * ```
+ */
+let AppearanceService = class AppearanceService {
+    pedAdapter;
+    playerServer;
+    events;
+    constructor(pedAdapter, playerServer, events) {
+        this.pedAdapter = pedAdapter;
+        this.playerServer = playerServer;
+        this.events = events;
+    }
+    /**
+     * Applies validated appearance to a player.
+     *
+     * @remarks
+     * This method:
+     * 1. Validates the appearance data
+     * 2. Applies server-side natives (components, props)
+     * 3. Emits event to client for client-only natives
+     * 4. Returns the validated appearance for persistence
+     *
+     * @param playerSrc - Player source/client ID
+     * @param appearance - Appearance data to apply
+     * @returns Result with success status and validated appearance
+     */
+    async applyAppearance(playerSrc, appearance) {
+        const validation = this.validateAppearance(appearance);
+        if (!validation.valid) {
+            return { success: false, errors: validation.errors };
+        }
+        const ped = this.playerServer.getPed(playerSrc);
+        if (ped === 0) {
+            return { success: false, errors: ['Player ped not found'] };
+        }
+        // Apply server-side natives (components and props)
+        this.applyServerSideAppearance(ped, appearance);
+        // Emit event to client for client-only natives
+        this.events.emit('opencore:appearance:apply', parseInt(playerSrc, 10), appearance);
+        return { success: true, appearance };
+    }
+    /**
+     * Applies only components and props (server-side available natives).
+     *
+     * @remarks
+     * Use this for quick clothing changes without full appearance update.
+     *
+     * @param playerSrc - Player source/client ID
+     * @param appearance - Partial appearance with components/props only
+     * @returns Success status
+     */
+    applyClothing(playerSrc, appearance) {
+        const ped = this.playerServer.getPed(playerSrc);
+        if (ped === 0) {
+            return false;
+        }
+        this.applyServerSideAppearance(ped, appearance);
+        return true;
+    }
+    /**
+     * Resets a player's appearance to default.
+     *
+     * @param playerSrc - Player source/client ID
+     * @returns Success status
+     */
+    resetAppearance(playerSrc) {
+        const ped = this.playerServer.getPed(playerSrc);
+        if (ped === 0) {
+            return false;
+        }
+        this.pedAdapter.setDefaultComponentVariation(ped);
+        // Notify client to reset client-only appearance elements
+        this.events.emit('opencore:appearance:reset', parseInt(playerSrc, 10));
+        return true;
+    }
+    /**
+     * Validates appearance data without applying it.
+     *
+     * @remarks
+     * Use this to validate appearance data before storing or applying.
+     * All validation rules are enforced to prevent invalid/malicious data.
+     *
+     * @param appearance - Appearance data to validate
+     * @returns Validation result with errors if any
+     */
+    validateAppearance(appearance) {
+        const errors = [];
+        if (!appearance) {
+            return { valid: false, errors: ['Appearance data is null or undefined'] };
+        }
+        // Validate components (0-11)
+        if (appearance.components) {
+            for (const [id, data] of Object.entries(appearance.components)) {
+                const componentId = parseInt(id, 10);
+                if (Number.isNaN(componentId) || componentId < 0 || componentId > 11) {
+                    errors.push(`Invalid component ID: ${id} (must be 0-11)`);
+                }
+                if (data.drawable === undefined || data.drawable < -1) {
+                    errors.push(`Invalid drawable for component ${id}`);
+                }
+                if (data.texture === undefined || data.texture < 0) {
+                    errors.push(`Invalid texture for component ${id}`);
+                }
+            }
+        }
+        // Validate props (0-7)
+        if (appearance.props) {
+            for (const [id, data] of Object.entries(appearance.props)) {
+                const propId = parseInt(id, 10);
+                if (Number.isNaN(propId) || propId < 0 || propId > 7) {
+                    errors.push(`Invalid prop ID: ${id} (must be 0-7)`);
+                }
+                if (data.drawable === undefined) {
+                    errors.push(`Missing drawable for prop ${id}`);
+                }
+                if (data.texture === undefined || data.texture < 0) {
+                    errors.push(`Invalid texture for prop ${id}`);
+                }
+            }
+        }
+        // Validate faceFeatures (0-19, values -1.0 to 1.0)
+        if (appearance.faceFeatures) {
+            for (const [id, value] of Object.entries(appearance.faceFeatures)) {
+                const index = parseInt(id, 10);
+                if (Number.isNaN(index) || index < 0 || index > 19) {
+                    errors.push(`Invalid face feature index: ${id} (must be 0-19)`);
+                }
+                if (typeof value !== 'number' || value < -1.0 || value > 1.0) {
+                    errors.push(`Face feature ${id} value out of range: ${value} (must be -1.0 to 1.0)`);
+                }
+            }
+        }
+        // Validate headBlend
+        if (appearance.headBlend) {
+            const hb = appearance.headBlend;
+            if (typeof hb.shapeFirst !== 'number' || hb.shapeFirst < 0 || hb.shapeFirst > 45) {
+                errors.push('Invalid shapeFirst (must be 0-45)');
+            }
+            if (typeof hb.shapeSecond !== 'number' || hb.shapeSecond < 0 || hb.shapeSecond > 45) {
+                errors.push('Invalid shapeSecond (must be 0-45)');
+            }
+            if (typeof hb.skinFirst !== 'number' || hb.skinFirst < 0 || hb.skinFirst > 45) {
+                errors.push('Invalid skinFirst (must be 0-45)');
+            }
+            if (typeof hb.skinSecond !== 'number' || hb.skinSecond < 0 || hb.skinSecond > 45) {
+                errors.push('Invalid skinSecond (must be 0-45)');
+            }
+            if (typeof hb.shapeMix !== 'number' || hb.shapeMix < 0 || hb.shapeMix > 1) {
+                errors.push('Invalid shapeMix (must be 0.0-1.0)');
+            }
+            if (typeof hb.skinMix !== 'number' || hb.skinMix < 0 || hb.skinMix > 1) {
+                errors.push('Invalid skinMix (must be 0.0-1.0)');
+            }
+            if (hb.shapeThird !== undefined && (hb.shapeThird < 0 || hb.shapeThird > 45)) {
+                errors.push('Invalid shapeThird (must be 0-45)');
+            }
+            if (hb.skinThird !== undefined && (hb.skinThird < 0 || hb.skinThird > 45)) {
+                errors.push('Invalid skinThird (must be 0-45)');
+            }
+            if (hb.thirdMix !== undefined && (hb.thirdMix < 0 || hb.thirdMix > 1)) {
+                errors.push('Invalid thirdMix (must be 0.0-1.0)');
+            }
+        }
+        // Validate headOverlays (0-12)
+        if (appearance.headOverlays) {
+            for (const [id, overlay] of Object.entries(appearance.headOverlays)) {
+                const overlayId = parseInt(id, 10);
+                if (Number.isNaN(overlayId) || overlayId < 0 || overlayId > 12) {
+                    errors.push(`Invalid overlay ID: ${id} (must be 0-12)`);
+                }
+                if (typeof overlay.index !== 'number' || overlay.index < 0) {
+                    errors.push(`Invalid overlay index for ID ${id}`);
+                }
+                if (typeof overlay.opacity !== 'number' || overlay.opacity < 0 || overlay.opacity > 1) {
+                    errors.push(`Invalid overlay opacity for ID ${id} (must be 0.0-1.0)`);
+                }
+                if (overlay.colorType !== undefined && ![0, 1, 2].includes(overlay.colorType)) {
+                    errors.push(`Invalid overlay colorType for ID ${id} (must be 0, 1, or 2)`);
+                }
+            }
+        }
+        // Validate hairColor
+        if (appearance.hairColor) {
+            if (typeof appearance.hairColor.colorId !== 'number' || appearance.hairColor.colorId < 0) {
+                errors.push('Invalid hair colorId');
+            }
+            if (typeof appearance.hairColor.highlightColorId !== 'number' ||
+                appearance.hairColor.highlightColorId < 0) {
+                errors.push('Invalid hair highlightColorId');
+            }
+        }
+        // Validate eyeColor (0-31)
+        if (appearance.eyeColor !== undefined) {
+            if (typeof appearance.eyeColor !== 'number' ||
+                appearance.eyeColor < 0 ||
+                appearance.eyeColor > 31) {
+                errors.push(`Invalid eye color: ${appearance.eyeColor} (must be 0-31)`);
+            }
+        }
+        // Validate tattoos
+        if (appearance.tattoos) {
+            if (!Array.isArray(appearance.tattoos)) {
+                errors.push('Tattoos must be an array');
+            }
+            else {
+                for (let i = 0; i < appearance.tattoos.length; i++) {
+                    const tattoo = appearance.tattoos[i];
+                    if (!tattoo.collection || typeof tattoo.collection !== 'string') {
+                        errors.push(`Invalid tattoo collection at index ${i}`);
+                    }
+                    if (!tattoo.overlay || typeof tattoo.overlay !== 'string') {
+                        errors.push(`Invalid tattoo overlay at index ${i}`);
+                    }
+                }
+            }
+        }
+        // Validate model
+        if (appearance.model !== undefined) {
+            if (typeof appearance.model !== 'string' || appearance.model.length === 0) {
+                errors.push('Invalid model (must be a non-empty string)');
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    /**
+     * Applies server-side appearance natives (components and props only).
+     *
+     * @param ped - Ped entity handle
+     * @param appearance - Appearance data
+     */
+    applyServerSideAppearance(ped, appearance) {
+        // Apply components
+        if (appearance.components) {
+            for (const [componentId, data] of Object.entries(appearance.components)) {
+                this.pedAdapter.setComponentVariation(ped, parseInt(componentId, 10), data.drawable, data.texture, 2);
+            }
+        }
+        // Apply props
+        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);
+                }
+            }
+        }
+    }
+};
+AppearanceService = __decorate([
+    injectable(),
+    __param(0, inject(IPedAppearanceServer)),
+    __param(1, inject(IPlayerServer)),
+    __param(2, inject(EventsAPI)),
+    __metadata("design:paramtypes", [IPedAppearanceServer,
+        IPlayerServer,
+        EventsAPI])
+], AppearanceService);
+export { AppearanceService };

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

@@ -0,0 +1,6 @@
+export * from './appearance.service';
+export { SessionRecoveryService } from './session-recovery.local';
+export { PlayerPersistenceService } from './persistence.service';
+export * from '../ports/internal/command-execution.port';
+export type * from '../types/linked-id';
+export * from '../types/player-session.types';

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

@@ -0,0 +1,6 @@
+// Services
+export * from './appearance.service';
+export { SessionRecoveryService } from './session-recovery.local';
+export { PlayerPersistenceService } from './persistence.service';
+export * from '../ports/internal/command-execution.port';
+export * from '../types/player-session.types';

package/dist/runtime/server/services/parallel/native-worker.entry.d.ts

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