@antelopejs/core 1.13.5 → 1.15.0

package/dist/core/resolution/resolver.js

@@ -1,276 +1,198 @@
 "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_util_1 = require("node:util");
-const interface_core_1 = require("@antelopejs/interface-core");
+exports.connectionPath = connectionPath;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const modules_1 = require("@antelopejs/interface-core/modules");
 const internal_1 = require("@antelopejs/interface-core/internal");
 const observable_map_1 = require("./observable-map");
 const package_resolution_1 = require("./package-resolution");
 const path_owner_index_1 = require("./path-owner-index");
+const interface_instances_1 = require("./interface-instances");
 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 SHARED_INTERFACE_OWNER_SUFFIX = "#shared";
-const CLASS_PREFIX = "class ";
-const PROXY_ATTACHMENT_METHODS = new Set([
-    "detach",
-    "onCall",
-    "onHandlers",
-    "onRegister",
-    "onUnregister",
-]);
-let nextResolverIdentity = 1;
-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);
-    }
-    return isBrandedInterfaceProxy(value, kind);
-}
-function isBrandedInterfaceProxy(value, kind) {
+const CONNECTION_PREFIX = "@ajs.connection/";
+const INSTANCE_OWNER_SUFFIX = "#instance";
+const RELATIVE_OR_ABSOLUTE = /^(\.{1,2}(\/|\\|$)|\/|[A-Za-z]:[\\/])/;
+function realFolder(folder) {
     try {
-        return (0, interface_core_1.IsInterfaceProxy)(value, kind);
+        return node_fs_1.realpathSync.native(folder);
     }
     catch {
-        return false;
+        return node_path_1.default.resolve(folder);
     }
 }
-function isPlainContainer(value) {
-    if (Array.isArray(value)) {
-        return true;
+function parseConnection(request) {
+    if (!request.startsWith(CONNECTION_PREFIX)) {
+        return undefined;
     }
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-function getProxyCandidate(candidate) {
-    if (typeof candidate === "function" && "proxy" in candidate) {
-        return candidate.proxy;
+    const rest = request.slice(CONNECTION_PREFIX.length);
+    const separator = rest.indexOf("/");
+    const index = Number(rest.slice(0, separator));
+    if (separator < 0 || !Number.isInteger(index)) {
+        throw new Error(`Malformed connection path '${request}'.`);
     }
-    return candidate;
+    return { index, request: rest.slice(separator + 1) };
 }
-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;
+function connectionPath(index, packageName) {
+    return `${CONNECTION_PREFIX}${index}/${packageName}`;
 }
 class Resolver {
     pathMapper;
-    moduleByFolder = new observable_map_1.ObservableMap(() => this.localModuleOwners.invalidate());
+    moduleByFolder = new observable_map_1.ObservableMap(() => this.owners.invalidate());
     modulesById = new Map();
-    interfacePackages = new observable_map_1.ObservableMap(() => this.interfacePackageOwners.invalidate());
+    interfacePackages = new observable_map_1.ObservableMap(() => this.owners.invalidate());
     interfacePackageEntries = new Map();
     interfacePackageResolveFrom = new Map();
     lifecycleInterfacePackages = new Set();
     stubbedInterfacePackages = new Set();
     stubModulePath;
-    resolverIdentity = nextResolverIdentity++;
-    localModuleOwners = new path_owner_index_1.PathOwnerIndex(() => this.listModuleRoots());
-    interfacePackageOwners = new path_owner_index_1.PathOwnerIndex(() => this.listInterfacePackageRoots());
-    interfaceGraphFiles = new Map();
-    interfaceDependencies = new Map();
-    boundValues = new WeakMap();
-    routedEvents = new Map();
-    proxyOwners = new Map();
-    providerlessContexts = new WeakMap();
-    sharedInterfaceContexts = new WeakMap();
-    interfaceBodyContexts = new WeakMap();
-    interfaceBodySharedContexts = new WeakMap();
-    sharedContexts = new WeakMap();
-    sharedStubInterfaces = new WeakMap();
-    adoptedContexts = new WeakMap();
-    stubbedContexts = new WeakSet();
+    instances = new interface_instances_1.InterfaceInstances(() => this.owners.invalidate(), (instance) => this.retireInstance(instance));
+    bindings;
+    instanceFiles = new Map();
+    owners = new path_owner_index_1.PathOwnerIndex(() => this.listOwnerRoots());
     constructor(pathMapper) {
         this.pathMapper = pathMapper;
     }
+    setBindings(graph) {
+        this.bindings = graph;
+        this.instances.update(graph, this.canonicalPackages(), this.fixedRoots());
+    }
     resolve(request, parent) {
-        const parentModule = this.resolveLocalModule(parent?.filename);
-        if (parentModule) {
-            const mapped = this.pathMapper.resolve(request, parentModule.manifest);
+        const fileOwner = parent?.filename
+            ? this.owners.findOwner(parent.filename)
+            : undefined;
+        if (fileOwner?.module) {
+            const mapped = this.pathMapper.resolve(request, fileOwner.module.manifest);
             if (mapped) {
                 return { resolvedPath: mapped };
             }
         }
-        const coreResult = this.resolveInterfaceCore(request);
-        if (coreResult) {
-            return this.bindResultProvider(coreResult, CORE_PKG, { bindExports: false, sharedExports: false }, parent, parentModule);
-        }
-        const interfaceRequest = this.resolveInterfacePackage(request);
-        if (interfaceRequest) {
-            this.trackInterfaceDependency(parent?.filename, interfaceRequest.packageName);
-            return this.bindResultProvider(interfaceRequest.result, interfaceRequest.packageName, {
-                bindExports: this.interfaceGraphFiles.get(parent?.filename ?? "") !==
-                    interfaceRequest.packageName,
-                sharedExports: this.isInterfacePackageFile(parent?.filename),
-            }, parent, parentModule);
+        return (this.resolveInterfaceCore(request) ??
+            this.resolveInterfaceRequest(request, fileOwner ?? this.contextOwner()));
+    }
+    locate(result, resolvedPath) {
+        if (!result.instance) {
+            return resolvedPath;
         }
-        return this.resolveRelativeInterface(request, parent, parentModule);
+        return this.instances.locate(result.instance, resolvedPath) ?? resolvedPath;
     }
     ownsResolutionContext(_request, parent) {
         const contextModule = (0, internal_1.getModuleContext)()?.module;
         if (contextModule && this.modulesById.has(contextModule)) {
             return true;
         }
-        return Boolean(this.resolveLocalModule(parent?.filename));
+        return Boolean(this.owners.findOwner(parent?.filename ?? ""));
     }
-    requiresPreResolution(request, parent) {
-        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);
+    instanceToLoad(request, parent) {
+        const resolved = this.resolve(request, parent)?.instance;
+        if (resolved) {
+            return resolved;
         }
-        this.bindImportedRoutes(context, result, references);
-        if (!result.bindExports) {
-            return value;
+        if (!RELATIVE_OR_ABSOLUTE.test(request) || !parent?.filename) {
+            return undefined;
         }
-        return this.bindInterfaceValue(value, this.getBindingContext(result, context));
+        return (this.instanceFiles.get(parent.filename) ??
+            this.owners.findOwner(parent.filename)?.instance);
+    }
+    recordInstanceFile(instance, filePath) {
+        this.instanceFiles.set(filePath, instance);
     }
-    runInInterfaceContext(result, load) {
-        const context = (0, internal_1.captureModuleContext)();
-        if (!context || !this.isSharedInterfaceLoad(result)) {
+    runInInstance(instance, load) {
+        const descriptor = this.instances.describe(instance);
+        if (!descriptor ||
+            this.lifecycleInterfacePackages.has(descriptor.interfaceName)) {
             return load();
         }
-        return (0, internal_1.runWithCapturedModuleContext)(this.getInterfaceBodyContext(result, context), load);
+        const module = (0, internal_1.getModuleContext)()?.module ??
+            descriptor.provider ??
+            descriptor.interfaceName;
+        return (0, internal_1.runWithModuleContext)({ module, owner: `${instance}${INSTANCE_OWNER_SUFFIX}` }, load);
     }
-    isSharedInterfaceLoad(result) {
-        return Boolean(result.interfaceName &&
-            result.interfaceName !== CORE_PKG &&
-            result.provider &&
-            !this.lifecycleInterfacePackages.has(result.interfaceName));
-    }
-    trackInterfaceFile(result, resolvedPath) {
-        if (result.interfaceName) {
-            this.interfaceGraphFiles.set(resolvedPath, result.interfaceName);
+    loadInstance(instance) {
+        const root = this.instances.rootOf(instance);
+        const entry = this.instanceEntry(instance);
+        if (!root || !entry) {
+            return undefined;
         }
+        this.runInInstance(instance, () => require(entry));
+        return root;
     }
-    getInterfaceEntryToPrime(result, resolvedPath) {
-        const interfaceName = result.interfaceName;
-        if (!interfaceName || this.lifecycleInterfacePackages.has(interfaceName)) {
+    entryToPrime(request, parent, resolvedPath) {
+        const instance = this.resolve(request, parent)?.instance;
+        const descriptor = instance && this.instances.describe(instance);
+        if (!instance ||
+            !descriptor ||
+            this.lifecycleInterfacePackages.has(descriptor.interfaceName)) {
             return undefined;
         }
-        const entry = this.interfacePackageEntries.get(interfaceName);
-        if (!entry || entry === resolvedPath || require.cache[entry]) {
+        const entry = this.instanceEntry(instance);
+        return entry && entry !== resolvedPath && !require.cache[entry]
+            ? entry
+            : undefined;
+    }
+    instanceEntry(instance) {
+        const name = this.instances.describe(instance)?.interfaceName;
+        const canonicalEntry = name
+            ? (this.interfacePackageEntries.get(name) ??
+                this.interfacePackages.get(name))
+            : undefined;
+        if (!canonicalEntry) {
             return undefined;
         }
-        return {
-            ...result,
-            resolvedPath: entry,
-            resolveFrom: undefined,
-            bindExports: false,
-        };
+        return (this.instances.locate(instance, realFolder(canonicalEntry)) ??
+            canonicalEntry);
     }
     getInterfaceGraphRoot(filePath) {
-        const packageName = this.interfaceGraphFiles.get(filePath);
-        if (!packageName) {
-            return undefined;
-        }
-        if (packageName === CORE_PKG) {
-            return CORE_PACKAGE?.root;
-        }
-        return this.interfacePackages.get(packageName);
+        const instance = this.instanceFiles.get(filePath) ??
+            this.owners.findOwner(filePath)?.instance;
+        return instance ? this.instances.rootOf(instance) : undefined;
     }
-    buildProviderRoutes(moduleId) {
-        const routes = {};
-        this.bindKnownRoutes(moduleId, routes);
-        return routes;
+    releaseInstances() {
+        this.instances.release();
     }
     clearCache() {
-        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();
-        this.localModuleOwners.invalidate();
-        this.interfacePackageOwners.invalidate();
-    }
-    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);
-        }
+        this.instanceFiles.clear();
+        this.owners.invalidate();
     }
-    bindImportedRoutes(context, result, references) {
-        for (const { identity } of references) {
-            const owner = this.proxyOwners.get(identity)?.interfaceName;
-            if (result.interfaceName && owner !== result.interfaceName) {
-                continue;
+    retireInstance(instance) {
+        for (const [file, owner] of this.instanceFiles) {
+            if (owner === instance) {
+                this.instanceFiles.delete(file);
             }
-            this.bindRoute(context.module, context.providerRoutes, identity, result.provider);
         }
+        (0, modules_1.ReleaseOwner)(`${instance}${INSTANCE_OWNER_SUFFIX}`);
     }
-    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);
+    canonicalPackages() {
+        const canonical = new Map();
+        for (const [name, root] of this.interfacePackages) {
+            if (name !== CORE_PKG) {
+                canonical.set(name, {
+                    root: node_path_1.default.resolve(root),
+                    realRoot: realFolder(root),
+                });
             }
         }
+        return canonical;
     }
-    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.`);
+    fixedRoots() {
+        const roots = new Map();
+        for (const name of this.lifecycleInterfacePackages) {
+            for (const key of this.instances.keysOf(name)) {
+                const provider = this.instances.describe(key)?.provider;
+                const module = provider ? this.modulesById.get(provider) : undefined;
+                if (module?.manifest.manifest.name === name) {
+                    roots.set(key, realFolder(module.manifest.folder));
+                }
+            }
         }
-        routes[identity] = provider;
+        return roots;
     }
     resolveInterfaceCore(request) {
         if (request === CORE_PKG) {
@@ -281,485 +203,105 @@ class Resolver {
         }
         return undefined;
     }
-    resolveInterfacePackage(request) {
-        for (const [packageName, rootDir] of this.interfacePackages) {
-            if (request === packageName) {
-                return {
-                    packageName,
-                    result: {
-                        resolvedPath: this.interfacePackageEntries.get(packageName) ?? rootDir,
-                    },
-                };
-            }
-            if (request.startsWith(`${packageName}/`)) {
-                return {
-                    packageName,
-                    result: {
-                        resolvedPath: request,
-                        resolveFrom: this.interfacePackageResolveFrom.get(packageName) ?? rootDir,
-                    },
-                };
-            }
-        }
-        return undefined;
-    }
-    resolveRelativeInterface(request, parent, parentModule) {
-        if (!request.startsWith(".") || !parent?.filename) {
-            return undefined;
-        }
-        const packageName = this.findInterfacePackageByPath(parent.filename);
+    resolveInterfaceRequest(request, owner) {
+        const connection = parseConnection(request);
+        const target = connection?.request ?? request;
+        const packageName = this.findInterfacePackage(target);
         if (!packageName) {
+            if (connection) {
+                throw new Error(`Connection path '${request}' does not name an interface package.`);
+            }
             return undefined;
         }
-        return this.bindResultProvider({ resolvedPath: request }, packageName, {
-            bindExports: !this.interfaceGraphFiles.has(parent.filename),
-            sharedExports: true,
-        }, parent, parentModule);
+        const instance = connection
+            ? this.connectionInstance(owner, packageName, connection.index)
+            : this.instanceFor(owner, packageName);
+        return { ...this.canonicalRequest(packageName, target), instance };
     }
-    bindResultProvider(result, packageName, binding, parent, parentModule) {
-        const provider = this.resolveRequestProvider(packageName, parent?.filename, parentModule);
+    canonicalRequest(packageName, request) {
+        const root = this.interfacePackages.get(packageName);
+        if (request === packageName) {
+            return {
+                resolvedPath: this.interfacePackageEntries.get(packageName) ?? root,
+            };
+        }
         return {
-            ...result,
-            bindExports: binding.bindExports,
-            sharedExports: binding.sharedExports,
-            interfaceName: packageName,
-            provider,
+            resolvedPath: request,
+            resolveFrom: this.interfacePackageResolveFrom.get(packageName) ?? root,
         };
     }
-    isInterfacePackageFile(filename) {
-        if (!filename) {
-            return false;
-        }
-        return (this.interfaceGraphFiles.has(filename) ||
-            this.findInterfacePackageByPath(filename) !== undefined);
-    }
-    resolveProvider(module, packageName) {
-        if (module.manifest.implements?.includes(packageName)) {
-            return module.id;
-        }
-        return internal_1.internal.interfaceConnections[module.id]?.[packageName]?.find(({ selected }) => selected)?.provider;
+    findInterfacePackage(request) {
+        return [...this.interfacePackages.keys()].find((packageName) => packageName !== CORE_PKG &&
+            (request === packageName || request.startsWith(`${packageName}/`)));
     }
-    resolveRequestProvider(packageName, parentFilename, parentModule) {
+    contextOwner() {
         const contextModule = (0, internal_1.getModuleContext)()?.module;
-        const consumer = contextModule
+        const module = contextModule
             ? this.modulesById.get(contextModule)
             : undefined;
-        const direct = consumer
-            ? this.resolveProvider(consumer, packageName)
-            : undefined;
-        if (direct) {
-            return direct;
-        }
-        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));
-    }
-    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;
-            }
-        }
-        return undefined;
-    }
-    resolveProviders(module, interfaceName, visited = new Set()) {
-        const direct = this.resolveProvider(module, interfaceName);
-        if (direct) {
-            return new Set([direct]);
-        }
-        if (visited.has(interfaceName)) {
-            return new Set();
-        }
-        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);
-        }
-        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);
-            }
-        }
-    }
-    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);
+        return module ? { module } : undefined;
     }
-    findRequestedInterface(request, parentFilename) {
-        if (request === CORE_PKG || request.startsWith(`${CORE_PKG}/`)) {
-            return CORE_PKG;
-        }
-        const direct = this.findInterfacePackageRequest(request);
-        if (direct) {
-            return direct;
+    scopeOf(owner) {
+        if (owner?.module) {
+            return this.bindings?.modules.get(owner.module.id)?.keys ?? new Map();
         }
-        return request.startsWith(".") && parentFilename
-            ? this.findInterfacePackageByPath(parentFilename)
-            : undefined;
-    }
-    findInterfacePackageRequest(request) {
-        return [...this.interfacePackages.keys()].find((packageName) => request === packageName || request.startsWith(`${packageName}/`));
-    }
-    findInterfacePackageByPath(fileName) {
-        return this.interfacePackageOwners.findOwner(fileName);
+        return owner?.instance ? this.instanceScope(owner.instance) : new Map();
     }
-    listInterfacePackageRoots() {
-        const coreRoots = CORE_PACKAGE
-            ? [{ root: CORE_PACKAGE.root, owner: CORE_PKG }]
-            : [];
-        const packageRoots = [...this.interfacePackages].map(([packageName, root]) => ({ root, owner: packageName }));
-        return [...coreRoots, ...packageRoots];
-    }
-    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;
-    }
-    bindPassedValue(value, context) {
-        return this.needsFacade(value)
-            ? this.bindInterfaceValue(value, context)
-            : value;
-    }
-    needsFacade(value, visited) {
-        if (typeof value === "function") {
-            return true;
-        }
-        if (typeof value !== "object" ||
-            value === null ||
-            node_util_1.types.isProxy(value)) {
-            return false;
+    instanceScope(instance) {
+        const descriptor = this.instances.describe(instance);
+        if (descriptor?.provider) {
+            return this.bindings?.modules.get(descriptor.provider)?.keys ?? new Map();
         }
-        if (!isPlainContainer(value)) {
-            return isRecognizedInterfaceProxy(value);
-        }
-        return (isBrandedInterfaceProxy(value) || this.holdsFacadeMember(value, visited));
-    }
-    holdsFacadeMember(container, visited = new Set()) {
-        if (visited.has(container)) {
-            return false;
-        }
-        visited.add(container);
-        for (const member of Object.values(container)) {
-            if (this.needsFacade(member, visited)) {
-                return true;
+        const scope = new Map();
+        for (const key of descriptor?.dependencies ?? []) {
+            const dependency = this.bindings?.instances.get(key);
+            if (dependency) {
+                scope.set(dependency.interfaceName, key);
             }
         }
-        return false;
+        return scope;
     }
-    bindStubbedInterfaceValue(result, value, context) {
-        if (!result.interfaceName ||
-            !this.stubbedInterfacePackages.has(result.interfaceName)) {
-            return value;
+    describeOwner(owner) {
+        if (owner?.module) {
+            return `Module '${owner.module.id}'`;
         }
-        const providerless = this.getProviderlessContext(this.getBindingContext(result, context), result.interfaceName);
-        return this.bindInterfaceValue(value, providerless);
+        return owner?.instance
+            ? `Interface instance '${owner.instance}'`
+            : "Code outside any module";
     }
-    getBindingContext(result, context) {
-        if (!result.sharedExports) {
-            return this.interfaceBodySharedContexts.get(context) ?? context;
-        }
-        return this.getSharedInterfaceContext(result, context);
-    }
-    getSharedInterfaceContext(result, context) {
-        const importer = this.interfaceBodySharedContexts.get(context) ?? context;
-        const interfaceName = result.interfaceName ?? "";
-        const contexts = this.sharedInterfaceContexts.get(importer) ?? new Map();
-        const existing = contexts.get(interfaceName);
-        if (existing) {
-            return existing;
+    instanceFor(owner, packageName) {
+        const bound = this.scopeOf(owner).get(packageName);
+        if (bound) {
+            return bound;
         }
-        const shared = { ...importer, provider: result.provider };
-        contexts.set(interfaceName, shared);
-        this.sharedInterfaceContexts.set(importer, contexts);
-        this.sharedContexts.set(shared, interfaceName);
-        return shared;
-    }
-    getInterfaceBodyContext(result, context) {
-        const shared = this.getSharedInterfaceContext(result, context);
-        const existing = this.interfaceBodyContexts.get(shared);
-        if (existing) {
-            return existing;
+        const keys = this.instances.keysOf(packageName);
+        if (keys.length <= 1) {
+            return keys[0];
         }
-        const body = this.createInterfaceBodyContext(shared, result.interfaceName ?? "");
-        this.interfaceBodyContexts.set(shared, body);
-        this.interfaceBodySharedContexts.set(body, shared);
-        return body;
-    }
-    createInterfaceBodyContext(shared, interfaceName) {
-        const packageContext = {
-            module: shared.module,
-            owner: `${interfaceName}${SHARED_INTERFACE_OWNER_SUFFIX}`,
-            provider: shared.provider,
-            providerRoutes: shared.providerRoutes,
-        };
-        return (0, internal_1.runWithModuleContext)(packageContext, () => (0, internal_1.captureModuleContext)());
+        throw new Error(`${this.describeOwner(owner)} imports ${packageName}, which has several instances (${keys.join(", ")}), but does not declare it; add it to the dependencies of the importing package.`);
     }
-    effectiveContext(context) {
-        const sharedInterface = this.sharedContexts.get(context);
-        if (sharedInterface === undefined) {
-            return context;
-        }
-        const ambient = (0, internal_1.captureModuleContext)();
-        if (!ambient) {
-            return context;
-        }
-        const adopted = this.getAdoptedContext(context, ambient, sharedInterface);
-        const stubbed = this.sharedStubInterfaces.get(context);
-        return stubbed ? this.getProviderlessContext(adopted, stubbed) : adopted;
-    }
-    getAdoptedContext(shared, ambient, interfaceName) {
-        const cached = this.adoptedContexts.get(shared)?.get(ambient);
-        if (cached) {
-            return cached;
-        }
-        const adopted = {
-            ...ambient,
-            provider: this.adoptedProvider(interfaceName, ambient, shared),
-            providerRoutes: this.chainProviderRoutes(ambient.providerRoutes, shared.providerRoutes),
-        };
-        const contexts = this.adoptedContexts.get(shared) ??
-            new WeakMap();
-        contexts.set(ambient, adopted);
-        this.adoptedContexts.set(shared, contexts);
-        return adopted;
-    }
-    adoptedProvider(interfaceName, ambient, shared) {
-        const consumer = this.modulesById.get(ambient.module);
-        const direct = consumer
-            ? this.resolveProvider(consumer, interfaceName)
-            : undefined;
-        return direct ?? shared.provider;
-    }
-    chainProviderRoutes(routes, fallback) {
-        if (!routes || !fallback) {
-            return routes ?? fallback;
-        }
-        return new Proxy(routes, {
-            get: (target, identity) => Reflect.get(target, identity) ?? Reflect.get(fallback, identity),
-        });
-    }
-    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),
-        };
-        contexts.set(interfaceName, providerless);
-        this.providerlessContexts.set(context, contexts);
-        this.stubbedContexts.add(providerless);
-        const sharedInterface = this.sharedContexts.get(context);
-        if (sharedInterface !== undefined) {
-            this.sharedContexts.set(providerless, sharedInterface);
-            this.sharedStubInterfaces.set(providerless, interfaceName);
-        }
-        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);
-            },
-        });
-    }
-    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;
-        }
-        return isPlainContainer(value);
-    }
-    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.bindPassedValue(member, context);
-                members.set(property, { bound, source: member });
-                return bound;
-            },
-        });
-        return facade;
-    }
-    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);
-    }
-    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)(this.effectiveContext(context), () => Reflect.apply(target, receiver, argumentsList.map((argument) => this.bindPassedValue(argument, context))));
-                return this.bindFunctionResult(result, context);
-            },
-            construct: (target, argumentsList, newTarget) => (0, internal_1.runWithCapturedModuleContext)(this.effectiveContext(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)
+    connectionInstance(owner, packageName, index) {
+        const module = owner?.module;
+        const key = module
+            ? this.bindings?.modules
+                .get(module.id)
+                ?.connectionKeys.get(packageName)?.[index]
             : undefined;
-        if (!identity || !provider) {
-            return value;
-        }
-        const key = `${identity}\0${provider}`;
-        const routed = this.routedEvents.get(key);
-        if (routed) {
-            return this.bindRoutedEvent(routed, context);
-        }
-        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)(this.effectiveContext(context), () => event.register(bound));
-        };
-        const unregister = (handler) => (0, internal_1.runWithCapturedModuleContext)(this.effectiveContext(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) {
-            return undefined;
-        }
-        return this.localModuleOwners.findOwner(fileName);
-    }
-    listModuleRoots() {
-        return [...this.moduleByFolder].map(([root, owner]) => ({ root, owner }));
+        if (!key) {
+            throw new Error(`${this.describeOwner(owner)} has no connection ${index} to ${packageName}.`);
+        }
+        return key;
+    }
+    listOwnerRoots() {
+        const modules = [...this.moduleByFolder].map(([root, module]) => ({
+            root,
+            owner: { module },
+        }));
+        const instances = [...this.instances.roots()].map(([instance, root]) => ({
+            root,
+            owner: { instance },
+        }));
+        return [...modules, ...instances];
     }
 }
 exports.Resolver = Resolver;