@antelopejs/core 1.4.9 → 1.4.11

package/dist/core/resolution/resolver.js

@@ -1,23 +1,73 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Resolver = void 0;
-const node_module_1 = __importDefault(require("node:module"));
-const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const interface_core_1 = require("@antelopejs/interface-core");
 const internal_1 = require("@antelopejs/interface-core/internal");
 const package_resolution_1 = require("./package-resolution");
 const CORE_PKG = "@antelopejs/interface-core";
 const CORE_PACKAGE = (0, package_resolution_1.resolvePackage)(CORE_PKG, __dirname);
 const CORE_RESOLVE_FROM = CORE_PACKAGE?.root ?? __dirname;
 const CORE_ENTRY = CORE_PACKAGE?.entry ?? CORE_PKG;
-const CORE_ENTRY_RELATIVE = CORE_PACKAGE
-    ? node_path_1.default.relative(CORE_PACKAGE.root, CORE_PACKAGE.entry)
-    : node_path_1.default.join("dist", "index.js");
-const CORE_PROXIES_RELATIVE = node_path_1.default.join("dist", "proxies.js");
+const CLASS_PREFIX = "class ";
+const PROXY_ATTACHMENT_METHODS = new Set([
+    "detach",
+    "onCall",
+    "onHandlers",
+    "onRegister",
+    "onUnregister",
+]);
 let nextResolverIdentity = 1;
