@jshookmcp/jshook 0.2.0 → 0.2.1

package/dist/src/server/DomainInstanceRegistry.js

@@ -0,0 +1,233 @@
+export class DomainInstanceRegistry {
+    _collector;
+    _pageController;
+    _domInspector;
+    _scriptManager;
+    _debuggerManager;
+    _runtimeInspector;
+    _consoleMonitor;
+    _llm;
+    _deobfuscator;
+    _advancedDeobfuscator;
+    _astOptimizer;
+    _obfuscationDetector;
+    _analyzer;
+    _cryptoDetector;
+    _hookManager;
+    _browserHandlers;
+    _debuggerHandlers;
+    _advancedHandlers;
+    _aiHookHandlers;
+    _hookPresetHandlers;
+    _coreAnalysisHandlers;
+    _coreMaintenanceHandlers;
+    _extensionManagementHandlers;
+    _processHandlers;
+    _workflowHandlers;
+    _wasmHandlers;
+    _streamingHandlers;
+    _encodingHandlers;
+    _antidebugHandlers;
+    _graphqlHandlers;
+    _platformHandlers;
+    _sourcemapHandlers;
+    _transformHandlers;
+    get collector() {
+        return this._collector;
+    }
+    set collector(value) {
+        this._collector = value;
+    }
+    get pageController() {
+        return this._pageController;
+    }
+    set pageController(value) {
+        this._pageController = value;
+    }
+    get domInspector() {
+        return this._domInspector;
+    }
+    set domInspector(value) {
+        this._domInspector = value;
+    }
+    get scriptManager() {
+        return this._scriptManager;
+    }
+    set scriptManager(value) {
+        this._scriptManager = value;
+    }
+    get debuggerManager() {
+        return this._debuggerManager;
+    }
+    set debuggerManager(value) {
+        this._debuggerManager = value;
+    }
+    get runtimeInspector() {
+        return this._runtimeInspector;
+    }
+    set runtimeInspector(value) {
+        this._runtimeInspector = value;
+    }
+    get consoleMonitor() {
+        return this._consoleMonitor;
+    }
+    set consoleMonitor(value) {
+        this._consoleMonitor = value;
+    }
+    get llm() {
+        return this._llm;
+    }
+    set llm(value) {
+        this._llm = value;
+    }
+    get deobfuscator() {
+        return this._deobfuscator;
+    }
+    set deobfuscator(value) {
+        this._deobfuscator = value;
+    }
+    get advancedDeobfuscator() {
+        return this._advancedDeobfuscator;
+    }
+    set advancedDeobfuscator(value) {
+        this._advancedDeobfuscator = value;
+    }
+    get astOptimizer() {
+        return this._astOptimizer;
+    }
+    set astOptimizer(value) {
+        this._astOptimizer = value;
+    }
+    get obfuscationDetector() {
+        return this._obfuscationDetector;
+    }
+    set obfuscationDetector(value) {
+        this._obfuscationDetector = value;
+    }
+    get analyzer() {
+        return this._analyzer;
+    }
+    set analyzer(value) {
+        this._analyzer = value;
+    }
+    get cryptoDetector() {
+        return this._cryptoDetector;
+    }
+    set cryptoDetector(value) {
+        this._cryptoDetector = value;
+    }
+    get hookManager() {
+        return this._hookManager;
+    }
+    set hookManager(value) {
+        this._hookManager = value;
+    }
+    get browserHandlers() {
+        return this._browserHandlers;
+    }
+    set browserHandlers(value) {
+        this._browserHandlers = value;
+    }
+    get debuggerHandlers() {
+        return this._debuggerHandlers;
+    }
+    set debuggerHandlers(value) {
+        this._debuggerHandlers = value;
+    }
+    get advancedHandlers() {
+        return this._advancedHandlers;
+    }
+    set advancedHandlers(value) {
+        this._advancedHandlers = value;
+    }
+    get aiHookHandlers() {
+        return this._aiHookHandlers;
+    }
+    set aiHookHandlers(value) {
+        this._aiHookHandlers = value;
+    }
+    get hookPresetHandlers() {
+        return this._hookPresetHandlers;
+    }
+    set hookPresetHandlers(value) {
+        this._hookPresetHandlers = value;
+    }
+    get coreAnalysisHandlers() {
+        return this._coreAnalysisHandlers;
+    }
+    set coreAnalysisHandlers(value) {
+        this._coreAnalysisHandlers = value;
+    }
+    get coreMaintenanceHandlers() {
+        return this._coreMaintenanceHandlers;
+    }
+    set coreMaintenanceHandlers(value) {
+        this._coreMaintenanceHandlers = value;
+    }
+    get extensionManagementHandlers() {
+        return this._extensionManagementHandlers;
+    }
+    set extensionManagementHandlers(value) {
+        this._extensionManagementHandlers = value;
+    }
+    get processHandlers() {
+        return this._processHandlers;
+    }
+    set processHandlers(value) {
+        this._processHandlers = value;
+    }
+    get workflowHandlers() {
+        return this._workflowHandlers;
+    }
+    set workflowHandlers(value) {
+        this._workflowHandlers = value;
+    }
+    get wasmHandlers() {
+        return this._wasmHandlers;
+    }
+    set wasmHandlers(value) {
+        this._wasmHandlers = value;
+    }
+    get streamingHandlers() {
+        return this._streamingHandlers;
+    }
+    set streamingHandlers(value) {
+        this._streamingHandlers = value;
+    }
+    get encodingHandlers() {
+        return this._encodingHandlers;
+    }
+    set encodingHandlers(value) {
+        this._encodingHandlers = value;
+    }
+    get antidebugHandlers() {
+        return this._antidebugHandlers;
+    }
+    set antidebugHandlers(value) {
+        this._antidebugHandlers = value;
+    }
+    get graphqlHandlers() {
+        return this._graphqlHandlers;
+    }
+    set graphqlHandlers(value) {
+        this._graphqlHandlers = value;
+    }
+    get platformHandlers() {
+        return this._platformHandlers;
+    }
+    set platformHandlers(value) {
+        this._platformHandlers = value;
+    }
+    get sourcemapHandlers() {
+        return this._sourcemapHandlers;
+    }
+    set sourcemapHandlers(value) {
+        this._sourcemapHandlers = value;
+    }
+    get transformHandlers() {
+        return this._transformHandlers;
+    }
+    set transformHandlers(value) {
+        this._transformHandlers = value;
+    }
+}

