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

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

@@ -0,0 +1,161 @@
+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 { GLOBAL_CONTAINER } from '../../../kernel/di/container';
+import { loggers } from '../../../kernel/logger';
+import { PlayerPersistenceContract } from '../contracts';
+/**
+ * Internal service that orchestrates player data persistence.
+ *
+ * This service manages the lifecycle of persistence hooks and auto-save intervals.
+ * It is used internally by the framework and should not be instantiated directly.
+ */
+let PlayerPersistenceService = class PlayerPersistenceService {
+    provider = null;
+    autoSaveIntervals = new Map();
+    initialized = false;
+    /**
+     * Initializes the persistence service by resolving the provider from DI.
+     * Called during bootstrap if a provider is registered.
+     */
+    initialize() {
+        if (this.initialized)
+            return;
+        try {
+            if (GLOBAL_CONTAINER.isRegistered(PlayerPersistenceContract)) {
+                const provider = GLOBAL_CONTAINER.resolve(PlayerPersistenceContract);
+                this.provider = provider;
+                loggers.bootstrap.info('Player Persistence Provider initialized', {
+                    autoSaveEnabled: provider.config.autoSaveEnabled,
+                    autoSaveIntervalMs: provider.config.autoSaveIntervalMs,
+                });
+            }
+        }
+        catch {
+            // Provider not registered, persistence is disabled
+            this.provider = null;
+        }
+        this.initialized = true;
+    }
+    /**
+     * Whether persistence is enabled (provider is configured).
+     */
+    get isEnabled() {
+        return this.provider !== null;
+    }
+    /**
+     * Handles player session load - called when a player joins.
+     *
+     * @param player - The player who just joined
+     */
+    async handleSessionLoad(player) {
+        if (!this.provider)
+            return;
+        try {
+            await this.provider.onSessionLoad(player);
+            loggers.session.debug('Player data loaded', { clientId: player.clientID });
+            // Start auto-save interval if enabled
+            if (this.provider.config.autoSaveEnabled) {
+                this.startAutoSave(player);
+            }
+        }
+        catch (error) {
+            loggers.session.error('Failed to load player data', { clientId: player.clientID }, error);
+        }
+    }
+    /**
+     * Handles player session save - called when a player disconnects.
+     *
+     * @param player - The player who is disconnecting
+     */
+    async handleSessionSave(player) {
+        if (!this.provider)
+            return;
+        // Stop auto-save interval first
+        this.stopAutoSave(player.clientID);
+        try {
+            await this.provider.onSessionSave(player);
+            loggers.session.debug('Player data saved', { clientId: player.clientID });
+        }
+        catch (error) {
+            loggers.session.error('Failed to save player data', { clientId: player.clientID }, error);
+        }
+    }
+    /**
+     * Manually triggers a save for a specific player.
+     *
+     * @param player - The player whose data should be saved
+     */
+    async savePlayer(player) {
+        if (!this.provider)
+            return;
+        try {
+            await this.provider.onSessionSave(player);
+            loggers.session.debug('Player data manually saved', { clientId: player.clientID });
+        }
+        catch (error) {
+            loggers.session.error('Failed to manually save player data', { clientId: player.clientID }, error);
+        }
+    }
+    /**
+     * Saves all connected players' data.
+     * Useful for server shutdown or periodic global saves.
+     *
+     * @param players - Array of all connected players
+     */
+    async saveAllPlayers(players) {
+        if (!this.provider)
+            return;
+        const savePromises = players.map((player) => this.provider?.onSessionSave(player).catch((error) => {
+            loggers.session.error('Failed to save player data during bulk save', { clientId: player.clientID }, error);
+        }));
+        await Promise.all(savePromises);
+        loggers.session.info('Bulk player save completed', { playerCount: players.length });
+    }
+    /**
+     * Starts the auto-save interval for a player.
+     */
+    startAutoSave(player) {
+        if (!this.provider)
+            return;
+        const intervalMs = this.provider.config.autoSaveIntervalMs;
+        const interval = setInterval(async () => {
+            try {
+                await this.provider?.onAutoSave(player);
+                loggers.session.debug('Player auto-save completed', { clientId: player.clientID });
+            }
+            catch (error) {
+                loggers.session.error('Auto-save failed', { clientId: player.clientID }, error);
+            }
+        }, intervalMs);
+        this.autoSaveIntervals.set(player.clientID, interval);
+    }
+    /**
+     * Stops the auto-save interval for a player.
+     */
+    stopAutoSave(clientId) {
+        const interval = this.autoSaveIntervals.get(clientId);
+        if (interval) {
+            clearInterval(interval);
+            this.autoSaveIntervals.delete(clientId);
+        }
+    }
+    /**
+     * Stops all auto-save intervals.
+     * Called during server shutdown.
+     */
+    stopAllAutoSaves() {
+        for (const interval of this.autoSaveIntervals.values()) {
+            clearInterval(interval);
+        }
+        this.autoSaveIntervals.clear();
+    }
+};
+PlayerPersistenceService = __decorate([
+    injectable()
+], PlayerPersistenceService);
+export { PlayerPersistenceService };

