@softarc/native-federation-orchestrator 4.5.1 → 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
 };
@@ -1868,13 +1899,15 @@ var createModeConfig = (override) => {
     strictExternalCompatibility: override.strict,
     strictExternalSameVersionCompatibility: override.strict,
     strictExternalVersion: override.strict,
-    strictImportMap: override.strict
+    strictImportMap: override.strict,
+    strictEntryPointCoverage: override.strict
   } : {
     strictRemoteEntry: override.strict?.strictRemoteEntry ?? false,
     strictExternalCompatibility: override.strict?.strictExternalCompatibility ?? false,
     strictExternalSameVersionCompatibility: override.strict?.strictExternalSameVersionCompatibility ?? false,
     strictExternalVersion: override.strict?.strictExternalVersion ?? false,
-    strictImportMap: override.strict?.strictImportMap ?? false
+    strictImportMap: override.strict?.strictImportMap ?? false,
+    strictEntryPointCoverage: override.strict?.strictEntryPointCoverage ?? false
   };
   return {
     strict: strictnessConfig,
@@ -2020,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),
@@ -2132,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,
@@ -2148,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",
@@ -2171,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
           )
         );
@@ -2200,24 +2313,47 @@ function createDetermineSharedExternals(config, ports) {
     }
     return Promise.resolve();
   };
-  function setVersionActions(externalName, external) {
+  function uncoveredTears(external, winner, accepts) {
+    const basis = winner.remotes[0].entries;
+    return external.versions.reduce((sum, v) => {
+      if (v === winner) return sum;
+      if (!accepts(v, winner.tag)) return sum;
+      return sum + v.remotes.reduce((n, r) => n + countUncoveredEntrypoints(r, basis), 0);
+    }, 0);
+  }
+  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];
     }
     if (!sharedVersion) {
       let leastExtraDownloads = Number.MAX_VALUE;
+      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;
         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;
         }
       });
@@ -2226,23 +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";
+    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
@@ -2347,9 +2541,6 @@ function buildPools(sharedExternals, useAutoExternalPooling, log) {
 }
 
 // src/lib/core/2.app/steps/pooling/pool.util.ts
