@frontmcp/sdk 0.6.1 → 0.6.2

package/src/provider/provider.registry.js

@@ -1,868 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const common_1 = require("../common");
-const provider_utils_1 = require("./provider.utils");
-const token_utils_1 = require("../utils/token.utils");
-const metadata_utils_1 = require("../utils/metadata.utils");
-const regsitry_1 = require("../regsitry");
-const scope_1 = require("../scope");
-const session_key_provider_1 = require("../context/session-key.provider");
-class ProviderRegistry extends regsitry_1.RegistryAbstract {
-    parentProviders;
-    /** used to track which registry provided which token */
-    providedBy;
-    /** topo order (deps first) */
-    order = new Set();
-    // /** scoped instance stores by key */
-    // private scoped = new Map<string, Map<Token, any>>();
-    registries = new Map();
-    /** Session-scoped provider instance cache by sessionKey */
-    sessionStores = new Map();
-    /** Locks to prevent concurrent session builds (race condition prevention) */
-    sessionBuildLocks = new Map();
-    /** Maximum number of sessions to cache (LRU eviction) */
-    static MAX_SESSION_CACHE_SIZE = 10000;
-    /** Session cache TTL in milliseconds (1 hour) */
-    static SESSION_CACHE_TTL_MS = 3600000;
-    /** Cleanup interval in milliseconds (1 minute) */
-    static SESSION_CLEANUP_INTERVAL_MS = 60000;
-    /** Handle for the session cleanup interval */
-    sessionCleanupInterval = null;
-    constructor(list, parentProviders) {
-        super('ProviderRegistry', parentProviders, list, false);
-        this.parentProviders = parentProviders;
-        this.providedBy = new Map();
-        this.buildGraph();
-        this.topoSort();
-        this.ready = this.initialize();
-    }
-    getProviders() {
-        return [...this.instances.values()];
-    }
-    /* -------------------- Hierarchy helpers -------------------- */
-    /** Walk up the registry chain to find a def for a token. */
-    lookupDefInHierarchy(token) {
-        if (this.defs.has(token))
-            return { registry: this, rec: this.defs.get(token) };
-        return this.providers?.lookupDefInHierarchy(token);
-    }
-    /** Resolve a DEFAULT-scoped dependency from the hierarchy, enforcing scope & instantiation. */
-    resolveDefaultFromHierarchy(token) {
-        const found = this.lookupDefInHierarchy(token);
-        if (!found)
-            throw new Error(`Cannot resolve token ${(0, token_utils_1.tokenName)(token)}: not registered in hierarchy.`);
-        const { registry, rec } = found;
-        const sc = registry.getProviderScope(rec);
-        if (sc !== common_1.ProviderScope.GLOBAL) {
-            const scName = common_1.ProviderScope[sc];
-            throw new Error(`Dependency ${(0, token_utils_1.tokenName)(token)} is scoped (${scName}) in ${registry.constructor.name}; cannot use as DEFAULT.`);
-        }
-        const inst = registry.instances.get(token);
-        if (inst === undefined) {
-            throw new Error(`Dependency ${(0, token_utils_1.tokenName)(token)} (DEFAULT) is not instantiated in ${registry.constructor.name}`);
-        }
-        return inst;
-    }
-    /* -------------------- Build phase -------------------- */
-    buildMap(list) {
-        const tokens = new Set();
-        const defs = new Map();
-        const graph = new Map();
-        for (const raw of list) {
-            const rec = (0, provider_utils_1.normalizeProvider)(raw);
-            const provide = rec.provide;
-            tokens.add(provide);
-            defs.set(provide, rec);
-            graph.set(provide, new Set());
-        }
-        return { tokens, defs, graph };
-    }
-    buildGraph() {
-        for (const token of this.tokens) {
-            const rec = this.defs.get(token);
-            const deps = this.discoveryDeps(rec);
-            for (const d of deps) {
-                const isLocal = this.tokens.has(d);
-                const up = isLocal ? undefined : this.lookupDefInHierarchy(d);
-                if (!isLocal && !up) {
-                    throw new Error(`Provider ${(0, token_utils_1.tokenName)(token)} depends on ${(0, token_utils_1.tokenName)(d)}, which is not registered (local or parent).`);
-                }
-                const depRec = isLocal ? this.defs.get(d) : up.rec;
-                const depScope = isLocal ? this.getProviderScope(depRec) : up.registry.getProviderScope(depRec);
-                if (this.getProviderScope(rec) === common_1.ProviderScope.GLOBAL && depScope !== common_1.ProviderScope.GLOBAL) {
-                    throw new Error(`Invalid dependency: DEFAULT-scoped provider ${(0, token_utils_1.tokenName)(token)} cannot depend on scoped provider ${(0, token_utils_1.tokenName)(d)}.`);
-                }
-                // Only wire local -> local edges in our local graph; parent deps are external to this DAG.
-                if (isLocal)
-                    this.graph.get(token).add(d);
-            }
-        }
-    }
-    topoSort() {
-        const WHITE = 0, GRAY = 1, BLACK = 2;
-        const color = new Map();
-        const order = new Set();
-        const path = [];
-        const dfs = (n) => {
-            color.set(n, GRAY);
-            path.push(n);
-            for (const dep of this.graph.get(n) ?? []) {
-                const c = color.get(dep) ?? WHITE;
-                if (c === GRAY) {
-                    const idx = path.findIndex((p) => p === dep);
-                    const cycle = [...path.slice(idx), dep].map((t) => (0, token_utils_1.tokenName)(t)).join(' -> ');
-                    throw new Error(`Dependency cycle detected: ${cycle}`);
-                }
-                if (c === WHITE)
-                    dfs(dep);
-            }
-            color.set(n, BLACK);
-            order.add(n);
-            path.pop();
-        };
-        for (const n of this.graph.keys())
-            if ((color.get(n) ?? WHITE) === WHITE)
-                dfs(n);
-        this.order = order;
-    }
-    /** Incremental instantiation for DEFAULT providers.
-     *  - Skips already-built singletons unless force:true.
-     *  - Can limit to a subset via onlyTokens.
-     */
-    async initialize(opts) {
-        const force = !!opts?.force;
-        const only = opts?.onlyTokens ? new Set(opts.onlyTokens) : null;
-        for (const token of this.order) {
-            const rec = this.defs.get(token);
-            if (this.getProviderScope(rec) !== common_1.ProviderScope.GLOBAL)
-                continue;
-            if (only && !only.has(token))
-                continue;
-            if (!force && this.instances.has(token))
-                continue;
-            if (force && this.instances.has(token)) {
-                this.instances.delete(token);
-            }
-            try {
-                await this.initiateOne(token, rec);
-            }
-            catch (e) {
-                const msg = e?.message ?? e;
-                // Use safe logging to avoid Node.js 24 util.inspect bug with Zod errors
-                console.error(`Failed instantiating:`, msg);
-                throw new Error(`Failed constructing ${(0, token_utils_1.tokenName)(token)}: ${msg}`);
-            }
-        }
-        // Start background session cleanup after initialization
-        // This ensures expired sessions are periodically cleaned up (TTL enforcement)
-        // Only start for scope-level registries (those with parentProviders) since
-        // SESSION providers are stored in scope registries, not the global registry
-        if (this.parentProviders) {
-            this.startSessionCleanup();
-        }
-    }
-    /* -------------------- Views & session stores -------------------- */
-    /** Return the live singleton map as a read-only view. No copying. */
-    getAllSingletons() {
-        return this.instances; // exposed as ReadonlyMap in the type
-    }
-    discoveryDeps(rec) {
-        return (0, provider_utils_1.providerDiscoveryDeps)(rec, this.tokens, (k, phase) => (0, token_utils_1.depsOfClass)(k, phase));
-    }
-    invocationTokens(_token, rec) {
-        return (0, provider_utils_1.providerInvocationTokens)(rec, (k, phase) => (0, token_utils_1.depsOfClass)(k, phase));
-    }
-    /**
-     * Normalize deprecated scopes to their modern equivalents.
-     *
-     * - SESSION → CONTEXT (deprecated)
-     * - REQUEST → CONTEXT (deprecated)
-     *
-     * This enables backwards compatibility while unifying the scope model.
-     */
-    normalizeScope(scope) {
-        switch (scope) {
-            case common_1.ProviderScope.SESSION:
-            case common_1.ProviderScope.REQUEST:
-                return common_1.ProviderScope.CONTEXT;
-            default:
-                return scope;
-        }
-    }
-    getProviderScope(rec) {
-        const rawScope = rec.metadata?.scope ?? common_1.ProviderScope.GLOBAL;
-        return this.normalizeScope(rawScope);
-    }
-    getScope() {
-        return this.getActiveScope();
-    }
-    /* -------------------- Instantiation -------------------- */
-    async withTimeout(p, ms, label) {
-        if (ms <= 0 || !Number.isFinite(ms))
-            return p;
-        let timer;
-        try {
-            const tm = new Promise((_, rej) => (timer = setTimeout(() => rej(new Error(`Timeout after ${ms}ms: ${label}`)), ms)));
-            return await Promise.race([p, tm]);
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    async resolveFactoryArg(t, store, scopeKey) {
-        if (store.has(t))
-            return store.get(t);
-        if (this.instances.has(t))
-            return this.instances.get(t);
-        // Local def?
-        const rec = this.defs.get(t);
-        if (rec) {
-            const sc = this.getProviderScope(rec);
-            if (sc === common_1.ProviderScope.GLOBAL) {
-                if (!this.instances.has(t)) {
-                    throw new Error(`Dependency ${(0, token_utils_1.tokenName)(t)} (DEFAULT scope) is not instantiated`);
-                }
-                return this.instances.get(t);
-            }
-            else {
-                await this.buildIntoStore(t, rec, store, scopeKey);
-                return store.get(t);
-            }
-        }
-        // Parent def?
-        const up = this.lookupDefInHierarchy(t);
-        if (up) {
-            const sc = up.registry.getProviderScope(up.rec);
-            if (sc === common_1.ProviderScope.GLOBAL) {
-                const inst = up.registry.instances.get(t);
-                if (inst === undefined) {
-                    throw new Error(`Dependency ${(0, token_utils_1.tokenName)(t)} (DEFAULT scope) is not instantiated in parent`);
-                }
-                return inst;
-            }
-            else {
-                await up.registry.buildIntoStore(t, up.rec, store, scopeKey);
-                return store.get(t);
-            }
-        }
-        // Constructable fallback (non-DI)
-        if ((0, token_utils_1.isClass)(t)) {
-            if ((0, metadata_utils_1.hasAsyncWith)(t)) {
-                const out = t.with();
-                return (0, token_utils_1.isPromise)(out) ? await this.withTimeout(out, this.asyncTimeoutMs, `${t.name}.with(...)`) : out;
-            }
-            const instance = new t();
-            const init = instance?.init;
-            if (typeof init === 'function') {
-                const ret = init.call(instance);
-                if ((0, token_utils_1.isPromise)(ret))
-                    await this.withTimeout(ret, this.asyncTimeoutMs, `${t.name}.init()`);
-            }
-            return instance;
-        }
-        throw new Error(`Cannot resolve token ${(0, token_utils_1.tokenName)(t)}: not registered in hierarchy and not constructable.`);
-    }
-    /** Build a single DEFAULT-scoped singleton (used by incremental instantiating). */
-    async initiateOne(token, rec) {
-        switch (rec.kind) {
-            case common_1.ProviderKind.VALUE: {
-                this.instances.set(token, rec.useValue);
-                return;
-            }
-            case common_1.ProviderKind.FACTORY: {
-                const deps = this.invocationTokens(token, rec);
-                const args = [];
-                for (const d of deps)
-                    args.push(await this.resolveFactoryArg(d, this.instances));
-                const out = rec.useFactory(...args);
-                const val = (0, token_utils_1.isPromise)(out)
-                    ? await this.withTimeout(out, this.asyncTimeoutMs, `${(0, token_utils_1.tokenName)(token)}.useFactory(...)`)
-                    : out;
-                this.instances.set(token, val);
-                return;
-            }
-            case common_1.ProviderKind.CLASS: {
-                const depTokens = this.invocationTokens(token, rec);
-                const deps = depTokens.map((t) => this.resolveDefaultFromHierarchy(t));
-                const klass = rec.useClass;
-                if ((0, metadata_utils_1.hasAsyncWith)(klass)) {
-                    const out = klass.with(...deps);
-                    const val = (0, token_utils_1.isPromise)(out)
-                        ? await this.withTimeout(out, this.asyncTimeoutMs, `${klass.name}.with(...)`)
-                        : out;
-                    this.instances.set(token, val);
-                }
-                else {
-                    const instance = new klass(...deps);
-                    const init = instance?.init;
-                    if (typeof init === 'function') {
-                        const ret = init.call(instance);
-                        if ((0, token_utils_1.isPromise)(ret))
-                            await this.withTimeout(ret, this.asyncTimeoutMs, `${klass.name}.init()`);
-                    }
-                    this.instances.set(token, instance);
-                }
-                return;
-            }
-            case common_1.ProviderKind.CLASS_TOKEN: {
-                const depTokens = this.invocationTokens(token, rec);
-                const deps = depTokens.map((t) => this.resolveDefaultFromHierarchy(t));
-                const klass = rec.provide;
-                if ((0, metadata_utils_1.hasAsyncWith)(klass)) {
-                    const out = klass.with(...deps);
-                    const val = (0, token_utils_1.isPromise)(out)
-                        ? await this.withTimeout(out, this.asyncTimeoutMs, `${klass.name}.with(...)`)
-                        : out;
-                    this.instances.set(token, val);
-                }
-                else {
-                    const instance = new klass(...deps);
-                    const init = instance?.init;
-                    if (typeof init === 'function') {
-                        const ret = init.call(instance);
-                        if ((0, token_utils_1.isPromise)(ret))
-                            await this.withTimeout(ret, this.asyncTimeoutMs, `${klass.name}.init()`);
-                    }
-                    this.instances.set(token, instance);
-                }
-                return;
-            }
-        }
-    }
-    // Build a registered provider into the given scoped store (recursive for scoped deps).
-    async buildIntoStore(token, rec, store, scopeKey, injectedDeps) {
-        if (store.has(token))
-            return;
-        try {
-            switch (rec.kind) {
-                case common_1.ProviderKind.VALUE: {
-                    store.set(token, rec.useValue);
-                    return;
-                }
-                case common_1.ProviderKind.FACTORY: {
-                    const deps = this.invocationTokens(token, rec);
-                    const args = [];
-                    for (const d of deps)
-                        args.push(await this.resolveFactoryArg(d, store, scopeKey));
-                    const out = rec.useFactory(...args);
-                    const val = (0, token_utils_1.isPromise)(out)
-                        ? await this.withTimeout(out, this.asyncTimeoutMs, `${(0, token_utils_1.tokenName)(token)}.useFactory(...)`)
-                        : out;
-                    store.set(token, val);
-                    return;
-                }
-                case common_1.ProviderKind.CLASS: {
-                    const depsTokens = this.invocationTokens(token, rec);
-                    const deps = [];
-                    for (const d of depsTokens)
-                        deps.push(await this.resolveManagedForClass(d, store, scopeKey));
-                    const klass = rec.useClass;
-                    if ((0, metadata_utils_1.hasAsyncWith)(klass)) {
-                        const out = klass.with(...deps);
-                        const val = (0, token_utils_1.isPromise)(out)
-                            ? await this.withTimeout(out, this.asyncTimeoutMs, `${klass.name}.with(...)`)
-                            : out;
-                        store.set(token, val);
-                    }
-                    else {
-                        const instance = new klass(...deps);
-                        const init = instance?.init;
-                        if (typeof init === 'function') {
-                            const ret = init.call(instance);
-                            if ((0, token_utils_1.isPromise)(ret))
-                                await this.withTimeout(ret, this.asyncTimeoutMs, `${klass.name}.init()`);
-                        }
-                        store.set(token, instance);
-                    }
-                    return;
-                }
-                case common_1.ProviderKind.CLASS_TOKEN: {
-                    const depsTokens = this.invocationTokens(token, rec);
-                    const deps = injectedDeps ?? [];
-                    for (const d of depsTokens)
-                        deps.push(await this.resolveManagedForClass(d, store, scopeKey));
-                    const klass = rec.provide;
-                    if ((0, metadata_utils_1.hasAsyncWith)(klass)) {
-                        const out = klass.with(...deps);
-                        const val = (0, token_utils_1.isPromise)(out)
-                            ? await this.withTimeout(out, this.asyncTimeoutMs, `${klass.name}.with(...)`)
-                            : out;
-                        store.set(token, val);
-                    }
-                    else {
-                        const instance = new klass(...deps);
-                        const init = instance?.init;
-                        if (typeof init === 'function') {
-                            const ret = init.call(instance);
-                            if ((0, token_utils_1.isPromise)(ret))
-                                await this.withTimeout(ret, this.asyncTimeoutMs, `${klass.name}.init()`);
-                        }
-                        store.set(token, instance);
-                    }
-                    return;
-                }
-            }
-        }
-        catch (e) {
-            const msg = e?.message ?? e;
-            // Use safe logging to avoid Node.js 24 util.inspect bug with Zod errors
-            console.error(`Failed constructing:`, msg);
-            throw new Error(`Failed constructing (scoped) ${(0, token_utils_1.tokenName)(token)}: ${msg}`);
-        }
-    }
-    // Ensure managed dependency value for CLASS/CLASS_TOKEN providers:
-    // prefer scoped store, then singleton; recursively build scoped deps.
-    // If not local, climb the hierarchy and either read DEFAULT instance or build scoped into this store.
-    async resolveManagedForClass(d, store, scopeKey) {
-        if (store.has(d))
-            return store.get(d);
-        if (this.instances.has(d))
-            return this.instances.get(d);
-        // Local DI?
-        const depRec = this.defs.get(d);
-        if (depRec) {
-            const sc = this.getProviderScope(depRec);
-            if (sc === common_1.ProviderScope.GLOBAL) {
-                const v = this.instances.get(d);
-                if (v === undefined)
-                    throw new Error(`${(0, token_utils_1.tokenName)(d)} (DEFAULT scope) is not instantiated`);
-                return v;
-            }
-            else {
-                await this.buildIntoStore(d, depRec, store, scopeKey);
-                return store.get(d);
-            }
-        }
-        // Parent DI?
-        const up = this.lookupDefInHierarchy(d);
-        if (up) {
-            const sc = up.registry.getProviderScope(up.rec);
-            if (sc === common_1.ProviderScope.GLOBAL) {
-                const v = up.registry.instances.get(d);
-                if (v === undefined)
-                    throw new Error(`${(0, token_utils_1.tokenName)(d)} (DEFAULT scope) is not instantiated in parent`);
-                return v;
-            }
-            else {
-                await up.registry.buildIntoStore(d, up.rec, store, scopeKey);
-                return store.get(d);
-            }
-        }
-        throw new Error(`${(0, token_utils_1.tokenName)(d)} is not instantiated`);
-    }
-    get(token) {
-        if (this.instances.has(token))
-            return this.instances.get(token);
-        const rec = this.defs.get(token);
-        if (rec && this.getProviderScope(rec) !== common_1.ProviderScope.GLOBAL) {
-            const scName = common_1.ProviderScope[this.getProviderScope(rec)];
-            throw new Error(`Provider ${(0, token_utils_1.tokenName)(token)} is scoped (${scName}). Use getScoped(token, key).`);
-        }
-        // bubble to parent
-        if (this.providers)
-            return this.providers.get(token);
-        throw new Error(`Provider ${(0, token_utils_1.tokenName)(token)} is not available in local or parent registries`);
-    }
-    // noinspection JSUnusedGlobalSymbols
-    addRegistry(type, value) {
-        let registry = this.registries.get(type);
-        if (!registry) {
-            this.registries.set(type, new Set());
-            registry = this.registries.get(type);
-        }
-        registry.add(value);
-    }
-    getRegistries(type) {
-        return [...(this.registries.get(type) ?? [])];
-    }
-    getHooksRegistry() {
-        return this.getRegistries('HookRegistry')[0];
-    }
-    // noinspection JSUnusedGlobalSymbols
-    getScopeRegistry() {
-        return this.getRegistries('ScopeRegistry')[0];
-    }
-    /** bootstrap helper: resolve a dependency usable during app bootstrap (must be GLOBAL). */
-    async resolveBootstrapDep(t) {
-        if (this.instances.has(t))
-            return this.instances.get(t);
-        if (this.registries.has(t))
-            return this.registries.get(t);
-        const found = this.lookupDefInHierarchy(t);
-        if (found) {
-            const { registry, rec } = found;
-            const sc = registry.getProviderScope(rec);
-            if (sc !== common_1.ProviderScope.GLOBAL)
-                throw new Error(`Plugin dependency ${(0, token_utils_1.tokenName)(t)} must be DEFAULT-scoped at bootstrap`);
-            const v = registry.instances.get(t);
-            if (v === undefined)
-                throw new Error(`Plugin dependency ${(0, token_utils_1.tokenName)(t)} (DEFAULT scope) is not instantiated`);
-            return v;
-        }
-        throw new Error(`Cannot resolve plugin dependency ${(0, token_utils_1.tokenName)(t)} (local or parent)`);
-    }
-    /** Lightweight, synchronous resolver for app-scoped DI.
-     *  - If `cls` is a registered DEFAULT provider token, returns the singleton (must be instantiated).
-     *  - If `cls` is SCOPED in DI, throws (use getScoped/buildViews instead).
-     *  - Otherwise, if `cls` is a constructable class not registered in DI, returns `new cls()`.
-     *    If it defines a synchronous init(), it will be invoked (async init() is NOT awaited).
-     */
-    resolve(cls) {
-        // 1) If it's a registered token (local or parent), handle via DI rules
-        const found = this.lookupDefInHierarchy(cls);
-        if (found) {
-            const { registry, rec } = found;
-            const sc = registry.getProviderScope(rec);
-            if (sc !== common_1.ProviderScope.GLOBAL) {
-                const scName = common_1.ProviderScope[sc];
-                throw new Error(`Provider ${(0, token_utils_1.tokenName)(cls)} is scoped (${scName}). Use getScoped(token, key) or buildViews(...).`);
-            }
-            if (!registry.instances.has(cls)) {
-                throw new Error(`Provider ${(0, token_utils_1.tokenName)(cls)} (DEFAULT scope) is not instantiated. Call providers.instantiate() first.`);
-            }
-            return registry.instances.get(cls);
-        }
-        // 2) Not a registered token — best-effort construct (for tools/hooks/wrappers)
-        if ((0, token_utils_1.isClass)(cls)) {
-            const instance = new cls();
-            // Call sync init() if present (do NOT await)
-            const init = instance?.init;
-            if (typeof init === 'function') {
-                // If someone accidentally made init async here, we intentionally do NOT await to keep it sync.
-                init.call(instance);
-            }
-            return instance;
-        }
-        // 3) Unsupported token type
-        throw new Error(`Cannot resolve ${(0, token_utils_1.tokenName)(cls)}: not a registered DEFAULT provider and not a constructable class.`);
-    }
-    mergeFromRegistry(providedBy, exported) {
-        for (const { token, def, instance } of exported) {
-            if (def.metadata.scope === common_1.ProviderScope.GLOBAL) {
-                this.instances.set(token, instance);
-            }
-            this.defs.set(token, def);
-            this.providedBy.set(token, providedBy);
-        }
-    }
-    /**
-     * Used by plugins to get the exported provider definitions.
-     */
-    getProviderInfo(token) {
-        const def = this.defs.get(token);
-        const instance = this.instances.get(token);
-        if (!def || !instance)
-            throw new Error(`Cannot get provider info for ${(0, token_utils_1.tokenName)(token)}: not a registered DEFAULT provider and not a constructable class.`);
-        return {
-            token,
-            def,
-            instance,
-        };
-    }
-    injectProvider(injected) {
-        const rec = {
-            ...injected,
-            kind: common_1.ProviderKind.INJECTED,
-        };
-        this.tokens.add(rec.provide);
-        this.defs.set(rec.provide, rec);
-        this.graph.set(rec.provide, new Set());
-        this.instances.set(rec.provide, rec.value);
-    }
-    async addDynamicProviders(dynamicProviders) {
-        // Normalize ProviderType[] to ProviderRecord[] before instantiation
-        const normalized = dynamicProviders.map((p) => (0, provider_utils_1.normalizeProvider)(p));
-        return Promise.all(normalized.map((rec) => this.initiateOne(rec.provide, rec)));
-    }
-    getWithParents(token) {
-        if (this.instances.has(token)) {
-            return this.get(token);
-        }
-        const parent = this.parentProviders;
-        if (!parent) {
-            return this.get(token);
-        }
-        return parent.getWithParents(token);
-    }
-    getActiveScope() {
-        return this.getWithParents(scope_1.Scope);
-    }
-    getActiveServer() {
-        return this.getWithParents(common_1.FrontMcpServer);
-    }
-    /* -------------------- Session Cache Management -------------------- */
-    /**
-     * Clean up a specific session's provider cache.
-     * Call this when a session is terminated or expired.
-     *
-     * @param sessionKey - The session identifier to clean up
-     */
-    cleanupSession(sessionKey) {
-        this.sessionStores.delete(sessionKey);
-        // Resolve any waiters before deleting the lock to prevent hung promises
-        const lock = this.sessionBuildLocks.get(sessionKey);
-        if (lock) {
-            lock.resolve();
-            this.sessionBuildLocks.delete(sessionKey);
-        }
-    }
-    /**
-     * Clean up expired sessions from the cache.
-     * Sessions older than SESSION_CACHE_TTL_MS are removed.
-     *
-     * @returns Number of sessions cleaned up
-     */
-    cleanupExpiredSessions() {
-        const now = Date.now();
-        const cutoff = now - ProviderRegistry.SESSION_CACHE_TTL_MS;
-        let cleaned = 0;
-        for (const [key, entry] of this.sessionStores) {
-            if (entry.lastAccess < cutoff) {
-                this.sessionStores.delete(key);
-                // Resolve any waiters before deleting the lock to prevent hung promises
-                const lock = this.sessionBuildLocks.get(key);
-                if (lock) {
-                    lock.resolve();
-                    this.sessionBuildLocks.delete(key);
-                }
-                cleaned++;
-            }
-        }
-        return cleaned;
-    }
-    /**
-     * Start the background session cleanup timer.
-     * This periodically removes expired sessions from the cache.
-     */
-    startSessionCleanup() {
-        // Only start if not already running
-        if (this.sessionCleanupInterval) {
-            return;
-        }
-        this.sessionCleanupInterval = setInterval(() => {
-            const cleaned = this.cleanupExpiredSessions();
-            if (cleaned > 0) {
-                console.debug(`[ProviderRegistry] Cleaned up ${cleaned} expired sessions`);
-            }
-        }, ProviderRegistry.SESSION_CLEANUP_INTERVAL_MS);
-        // Allow the process to exit even if the interval is running
-        // This is important for graceful shutdown in serverless environments
-        if (this.sessionCleanupInterval.unref) {
-            this.sessionCleanupInterval.unref();
-        }
-    }
-    /**
-     * Stop the background session cleanup timer.
-     * Call this when shutting down the server gracefully.
-     */
-    stopSessionCleanup() {
-        if (this.sessionCleanupInterval) {
-            clearInterval(this.sessionCleanupInterval);
-            this.sessionCleanupInterval = null;
-        }
-    }
-    /**
-     * Dispose of the registry, cleaning up all resources.
-     * Call this when the registry/scope is being destroyed to prevent:
-     * - Memory leaks from retained interval handles
-     * - Orphaned session cleanup timers
-     *
-     * @example
-     * ```typescript
-     * // In scope teardown
-     * scope.providers.dispose();
-     * ```
-     */
-    dispose() {
-        this.stopSessionCleanup();
-        // Clear all session stores to help garbage collection
-        this.sessionStores.clear();
-        // Resolve any pending locks to prevent hung promises
-        for (const lock of this.sessionBuildLocks.values()) {
-            lock.resolve();
-        }
-        this.sessionBuildLocks.clear();
-    }
-    /**
-     * Get session cache statistics for monitoring.
-     */
-    getSessionCacheStats() {
-        return {
-            size: this.sessionStores.size,
-            maxSize: ProviderRegistry.MAX_SESSION_CACHE_SIZE,
-            ttlMs: ProviderRegistry.SESSION_CACHE_TTL_MS,
-        };
-    }
-    /* -------------------- Scoped Provider Views -------------------- */
-    /**
-     * Build provider instance views for different scopes.
-     *
-     * This method creates a complete view of providers across all scopes:
-     * - GLOBAL: Returns existing singleton instances (read-only)
-     * - CONTEXT: Builds per-context providers (unified session + request)
-     *
-     * Note: For backwards compatibility, SESSION and REQUEST scopes are normalized
-     * to CONTEXT. The returned views include `session` and `request` aliases that
-     * both point to the `context` store.
-     *
-     * @param sessionKey - Unique context/session identifier for CONTEXT-scoped providers
-     * @param contextProviders - Optional pre-built CONTEXT-scoped providers (e.g., FrontMcpContext)
-     * @returns ProviderViews with global and context provider maps (session/request as aliases)
-     */
-    async buildViews(sessionKey, contextProviders) {
-        // Early validation BEFORE any cache operations or lock acquisition
-        // This prevents cache pollution with invalid session keys
-        session_key_provider_1.SessionKey.validate(sessionKey);
-        // 1. Global providers - return existing singletons
-        const global = this.getAllSingletons();
-        // 2. Context providers - build per-context (unified session+request)
-        // Note: We don't cache context providers because they're per-request.
-        // The unified context model means all non-global providers are fresh per-request.
-        const contextStore = new Map(contextProviders);
-        // Inject SessionKey for backwards compatibility with providers that depend on it
-        // @deprecated - Providers should migrate to using FRONTMCP_CONTEXT instead
-        if (!contextStore.has(session_key_provider_1.SessionKey)) {
-            contextStore.set(session_key_provider_1.SessionKey, new session_key_provider_1.SessionKey(sessionKey));
-        }
-        // Build all CONTEXT-scoped providers (including normalized SESSION/REQUEST)
-        for (const token of this.order) {
-            const rec = this.defs.get(token);
-            if (!rec)
-                continue;
-            // getProviderScope() already normalizes SESSION/REQUEST → CONTEXT
-            if (this.getProviderScope(rec) !== common_1.ProviderScope.CONTEXT)
-                continue;
-            if (contextStore.has(token))
-                continue;
-            await this.buildIntoStoreWithViews(token, rec, contextStore, sessionKey, contextStore, global);
-        }
-        // Return views with backwards-compatible aliases
-        // All three (context, session, request) point to the same map
-        return {
-            global,
-            context: contextStore,
-            // Backwards compatibility aliases
-            session: contextStore,
-            request: contextStore,
-        };
-    }
-    /**
-     * Build a provider into a store, with access to context and global views for dependencies.
-     */
-    async buildIntoStoreWithViews(token, rec, store, scopeKey, contextStore, globalStore) {
-        if (store.has(token))
-            return;
-        try {
-            switch (rec.kind) {
-                case common_1.ProviderKind.VALUE: {
-                    store.set(token, rec.useValue);
-                    return;
-                }
-                case common_1.ProviderKind.FACTORY: {
-                    const deps = this.invocationTokens(token, rec);
-                    const args = [];
-                    for (const d of deps) {
-                        args.push(await this.resolveFromViews(d, contextStore, globalStore, scopeKey));
-                    }
-                    const out = rec.useFactory(...args);
-                    const val = (0, token_utils_1.isPromise)(out)
-                        ? await this.withTimeout(out, this.asyncTimeoutMs, `${(0, token_utils_1.tokenName)(token)}.useFactory(...)`)
-                        : out;
-                    store.set(token, val);
-                    return;
-                }
-                case common_1.ProviderKind.CLASS:
-                case common_1.ProviderKind.CLASS_TOKEN: {
-                    const depsTokens = this.invocationTokens(token, rec);
-                    const deps = [];
-                    for (const d of depsTokens) {
-                        deps.push(await this.resolveFromViews(d, contextStore, globalStore, scopeKey));
-                    }
-                    const klass = rec.kind === common_1.ProviderKind.CLASS ? rec.useClass : rec.provide;
-                    if ((0, metadata_utils_1.hasAsyncWith)(klass)) {
-                        const out = klass.with(...deps);
-                        const val = (0, token_utils_1.isPromise)(out)
-                            ? await this.withTimeout(out, this.asyncTimeoutMs, `${klass.name}.with(...)`)
-                            : out;
-                        store.set(token, val);
-                    }
-                    else {
-                        const instance = new klass(...deps);
-                        const init = instance?.init;
-                        if (typeof init === 'function') {
-                            const ret = init.call(instance);
-                            if ((0, token_utils_1.isPromise)(ret))
-                                await this.withTimeout(ret, this.asyncTimeoutMs, `${klass.name}.init()`);
-                        }
-                        store.set(token, instance);
-                    }
-                    return;
-                }
-            }
-        }
-        catch (e) {
-            const msg = e?.message ?? e;
-            console.error(`Failed constructing (context-scoped):`, msg);
-            throw new Error(`Failed constructing (context-scoped) ${(0, token_utils_1.tokenName)(token)}: ${msg}`);
-        }
-    }
-    /**
-     * Resolve a dependency from the available views (context → global).
-     */
-    async resolveFromViews(token, contextStore, globalStore, scopeKey) {
-        // Check stores in order: context -> global -> instances
-        if (contextStore.has(token))
-            return contextStore.get(token);
-        if (globalStore.has(token))
-            return globalStore.get(token);
-        if (this.instances.has(token))
-            return this.instances.get(token);
-        // Try to build if it's a registered provider
-        const rec = this.defs.get(token);
-        if (rec) {
-            const scope = this.getProviderScope(rec);
-            if (scope === common_1.ProviderScope.GLOBAL) {
-                throw new Error(`GLOBAL dependency ${(0, token_utils_1.tokenName)(token)} is not instantiated`);
-            }
-            else {
-                // CONTEXT scope - build into context store
-                await this.buildIntoStoreWithViews(token, rec, contextStore, scopeKey, contextStore, globalStore);
-                return contextStore.get(token);
-            }
-        }
-        // Check parent hierarchy
-        const up = this.lookupDefInHierarchy(token);
-        if (up) {
-            const sc = up.registry.getProviderScope(up.rec);
-            if (sc === common_1.ProviderScope.GLOBAL) {
-                const v = up.registry.instances.get(token);
-                if (v !== undefined)
-                    return v;
-                throw new Error(`GLOBAL dependency ${(0, token_utils_1.tokenName)(token)} is not instantiated in parent`);
-            }
-        }
-        throw new Error(`Cannot resolve dependency ${(0, token_utils_1.tokenName)(token)} from views`);
-    }
-    /**
-     * Get a provider from the given views, checking context → global.
-     *
-     * @param token - The provider token to look up
-     * @param views - The provider views to search
-     * @returns The provider instance
-     * @throws Error if provider not found in any view
-     */
-    getScoped(token, views) {
-        // Check context first (unified session+request store)
-        if (views.context.has(token))
-            return views.context.get(token);
-        if (views.global.has(token))
-            return views.global.get(token);
-        // Check instances as fallback for global providers
-        if (this.instances.has(token))
-            return this.instances.get(token);
-        throw new Error(`Provider ${(0, token_utils_1.tokenName)(token)} not found in views. Ensure it was built via buildViews().`);
-    }
-}
-exports.default = ProviderRegistry;
-//# sourceMappingURL=provider.registry.js.map