package/dist/runtime/server/services/rate-limiter.service.d.ts

@@ -0,0 +1,23 @@
+/**
+ * In-memory rate limiter used by security-related decorators.
+ *
+ * @remarks
+ * This service is intentionally simple and process-local.
+ * It is primarily used by {@link Throttle} to enforce per-player call limits.
+ */
+export declare class RateLimiterService {
+    private hits;
+    /**
+     * Checks whether a key is still within the rate limit window.
+     *
+     * @param key - Unique identifier for the caller/action.
+     * @param limit - Maximum number of calls allowed within the time window.
+     * @param windowMs - Sliding window size in milliseconds.
+     * @returns `true` if the call is allowed; `false` if the limit was exceeded.
+     */
+    checkLimit(key: string, limit: number, windowMs: number): boolean;
+    /**
+     * Best-effort cleanup to prevent unbounded memory growth.
+     */
+    private cleanup;
+}

package/dist/runtime/server/services/rate-limiter.service.js

@@ -0,0 +1,52 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'tsyringe';
+/**
+ * In-memory rate limiter used by security-related decorators.
+ *
+ * @remarks
+ * This service is intentionally simple and process-local.
+ * It is primarily used by {@link Throttle} to enforce per-player call limits.
+ */
+let RateLimiterService = class RateLimiterService {
+    hits = new Map();
+    /**
+     * Checks whether a key is still within the rate limit window.
+     *
+     * @param key - Unique identifier for the caller/action.
+     * @param limit - Maximum number of calls allowed within the time window.
+     * @param windowMs - Sliding window size in milliseconds.
+     * @returns `true` if the call is allowed; `false` if the limit was exceeded.
+     */
+    checkLimit(key, limit, windowMs) {
+        const now = Date.now();
+        const timestamps = this.hits.get(key) || [];
+        const validTimestamps = timestamps.filter((t) => now - t < windowMs);
+        if (validTimestamps.length >= limit) {
+            return false;
+        }
+        validTimestamps.push(now);
+        this.hits.set(key, validTimestamps);
+        if (this.hits.size > 5000)
+            this.cleanup();
+        return true;
+    }
+    /**
+     * Best-effort cleanup to prevent unbounded memory growth.
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [key, times] of this.hits.entries()) {
+            if (times.every((t) => now - t > 60000))
+                this.hits.delete(key);
+        }
+    }
+};
+RateLimiterService = __decorate([
+    injectable()
+], RateLimiterService);
+export { RateLimiterService };

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

@@ -0,0 +1,11 @@
+import { RuntimeContext } from '../runtime';
+/**
+ * Registers server runtime services in the dependency injection container.
+ *
+ * @remarks
+ * This function handles service bindings based on the runtime mode:
+ * - Service bindings may resolve to local implementations (CORE mode) or remote proxies.
+ *
+ * @param ctx - Runtime context containing mode and feature flags.
+ */
+export declare function registerServicesServer(ctx: RuntimeContext): void;

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

@@ -0,0 +1,108 @@
+import { GLOBAL_CONTAINER } from '../../../kernel/di/index';
+import { WorldContext } from '../../core/world';
+import { PrincipalProviderContract } from '../contracts/security/principal-provider.contract';
+import { BinaryProcessManager } from '../system/managers/binary-process.manager';
+import { Chat } from '../apis/chat.api';
+import { LocalCommandImplementation } from '../implementations/local/command.local';
+import { LocalPlayerImplementation } from '../implementations/local/player.local';
+import { LocalPrincipalService } from '../implementations/local/principal.local';
+import { SessionRecoveryService } from './session-recovery.local';
+import { DefaultPrincipalProvider } from '../default/default-principal.provider';
+import { PlayerPersistenceService } from './persistence.service';
+import { CommandExecutionPort } from '../ports/internal/command-execution.port';
+import { Players } from '../ports/players.api-port';
+import { PlayerSessionLifecyclePort } from '../ports/internal/player-session-lifecycle.port';
+import { Authorization } from '../ports/authorization.api-port';
+import { RemoteCommandImplementation } from '../implementations/remote/command.remote';
+import { RemotePlayerImplementation } from '../implementations/remote/player.remote';
+import { RemotePrincipalImplementation } from '../implementations/remote/principal.remote';
+import { RemoteChannelImplementation } from '../implementations/remote/channel.remote';
+import { Channels } from '../api';
+import { LocalChannelImplementation } from '../implementations/local/channel.local';
+import { Npcs } from '../apis/npcs.api';
+/**
+ * Registers server runtime services in the dependency injection container.
+ *
+ * @remarks
+ * This function handles service bindings based on the runtime mode:
+ * - Service bindings may resolve to local implementations (CORE mode) or remote proxies.
+ *
+ * @param ctx - Runtime context containing mode and feature flags.
+ */
+export function registerServicesServer(ctx) {
+    const { mode, features } = ctx;
+    // ═══════════════════════════════════════════════════════════════
+    // PHASE 1: Register all service types FIRST (recipes only)
+    // ═══════════════════════════════════════════════════════════════
+    // WorldContext must be registered first as it has no dependencies
+    if (!GLOBAL_CONTAINER.isRegistered(WorldContext)) {
+        GLOBAL_CONTAINER.registerSingleton(WorldContext);
+    }
+    if (features.players.enabled) {
+        if (features.players.provider === 'local' || mode === 'CORE') {
+            GLOBAL_CONTAINER.registerSingleton(LocalPlayerImplementation);
+            GLOBAL_CONTAINER.register(Players, { useToken: LocalPlayerImplementation });
+            GLOBAL_CONTAINER.register(PlayerSessionLifecyclePort, {
+                useToken: LocalPlayerImplementation,
+            });
+        }
+        else {
+            GLOBAL_CONTAINER.registerSingleton(Players, RemotePlayerImplementation);
+        }
+    }
+    if (mode === 'RESOURCE' && features.players.enabled) {
+        GLOBAL_CONTAINER.register(PlayerSessionLifecyclePort, {
+            useFactory: () => {
+                throw new Error('[OpenCore] PlayerSessionLifecyclePort is not available in RESOURCE mode');
+            },
+        });
+    }
+    if (features.sessionLifecycle.enabled && mode !== 'RESOURCE') {
+        GLOBAL_CONTAINER.registerSingleton(PlayerPersistenceService, PlayerPersistenceService);
+        GLOBAL_CONTAINER.registerSingleton(SessionRecoveryService, SessionRecoveryService);
+    }
+    if (features.principal.enabled) {
+        if (features.principal.provider === 'local' || mode === 'CORE' || mode === 'STANDALONE') {
+            // CORE/STANDALONE: Local principal service wraps user's PrincipalProviderContract
+            if (!GLOBAL_CONTAINER.isRegistered(PrincipalProviderContract)) {
+                GLOBAL_CONTAINER.registerSingleton(PrincipalProviderContract, DefaultPrincipalProvider);
+            }
+            GLOBAL_CONTAINER.registerSingleton(LocalPrincipalService);
+            GLOBAL_CONTAINER.register(Authorization, { useToken: LocalPrincipalService });
+        }
+        else {
+            // RESOURCE: Remote principal service delegates to CORE
+            GLOBAL_CONTAINER.registerSingleton(Authorization, RemotePrincipalImplementation);
+        }
+    }
+    if (features.commands.enabled) {
+        if (features.commands.provider === 'local' || mode === 'CORE') {
+            // CORE/STANDALONE: local command execution
+            GLOBAL_CONTAINER.registerSingleton(LocalCommandImplementation);
+            GLOBAL_CONTAINER.register(CommandExecutionPort, {
+                useToken: LocalCommandImplementation,
+            });
+        }
+        else {
+            // RESOURCE: remote command execution (delegates to CORE)
+            GLOBAL_CONTAINER.registerSingleton(CommandExecutionPort, RemoteCommandImplementation);
+        }
+    }
+    if (features.chat.enabled) {
+        if (mode === 'RESOURCE') {
+            // RESOURCE: remote channel management (delegates to CORE)
+            GLOBAL_CONTAINER.registerSingleton(Channels, RemoteChannelImplementation);
+        }
+        else {
+            // CORE/STANDALONE: local channel management
+            GLOBAL_CONTAINER.registerSingleton(Channels, LocalChannelImplementation);
+        }
+        GLOBAL_CONTAINER.registerSingleton(Chat);
+    }
+    if (!GLOBAL_CONTAINER.isRegistered(Npcs)) {
+        GLOBAL_CONTAINER.registerSingleton(Npcs);
+    }
+    if (!GLOBAL_CONTAINER.isRegistered(BinaryProcessManager)) {
+        GLOBAL_CONTAINER.registerSingleton(BinaryProcessManager);
+    }
+}

package/dist/runtime/server/services/session-recovery.local.d.ts

@@ -0,0 +1,39 @@
+import { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+import { Players } from '../ports/players.api-port';
+import { PlayerSessionLifecyclePort } from '../ports/internal/player-session-lifecycle.port';
+/**
+ * Service responsible for recovering player sessions after resource restarts.
+ *
+ * @remarks
+ * When a resource restarts (e.g., during development hot-reload), player sessions
+ * are lost because the PlayerService map is cleared. However, players remain connected
+ * to FiveM. This service detects these orphaned players and recreates their sessions.
+ *
+ * **Recovery Flow:**
+ * 1. Query FiveM for all connected player sources via `getPlayers()`
+ * 2. For each connected player, check if a session exists in PlayerService
+ * 3. If no session exists, create one with basic identifiers (license, steam, discord)
+ * 4. Emit `internal:playerSessionRecovered` event for each recovered session
+ *
+ * **Limitations:**
+ * - Only basic session data is recovered (clientID, identifiers)
+ * - `accountID` is NOT recovered - players must re-authenticate
+ * - Session metadata and states are NOT recovered
+ */
+export declare class SessionRecoveryService {
+    private readonly playerServer;
+    private readonly playerDirectory;
+    private readonly playerSessionLifecycle;
+    constructor(playerServer: IPlayerServer, playerDirectory: Players, playerSessionLifecycle: PlayerSessionLifecyclePort);
+    /**
+     * Scans for connected players and recovers sessions for any without an active session.
+     *
+     * @returns Object containing recovery statistics
+     */
+    recoverSessions(): {
+        total: number;
+        recovered: number;
+        existing: number;
+    };
+    private recoverPlayerSession;
+}

package/dist/runtime/server/services/session-recovery.local.js

@@ -0,0 +1,108 @@
+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 { IPlayerServer } from '../../../adapters/contracts/server/IPlayerServer';
+import { loggers } from '../../../kernel/logger';
+import { emitFrameworkEvent } from '../bus/internal-event.bus';
+import { Players } from '../ports/players.api-port';
+import { PlayerSessionLifecyclePort } from '../ports/internal/player-session-lifecycle.port';
+/**
+ * Service responsible for recovering player sessions after resource restarts.
+ *
+ * @remarks
+ * When a resource restarts (e.g., during development hot-reload), player sessions
+ * are lost because the PlayerService map is cleared. However, players remain connected
+ * to FiveM. This service detects these orphaned players and recreates their sessions.
+ *
+ * **Recovery Flow:**
+ * 1. Query FiveM for all connected player sources via `getPlayers()`
+ * 2. For each connected player, check if a session exists in PlayerService
+ * 3. If no session exists, create one with basic identifiers (license, steam, discord)
+ * 4. Emit `internal:playerSessionRecovered` event for each recovered session
+ *
+ * **Limitations:**
+ * - Only basic session data is recovered (clientID, identifiers)
+ * - `accountID` is NOT recovered - players must re-authenticate
+ * - Session metadata and states are NOT recovered
+ */
+let SessionRecoveryService = class SessionRecoveryService {
+    playerServer;
+    playerDirectory;
+    playerSessionLifecycle;
+    constructor(playerServer, playerDirectory, playerSessionLifecycle) {
+        this.playerServer = playerServer;
+        this.playerDirectory = playerDirectory;
+        this.playerSessionLifecycle = playerSessionLifecycle;
+    }
+    /**
+     * Scans for connected players and recovers sessions for any without an active session.
+     *
+     * @returns Object containing recovery statistics
+     */
+    recoverSessions() {
+        const connectedPlayers = this.playerServer.getConnectedPlayers();
+        const stats = { total: connectedPlayers.length, recovered: 0, existing: 0 };
+        if (connectedPlayers.length === 0) {
+            loggers.session.debug('[SessionRecovery] No connected players found');
+            return stats;
+        }
+        loggers.session.info(`[SessionRecovery] Found ${connectedPlayers.length} connected player(s), checking sessions...`);
+        for (const playerSrc of connectedPlayers) {
+            const clientId = Number(playerSrc);
+            if (Number.isNaN(clientId) || clientId <= 0) {
+                loggers.session.warn(`[SessionRecovery] Invalid player source: ${playerSrc}`);
+                continue;
+            }
+            const existingPlayer = this.playerDirectory.getByClient(clientId);
+            if (existingPlayer) {
+                stats.existing++;
+                continue;
+            }
+            this.recoverPlayerSession(clientId);
+            stats.recovered++;
+        }
+        if (stats.recovered > 0) {
+            loggers.session.info(`[SessionRecovery] Recovery complete: ${stats.recovered} recovered, ${stats.existing} already existed`);
+        }
+        else {
+            loggers.session.debug(`[SessionRecovery] All ${stats.existing} sessions already exist`);
+        }
+        return stats;
+    }
+    recoverPlayerSession(clientId) {
+        const clientIdStr = clientId.toString();
+        const license = this.playerServer.getIdentifier(clientIdStr, 'license');
+        const steam = this.playerServer.getIdentifier(clientIdStr, 'steam');
+        const discord = this.playerServer.getIdentifier(clientIdStr, 'discord');
+        const playerName = this.playerServer.getName(clientIdStr);
+        const player = this.playerSessionLifecycle.bind(clientId, {
+            license,
+            steam,
+            discord,
+        });
+        loggers.session.info(`[SessionRecovery] Recovered session for player`, {
+            clientId,
+            name: playerName,
+            license: license ? `${license.substring(0, 20)}...` : 'none',
+        });
+        emitFrameworkEvent('internal:playerSessionRecovered', {
+            clientId,
+            player,
+            license,
+        });
+    }
+};
+SessionRecoveryService = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [IPlayerServer,
+        Players,
+        PlayerSessionLifecyclePort])
+], SessionRecoveryService);
+export { SessionRecoveryService };

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

