@antelopejs/core 1.13.4 → 1.14.0

package/dist/core/module-isolation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-isolation.js","sourceRoot":"","sources":["../../src/core/module-isolation.ts"],"names":[],"mappings":"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"}

package/dist/core/module-manager.d.ts

@@ -5,10 +5,12 @@ import { ModuleRegistry } from "./module-registry";
 import type { UnresolvedInterface } from "./resolution/interface-resolution";
 import { type ModuleManifest } from "./module-manifest";
 import { type InterfaceConnectionRef, InterfaceRegistry } from "./interface-registry";
+import type { BindingGraph } from "./resolution/binding-graph-types";
 export interface ModuleConfig {
     config?: unknown;
     importOverrides?: Map<string, InterfaceConnectionRef[]>;
     disabledExports?: Set<string>;
+    exportPriority?: Map<string, number>;
 }
 export interface ManagedModule {
     module: Module;
@@ -35,6 +37,8 @@ export declare class ModuleManager {
     private readonly interfacePackagePlans;
     private readonly configVars;
     private pendingCleanup;
+    private bindingGraph?;
+    private readonly isolation;
     private startupOrder;
     constructor(deps?: ModuleManagerDeps);
     addStaticModule(entry: {
@@ -45,6 +49,7 @@ export declare class ModuleManager {
         manifest: ModuleManifest;
         config?: ModuleConfig;
     }>): ManagedModule[];
+    private restoreModules;
     listModules(): string[];
     getModule(id: string): Module | undefined;
     getModuleEntry(id: string): ManagedModule | undefined;
@@ -55,12 +60,17 @@ export declare class ModuleManager {
     private evictModuleFiles;
     private collectAvoidedFolders;
     private belongsToInterfacePackageTree;
+    setInstanceRoot(root: string): void;
+    placeModule(moduleId: string, manifest: ModuleManifest): ModuleManifest;
+    checkReplacement(moduleId: string, replacement: Module): void;
+    discardPlacedModule(manifest: ModuleManifest): void;
     replaceLoadedModule(id: string, module: Module): ManagedModule | undefined;
     refreshAssociations(): void;
     hasResolvedInterface(moduleId: string, interfaceName: string): boolean;
     registerStubbedInterfaces(stubbed: UnresolvedInterface[]): void;
     private registerStubbedInterfacePackage;
     private applyInterfaceStubs;
+    private neutralizeInstances;
     private collectImplementedInterfaces;
     constructAll(): Promise<void>;
     constructModules(modules: ManagedModule[]): Promise<void>;
@@ -85,20 +95,28 @@ export declare class ModuleManager {
     private clearManagedState;
     private releaseRuntimeState;
     private trackModuleStart;
+    getBindingGraph(): BindingGraph | undefined;
     private rebuildAssociations;
+    private buildBindings;
+    private runningBindings;
+    private logBindingWarnings;
+    private bindablePackages;
+    private collectBindingInterfaces;
+    private collectBindingModules;
     private collectInterfaceSources;
     private resolveInterfacePackagePaths;
     private resolveImplementedPackage;
     private collectInterfacePackageConsumers;
     private registerInterfacePackage;
     private validateInterfacePackages;
-    private findVersionErrors;
-    private findPreloadedCopyErrors;
+    private findRangeConflicts;
+    private findPreloadedCopies;
     private buildModuleAssociations;
     private addDefaultAssociations;
     private applyImportOverrides;
     private addInterfaceSource;
     private validateImportOverrides;
-    private configureModuleContexts;
+    private validateOverrideSource;
+    private validateSelfHostedConnection;
 }
 export {};

package/dist/core/module-manager.js

@@ -38,6 +38,7 @@ 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 types_1 = require("../types");
 const module_tracker_1 = require("./module-tracker");
 const resolver_1 = require("./resolution/resolver");
@@ -51,7 +52,12 @@ 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";
 function compareModuleIds(left, right) {
     return left.localeCompare(right);
 }
@@ -70,6 +76,8 @@ class ModuleManager {
     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();
@@ -84,27 +92,54 @@ class ModuleManager {
             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) {
-            const module = new module_1.Module(entry.manifest);
+            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);
         }
-        this.rebuildAssociations();
+        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();
+    }
     listModules() {
         return this.registry.list();
     }
@@ -172,11 +207,39 @@ class ModuleManager {
         }
         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;
@@ -193,6 +256,7 @@ class ModuleManager {
             const entries = stubbed.filter((entry) => entry.interfacePackage === packageName);
             this.registerStubbedInterfacePackage(packageName, entries);
         }
+        this.buildBindings();
     }
     registerStubbedInterfacePackage(packageName, entries) {
         const consumers = this.collectInterfacePackageConsumers(packageName);
@@ -222,14 +286,22 @@ class ModuleManager {
             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 {
-                require(interfaceName);
+                root = this.resolver.loadInstance(instance);
             }
             catch (err) {
-                Logger.Error(`Failed to load interface '${interfaceName}':`, err);
+                Logger.Error(`Failed to load interface '${instance}':`, err);
                 continue;
             }
-            (0, stub_interface_runtime_1.neutralizeInterfacePackage)(resolvedPackage.root, interfaceName);
+            if (root) {
+                (0, stub_interface_runtime_1.neutralizeInterfacePackage)(root, interfaceName);
+            }
         }
     }
     collectImplementedInterfaces() {
@@ -249,7 +321,7 @@ class ModuleManager {
         let plan;
         let provided;
         try {
-            this.configureModuleContexts();
+            this.logBindingWarnings();
             this.validateInterfacePackages();
             this.applyInterfaceStubs();
             plan = this.planConfigVars(modules);
@@ -278,7 +350,7 @@ class ModuleManager {
     async constructModules(modules) {
         const leaseAcquired = this.resolverDetour.attach();
         try {
-            this.configureModuleContexts();
+            this.logBindingWarnings();
             this.validateInterfacePackages();
             this.applyInterfaceStubs();
             await Promise.all(modules
@@ -334,6 +406,8 @@ class ModuleManager {
         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");
@@ -436,20 +510,24 @@ class ModuleManager {
             !config.disabledExports?.has(interfaceName));
     }
     rejectCallsInto(moduleId, interfaceName) {
-        const packageRoot = this.resolver.interfacePackages.get(interfaceName);
         const entry = this.getModuleEntry(moduleId);
-        if (!packageRoot || !entry) {
+        if (!entry) {
             return;
         }
+        let instanceRoot;
         try {
-            require(interfaceName);
+            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)(packageRoot, interfaceName, `has no provider: module '${moduleId}' did not construct`));
+        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));
@@ -530,10 +608,69 @@ class ModuleManager {
         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();
@@ -652,41 +789,49 @@ class ModuleManager {
         this.resolver.lifecycleInterfacePackages.delete(packageName);
     }
     validateInterfacePackages() {
-        const errors = [...this.interfacePackagePlans].flatMap(([name, plan]) => [
-            ...this.findVersionErrors(name, plan),
-            ...this.findPreloadedCopyErrors(name, plan),
-        ]);
-        if (errors.length === 0) {
+        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 Error(`Incompatible interface package resolution:\n${errors.join("\n")}`);
+        throw new interface_resolution_error_1.InterfaceResolutionError({ rangeConflicts, preloadedCopies });
     }
-    findVersionErrors(packageName, plan) {
+    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 [];
             }
-            const installed = consumer.resolvedPackage
-                ? `${consumer.resolvedPackage.version} at ${consumer.resolvedPackage.root}`
-                : "not installed from the consumer";
             return [
-                `  - ${consumer.moduleId} requires ${packageName}@${consumer.range}, but the canonical package is ${plan.canonicalPackage.version} at ${plan.canonicalPackage.root} (consumer copy: ${installed})`,
+                {
+                    moduleId: consumer.moduleId,
+                    packageName,
+                    range: consumer.range,
+                    canonical: plan.canonicalPackage,
+                    consumerCopy: consumer.resolvedPackage,
+                },
             ];
         });
     }
-    findPreloadedCopyErrors(packageName, plan) {
+    findPreloadedCopies(packageName, plan) {
         const canonicalRoot = plan.canonicalPackage.realRoot;
-        const copies = plan.consumers
-            .map((consumer) => consumer.resolvedPackage)
-            .filter((resolvedPackage) => Boolean(resolvedPackage && resolvedPackage.realRoot !== canonicalRoot));
         const loadedFiles = Object.keys(require.cache);
-        return copies.flatMap((copy) => {
+        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
                 ? [
-                    `  - ${packageName}@${copy.version} was loaded from ${copy.root} before the canonical copy at ${plan.canonicalPackage.root}; preloaded interface copies cannot be redirected (${loadedFile})`,
+                    {
+                        moduleId,
+                        packageName,
+                        copy,
+                        canonical: plan.canonicalPackage,
+                        loadedFile,
+                    },
                 ]
                 : [];
         });
@@ -725,7 +870,12 @@ class ModuleManager {
         for (const [iface, overrides] of importOverrides.entries()) {
             this.validateImportOverrides(moduleId, iface, overrides);
             connections.set(iface, overrides);
-            selected.set(iface, overrides[0].module);
+            if (overrides[0].module === undefined) {
+                selected.delete(iface);
+            }
+            else {
+                selected.set(iface, overrides[0].module);
+            }
         }
     }
     addInterfaceSource(sources, interfaceName, module) {
@@ -739,12 +889,7 @@ class ModuleManager {
         }
         const connectionIds = new Set();
         for (const override of overrides) {
-            const target = this.getModuleEntry(override.module);
-            const implementsInterface = target?.module.manifest.implements.includes(interfaceName) &&
-                !target.config.disabledExports?.has(interfaceName);
-            if (!implementsInterface) {
-                throw new Error(`Module '${consumerId}' routes '${interfaceName}' to '${override.module}', but that loaded module does not provide the interface.`);
-            }
+            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}'.`);
             }
@@ -753,14 +898,47 @@ class ModuleManager {
             }
         }
     }
-    configureModuleContexts() {
-        for (const { module, config } of this.getAllManagedModules()) {
-            const isProvider = (module.manifest.implements ?? []).some((interfaceName) => !config.disabledExports?.has(interfaceName));
-            module.setProviderRoutes(this.resolver.buildProviderRoutes(module.id), isProvider);
+    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 collectRejectedErrors(results) {
     return results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
 }