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

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

@@ -0,0 +1,43 @@
+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 { IClientWebViewBridge } from '../../../adapters/contracts/client/ui/webview/IClientWebViewBridge';
+const NODE_WEBVIEW_CAPABILITIES = {
+    supportsFocus: false,
+    supportsCursor: false,
+    supportsInputPassthrough: false,
+    supportsBidirectionalMessaging: false,
+    supportsExecute: false,
+    supportsHeadless: false,
+};
+let NodeClientWebViewBridge = class NodeClientWebViewBridge extends IClientWebViewBridge {
+    views = new Set();
+    getCapabilities() {
+        return NODE_WEBVIEW_CAPABILITIES;
+    }
+    create(definition) {
+        this.views.add(definition.id);
+    }
+    destroy(viewId) {
+        this.views.delete(viewId);
+    }
+    exists(viewId) {
+        return this.views.has(viewId);
+    }
+    show(_viewId) { }
+    hide(_viewId) { }
+    focus(_viewId, _options) { }
+    blur(_viewId) { }
+    send(_viewId, _event, _payload) { }
+    onMessage(_handler) {
+        return () => { };
+    }
+};
+NodeClientWebViewBridge = __decorate([
+    injectable()
+], NodeClientWebViewBridge);
+export { NodeClientWebViewBridge };

package/dist/runtime/client/adapter/platform-bridge.d.ts

@@ -0,0 +1 @@
+export { IClientPlatformBridge, type TextDrawOptions, } from '../../../adapters/contracts/client/IClientPlatformBridge';

package/dist/runtime/client/adapter/platform-bridge.js

@@ -0,0 +1 @@
+export { IClientPlatformBridge, } from '../../../adapters/contracts/client/IClientPlatformBridge';

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

@@ -0,0 +1,9 @@
+import { type OpenCoreClientAdapter } from './client-adapter';
+/**
+ * Installs the active client adapter for the current bootstrap.
+ */
+export declare function installClientAdapter(adapter?: OpenCoreClientAdapter): Promise<void>;
+export declare function getActiveClientAdapterName(): string | undefined;
+export declare function assertClientAdapterCompatibility(adapter?: OpenCoreClientAdapter): void;
+export declare function getCurrentClientResourceName(): string;
+export declare function __resetClientAdapterRegistryForTests(): void;

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

@@ -0,0 +1,85 @@
+import { di } from '../client-container';
+import { bindClientTransportInstances, } from './client-adapter';
+import { IClientRuntimeBridge } from './runtime-bridge';
+let activeClientAdapterName = null;
+async function getDefaultClientAdapter() {
+    if (typeof __OPENCORE_TARGET__ !== 'undefined' && __OPENCORE_TARGET__ === 'client') {
+        throw new Error('[OpenCore] No client adapter provided. Configure one in opencore.config.ts or pass adapter to Client.init().');
+    }
+    const { createNodeClientAdapter } = await import('./node-client-adapter');
+    return createNodeClientAdapter();
+}
+function assertTokenAvailable(token, adapterName) {
+    if (di.isRegistered(token)) {
+        throw new Error(`[OpenCore] Adapter '${adapterName}' cannot bind an already registered token.`);
+    }
+}
+function createAdapterContext(adapterName) {
+    return {
+        adapterName,
+        container: di,
+        isRegistered(token) {
+            return di.isRegistered(token);
+        },
+        bindSingleton(token, implementation) {
+            assertTokenAvailable(token, adapterName);
+            di.registerSingleton(token, implementation);
+        },
+        bindInstance(token, value) {
+            assertTokenAvailable(token, adapterName);
+            di.registerInstance(token, value);
+        },
+        bindFactory(token, factory) {
+            assertTokenAvailable(token, adapterName);
+            di.register(token, { useFactory: factory });
+        },
+        bindMessagingTransport(transport) {
+            bindClientTransportInstances(this, transport);
+        },
+        useRuntimeBridge(runtime) {
+            this.bindInstance(IClientRuntimeBridge, runtime);
+        },
+    };
+}
+/**
+ * Installs the active client adapter for the current bootstrap.
+ */
+export async function installClientAdapter(adapter) {
+    const active = adapter ?? (await getDefaultClientAdapter());
+    if (activeClientAdapterName) {
+        if (activeClientAdapterName !== active.name) {
+            throw new Error(`[OpenCore] Client adapter '${active.name}' cannot be installed because '${activeClientAdapterName}' is already active.`);
+        }
+        return;
+    }
+    await active.register(createAdapterContext(active.name));
+    activeClientAdapterName = active.name;
+}
+export function getActiveClientAdapterName() {
+    return activeClientAdapterName ?? undefined;
+}
+export function assertClientAdapterCompatibility(adapter) {
+    if (!adapter || !activeClientAdapterName) {
+        return;
+    }
+    if (adapter.name !== activeClientAdapterName) {
+        throw new Error(`[OpenCore] Client adapter '${adapter.name}' does not match active adapter '${activeClientAdapterName}'.`);
+    }
+}
+export function getCurrentClientResourceName() {
+    if (di.isRegistered(IClientRuntimeBridge)) {
+        return di
+            .resolve(IClientRuntimeBridge)
+            .getCurrentResourceName();
+    }
+    const fn = globalThis.GetCurrentResourceName;
+    if (typeof fn === 'function') {
+        const name = fn();
+        if (typeof name === 'string' && name.trim())
+            return name;
+    }
+    return 'default';
+}
+export function __resetClientAdapterRegistryForTests() {
+    activeClientAdapterName = null;
+}

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

