@softarc/native-federation-orchestrator 4.5.2 → 4.5.3

package/fesm2022/node.mjs

@@ -1490,16 +1490,21 @@ var createRemoteInfoRepository = (config) => {
   const STORAGE = config.storage("remotes", {});
   if (config.clearStorage) STORAGE.clear();
   const _cache = STORAGE.get() ?? {};
+  let _dirty = false;
   return {
     contains: function(remoteName) {
       return !!_cache[remoteName];
     },
     remove: function(remoteName) {
-      delete _cache[remoteName];
+      if (remoteName in _cache) {
+        delete _cache[remoteName];
+        _dirty = true;
+      }
       return this;
     },
     addOrUpdate: function(remoteName, remote) {
       _cache[remoteName] = remote;
+      _dirty = true;
       return this;
     },
     tryGet: function(remoteName) {
@@ -1514,7 +1519,9 @@ var createRemoteInfoRepository = (config) => {
       return _cache;
     },
     commit: function() {
+      if (!_dirty) return this;
       STORAGE.set(_cache);
+      _dirty = false;
       return this;
     }
   };
@@ -1525,14 +1532,19 @@ var createScopedExternalsRepository = (config) => {
   const STORAGE = config.storage("scoped-externals", {});
   if (config.clearStorage) STORAGE.clear();
   const _cache = STORAGE.get() ?? {};
+  let _dirty = false;
   return {
     addExternal: function(remoteName, external, version) {
       if (!_cache[remoteName]) _cache[remoteName] = {};
       _cache[remoteName][external] = version;
+      _dirty = true;
       return this;
     },
     remove: function(remoteName) {
-      delete _cache[remoteName];
+      if (remoteName in _cache) {
+        delete _cache[remoteName];
+        _dirty = true;
+      }
       return this;
     },
     getAll: function() {
@@ -1542,7 +1554,9 @@ var createScopedExternalsRepository = (config) => {
       return Optional.of(_cache[remoteName]);
     },
     commit: function() {
+      if (!_dirty) return this;
       STORAGE.set(_cache);
+      _dirty = false;
       return this;
     }
   };
@@ -1559,8 +1573,9 @@ var createSharedExternalsRepository = (config) => {
     { [GLOBAL_SCOPE]: {} }
   );
   if (config.clearStorage) STORAGE.clear();
-  const _cache = STORAGE.get();
+  const _cache = STORAGE.get() ?? { [GLOBAL_SCOPE]: {} };
   let _sawPoolTag = false;
+  let _dirty = false;
   return {
     markPoolTagPresent: function() {
       _sawPoolTag = true;
@@ -1574,28 +1589,38 @@ var createSharedExternalsRepository = (config) => {
     addOrUpdate: function(externalName, external, shareScope) {
       if (!_cache[shareScope ?? GLOBAL_SCOPE]) _cache[shareScope ?? GLOBAL_SCOPE] = {};
       _cache[shareScope ?? GLOBAL_SCOPE][externalName] = external;
+      _dirty = true;
       return this;
     },
     getScopes: function(o = { includeGlobal: true }) {
       if (o.includeGlobal) return Object.keys(_cache);
       return Object.keys(_cache).filter((s) => s !== GLOBAL_SCOPE);
     },
-    removeFromAllScopes: function(remoteName) {
+    // Batched: one traversal of the graph per init instead of one per overridden remote.
+    removeFromAllScopes: function(remoteNames) {
+      if (remoteNames.size === 0) return;
       Object.values(_cache).forEach((scope) => {
         const removeExternals = [];
         Object.entries(scope).forEach(([name, external]) => {
-          const removeVersionIdx = [];
-          external.versions.forEach((version, i) => {
-            const versionRemoteIDX = version.remotes.findIndex((r) => r.name === remoteName);
-            if (~versionRemoteIDX) {
-              version.remotes.splice(versionRemoteIDX, 1);
+          let removedVersion = false;
+          for (let i = external.versions.length - 1; i >= 0; i--) {
+            const remotes = external.versions[i].remotes;
+            let keep = 0;
+            for (let r = 0; r < remotes.length; r++) {
+              if (remoteNames.has(remotes[r].name)) continue;
+              remotes[keep++] = remotes[r];
             }
-            if (version.remotes.length === 0) removeVersionIdx.push(i);
-          });
-          if (removeVersionIdx.length > 0) {
-            for (let i = removeVersionIdx.length - 1; i >= 0; i--) {
-              external.versions.splice(removeVersionIdx[i], 1);
+            if (keep !== remotes.length) {
+              remotes.length = keep;
+              _dirty = true;
             }
+            if (remotes.length === 0) {
+              external.versions.splice(i, 1);
+              removedVersion = true;
+              _dirty = true;
+            }
+          }
+          if (removedVersion) {
             external.dirty = true;
             if (external.versions.length === 0) removeExternals.push(name);
           }
@@ -1619,7 +1644,9 @@ var createSharedExternalsRepository = (config) => {
       return Optional.of(_cache[shareScope ?? GLOBAL_SCOPE]?.[external]);
     },
     commit: function() {
+      if (!_dirty) return this;
       STORAGE.set(_cache);
+      _dirty = false;
       return this;
     }
   };
@@ -1630,17 +1657,21 @@ var createChunkRepository = (config) => {
   const STORAGE = config.storage("shared-chunks", {});
   if (config.clearStorage) STORAGE.clear();
   const _cache = STORAGE.get() ?? {};
+  let _dirty = false;
   return {
     addOrReplace: function(remoteName, bundleName, chunks) {
       if (!_cache[remoteName]) _cache[remoteName] = {};
       _cache[remoteName][bundleName] = chunks;
+      _dirty = true;
       return this;
     },
     tryGet: function(remoteName, bundleName) {
       return Optional.of(_cache[remoteName]?.[bundleName]);
     },
     commit: function() {
+      if (!_dirty) return this;
       STORAGE.set(_cache);
+      _dirty = false;
       return this;
     }
   };
@@ -1830,10 +1861,9 @@ var globalThisStorageEntry = (namespace) => (key, initialValue) => {
     globalThis[namespace] = {};
   }
   const storage = globalThis[namespace];
-  if (!storage[key]) storage[key] = initialValue;
   const entry = {
     get() {
-      return cloneEntry(key, storage[key]);
+      return cloneEntry(key, key in storage ? storage[key] : initialValue);
     },
     set(value) {
       storage[key] = cloneEntry(key, value);
@@ -1857,6 +1887,7 @@ var createStorageConfig = (override) => ({
 var defaultProfile = {
   latestSharedExternal: false,
   skipInvalidExternalVersions: false,
+  scopeUncoveredEntrypoints: false,
   overrideCachedRemotes: "init-only",
   overrideCachedRemotesIfURLMatches: false
 };
@@ -2022,19 +2053,71 @@ function createGetRemoteEntries(config, ports) {
   }
 }
 
+// src/lib/core/1.domain/externals/basis.ts
+var coverage = (remote) => Object.keys(remote.entries).length;
+function isBetterBasis(candidate, basis) {
+  if (basis.cached !== candidate.cached) return candidate.cached;
+  return coverage(candidate) > coverage(basis);
+}
+function addRemoteToVersion(version, remote, isHost = false) {
+  if (isHost) {
+    version.host = true;
+    version.remotes.unshift(remote);
+    return;
+  }
+  const basis = version.remotes[0];
+  if (basis && !version.host && isBetterBasis(remote, basis)) {
+    version.remotes.unshift(remote);
+    return;
+  }
+  version.remotes.push(remote);
+}
+function versionDemands(version) {
+  if (version.remotes.length < 2) return version.remotes;
+  const distinct = /* @__PURE__ */ new Map();
+  for (const remote of version.remotes) {
+    const key = `${remote.requiredVersion}|${remote.strictVersion}|${remote.cached}`;
+    if (!distinct.has(key)) distinct.set(key, remote);
+  }
+  return Array.from(distinct.values());
+}
+function findVersionForTag(versions, tag) {
+  let scoped;
+  for (const version of versions) {
+    if (version.tag !== tag) continue;
+    if (version.action !== "scope") return version;
+    scoped ??= version;
+  }
+  return scoped;
+}
+function uncoveredEntrypoints(remote, basis) {
+  return Object.keys(remote.entries).filter((entrypoint) => !(entrypoint in basis));
+}
+function countUncoveredEntrypoints(remote, basis) {
+  let uncovered = 0;
+  for (const entrypoint in remote.entries) {
+    if (!(entrypoint in basis)) uncovered++;
+  }
+  return uncovered;
+}
+
 // src/lib/core/2.app/steps/store-remote-entry.ts
+function createRemoveCachedRemoteEntries(ports) {
+  return (remoteNames) => {
+    if (remoteNames.size === 0) return;
+    for (const remoteName of remoteNames) {
+      ports.remoteInfoRepo.remove(remoteName);
+      ports.scopedExternalsRepo.remove(remoteName);
+    }
+    ports.sharedExternalsRepo.removeFromAllScopes(remoteNames);
+  };
+}
 function createStoreRemoteEntry(config, ports, logStep) {
   return (remoteEntry, onSharedExternal) => {
-    if (remoteEntry?.override) removeCachedRemoteEntry(remoteEntry);
     addRemoteInfoToStorage(remoteEntry);
     addExternalsToStorage(remoteEntry, onSharedExternal);
     addSharedChunksToStorage(remoteEntry);
   };
-  function removeCachedRemoteEntry(remoteEntry) {
-    ports.remoteInfoRepo.remove(remoteEntry.name);
-    ports.scopedExternalsRepo.remove(remoteEntry.name);
-    ports.sharedExternalsRepo.removeFromAllScopes(remoteEntry.name);
-  }
   function addRemoteInfoToStorage({ name, url, exposes, integrity }) {
     ports.remoteInfoRepo.addOrUpdate(name, {
       scopeUrl: getScope(url),
@@ -2134,14 +2217,35 @@ function createStoreRemoteEntry(config, ports, logStep) {
 // src/lib/core/2.app/steps/process-remote-entries.ts
 function createProcessRemoteEntries(config, ports) {
   const storeRemoteEntry = createStoreRemoteEntry(config, ports, 2);
+  const removeCachedRemoteEntries = createRemoveCachedRemoteEntries(ports);
   return (remoteEntries) => {
     try {
-      remoteEntries.forEach((remoteEntry) => storeRemoteEntry(remoteEntry, addSharedExternal));
+      const evictPerEntry = evictOverriddenRemotes(remoteEntries);
+      remoteEntries.forEach((remoteEntry) => {
+        if (remoteEntry?.override && evictPerEntry.has(remoteEntry.name)) {
+          removeCachedRemoteEntries(/* @__PURE__ */ new Set([remoteEntry.name]));
+        }
+        storeRemoteEntry(remoteEntry, addSharedExternal);
+      });
       return Promise.resolve(remoteEntries);
     } catch (e) {
       return Promise.reject(e);
     }
   };
+  function evictOverriddenRemotes(remoteEntries) {
+    const batched = /* @__PURE__ */ new Set();
+    const repeated = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    for (const remoteEntry of remoteEntries) {
+      if (!remoteEntry) continue;
+      if (seen.has(remoteEntry.name)) repeated.add(remoteEntry.name);
+      seen.add(remoteEntry.name);
+      if (remoteEntry.override) batched.add(remoteEntry.name);
+    }
+    for (const remoteName of repeated) batched.delete(remoteName);
+    removeCachedRemoteEntries(batched);
+    return repeated;
+  }
   function addSharedExternal(remoteEntry, _sharedInfo, {
     tag,
     remote,
@@ -2150,15 +2254,12 @@ function createProcessRemoteEntries(config, ports) {
     assertSameVersionCompatibility,
     commit
   }) {
-    const matchingVersion = cached2.versions.find((version) => version.tag === tag);
+    if (scopeType !== "strict") cached2.dirty = true;
+    const matchingVersion = findVersionForTag(cached2.versions, tag);
     if (matchingVersion) {
       assertSameVersionCompatibility(matchingVersion);
-      if (!matchingVersion.host && !!remoteEntry?.host) {
-        matchingVersion.host = true;
-        matchingVersion.remotes.unshift(remote);
-      } else matchingVersion.remotes.push(remote);
+      addRemoteToVersion(matchingVersion, remote, !matchingVersion.host && !!remoteEntry?.host);
     } else {
-      if (scopeType !== "strict") cached2.dirty = true;
       cached2.versions.push({
         tag,
         action: scopeType === "strict" ? "share" : "skip",
@@ -2173,13 +2274,23 @@ function createProcessRemoteEntries(config, ports) {
 // src/lib/core/2.app/steps/determine-shared-externals.ts
 function createDetermineSharedExternals(config, ports) {
   return () => {
+    const memo = /* @__PURE__ */ new Map();
+    const isCompatible = (tag, requiredVersion) => {
+      const key = `${tag}|${requiredVersion}`;
+      let hit = memo.get(key);
+      if (hit === void 0) {
+        hit = ports.versionCheck.isCompatible(tag, requiredVersion);
+        memo.set(key, hit);
+      }
+      return hit;
+    };
     for (const shareScope of ports.sharedExternalsRepo.getScopes()) {
       const sharedExternals = ports.sharedExternalsRepo.getFromScope(shareScope);
       try {
         Object.entries(sharedExternals).filter(([_, e]) => e.dirty).forEach(
           ([name, external]) => ports.sharedExternalsRepo.addOrUpdate(
             name,
-            setVersionActions(name, external),
+            setVersionActions(name, external, isCompatible),
             shareScope
           )
         );
@@ -2202,20 +2313,26 @@ function createDetermineSharedExternals(config, ports) {
     }
     return Promise.resolve();
   };
-  function uncoveredTears(external, winner) {
+  function uncoveredTears(external, winner, accepts) {
     const basis = winner.remotes[0].entries;
     return external.versions.reduce((sum, v) => {
       if (v === winner) return sum;
-      if (!ports.versionCheck.isCompatible(winner.tag, v.remotes[0].requiredVersion)) return sum;
-      return sum + v.remotes.reduce((n, r) => n + Object.keys(r.entries).filter((e) => !(e in basis)).length, 0);
+      if (!accepts(v, winner.tag)) return sum;
+      return sum + v.remotes.reduce((n, r) => n + countUncoveredEntrypoints(r, basis), 0);
     }, 0);
   }
-  function setVersionActions(externalName, external) {
+  function setVersionActions(externalName, external, isCompatible) {
     if (external.versions.length === 1) {
       external.versions[0].action = "share";
+      applyEntrypointCoveragePolicy(externalName, external);
       external.dirty = false;
       return external;
     }
+    const demands = new Map(
+      external.versions.map((v) => [v, versionDemands(v)])
+    );
+    const accepts = (version, tag) => demands.get(version).every((d) => isCompatible(tag, d.requiredVersion));
+    const objector = (version, tag) => demands.get(version).find((d) => d.strictVersion && !isCompatible(tag, d.requiredVersion));
     let sharedVersion = external.versions.find((v) => v.host);
     if (!sharedVersion && config.profile.latestSharedExternal) {
       sharedVersion = external.versions[0];
@@ -2225,11 +2342,17 @@ function createDetermineSharedExternals(config, ports) {
       let leastTears = Number.MAX_VALUE;
       external.versions.forEach((vA) => {
         const extraDownloads = external.versions.filter(
-          (vB) => !vB.remotes[0].cached && vB.remotes[0].strictVersion && !ports.versionCheck.isCompatible(vA.tag, vB.remotes[0].requiredVersion)
+          (vB) => demands.get(vB).some((d) => !d.cached && d.strictVersion && !isCompatible(vA.tag, d.requiredVersion))
         ).length;
-        const tears = uncoveredTears(external, vA);
-        if (extraDownloads < leastExtraDownloads || extraDownloads === leastExtraDownloads && tears < leastTears) {
+        if (extraDownloads < leastExtraDownloads) {
           leastExtraDownloads = extraDownloads;
+          leastTears = uncoveredTears(external, vA, accepts);
+          sharedVersion = vA;
+          return;
+        }
+        if (extraDownloads > leastExtraDownloads) return;
+        const tears = uncoveredTears(external, vA, accepts);
+        if (tears < leastTears) {
           leastTears = tears;
           sharedVersion = vA;
         }
@@ -2239,39 +2362,81 @@ function createDetermineSharedExternals(config, ports) {
       throw new NFError(`[${externalName}] Could not determine shared version!`);
     }
     external.versions.forEach((v) => {
-      if (ports.versionCheck.isCompatible(sharedVersion.tag, v.remotes[0].requiredVersion)) {
+      if (accepts(v, sharedVersion.tag)) {
         v.action = "skip";
         return;
       }
-      if (config.strict.strictExternalCompatibility && v.remotes[0].strictVersion) {
+      const strict = objector(v, sharedVersion.tag);
+      if (config.strict.strictExternalCompatibility && strict) {
         config.log.error(
           3,
-          `[${v.remotes[0].name}][${externalName}@${v.tag}] Is not compatible with requiredRange '${sharedVersion.remotes[0]?.requiredVersion}' from remote '${sharedVersion.remotes[0].name}'.`
+          `[${strict.name}][${externalName}@${v.tag}] Is not compatible with requiredRange '${strict.requiredVersion}' of shared ${externalName}@${sharedVersion.tag}.`
         );
         throw new NFError(`External ${externalName}@${v.tag} could not be shared.`);
       }
-      v.action = v.remotes[0].strictVersion ? "scope" : "skip";
+      v.action = strict ? "scope" : "skip";
     });
     sharedVersion.action = "share";
-    if (config.strict.strictEntryPointCoverage) {
-      const basis = sharedVersion.remotes[0].entries;
-      external.versions.forEach((v) => {
-        if (v.action !== "skip") return;
-        const uncovered = v.remotes.some(
-          (r) => Object.keys(r.entries).some((entrypoint) => !(entrypoint in basis))
-        );
-        if (uncovered) {
-          v.action = "scope";
-          config.log.debug(
-            3,
-            `[${externalName}@${v.tag}] Scoped: entrypoints not covered by shared ${externalName}@${sharedVersion.tag}.`
-          );
-        }
-      });
-    }
+    applyEntrypointCoveragePolicy(externalName, external);
     external.dirty = false;
     return external;
   }
+  function applyEntrypointCoveragePolicy(externalName, external) {
+    const { strictEntryPointCoverage } = config.strict;
+    if (!strictEntryPointCoverage && !config.profile.scopeUncoveredEntrypoints) return;
+    const tears = findTears(external);
+    if (tears.length === 0) return;
+    if (strictEntryPointCoverage) {
+      const { version, remote, uncovered } = tears[0];
+      config.log.error(
+        3,
+        `[${externalName}@${version.tag}][${remote.name}] Entrypoints not covered by the shared version: ${uncovered.join(", ")}.`
+      );
+      throw new NFError(
+        `External ${externalName} could not be shared without tearing entrypoints.`
+      );
+    }
+    scopeTornRemotes(externalName, external, tears);
+  }
+  function findTears(external) {
+    const shared = external.versions.find((v) => v.action === "share");
+    if (!shared) return [];
+    const basis = shared.remotes[0].entries;
+    const tears = [];
+    for (const version of external.versions) {
+      if (version.action === "scope") continue;
+      version.remotes.forEach((remote, index) => {
+        if (version === shared && index === 0) return;
+        const uncovered = uncoveredEntrypoints(remote, basis);
+        if (uncovered.length > 0) tears.push({ version, remote, uncovered });
+      });
+    }
+    return tears;
+  }
+  function scopeTornRemotes(externalName, external, tears) {
+    const torn = new Set(tears.map((t) => t.remote));
+    const demotedByTag = /* @__PURE__ */ new Map();
+    for (const { version, remote, uncovered } of tears) {
+      const group = demotedByTag.get(version.tag);
+      if (group) group.push(remote);
+      else demotedByTag.set(version.tag, [remote]);
+      config.log.debug(
+        3,
+        `[${externalName}@${version.tag}][${remote.name}] Scoped: entrypoints not covered by the shared version: ${uncovered.join(", ")}.`
+      );
+    }
+    for (const version of external.versions) {
+      if (version.remotes.some((r) => torn.has(r))) {
+        version.remotes = version.remotes.filter((r) => !torn.has(r));
+      }
+    }
+    external.versions = external.versions.filter((v) => v.remotes.length > 0);
+    for (const [tag, remotes] of demotedByTag) {
+      const scoped = external.versions.find((v) => v.tag === tag && v.action === "scope");
+      if (scoped) scoped.remotes.push(...remotes);
+      else external.versions.push({ tag, host: false, action: "scope", remotes });
+    }
+  }
 }
 
 // src/lib/core/2.app/steps/pooling/pool-graph.ts
@@ -2566,6 +2731,7 @@ function createGenerateImportMap(config, ports) {
     for (const [externalName, external] of Object.entries(sharedExternals)) {
       let override = void 0;
       let overrideScope = void 0;
+      const cachedBefore = cachedFingerprint(external);
       for (const version of external.versions) {
         if (version.action === "scope") {
           for (const remote of version.remotes) {
@@ -2611,7 +2777,7 @@ function createGenerateImportMap(config, ports) {
           }
           for (const [packageName, file] of Object.entries(r.entries)) {
             if (packageName in source.entries) continue;
-            if (config.strict.strictEntryPointCoverage) {
+            if (config.strict.strictEntryPointCoverage || config.profile.scopeUncoveredEntrypoints) {
               warnUncoveredEntrypoint(shareScope, externalName, r.name, packageName);
               continue;
             }
@@ -2625,9 +2791,14 @@ function createGenerateImportMap(config, ports) {
           addIntegrity(importMap, m.url, m.name, m.file);
         }
       }
-      ports.sharedExternalsRepo.addOrUpdate(externalName, external, shareScope);
+      if (cachedFingerprint(external) !== cachedBefore) {
+        ports.sharedExternalsRepo.addOrUpdate(externalName, external, shareScope);
+      }
     }
   }
+  function cachedFingerprint(external) {
+    return external.versions.map((v) => v.remotes.map((r) => r.cached ? 1 : 0).join("")).join("|");
+  }
   function findOverride(external, shareScope, externalName) {
     const sharedVersions = external.versions.filter((v) => v.action === "share");
     const scopedExternalName = `${shareScope}.${externalName}`;
@@ -2659,6 +2830,7 @@ function createGenerateImportMap(config, ports) {
   function addGlobalSharedExternals(importMap, chunkBundles) {
     const sharedExternals = ports.sharedExternalsRepo.getFromScope();
     for (const [externalName, external] of Object.entries(sharedExternals)) {
+      const cachedBefore = cachedFingerprint(external);
       for (const version of external.versions) {
         if (version.action === "skip") continue;
         if (version.action === "scope") {
@@ -2686,31 +2858,39 @@ function createGenerateImportMap(config, ports) {
         }
         registerBundleChunks(chunkBundles, version.remotes[0].name, version.remotes[0].bundle);
         version.remotes[0].cached = true;
+        selfFillUncovered(importMap, chunkBundles, externalName, version.remotes, 1);
       }
       for (const version of external.versions) {
         if (version.action !== "skip") continue;
-        const remote = version.remotes[0];
-        for (const [packageName, file] of Object.entries(remote.entries)) {
-          if (importMap.imports[packageName]) continue;
-          if (config.strict.strictEntryPointCoverage) {
-            warnUncoveredEntrypoint(GLOBAL_SCOPE, externalName, remote.name, packageName);
-            continue;
-          }
-          const scope = getScope2(GLOBAL_SCOPE, remote.name, externalName);
-          const url = join(scope, file);
-          addToGlobal(importMap, { [packageName]: url });
-          addIntegrity(importMap, url, remote.name, file);
-          registerBundleChunks(chunkBundles, remote.name, remote.bundle);
-          remote.cached = true;
-        }
+        selfFillUncovered(importMap, chunkBundles, externalName, version.remotes);
+      }
+      if (cachedFingerprint(external) !== cachedBefore) {
+        ports.sharedExternalsRepo.addOrUpdate(externalName, external);
       }
-      ports.sharedExternalsRepo.addOrUpdate(externalName, external);
     }
     return importMap;
   }
+  function selfFillUncovered(importMap, chunkBundles, externalName, remotes, from = 0) {
+    for (let i = from; i < remotes.length; i++) {
+      const remote = remotes[i];
+      for (const [packageName, file] of Object.entries(remote.entries)) {
+        if (importMap.imports[packageName]) continue;
+        if (config.strict.strictEntryPointCoverage || config.profile.scopeUncoveredEntrypoints) {
+          warnUncoveredEntrypoint(GLOBAL_SCOPE, externalName, remote.name, packageName);
+          continue;
+        }
+        const scope = getScope2(GLOBAL_SCOPE, remote.name, externalName);
+        const url = join(scope, file);
+        addToGlobal(importMap, { [packageName]: url });
+        addIntegrity(importMap, url, remote.name, file);
+        registerBundleChunks(chunkBundles, remote.name, remote.bundle);
+        remote.cached = true;
+      }
+    }
+  }
   function warnUncoveredEntrypoint(scope, externalName, remoteName, packageName) {
     const msg = `[${scope}][${externalName}][${remoteName}] Entrypoint '${packageName}' is not covered by the shared version.`;
-    if (config.strict.strictImportMap) {
+    if (config.strict.strictEntryPointCoverage || config.strict.strictImportMap) {
       config.log.error(4, msg);
       throw new NFError("Could not create ImportMap.");
     }
@@ -2899,18 +3079,23 @@ function createGetRemoteEntry(config, ports) {
 // src/lib/core/2.app/steps/update-cache.ts
 function createUpdateCache(config, ports) {
   const storeRemoteEntry = createStoreRemoteEntry(config, ports, 8);
+  const removeCachedRemoteEntries = createRemoveCachedRemoteEntries(ports);
   return (remoteEntry) => {
     try {
       const actions = {};
+      if (remoteEntry?.override) removeCachedRemoteEntries(/* @__PURE__ */ new Set([remoteEntry.name]));
       storeRemoteEntry(remoteEntry, (entry, external, ctx) => {
         const { action, sharedVersion } = resolveSharedExternal(entry, external, ctx);
         actions[external.packageName] = { action };
-        if (action === "skip" && external.shareScope && sharedVersion?.remotes[0]?.entries) {
-          actions[external.packageName].override = resolveOverrideEntries(
-            entry,
-            external,
-            sharedVersion
-          );
+        if (action === "skip" && sharedVersion?.remotes[0]?.entries) {
+          actions[external.packageName].covered = Object.keys(sharedVersion.remotes[0].entries);
+          if (external.shareScope) {
+            actions[external.packageName].override = resolveOverrideEntries(
+              entry,
+              external,
+              sharedVersion
+            );
+          }
         }
       });
       return Promise.resolve({ entry: remoteEntry, actions });
@@ -2938,13 +3123,29 @@ function createUpdateCache(config, ports) {
       }
       config.log.warn(8, errorMsg);
     }
-    if (action === "skip" && config.strict.strictEntryPointCoverage && sharedVersion && Object.keys(remote.entries).some((e) => !(e in sharedVersion.remotes[0].entries))) {
-      action = "scope";
+    if (action === "skip" && sharedVersion) {
+      const uncovered = uncoveredEntrypoints(remote, sharedVersion.remotes[0].entries);
+      if (uncovered.length > 0) {
+        const msg = `[${sharedInfo.shareScope ?? GLOBAL_SCOPE}][${remoteEntry.name}][${sharedInfo.packageName}] Entrypoints not covered by the shared version: ${uncovered.join(", ")}.`;
+        if (config.strict.strictEntryPointCoverage) {
+          config.log.error(8, msg);
+          throw new NFError(`Could not process remote '${remoteEntry.name}'`);
+        }
+        if (config.profile.scopeUncoveredEntrypoints) {
+          config.log.debug(8, msg);
+          action = "scope";
+        }
+      }
     }
-    const matchingVersion = cached2.versions.find((cached3) => cached3.tag === tag);
-    if (matchingVersion) {
+    const matchingVersion = findVersionForTag(cached2.versions, tag);
+    if (action === "scope") {
+      remote.cached = true;
+      const scoped = cached2.versions.find((v) => v.tag === tag && v.action === "scope");
+      if (scoped) scoped.remotes.push(remote);
+      else cached2.versions.push({ tag, action, host: false, remotes: [remote] });
+    } else if (matchingVersion) {
       assertSameVersionCompatibility(matchingVersion);
-      matchingVersion.remotes.push(remote);
+      addRemoteToVersion(matchingVersion, remote);
     } else {
       if (!sharedVersion) action = "share";
       remote.cached = action !== "skip";
@@ -3047,22 +3248,24 @@ function createConvertToImportMap(config, ports) {
         return;
       }
       if (actions[external.packageName].action === "skip") {
-        const override = actions[external.packageName].override;
-        if (!external.shareScope) return;
+        const { override, covered } = actions[external.packageName];
+        if (!external.shareScope) {
+          if (covered) {
+            serveUncovered(remoteEntry, external, covered, remoteEntryScope, importMap);
+          }
+          return;
+        }
         if (override) {
           Object.entries(override).forEach(([packageName, url]) => {
             addToScopes(remoteEntryScope, packageName, url, importMap);
           });
-          Object.entries(external.entries).forEach(([packageName, fileName]) => {
-            if (packageName in override) return;
-            if (config.strict.strictEntryPointCoverage) {
-              warnUncoveredEntrypoint(remoteEntry.name, external.packageName, packageName);
-              return;
-            }
-            const url = join(remoteEntryScope, fileName);
-            addToScopes(remoteEntryScope, packageName, url, importMap);
-            addIntegrity(importMap, url, integrityMap, fileName);
-          });
+          serveUncovered(
+            remoteEntry,
+            external,
+            covered ?? Object.keys(override),
+            remoteEntryScope,
+            importMap
+          );
           return;
         }
         log.error(
@@ -3129,9 +3332,22 @@ function createConvertToImportMap(config, ports) {
     });
     return importMap;
   }
+  function serveUncovered(remoteEntry, external, covered, remoteEntryScope, importMap) {
+    const provided = new Set(covered);
+    Object.entries(external.entries).forEach(([packageName, fileName]) => {
+      if (provided.has(packageName)) return;
+      if (config.strict.strictEntryPointCoverage || config.profile.scopeUncoveredEntrypoints) {
+        warnUncoveredEntrypoint(remoteEntry.name, external.packageName, packageName);
+        return;
+      }
+      const url = join(remoteEntryScope, fileName);
+      addToScopes(remoteEntryScope, packageName, url, importMap);
+      addIntegrity(importMap, url, remoteEntry.integrity, fileName);
+    });
+  }
   function warnUncoveredEntrypoint(remoteName, externalName, packageName) {
     const msg = `[${remoteName}][${externalName}] Entrypoint '${packageName}' is not covered by the override.`;
-    if (config.strict.strictImportMap) {
+    if (config.strict.strictEntryPointCoverage || config.strict.strictImportMap) {
       log.error(9, msg);
       throw new NFError("Could not create ImportMap.");
     }