@antelopejs/core 1.17.0 → 1.18.0

package/dist/core/module-manager.js

@@ -1,994 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleManager = void 0;
-const path = __importStar(require("node:path"));
-const semver_1 = require("semver");
-const logging_1 = require("@antelopejs/interface-core/logging");
-const module_1 = require("./module");
-const module_isolation_1 = require("./module-isolation");
-const lifecycle_signals_1 = require("./lifecycle-signals");
-const types_1 = require("../types");
-const module_tracker_1 = require("./module-tracker");
-const resolver_1 = require("./resolution/resolver");
-const module_registry_1 = require("./module-registry");
-const path_mapper_1 = require("./resolution/path-mapper");
-const config_vars_1 = require("./config/config-vars");
-const config_var_store_1 = require("./config/config-var-store");
-const resolver_detour_1 = require("./resolution/resolver-detour");
-const module_manifest_1 = require("./module-manifest");
-const config_var_graph_1 = require("./config/config-var-graph");
-const interface_registry_1 = require("./interface-registry");
-const stub_interface_runtime_1 = require("./resolution/stub-interface-runtime");
-const package_resolution_1 = require("./resolution/package-resolution");
-const binding_graph_1 = require("./resolution/binding-graph");
-const binding_diagnostics_1 = require("./resolution/binding-diagnostics");
-const interface_dependencies_1 = require("./resolution/interface-dependencies");
-const interface_resolution_error_1 = require("./resolution/interface-resolution-error");
-const Logger = new logging_1.Logging.Channel("loader");
-const INTERFACE_CORE_PACKAGE = "@antelopejs/interface-core";
-const MS_PER_SECOND = 1000;
-const START_SLOW_WARNING_MS = 10 * MS_PER_SECOND;
-const START_TIMEOUT_MS = 120 * MS_PER_SECOND;
-function compareModuleIds(left, right) {
-    return left.localeCompare(right);
-}
-class ModuleManager {
-    registry;
-    resolver;
-    interfaceRegistry;
-    moduleTracker;
-    resolverDetour;
-    resolvedAssociations = new Map();
-    resolvedConnections = new Map();
-    selectedProviders = new Map();
-    staticModules = [];
-    loaded = new Map();
-    stubbedInterfacePackages = new Map();
-    interfacePackagePlans = new Map();
-    configVars = new config_var_store_1.ConfigVarStore();
-    pendingCleanup = [];
-    bindingGraph;
-    isolation = new module_isolation_1.ModuleIsolation();
-    startupOrder = [];
-    constructor(deps = {}) {
-        this.registry = deps.registry ?? new module_registry_1.ModuleRegistry();
-        this.resolver = deps.resolver ?? new resolver_1.Resolver(new path_mapper_1.PathMapper());
-        this.resolverDetour = new resolver_detour_1.ResolverDetour(this.resolver);
-        this.interfaceRegistry = deps.interfaceRegistry ?? new interface_registry_1.InterfaceRegistry();
-        this.moduleTracker = deps.moduleTracker ?? new module_tracker_1.ModuleTracker();
-    }
-    addStaticModule(entry) {
-        const module = new module_1.Module(entry.manifest);
-        const config = {
-            config: entry.config?.config,
-            importOverrides: entry.config?.importOverrides ?? new Map(),
-            disabledExports: entry.config?.disabledExports ?? new Set(),
-            exportPriority: entry.config?.exportPriority ?? new Map(),
-        };
-        this.registry.register(module);
-        this.staticModules.push({ module, config });
-    }
-    addModules(entries) {
-        const created = [];
-        const replaced = new Map();
-        for (const entry of entries) {
-            replaced.set(entry.manifest.name, this.loaded.get(entry.manifest.name));
-            const manifest = this.placeModule(entry.manifest.name, entry.manifest);
-            const module = new module_1.Module(manifest);
-            this.isolation.adopt(module.id, manifest);
-            const config = {
-                config: entry.config?.config,
-                importOverrides: entry.config?.importOverrides ?? new Map(),
-                disabledExports: entry.config?.disabledExports ?? new Set(),
-                exportPriority: entry.config?.exportPriority ?? new Map(),
-            };
-            this.registry.register(module);
-            const managed = { module, config };
-            this.loaded.set(module.id, managed);
-            created.push(managed);
-        }
-        try {
-            this.rebuildAssociations();
-        }
-        catch (error) {
-            this.restoreModules(replaced);
-            throw error;
-        }
-        return created;
-    }
-    restoreModules(replaced) {
-        for (const [id, previous] of replaced) {
-            this.isolation.forget(id);
-            if (previous) {
-                this.loaded.set(id, previous);
-                this.registry.register(previous.module);
-                this.isolation.adopt(id, previous.module.manifest);
-            }
-            else {
-                this.loaded.delete(id);
-                this.registry.unregister(id);
-            }
-        }
-        this.rebuildAssociations();
-    }
-    discardModules(ids) {
-        for (const id of ids) {
-            this.isolation.forget(id);
-            this.loaded.delete(id);
-            this.registry.unregister(id);
-        }
-        this.rebuildAssociations();
-    }
-    listModules() {
-        return this.registry.list();
-    }
-    getModule(id) {
-        return this.registry.get(id);
-    }
-    getModuleEntry(id) {
-        return (this.loaded.get(id) ??
-            this.staticModules.find((entry) => entry.module.id === id));
-    }
-    getLoadedModuleEntry(id) {
-        return this.loaded.get(id);
-    }
-    getLoadedModules() {
-        if (!(this.loaded instanceof Map)) {
-            return new Map().values();
-        }
-        return this.loaded.values();
-    }
-    getAllManagedModules() {
-        return [...this.staticModules, ...this.loaded.values()];
-    }
-    unrequireModuleFiles(moduleId, shouldPreserveInterfaceGraph = true) {
-        (0, package_resolution_1.clearPathResolutionCache)();
-        this.evictModuleFiles(moduleId, shouldPreserveInterfaceGraph);
-    }
-    evictModuleFiles(moduleId, shouldPreserveInterfaceGraph) {
-        const entry = this.loaded.get(moduleId);
-        if (!entry) {
-            return;
-        }
-        const moduleFolder = path.resolve(entry.module.manifest.folder);
-        const moduleEntryFile = (0, module_manifest_1.resolveManifestEntryFile)(entry.module.manifest);
-        const isInModule = (0, package_resolution_1.createPathWithinMatcher)(moduleFolder);
-        const avoidedMatchers = this.collectAvoidedFolders(moduleId, moduleFolder, isInModule).map((folder) => (0, package_resolution_1.createPathWithinMatcher)(folder));
-        for (const filePath of Object.keys(require.cache)) {
-            if (!isInModule(filePath)) {
-                continue;
-            }
-            if (shouldPreserveInterfaceGraph &&
-                filePath !== moduleEntryFile &&
-                this.belongsToInterfacePackageTree(filePath, isInModule)) {
-                continue;
-            }
-            if (!avoidedMatchers.some((isAvoided) => isAvoided(filePath))) {
-                delete require.cache[filePath];
-            }
-        }
-    }
-    collectAvoidedFolders(moduleId, moduleFolder, isInModule) {
-        const avoidedFolders = new Set([
-            path.join(moduleFolder, "node_modules"),
-        ]);
-        for (const [id, other] of this.loaded) {
-            if (id !== moduleId && isInModule(other.module.manifest.folder)) {
-                avoidedFolders.add(path.resolve(other.module.manifest.folder));
-            }
-        }
-        return [...avoidedFolders];
-    }
-    belongsToInterfacePackageTree(filePath, isInModule) {
-        const root = this.resolver.getInterfaceGraphRoot(filePath);
-        if (!root) {
-            return false;
-        }
-        return isInModule(path.resolve(root));
-    }
-    setInstanceRoot(root) {
-        this.isolation.setRoot(root);
-    }
-    placeModule(moduleId, manifest) {
-        return this.isolation.place(moduleId, manifest);
-    }
-    checkReplacement(moduleId, replacement) {
-        const entry = this.loaded.get(moduleId);
-        if (!entry) {
-            return;
-        }
-        const modules = this.collectBindingModules();
-        modules.set(moduleId, toBindingModule(replacement, entry.config, this.bindablePackages(), this.resolvedConnections));
-        const running = this.runningBindings();
-        running.delete(moduleId);
-        const graph = (0, binding_graph_1.buildBindingGraph)({
-            interfaces: this.collectBindingInterfaces(),
-            modules,
-            running,
-        });
-        if (graph.errors.length > 0) {
-            throw new binding_diagnostics_1.InterfaceBindingError(graph.errors);
-        }
-    }
-    discardPlacedModule(manifest) {
-        this.isolation.discard(manifest);
-    }
-    replaceLoadedModule(id, module) {
-        const entry = this.loaded.get(id);
-        if (!entry) {
-            return;
-        }
-        this.isolation.adopt(id, module.manifest);
-        entry.module = module;
-        this.registry.register(module);
-        return entry;
-    }
-    refreshAssociations() {
-        this.rebuildAssociations();
-    }
-    hasResolvedInterface(moduleId, interfaceName) {
-        return this.resolvedAssociations.get(moduleId)?.has(interfaceName) ?? false;
-    }
-    registerStubbedInterfaces(stubbed) {
-        const packageNames = new Set(stubbed.map((entry) => entry.interfacePackage));
-        for (const packageName of packageNames) {
-            const entries = stubbed.filter((entry) => entry.interfacePackage === packageName);
-            this.registerStubbedInterfacePackage(packageName, entries);
-        }
-        this.buildBindings();
-    }
-    registerStubbedInterfacePackage(packageName, entries) {
-        const consumers = this.collectInterfacePackageConsumers(packageName);
-        const canonicalPackage = [...consumers]
-            .sort((left, right) => compareModuleIds(left.moduleId, right.moduleId))
-            .find((consumer) => consumer.resolvedPackage)?.resolvedPackage;
-        if (!canonicalPackage) {
-            return;
-        }
-        this.stubbedInterfacePackages.set(packageName, canonicalPackage);
-        this.interfacePackagePlans.set(packageName, {
-            canonicalPackage,
-            consumers,
-        });
-        this.registerInterfacePackage(packageName, canonicalPackage, true);
-        (0, stub_interface_runtime_1.logStubInterfaceWarningOnce)(packageName, entries.some((entry) => entry.standalone));
-    }
-    applyInterfaceStubs() {
-        const implemented = this.collectImplementedInterfaces();
-        const stubbed = Array.from(this.stubbedInterfacePackages);
-        for (const [interfaceName, resolvedPackage] of stubbed) {
-            if (implemented.has(interfaceName)) {
-                this.stubbedInterfacePackages.delete(interfaceName);
-                this.resolver.stubbedInterfacePackages.delete(interfaceName);
-                continue;
-            }
-            if (!this.resolver.interfacePackages.has(interfaceName)) {
-                this.registerInterfacePackage(interfaceName, resolvedPackage, true);
-            }
-            this.neutralizeInstances(interfaceName);
-        }
-    }
-    neutralizeInstances(interfaceName) {
-        for (const instance of this.resolver.instances.keysOf(interfaceName)) {
-            let root;
-            try {
-                root = this.resolver.loadInstance(instance);
-            }
-            catch (err) {
-                Logger.Error(`Failed to load interface '${instance}':`, err);
-                continue;
-            }
-            if (root) {
-                (0, stub_interface_runtime_1.neutralizeInterfacePackage)(root, interfaceName);
-            }
-        }
-    }
-    collectImplementedInterfaces() {
-        const implemented = new Set();
-        for (const { module, config } of this.getAllManagedModules()) {
-            for (const iface of module.manifest.implements ?? []) {
-                if (!config.disabledExports?.has(iface)) {
-                    implemented.add(iface);
-                }
-            }
-        }
-        return implemented;
-    }
-    async constructAll() {
-        const leaseAcquired = this.resolverDetour.attach();
-        const modules = [...this.loaded.values()];
-        let plan;
-        let provided;
-        try {
-            this.logBindingWarnings();
-            this.validateInterfacePackages();
-            this.applyInterfaceStubs();
-            plan = this.planConfigVars(modules);
-            provided = await this.runProvidePhase(modules, plan);
-        }
-        catch (error) {
-            if (leaseAcquired) {
-                throw aggregateErrors([error, ...this.releaseRuntimeState()], "Failed to construct modules");
-            }
-            throw error;
-        }
-        const errors = [
-            ...provided.errors,
-            ...(await this.constructReadyModules(modules, plan, provided.failed)),
-        ];
-        if (errors.length === 0) {
-            return;
-        }
-        const cleanupCandidates = modules.filter(({ module }) => module.state !== types_1.ModuleState.Loaded);
-        const cleanupErrors = await runModuleOperations(cleanupCandidates.reverse(), (module) => module.destroy());
-        if (leaseAcquired) {
-            cleanupErrors.push(...this.releaseRuntimeState());
-        }
-        throw new AggregateError([...errors, ...cleanupErrors], "Failed to construct modules");
-    }
-    async constructModules(modules) {
-        const leaseAcquired = this.resolverDetour.attach();
-        try {
-            this.logBindingWarnings();
-            this.validateInterfacePackages();
-            this.applyInterfaceStubs();
-            await Promise.all(modules
-                .filter((entry) => (0, config_vars_1.declaredConfigVars)(entry.module.manifest).length > 0)
-                .map((entry) => this.provideEntry(entry)));
-            await Promise.all(modules.map((entry) => this.constructEntry(entry)));
-        }
-        catch (error) {
-            if (leaseAcquired) {
-                throw aggregateErrors([error, ...this.releaseRuntimeState()], "Failed to construct modules");
-            }
-            throw error;
-        }
-    }
-    async startAll() {
-        try {
-            await this.startModules([...this.loaded.values()]);
-        }
-        catch (error) {
-            let cleanupErrors = [];
-            try {
-                await this.destroyAll();
-            }
-            catch (cleanupError) {
-                cleanupErrors = unpackErrors(cleanupError);
-            }
-            throw new AggregateError([...unpackErrors(error), ...cleanupErrors], "Failed to start modules");
-        }
-    }
-    async startModules(modules) {
-        modules.forEach(({ module }) => {
-            this.trackModuleStart(module.id);
-        });
-        const results = await Promise.allSettled(modules.map(({ module }) => startWithinDeadline(module)));
-        const errors = collectRejectedErrors(results);
-        if (errors.length > 0) {
-            throw new AggregateError(errors, "Failed to start modules");
-        }
-        (0, lifecycle_signals_1.announceModulesStarted)();
-    }
-    async stopAll() {
-        const modules = this.getReverseLifecycleModules();
-        const errors = await runModuleOperations(modules, (module) => module.stop());
-        this.startupOrder = [];
-        if (errors.length > 0) {
-            throw new AggregateError(errors, "Failed to stop modules");
-        }
-    }
-    async destroyAll() {
-        const modules = this.getReverseLifecycleModules();
-        const results = await runTrackedModuleOperations(modules, (module) => module.destroy());
-        this.pendingCleanup = results.failed.filter(({ module }) => module.state !== types_1.ModuleState.Loaded);
-        (0, package_resolution_1.clearPathResolutionCache)();
-        for (const id of this.loaded.keys()) {
-            this.evictModuleFiles(id, false);
-        }
-        this.isolation.releaseAll();
-        this.resolver.releaseInstances();
-        const errors = [...results.errors, ...this.clearManagedState()];
-        if (errors.length > 0) {
-            throw new AggregateError(errors, "Failed to destroy modules");
-        }
-    }
-    async constructModule(module, config) {
-        try {
-            await module.construct(config);
-        }
-        catch (error) {
-            Logger.Error(`Failed to construct module:`);
-            Logger.Error(`  - ID: ${module.id}`);
-            Logger.Error(`  - Version: ${module.version}`);
-            Logger.Error("  - Error:", error);
-            throw error;
-        }
-    }
-    planConfigVars(modules) {
-        return (0, config_var_graph_1.buildConfigVarPlan)(modules.map(({ module, config }) => ({
-            id: module.id,
-            declared: (0, config_vars_1.declaredConfigVars)(module.manifest),
-            config: config.config,
-        })));
-    }
-    async runProvidePhase(modules, plan) {
-        const entries = new Map(modules.map((entry) => [entry.module.id, entry]));
-        const errors = [];
-        const failed = new Set();
-        for (const stage of plan.stages) {
-            const runnable = stage.filter((id) => {
-                const blocker = this.findFailedProvider(plan, id, failed);
-                if (!blocker) {
-                    return true;
-                }
-                failed.add(id);
-                const message = `Module '${id}' did not provide its config variables: provider '${blocker}' failed.`;
-                Logger.Error(message);
-                errors.push(new Error(message));
-                return false;
-            });
-            const results = await Promise.allSettled(runnable.map((id) => this.provideEntry(entries.get(id))));
-            results.forEach((result, index) => {
-                if (result.status === "rejected") {
-                    failed.add(runnable[index]);
-                    errors.push(result.reason);
-                }
-            });
-        }
-        return { errors, failed };
-    }
-    async constructReadyModules(modules, plan, failed) {
-        const errors = [];
-        const dead = new Set(failed);
-        const runnable = modules.filter(({ module }) => {
-            if (dead.has(module.id)) {
-                return false;
-            }
-            const blocker = this.findFailedProvider(plan, module.id, failed);
-            if (!blocker) {
-                return true;
-            }
-            dead.add(module.id);
-            const message = `Module '${module.id}' did not construct: provider '${blocker}' failed.`;
-            Logger.Error(message);
-            errors.push(new Error(message));
-            return false;
-        });
-        this.rejectCallsIntoDeadModules(dead, dead);
-        const results = await Promise.allSettled(runnable.map((entry) => this.constructOrDisable(entry, dead)));
-        return [...errors, ...collectRejectedErrors(results)];
-    }
-    async constructOrDisable(entry, dead) {
-        try {
-            await this.constructEntry(entry);
-        }
-        catch (error) {
-            dead.add(entry.module.id);
-            this.rejectCallsIntoDeadModules(dead, [entry.module.id]);
-            throw error;
-        }
-    }
-    rejectCallsIntoDeadModules(dead, targets) {
-        for (const moduleId of targets) {
-            const entry = this.getModuleEntry(moduleId);
-            if (!entry) {
-                continue;
-            }
-            for (const interfaceName of this.orphanedInterfaces(entry, dead)) {
-                this.rejectCallsInto(moduleId, interfaceName);
-            }
-        }
-    }
-    orphanedInterfaces(entry, dead) {
-        return (entry.module.manifest.implements ?? []).filter((interfaceName) => !entry.config.disabledExports?.has(interfaceName) &&
-            !this.hasLiveImplementer(interfaceName, dead));
-    }
-    hasLiveImplementer(interfaceName, dead) {
-        return this.getAllManagedModules().some(({ module, config }) => !dead.has(module.id) &&
-            (module.manifest.implements ?? []).includes(interfaceName) &&
-            !config.disabledExports?.has(interfaceName));
-    }
-    rejectCallsInto(moduleId, interfaceName) {
-        const entry = this.getModuleEntry(moduleId);
-        if (!entry) {
-            return;
-        }
-        let instanceRoot;
-        try {
-            instanceRoot = this.resolver.loadInstance(`${interfaceName}@${moduleId}`);
-        }
-        catch (error) {
-            Logger.Trace(`Could not load interface '${interfaceName}' to fail calls into '${moduleId}':`, error);
-            return;
-        }
-        if (!instanceRoot) {
-            return;
-        }
-        const root = instanceRoot;
-        Logger.Debug(`Interface '${interfaceName}' lost its provider '${moduleId}'; calls into it now reject.`);
-        entry.module.runInContext(() => (0, stub_interface_runtime_1.neutralizeInterfacePackage)(root, interfaceName, `has no provider: module '${moduleId}' did not construct`));
-    }
-    findFailedProvider(plan, moduleId, failed) {
-        return [...(plan.dependencies.get(moduleId) ?? [])].find((provider) => failed.has(provider));
-    }
-    async provideEntry(entry) {
-        const { module, config } = entry;
-        config.config = this.configVars.resolve(module.id, config.config);
-        const published = await this.provideModule(module, config.config);
-        this.configVars.record(module.id, (0, config_vars_1.declaredConfigVars)(module.manifest), published);
-    }
-    async provideModule(module, config) {
-        try {
-            return await module.provide(config);
-        }
-        catch (error) {
-            Logger.Error(`Failed to provide config variables:`);
-            Logger.Error(`  - ID: ${module.id}`);
-            Logger.Error(`  - Version: ${module.version}`);
-            Logger.Error("  - Error:", error);
-            throw error;
-        }
-    }
-    async constructEntry(entry) {
-        const { module, config } = entry;
-        config.config = this.configVars.resolve(module.id, config.config);
-        await this.constructModule(module, config.config);
-    }
-    getReverseLifecycleModules() {
-        const orderedIds = [...this.startupOrder].reverse();
-        const seen = new Set(orderedIds);
-        for (const id of [...this.loaded.keys()].reverse()) {
-            if (!seen.has(id)) {
-                orderedIds.push(id);
-            }
-        }
-        const loadedModules = orderedIds.flatMap((id) => {
-            const entry = this.loaded.get(id);
-            return entry ? [entry] : [];
-        });
-        const loadedInstances = new Set(loadedModules.map(({ module }) => module));
-        return [
-            ...loadedModules,
-            ...this.pendingCleanup.filter(({ module }) => !loadedInstances.has(module)),
-        ];
-    }
-    clearManagedState() {
-        this.loaded.clear();
-        this.staticModules.length = 0;
-        this.registry.clear();
-        this.resolvedAssociations.clear();
-        this.resolver.moduleByFolder.clear();
-        this.resolver.modulesById.clear();
-        this.resolver.interfacePackages.clear();
-        this.resolver.interfacePackageEntries.clear();
-        this.resolver.interfacePackageResolveFrom.clear();
-        this.resolver.lifecycleInterfacePackages.clear();
-        this.interfacePackagePlans.clear();
-        this.startupOrder = [];
-        return this.releaseRuntimeState();
-    }
-    releaseRuntimeState() {
-        const errors = [];
-        this.configVars.clear();
-        this.stubbedInterfacePackages.clear();
-        this.resolver.stubbedInterfacePackages.clear();
-        (0, stub_interface_runtime_1.clearStubInterfaceWarnings)();
-        this.moduleTracker.clear();
-        this.interfaceRegistry.clear();
-        try {
-            this.resolverDetour.detach();
-        }
-        catch (error) {
-            errors.push(error);
-        }
-        return errors;
-    }
-    trackModuleStart(moduleId) {
-        this.startupOrder = this.startupOrder.filter((id) => id !== moduleId);
-        this.startupOrder.push(moduleId);
-    }
-    getBindingGraph() {
-        return this.bindingGraph;
-    }
-    rebuildAssociations() {
-        (0, package_resolution_1.clearPathResolutionCache)();
-        const interfaceSources = this.collectInterfaceSources();
-        this.buildModuleAssociations(interfaceSources);
-        this.buildBindings();
-    }
-    buildBindings() {
-        const graph = (0, binding_graph_1.buildBindingGraph)({
-            interfaces: this.collectBindingInterfaces(),
-            modules: this.collectBindingModules(),
-            running: this.runningBindings(),
-        });
-        if (graph.errors.length > 0) {
-            throw new binding_diagnostics_1.InterfaceBindingError(graph.errors);
-        }
-        this.bindingGraph = graph;
-        this.resolver.setBindings(graph);
-    }
-    runningBindings() {
-        const running = new Map();
-        for (const { module } of this.getAllManagedModules()) {
-            const scope = this.bindingGraph?.modules.get(module.id)?.scope;
-            if (module.state === types_1.ModuleState.Loaded || !scope) {
-                continue;
-            }
-            const bindings = new Map();
-            scope.forEach((binding, interfaceName) => {
-                if (binding.provider) {
-                    bindings.set(interfaceName, binding.provider);
-                }
-            });
-            running.set(module.id, bindings);
-        }
-        return running;
-    }
-    logBindingWarnings() {
-        this.bindingGraph?.warnings.forEach((warning) => Logger.Warn(warning));
-    }
-    bindablePackages() {
-        return new Set([...this.resolver.interfacePackages.keys()].filter((packageName) => packageName !== INTERFACE_CORE_PACKAGE));
-    }
-    collectBindingInterfaces() {
-        const packages = this.bindablePackages();
-        const interfaces = new Map();
-        for (const name of packages) {
-            const root = this.resolver.interfacePackages.get(name);
-            interfaces.set(name, {
-                name,
-                dependencies: (0, interface_dependencies_1.readInterfaceDependencies)(name, root, packages),
-            });
-        }
-        return interfaces;
-    }
-    collectBindingModules() {
-        const packages = this.bindablePackages();
-        const modules = new Map();
-        for (const { module, config } of this.getAllManagedModules()) {
-            modules.set(module.id, toBindingModule(module, config, packages, this.resolvedConnections));
-        }
-        return modules;
-    }
-    collectInterfaceSources() {
-        this.resolver.moduleByFolder.clear();
-        this.resolver.modulesById.clear();
-        this.resolver.interfacePackages.clear();
-        this.resolver.interfacePackageEntries.clear();
-        this.resolver.interfacePackageResolveFrom.clear();
-        this.resolver.lifecycleInterfacePackages.clear();
-        this.resolver.stubbedInterfacePackages.clear();
-        this.interfacePackagePlans.clear();
-        this.resolvedAssociations.clear();
-        this.resolvedConnections.clear();
-        this.selectedProviders.clear();
-        this.moduleTracker.clear();
-        this.interfaceRegistry.clear();
-        const interfaceSources = new Map();
-        for (const { module, config } of this.loaded.values()) {
-            this.resolver.moduleByFolder.set(module.manifest.folder, module);
-            this.resolver.modulesById.set(module.id, module);
-            this.moduleTracker.add({
-                dir: module.manifest.folder,
-                id: module.id,
-                isImplementor: (module.manifest.implements ?? []).length > 0,
-            });
-            for (const interfacePackage of module.manifest.implements ?? []) {
-                if (!config.disabledExports?.has(interfacePackage)) {
-                    this.addInterfaceSource(interfaceSources, interfacePackage, module);
-                }
-            }
-        }
-        for (const { module, config } of this.staticModules) {
-            this.resolver.modulesById.set(module.id, module);
-            for (const interfacePackage of module.manifest.implements ?? []) {
-                if (!config.disabledExports?.has(interfacePackage)) {
-                    this.addInterfaceSource(interfaceSources, interfacePackage, module);
-                }
-            }
-        }
-        this.resolveInterfacePackagePaths(interfaceSources);
-        return interfaceSources;
-    }
-    resolveInterfacePackagePaths(interfaceSources) {
-        for (const [ifacePkg, modules] of interfaceSources) {
-            const module = [...modules].sort((left, right) => compareModuleIds(left.id, right.id))[0];
-            if (!module) {
-                continue;
-            }
-            const canonicalPackage = this.resolveImplementedPackage(ifacePkg, module);
-            if (!canonicalPackage) {
-                continue;
-            }
-            this.interfacePackagePlans.set(ifacePkg, {
-                canonicalPackage,
-                consumers: this.collectInterfacePackageConsumers(ifacePkg),
-            });
-            this.registerInterfacePackage(ifacePkg, canonicalPackage, false);
-        }
-        for (const [packageName, canonicalPackage] of this
-            .stubbedInterfacePackages) {
-            if (interfaceSources.has(packageName)) {
-                continue;
-            }
-            this.interfacePackagePlans.set(packageName, {
-                canonicalPackage,
-                consumers: this.collectInterfacePackageConsumers(packageName),
-            });
-            this.registerInterfacePackage(packageName, canonicalPackage, true);
-        }
-    }
-    resolveImplementedPackage(packageName, module) {
-        const resolvedPackage = (0, package_resolution_1.resolvePackage)(packageName, module.manifest.folder);
-        if (resolvedPackage) {
-            return resolvedPackage;
-        }
-        if (module.manifest.manifest.name !== packageName) {
-            return undefined;
-        }
-        return {
-            ...(0, package_resolution_1.resolvePackageAtRoot)(packageName, module.manifest.folder, module.manifest.version),
-            antelopeJs: module.manifest.manifest.antelopeJs,
-        };
-    }
-    collectInterfacePackageConsumers(packageName) {
-        const consumers = [];
-        for (const { module } of this.loaded.values()) {
-            const manifest = module.manifest.manifest;
-            const range = manifest.dependencies?.[packageName] ??
-                manifest.optionalDependencies?.[packageName];
-            if (!range) {
-                continue;
-            }
-            consumers.push({
-                moduleId: module.id,
-                range,
-                resolvedPackage: (0, package_resolution_1.resolvePackage)(packageName, module.manifest.folder),
-            });
-        }
-        return consumers;
-    }
-    registerInterfacePackage(packageName, resolvedPackage, isStubbed = false) {
-        this.resolver.interfacePackages.set(packageName, resolvedPackage.root);
-        this.resolver.interfacePackageEntries.set(packageName, resolvedPackage.entry);
-        this.resolver.interfacePackageResolveFrom.set(packageName, resolvedPackage.resolveFrom);
-        if (isStubbed) {
-            this.resolver.stubbedInterfacePackages.add(packageName);
-        }
-        else {
-            this.resolver.stubbedInterfacePackages.delete(packageName);
-        }
-        const implementations = resolvedPackage.antelopeJs?.implements;
-        if (Array.isArray(implementations) &&
-            implementations.includes(packageName)) {
-            this.resolver.lifecycleInterfacePackages.add(packageName);
-            return;
-        }
-        this.resolver.lifecycleInterfacePackages.delete(packageName);
-    }
-    validateInterfacePackages() {
-        const plans = [...this.interfacePackagePlans];
-        const rangeConflicts = plans.flatMap(([name, plan]) => this.findRangeConflicts(name, plan));
-        const preloadedCopies = plans.flatMap(([name, plan]) => this.findPreloadedCopies(name, plan));
-        if (rangeConflicts.length === 0 && preloadedCopies.length === 0) {
-            return;
-        }
-        throw new interface_resolution_error_1.InterfaceResolutionError({ rangeConflicts, preloadedCopies });
-    }
-    findRangeConflicts(packageName, plan) {
-        return plan.consumers.flatMap((consumer) => {
-            const range = (0, semver_1.validRange)(consumer.range);
-            if (!range || (0, semver_1.satisfies)(plan.canonicalPackage.version, range)) {
-                return [];
-            }
-            return [
-                {
-                    moduleId: consumer.moduleId,
-                    packageName,
-                    range: consumer.range,
-                    canonical: plan.canonicalPackage,
-                    consumerCopy: consumer.resolvedPackage,
-                },
-            ];
-        });
-    }
-    findPreloadedCopies(packageName, plan) {
-        const canonicalRoot = plan.canonicalPackage.realRoot;
-        const loadedFiles = Object.keys(require.cache);
-        return plan.consumers.flatMap(({ moduleId, resolvedPackage: copy }) => {
-            if (!copy || copy.realRoot === canonicalRoot) {
-                return [];
-            }
-            const isInCopy = (0, package_resolution_1.createPathWithinMatcher)(copy.root);
-            const loadedFile = loadedFiles.find((filePath) => isInCopy(filePath));
-            return loadedFile
-                ? [
-                    {
-                        moduleId,
-                        packageName,
-                        copy,
-                        canonical: plan.canonicalPackage,
-                        loadedFile,
-                    },
-                ]
-                : [];
-        });
-    }
-    buildModuleAssociations(interfaceSources) {
-        for (const { module, config } of this.loaded.values()) {
-            const connections = new Map();
-            const selected = new Map();
-            this.addDefaultAssociations(module, connections, selected, interfaceSources);
-            this.applyImportOverrides(module.id, config.importOverrides, connections, selected);
-            this.resolvedAssociations.set(module.id, new Set(connections.keys()));
-            this.resolvedConnections.set(module.id, connections);
-            this.selectedProviders.set(module.id, selected);
-            this.interfaceRegistry.setConnections(module.id, connections, selected);
-        }
-    }
-    addDefaultAssociations(module, connections, selected, interfaceSources) {
-        const dependencies = module.manifest.manifest.dependencies ?? {};
-        const optionalDependencies = module.manifest.manifest.optionalDependencies ?? {};
-        for (const [iface, providers] of interfaceSources) {
-            if (iface in dependencies || iface in optionalDependencies) {
-                const providerIds = providers.map(({ id }) => id).sort();
-                const defaultProvider = providerIds[0];
-                if (!defaultProvider) {
-                    continue;
-                }
-                connections.set(iface, providerIds.map((provider) => ({ module: provider })));
-                selected.set(iface, defaultProvider);
-            }
-        }
-    }
-    applyImportOverrides(moduleId, importOverrides, connections, selected) {
-        if (!importOverrides) {
-            return;
-        }
-        for (const [iface, overrides] of importOverrides.entries()) {
-            this.validateImportOverrides(moduleId, iface, overrides);
-            connections.set(iface, overrides);
-            if (overrides[0].module === undefined) {
-                selected.delete(iface);
-            }
-            else {
-                selected.set(iface, overrides[0].module);
-            }
-        }
-    }
-    addInterfaceSource(sources, interfaceName, module) {
-        const providers = sources.get(interfaceName) ?? [];
-        providers.push(module);
-        sources.set(interfaceName, providers);
-    }
-    validateImportOverrides(consumerId, interfaceName, overrides) {
-        if (overrides.length === 0) {
-            throw new Error(`Module '${consumerId}' has no providers in its '${interfaceName}' import override.`);
-        }
-        const connectionIds = new Set();
-        for (const override of overrides) {
-            this.validateOverrideSource(consumerId, interfaceName, override.module);
-            if (override.id && connectionIds.has(override.id)) {
-                throw new Error(`Module '${consumerId}' has duplicate connection ID '${override.id}' for '${interfaceName}'.`);
-            }
-            if (override.id) {
-                connectionIds.add(override.id);
-            }
-        }
-    }
-    validateOverrideSource(consumerId, interfaceName, source) {
-        if (source === undefined) {
-            this.validateSelfHostedConnection(consumerId, interfaceName);
-            return;
-        }
-        const target = this.getModuleEntry(source);
-        const implementsInterface = target?.module.manifest.implements.includes(interfaceName) &&
-            !target.config.disabledExports?.has(interfaceName);
-        if (!implementsInterface) {
-            throw new Error(`Module '${consumerId}' routes '${interfaceName}' to '${source}', but that loaded module does not provide the interface.`);
-        }
-    }
-    validateSelfHostedConnection(consumerId, interfaceName) {
-        if (this.hasLiveImplementer(interfaceName, new Set())) {
-            throw new Error(`Module '${consumerId}' declares a '${interfaceName}' connection without a source, but loaded modules provide that interface; name the provider.`);
-        }
-    }
-}
-exports.ModuleManager = ModuleManager;
-function toBindingConnections(connections) {
-    return new Map([...(connections ?? [])].map(([interfaceName, refs]) => [
-        interfaceName,
-        refs.map(({ module: source, id }) => ({ source, id })),
-    ]));
-}
-function toBindingModule(module, config, packages, listed) {
-    const manifest = module.manifest.manifest;
-    const declared = {
-        ...manifest.optionalDependencies,
-        ...manifest.dependencies,
-    };
-    const connections = toBindingConnections(config.importOverrides);
-    return {
-        id: module.id,
-        implements: (module.manifest.implements ?? []).filter((name) => packages.has(name) && !config.disabledExports?.has(name)),
-        uses: Object.keys(declared).filter((name) => packages.has(name)),
-        connections,
-        listedConnections: toBindingConnections(listed.get(module.id)),
-        exportPriority: config.exportPriority ?? new Map(),
-    };
-}
-function startWithinDeadline(module) {
-    const timers = [];
-    const deadline = new Promise((_, reject) => {
-        timers.push(setTimeout(() => {
-            Logger.Warn(`Module '${module.id}' is still starting after ${START_SLOW_WARNING_MS / MS_PER_SECOND} s`);
-        }, START_SLOW_WARNING_MS), setTimeout(() => {
-            reject(new Error(`Module '${module.id}' did not start within ${START_TIMEOUT_MS / MS_PER_SECOND} s`));
-        }, START_TIMEOUT_MS));
-    });
-    return Promise.race([module.start(), deadline]).finally(() => {
-        timers.forEach(clearTimeout);
-    });
-}
-function collectRejectedErrors(results) {
-    return results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
-}
-function unpackErrors(error) {
-    return error instanceof AggregateError ? error.errors : [error];
-}
-function aggregateErrors(errors, message) {
-    return errors.length === 1 ? errors[0] : new AggregateError(errors, message);
-}
-async function runModuleOperations(modules, operation) {
-    return (await runTrackedModuleOperations(modules, operation)).errors;
-}
-async function runTrackedModuleOperations(modules, operation) {
-    const errors = [];
-    const failed = [];
-    for (const entry of modules) {
-        try {
-            await operation(entry.module);
-        }
-        catch (error) {
-            errors.push(...unpackErrors(error));
-            failed.push(entry);
-        }
-    }
-    return { errors, failed };
-}
-//# sourceMappingURL=module-manager.js.map