@@ -0,0 +1 @@
+export { IClientRuntimeBridge } from '../../../adapters/contracts/client/IClientRuntimeBridge';

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

@@ -0,0 +1 @@
+export { IClientRuntimeBridge } from '../../../adapters/contracts/client/IClientRuntimeBridge';

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

@@ -0,0 +1,9 @@
+export * from './client-core';
+export * from './client-runtime';
+export * from './adapter';
+export * from './decorators';
+export * from './library';
+export * from './services';
+export * from './types';
+export * from './webview-bridge';
+export * from './ui-bridge';

package/dist/runtime/client/api.js

@@ -0,0 +1,9 @@
+export * from './client-core';
+export * from './client-runtime';
+export * from './adapter';
+export * from './decorators';
+export * from './library';
+export * from './services';
+export * from './types';
+export * from './webview-bridge';
+export * from './ui-bridge';

package/dist/runtime/client/bus/library-event.bus.d.ts

@@ -0,0 +1,5 @@
+import { LibraryEventEnvelope, LibraryEventId } from '../../core/library/types';
+type LibraryEventHandler = (event: LibraryEventEnvelope) => void | Promise<void>;
+export declare function onLibraryEvent(eventId: LibraryEventId, handler: LibraryEventHandler): () => void;
+export declare function emitLibraryEvent(eventId: LibraryEventId, event: LibraryEventEnvelope): void;
+export {};

package/dist/runtime/client/bus/library-event.bus.js

@@ -0,0 +1,28 @@
+import { coreLogger, LogDomain } from '../../../kernel/logger';
+const handlers = new Map();
+const libraryEventLogger = coreLogger.child('LibraryEvent', LogDomain.CLIENT);
+export function onLibraryEvent(eventId, handler) {
+    const eventHandlers = handlers.get(eventId) ?? new Set();
+    eventHandlers.add(handler);
+    handlers.set(eventId, eventHandlers);
+    return () => {
+        const current = handlers.get(eventId);
+        if (!current)
+            return;
+        current.delete(handler);
+        if (current.size === 0)
+            handlers.delete(eventId);
+    };
+}
+export function emitLibraryEvent(eventId, event) {
+    const eventHandlers = handlers.get(eventId);
+    if (!eventHandlers || eventHandlers.size === 0)
+        return;
+    for (const handler of [...eventHandlers]) {
+        Promise.resolve(handler(event)).catch((error) => {
+            libraryEventLogger.error(`Handler error in library event`, {
+                eventId,
+            }, error);
+        });
+    }
+}

package/dist/runtime/client/client-api-runtime.d.ts