-function versionForRemote(member, remote) {
-  return member.external.versions.find((v) => v.remotes.some((r) => r.name === remote));
-}
 function remotesInPool(members) {
   return [
     ...new Set(members.flatMap((m) => m.external.versions.flatMap((v) => v.remotes.map((r) => r.name))))
@@ -2357,57 +2548,12 @@ function remotesInPool(members) {
 }
 
 // src/lib/core/2.app/steps/pooling/pool-shared-externals.ts
-function poolWinners(members) {
-  return members.map((member) => {
-    const share = member.external.versions.find((v) => v.action === "share");
-    return {
-      member,
-      tag: share?.tag ?? "",
-      providers: new Set((share?.remotes ?? []).map((r) => r.name))
-    };
-  });
-}
-function selectCoverageAnchor(winners) {
-  const coverage = /* @__PURE__ */ new Map();
-  for (const winner of winners)
-    for (const remote of winner.providers) coverage.set(remote, (coverage.get(remote) ?? 0) + 1);
-  if (coverage.size === 0) return void 0;
-  const anchorRemote = [...coverage.keys()].sort(
-    (a, b) => coverage.get(b) - coverage.get(a) || a.localeCompare(b)
-  )[0];
-  return {
-    anchorRemote,
-    tagPerMember: Object.fromEntries(
-      winners.filter((w) => w.providers.has(anchorRemote)).map((w) => [w.member.name, w.tag])
-    )
-  };
-}
-function classifyPoolConservative(members, anchor) {
-  const classification = /* @__PURE__ */ new Map();
-  for (const remote of remotesInPool(members)) {
-    let coverageForced = false;
-    let verdict = "follow";
-    for (const member of members) {
-      const version = versionForRemote(member, remote);
-      if (!version) continue;
-      const anchorTag = anchor.tagPerMember[member.name];
-      if (!anchorTag) {
-        coverageForced = true;
-        continue;
-      }
-      if (version.tag === anchorTag) continue;
-      if (version.action === "scope") {
-        verdict = "scope-incompat";
-        break;
-      }
-    }
-    classification.set(
-      remote,
-      verdict === "scope-incompat" ? "scope-incompat" : coverageForced ? "scope-coverage" : "follow"
-    );
-  }
-  classification.set(anchor.anchorRemote, "follow");
-  return classification;
+function islandedRemotes(members) {
+  const islanded = /* @__PURE__ */ new Set();
+  for (const member of members)
+    for (const version of member.external.versions)
+      if (version.action === "scope") for (const remote of version.remotes) islanded.add(remote.name);
+  return islanded;
 }
 function createPoolSharedExternals(config, ports) {
   return () => {
@@ -2443,73 +2589,57 @@ function createPoolSharedExternals(config, ports) {
     if (members.length < 2) return;
     const allRemotes = remotesInPool(members);
     if (allRemotes.length < 2) return;
-    const anchor = selectCoverageAnchor(poolWinners(members));
-    if (!anchor) return;
-    const classification = classifyPoolConservative(members, anchor);
+    const islanded = islandedRemotes(members);
     config.log.debug(
       3,
-      `[${scope}][pool:${poolName}] members=[${members.map((m) => m.name).join(", ")}], anchor=${anchor.anchorRemote}, remotes={${allRemotes.map((r) => `${r}:${classification.get(r)}`).join(", ")}}`
+      `[${scope}][pool:${poolName}] ${members.length} members across ${allRemotes.length} remotes, islanded={${[...islanded].join(", ") || "\u2205"}}
+` + members.map((m) => `  - ${m.name}`).join("\n")
     );
-    const incompatForced = allRemotes.some((r) => classification.get(r) === "scope-incompat");
-    if (incompatForced && config.strict.strictExternalCompatibility) {
+    if (islanded.size > 0 && config.strict.strictExternalCompatibility) {
       config.log.error(
         3,
-        `[${scope}][pool:${poolName}] A remote is version-incompatible with anchor '${anchor.anchorRemote}'.`
+        `[${scope}][pool:${poolName}] version-incompatible remotes cannot be pooled: {${[...islanded].join(", ")}}.`
       );
       throw new NFError(`Could not pool '${poolName}' in scope ${scope}.`);
     }
     for (const member of members) {
-      const rebuilt = rebuildMember(member, anchor, classification);
+      const rebuilt = rebuildMember(member, islanded);
       warnIfScopedOnly(poolName, member.name, rebuilt, scope);
       ports.sharedExternalsRepo.addOrUpdate(member.name, rebuilt, scope);
     }
   }
   function warnIfScopedOnly(poolName, memberName, rebuilt, scope) {
     if (rebuilt.versions.some((v) => v.action === "share")) return;
-    const copies = rebuilt.versions.reduce((n, v) => n + v.remotes.length, 0);
+    const consumers = new Set(rebuilt.versions.flatMap((v) => v.remotes.map((r) => r.name))).size;
+    if (consumers < 2) return;
     config.log.warn(
       3,
-      `[${scope}][pool:${poolName}] '${memberName}' is scoped-only \u2014 no coherent shared build provides it; ${copies} remotes download their own copy.`
+      `[${scope}][pool:${poolName}] '${memberName}' is scoped-only \u2014 no coherent shared build provides it; ${consumers} remotes download their own copy.`
     );
   }
-  function rebuildMember(member, anchor, classification) {
-    const anchorTag = anchor.tagPerMember[member.name];
+  function rebuildMember(member, islanded) {
     const entries = member.external.versions.flatMap(
-      (v) => v.remotes.map((meta) => ({ remote: meta.name, tag: v.tag, host: v.host, meta }))
-    );
-    if (!anchorTag) {
-      return {
-        dirty: false,
-        versions: entries.length > 0 ? [
-          {
-            tag: entries[0].tag,
-            host: false,
-            action: "scope",
-            remotes: entries.map((e) => e.meta)
-          }
-        ] : []
-      };
-    }
-    const anchorMeta = entries.find(
-      (e) => e.remote === anchor.anchorRemote && e.tag === anchorTag
-    ).meta;
-    const anchorHost = member.external.versions.find((v) => v.tag === anchorTag)?.host ?? false;
-    const scopes = (e) => {
-      const cls = classification.get(e.remote);
-      return cls === "scope-incompat" || cls === "scope-coverage" && e.tag !== anchorTag;
-    };
-    const shareOnAnchor = entries.filter(
-      (e) => e.remote !== anchor.anchorRemote && e.tag === anchorTag && !scopes(e)
+      (v) => v.remotes.map((meta) => ({ remote: meta.name, tag: v.tag, host: v.host, action: v.action, meta }))
     );
-    const shareVersion = {
-      tag: anchorTag,
-      host: anchorHost,
-      action: "share",
-      remotes: [anchorMeta, ...shareOnAnchor.map((e) => e.meta)]
-    };
+    const isScoped = (e) => islanded.has(e.remote) || e.action === "scope";
+    let scoped = entries.filter(isScoped);
+    let clean = entries.filter((e) => !isScoped(e));
+    if (!clean.some((e) => e.action === "share")) {
+      scoped = [...scoped, ...clean];
+      clean = [];
+    }
+    const shareEntries = clean.filter((e) => e.action === "share");
+    const shareVersion = shareEntries.length > 0 ? [
+      {
+        tag: shareEntries[0].tag,
+        host: shareEntries[0].host,
+        action: "share",
+        remotes: shareEntries.map((e) => e.meta)
+      }
+    ] : [];
     const skipByTag = /* @__PURE__ */ new Map();
-    for (const e of entries) {
-      if (e.tag === anchorTag || scopes(e)) continue;
+    for (const e of clean) {
+      if (e.action !== "skip") continue;
       const version = skipByTag.get(e.tag) ?? {
         tag: e.tag,
         host: e.host,
@@ -2519,16 +2649,25 @@ function createPoolSharedExternals(config, ports) {
       version.remotes.push(e.meta);
       skipByTag.set(e.tag, version);
     }
-    const scoped = entries.filter((e) => scopes(e));
-    const scopeVersion = scoped.length > 0 ? [{ tag: anchorTag, host: false, action: "scope", remotes: scoped.map((e) => e.meta) }] : [];
+    const scopeByTag = /* @__PURE__ */ new Map();
+    for (const e of scoped) {
+      const version = scopeByTag.get(e.tag) ?? {
+        tag: e.tag,
+        host: false,
+        action: "scope",
+        remotes: []
+      };
+      version.remotes.push(e.meta);
+      scopeByTag.set(e.tag, version);
+    }
     return {
       dirty: false,
-      versions: [shareVersion, ...skipByTag.values(), ...scopeVersion]
+      versions: [...shareVersion, ...skipByTag.values(), ...scopeByTag.values()]
     };
   }
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.3.1_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
+// node_modules/.pnpm/@softarc+native-federation@4.3.2_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
 var CHUNK_PREFIX = "@nf-internal";
 function toChunkImport(fileName) {
   if (fileName.startsWith("./")) {
@@ -2592,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) {
@@ -2635,14 +2775,30 @@ function createGenerateImportMap(config, ports) {
           for (const m of mappings) {
             addToScope(importMap, rScope, { [m.packageName]: m.url });
           }
+          for (const [packageName, file] of Object.entries(r.entries)) {
+            if (packageName in source.entries) continue;
+            if (config.strict.strictEntryPointCoverage || config.profile.scopeUncoveredEntrypoints) {
+              warnUncoveredEntrypoint(shareScope, externalName, r.name, packageName);
+              continue;
+            }
+            const url = join(rScope, file);
+            addToScope(importMap, rScope, { [packageName]: url });
+            addIntegrity(importMap, url, r.name, file);
+            r.cached = true;
+          }
         });
         for (const m of mappings) {
           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}`;
@@ -2674,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") {
@@ -2701,11 +2858,44 @@ 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;
+        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.strictEntryPointCoverage || config.strict.strictImportMap) {
+      config.log.error(4, msg);
+      throw new NFError("Could not create ImportMap.");
+    }
+    config.log.warn(4, msg);
+  }
   function notifyDuplicateGlobalExternal(externalName) {
     if (config.strict.strictImportMap) {
       config.log.error(4, `[${externalName}] Shared external has multiple shared versions.`);
@@ -2889,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 });
@@ -2928,10 +3123,29 @@ function createUpdateCache(config, ports) {
       }
       config.log.warn(8, errorMsg);
     }
-    const matchingVersion = cached2.versions.find((cached3) => cached3.tag === tag);
-    if (matchingVersion) {
+    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 = 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";
@@ -2992,8 +3206,6 @@ function createPoolDynamicExternals(config) {
         const memberActions = members.map((name) => actions[name].action);
         if (memberActions.includes("scope")) {
           members.forEach(scope);
-        } else if (memberActions.includes("share") && memberActions.includes("skip")) {
-          members.filter((name) => actions[name].action === "share").forEach(scope);
         }
       }
     }
@@ -3036,12 +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);
           });
+          serveUncovered(
+            remoteEntry,
+            external,
+            covered ?? Object.keys(override),
+            remoteEntryScope,
+            importMap
+          );
           return;
         }
         log.error(
@@ -3108,6 +3332,27 @@ 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.strictEntryPointCoverage || config.strict.strictImportMap) {
+      log.error(9, msg);
+      throw new NFError("Could not create ImportMap.");
+    }
+    log.warn(9, msg);
+  }
   function addIntegrity(importMap, url, integrityMap, file) {
     const hash = integrityMap?.[file];
     if (!hash) return;