@@ -0,0 +1,9 @@
+import { ClassConstructor } from '../../kernel/di/index';
+import { CommandErrorObserverContract, PlayerPersistenceContract, PrincipalProviderContract } from './contracts';
+import { NetEventSecurityObserverContract } from './contracts/security/net-event-security-observer.contract';
+import { SecurityHandlerContract } from './contracts/security/security-handler.contract';
+export declare function setPrincipalProvider(provider: ClassConstructor<PrincipalProviderContract>): void;
+export declare function setSecurityHandler(handler: ClassConstructor<SecurityHandlerContract>): void;
+export declare function setPersistenceProvider(provider: ClassConstructor<PlayerPersistenceContract>): void;
+export declare function setNetEventSecurityObserver(observer: ClassConstructor<NetEventSecurityObserverContract>): void;
+export declare function setCommandErrorObserver(observer: ClassConstructor<CommandErrorObserverContract>): void;

package/dist/runtime/server/setup.js

@@ -0,0 +1,25 @@
+import { GLOBAL_CONTAINER } from '../../kernel/di/index';
+import { loggers } from '../../kernel/logger';
+import { CommandErrorObserverContract, PlayerPersistenceContract, PrincipalProviderContract, } from './contracts';
+import { NetEventSecurityObserverContract } from './contracts/security/net-event-security-observer.contract';
+import { SecurityHandlerContract } from './contracts/security/security-handler.contract';
+export function setPrincipalProvider(provider) {
+    GLOBAL_CONTAINER.registerSingleton(PrincipalProviderContract, provider);
+    loggers.bootstrap.info(`Principal Provider configured: ${provider.name}`);
+}
+export function setSecurityHandler(handler) {
+    GLOBAL_CONTAINER.registerSingleton(SecurityHandlerContract, handler);
+    loggers.bootstrap.info(`Security Handler configured: ${handler.name}`);
+}
+export function setPersistenceProvider(provider) {
+    GLOBAL_CONTAINER.registerSingleton(PlayerPersistenceContract, provider);
+    loggers.bootstrap.info(`Persistence Provider configured: ${provider.name}`);
+}
+export function setNetEventSecurityObserver(observer) {
+    GLOBAL_CONTAINER.registerSingleton(NetEventSecurityObserverContract, observer);
+    loggers.bootstrap.info(`NetEvent Security Observer configured: ${observer.name}`);
+}
+export function setCommandErrorObserver(observer) {
+    GLOBAL_CONTAINER.registerSingleton(CommandErrorObserverContract, observer);
+    loggers.bootstrap.info(`Command Security Observer configured: ${observer.name}`);
+}

package/dist/runtime/server/system/managers/binary-process.manager.d.ts

@@ -0,0 +1,19 @@
+import { IResourceInfo } from '../../../../adapters/contracts/IResourceInfo';
+import { BinaryServiceOptions } from '../../decorators/binaryService';
+export declare class BinaryProcessManager {
+    private resourceInfo;
+    private services;
+    constructor(resourceInfo: IResourceInfo);
+    register(options: BinaryServiceOptions, serviceClass: new (...args: any[]) => any): void;
+    call(serviceName: string, action: string, params: unknown[], timeoutMs?: number): Promise<unknown>;
+    private resolveServiceInstance;
+    private applyBinaryProxies;
+    private resolveBinaryPath;
+    private spawnProcess;
+    private handleStdout;
+    private handleResponse;
+    private failPending;
+    private registerEventHandlers;
+    private dispatchEvent;
+    private writeLine;
+}