@@ -0,0 +1,7 @@
+import * as BaseClientApi from './api';
+import type { ClientPluginApi } from './library/plugin/client-plugin-api';
+export type ClientApi = typeof BaseClientApi & ClientPluginApi & {
+    registerApiExtension(key: string, value: unknown): void;
+};
+export declare function createClientRuntime(): ClientApi;
+export declare const Client: ClientApi;

package/dist/runtime/client/client-api-runtime.js

@@ -0,0 +1,34 @@
+import * as BaseClientApi from './api';
+const RESERVED_CLIENT_API_KEYS = new Set([
+    'registerApiExtension',
+    '__proto__',
+    'prototype',
+    'constructor',
+]);
+function assertExtensionKey(key) {
+    if (!key || key.trim().length === 0) {
+        throw new Error('Client API extension key must be a non-empty string');
+    }
+    if (RESERVED_CLIENT_API_KEYS.has(key)) {
+        throw new Error(`Client 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(`Client API "${key}" already registered`);
+        }
+        dynamicApi[key] = value;
+        runtime[key] = value;
+    };
+    return runtime;
+}
+export function createClientRuntime() {
+    const runtime = {
+        ...BaseClientApi,
+    };
+    return attachApiExtensionRuntime(runtime);
+}
+export const Client = attachApiExtensionRuntime(BaseClientApi);

package/dist/runtime/client/client-bootstrap.d.ts

@@ -0,0 +1,7 @@
+import { type ClientInitOptions } from './client-runtime';
+/**
+ * Initialize the client core framework
+ *
+ * @param options - Client initialization options
+ */
+export declare function initClientCore(options?: ClientInitOptions): Promise<void>;

package/dist/runtime/client/client-bootstrap.js

@@ -0,0 +1,167 @@
+import { MetadataScanner } from '../../kernel/di/metadata.scanner';
+import { loggers } from '../../kernel/logger';
+import { assertClientAdapterCompatibility, getActiveClientAdapterName, getCurrentClientResourceName, installClientAdapter, } from './adapter/registry';
+import { di } from './client-container';
+import { getClientRuntimeContext, setClientRuntimeContext, } from './client-runtime';
+import { getClientControllerRegistry } from './decorators';
+import { BlipService, Camera, CameraEffectsRegistry, Cinematic, MarkerService, NotificationService, PedService, ProgressService, ClientSessionBridgeService, SpawnService, StreamingService, TextUIService, VehicleClientService, VehicleService, } from './services';
+import { registerSystemClient } from './system/processors.register';
+import { WebViewBridge } from './webview-bridge';
+import { WebViewService } from './webview.service';
+/**
+ * Services that have an init() method which registers global runtime event listeners.
+ *
+ * These services are:
+ * - Registered in DI for ALL modes (so they can be injected and used)
+ * - Only initialized (.init() called) in CORE mode to avoid duplicate event handlers
+ */
+const SERVICES_WITH_GLOBAL_LISTENERS = [SpawnService, ClientSessionBridgeService];
+/**
+ * All client services that should be available in the DI container
+ */
+// const ALL_CLIENT_SERVICES = [
+//   SpawnService,
+//   WebViewBridge,
+//   NotificationService,
+//   TextUIService,
+//   ProgressService,
+//   MarkerService,
+//   BlipService,
+//   VehicleClientService,
+//   VehicleService,
+//   PedService,
+//   StreamingService,
+// ] as const
+/**
+ * Register singleton services in the DI container
+ *
+ * @remarks
+ * All services are registered in ALL modes so they can be injected and used.
+ * However, only CORE mode will call .init() on services with global listeners.
+ */
+function registerServices() {
+    // Register all client services in DI (available in all modes)
+    if (!di.isRegistered(SpawnService))
+        di.registerSingleton(SpawnService, SpawnService);
+    if (!di.isRegistered(WebViewService))
+        di.registerSingleton(WebViewService, WebViewService);
+    if (!di.isRegistered(WebViewBridge))
+        di.registerSingleton(WebViewBridge, WebViewBridge);
+    if (!di.isRegistered(NotificationService))
+        di.registerSingleton(NotificationService, NotificationService);
+    if (!di.isRegistered(TextUIService))
+        di.registerSingleton(TextUIService, TextUIService);
+    if (!di.isRegistered(ProgressService))
+        di.registerSingleton(ProgressService, ProgressService);
+    if (!di.isRegistered(ClientSessionBridgeService))
+        di.registerSingleton(ClientSessionBridgeService, ClientSessionBridgeService);
+    if (!di.isRegistered(MarkerService))
+        di.registerSingleton(MarkerService, MarkerService);
+    if (!di.isRegistered(BlipService))
+        di.registerSingleton(BlipService, BlipService);
+    if (!di.isRegistered(Camera))
+        di.registerSingleton(Camera, Camera);
+    if (!di.isRegistered(CameraEffectsRegistry))
+        di.registerSingleton(CameraEffectsRegistry, CameraEffectsRegistry);
+    if (!di.isRegistered(Cinematic))
+        di.registerSingleton(Cinematic, Cinematic);
+    if (!di.isRegistered(VehicleClientService))
+        di.registerSingleton(VehicleClientService, VehicleClientService);
+    if (!di.isRegistered(VehicleService))
+        di.registerSingleton(VehicleService, VehicleService);
+    if (!di.isRegistered(PedService))
+        di.registerSingleton(PedService, PedService);
+    if (!di.isRegistered(StreamingService))
+        di.registerSingleton(StreamingService, StreamingService);
+}
+/**
+ * Bootstrap services that need initialization
+ *
+ * @remarks
+ * Only called in CORE mode to initialize services that register global event listeners.
+ * This prevents duplicate event handlers when multiple resources use the framework.
+ *
+ * @param mode - The client initialization mode
+ */
+async function bootstrapServices(mode) {
+    if (mode === 'CORE') {
+        // Initialize services with global listeners (only in CORE mode)
+        for (const Service of SERVICES_WITH_GLOBAL_LISTENERS) {
+            const instance = di.resolve(Service);
+            if (typeof instance.init === 'function') {
+                await instance.init();
+            }
+        }
+        // Instantiate VehicleClientService to register its event handlers
+        di.resolve(VehicleClientService);
+    }
+}
+async function tryImportAutoLoad() {
+    try {
+        await import('./.opencore/autoload.client.controllers');
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.includes('Cannot find module')) {
+            loggers.bootstrap.debug(`[Bootstrap] No client controllers autoload file found, skipping.`);
+            return;
+        }
+        throw err;
+    }
+}
+/**
+ * Initialize the client core framework
+ *
+ * @param options - Client initialization options
+ */
+export async function initClientCore(options = {}) {
+    const mode = options.mode ?? 'CORE';
+    // Check if already initialized
+    const existingContext = getClientRuntimeContext();
+    if (existingContext?.isInitialized) {
+        assertClientAdapterCompatibility(options.adapter);
+        // Register system processors for the active bundle if needed.
+        registerSystemClient();
+        const resourceName = getCurrentClientResourceName();
+        // If already initialized, only scan controllers for this resource
+        if (mode === 'RESOURCE' || mode === 'STANDALONE') {
+            await tryImportAutoLoad();
+            const scanner = di.resolve(MetadataScanner);
+            scanner.scan(getClientControllerRegistry(resourceName));
+            loggers.bootstrap.info(`Resource "${resourceName}" controllers registered`);
+            return;
+        }
+        // If trying to initialize CORE mode twice, throw error
+        throw new Error(`Client already initialized in ${existingContext.mode} mode by resource "${existingContext.resourceName}". Cannot initialize again in ${mode} mode.`);
+    }
+    await installClientAdapter(options.adapter);
+    loggers.bootstrap.debug('Client adapter registered', {
+        adapter: getActiveClientAdapterName() ?? 'unknown',
+    });
+    const resourceName = getCurrentClientResourceName();
+    // Register system processors early (needed for MetadataScanner)
+    // These processors are safe - they just process metadata, they don't register event handlers
+    // Each resource bundle needs its own copy registered in its DI container
+    registerSystemClient();
+    // Set runtime context
+    setClientRuntimeContext({
+        mode,
+        resourceName,
+        isInitialized: true,
+    });
+    // Register all services in DI (available in all modes)
+    registerServices();
+    // Bootstrap services (only in CORE mode)
+    // This is where services that register global event handlers are initialized
+    await bootstrapServices(mode);
+    // Import framework controllers (only in CORE mode)
+    // These controllers listen to global events and should only be registered once
+    if (mode === 'CORE') {
+        await import('./controllers/spawner.controller');
+        await import('./controllers/appearance.controller');
+    }
+    await tryImportAutoLoad();
+    // Scan and register controllers
+    const scanner = di.resolve(MetadataScanner);
+    scanner.scan(getClientControllerRegistry(resourceName));
+    loggers.bootstrap.info(`Client initialized in ${mode} mode`, { resourceName });
+}

package/dist/runtime/client/client-container.js

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { container } from 'tsyringe';
+export const di = container;

package/dist/runtime/client/client-core.d.ts

@@ -0,0 +1,21 @@
+import type { OpenCoreClientAdapter } from './adapter';
+import { ClientInitOptions } from './client-runtime';
+export declare function useAdapter(adapter: OpenCoreClientAdapter): void;
+/**
+ * Initialize the OpenCore client framework
+ *
+ * @param options - Client initialization options
+ *
+ * @example
+ * ```ts
+ * // Core resource (initializes all services)
+ * await Client.init({ mode: 'CORE' })
+ *
+ * // Resource mode (only registers controllers)
+ * await Client.init({ mode: 'RESOURCE' })
+ *
+ * // Standalone mode (only registers controllers)
+ * await Client.init({ mode: 'STANDALONE' })
+ * ```
+ */
+export declare function init(options?: ClientInitOptions): Promise<void>;

package/dist/runtime/client/client-core.js

@@ -0,0 +1,32 @@
+import { initClientCore } from './client-bootstrap';
+import { installClientAdapter } from './adapter/registry';
+import { installClientPlugins } from './library/plugin/install-client-plugins';
+let pendingAdapter;
+export function useAdapter(adapter) {
+    pendingAdapter = adapter;
+}
+/**
+ * Initialize the OpenCore client framework
+ *
+ * @param options - Client initialization options
+ *
+ * @example
+ * ```ts
+ * // Core resource (initializes all services)
+ * await Client.init({ mode: 'CORE' })
+ *
+ * // Resource mode (only registers controllers)
+ * await Client.init({ mode: 'RESOURCE' })
+ *
+ * // Standalone mode (only registers controllers)
+ * await Client.init({ mode: 'STANDALONE' })
+ * ```
+ */
+export async function init(options = {}) {
+    if (!options.adapter && pendingAdapter) {
+        options = { ...options, adapter: pendingAdapter };
+    }
+    await installClientAdapter(options.adapter);
+    await installClientPlugins(options.plugins ?? [], options);
+    await initClientCore(options);
+}

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

@@ -0,0 +1,66 @@
+import type { OpenCoreClientPlugin } from './library/plugin';
+/**
+ * Client Runtime Configuration
+ *
+ * Defines initialization modes and configuration for the client-side framework.
+ */
+export type ClientMode = 'CORE' | 'RESOURCE' | 'STANDALONE';
+/**
+ * Client initialization options
+ *
+ * @remarks
+ * - **CORE**: Initializes all framework services (SpawnService, NotificationService, etc.)
+ *   and scans controllers. Should only be used by the main core resource.
+ *
+ * - **RESOURCE**: Only scans controllers from this resource. Does NOT initialize services.
+ *   Used when a resource extends the core with additional functionality.
+ *
+ * - **STANDALONE**: Same as RESOURCE - only scans controllers. Services must be registered
+ *   manually if needed. Use for independent resources or testing.
+ *
+ * @example
+ * ```ts
+ * // Core resource
+ * await Client.init({ mode: 'CORE' })
+ *
+ * // Chat resource (extends core)
+ * await Client.init({ mode: 'RESOURCE' })
+ * ```
+ */
+export interface ClientInitOptions {
+    /**
+     * The client initialization mode.
+     *
+     * Defaults to 'CORE' if not specified (for backwards compatibility).
+     */
+    mode?: ClientMode;
+    /** Optional runtime adapter for non-node client environments. */
+    adapter?: import('./adapter').OpenCoreClientAdapter;
+    /**
+     * Optional client plugins installed before bootstrap.
+     */
+    plugins?: OpenCoreClientPlugin[];
+}
+/**
+ * Client runtime context
+ */
+export interface ClientRuntimeContext {
+    mode: ClientMode;
+    resourceName: string;
+    isInitialized: boolean;
+}
+/**
+ * Get the current client runtime context
+ */
+export declare function getClientRuntimeContext(): ClientRuntimeContext | null;
+/**
+ * Set the client runtime context
+ *
+ * @internal
+ */
+export declare function setClientRuntimeContext(ctx: ClientRuntimeContext): void;
+/**
+ * Check if the client has been initialized
+ */
+export declare function isClientInitialized(): boolean;
+export declare function __resetClientRuntimeContextForTests(): void;

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

@@ -0,0 +1,24 @@
+let runtimeContext = null;
+/**
+ * Get the current client runtime context
+ */
+export function getClientRuntimeContext() {
+    return runtimeContext;
+}
+/**
+ * Set the client runtime context
+ *
+ * @internal
+ */
+export function setClientRuntimeContext(ctx) {
+    runtimeContext = ctx;
+}
+/**
+ * Check if the client has been initialized
+ */
+export function isClientInitialized() {
+    return runtimeContext?.isInitialized ?? false;
+}
+export function __resetClientRuntimeContextForTests() {
+    runtimeContext = null;
+}

package/dist/runtime/client/controllers/appearance.controller.d.ts

@@ -0,0 +1,10 @@
+import { PlayerAppearance } from '../../../kernel/shared';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { AppearanceService } from '../services/appearance.service';
+export declare class AppearanceTestClientController {
+    private readonly appearanceService;
+    private readonly platform;
+    constructor(appearanceService: AppearanceService, platform: IClientPlatformBridge);
+    onApply(appearance: PlayerAppearance): Promise<void>;
+    onReset(): void;
+}

package/dist/runtime/client/controllers/appearance.controller.js

@@ -0,0 +1,58 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 } from 'tsyringe';
+import { Controller, OnNet } from '../decorators';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { AppearanceService } from '../services/appearance.service';
+import { loggers } from '../../../kernel/logger';
+let AppearanceTestClientController = class AppearanceTestClientController {
+    appearanceService;
+    platform;
+    constructor(appearanceService, platform) {
+        this.appearanceService = appearanceService;
+        this.platform = platform;
+    }
+    async onApply(appearance) {
+        loggers.netEvent.debug('appearance:apply received', {
+            appearance,
+        });
+        const ped = this.platform.getLocalPlayerPed();
+        await this.appearanceService.applyAppearance(ped, appearance);
+    }
+    onReset() {
+        loggers.netEvent.debug('appearance:reset received');
+        const ped = this.platform.getLocalPlayerPed();
+        this.appearanceService.setDefaultAppearance(ped);
+        this.appearanceService.clearTattoos(ped);
+    }
+};
+__decorate([
+    OnNet('opencore:appearance:apply'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AppearanceTestClientController.prototype, "onApply", null);
+__decorate([
+    OnNet('opencore:appearance:reset'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], AppearanceTestClientController.prototype, "onReset", null);
+AppearanceTestClientController = __decorate([
+    Controller(),
+    __param(0, inject(AppearanceService)),
+    __param(1, inject(IClientPlatformBridge)),
+    __metadata("design:paramtypes", [AppearanceService,
+        IClientPlatformBridge])
+], AppearanceTestClientController);
+export { AppearanceTestClientController };

package/dist/runtime/client/controllers/spawner.controller.d.ts

@@ -0,0 +1,12 @@
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { SpawnService } from '../services';
+export declare class SpawnerController {
+    private readonly spawnService;
+    constructor(spawnService: SpawnService);
+    handleSpawn(data: {
+        position: Vector3;
+        model: string;
+    }): Promise<void>;
+    handleRespawn(position: Vector3, heading?: number): Promise<void>;
+    handleTeleport(position: Vector3, heading?: number): Promise<void>;
+}