-let nextAliasIdentity = 2;
+function isRecognizedInterfaceProxy(value, kind) {
+    if (node_util_1.types.isProxy(value)) {
+        return false;
+    }
+    if (value instanceof interface_core_1.AsyncProxy ||
+        value instanceof interface_core_1.EventProxy ||
+        value instanceof interface_core_1.RegisteringProxy) {
+        return (0, interface_core_1.IsInterfaceProxy)(value, kind);
+    }
+    try {
+        return (0, interface_core_1.IsInterfaceProxy)(value, kind);
+    }
+    catch {
+        return false;
+    }
+}
+function getProxyCandidate(candidate) {
+    if (typeof candidate === "function" && "proxy" in candidate) {
+        return candidate.proxy;
+    }
+    return candidate;
+}
+function collectProxyReferences(value) {
+    const references = [];
+    const visited = new WeakSet();
+    const visit = (candidate) => {
+        if ((typeof candidate !== "object" && typeof candidate !== "function") ||
+            candidate === null) {
+            return;
+        }
+        if (node_util_1.types.isProxy(candidate)) {
+            return;
+        }
+        const proxy = getProxyCandidate(candidate);
+        if (isRecognizedInterfaceProxy(proxy)) {
+            const identity = (0, interface_core_1.GetInterfaceProxyIdentity)(proxy);
+            if (identity) {
+                references.push({ identity, proxy: proxy });
+            }
+            return;
+        }
+        if (visited.has(candidate)) {
+            return;
+        }
+        visited.add(candidate);
+        Object.values(candidate).forEach(visit);
+    };
+    visit(value);
+    return references;
+}
 class Resolver {
     pathMapper;
     moduleByFolder = new Map();
@@ -25,85 +75,153 @@ class Resolver {
     interfacePackages = new Map();
     interfacePackageEntries = new Map();
     interfacePackageResolveFrom = new Map();
+    lifecycleInterfacePackages = new Set();
+    stubbedInterfacePackages = new Set();
     stubModulePath;
     resolverIdentity = nextResolverIdentity++;
-    interfaceAliases = new Map();
-    facadeWrappers = new WeakMap();
-    facadePaths = new WeakMap();
+    interfaceGraphFiles = new Map();
+    interfaceDependencies = new Map();
+    boundValues = new WeakMap();
+    routedEvents = new Map();
+    proxyOwners = new Map();
+    providerlessContexts = new WeakMap();
+    stubbedContexts = new WeakSet();
     constructor(pathMapper) {
         this.pathMapper = pathMapper;
     }
     resolve(request, parent) {
-        if (this.isExactResolverPath(request)) {
-            return { resolvedPath: request, exact: true };
-        }
-        const inheritedAlias = this.resolveInheritedAlias(request, parent?.filename);
-        if (inheritedAlias) {
-            return inheritedAlias;
-        }
-        const matchingModule = this.resolveLocalModule(parent?.filename);
-        if (matchingModule) {
-            const mapped = this.pathMapper.resolve(request, matchingModule.manifest);
+        const parentModule = this.resolveLocalModule(parent?.filename);
+        if (parentModule) {
+            const mapped = this.pathMapper.resolve(request, parentModule.manifest);
             if (mapped) {
                 return { resolvedPath: mapped };
             }
         }
         const coreResult = this.resolveInterfaceCore(request);
         if (coreResult) {
-            return coreResult;
+            return this.bindResultProvider(coreResult, CORE_PKG, false, parent, parentModule);
         }
         const interfaceRequest = this.resolveInterfacePackage(request);
         if (interfaceRequest) {
-            const provider = matchingModule
-                ? this.resolveProvider(matchingModule, interfaceRequest.packageName)
-                : undefined;
-            if (!provider) {
-                return interfaceRequest.result;
-            }
-            return {
-                ...interfaceRequest.result,
-                alias: this.getInterfaceAlias(interfaceRequest.packageName, provider),
-            };
+            this.trackInterfaceDependency(parent?.filename, interfaceRequest.packageName);
+            return this.bindResultProvider(interfaceRequest.result, interfaceRequest.packageName, this.interfaceGraphFiles.get(parent?.filename ?? "") !==
+                interfaceRequest.packageName, parent, parentModule);
         }
-        return undefined;
+        return this.resolveRelativeInterface(request, parent, parentModule);
     }
-    ownsResolutionContext(request, parent) {
-        return Boolean(this.isExactResolverPath(request) ||
-            (parent?.filename &&
-                (this.findAliasByPath(parent.filename) ||
-                    this.resolveLocalModule(parent.filename))));
+    ownsResolutionContext(_request, parent) {
+        const contextModule = (0, internal_1.getModuleContext)()?.module;
+        if (contextModule && this.modulesById.has(contextModule)) {
+            return true;
+        }
+        return Boolean(this.resolveLocalModule(parent?.filename));
     }
     requiresPreResolution(request, parent) {
-        if (parent?.filename && this.findAliasByPath(parent.filename)) {
-            return true;
+        return Boolean(this.findRequestedInterface(request, parent?.filename));
+    }
+    bindProviderRoutes(result, value) {
+        const references = collectProxyReferences(value);
+        if (result.interfaceName) {
+            this.registerProxyOwners(result.interfaceName, references);
+        }
+        const context = (0, internal_1.captureModuleContext)();
+        if (!context?.providerRoutes) {
+            return value;
+        }
+        this.replayKnownRoutes(context);
+        if (!result.provider) {
+            return this.bindStubbedInterfaceValue(result, value, context);
         }
-        const matchingModule = this.resolveLocalModule(parent?.filename);
-        const interfaceRequest = this.findInterfacePackageRequest(request);
-        return Boolean(matchingModule &&
-            interfaceRequest &&
-            this.resolveProvider(matchingModule, interfaceRequest));
+        this.bindImportedRoutes(context, result, references);
+        return result.bindExports ? this.bindInterfaceValue(value, context) : value;
     }
-    applyAlias(resolvedPath, alias) {
-        if (!alias) {
-            return resolvedPath;
+    trackInterfaceFile(result, resolvedPath) {
+        if (result.interfaceName) {
+            this.interfaceGraphFiles.set(resolvedPath, result.interfaceName);
         }
-        const coreFacade = this.resolveCoreFacade(resolvedPath, alias);
-        if (coreFacade) {
-            return coreFacade;
+    }
+    getInterfaceEntryToPrime(result, resolvedPath) {
+        const interfaceName = result.interfaceName;
+        if (!interfaceName || this.lifecycleInterfacePackages.has(interfaceName)) {
+            return undefined;
         }
-        if (!(0, package_resolution_1.isPathWithin)(resolvedPath, alias.root)) {
-            return resolvedPath;
+        const entry = this.interfacePackageEntries.get(interfaceName);
+        if (!entry || entry === resolvedPath || require.cache[entry]) {
+            return undefined;
         }
-        const relativePath = node_path_1.default.relative(alias.root, resolvedPath);
-        return `${alias.root}${node_path_1.default.sep.repeat(alias.separatorCount)}${relativePath}`;
+        return {
+            ...result,
+            resolvedPath: entry,
+            resolveFrom: undefined,
+            bindExports: false,
+        };
+    }
+    isInterfaceGraphFile(filePath) {
+        return this.interfaceGraphFiles.has(filePath);
+    }
+    buildProviderRoutes(moduleId) {
+        const routes = {};
+        this.bindKnownRoutes(moduleId, routes);
+        return routes;
     }
     clearCache() {
-        for (const cachePath of Object.keys(require.cache)) {
-            if (this.isExactResolverPath(cachePath)) {
-                delete require.cache[cachePath];
+        for (const event of this.routedEvents.values()) {
+            internal_1.internal.knownEvents.delete(event);
+            const identity = (0, interface_core_1.GetInterfaceProxyIdentity)(event);
+            if (identity) {
+                internal_1.internal.proxyStates.delete(identity);
+            }
+        }
+        this.routedEvents.clear();
+        this.interfaceGraphFiles.clear();
+        this.interfaceDependencies.clear();
+        this.proxyOwners.clear();
+    }
+    registerProxyOwners(interfaceName, references) {
+        for (const { identity, proxy } of references) {
+            const owner = this.proxyOwners.get(identity);
+            if (!owner) {
+                this.proxyOwners.set(identity, {
+                    interfaceName,
+                    proxies: new WeakSet([proxy]),
+                });
+                continue;
+            }
+            if (owner.interfaceName !== interfaceName && !owner.proxies.has(proxy)) {
+                throw new Error(`Interface packages '${owner.interfaceName}' and '${interfaceName}' declare distinct proxies with identity '${identity}'. Use unique interface proxy identities.`);
+            }
+            owner.proxies.add(proxy);
+        }
+    }
+    bindImportedRoutes(context, result, references) {
+        for (const { identity } of references) {
+            const owner = this.proxyOwners.get(identity)?.interfaceName;
+            if (result.interfaceName && owner !== result.interfaceName) {
+                continue;
+            }
+            this.bindRoute(context.module, context.providerRoutes, identity, result.provider);
+        }
+    }
+    replayKnownRoutes(context) {
+        this.bindKnownRoutes(context.module, context.providerRoutes);
+    }
+    bindKnownRoutes(moduleId, routes) {
+        const module = this.modulesById.get(moduleId);
+        if (!module) {
+            return;
+        }
+        for (const [identity, { interfaceName }] of this.proxyOwners) {
+            for (const provider of this.resolveProviders(module, interfaceName)) {
+                this.bindRoute(moduleId, routes, identity, provider);
             }
         }
-        this.interfaceAliases.clear();
+    }
+    bindRoute(moduleId, routes, identity, provider) {
+        const current = routes[identity];
+        if (current && current !== provider) {
+            throw new Error(`Module '${moduleId}' resolves proxy '${identity}' to both '${current}' and '${provider}'. Use unique interface proxy identities.`);
+        }
+        routes[identity] = provider;
     }
     resolveInterfaceCore(request) {
         if (request === CORE_PKG) {
@@ -115,43 +233,44 @@ class Resolver {
         return undefined;
     }
     resolveInterfacePackage(request) {
-        for (const [pkg, rootDir] of this.interfacePackages) {
-            if (request === pkg) {
+        for (const [packageName, rootDir] of this.interfacePackages) {
+            if (request === packageName) {
                 return {
-                    packageName: pkg,
+                    packageName,
                     result: {
-                        resolvedPath: this.interfacePackageEntries.get(pkg) ?? rootDir,
+                        resolvedPath: this.interfacePackageEntries.get(packageName) ?? rootDir,
                     },
                 };
             }
-            if (request.startsWith(`${pkg}/`)) {
+            if (request.startsWith(`${packageName}/`)) {
                 return {
-                    packageName: pkg,
+                    packageName,
                     result: {
                         resolvedPath: request,
-                        resolveFrom: this.interfacePackageResolveFrom.get(pkg) ?? rootDir,
+                        resolveFrom: this.interfacePackageResolveFrom.get(packageName) ?? rootDir,
                     },
                 };
             }
         }
         return undefined;
     }
-    resolveInheritedAlias(request, parentFilename) {
-        if (!parentFilename) {
+    resolveRelativeInterface(request, parent, parentModule) {
+        if (!request.startsWith(".") || !parent?.filename) {
             return undefined;
         }
-        const alias = this.findAliasByPath(parentFilename);
-        if (!alias) {
+        const packageName = this.findInterfacePackageByPath(parent.filename);
+        if (!packageName) {
             return undefined;
         }
-        const coreResult = this.resolveInterfaceCore(request);
-        if (coreResult) {
-            return { ...coreResult, alias };
-        }
+        return this.bindResultProvider({ resolvedPath: request }, packageName, !this.interfaceGraphFiles.has(parent.filename), parent, parentModule);
+    }
+    bindResultProvider(result, packageName, bindExports, parent, parentModule) {
+        const provider = this.resolveRequestProvider(packageName, parent?.filename, parentModule);
         return {
-            resolvedPath: request,
-            parentFilename: this.removeAlias(parentFilename, alias),
-            alias,
+            ...result,
+            bindExports,
+            interfaceName: packageName,
+            provider,
         };
     }
     resolveProvider(module, packageName) {
@@ -160,124 +279,303 @@ class Resolver {
         }
         return internal_1.internal.interfaceConnections[module.id]?.[packageName]?.find(({ selected }) => selected)?.provider;
     }
-    getInterfaceAlias(packageName, provider) {
-        const key = `${packageName}\0${provider}`;
-        const existing = this.interfaceAliases.get(key);
-        if (existing) {
-            return existing;
+    resolveRequestProvider(packageName, parentFilename, parentModule) {
+        const contextModule = (0, internal_1.getModuleContext)()?.module;
+        const consumer = contextModule
+            ? this.modulesById.get(contextModule)
+            : undefined;
+        const direct = consumer
+            ? this.resolveProvider(consumer, packageName)
+            : undefined;
+        if (direct) {
+            return direct;
         }
-        const root = this.interfacePackages.get(packageName);
-        const separatorCount = nextAliasIdentity++;
-        const alias = {
-            root,
-            separatorCount,
-            coreFacadeEntries: new Set(),
-        };
-        this.facadeWrappers.set(alias, new Map());
-        this.facadePaths.set(alias, new Map());
-        this.interfaceAliases.set(key, alias);
-        return alias;
+        const parentInterface = parentFilename
+            ? this.interfaceGraphFiles.get(parentFilename)
+            : undefined;
+        const inherited = consumer && parentInterface
+            ? this.resolveChildProvider(consumer, parentInterface, packageName)
+            : undefined;
+        return (inherited ??
+            (parentModule
+                ? this.resolveProvider(parentModule, packageName)
+                : undefined));
     }
-    resolveCoreFacade(entry, alias) {
-        if (!node_path_1.default.isAbsolute(entry)) {
-            return undefined;
+    resolveChildProvider(consumer, parentInterface, childInterface) {
+        for (const provider of this.resolveProviders(consumer, parentInterface)) {
+            const providerModule = this.modulesById.get(provider);
+            const childProvider = providerModule
+                ? this.resolveProvider(providerModule, childInterface)
+                : undefined;
+            if (childProvider) {
+                return childProvider;
+            }
         }
-        const corePackage = (0, package_resolution_1.findPackageFromEntry)(entry, CORE_PKG, node_path_1.default.dirname(entry));
-        if (!corePackage || !this.isFacadeCoreEntry(entry, corePackage.root)) {
-            return undefined;
+        return undefined;
+    }
+    resolveProviders(module, interfaceName, visited = new Set()) {
+        const direct = this.resolveProvider(module, interfaceName);
+        if (direct) {
+            return new Set([direct]);
         }
-        const paths = this.facadePaths.get(alias);
-        const existing = paths.get(entry);
-        if (existing) {
-            return existing;
+        if (visited.has(interfaceName)) {
+            return new Set();
         }
-        const wrappersByRoot = this.facadeWrappers.get(alias);
-        const namespace = `${this.resolverIdentity}:${alias.separatorCount}`;
-        const coreEntry = node_path_1.default.join(corePackage.root, CORE_ENTRY_RELATIVE);
-        const wrappers = wrappersByRoot.get(corePackage.root) ??
-            this.createCoreWrappers(namespace, coreEntry);
-        wrappersByRoot.set(corePackage.root, wrappers);
-        const facadePath = this.createCoreFacade(entry, wrappers, namespace);
-        paths.set(entry, facadePath);
-        alias.coreFacadeEntries.add(facadePath);
-        return facadePath;
-    }
-    createCoreWrappers(namespace, coreEntry) {
-        const core = require(coreEntry);
-        let nextAnonymousIdentity = 1;
-        const namespacedIdentity = (identity) => `${namespace}:${identity ?? `anonymous:${nextAnonymousIdentity++}`}`;
-        class AsyncProxy extends core.AsyncProxy {
-            constructor(identity) {
-                super(namespacedIdentity(identity));
+        visited.add(interfaceName);
+        const providers = new Set();
+        for (const [parent, children] of this.interfaceDependencies) {
+            if (!children.has(interfaceName)) {
+                continue;
             }
+            this.collectChildProviders(module, parent, interfaceName, visited, providers);
         }
-        class EventProxy extends core.EventProxy {
-            constructor(identity) {
-                super(namespacedIdentity(identity));
+        return providers;
+    }
+    collectChildProviders(module, parentInterface, childInterface, visited, providers) {
+        for (const parentProvider of this.resolveProviders(module, parentInterface, new Set(visited))) {
+            const providerModule = this.modulesById.get(parentProvider);
+            const childProvider = providerModule
+                ? this.resolveProvider(providerModule, childInterface)
+                : undefined;
+            if (childProvider) {
+                providers.add(childProvider);
             }
         }
-        class RegisteringProxy extends core.RegisteringProxy {
-            constructor(identity) {
-                super(namespacedIdentity(identity));
+    }
+    trackInterfaceDependency(parentFilename, childInterface) {
+        const parentInterface = parentFilename
+            ? this.interfaceGraphFiles.get(parentFilename)
+            : undefined;
+        if (!parentInterface || parentInterface === childInterface) {
+            return;
+        }
+        const dependencies = this.interfaceDependencies.get(parentInterface) ?? new Set();
+        dependencies.add(childInterface);
+        this.interfaceDependencies.set(parentInterface, dependencies);
+    }
+    findRequestedInterface(request, parentFilename) {
+        if (request === CORE_PKG || request.startsWith(`${CORE_PKG}/`)) {
+            return CORE_PKG;
+        }
+        const direct = this.findInterfacePackageRequest(request);
+        if (direct) {
+            return direct;
+        }
+        return request.startsWith(".") && parentFilename
+            ? this.findInterfacePackageByPath(parentFilename)
+            : undefined;
+    }
+    findInterfacePackageRequest(request) {
+        return [...this.interfacePackages.keys()].find((packageName) => request === packageName || request.startsWith(`${packageName}/`));
+    }
+    findInterfacePackageByPath(fileName) {
+        const coreRoot = CORE_PACKAGE?.root ?? "";
+        let matchingRoot = coreRoot && (0, package_resolution_1.isPathWithin)(fileName, coreRoot) ? coreRoot : "";
+        let matchingPackage = matchingRoot ? CORE_PKG : undefined;
+        for (const [packageName, root] of this.interfacePackages) {
+            if ((0, package_resolution_1.isPathWithin)(fileName, root) && root.length > matchingRoot.length) {
+                matchingRoot = root;
+                matchingPackage = packageName;
             }
         }
-        const InterfaceFunction = (identity) => {
-            const proxy = new AsyncProxy(identity);
-            const func = (...args) => proxy.call(...args);
-            func.proxy = proxy;
-            return func;
+        return matchingPackage;
+    }
+    bindInterfaceValue(value, context) {
+        if (isRecognizedInterfaceProxy(value, "event")) {
+            return this.getRoutedEvent(value, context);
+        }
+        if (typeof value === "function" &&
+            this.isClass(value)) {
+            return value;
+        }
+        if (!this.isBindableValue(value)) {
+            return value;
+        }
+        const cached = this.boundValues.get(value)?.get(context);
+        if (cached) {
+            return cached;
+        }
+        const bound = typeof value === "function"
+            ? this.createFunctionFacade(value, context)
+            : this.createObjectFacade(value, context);
+        const contexts = this.boundValues.get(value) ??
+            new WeakMap();
+        contexts.set(context, bound);
+        this.boundValues.set(value, contexts);
+        return bound;
+    }
+    bindStubbedInterfaceValue(result, value, context) {
+        if (!result.interfaceName ||
+            !this.stubbedInterfacePackages.has(result.interfaceName)) {
+            return value;
+        }
+        const providerless = this.getProviderlessContext(context, result.interfaceName);
+        return this.bindInterfaceValue(value, providerless);
+    }
+    getProviderlessContext(context, interfaceName) {
+        const contexts = this.providerlessContexts.get(context) ?? new Map();
+        const existing = contexts.get(interfaceName);
+        if (existing) {
+            return existing;
+        }
+        const providerless = {
+            ...context,
+            provider: undefined,
+            providerRoutes: this.filterStubbedProviderRoutes(context, interfaceName),
         };
-        return { AsyncProxy, EventProxy, InterfaceFunction, RegisteringProxy };
-    }
-    isFacadeCoreEntry(entry, coreRoot) {
-        const relativeEntry = node_path_1.default.relative(coreRoot, entry);
-        return (relativeEntry === CORE_ENTRY_RELATIVE ||
-            relativeEntry === CORE_PROXIES_RELATIVE);
-    }
-    facadeSuffix(entry) {
-        return `-${node_path_1.default.basename(entry, node_path_1.default.extname(entry))}.js`;
-    }
-    createCoreFacade(entry, wrappers, namespace) {
-        const facadePath = node_path_1.default.join(node_path_1.default.dirname(entry), `.antelope-resolver-${namespace}${this.facadeSuffix(entry)}`);
-        const facade = Object.create(Object.getPrototypeOf(require(entry)));
-        Object.defineProperties(facade, Object.getOwnPropertyDescriptors(require(entry)));
-        Object.defineProperties(facade, {
-            AsyncProxy: { enumerable: true, value: wrappers.AsyncProxy },
-            EventProxy: { enumerable: true, value: wrappers.EventProxy },
-            InterfaceFunction: {
-                enumerable: true,
-                value: wrappers.InterfaceFunction,
+        contexts.set(interfaceName, providerless);
+        this.providerlessContexts.set(context, contexts);
+        this.stubbedContexts.add(providerless);
+        return providerless;
+    }
+    filterStubbedProviderRoutes(context, interfaceName) {
+        const routes = context.providerRoutes ?? {};
+        return new Proxy(routes, {
+            get: (target, identity) => {
+                const owner = typeof identity === "string"
+                    ? this.proxyOwners.get(identity)?.interfaceName
+                    : undefined;
+                if (owner === interfaceName &&
+                    this.stubbedInterfacePackages.has(interfaceName)) {
+                    return undefined;
+                }
+                return Reflect.get(target, identity);
             },
-            RegisteringProxy: { enumerable: true, value: wrappers.RegisteringProxy },
         });
-        const facadeModule = new node_module_1.default(facadePath);
-        facadeModule.filename = facadePath;
-        facadeModule.exports = facade;
-        facadeModule.loaded = true;
-        require.cache[facadePath] = facadeModule;
-        return facadePath;
     }
-    findInterfacePackageRequest(request) {
-        return [...this.interfacePackages.keys()].find((packageName) => request === packageName || request.startsWith(`${packageName}/`));
+    isBindableValue(value) {
+        if ((typeof value !== "object" && typeof value !== "function") ||
+            value === null) {
+            return false;
+        }
+        if (node_util_1.types.isProxy(value)) {
+            return false;
+        }
+        if (typeof value === "function" || isRecognizedInterfaceProxy(value)) {
+            return true;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        return (Array.isArray(value) ||
+            prototype === Object.prototype ||
+            prototype === null);
     }
-    findAliasByPath(fileName) {
-        return [...this.interfaceAliases.values()].find((alias) => {
-            if (!fileName.startsWith(alias.root)) {
-                return false;
-            }
-            const suffix = fileName.slice(alias.root.length);
-            const separators = suffix.match(new RegExp(`^\\${node_path_1.default.sep}+`))?.[0];
-            return separators?.length === alias.separatorCount;
+    isClass(value) {
+        return Function.prototype.toString.call(value).startsWith(CLASS_PREFIX);
+    }
+    createObjectFacade(value, context) {
+        const members = new Map();
+        const facade = new Proxy(value, {
+            get: (target, property) => {
+                const descriptor = Reflect.getOwnPropertyDescriptor(target, property);
+                if (descriptor &&
+                    !descriptor.configurable &&
+                    "value" in descriptor &&
+                    !descriptor.writable) {
+                    return descriptor.value;
+                }
+                const member = Reflect.get(target, property, target);
+                const cached = members.get(property);
+                if (cached && Object.is(cached.source, member)) {
+                    return cached.bound;
+                }
+                const bound = typeof member === "function" && !this.isClass(member)
+                    ? this.bindObjectFunction(member, target, facade, property, context)
+                    : this.bindInterfaceValue(member, context);
+                members.set(property, { bound, source: member });
+                return bound;
+            },
         });
+        return facade;
     }
-    removeAlias(fileName, alias) {
-        return `${alias.root}${node_path_1.default.sep}${fileName.slice(alias.root.length + alias.separatorCount)}`;
+    bindObjectFunction(member, target, facade, property, context) {
+        const isStubAttachment = this.stubbedContexts.has(context) &&
+            isRecognizedInterfaceProxy(target) &&
+            PROXY_ATTACHMENT_METHODS.has(property);
+        return isStubAttachment
+            ? member.bind(target)
+            : this.createFunctionFacade(member, context, target, facade);
     }
-    isExactResolverPath(request) {
-        if (this.findAliasByPath(request)) {
-            return true;
+    createFunctionFacade(value, context, boundThis, facadeThis) {
+        return new Proxy(value, {
+            apply: (target, thisArg, argumentsList) => {
+                const receiver = boundThis &&
+                    (!facadeThis || thisArg === facadeThis || thisArg === undefined)
+                    ? boundThis
+                    : thisArg;
+                const result = (0, internal_1.runWithCapturedModuleContext)(context, () => Reflect.apply(target, receiver, argumentsList.map((argument) => this.bindInterfaceValue(argument, context))));
+                return this.bindFunctionResult(result, context);
+            },
+            construct: (target, argumentsList, newTarget) => (0, internal_1.runWithCapturedModuleContext)(context, () => Reflect.construct(target, argumentsList, newTarget)),
+            get: (target, property) => {
+                if (property === "prototype") {
+                    return target.prototype;
+                }
+                return this.bindInterfaceValue(Reflect.get(target, property, target), context);
+            },
+        });
+    }
+    bindFunctionResult(value, context) {
+        if (value instanceof Promise) {
+            return value.then((result) => typeof result === "function"
+                ? this.bindInterfaceValue(result, context)
+                : result);
+        }
+        return typeof value === "function"
+            ? this.bindInterfaceValue(value, context)
+            : value;
+    }
+    getRoutedEvent(value, context) {
+        const identity = (0, interface_core_1.GetInterfaceProxyIdentity)(value);
+        const provider = identity
+            ? (context.providerRoutes?.[identity] ?? context.provider)
+            : undefined;
+        if (!identity || !provider) {
+            return value;
+        }
+        const key = `${identity}\0${provider}`;
+        const routed = this.routedEvents.get(key);
+        if (routed) {
+            return this.bindRoutedEvent(routed, context);
         }
-        return [...this.interfaceAliases.values()].some((alias) => alias.coreFacadeEntries.has(request));
+        const created = new interface_core_1.EventProxy(`${this.resolverIdentity}:${provider}:${identity}`);
+        this.routedEvents.set(key, created);
+        return this.bindRoutedEvent(created, context);
+    }
+    bindRoutedEvent(event, context) {
+        const cached = this.boundValues.get(event)?.get(context);
+        if (cached) {
+            return cached;
+        }
+        const bound = this.createEventFacade(event, context);
+        const contexts = this.boundValues.get(event) ??
+            new WeakMap();
+        contexts.set(context, bound);
+        this.boundValues.set(event, contexts);
+        return bound;
+    }
+    createEventFacade(event, context) {
+        const handlers = new WeakMap();
+        const register = (handler) => {
+            const bound = handlers.get(handler) ?? this.createFunctionFacade(handler, context);
+            handlers.set(handler, bound);
+            return (0, internal_1.runWithCapturedModuleContext)(context, () => event.register(bound));
+        };
+        const unregister = (handler) => (0, internal_1.runWithCapturedModuleContext)(context, () => event.unregister(handlers.get(handler) ?? handler));
+        const emit = this.createFunctionFacade(event.emit, context, event);
+        return new Proxy(event, {
+            get: (target, property) => {
+                if (property === "register") {
+                    return register;
+                }
+                if (property === "unregister") {
+                    return unregister;
+                }
+                if (property === "emit") {
+                    return emit;
+                }
+                return Reflect.get(target, property, target);
+            },
+        });
     }
     resolveLocalModule(fileName) {
         if (!fileName) {