package/dist/src/server/MCPServer.activation.ttl.d.ts

@@ -0,0 +1,11 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+export interface DomainTtlEntry {
+    timer: ReturnType<typeof setTimeout>;
+    ttlMs: number;
+    toolNames: Set<string>;
+}
+export declare function startDomainTtl(ctx: MCPServerContext, domain: string, ttlMinutes: number, toolNames: Iterable<string>): void;
+export declare function refreshDomainTtl(ctx: MCPServerContext, domain: string): void;
+export declare function refreshDomainTtlForTool(ctx: MCPServerContext, toolName: string): void;
+export declare function clearDomainTtl(ctx: MCPServerContext, domain: string): void;
+export declare function deactivateDomainOnExpiry(ctx: MCPServerContext, domain: string): Promise<void>;

package/dist/src/server/MCPServer.activation.ttl.js

@@ -0,0 +1,100 @@
+import { logger } from '../utils/logger.js';
+import { getToolDomain } from './ToolCatalog.js';
+export function startDomainTtl(ctx, domain, ttlMinutes, toolNames) {
+    clearDomainTtl(ctx, domain);
+    if (ttlMinutes <= 0)
+        return;
+    const ttlMs = ttlMinutes * 60 * 1000;
+    const names = new Set(toolNames);
+    const timer = setTimeout(() => {
+        logger.info(`Domain "${domain}" TTL expired (${ttlMinutes}min) — auto-deactivating ${names.size} tools`);
+        void deactivateDomainOnExpiry(ctx, domain).catch((err) => {
+            logger.error(`Failed to deactivate domain "${domain}" on TTL expiry:`, err);
+        });
+    }, ttlMs);
+    ctx.domainTtlEntries.set(domain, { timer, ttlMs, toolNames: names });
+}
+export function refreshDomainTtl(ctx, domain) {
+    const entry = ctx.domainTtlEntries.get(domain);
+    if (!entry)
+        return;
+    clearTimeout(entry.timer);
+    const ttlMinutes = entry.ttlMs / 60_000;
+    entry.timer = setTimeout(() => {
+        logger.info(`Domain "${domain}" TTL expired (${ttlMinutes}min) — auto-deactivating`);
+        void deactivateDomainOnExpiry(ctx, domain).catch((err) => {
+            logger.error(`Failed to deactivate domain "${domain}" on TTL expiry:`, err);
+        });
+    }, entry.ttlMs);
+}
+export function refreshDomainTtlForTool(ctx, toolName) {
+    let domain = getToolDomain(toolName);
+    if (!domain) {
+        const extRecord = ctx.extensionToolsByName.get(toolName);
+        if (extRecord)
+            domain = extRecord.domain;
+    }
+    if (domain && ctx.domainTtlEntries.has(domain)) {
+        refreshDomainTtl(ctx, domain);
+    }
+}
+export function clearDomainTtl(ctx, domain) {
+    const entry = ctx.domainTtlEntries.get(domain);
+    if (entry) {
+        clearTimeout(entry.timer);
+        ctx.domainTtlEntries.delete(domain);
+    }
+}
+export async function deactivateDomainOnExpiry(ctx, domain) {
+    const entry = ctx.domainTtlEntries.get(domain);
+    if (!entry)
+        return;
+    const toolNames = entry.toolNames;
+    ctx.domainTtlEntries.delete(domain);
+    let removedCount = 0;
+    for (const name of toolNames) {
+        if (!ctx.activatedToolNames.has(name))
+            continue;
+        const registeredTool = ctx.activatedRegisteredTools.get(name);
+        if (registeredTool) {
+            try {
+                registeredTool.remove();
+            }
+            catch (e) {
+                logger.warn(`Failed to remove tool "${name}" on domain TTL expiry:`, e);
+            }
+        }
+        ctx.router.removeHandler(name);
+        ctx.activatedToolNames.delete(name);
+        ctx.activatedRegisteredTools.delete(name);
+        const extRecord = ctx.extensionToolsByName.get(name);
+        if (extRecord) {
+            extRecord.registeredTool = undefined;
+        }
+        removedCount++;
+    }
+    if (removedCount > 0) {
+        ctx.enabledDomains.delete(domain);
+        for (const activeName of ctx.activatedToolNames) {
+            const d = getToolDomain(activeName);
+            if (d === domain) {
+                ctx.enabledDomains.add(domain);
+                break;
+            }
+        }
+        for (const selectedTool of ctx.selectedTools) {
+            const d = getToolDomain(selectedTool.name);
+            if (d === domain) {
+                ctx.enabledDomains.add(domain);
+                break;
+            }
+        }
+        try {
+            await ctx.server.sendToolListChanged();
+        }
+        catch (e) {
+            logger.warn('sendToolListChanged failed after domain TTL expiry:', e);
+        }
+        logger.info(`Domain "${domain}" deactivated: removed ${removedCount} tools`);
+    }
+}

