@frontmcp/sdk 0.2.3 → 0.3.0

package/src/provider/provider.registry.js

@@ -0,0 +1,679 @@
+"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");
+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();
+    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.getScope(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.getScope(depRec) : up.registry.getScope(depRec);
+                if (this.getScope(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.getScope(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;
+                console.error(`Failed instantiating`, e);
+                throw new Error(`Failed constructing ${(0, token_utils_1.tokenName)(token)}: ${msg}`);
+            }
+        }
+    }
+    /* -------------------- 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
+    }
+    // /** Get (or create) the mutable session store for a sessionId. */
+    // sessionMap(sessionId: string): Map<Token, unknown> {
+    //   let store = this.scoped.get(sessionId);
+    //   if (!store) {
+    //     store = new Map<Token, unknown>();
+    //     this.scoped.set(sessionId, store);
+    //   }
+    //   return store;
+    // }
+    // /** Try to build SessionProvider from registered DI definition (CLASS/FACTORY/etc.). */
+    // private async tryBuildRegisteredSessionProvider(
+    //   sessionId: string,
+    //   requestId?: string | number,
+    // ): Promise<SessionProvider | undefined> {
+    //   // Prefer local def; otherwise look up in hierarchy
+    //   const found = this.lookupDefInHierarchy(SessionProvider as unknown as Token);
+    //   const rec = found?.rec;
+    //   const reg = found?.registry;
+    //
+    //   if (!rec) return undefined;
+    //
+    //   const sc = (rec as any).scope ?? ProviderScope.GLOBAL;
+    //   if (sc === ProviderScope.GLOBAL) {
+    //     // If someone registered a DEFAULT-scoped SessionProvider, use the singleton instance (from the owning registry)
+    //     if (!reg!.instances.has(SessionProvider)) {
+    //       throw new Error(
+    //         `Registered ${tokenName(SessionProvider)} (DEFAULT) not instantiated at bootstrap`,
+    //       );
+    //     }
+    //     return reg!.instances.get(SessionProvider) as SessionProvider;
+    //   }
+    //
+    //   // Build into the session store using the owning registry's factory (so its metadata/defs are used)
+    //   const store = this.sessionMap(sessionId);
+    //   await reg!.buildIntoStore(
+    //     SessionProvider as unknown as Token,
+    //     rec,
+    //     store,
+    //     sessionId,
+    //     [sessionId, requestId],
+    //   );
+    //   const sp = store.get(SessionProvider as unknown as Token) as SessionProvider | undefined;
+    //
+    //   // Ensure request id is set/updated, if setter exists
+    //   if (sp && requestId && typeof sp.setRequestId === 'function') sp.setRequestId(requestId);
+    //   return sp;
+    // }
+    // /** Ensure a SessionProvider is present in the session map (registered or anonymous).
+    //  * @deprecated
+    //  */
+    // async ensureSessionProvider(sessionId: string, requestId?: string | number): Promise<SessionProvider> {
+    //   const store = this.sessionMap(sessionId);
+    //
+    //   // already present
+    //   if (store.has(SessionProvider)) {
+    //     const sp = store.get(SessionProvider) as SessionProvider;
+    //     if (requestId && typeof sp.setRequestId === 'function') sp.setRequestId(requestId);
+    //     return sp;
+    //   }
+    //
+    //   // try registered provider first (local or parent)
+    //   const registered = await this.tryBuildRegisteredSessionProvider(sessionId, requestId);
+    //   return registered as SessionProvider;
+    //
+    // }
+    // /**
+    //  * Create (or get) an authenticated session store, seed SessionProvider if missing.
+    //  * @deprecated
+    //  * */
+    // bootstrapSession(sessionId: string, requestId?: string): Map<Token, unknown> {
+    //   let store = this.scoped.get(sessionId);
+    //   if (!store) {
+    //     store = new Map<Token, unknown>();
+    //     this.scoped.set(sessionId, store);
+    //   }
+    //   if (!store.has(SessionProvider)) {
+    //     store.set(SessionProvider, {}); // new SessionProvider(sessionId, requestId ?? '', false));
+    //   } else if (requestId) {
+    //     (store.get(SessionProvider) as SessionProvider).setRequestId(requestId);
+    //   }
+    //   return store;
+    // }
+    // /**
+    //  * Returns all tokens that are registered as session-scoped (including SessionProvider).
+    //  * @deprecated
+    //  */
+    // listSessionScopedTokens(): Token[] {
+    //   const out: Token[] = [];
+    //   // Only local scoped tokens are known here; parent-scoped tokens will be pulled on demand.
+    //   for (const [tok, rec] of this.defs.entries()) {
+    //     if (this.getScope(rec) === ProviderScope.SESSION) out.push(tok);
+    //   }
+    //   return out;
+    // }
+    // /** Eager build selected session providers into the given session store. */
+    // private async buildSelectedSessionProviders(sessionId: string, requestId?: string | number): Promise<void> {
+    //   const store = this.sessionMap(sessionId);
+    //   await this.ensureSessionProvider(sessionId, requestId);
+    //
+    //   // Iterate over all session-scoped tokens (local list). Parent-scoped will resolve on demand.
+    //   for (const tok of this.listSessionScopedTokens()) {
+    //     if (tok === (SessionProvider as any)) continue;
+    //
+    //     if (store.has(tok)) continue; // already built
+    //
+    //     const rec = this.defs.get(tok);
+    //     if (!rec) continue; // should not happen
+    //
+    //     // Recursively build into this session store (handles scoped/default deps)
+    //     await this.buildIntoStore(tok, rec, store, sessionId);
+    //   }
+    // }
+    // /** Convenience: build all three maps you can pass straight into an invoke ctx. */
+    // async buildViews(sessionId: string, requestId?: string | number): Promise<ProviderViews> {
+    //   await this.buildSelectedSessionProviders(sessionId, requestId);
+    //   return {
+    //     global: this.getAllSingletons(),
+    //     session: this.sessionMap(sessionId),
+    //     request: new Map<Token, unknown>(),
+    //   };
+    // }
+    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));
+    }
+    getScope(rec) {
+        return rec.metadata?.scope ?? common_1.ProviderScope.GLOBAL;
+    }
+    /* -------------------- 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.getScope(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.getScope(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;
+            console.error(`Failed constructing`, e);
+            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.getScope(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.getScope(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.getScope(rec) !== common_1.ProviderScope.GLOBAL) {
+            const scName = common_1.ProviderScope[this.getScope(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.getScope(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.getScope(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) {
+        return Promise.all(dynamicProviders.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);
+    }
+    async buildViews(session) {
+        return {
+            global: new Map(),
+            session: new Map(),
+            request: new Map(),
+        };
+    }
+}
+exports.default = ProviderRegistry;
+//# sourceMappingURL=provider.registry.js.map