ProviderRegistry

import { ProviderRegistry } from '@frontmcp/sdk';

// Access via scope
const providers = scope.providers;

// Get a singleton provider
const logger = providers.get(LoggerToken);

// Get a scoped provider
const service = providers.getScoped(ServiceToken, views);

get<T>(token: Token<T>): T

const logger = registry.get(LoggerToken);
const config = registry.get(ConfigToken);

getScoped<T>(token: Token<T>, views: ProviderViews): T

const views = registry.buildViews(sessionKey, contextProviders);
const session = registry.getScoped(SessionToken, views);

resolve<T>(cls: Class<T>): T

const service = registry.resolve(MyService);

resolveBootstrapDep<T>(token: Token<T>): T

getProviders(): ReadonlyArray<ProviderEntry>

buildViews(
  sessionKey: string,
  contextProviders?: Map<Token, unknown>
): ProviderViews

const views = registry.buildViews('session-123', new Map([
  [RequestToken, currentRequest],
]));

addRegistry<T>(type: RegistryType, value: T): void

getRegistries<T>(type: RegistryType): T[]

getHooksRegistry(): HookRegistry

getScopeRegistry(): ScopeRegistry

mergeFromRegistry(providedBy: Token, exported: ProviderExport[]): void

getProviderInfo(token: Token): ProviderDef | undefined

injectProvider<T>(injected: InjectedProvider<T>): void

registry.injectProvider({
  token: ConfigToken,
  value: { debug: true },
});

addDynamicProviders(dynamicProviders: DynamicProvider[]): void

cleanupSession(sessionKey: string): void

cleanupExpiredSessions(): void

startSessionCleanup(): void

stopSessionCleanup(): void

getSessionCacheStats(): SessionCacheStats

isSessionCacheEnabled(): boolean

dispose(): void

getActiveScope(): Scope

getActiveServer(): Server

interface ProviderViews {
  singleton: Map<Token, unknown>;  // Server-wide singletons
  session: Map<Token, unknown>;    // Session-scoped instances
  context: Map<Token, unknown>;    // Context-scoped instances
}

// Session cache stats
const stats = registry.getSessionCacheStats();
console.log(`Active sessions: ${stats.activeCount}`);
console.log(`Cache hits: ${stats.hits}`);
console.log(`Cache misses: ${stats.misses}`);

interface ProviderDef<T> {
  token: Token<T>;                    // Injection token
  useClass?: Class<T>;                // Class to instantiate
  useFactory?: () => T | Promise<T>;  // Factory function
  useValue?: T;                       // Direct value
  scope?: ProviderScope;              // Lifecycle scope
  deps?: Token[];                     // Dependencies
}

@Provider({
  token: CacheToken,
  useFactory: () => new RedisCache(),
  scope: ProviderScope.SINGLETON,
})
class CacheProvider { }