package/dist/src/server/MCPServer.context.d.ts

@@ -56,19 +56,11 @@ export interface ToolRegistryState {
     router: ToolExecutionRouter;
     handlerDeps: ToolHandlerDeps;
 }
-export interface ProfileState {
+export interface ActivationState {
     baseTier: ToolProfile;
-    currentTier: ToolProfile;
-    boostHistory: ToolProfile[];
-    boostedToolNames: Set<string>;
-    boostedRegisteredTools: Map<string, RegisteredTool>;
-    boostTtlTimer: ReturnType<typeof setTimeout> | null;
-    boostTtlMinutes: number;
-    boostLock: Promise<void>;
     activatedToolNames: Set<string>;
     activatedRegisteredTools: Map<string, RegisteredTool>;
-    absorbedFromActivated: Set<string>;
-    boostedExtensionToolNames: Set<string>;
+    domainTtlEntries: Map<string, import('./MCPServer.activation.ttl.js').DomainTtlEntry>;
 }
 export interface TransportState {
     httpServer?: Server;
@@ -121,12 +113,9 @@ export interface ServerMethods {
     registerCaches(): Promise<void>;
     resolveEnabledDomains(tools: Tool[]): Set<string>;
     registerSingleTool(toolDef: Tool): RegisteredTool;
-    boostProfile(target?: string, ttlMinutes?: number): Promise<Record<string, unknown>>;
-    unboostProfile(target?: string): Promise<Record<string, unknown>>;
-    switchToTier(targetTier: ToolProfile): Promise<void>;
     reloadExtensions(): Promise<ExtensionReloadResult>;
     listExtensions(): ExtensionListResult;
     executeToolWithTracking(name: string, args: ToolArgs): Promise<ToolResponse>;
 }
-export interface MCPServerContext extends ServerCore, ToolRegistryState, ProfileState, TransportState, ExtensionState, DomainInstances, ServerMethods {
+export interface MCPServerContext extends ServerCore, ToolRegistryState, ActivationState, TransportState, ExtensionState, DomainInstances, ServerMethods {
 }

package/dist/src/server/MCPServer.d.ts

@@ -3,47 +3,18 @@ import type { Server } from 'node:http';
 import type { Socket } from 'node:net';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import type { Config } from '../types/index.js';
-import type { CodeCollector } from '../modules/collector/CodeCollector.js';
-import type { PageController } from '../modules/collector/PageController.js';
-import type { DOMInspector } from '../modules/collector/DOMInspector.js';
-import type { ScriptManager } from '../modules/debugger/ScriptManager.js';
-import type { DebuggerManager } from '../modules/debugger/DebuggerManager.js';
-import type { RuntimeInspector } from '../modules/debugger/RuntimeInspector.js';
-import type { ConsoleMonitor } from '../modules/monitor/ConsoleMonitor.js';
-import type { BrowserToolHandlers } from './domains/browser/index.js';
-import type { DebuggerToolHandlers } from './domains/debugger/index.js';
-import type { AdvancedToolHandlers } from './domains/network/index.js';
-import type { AIHookToolHandlers, HookPresetToolHandlers } from './domains/hooks/index.js';
-import type { Deobfuscator } from '../modules/deobfuscator/Deobfuscator.js';
-import type { AdvancedDeobfuscator } from '../modules/deobfuscator/AdvancedDeobfuscator.js';
-import type { ASTOptimizer } from '../modules/deobfuscator/ASTOptimizer.js';
-import type { ObfuscationDetector } from '../modules/detector/ObfuscationDetector.js';
-import type { LLMService } from '../services/LLMService.js';
-import type { CodeAnalyzer } from '../modules/analyzer/CodeAnalyzer.js';
-import type { CryptoDetector } from '../modules/crypto/CryptoDetector.js';
-import type { HookManager } from '../modules/hook/HookManager.js';
 import { TokenBudgetManager } from '../utils/TokenBudgetManager.js';
 import { UnifiedCacheManager } from '../utils/UnifiedCacheManager.js';
 import { DetailedDataManager } from '../utils/DetailedDataManager.js';
-import type { CoreAnalysisHandlers } from './domains/analysis/index.js';
-import type { CoreMaintenanceHandlers, ExtensionManagementHandlers } from './domains/maintenance/index.js';
-import type { ProcessToolHandlers } from './domains/process/index.js';
-import type { WorkflowHandlers } from './domains/workflow/index.js';
-import type { WasmToolHandlers } from './domains/wasm/index.js';
-import type { StreamingToolHandlers } from './domains/streaming/index.js';
-import type { EncodingToolHandlers } from './domains/encoding/index.js';
-import type { AntiDebugToolHandlers } from './domains/antidebug/index.js';
-import type { GraphQLToolHandlers } from './domains/graphql/index.js';
-import type { PlatformToolHandlers } from './domains/platform/index.js';
-import type { SourcemapToolHandlers } from './domains/sourcemap/index.js';
-import type { TransformToolHandlers } from './domains/transform/index.js';
 import type { ToolProfile } from './ToolCatalog.js';
 import { ToolExecutionRouter } from './ToolExecutionRouter.js';
 import { ToolCallContextGuard } from './ToolCallContextGuard.js';
 import type { ToolArgs } from './types.js';
+import type { DomainTtlEntry } from './MCPServer.activation.ttl.js';
 import type { MCPServerContext } from './MCPServer.context.js';
 import type { ToolHandlerDeps } from './registry/contracts.js';
 import type { ExtensionListResult, ExtensionPluginRecord, ExtensionPluginRuntimeRecord, ExtensionReloadResult, ExtensionToolRecord, ExtensionWorkflowRecord, ExtensionWorkflowRuntimeRecord } from './extensions/types.js';
+import { DomainInstanceRegistry } from './DomainInstanceRegistry.js';
 export declare class MCPServer implements MCPServerContext {
     readonly config: Config;
     readonly server: McpServer;
@@ -60,17 +31,9 @@ export declare class MCPServer implements MCPServerContext {
     private cacheAdaptersRegistered;
     private cacheRegistrationPromise?;
     readonly baseTier: ToolProfile;
-    currentTier: ToolProfile;
-    readonly boostHistory: ToolProfile[];
-    readonly boostedToolNames: Set<string>;
-    readonly boostedRegisteredTools: Map<string, RegisteredTool>;
-    boostTtlTimer: ReturnType<typeof setTimeout> | null;
-    boostTtlMinutes: number;
-    boostLock: Promise<void>;
     readonly activatedToolNames: Set<string>;
     readonly activatedRegisteredTools: Map<string, RegisteredTool>;
-    readonly absorbedFromActivated: Set<string>;
-    readonly boostedExtensionToolNames: Set<string>;
+    readonly domainTtlEntries: Map<string, DomainTtlEntry>;
     readonly extensionToolsByName: Map<string, ExtensionToolRecord>;
     readonly extensionPluginsById: Map<string, ExtensionPluginRecord>;
     readonly extensionPluginRuntimeById: Map<string, ExtensionPluginRuntimeRecord>;
@@ -79,45 +42,76 @@ export declare class MCPServer implements MCPServerContext {
     lastExtensionReloadAt?: string;
     httpServer?: Server;
     readonly httpSockets: Set<Socket>;
-    collector?: CodeCollector;
-    pageController?: PageController;
-    domInspector?: DOMInspector;
-    scriptManager?: ScriptManager;
-    debuggerManager?: DebuggerManager;
-    runtimeInspector?: RuntimeInspector;
-    consoleMonitor?: ConsoleMonitor;
-    llm?: LLMService;
-    browserHandlers?: BrowserToolHandlers;
-    debuggerHandlers?: DebuggerToolHandlers;
-    advancedHandlers?: AdvancedToolHandlers;
-    aiHookHandlers?: AIHookToolHandlers;
-    hookPresetHandlers?: HookPresetToolHandlers;
-    deobfuscator?: Deobfuscator;
-    advancedDeobfuscator?: AdvancedDeobfuscator;
-    astOptimizer?: ASTOptimizer;
-    obfuscationDetector?: ObfuscationDetector;
-    analyzer?: CodeAnalyzer;
-    cryptoDetector?: CryptoDetector;
-    hookManager?: HookManager;
-    coreAnalysisHandlers?: CoreAnalysisHandlers;
-    coreMaintenanceHandlers?: CoreMaintenanceHandlers;
-    extensionManagementHandlers?: ExtensionManagementHandlers;
-    processHandlers?: ProcessToolHandlers;
-    workflowHandlers?: WorkflowHandlers;
-    wasmHandlers?: WasmToolHandlers;
-    streamingHandlers?: StreamingToolHandlers;
-    encodingHandlers?: EncodingToolHandlers;
-    antidebugHandlers?: AntiDebugToolHandlers;
-    graphqlHandlers?: GraphQLToolHandlers;
-    platformHandlers?: PlatformToolHandlers;
-    sourcemapHandlers?: SourcemapToolHandlers;
-    transformHandlers?: TransformToolHandlers;
+    readonly domainInstances: DomainInstanceRegistry;
+    get collector(): import("./domains/shared/modules.js").CodeCollector | undefined;
+    set collector(v: import("./domains/shared/modules.js").CodeCollector | undefined);
+    get pageController(): import("./domains/shared/modules.js").PageController | undefined;
+    set pageController(v: import("./domains/shared/modules.js").PageController | undefined);
+    get domInspector(): import("./domains/shared/modules.js").DOMInspector | undefined;
+    set domInspector(v: import("./domains/shared/modules.js").DOMInspector | undefined);
+    get scriptManager(): import("./domains/shared/modules.js").ScriptManager | undefined;
+    set scriptManager(v: import("./domains/shared/modules.js").ScriptManager | undefined);
+    get debuggerManager(): import("./domains/shared/modules.js").DebuggerManager | undefined;
+    set debuggerManager(v: import("./domains/shared/modules.js").DebuggerManager | undefined);
+    get runtimeInspector(): import("./domains/shared/modules.js").RuntimeInspector | undefined;
+    set runtimeInspector(v: import("./domains/shared/modules.js").RuntimeInspector | undefined);
+    get consoleMonitor(): import("./domains/shared/modules.js").ConsoleMonitor | undefined;
+    set consoleMonitor(v: import("./domains/shared/modules.js").ConsoleMonitor | undefined);
+    get llm(): import("../services/LLMService.js").LLMService | undefined;
+    set llm(v: import("../services/LLMService.js").LLMService | undefined);
+    get browserHandlers(): import("./domains/browser/index.js").BrowserToolHandlers | undefined;
+    set browserHandlers(v: import("./domains/browser/index.js").BrowserToolHandlers | undefined);
+    get debuggerHandlers(): import("./domains/debugger/index.js").DebuggerToolHandlers | undefined;
+    set debuggerHandlers(v: import("./domains/debugger/index.js").DebuggerToolHandlers | undefined);
+    get advancedHandlers(): import("./domains/network/index.js").AdvancedToolHandlers | undefined;
+    set advancedHandlers(v: import("./domains/network/index.js").AdvancedToolHandlers | undefined);
+    get aiHookHandlers(): import("./domains/hooks/index.js").AIHookToolHandlers | undefined;
+    set aiHookHandlers(v: import("./domains/hooks/index.js").AIHookToolHandlers | undefined);
+    get hookPresetHandlers(): import("./domains/hooks/index.js").HookPresetToolHandlers | undefined;
+    set hookPresetHandlers(v: import("./domains/hooks/index.js").HookPresetToolHandlers | undefined);
+    get deobfuscator(): import("./domains/shared/modules.js").Deobfuscator | undefined;
+    set deobfuscator(v: import("./domains/shared/modules.js").Deobfuscator | undefined);
+    get advancedDeobfuscator(): import("./domains/shared/modules.js").AdvancedDeobfuscator | undefined;
+    set advancedDeobfuscator(v: import("./domains/shared/modules.js").AdvancedDeobfuscator | undefined);
+    get astOptimizer(): import("./domains/shared/modules.js").ASTOptimizer | undefined;
+    set astOptimizer(v: import("./domains/shared/modules.js").ASTOptimizer | undefined);
+    get obfuscationDetector(): import("./domains/shared/modules.js").ObfuscationDetector | undefined;
+    set obfuscationDetector(v: import("./domains/shared/modules.js").ObfuscationDetector | undefined);
+    get analyzer(): import("./domains/shared/modules.js").CodeAnalyzer | undefined;
+    set analyzer(v: import("./domains/shared/modules.js").CodeAnalyzer | undefined);
+    get cryptoDetector(): import("./domains/shared/modules.js").CryptoDetector | undefined;
+    set cryptoDetector(v: import("./domains/shared/modules.js").CryptoDetector | undefined);
+    get hookManager(): import("./domains/shared/modules.js").HookManager | undefined;
+    set hookManager(v: import("./domains/shared/modules.js").HookManager | undefined);
+    get coreAnalysisHandlers(): import("./domains/analysis/index.js").CoreAnalysisHandlers | undefined;
+    set coreAnalysisHandlers(v: import("./domains/analysis/index.js").CoreAnalysisHandlers | undefined);
+    get coreMaintenanceHandlers(): import("./domains/maintenance/index.js").CoreMaintenanceHandlers | undefined;
+    set coreMaintenanceHandlers(v: import("./domains/maintenance/index.js").CoreMaintenanceHandlers | undefined);
+    get extensionManagementHandlers(): import("./domains/maintenance/index.js").ExtensionManagementHandlers | undefined;
+    set extensionManagementHandlers(v: import("./domains/maintenance/index.js").ExtensionManagementHandlers | undefined);
+    get processHandlers(): import("./domains/process/index.js").ProcessToolHandlers | undefined;
+    set processHandlers(v: import("./domains/process/index.js").ProcessToolHandlers | undefined);
+    get workflowHandlers(): import("./domains/workflow/index.js").WorkflowHandlers | undefined;
+    set workflowHandlers(v: import("./domains/workflow/index.js").WorkflowHandlers | undefined);
+    get wasmHandlers(): import("./domains/wasm/index.js").WasmToolHandlers | undefined;
+    set wasmHandlers(v: import("./domains/wasm/index.js").WasmToolHandlers | undefined);
+    get streamingHandlers(): import("./domains/streaming/index.js").StreamingToolHandlers | undefined;
+    set streamingHandlers(v: import("./domains/streaming/index.js").StreamingToolHandlers | undefined);
+    get encodingHandlers(): import("./domains/encoding/index.js").EncodingToolHandlers | undefined;
+    set encodingHandlers(v: import("./domains/encoding/index.js").EncodingToolHandlers | undefined);
+    get antidebugHandlers(): import("./domains/antidebug/index.js").AntiDebugToolHandlers | undefined;
+    set antidebugHandlers(v: import("./domains/antidebug/index.js").AntiDebugToolHandlers | undefined);
+    get graphqlHandlers(): import("./domains/graphql/index.js").GraphQLToolHandlers | undefined;
+    set graphqlHandlers(v: import("./domains/graphql/index.js").GraphQLToolHandlers | undefined);
+    get platformHandlers(): import("./domains/platform/index.js").PlatformToolHandlers | undefined;
+    set platformHandlers(v: import("./domains/platform/index.js").PlatformToolHandlers | undefined);
+    get sourcemapHandlers(): import("./domains/sourcemap/index.js").SourcemapToolHandlers | undefined;
+    set sourcemapHandlers(v: import("./domains/sourcemap/index.js").SourcemapToolHandlers | undefined);
+    get transformHandlers(): import("./domains/transform/index.js").TransformToolHandlers | undefined;
+    set transformHandlers(v: import("./domains/transform/index.js").TransformToolHandlers | undefined);
     constructor(config: Config);
     resolveEnabledDomains(tools: Tool[]): Set<string>;
     registerSingleTool(toolDef: Tool): RegisteredTool;
-    boostProfile(target?: string, ttlMinutes?: number): Promise<Record<string, unknown>>;
-    unboostProfile(target?: string): Promise<Record<string, unknown>>;
-    switchToTier(targetTier: ToolProfile): Promise<void>;
     reloadExtensions(): Promise<ExtensionReloadResult>;
     listExtensions(): ExtensionListResult;
     registerCaches(): Promise<void>;