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

package/dist/runtime/server/implementations/local/principal.local.d.ts

@@ -0,0 +1,28 @@
+import { PrincipalProviderContract } from '../../contracts';
+import { Principal } from '../../types/principal.type';
+import { GuardOptions } from '../../decorators/guard';
+import { Player } from '../../entities';
+import { Authorization } from '../../ports/authorization.api-port';
+/**
+ * Local principal service for CORE/STANDALONE mode.
+ *
+ * @remarks
+ * This service wraps the user-provided PrincipalProviderContract and provides
+ * convenience methods for permission checking. All operations are performed locally.
+ */
+export declare class LocalPrincipalService extends Authorization {
+    private readonly provider;
+    constructor(provider: PrincipalProviderContract);
+    getPrincipal(player: Player): Promise<Principal | null>;
+    getPrincipalByAccountId(accountId: string): Promise<Principal | null>;
+    refreshPrincipal(player: Player): Promise<void>;
+    hasPermission(player: Player, permission: string): Promise<boolean>;
+    hasRank(player: Player, requiredRank: number): Promise<boolean>;
+    hasAnyPermission(player: Player, permissions: string[]): Promise<boolean>;
+    hasAllPermissions(player: Player, permissions: string[]): Promise<boolean>;
+    getPermissions(player: Player): Promise<string[]>;
+    getRank(player: Player): Promise<number | null>;
+    getPrincipalName(player: Player): Promise<string | null>;
+    getPrincipalMeta(player: Player, key: string): Promise<unknown>;
+    enforce(player: Player, requirements: GuardOptions): Promise<void>;
+}

package/dist/runtime/server/implementations/local/principal.local.js

