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

package/dist/runtime/server/bootstrap.js

@@ -1,8 +1,10 @@
-import { IEngineEvents } from '../../adapters';
-import { registerServerCapabilities } from '../../adapters/register-capabilities';
+import { IEngineEvents, IPlatformContext } from '../../adapters';
+import { IExports } from '../../adapters/contracts/IExports';
 import { EventsAPI } from '../../adapters/contracts/transport/events.api';
 import { GLOBAL_CONTAINER, MetadataScanner } from '../../kernel/di/index';
 import { getLogLevel, LogLevelLabels, loggers } from '../../kernel/logger';
+import { createNodeServerAdapter } from './adapter/node-server-adapter';
+import { installServerAdapter } from './adapter/registry';
 import { PrincipalProviderContract } from './contracts/index';
 import { getServerBinaryServiceRegistry } from './decorators/binaryService';
 import { getServerControllerRegistry } from './decorators/controller';
@@ -10,6 +12,7 @@ import { getFrameworkModeScope, setRuntimeContext, validateRuntimeOptions, } fro
 import { BinaryProcessManager } from './system/managers/binary-process.manager';
 import { SessionRecoveryService } from './services/session-recovery.local';
 import { registerServicesServer } from './services/services.register';
+import { SYSTEM_EVENTS } from '../shared/types/system-types';
 import { METADATA_KEYS } from './system/metadata-server.keys';
 import { registerSystemServer } from './system/processors.register';
 const CORE_WAIT_TIMEOUT = 10000;
@@ -84,9 +87,13 @@ export async function initServer(options, plugins) {
         mode: ctx.mode,
         scope: getFrameworkModeScope(ctx.mode),
     });
-    // Register platform-specific capabilities (adapters)
-    await registerServerCapabilities();
-    loggers.bootstrap.debug('Platform capabilities registered');
+    // Register platform-specific capabilities through the selected server adapter.
+    await installServerAdapter(options.adapter ?? createNodeServerAdapter());
+    const platformContext = GLOBAL_CONTAINER.resolve(IPlatformContext);
+    loggers.bootstrap.debug('Loading server Adapter ', {
+        adapter: options.adapter?.name ?? 'node',
+        game: platformContext.gameProfile,
+    });
     const dependenciesToWaitFor = [];
     if (ctx.mode === 'RESOURCE') {
         loggers.bootstrap.info(`[WAIT] Standing by for Core '${ctx.coreResourceName}' to be ready...`);
@@ -157,13 +164,13 @@ export async function initServer(options, plugins) {
         const engineEvents = GLOBAL_CONTAINER.resolve(IEngineEvents);
         const events = GLOBAL_CONTAINER.resolve(EventsAPI);
         // 1. Broadast to resources already running
-        engineEvents.emit('core:ready');
-        events.emit('core:ready', 'all');
-        // 2. Listen for 'core:request-ready' for resources starting late (hot-reload)
-        engineEvents.on('core:request-ready', () => {
-            engineEvents.emit('core:ready');
+        engineEvents.emit(SYSTEM_EVENTS.core.ready);
+        events.emit(SYSTEM_EVENTS.core.ready, 'all');
+        // 2. Listen for '_systemcore:request-ready' for resources starting late (hot-reload)
+        engineEvents.on(SYSTEM_EVENTS.core.requestReady, () => {
+            engineEvents.emit(SYSTEM_EVENTS.core.ready);
         });
-        loggers.bootstrap.info(`'core:ready' logic initialized and broadcasted`);
+        loggers.bootstrap.info(`'${SYSTEM_EVENTS.core.ready}' logic initialized and broadcasted`);
     }
     const logLevelLabel = LogLevelLabels[getLogLevel()];
     loggers.bootstrap.info(`LogLevel Setted: ${logLevelLabel}`);
@@ -183,22 +190,24 @@ function createCoreDependency(coreName) {
                 clearInterval(pollingInterval);
         };
         // 1. Register listener FIRST (before any requests)
+        const exportsService = GLOBAL_CONTAINER.resolve(IExports);
         const onReady = () => {
             if (!resolved) {
-                loggers.bootstrap.debug(`Core '${coreName}' detected via 'core:ready' event!`);
+                loggers.bootstrap.debug(`Core '${coreName}' detected via '${SYSTEM_EVENTS.core.ready}' event!`);
                 cleanup();
                 resolve();
             }
         };
-        engineEvents.on('core:ready', onReady);
-        loggers.bootstrap.debug(`Listening for 'core:ready' event from Core`);
+        engineEvents.on(SYSTEM_EVENTS.core.ready, onReady);
+        loggers.bootstrap.debug(`Listening for '${SYSTEM_EVENTS.core.ready}' event from Core`);
         // 2. Check if already ready via export (Polling)
         const checkReady = () => {
             if (resolved)
                 return;
             try {
-                const globalExports = globalThis.exports;
-                const isReady = globalExports?.[coreName]?.isCoreReady?.();
+                const isReady = exportsService
+                    .getResource(coreName)
+                    ?.isCoreReady?.();
                 loggers.bootstrap.debug(`Polling isCoreReady export: ${isReady}`);
                 if (isReady === true) {
                     loggers.bootstrap.debug(`Core '${coreName}' detected via isCoreReady export!`);
@@ -215,15 +224,15 @@ function createCoreDependency(coreName) {
         // 3. Request status (for hot-reload cases where Core is already up)
         // This is sent AFTER registering the listener so we can receive the response
         if (!resolved) {
-            loggers.bootstrap.debug(`Requesting Core status via 'core:request-ready' event`);
-            engineEvents.emit('core:request-ready');
+            loggers.bootstrap.debug(`Requesting Core status via '${SYSTEM_EVENTS.core.requestReady}' event`);
+            engineEvents.emit(SYSTEM_EVENTS.core.requestReady);
         }
         // 4. Timeout protection
         timeout = setTimeout(() => {
             if (!resolved) {
                 loggers.bootstrap.warn(`Timeout waiting for Core '${coreName}' after ${CORE_WAIT_TIMEOUT}ms`);
                 cleanup();
-                reject(new Error(`[OpenCore] Timeout waiting for CORE '${coreName}'. The Core did not emit 'core:ready' or expose 'isCoreReady' within ${CORE_WAIT_TIMEOUT}ms.`));
+                reject(new Error(`[OpenCore] Timeout waiting for CORE '${coreName}'. The Core did not emit '${SYSTEM_EVENTS.core.ready}' or expose 'isCoreReady' within ${CORE_WAIT_TIMEOUT}ms.`));
             }
         }, CORE_WAIT_TIMEOUT);
     });

package/dist/runtime/server/controllers/channel.controller.js

@@ -360,7 +360,7 @@ __decorate([
     __metadata("design:returntype", Array)
 ], ChannelExportController.prototype, "getAllChannels", null);
 __decorate([
-    OnRuntimeEvent('onServerResourceStop'),
+    OnRuntimeEvent(RUNTIME_EVENTS.serverResourceStop),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", void 0)
@@ -371,3 +371,4 @@ ChannelExportController = __decorate([
         Players])
 ], ChannelExportController);
 export { ChannelExportController };
+import { RUNTIME_EVENTS } from '../../../adapters/contracts/runtime';

package/dist/runtime/server/controllers/command-export.controller.js

@@ -11,9 +11,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject } from 'tsyringe';
+import { z } from 'zod';
 import { IEngineEvents } from '../../../adapters/contracts/IEngineEvents';
 import { AppError, SecurityError } from '../../../kernel/error';
 import { loggers } from '../../../kernel/logger';
+import { buildRemoteCommandExecuteEventName, SYSTEM_EVENTS } from '../../shared/types/system-types';
 import { CommandErrorObserverContract } from '../contracts/security/command-error-observer.contract';
 import { Controller, Export, Public } from '../decorators';
 import { OnNet } from '../decorators/onNet';
@@ -211,7 +213,7 @@ let CommandExportController = class CommandExportController {
             // Validate security BEFORE delegating to resource
             await this.validateSecurity(player, commandName, remoteEntry.metadata.security);
             // Delegate to resource via local event (server-to-server, not network)
-            const eventName = `opencore:command:execute:${remoteEntry.resourceName}`;
+            const eventName = buildRemoteCommandExecuteEventName(remoteEntry.resourceName);
             this.engineEvents.emit(eventName, clientID, commandName, args);
             loggers.command.debug(`Delegated remote command execution to ${remoteEntry.resourceName}`, {
                 command: commandName,
@@ -267,7 +269,7 @@ let CommandExportController = class CommandExportController {
             if (!allowed) {
                 const errorMessage = message || `Rate limit exceeded for command: ${commandName}`;
                 if (onExceed === 'KICK') {
-                    DropPlayer(player.clientID.toString(), errorMessage);
+                    player.kick(errorMessage);
                 }
                 throw new SecurityError(onExceed || 'LOG', errorMessage, { clientID: player.clientID });
             }
@@ -294,7 +296,7 @@ let CommandExportController = class CommandExportController {
 };
 __decorate([
     Public(),
-    OnNet('core:execute-command'),
+    OnNet(SYSTEM_EVENTS.command.execute, z.tuple([z.string().min(1), z.array(z.string())])),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Player, String, Array]),
     __metadata("design:returntype", Promise)

package/dist/runtime/server/controllers/player-export.controller.js

@@ -13,6 +13,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { inject } from 'tsyringe';
 import { Controller } from '../decorators/controller';
 import { Export } from '../decorators/export';
+import { serializeServerPlayerData } from '../adapter/serialization';
 import { Players } from '../ports/players.api-port';
 /**
  * Exports player directory functionality for RESOURCE mode access.
@@ -37,18 +38,18 @@ let PlayerExportController = class PlayerExportController {
     }
     getPlayerData(clientID) {
         const player = this.playerService.getByClient(clientID);
-        return player?.serialize() ?? null;
+        return player ? serializeServerPlayerData(player) : null;
     }
     getManyData(clientIds) {
-        return this.playerService.getMany(clientIds).map((p) => p.serialize());
+        return this.playerService.getMany(clientIds).map((player) => serializeServerPlayerData(player));
     }
     getAllPlayersData() {
-        return this.playerService.getAll().map((p) => p.serialize());
+        return this.playerService.getAll().map((player) => serializeServerPlayerData(player));
     }
     getPlayerByAccountId(accountId) {
         const players = this.playerService.getAll();
         const player = players.find((p) => p.accountID === accountId);
-        return player?.serialize() ?? null;
+        return player ? serializeServerPlayerData(player) : null;
     }
     getPlayerCount() {
         return this.playerService.getAll().length;

package/dist/runtime/server/controllers/remote-command-execution.controller.js

@@ -14,6 +14,7 @@ import { inject } from 'tsyringe';
 import { IEngineEvents } from '../../../adapters/contracts/IEngineEvents';
 import { IResourceInfo } from '../../../adapters/contracts/IResourceInfo';
 import { loggers } from '../../../kernel/logger';
+import { buildRemoteCommandExecuteEventName } from '../../shared/types/system-types';
 import { CommandErrorObserverContract } from '../contracts/security/command-error-observer.contract';
 import { Controller } from '../decorators';
 import { normalizeToAppError } from '../helpers/normalize-app-error';
@@ -73,7 +74,7 @@ let RemoteCommandExecutionController = class RemoteCommandExecutionController {
      */
     registerEventHandler() {
         const resourceName = this.resourceInfo.getCurrentResourceName();
-        const eventName = `opencore:command:execute:${resourceName}`;
+        const eventName = buildRemoteCommandExecuteEventName(resourceName);
         this.engineEvents.on(eventName, async (clientID, commandName, args) => {
             await this.handleCommandExecution(clientID, commandName, args);
         });

package/dist/runtime/server/controllers/session.controller.js

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+import { RUNTIME_EVENTS } from '../../../adapters/contracts/runtime';
 import { inject } from 'tsyringe';
 import { loggers } from '../../../kernel/logger';
 import { emitFrameworkEvent } from '../bus/internal-event.bus';
@@ -60,13 +61,13 @@ let SessionController = class SessionController {
     }
 };
 __decorate([
-    OnRuntimeEvent('playerJoining'),
+    OnRuntimeEvent(RUNTIME_EVENTS.playerJoining),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Number, Object]),
     __metadata("design:returntype", Promise)
 ], SessionController.prototype, "onPlayerJoining", null);
 __decorate([
-    OnRuntimeEvent('playerDropped'),
+    OnRuntimeEvent(RUNTIME_EVENTS.playerDropped),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Number]),
     __metadata("design:returntype", Promise)

package/dist/runtime/server/controllers/vehicle.controller.d.ts

@@ -1,3 +1,4 @@
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { Player } from '../entities/player';
 import { Vehicles } from '../apis/vehicles.api';
 /**
@@ -8,7 +9,8 @@ import { Vehicles } from '../apis/vehicles.api';
  */
 export declare class VehicleController {
     private readonly vehicleService;
-    constructor(vehicleService: Vehicles);
+    private readonly events;
+    constructor(vehicleService: Vehicles, events: EventsAPI<'server'>);
     /**
      * Handles client request to get vehicle data.
      */

package/dist/runtime/server/controllers/vehicle.controller.js

@@ -11,6 +11,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject } from 'tsyringe';
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
 import { Controller, OnNet } from '../decorators';
 import { Player } from '../entities/player';
 import { Vehicles } from '../apis/vehicles.api';
@@ -22,8 +24,10 @@ import { Vehicles } from '../apis/vehicles.api';
  */
 let VehicleController = class VehicleController {
     vehicleService;
-    constructor(vehicleService) {
+    events;
+    constructor(vehicleService, events) {
         this.vehicleService = vehicleService;
+        this.events = events;
     }
     /**
      * Handles client request to get vehicle data.
@@ -31,11 +35,11 @@ let VehicleController = class VehicleController {
     handleGetData(player, networkId) {
         const vehicle = this.vehicleService.getByNetworkId(networkId);
         if (!vehicle) {
-            emitNet('opencore:vehicle:dataResult', player.clientID, null);
+            this.events.emit(SYSTEM_EVENTS.vehicle.dataResult, player.clientID, null);
             return null;
         }
         const data = vehicle.serialize();
-        emitNet('opencore:vehicle:dataResult', player.clientID, data);
+        this.events.emit(SYSTEM_EVENTS.vehicle.dataResult, player.clientID, data);
         return data;
     }
     /**
@@ -44,18 +48,18 @@ let VehicleController = class VehicleController {
     handleGetPlayerVehicles(player) {
         const vehicles = this.vehicleService.getPlayerVehicles(player.clientID);
         const serialized = vehicles.map((v) => v.serialize());
-        emitNet('opencore:vehicle:playerVehiclesResult', player.clientID, serialized);
+        this.events.emit(SYSTEM_EVENTS.vehicle.playerVehiclesResult, player.clientID, serialized);
         return serialized;
     }
 };
 __decorate([
-    OnNet('opencore:vehicle:getData'),
+    OnNet(SYSTEM_EVENTS.vehicle.getData),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Player, Number]),
     __metadata("design:returntype", void 0)
 ], VehicleController.prototype, "handleGetData", null);
 __decorate([
-    OnNet('opencore:vehicle:getPlayerVehicles'),
+    OnNet(SYSTEM_EVENTS.vehicle.getPlayerVehicles),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Player]),
     __metadata("design:returntype", void 0)
@@ -63,6 +67,8 @@ __decorate([
 VehicleController = __decorate([
     Controller(),
     __param(0, inject(Vehicles)),
-    __metadata("design:paramtypes", [Vehicles])
+    __param(1, inject(EventsAPI)),
+    __metadata("design:paramtypes", [Vehicles,
+        EventsAPI])
 ], VehicleController);
 export { VehicleController };

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

@@ -1,7 +1,9 @@
 import { type OpenCorePlugin } from './library/plugin';
 import { type FrameworkMode, type ServerInitOptions } from './runtime';
+import { OpenCoreServerAdapter } from './adapter';
 export declare let _mode: FrameworkMode;
 export interface OpenCoreInitOptions extends ServerInitOptions {
     plugins?: OpenCorePlugin[];
 }
+export declare function useAdapter(adapter: OpenCoreServerAdapter): void;
 export declare function init(options: OpenCoreInitOptions): Promise<void>;

package/dist/runtime/server/core.js

@@ -4,11 +4,16 @@ import { Server } from './server.runtime';
 import { initServer } from './bootstrap';
 import { resolveRuntimeOptions, } from './runtime';
 export let _mode;
+let _pendingAdapter;
+export function useAdapter(adapter) {
+    _pendingAdapter = adapter;
+}
 function createConfigAccessor(options) {
+    const runtimeOptions = { ...options };
     return {
         get(key) {
             const segments = key.split('.').filter(Boolean);
-            let current = options;
+            let current = runtimeOptions;
             for (const segment of segments) {
                 if (typeof current !== 'object' || current === null) {
                     return undefined;
@@ -20,6 +25,9 @@ function createConfigAccessor(options) {
     };
 }
 export async function init(options) {
+    if (!options.adapter && _pendingAdapter) {
+        options = { ...options, adapter: _pendingAdapter };
+    }
     const resolved = resolveRuntimeOptions(options);
     _mode = resolved.mode;
     const registry = new PluginRegistry();

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

@@ -36,6 +36,8 @@ export interface CommandMetadata extends CommandConfig {
     security?: SecurityMetadata;
     /** True if the last parameter uses the spread operator (...args) */
     hasSpreadParam?: boolean;
+    /** True when a parameter defines a JS default value. */
+    defaultParams?: boolean[];
 }
 type ServerCommandHandler = (() => any) | ((player: Player, ...args: any[]) => any);
 /**

package/dist/runtime/server/decorators/command.js

@@ -1,5 +1,5 @@
 import { Player } from '../entities/player';
-import { getParameterNames, getSpreadParameterIndices } from '../helpers/function-helper';
+import { getDefaultParameterIndices, getParameterNames, getSpreadParameterIndices, } from '../helpers/function-helper';
 import { METADATA_KEYS } from '../system/metadata-server.keys';
 // Implementation
 export function Command(configOrName, schema) {
@@ -20,6 +20,7 @@ export function Command(configOrName, schema) {
             throw new Error(`@Command '${config.command}': first parameter must be Player if parameters are present`);
         }
         const paramNames = getParameterNames(descriptor.value);
+        const defaultParams = getDefaultParameterIndices(descriptor.value);
         const spreadIndices = getSpreadParameterIndices(descriptor.value);
         const hasSpreadParam = spreadIndices.length > 0 && spreadIndices[spreadIndices.length - 1];
         const metadata = {
@@ -30,6 +31,7 @@ export function Command(configOrName, schema) {
             paramNames,
             expectsPlayer,
             hasSpreadParam,
+            defaultParams,
         };
         Reflect.defineMetadata(METADATA_KEYS.COMMAND, metadata, target, propertyKey);
     };

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

@@ -1,3 +1,4 @@
+import type { RuntimeEventName } from '../../../adapters/contracts/runtime';
 /**
  * Registers a method as a server-side listener for a native Runtime event.
  * Runtime === CitizenFX (Cfx)
@@ -22,4 +23,4 @@
  * }
  * ```
  */
-export declare function OnRuntimeEvent(event: string): (target: any, propertyKey: string) => void;
+export declare function OnRuntimeEvent(event: RuntimeEventName): (target: any, propertyKey: string) => void;

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

@@ -1,13 +1,15 @@
-import { NativeHandle } from 'src/runtime/core/nativehandle';
 import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
+import { INpcLifecycleServer } from '../../../adapters/contracts/server/npc-lifecycle/INpcLifecycleServer';
 import { IPedServer } from '../../../adapters/contracts/server/IPedServer';
 import { Vector3 } from '../../../kernel/utils/vector3';
 import { BaseEntity } from '../../core/entity';
 import { Spatial } from '../../core/spatial';
 import { SerializedNpcData } from '../types/npc.types';
+import { NativeHandle } from '../../core';
 export interface NpcAdapters {
     entityServer: IEntityServer;
     pedServer: IPedServer;
+    npcLifecycle: INpcLifecycleServer;
 }
 /**
  * Immutable-ish runtime session snapshot for an NPC.

package/dist/runtime/server/entities/npc.js

@@ -137,7 +137,7 @@ export class NPC extends BaseEntity {
     setRoutingBucket(bucket) {
         if (!this.exists)
             return;
-        this.adapters.entityServer.setRoutingBucket(this.session.handle, bucket);
+        this.adapters.entityServer.setDimension(this.session.handle, bucket);
         this.session.routingBucket = bucket;
         this._dimension = bucket;
     }
@@ -147,7 +147,7 @@ export class NPC extends BaseEntity {
      * @returns Routing bucket.
      */
     getRoutingBucket() {
-        return this.adapters.entityServer.getRoutingBucket(this.session.handle);
+        return this.adapters.entityServer.getDimension(this.session.handle);
     }
     /**
      * Current dimension of the NPC.
@@ -272,7 +272,7 @@ export class NPC extends BaseEntity {
     delete() {
         if (!this.exists)
             return;
-        this.adapters.pedServer.delete(this.session.handle);
+        void this.adapters.npcLifecycle.delete({ handle: this.session.handle });
     }
     /**
      * Serialize the NPC into a transport-friendly plain object.

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

@@ -1,6 +1,8 @@
 import { IPlayerInfo } from '../../../adapters';
 import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
+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 type { PlayerIdentifier } from '../../../adapters/contracts/types/identifier';
 import { Vector3 } from '../../../kernel/utils/vector3';
@@ -9,7 +11,7 @@ import { Spatial } from '../../core/spatial';
 import { LinkedID } from '../types/linked-id';
 import { PlayerSession } from '../types/player-session.types';
 import { SerializedPlayerData } from '../types/core-exports.types';
-import { NativeHandle } from 'src/runtime/core/nativehandle';
+import { NativeHandle } from '../../core';
 /**
  * Adapter bundle for player operations.
  * Passed to Player instances by PlayerDirectory.
@@ -17,6 +19,8 @@ import { NativeHandle } from 'src/runtime/core/nativehandle';
 export interface PlayerAdapters {
     playerInfo: IPlayerInfo;
     playerServer: IPlayerServer;
+    playerLifecycle: IPlayerLifecycleServer;
+    playerStateSync: IPlayerStateSyncServer;
     entityServer: IEntityServer;
     events: EventsAPI<'server'>;
     defaultSpawnModel: string;
@@ -36,6 +40,7 @@ export declare class Player extends BaseEntity implements Spatial, NativeHandle
     private readonly session;
     private readonly adapters;
     private _position;
+    private _model;
     /**
      * Creates a new Player entity instance.
      * This is typically instantiated by the `PlayerService` upon connection.
@@ -117,23 +122,13 @@ export declare class Player extends BaseEntity implements Spatial, NativeHandle
      * @param model - The ped model to use (default from platform capabilities)
      */
     spawn(vector: Vector3, model?: string): void;
+    respawn(vector: Vector3, model?: string): void;
     /**
      * Disconnects the player from the server.
      *
      * @param reason - The message displayed to the player upon disconnection.
      */
     kick(reason?: string): void;
-    /**
-     * Sets the routing bucket (virtual world/dimension) for the player.
-     * Players in different buckets cannot see or interact with each other.
-     *
-     * @param bucket - The bucket ID (0 is the default shared world).
-     */
-    setRoutingBucket(bucket: number): void;
-    /**
-     * Gets the current routing bucket.
-     */
-    getRoutingBucket(): number;
     /**
      * Sets the player dimension (alias for setRoutingBucket).
      */
@@ -218,6 +213,8 @@ export declare class Player extends BaseEntity implements Spatial, NativeHandle
      * @param armor - Armor value to set (typically 0-100).
      */
     setArmor(armor: number): void;
+    get model(): string | undefined;
+    set model(model: string);
     /**
      * Kills the player by setting health to 0.
      */