@@ -0,0 +1,120 @@
+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 { AppError } from '../../../../kernel/error/app.error';
+import { PrincipalProviderContract } from '../../contracts';
+import { Authorization } from '../../ports/authorization.api-port';
+/**
+ * Local principal service for CORE/STANDALONE mode.
+ *
+ * @remarks
+ * This service wraps the user-provided PrincipalProviderContract and provides
+ * convenience methods for permission checking. All operations are performed locally.
+ */
+let LocalPrincipalService = class LocalPrincipalService extends Authorization {
+    provider;
+    constructor(provider) {
+        super();
+        this.provider = provider;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Principal Queries
+    // ═══════════════════════════════════════════════════════════════
+    async getPrincipal(player) {
+        return await this.provider.getPrincipal(player);
+    }
+    async getPrincipalByAccountId(accountId) {
+        return await this.provider.getPrincipalByLinkedID(accountId);
+    }
+    async refreshPrincipal(player) {
+        await this.provider.refreshPrincipal(player);
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Quick Authorization Checks
+    // ═══════════════════════════════════════════════════════════════
+    async hasPermission(player, permission) {
+        const principal = await this.provider.getPrincipal(player);
+        if (!principal)
+            return false;
+        // Check for wildcard (super-admin) or specific permission
+        return principal.permissions.includes('*') || principal.permissions.includes(permission);
+    }
+    async hasRank(player, requiredRank) {
+        const principal = await this.provider.getPrincipal(player);
+        if (!principal || principal.rank === undefined)
+            return false;
+        return principal.rank >= requiredRank;
+    }
+    async hasAnyPermission(player, permissions) {
+        const principal = await this.provider.getPrincipal(player);
+        if (!principal)
+            return false;
+        // Wildcard grants all permissions
+        if (principal.permissions.includes('*'))
+            return true;
+        return permissions.some((perm) => principal.permissions.includes(perm));
+    }
+    async hasAllPermissions(player, permissions) {
+        const principal = await this.provider.getPrincipal(player);
+        if (!principal)
+            return false;
+        // Wildcard grants all permissions
+        if (principal.permissions.includes('*'))
+            return true;
+        return permissions.every((perm) => principal.permissions.includes(perm));
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Property Getters
+    // ═══════════════════════════════════════════════════════════════
+    async getPermissions(player) {
+        const principal = await this.provider.getPrincipal(player);
+        return principal?.permissions ?? [];
+    }
+    async getRank(player) {
+        const principal = await this.provider.getPrincipal(player);
+        return principal?.rank ?? null;
+    }
+    async getPrincipalName(player) {
+        const principal = await this.provider.getPrincipal(player);
+        return principal?.name ?? null;
+    }
+    async getPrincipalMeta(player, key) {
+        const principal = await this.provider.getPrincipal(player);
+        return principal?.meta?.[key] ?? null;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Access Control Enforcement
+    // ═══════════════════════════════════════════════════════════════
+    async enforce(player, requirements) {
+        if (requirements.rank !== undefined) {
+            const principal = await this.provider.getPrincipal(player);
+            if (!principal) {
+                throw new AppError('AUTH:UNAUTHORIZED', 'No principal found', 'core');
+            }
+            if (principal.rank === undefined) {
+                throw new AppError('GAME:NO_RANK_IN_PRINCIPAL', "You're trying to compare a Principal rank, but there's no defined rank!", 'core');
+            }
+            if (principal.rank < requirements.rank) {
+                throw new AppError('AUTH:PERMISSION_DENIED', `Access Denied: Requires minimum rank level ${requirements.rank}`, 'core');
+            }
+        }
+        if (requirements.permission) {
+            const hasPerm = await this.hasPermission(player, requirements.permission);
+            if (!hasPerm) {
+                throw new AppError('AUTH:PERMISSION_DENIED', `Access Denied: Missing required permission '${requirements.permission}'`, 'core');
+            }
+        }
+    }
+};
+LocalPrincipalService = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [PrincipalProviderContract])
+], LocalPrincipalService);
+export { LocalPrincipalService };

package/dist/runtime/server/implementations/remote/channel.remote.d.ts

@@ -0,0 +1,47 @@
+import { IExports } from '../../../../adapters/contracts/IExports';
+import { RGB } from '../../../../kernel/utils/rgb';
+import { Channel } from '../../concepts/channel';
+import { Player } from '../../entities/player';
+import { ChannelMetadata, ChannelType, IChannelValidator } from '../../types/channel.types';
+import { Players } from '../../ports/players.api-port';
+import { Channels } from '../../ports/channel.api-port';
+/**
+ * Remote channel implementation for RESOURCE mode.
+ *
+ * @remarks
+ * In RESOURCE mode, this service delegates all channel operations to CORE via exports.
+ * Channels are centrally managed in CORE, allowing cross-resource communication.
+ *
+ * Flow:
+ * 1. Resource calls channel method → delegates to CORE export
+ * 2. CORE manages channel state centrally
+ * 3. All resources share the same channel registry
+ */
+export declare class RemoteChannelImplementation extends Channels {
+    private exportsService;
+    private readonly players;
+    private resourceName;
+    constructor(exportsService: IExports, players: Players);
+    /**
+     * Gets typed access to CORE resource exports.
+     */
+    private get core();
+    create(id: string, metadata: ChannelMetadata, maxSubscribers?: number): Channel;
+    delete(id: string): boolean;
+    exists(id: string): boolean;
+    get(id: string): Channel | undefined;
+    subscribe(channelId: string, player: Player, metadata?: Record<string, unknown>): boolean;
+    unsubscribe(channelId: string, player: Player): boolean;
+    isSubscribed(channelId: string, player: Player): boolean;
+    getSubscribers(channelId: string): Player[];
+    broadcast(channelId: string, sender: Player, message: string, author?: string, color?: RGB): void;
+    broadcastSystem(channelId: string, message: string, author?: string, color?: RGB): void;
+    createProximityChannel(originPlayer: Player, radius: number, channelId?: string): Channel | undefined;
+    createPrivate(players: Player[], metadata: ChannelMetadata): Channel;
+    getChannelsByType(type: ChannelType): Channel[];
+    getChannelsByPlayer(player: Player): Channel[];
+    getAllChannels(): Channel[];
+    setValidator(_validator: IChannelValidator): void;
+    clear(): void;
+    clearNonPersistent(): void;
+}

package/dist/runtime/server/implementations/remote/channel.remote.js

@@ -0,0 +1,165 @@
+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 { IExports } from '../../../../adapters/contracts/IExports';
+import { loggers } from '../../../../kernel/logger';
+import { Channel } from '../../concepts/channel';
+import { getRuntimeContext } from '../../runtime';
+import { ChannelType } from '../../types/channel.types';
+import { Players } from '../../ports/players.api-port';
+import { Channels } from '../../ports/channel.api-port';
+/**
+ * Remote channel implementation for RESOURCE mode.
+ *
+ * @remarks
+ * In RESOURCE mode, this service delegates all channel operations to CORE via exports.
+ * Channels are centrally managed in CORE, allowing cross-resource communication.
+ *
+ * Flow:
+ * 1. Resource calls channel method → delegates to CORE export
+ * 2. CORE manages channel state centrally
+ * 3. All resources share the same channel registry
+ */
+let RemoteChannelImplementation = class RemoteChannelImplementation extends Channels {
+    exportsService;
+    players;
+    resourceName;
+    constructor(exportsService, players) {
+        super();
+        this.exportsService = exportsService;
+        this.players = players;
+        this.resourceName = GetCurrentResourceName();
+    }
+    /**
+     * Gets typed access to CORE resource exports.
+     */
+    get core() {
+        const { coreResourceName } = getRuntimeContext();
+        const coreExports = this.exportsService.getResource(coreResourceName);
+        if (!coreExports) {
+            throw new Error(`[OpenCore] CORE resource '${coreResourceName}' exports not found. ` +
+                `Ensure the CORE resource is started BEFORE RESOURCE mode resources. ` +
+                `Add 'ensure ${coreResourceName}' before this resource in server.cfg`);
+        }
+        return coreExports;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Channel Creation & Management (delegated to CORE)
+    // ═══════════════════════════════════════════════════════════════
+    create(id, metadata, maxSubscribers) {
+        const success = this.core.createChannel(id, metadata, maxSubscribers, this.resourceName);
+        if (!success) {
+            throw new Error(`Failed to create channel '${id}' in CORE`);
+        }
+        loggers.api.debug(`Channel '${id}' created in CORE from resource '${this.resourceName}'`);
+        return new Channel(id, metadata, maxSubscribers);
+    }
+    delete(id) {
+        return this.core.deleteChannel(id);
+    }
+    exists(id) {
+        return this.core.channelExists(id);
+    }
+    get(id) {
+        if (this.core.channelExists(id)) {
+            return new Channel(id, { type: ChannelType.GLOBAL, persistent: true });
+        }
+        return undefined;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Subscription Management (delegated to CORE)
+    // ═══════════════════════════════════════════════════════════════
+    subscribe(channelId, player, metadata) {
+        return this.core.subscribeToChannel(channelId, player.clientID, metadata);
+    }
+    unsubscribe(channelId, player) {
+        return this.core.unsubscribeFromChannel(channelId, player.clientID);
+    }
+    isSubscribed(channelId, player) {
+        return this.core.isSubscribedToChannel(channelId, player.clientID);
+    }
+    getSubscribers(channelId) {
+        const clientIDs = this.core.getChannelSubscribers(channelId);
+        return clientIDs.map((id) => this.players.getByClient(id)).filter((p) => p !== undefined);
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Broadcasting (delegated to CORE)
+    // ═══════════════════════════════════════════════════════════════
+    broadcast(channelId, sender, message, author, color) {
+        const success = this.core.broadcastToChannel(channelId, sender.clientID, message, author, color);
+        if (!success) {
+            loggers.api.warn(`Failed to broadcast to channel '${channelId}'`);
+        }
+    }
+    broadcastSystem(channelId, message, author, color) {
+        const success = this.core.broadcastSystemToChannel(channelId, message, author, color);
+        if (!success) {
+            loggers.api.warn(`Failed to broadcast system message to channel '${channelId}'`);
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Specialized Channel Creation (delegated to CORE)
+    // ═══════════════════════════════════════════════════════════════
+    createProximityChannel(originPlayer, radius, channelId) {
+        const id = this.core.createProximityChannel(originPlayer.clientID, radius, channelId);
+        if (!id)
+            return undefined;
+        return new Channel(id, {
+            type: ChannelType.PROXIMITY,
+            maxRange: radius,
+            persistent: false,
+        }, undefined);
+    }
+    createPrivate(players, metadata) {
+        const clientIDs = players.map((p) => p.clientID);
+        const id = this.core.createPrivateChannel(clientIDs, metadata);
+        if (!id) {
+            throw new Error('Failed to create private channel in CORE');
+        }
+        return new Channel(id, { ...metadata, persistent: false }, players.length);
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Query & Introspection (delegated to CORE)
+    // ═══════════════════════════════════════════════════════════════
+    getChannelsByType(type) {
+        const channelIds = this.core.getChannelsByType(type);
+        return channelIds.map((id) => new Channel(id, { type, persistent: true }));
+    }
+    getChannelsByPlayer(player) {
+        const channelIds = this.core.getPlayerChannels(player.clientID);
+        return channelIds.map((id) => new Channel(id, { type: ChannelType.GLOBAL, persistent: true }));
+    }
+    getAllChannels() {
+        const channelIds = this.core.getAllChannels();
+        return channelIds.map((id) => new Channel(id, { type: ChannelType.GLOBAL, persistent: true }));
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Utility Methods
+    // ═══════════════════════════════════════════════════════════════
+    setValidator(_validator) {
+        loggers.api.warn('Channel validators are not supported in RESOURCE mode. Validators must be set in CORE.');
+    }
+    clear() {
+        loggers.api.warn('clear() is not supported in RESOURCE mode. Channels are managed by CORE.');
+    }
+    clearNonPersistent() {
+        loggers.api.warn('clearNonPersistent() is not supported in RESOURCE mode. Channels are managed by CORE.');
+    }
+};
+RemoteChannelImplementation = __decorate([
+    injectable(),
+    __param(0, inject(IExports)),
+    __metadata("design:paramtypes", [IExports,
+        Players])
+], RemoteChannelImplementation);
+export { RemoteChannelImplementation };

package/dist/runtime/server/implementations/remote/command.remote.d.ts

@@ -0,0 +1,64 @@
+import { IExports } from '../../../../adapters/contracts/IExports';
+import { CommandMetadata } from '../../decorators/command';
+import { Player } from '../../entities';
+import { CommandExecutionPort, type CommandInfo } from '../../ports/internal/command-execution.port';
+/**
+ * Remote command service for RESOURCE mode.
+ *
+ * @remarks
+ * In RESOURCE mode, this service:
+ * - Stores command handlers and metadata locally in the resource
+ * - Registers command metadata with CORE via exports
+ * - Executes handlers when invoked by CORE via net event
+ * - Validates arguments using Zod schemas (same as CommandService)
+ *
+ * Flow:
+ * 1. Resource declares @Command → metadata registered with CORE
+ * 2. Player executes command → CORE validates security and emits event to resource
+ * 3. Resource receives event → validates schema → executes handler
+ *
+ * Security validation is split:
+ * - CORE validates: @Guard (rank/permission), @Throttle (rate limit), @RequiresState
+ * - RESOURCE validates: Zod schema (not serializable, must be local)
+ */
+export declare class RemoteCommandImplementation extends CommandExecutionPort {
+    private exportsService;
+    private commands;
+    getCommandMeta(commandName: string): CommandMetadata | undefined;
+    constructor(exportsService: IExports);
+    /**
+     * Gets typed access to CORE resource exports.
+     */
+    private get core();
+    /**
+     * Registers a command handler locally and with CORE.
+     *
+     * @remarks
+     * The handler and full metadata are stored locally for schema validation.
+     * Only serializable metadata is sent to CORE for security validation.
+     */
+    register(metadata: CommandMetadata, handler: (...args: any[]) => any): void;
+    /**
+     * Executes a command handler stored in this resource.
+     *
+     * @remarks
+     * Called by the resource's command execution controller when CORE
+     * emits a command execution event to this resource.
+     *
+     * CORE has already validated:
+     * - @Guard (rank/permission requirements)
+     * - @Throttle (rate limiting)
+     * - @RequiresState (player state)
+     * - @Public (authentication - if not public, player must be authenticated)
+     *
+     * This method validates:
+     * - Zod schema (argument types and structure)
+     *
+     * @throws AppError - If schema validation fails or command not found
+     */
+    execute(player: Player, commandName: string, args: string[]): Promise<void>;
+    /**
+     * Returns all commands registered in CORE (local + remote).
+     */
+    getAllCommands(): CommandInfo[];
+}

package/dist/runtime/server/implementations/remote/command.remote.js

@@ -0,0 +1,154 @@
+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 { IExports } from '../../../../adapters/contracts/IExports';
+import { AppError } from '../../../../kernel/error/app.error';
+import { loggers } from '../../../../kernel/logger';
+import { validateAndExecuteCommand } from '../../helpers/command-validation.helper';
+import { getRuntimeContext } from '../../runtime';
+import { CommandExecutionPort } from '../../ports/internal/command-execution.port';
+/**
+ * Remote command service for RESOURCE mode.
+ *
+ * @remarks
+ * In RESOURCE mode, this service:
+ * - Stores command handlers and metadata locally in the resource
+ * - Registers command metadata with CORE via exports
+ * - Executes handlers when invoked by CORE via net event
+ * - Validates arguments using Zod schemas (same as CommandService)
+ *
+ * Flow:
+ * 1. Resource declares @Command → metadata registered with CORE
+ * 2. Player executes command → CORE validates security and emits event to resource
+ * 3. Resource receives event → validates schema → executes handler
+ *
+ * Security validation is split:
+ * - CORE validates: @Guard (rank/permission), @Throttle (rate limit), @RequiresState
+ * - RESOURCE validates: Zod schema (not serializable, must be local)
+ */
+let RemoteCommandImplementation = class RemoteCommandImplementation extends CommandExecutionPort {
+    exportsService;
+    commands = new Map();
+    getCommandMeta(commandName) {
+        return this.commands.get(commandName.toLowerCase())?.meta;
+    }
+    constructor(exportsService) {
+        super();
+        this.exportsService = exportsService;
+    }
+    /**
+     * Gets typed access to CORE resource exports.
+     */
+    get core() {
+        const { coreResourceName } = getRuntimeContext();
+        const coreExports = this.exportsService.getResource(coreResourceName);
+        if (!coreExports) {
+            throw new Error(`[OpenCore] CORE resource '${coreResourceName}' exports not found. ` +
+                `Ensure the CORE resource is started BEFORE RESOURCE mode resources. ` +
+                `Add 'ensure ${coreResourceName}' before this resource in server.cfg`);
+        }
+        return coreExports;
+    }
+    /**
+     * Registers a command handler locally and with CORE.
+     *
+     * @remarks
+     * The handler and full metadata are stored locally for schema validation.
+     * Only serializable metadata is sent to CORE for security validation.
+     */
+    register(metadata, handler) {
+        const commandKey = metadata.command.toLowerCase();
+        const resourceName = GetCurrentResourceName();
+        loggers.command.debug(`Registering command locally`, {
+            command: metadata.command,
+            resource: resourceName,
+        });
+        // Store handler with full metadata locally (for schema validation)
+        this.commands.set(commandKey, {
+            meta: metadata,
+            handler,
+        });
+        // Register metadata with CORE (security only, schema is not serializable)
+        try {
+            this.core.registerCommand({
+                command: metadata.command,
+                description: metadata.description,
+                usage: metadata.usage,
+                isPublic: metadata.isPublic ?? false,
+                resourceName,
+                security: metadata.security,
+            });
+        }
+        catch (e) {
+            loggers.command.error(`Failed to register command with CORE`, {
+                command: metadata.command,
+                resource: resourceName,
+                error: e,
+            });
+            return;
+        }
+        const publicFlag = metadata.isPublic ? ' [Public]' : '';
+        const schemaFlag = metadata.schema ? ' [Validated]' : '';
+        const securityFlags = [];
+        if (metadata.security?.guard)
+            securityFlags.push('Guard');
+        if (metadata.security?.throttle)
+            securityFlags.push('Throttle');
+        if (metadata.security?.requiresState)
+            securityFlags.push('RequiresState');
+        const securityInfo = securityFlags.length > 0 ? ` (${securityFlags.join(', ')})` : '';
+        loggers.command.debug(`Registered remote command: /${metadata.command}${publicFlag}${schemaFlag}${securityInfo} (delegated to CORE)`);
+    }
+    /**
+     * Executes a command handler stored in this resource.
+     *
+     * @remarks
+     * Called by the resource's command execution controller when CORE
+     * emits a command execution event to this resource.
+     *
+     * CORE has already validated:
+     * - @Guard (rank/permission requirements)
+     * - @Throttle (rate limiting)
+     * - @RequiresState (player state)
+     * - @Public (authentication - if not public, player must be authenticated)
+     *
+     * This method validates:
+     * - Zod schema (argument types and structure)
+     *
+     * @throws AppError - If schema validation fails or command not found
+     */
+    async execute(player, commandName, args) {
+        const entry = this.commands.get(commandName.toLowerCase());
+        if (!entry) {
+            loggers.command.error(`Handler not found for remote command: ${commandName}`, {
+                command: commandName,
+                resource: GetCurrentResourceName(),
+            });
+            throw new AppError('COMMAND:NOT_FOUND', `Command not found: ${commandName}`, 'server');
+        }
+        const { meta, handler } = entry;
+        return await validateAndExecuteCommand(meta, player, args, handler);
+    }
+    /**
+     * Returns all commands registered in CORE (local + remote).
+     */
+    getAllCommands() {
+        return this.core.getAllCommands();
+    }
+};
+RemoteCommandImplementation = __decorate([
+    injectable(),
+    __param(0, inject(IExports)),
+    __metadata("design:paramtypes", [IExports])
+], RemoteCommandImplementation);
+export { RemoteCommandImplementation };

package/dist/runtime/server/implementations/remote/player.remote.d.ts

@@ -0,0 +1,65 @@
+import { IExports, IPlayerInfo } from '../../../../adapters';
+import { IPlatformCapabilities } from '../../../../adapters/contracts/IPlatformCapabilities';
+import { EventsAPI } from '../../../../adapters/contracts/transport/events.api';
+import { IEntityServer } from '../../../../adapters/contracts/server/IEntityServer';
+import { IPlayerServer } from '../../../../adapters/contracts/server/IPlayerServer';
+import { Player } from '../../entities';
+import { Players } from '../../ports/players.api-port';
+import { LinkedID } from '../../services';
+/**
+ * Player service implementation for `RESOURCE` mode.
+ *
+ * @remarks
+ * This service delegates all player operations to CORE via exports.
+ * It creates local Player instances hydrated with real session data from CORE,
+ * ensuring RESOURCE mode has access to accurate player information.
+ */
+export declare class RemotePlayerImplementation extends Players {
+    private readonly playerInfo;
+    private readonly exportsService;
+    private readonly playerServer;
+    private readonly entityServer;
+    private readonly events;
+    private readonly platformCapabilities;
+    /**
+     * Cached adapters bundle for Player instances
+     */
+    private readonly playerAdapters;
+    constructor(playerInfo: IPlayerInfo, exportsService: IExports, playerServer: IPlayerServer, entityServer: IEntityServer, events: EventsAPI<'server'>, platformCapabilities: IPlatformCapabilities);
+    /**
+     * Gets typed access to CORE resource exports.
+     */
+    private get core();
+    /**
+     * Creates a local Player instance from serialized data.
+     *
+     * @remarks
+     * The returned Player is hydrated with session data from CORE,
+     * including accountID, identifiers, metadata, and states.
+     */
+    private createPlayerFromData;
+    /**
+     * Returns a Player instance with real session data from CORE.
+     */
+    getByClient(clientID: number): Player | undefined;
+    getMany(clientIds: number[]): Player[];
+    /**
+     * Returns all connected players with real session data from CORE.
+     */
+    getAll(): Player[];
+    getAccountLinked(clientID: number): LinkedID | undefined;
+    getMeta<T = unknown>(clientID: number, key: string): Promise<T | undefined>;
+    setMeta(clientID: number, key: string, value: unknown): void;
+    /**
+     * Finds a player by their persistent account ID.
+     */
+    getByAccountId(accountId: string): Player | undefined;
+    /**
+     * Gets the current player count from CORE.
+     */
+    getPlayerCount(): number;
+    /**
+     * Checks if a player with given account ID is online.
+     */
+    isOnline(accountId: string): boolean;
+}