@softarc/native-federation-orchestrator 4.5.2 → 4.6.0

package/fesm2022/@softarc/native-federation-orchestrator.mjs

@@ -1283,7 +1283,7 @@ var createInitFlow = ({
   adapters,
   config
 }) => {
-  return (remotesOrManifestUrl) => flow.getRemoteEntries(remotesOrManifestUrl).then(flow.processRemoteEntries).then(flow.determineSharedExternals).then(flow.poolSharedExternals).then(flow.generateImportMap).then((importMap) => flow.commitChanges(importMap, { override: true })).then(flow.exposeModuleLoader).then((loadRemoteModule) => ({
+  return (remotesOrManifestUrl) => flow.getRemoteEntries(remotesOrManifestUrl).then(flow.processRemoteEntries).then(flow.markPoolsForReelection).then(flow.determineSharedExternals).then(flow.poolSharedExternals).then(flow.generateImportMap).then((importMap) => flow.commitChanges(importMap, { override: true })).then(flow.exposeModuleLoader).then((loadRemoteModule) => ({
     config,
     adapters,
     loadRemoteModule
@@ -1426,19 +1426,92 @@ 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 versionEntries(version) {
+  return collectEntries(version, void 0);
+}
+function committedEntries(version) {
+  return collectEntries(version, (remote) => remote.cached);
+}
+function forEachVersionEntry(version, accepts, visit) {
+  for (const remote of version.remotes) {
+    if (remote.servedBy) continue;
+    if (accepts && !accepts(remote)) continue;
+    for (const entrypoint in remote.entries) visit(entrypoint, remote);
+  }
+}
+function collectEntries(version, accepts) {
+  const entries = /* @__PURE__ */ new Map();
+  forEachVersionEntry(version, accepts, (entrypoint, remote) => {
+    if (!entries.has(entrypoint)) entries.set(entrypoint, remote);
+  });
+  return entries;
+}
+function uncoveredEntrypoints(remote, covered) {
+  return Object.keys(remote.entries).filter((entrypoint) => !covered.has(entrypoint));
+}
+function countUncoveredEntrypoints(remote, covered) {
+  let uncovered = 0;
+  for (const entrypoint in remote.entries) {
+    if (!covered.has(entrypoint)) 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.sharedChunksRepo.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),
@@ -1454,7 +1527,6 @@ function createStoreRemoteEntry(config, ports, logStep) {
       const tag = resolveVersion(remoteEntry, external);
       if (tag === null) return;
       if (external.singleton) {
-        if (external.pool?.trim()) ports.sharedExternalsRepo.markPoolTagPresent();
         onSharedExternal(remoteEntry, external, sharedExternalContext(remoteEntry, external, tag));
       } else {
         addScopedExternal(remoteEntry, external, tag);
@@ -1538,14 +1610,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,
@@ -1554,15 +1647,12 @@ function createProcessRemoteEntries(config, ports) {
     assertSameVersionCompatibility,
     commit
   }) {
-    const matchingVersion = cached.versions.find((version) => version.tag === tag);
+    if (scopeType !== "strict") cached.dirty = true;
+    const matchingVersion = findVersionForTag(cached.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") cached.dirty = true;
       cached.versions.push({
         tag,
         action: scopeType === "strict" ? "share" : "skip",
@@ -1578,19 +1668,154 @@ function createProcessRemoteEntries(config, ports) {
 var GLOBAL_SCOPE = "__GLOBAL__";
 var STRICT_SCOPE = "strict";
 
+// src/lib/core/2.app/steps/apply-winner.ts
+function versionAcceptance(external, isCompatible) {
+  const demands = new Map(
+    external.versions.map((v) => [v, versionDemands(v)])
+  );
+  return {
+    accepts: (version, tag) => demands.get(version).every((d) => isCompatible(tag, d.requiredVersion)),
+    objector: (version, tag) => demands.get(version).find((d) => d.strictVersion && !isCompatible(tag, d.requiredVersion))
+  };
+}
+function createApplyWinner(config) {
+  return function applyWinner(externalName, external, winner, isCompatible, acceptance) {
+    if (external.versions.length > 1) {
+      const { accepts, objector } = acceptance ?? versionAcceptance(external, isCompatible);
+      const rebuilt = [];
+      for (const v of external.versions) {
+        rebuilt.push(v);
+        if (accepts(v, winner.tag)) {
+          v.action = "skip";
+          continue;
+        }
+        const strict = objector(v, winner.tag);
+        if (config.strict.strictExternalCompatibility && strict) {
+          config.log.error(
+            3,
+            `[${strict.name}][${externalName}@${v.tag}] Is not compatible with requiredRange '${strict.requiredVersion}' of shared ${externalName}@${winner.tag}.`
+          );
+          throw new NFError(`External ${externalName}@${v.tag} could not be shared.`);
+        }
+        if (v === winner) continue;
+        if (!strict) {
+          v.action = "skip";
+          continue;
+        }
+        const objecting = new Set(
+          v.remotes.filter((r) => r.strictVersion && !isCompatible(winner.tag, r.requiredVersion))
+        );
+        if (objecting.size === v.remotes.length) {
+          v.action = "scope";
+          continue;
+        }
+        v.remotes = v.remotes.filter((r) => !objecting.has(r));
+        v.action = "skip";
+        rebuilt.push({ tag: v.tag, host: false, action: "scope", remotes: [...objecting] });
+      }
+      const merged = /* @__PURE__ */ new Map();
+      external.versions = rebuilt.filter((v) => {
+        const first = merged.get(`${v.tag}|${v.action}`);
+        if (!first) {
+          merged.set(`${v.tag}|${v.action}`, v);
+          return true;
+        }
+        first.remotes.push(...v.remotes);
+        return false;
+      });
+    }
+    winner.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 = versionEntries(shared);
+    const tears = [];
+    for (const version of external.versions) {
+      if (version.action === "scope") continue;
+      if (version === shared) continue;
+      version.remotes.forEach((remote) => {
+        if (remote.servedBy) 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/determine-shared-externals.ts
 function createDetermineSharedExternals(config, ports) {
+  const applyWinner = createApplyWinner(config);
   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;
+    };
+    const touched = /* @__PURE__ */ new Map();
     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(
+        const elected = /* @__PURE__ */ new Set();
+        Object.entries(sharedExternals).filter(([_, e]) => e.dirty).forEach(([name, external]) => {
+          ports.sharedExternalsRepo.addOrUpdate(
             name,
-            setVersionActions(name, external),
+            setVersionActions(name, external, isCompatible),
             shareScope
-          )
-        );
+          );
+          elected.add(name);
+        });
+        if (elected.size > 0) touched.set(shareScope, elected);
       } catch (error) {
         config.log.error(
           3,
@@ -1608,22 +1833,25 @@ function createDetermineSharedExternals(config, ports) {
         );
       }
     }
-    return Promise.resolve();
+    return Promise.resolve(touched);
   };
-  function uncoveredTears(external, winner) {
-    const basis = winner.remotes[0].entries;
+  function uncoveredTears(external, winner, accepts) {
+    const basis = versionEntries(winner);
     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 v.remotes.reduce(
+        (n, r) => r.servedBy ? n : n + countUncoveredEntrypoints(r, basis),
+        sum
+      );
     }, 0);
   }
-  function setVersionActions(externalName, external) {
+  function setVersionActions(externalName, external, isCompatible) {
     if (external.versions.length === 1) {
-      external.versions[0].action = "share";
-      external.dirty = false;
-      return external;
+      return applyWinner(externalName, external, external.versions[0], isCompatible);
     }
+    const acceptance = versionAcceptance(external, isCompatible);
+    const { accepts } = acceptance;
     let sharedVersion = external.versions.find((v) => v.host);
     if (!sharedVersion && config.profile.latestSharedExternal) {
       sharedVersion = external.versions[0];
@@ -1631,13 +1859,39 @@ function createDetermineSharedExternals(config, ports) {
     if (!sharedVersion) {
       let leastExtraDownloads = Number.MAX_VALUE;
       let leastTears = Number.MAX_VALUE;
+      const selfServing = new Map(
+        external.versions.map((v) => {
+          const groups = /* @__PURE__ */ new Map();
+          for (const remote of v.remotes) {
+            if (remote.cached || !remote.strictVersion) continue;
+            const group = groups.get(remote.requiredVersion);
+            if (group) group.copies++;
+            else
+              groups.set(remote.requiredVersion, {
+                requiredVersion: remote.requiredVersion,
+                copies: 1
+              });
+          }
+          return [v, [...groups.values()]];
+        })
+      );
+      const costOf = (version, tag) => selfServing.get(version).reduce((n, g) => isCompatible(tag, g.requiredVersion) ? n : n + g.copies, 0);
       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)
-        ).length;
-        const tears = uncoveredTears(external, vA);
-        if (extraDownloads < leastExtraDownloads || extraDownloads === leastExtraDownloads && tears < leastTears) {
+        const extraDownloads = external.versions.reduce(
+          // A copy of the winner is never redirected, so it never self-serves however its own range
+          // reads — see `applyWinner`, which does not split the winner either.
+          (sum, vB) => vB === vA ? sum : sum + costOf(vB, vA.tag),
+          0
+        );
+        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;
         }
@@ -1646,40 +1900,302 @@ function createDetermineSharedExternals(config, ports) {
     if (!sharedVersion) {
       throw new NFError(`[${externalName}] Could not determine shared version!`);
     }
-    external.versions.forEach((v) => {
-      if (ports.versionCheck.isCompatible(sharedVersion.tag, v.remotes[0].requiredVersion)) {
-        v.action = "skip";
-        return;
+    return applyWinner(externalName, external, sharedVersion, isCompatible, acceptance);
+  }
+}
+
+// src/lib/core/2.app/steps/pooling/pool-views.ts
+function liveBuilds(members, islanded) {
+  return walkBuilds(members, islanded, true);
+}
+function committedView(members) {
+  const global = /* @__PURE__ */ new Map();
+  forEachGlobalClaim(members, void 0, (specifier, tag, meta) => {
+    if (!global.has(specifier))
+      global.set(specifier, { tag, remote: meta.name, file: meta.entries[specifier] });
+  });
+  return { builds: walkBuilds(members, void 0, false), global };
+}
+function walkBuilds(members, islanded, skipScoped) {
+  const builds = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    const versions = member.external.versions;
+    for (let v = 0; v < versions.length; v++) {
+      const version = versions[v];
+      if (skipScoped && version.action === "scope") continue;
+      const remotes = version.remotes;
+      for (let r = 0; r < remotes.length; r++) {
+        const meta = remotes[r];
+        if (islanded?.has(meta.name)) continue;
+        let own = builds.get(meta.name);
+        if (!own) {
+          builds.set(
+            meta.name,
+            own = { coverage: /* @__PURE__ */ new Map(), tags: /* @__PURE__ */ new Map(), instance: /* @__PURE__ */ new Map() }
+          );
+        }
+        if (!own.instance.has(member.name)) own.instance.set(member.name, version.tag);
+        for (const specifier in meta.entries) {
+          own.coverage.set(specifier, meta.entries[specifier]);
+          if (!own.tags.has(specifier)) own.tags.set(specifier, version.tag);
+        }
       }
-      if (config.strict.strictExternalCompatibility && v.remotes[0].strictVersion) {
-        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}'.`
-        );
-        throw new NFError(`External ${externalName}@${v.tag} could not be shared.`);
+    }
+  }
+  return builds;
+}
+function ownCopies(members, only) {
+  const own = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    for (const version of member.external.versions) {
+      for (const meta of version.remotes) {
+        if (only && !only.has(meta.name)) continue;
+        let copies = own.get(meta.name);
+        if (!copies) own.set(meta.name, copies = []);
+        if (!copies.some((c) => c.member === member.name))
+          copies.push({ member: member.name, tag: version.tag, entries: meta.entries });
       }
-      v.action = v.remotes[0].strictVersion ? "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}.`
-          );
+    }
+  }
+  return own;
+}
+function consumedMembers(members) {
+  const consumed = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    const versions = member.external.versions;
+    for (let v = 0; v < versions.length; v++) {
+      const remotes = versions[v].remotes;
+      for (let r = 0; r < remotes.length; r++) {
+        const name = remotes[r].name;
+        const list = consumed.get(name);
+        if (!list) consumed.set(name, [member.name]);
+        else if (list[list.length - 1] !== member.name) list.push(member.name);
+      }
+    }
+  }
+  return consumed;
+}
+function consumedSpecifiers(members) {
+  const consumed = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    const versions = member.external.versions;
+    for (let v = 0; v < versions.length; v++) {
+      const remotes = versions[v].remotes;
+      for (let r = 0; r < remotes.length; r++) {
+        const meta = remotes[r];
+        let own = consumed.get(meta.name);
+        if (!own) consumed.set(meta.name, own = /* @__PURE__ */ new Set());
+        for (const specifier in meta.entries) own.add(specifier);
+      }
+    }
+  }
+  return consumed;
+}
+function coversWholePool(members, build, islanded) {
+  const served = /* @__PURE__ */ new Set();
+  const wanted = /* @__PURE__ */ new Set();
+  for (const member of members) {
+    for (const version of member.external.versions) {
+      for (const meta of version.remotes) {
+        if (islanded.has(meta.name)) continue;
+        const into = meta.name === build ? served : wanted;
+        for (const specifier in meta.entries) into.add(specifier);
+      }
+    }
+  }
+  for (const specifier of wanted) if (!served.has(specifier)) return false;
+  return true;
+}
+function servingBuilds(members, islanded) {
+  const serving = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    const shared = member.external.versions.find((v) => v.action === "share");
+    const basis = shared?.remotes.find((r) => !islanded.has(r.name));
+    if (basis) serving.set(member.name, basis.name);
+  }
+  return serving;
+}
+function basisPerMember(members, islanded, dedupsElsewhere) {
+  const basis = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    const winner = member.external.versions.find((v) => v.action === "share");
+    if (!winner) continue;
+    const own = winner.remotes.find(
+      (r) => !islanded?.has(r.name) && !dedupsElsewhere?.(r.name)
+    );
+    if (own) basis.set(member.name, own.name);
+  }
+  return basis;
+}
+function hostRemotes(members) {
+  const hosts = /* @__PURE__ */ new Set();
+  for (const member of members) {
+    for (const version of member.external.versions) {
+      if (version.host && version.remotes.length > 0) hosts.add(version.remotes[0].name);
+    }
+  }
+  return hosts;
+}
+function arrivalOrder(members) {
+  const arrival = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    for (const version of member.external.versions) {
+      for (const meta of version.remotes) {
+        if (!arrival.has(meta.name)) arrival.set(meta.name, arrival.size);
+      }
+    }
+  }
+  return arrival;
+}
+function sharedTagPerSpecifier(members, islanded) {
+  const shared = /* @__PURE__ */ new Map();
+  forEachGlobalClaim(members, islanded, (specifier, tag) => {
+    if (!shared.has(specifier)) shared.set(specifier, tag);
+  });
+  return shared;
+}
+function forEachGlobalClaim(members, islanded, visit) {
+  const accepts = islanded ? (meta) => !islanded.has(meta.name) : void 0;
+  const claim = (version) => forEachVersionEntry(version, accepts, (specifier, meta) => visit(specifier, version.tag, meta));
+  for (const member of members) {
+    const versions = member.external.versions;
+    const winner = versions.find((v) => v.action === "share");
+    if (winner) claim(winner);
+    for (let v = 0; v < versions.length; v++) {
+      if (versions[v].action === "skip") claim(versions[v]);
+    }
+  }
+}
+
+// src/lib/core/2.app/steps/pooling/anchoring.ts
+function acceptanceTable(members, isCompatible) {
+  const table = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    const tags = [];
+    for (const version of member.external.versions) tags.push(version.tag);
+    for (const version of member.external.versions) {
+      for (const meta of version.remotes) {
+        let byMember = table.get(meta.name);
+        if (!byMember) table.set(meta.name, byMember = /* @__PURE__ */ new Map());
+        if (byMember.has(member.name)) continue;
+        const accepted = /* @__PURE__ */ new Set();
+        for (let t = 0; t < tags.length; t++) {
+          if (isCompatible(tags[t], meta.requiredVersion)) accepted.add(tags[t]);
         }
-      });
+        byMember.set(member.name, accepted);
+      }
     }
-    external.dirty = false;
-    return external;
   }
+  return table;
+}
+function covers(coverage2, consumed) {
+  for (const specifier of consumed) if (!coverage2.has(specifier)) return false;
+  return true;
+}
+function acceptsAll(acceptance, build, consumer, consumed) {
+  const byMember = acceptance.get(consumer);
+  if (!byMember) return false;
+  for (let i = 0; i < consumed.length; i++) {
+    const offered = build.get(consumed[i]);
+    if (offered === void 0) return false;
+    if (!byMember.get(consumed[i])?.has(offered)) return false;
+  }
+  return true;
+}
+function isWitnessed(specifiers, shared, builds) {
+  const wanted = [...specifiers];
+  for (const specifier of wanted) if (!shared.has(specifier)) return false;
+  for (const [, build] of builds) {
+    let matches = true;
+    for (let i = 0; i < wanted.length; i++) {
+      if (build.tags.get(wanted[i]) !== shared.get(wanted[i])) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) return true;
+  }
+  return false;
+}
+function explainSelfServe(remote, wants, specifiers, pool) {
+  let closest;
+  let fewest = Number.MAX_SAFE_INTEGER;
+  let gap = wants[0] ?? "";
+  for (const [build, view] of pool.builds) {
+    if (build === remote) continue;
+    let missing;
+    let count = 0;
+    for (const specifier of specifiers) {
+      if (view.coverage.has(specifier)) continue;
+      count++;
+      missing ??= specifier;
+    }
+    if (count >= fewest) continue;
+    fewest = count;
+    closest = build;
+    gap = missing ?? rejectedMember(view.instance, remote, wants, pool.acceptance) ?? gap;
+  }
+  return { gap, closest };
+}
+function rejectedMember(offered, consumer, wants, acceptance) {
+  const accepts = acceptance.get(consumer);
+  if (!accepts) return void 0;
+  for (const member of wants) {
+    const tag = offered.get(member);
+    if (tag === void 0) return member;
+    if (!accepts.get(member)?.has(tag)) return `${member}@${tag}`;
+  }
+  return void 0;
+}
+function assignAnchors(input) {
+  const { builds, acceptance, consumedMembers: consumedMembers2, hosts, arrival } = input;
+  const assignment = /* @__PURE__ */ new Map();
+  const byPriority = (a, b) => (arrival.get(a) ?? Number.MAX_SAFE_INTEGER) - (arrival.get(b) ?? Number.MAX_SAFE_INTEGER) || a.localeCompare(b);
+  const candidates = [...builds.keys()].sort(byPriority);
+  const pending = new Set([...consumedMembers2.keys()].sort(byPriority));
+  const anchored = /* @__PURE__ */ new Set();
+  const canServe = (candidate, consumer) => {
+    const build = builds.get(candidate);
+    if (!covers(build.coverage, input.consumedSpecifiers.get(consumer) ?? [])) return false;
+    return acceptsAll(acceptance, build.instance, consumer, consumedMembers2.get(consumer) ?? []);
+  };
+  const electAnchor = (anchor, served) => {
+    pending.delete(anchor);
+    assignment.set(anchor, void 0);
+    for (const consumer of served) {
+      pending.delete(consumer);
+      anchored.add(consumer);
+      assignment.set(consumer, anchor);
+    }
+  };
+  for (const host of [...hosts].sort(byPriority)) {
+    const served = [];
+    if (builds.has(host)) {
+      for (const consumer of pending) {
+        if (consumer !== host && canServe(host, consumer)) served.push(consumer);
+      }
+    }
+    electAnchor(host, served);
+  }
+  for (; ; ) {
+    let best;
+    let bestServed = [];
+    for (const candidate of candidates) {
+      if (anchored.has(candidate)) continue;
+      const served = [];
+      for (const consumer of pending) {
+        if (consumer !== candidate && canServe(candidate, consumer)) served.push(consumer);
+      }
+      if (served.length > bestServed.length) {
+        best = candidate;
+        bestServed = served;
+      }
+    }
+    if (best === void 0) break;
+    electAnchor(best, bestServed);
+  }
+  for (const consumer of pending) assignment.set(consumer, void 0);
+  return assignment;
 }
 
 // src/lib/core/2.app/steps/pooling/pool-graph.ts
@@ -1722,34 +2238,56 @@ function createDSU() {
 }
 var extNode = (name) => `ext\0${name}`;
 var tagNode = (remote, tag) => `tag\0${remote}\0${tag}`;
-var scopeNode = (scope) => `scope\0${scope}`;
+var scopeNode = (remote, scope) => `scope\0${remote}\0${scope}`;
 function autoScope(name, useAutoExternalPooling) {
   return useAutoExternalPooling ? SCOPED_PACKAGE.exec(name)?.[1] : void 0;
 }
+function owningPackage(name) {
+  const depth = name.startsWith("@") ? 2 : 1;
+  let cut = -1;
+  for (let seen = 0; seen < depth; seen++) {
+    cut = name.indexOf("/", cut + 1);
+    if (cut === -1) return void 0;
+  }
+  return name.slice(0, cut);
+}
 function groupByMembership(candidates, log) {
   const dsu = createDSU();
   const tagged = /* @__PURE__ */ new Set();
-  const poolable = [];
+  const joined = /* @__PURE__ */ new Set();
+  const tagRules = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (candidate.scope === void 0) continue;
+    for (const edge of candidate.tags) tagRules.add(`${edge.remote}\0${candidate.scope}`);
+  }
   for (const candidate of candidates) {
-    let joined = false;
-    if (candidate.scope !== void 0) {
-      dsu.union(extNode(candidate.name), scopeNode(candidate.scope));
-      joined = true;
-    }
     for (const edge of candidate.tags) {
       dsu.union(extNode(candidate.name), tagNode(edge.remote, edge.tag));
       tagged.add(candidate.name);
-      joined = true;
+      joined.add(candidate.name);
+    }
+    if (candidate.scope === void 0) continue;
+    for (const remote of candidate.remotes) {
+      if (tagRules.has(`${remote}\0${candidate.scope}`)) continue;
+      dsu.union(extNode(candidate.name), scopeNode(remote, candidate.scope));
+      joined.add(candidate.name);
     }
-    if (joined) poolable.push({ name: candidate.name, value: candidate.value });
+  }
+  const declared = new Set(candidates.map((c) => c.name));
+  for (const candidate of candidates) {
+    const owner = owningPackage(candidate.name);
+    if (owner !== void 0 && declared.has(owner))
+      dsu.union(extNode(candidate.name), extNode(owner));
   }
   const byComponent = /* @__PURE__ */ new Map();
-  for (const entry of poolable) {
-    const root = dsu.component(extNode(entry.name));
-    (byComponent.get(root) ?? byComponent.set(root, []).get(root)).push(entry);
+  for (const candidate of candidates) {
+    const root = dsu.component(extNode(candidate.name));
+    const members = byComponent.get(root) ?? byComponent.set(root, []).get(root);
+    members.push({ name: candidate.name, value: candidate.value });
   }
   const pools = [];
   for (const members of byComponent.values()) {
+    if (!members.some((m) => joined.has(m.name))) continue;
     members.sort((a, b) => a.name.localeCompare(b.name));
     if (members.length < 2) {
       const only = members[0];
@@ -1777,6 +2315,7 @@ function buildPools(sharedExternals, useAutoExternalPooling, log) {
           return tag ? [{ remote: r.name, tag }] : [];
         })
       ),
+      remotes: external.versions.flatMap((v) => v.remotes.map((r) => r.name)),
       value: { name, external }
     })
   );
@@ -1784,28 +2323,131 @@ function buildPools(sharedExternals, useAutoExternalPooling, log) {
 }
 
 // src/lib/core/2.app/steps/pooling/pool.util.ts
+function lazy(make) {
+  let value;
+  return () => value ??= make();
+}
 function remotesInPool(members) {
   return [
     ...new Set(members.flatMap((m) => m.external.versions.flatMap((v) => v.remotes.map((r) => r.name))))
   ];
 }
+function poolableScopes(config, repo) {
+  const { useAutoExternalPooling } = config.feature;
+  return {
+    useAutoExternalPooling,
+    scopes: repo.getScopes().filter(
+      (scope) => repo.scopeType(scope) !== "strict" && (useAutoExternalPooling || repo.hasPoolTag(scope))
+    )
+  };
+}
 
 // src/lib/core/2.app/steps/pooling/pool-shared-externals.ts
 function islandedRemotes(members) {
-  const islanded = /* @__PURE__ */ new Set();
+  const islanded = /* @__PURE__ */ new Map();
   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);
+      if (version.action === "scope") {
+        for (const remote of version.remotes)
+          if (!islanded.has(remote.name))
+            islanded.set(remote.name, {
+              kind: "incompatible",
+              member: member.name,
+              tag: version.tag
+            });
+      }
   return islanded;
 }
-function createPoolSharedExternals(config, ports) {
-  return () => {
-    const { useAutoExternalPooling } = config.feature;
-    if (!useAutoExternalPooling && !ports.sharedExternalsRepo.hasPoolTag()) {
-      return Promise.resolve();
+var basisFor = (members, islanded, serving) => basisPerMember(members, islanded, (remote) => {
+  const build = serving.get(remote);
+  return build !== void 0 && build !== remote;
+});
+function servedPerRemote(consumed, serving, basis) {
+  const served = /* @__PURE__ */ new Map();
+  for (const [remote, build] of serving) {
+    const byMember = /* @__PURE__ */ new Map();
+    for (const name of consumed.get(remote) ?? []) {
+      if (basis.get(name) !== build) byMember.set(name, build);
+    }
+    if (byMember.size > 0) served.set(remote, byMember);
+  }
+  return served;
+}
+var anyAnchorStored = (members) => members.some((m) => m.external.versions.some((v) => v.remotes.some((r) => r.servedBy !== void 0)));
+function findTornRemotes(members, islanded, basis, served, hosts) {
+  const { suspect, selfServed } = movedRemotes(members, islanded, basis, served, hosts);
+  if (suspect.size === 0) return [];
+  const builds = liveBuilds(members, islanded);
+  const shared = sharedTagPerSpecifier(members, islanded);
+  const own = ownCopies(members, suspect);
+  const torn = [];
+  for (const remote of suspect) {
+    const copies = own.get(remote) ?? [];
+    const mine = selfServed.get(remote);
+    const anchors = served.get(remote);
+    const ownTags = /* @__PURE__ */ new Map();
+    const resolved = /* @__PURE__ */ new Map();
+    for (const copy of copies) {
+      const from = mine?.has(copy.member) ? remote : anchors?.get(copy.member);
+      for (const specifier in copy.entries) {
+        if (!ownTags.has(specifier)) ownTags.set(specifier, copy.tag);
+        const tag = from === remote ? copy.tag : from !== void 0 ? builds.get(from)?.tags.get(specifier) : shared.get(specifier);
+        if (tag !== void 0 && !resolved.has(specifier)) resolved.set(specifier, tag);
+      }
+    }
+    if (resolved.size === 0) continue;
+    if (ships(ownTags, resolved)) continue;
+    let witnessed = false;
+    for (const [, build] of builds) {
+      if (ships(build.tags, resolved)) {
+        witnessed = true;
+        break;
+      }
     }
-    for (const scope of ports.sharedExternalsRepo.getScopes()) {
-      if (ports.sharedExternalsRepo.scopeType(scope) === "strict") continue;
+    if (!witnessed) {
+      torn.push({
+        remote,
+        combination: [...resolved].map(([specifier, tag]) => `${specifier}@${tag}`).join(", ")
+      });
+    }
+  }
+  return torn;
+}
+var ships = (build, resolved) => {
+  if (!build) return false;
+  for (const [specifier, tag] of resolved) if (build.get(specifier) !== tag) return false;
+  return true;
+};
+function movedRemotes(members, islanded, basis, served, hosts) {
+  const suspect = /* @__PURE__ */ new Set();
+  const selfServed = /* @__PURE__ */ new Map();
+  const add = (remote) => {
+    if (!islanded.has(remote) && !hosts.has(remote)) suspect.add(remote);
+  };
+  for (const remote of served.keys()) add(remote);
+  for (const member of members) {
+    const unpublished = !basis.has(member.name);
+    for (const version of member.external.versions) {
+      const scoped = version.action === "scope";
+      if (!unpublished && !scoped) continue;
+      for (const meta of version.remotes) {
+        add(meta.name);
+        const servesItself = scoped || unpublished && served.get(meta.name)?.get(member.name) === void 0;
+        if (!servesItself) continue;
+        let mine = selfServed.get(meta.name);
+        if (!mine) selfServed.set(meta.name, mine = /* @__PURE__ */ new Set());
+        mine.add(member.name);
+      }
+    }
+  }
+  return { suspect, selfServed };
+}
+function createPoolSharedExternals(config, ports) {
+  return (touched) => {
+    const { useAutoExternalPooling, scopes } = poolableScopes(config, ports.sharedExternalsRepo);
+    for (const scope of scopes) {
+      const touchedInScope = touched?.get(scope);
+      if (touched && !touchedInScope) continue;
       const sharedExternals = ports.sharedExternalsRepo.getFromScope(scope);
       try {
         for (const [poolName, members] of buildPools(
@@ -1813,6 +2455,7 @@ function createPoolSharedExternals(config, ports) {
           useAutoExternalPooling,
           config.log
         )) {
+          if (touchedInScope && !members.some((m) => touchedInScope.has(m.name))) continue;
           poolFamily(poolName, members, scope);
         }
       } catch (error) {
@@ -1833,45 +2476,138 @@ function createPoolSharedExternals(config, ports) {
     const allRemotes = remotesInPool(members);
     if (allRemotes.length < 2) return;
     const islanded = islandedRemotes(members);
+    const consumed = consumedMembers(members);
+    const hosts = hostRemotes(members);
+    const views = {
+      consumedSpecifiers: lazy(() => consumedSpecifiers(members)),
+      acceptance: lazy(() => acceptanceTable(members, ports.versionCheck.isCompatible)),
+      arrival: lazy(() => arrivalOrder(members))
+    };
     config.log.debug(
       3,
-      `[${scope}][pool:${poolName}] ${members.length} members across ${allRemotes.length} remotes, islanded={${[...islanded].join(", ") || "\u2205"}}
+      `[${scope}][pool:${poolName}] ${members.length} members across ${allRemotes.length} remotes, incompatible={${[...islanded.keys()].join(", ") || "\u2205"}}
 ` + members.map((m) => `  - ${m.name}`).join("\n")
     );
-    if (islanded.size > 0 && config.strict.strictExternalCompatibility) {
+    const assign = () => {
+      const serving2 = assignServingBuilds(members, islanded, consumed, hosts, views);
+      const basis2 = basisFor(members, islanded, serving2);
+      return { serving: serving2, basis: basis2, served: servedPerRemote(consumed, serving2, basis2) };
+    };
+    let { serving, basis, served } = assign();
+    if (islanded.size === 0 && serving.size === 0 && !anyAnchorStored(members)) return;
+    for (; ; ) {
+      const torn = findTornRemotes(members, islanded, basis, served, hosts);
+      if (torn.length === 0) break;
+      for (const { remote, combination } of torn)
+        islanded.set(remote, { kind: "torn", combination });
+      ({ serving, basis, served } = assign());
+    }
+    const incompatible = [...islanded].filter(([, cause]) => cause.kind === "incompatible").map(([remote]) => remote);
+    if (config.strict.strictExternalCompatibility && incompatible.length > 0) {
       config.log.error(
         3,
-        `[${scope}][pool:${poolName}] version-incompatible remotes cannot be pooled: {${[...islanded].join(", ")}}.`
+        `[${scope}][pool:${poolName}] version-incompatible remotes cannot be pooled: {${incompatible.join(", ")}}.`
       );
       throw new NFError(`Could not pool '${poolName}' in scope ${scope}.`);
     }
+    for (const [remote, cause] of islanded) {
+      const scoped = consumed.get(remote)?.length ?? 0;
+      config.log.warn(3, `[${scope}][pool:${poolName}] ${islandWarning(remote, cause, scoped)}`);
+    }
     for (const member of members) {
-      const rebuilt = rebuildMember(member, islanded);
-      warnIfScopedOnly(poolName, member.name, rebuilt, scope);
+      const rebuilt = rebuildMember(member, islanded, served, basis.get(member.name));
+      warnIfScopedOnly(poolName, member, rebuilt, islanded, scope);
       ports.sharedExternalsRepo.addOrUpdate(member.name, rebuilt, scope);
     }
   }
-  function warnIfScopedOnly(poolName, memberName, rebuilt, scope) {
+  function assignServingBuilds(members, islanded, consumed, hosts, views) {
+    for (; ; ) {
+      const bases = servingBuilds(members, islanded);
+      const distinct = new Set(bases.values());
+      if (distinct.size === 1 && bases.size === members.length) {
+        const sole = [...distinct][0];
+        if (coversWholePool(members, sole, islanded)) return /* @__PURE__ */ new Map();
+      }
+      const builds = liveBuilds(members, islanded);
+      const shared = sharedTagPerSpecifier(members, islanded);
+      const consumedSpec = views.consumedSpecifiers();
+      const needAnchor = /* @__PURE__ */ new Map();
+      const needSpecifiers = /* @__PURE__ */ new Map();
+      for (const [remote, wants] of consumed) {
+        if (islanded.has(remote)) continue;
+        if (isWitnessed(consumedSpec.get(remote) ?? [], shared, builds)) continue;
+        needAnchor.set(remote, wants);
+        needSpecifiers.set(remote, consumedSpec.get(remote) ?? /* @__PURE__ */ new Set());
+      }
+      if (needAnchor.size === 0) return /* @__PURE__ */ new Map();
+      const acceptance = views.acceptance();
+      const assignment = assignAnchors({
+        builds,
+        acceptance,
+        consumedSpecifiers: needSpecifiers,
+        consumedMembers: needAnchor,
+        hosts,
+        arrival: views.arrival()
+      });
+      const anchors = /* @__PURE__ */ new Set();
+      for (const build of assignment.values()) if (build !== void 0) anchors.add(build);
+      const serving = /* @__PURE__ */ new Map();
+      let scoped = false;
+      for (const [remote, wants] of needAnchor) {
+        const assigned = assignment.get(remote);
+        const build = assigned ?? (anchors.has(remote) || hosts.has(remote) ? remote : void 0);
+        if (build === void 0) {
+          islanded.set(remote, {
+            kind: "uncovered",
+            ...explainSelfServe(remote, wants, needSpecifiers.get(remote), { builds, acceptance })
+          });
+          scoped = true;
+          continue;
+        }
+        serving.set(remote, build);
+      }
+      if (!scoped) return serving;
+    }
+  }
+  function warnIfScopedOnly(poolName, member, rebuilt, islanded, scope) {
     if (rebuilt.versions.some((v) => v.action === "share")) return;
-    const consumers = new Set(rebuilt.versions.flatMap((v) => v.remotes.map((r) => r.name))).size;
+    const consumers = new Set(
+      rebuilt.versions.filter((v) => v.action === "scope").flatMap((v) => v.remotes.map((r) => r.name))
+    ).size;
     if (consumers < 2) return;
+    const provider = member.external.versions.find((v) => v.action === "share");
+    if (provider?.remotes.some((r) => islanded.has(r.name))) return;
     config.log.warn(
       3,
-      `[${scope}][pool:${poolName}] '${memberName}' is scoped-only \u2014 no coherent shared build provides it; ${consumers} remotes download their own copy.`
+      `[${scope}][pool:${poolName}] '${member.name}' is scoped-only \u2014 no coherent shared build provides it; ${consumers} remotes download their own copy.`
     );
   }
-  function rebuildMember(member, islanded) {
-    const entries = member.external.versions.flatMap(
-      (v) => v.remotes.map((meta) => ({ remote: meta.name, tag: v.tag, host: v.host, action: v.action, 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");
+  function rebuildMember(member, islanded, served, basis) {
+    let scoped = [];
+    let clean = [];
+    for (const version of member.external.versions) {
+      for (const meta of version.remotes) {
+        const entry = {
+          remote: meta.name,
+          tag: version.tag,
+          host: version.host,
+          action: version.action,
+          meta
+        };
+        (islanded.has(entry.remote) || entry.action === "scope" ? scoped : clean).push(entry);
+      }
+    }
+    for (const entry of scoped) delete entry.meta.servedBy;
+    for (const entry of clean) {
+      const build = served.get(entry.remote)?.get(member.name);
+      if (build !== void 0) entry.meta.servedBy = build;
+      else delete entry.meta.servedBy;
+    }
+    if (basis === void 0) {
+      scoped = [...scoped, ...clean.filter((e) => e.meta.servedBy === void 0)];
+      clean = clean.filter((e) => e.meta.servedBy !== void 0).map((e) => ({ ...e, action: "skip" }));
+    }
+    const shareEntries = clean.filter((e) => e.action === "share").sort((a, b) => Number(b.remote === basis) - Number(a.remote === basis));
     const shareVersion = shareEntries.length > 0 ? [
       {
         tag: shareEntries[0].tag,
@@ -1880,37 +2616,70 @@ function createPoolSharedExternals(config, ports) {
         remotes: shareEntries.map((e) => e.meta)
       }
     ] : [];
-    const skipByTag = /* @__PURE__ */ new Map();
-    for (const e of clean) {
-      if (e.action !== "skip") continue;
-      const version = skipByTag.get(e.tag) ?? {
-        tag: e.tag,
-        host: e.host,
-        action: "skip",
-        remotes: []
-      };
-      version.remotes.push(e.meta);
-      skipByTag.set(e.tag, version);
-    }
-    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);
-    }
+    const byTag = (entries, action) => {
+      const versions = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        const version = versions.get(entry.tag) ?? {
+          tag: entry.tag,
+          host: entry.host,
+          action,
+          remotes: []
+        };
+        version.remotes.push(entry.meta);
+        versions.set(entry.tag, version);
+      }
+      return [...versions.values()];
+    };
     return {
       dirty: false,
-      versions: [...shareVersion, ...skipByTag.values(), ...scopeByTag.values()]
+      versions: [
+        ...shareVersion,
+        ...byTag(
+          clean.filter((e) => e.action === "skip"),
+          "skip"
+        ),
+        ...byTag(scoped, "scope")
+      ].sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
     };
   }
 }
+function islandWarning(remote, cause, scoped) {
+  switch (cause.kind) {
+    case "incompatible":
+      return `'${remote}' is islanded: the resolver scoped its '${cause.member}@${cause.tag}', so all ${scoped} members it imports are scoped for it.`;
+    case "torn":
+      return `'${remote}' serves its own family: the mapping would have handed it ${cause.combination}, which no build shipped together, so all ${scoped} members it imports are scoped for it.`;
+    default: {
+      const closest = cause.closest ? `closest is '${cause.closest}'` : "no other build in the pool serves any of it";
+      return `'${remote}' serves its own family: no shared build offers every entrypoint it imports at a version it accepts \u2014 '${cause.gap}' is the gap, ${closest}. All ${scoped} members it imports are scoped for it.`;
+    }
+  }
+}
 
-// node_modules/.pnpm/@softarc+native-federation@4.3.2_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/build-notification-options.contract.js
+// src/lib/core/2.app/steps/pooling/mark-pools-for-reelection.ts
+function createMarkPoolsForReelection(config, ports) {
+  return () => {
+    const { useAutoExternalPooling, scopes } = poolableScopes(config, ports.sharedExternalsRepo);
+    for (const scope of scopes) {
+      const sharedExternals = ports.sharedExternalsRepo.getFromScope(scope);
+      if (!Object.values(sharedExternals).some((external) => external.dirty)) continue;
+      let spread = 0;
+      for (const [, members] of buildPools(sharedExternals, useAutoExternalPooling)) {
+        if (!members.some((m) => m.external.dirty)) continue;
+        for (const member of members)
+          if (!member.external.dirty) {
+            member.external.dirty = true;
+            spread++;
+          }
+      }
+      if (spread > 0)
+        config.log.debug(3, `[${scope}] ${spread} pool member(s) marked dirty for re-election.`);
+    }
+    return Promise.resolve();
+  };
+}
+
+// node_modules/.pnpm/@softarc+native-federation@4.4.0_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/build-notification-options.contract.js
 var BuildNotificationType = /* @__PURE__ */ ((BuildNotificationType2) => {
   BuildNotificationType2["COMPLETED"] = "federation-rebuild-complete";
   BuildNotificationType2["ERROR"] = "federation-rebuild-error";
@@ -1918,7 +2687,7 @@ var BuildNotificationType = /* @__PURE__ */ ((BuildNotificationType2) => {
   return BuildNotificationType2;
 })(BuildNotificationType || {});
 
-// node_modules/.pnpm/@softarc+native-federation@4.3.2_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
+// node_modules/.pnpm/@softarc+native-federation@4.4.0_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("./")) {
@@ -1979,9 +2748,10 @@ function createGenerateImportMap(config, ports) {
   }
   function processshareScope(importMap, shareScope, chunkBundles) {
     const sharedExternals = ports.sharedExternalsRepo.getFromScope(shareScope);
+    const index = buildServedIndex(sharedExternals);
     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) {
@@ -1997,37 +2767,53 @@ function createGenerateImportMap(config, ports) {
           continue;
         }
         version.remotes[0].cached = true;
-        let source = version.remotes[0];
-        let sourceScope = getScope2(shareScope, source.name, externalName);
-        if (version.action === "share") {
-          registerBundleChunks(chunkBundles, source.name, source.bundle);
-        } else if (version.action === "skip") {
+        let serving = version;
+        if (version.action === "skip") {
           if (!override) {
             override = findOverride(external, shareScope, externalName) ?? "NOT_AVAILABLE";
           }
           if (override !== "NOT_AVAILABLE") {
-            if (!overrideScope)
-              overrideScope = getScope2(shareScope, override.remotes[0].name, externalName);
-            source = override.remotes[0];
-            sourceScope = overrideScope;
-            override.remotes[0].cached = true;
+            serving = override;
             version.remotes[0].cached = false;
           }
         }
-        const mappings = Object.entries(source.entries).map(([packageName, file]) => ({
-          packageName,
-          url: join(sourceScope, file),
-          name: source.name,
-          file
-        }));
+        const provided = versionEntries(serving);
+        const mappings = [];
+        for (const [packageName, provider] of provided) {
+          const file = provider.entries[packageName];
+          mappings.push({
+            packageName,
+            url: join(getScope2(shareScope, provider.name, externalName), file),
+            name: provider.name,
+            file
+          });
+          provider.cached = true;
+          if (version.action === "share") {
+            registerBundleChunks(chunkBundles, provider.name, provider.bundle);
+          }
+        }
         version.remotes.forEach((r) => {
           const rScope = getScope2(shareScope, r.name, externalName);
+          if (index && r.servedBy) {
+            const files = index.get(r.servedBy);
+            const servedScope = getScope2(shareScope, r.servedBy, externalName);
+            for (const specifier of Object.keys(r.entries)) {
+              const source = files?.get(specifier);
+              if (!source) continue;
+              const url = join(servedScope, source.file);
+              addToScope(importMap, rScope, { [specifier]: url });
+              addIntegrity(importMap, url, r.servedBy, source.file);
+              registerBundleChunks(chunkBundles, r.servedBy, source.bundle);
+              source.meta.cached = true;
+            }
+            return;
+          }
           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) {
+            if (provided.has(packageName)) continue;
+            if (config.strict.strictEntryPointCoverage || config.profile.scopeUncoveredEntrypoints) {
               warnUncoveredEntrypoint(shareScope, externalName, r.name, packageName);
               continue;
             }
@@ -2041,9 +2827,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}`;
@@ -2072,10 +2863,68 @@ function createGenerateImportMap(config, ports) {
     }
     config.log.warn(4, `ShareScope external ${scopedExternalName} has multiple shared versions.`);
   }
+  function buildServedIndex(externals) {
+    let anyServed = false;
+    for (const external of Object.values(externals)) {
+      for (const version of external.versions) {
+        if (version.remotes.some((r) => r.servedBy)) anyServed = true;
+      }
+    }
+    if (!anyServed) return void 0;
+    const index = /* @__PURE__ */ new Map();
+    for (const external of Object.values(externals)) {
+      for (const version of external.versions) {
+        for (const remote of version.remotes) {
+          let own = index.get(remote.name);
+          if (!own) index.set(remote.name, own = /* @__PURE__ */ new Map());
+          for (const [specifier, file] of Object.entries(remote.entries)) {
+            if (!own.has(specifier))
+              own.set(specifier, { file, bundle: remote.bundle, meta: remote });
+          }
+        }
+      }
+    }
+    return index;
+  }
+  function collectServed(into, index, ctx, externalName, version) {
+    for (const consumer of version.remotes) {
+      if (!consumer.servedBy) continue;
+      const files = index.get(consumer.servedBy);
+      const scope = getScope2(ctx, consumer.name, externalName);
+      for (const specifier of Object.keys(consumer.entries)) {
+        const source = files?.get(specifier);
+        if (!source) {
+          config.log.warn(
+            4,
+            `[${ctx}][${externalName}][${consumer.name}] '${consumer.servedBy}' does not serve '${specifier}'.`
+          );
+          continue;
+        }
+        into.push({ scope, specifier, source, from: consumer.servedBy });
+      }
+    }
+  }
+  function flushServed(importMap, chunkBundles, served) {
+    for (const { scope, specifier, source, from } of served) {
+      const url = join(getScope2(GLOBAL_SCOPE, from), source.file);
+      if (importMap.imports[specifier] === url) continue;
+      addToScope(importMap, scope, { [specifier]: url });
+      addIntegrity(importMap, url, from, source.file);
+      registerBundleChunks(chunkBundles, from, source.bundle);
+      source.meta.cached = true;
+    }
+  }
   function addGlobalSharedExternals(importMap, chunkBundles) {
     const sharedExternals = ports.sharedExternalsRepo.getFromScope();
+    const index = buildServedIndex(sharedExternals);
+    const served = [];
+    const cachedBefore = /* @__PURE__ */ new Map();
     for (const [externalName, external] of Object.entries(sharedExternals)) {
+      cachedBefore.set(externalName, cachedFingerprint(external));
       for (const version of external.versions) {
+        if (index && version.action !== "scope") {
+          collectServed(served, index, GLOBAL_SCOPE, externalName, version);
+        }
         if (version.action === "skip") continue;
         if (version.action === "scope") {
           for (const remote of version.remotes) {
@@ -2094,39 +2943,64 @@ function createGenerateImportMap(config, ports) {
           notifyDuplicateGlobalExternal(externalName);
           continue;
         }
-        const scope = getScope2(GLOBAL_SCOPE, version.remotes[0].name, externalName);
-        for (const [packageName, file] of Object.entries(version.remotes[0].entries)) {
-          const url = join(scope, file);
-          addToGlobal(importMap, { [packageName]: url });
-          addIntegrity(importMap, url, version.remotes[0].name, file);
-        }
-        registerBundleChunks(chunkBundles, version.remotes[0].name, version.remotes[0].bundle);
-        version.remotes[0].cached = true;
+        mergeVersionEntries(importMap, chunkBundles, externalName, version);
       }
       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);
+      }
+    }
+    flushServed(importMap, chunkBundles, served);
+    for (const [externalName, external] of Object.entries(sharedExternals)) {
+      if (cachedFingerprint(external) !== cachedBefore.get(externalName)) {
+        ports.sharedExternalsRepo.addOrUpdate(externalName, external);
       }
-      ports.sharedExternalsRepo.addOrUpdate(externalName, external);
     }
     return importMap;
   }
+  function mergeVersionEntries(importMap, chunkBundles, externalName, version) {
+    const scopes = /* @__PURE__ */ new Map();
+    for (const [packageName, remote] of versionEntries(version)) {
+      if (importMap.imports[packageName]) {
+        config.log.debug(
+          4,
+          `[${GLOBAL_SCOPE}][${externalName}][${remote.name}] Entrypoint '${packageName}' is already mapped by another external, keeping '${importMap.imports[packageName]}'.`
+        );
+        continue;
+      }
+      let scope = scopes.get(remote.name);
+      if (scope === void 0) {
+        scopes.set(remote.name, scope = getScope2(GLOBAL_SCOPE, remote.name, externalName));
+        registerBundleChunks(chunkBundles, remote.name, remote.bundle);
+        remote.cached = true;
+      }
+      const file = remote.entries[packageName];
+      const url = join(scope, file);
+      addToGlobal(importMap, { [packageName]: url });
+      addIntegrity(importMap, url, remote.name, file);
+    }
+  }
+  function selfFillUncovered(importMap, chunkBundles, externalName, remotes) {
+    for (const remote of remotes) {
+      if (remote.servedBy) continue;
+      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.");
     }
@@ -2354,18 +3228,24 @@ 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);
+        const { action, provided, sameVersion } = 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" && provided) {
+          actions[external.packageName].covered = Array.from(provided.keys());
+          if (sameVersion) actions[external.packageName].sameVersion = true;
+          if (external.shareScope) {
+            actions[external.packageName].override = resolveOverrideEntries(
+              entry,
+              external,
+              provided
+            );
+          }
         }
       });
       return Promise.resolve({ entry: remoteEntry, actions });
@@ -2393,78 +3273,188 @@ 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";
+    const provided = sharedVersion ? sharedInfo.shareScope ? versionEntries(sharedVersion) : committedEntries(sharedVersion) : void 0;
+    const sameVersion = sharedVersion?.tag === tag;
+    if (action === "skip" && provided && !sameVersion) {
+      const uncovered = uncoveredEntrypoints(remote, provided);
+      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 = cached.versions.find((cached2) => cached2.tag === tag);
-    if (matchingVersion) {
+    const matchingVersion = findVersionForTag(cached.versions, tag);
+    if (action === "scope") {
+      remote.cached = true;
+      const scoped = cached.versions.find((v) => v.tag === tag && v.action === "scope");
+      if (scoped) scoped.remotes.push(remote);
+      else cached.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";
       cached.versions.push({ tag, action, host: false, remotes: [remote] });
     }
     commit();
-    return { action, sharedVersion };
-  }
-  function resolveOverrideEntries(remoteEntry, external, sharedVersion) {
-    return ports.remoteInfoRepo.tryGet(sharedVersion.remotes[0].name).map(
-      (remote) => Object.fromEntries(
-        Object.entries(sharedVersion.remotes[0].entries).map(([packageName, file]) => [
-          packageName,
-          join(remote.scopeUrl, file)
-        ])
-      )
-    ).orThrow(() => {
+    return { action, provided, sameVersion };
+  }
+  function resolveOverrideEntries(remoteEntry, external, provided) {
+    return Object.fromEntries(
+      Array.from(provided, ([packageName, provider]) => [
+        packageName,
+        join(
+          providerScopeUrl(remoteEntry, external, provider.name),
+          provider.entries[packageName]
+        )
+      ])
+    );
+  }
+  function providerScopeUrl(remoteEntry, external, providerName) {
+    return ports.remoteInfoRepo.tryGet(providerName).map((remote) => remote.scopeUrl).orThrow(() => {
       config.log.error(
         8,
         `[${external.shareScope ?? GLOBAL_SCOPE}][${remoteEntry.name}][${external.packageName}@${external.version}][override] Remote name not found in cache.`
       );
-      return new NFError(
-        `Could not find override url from remote ${sharedVersion.remotes[0].name}`
-      );
+      return new NFError(`Could not find override url from remote ${providerName}`);
     });
   }
 }
 
 // src/lib/core/2.app/steps/pooling/pool-dynamic-externals.ts
-function createPoolDynamicExternals(config) {
+function createPoolDynamicExternals(config, ports) {
   return ({ entry, actions }) => {
     const { useAutoExternalPooling } = config.feature;
-    if (!useAutoExternalPooling && !(entry.shared ?? []).some((e) => e.pool?.trim())) {
-      return Promise.resolve({ entry, actions });
-    }
-    const byScope = /* @__PURE__ */ new Map();
+    const declared = /* @__PURE__ */ new Map();
     for (const external of entry.shared ?? []) {
       const name = external.packageName;
       if (!external.singleton || !actions[name]) continue;
       if (external.shareScope === STRICT_SCOPE) continue;
-      const tag = external.pool?.trim();
       const shareScope = external.shareScope ?? GLOBAL_SCOPE;
-      const candidates = byScope.get(shareScope) ?? [];
-      candidates.push({
-        name,
-        scope: autoScope(name, useAutoExternalPooling),
-        tags: tag ? [{ remote: entry.name, tag }] : [],
-        value: name
-      });
-      byScope.set(shareScope, candidates);
+      let names = declared.get(shareScope);
+      if (!names) declared.set(shareScope, names = /* @__PURE__ */ new Set());
+      names.add(name);
     }
+    if (declared.size === 0) return Promise.resolve({ entry, actions });
     const scope = (name) => {
       actions[name].action = "scope";
       delete actions[name].override;
     };
-    for (const candidates of byScope.values()) {
-      for (const members of groupByMembership(candidates).values()) {
-        const memberActions = members.map((name) => actions[name].action);
-        if (memberActions.includes("scope")) {
-          members.forEach(scope);
+    for (const [shareScope, names] of declared) {
+      if (!useAutoExternalPooling && !ports.sharedExternalsRepo.hasPoolTag(shareScope)) continue;
+      const committed = ports.sharedExternalsRepo.getFromScope(shareScope);
+      for (const pool of buildPools(committed, useAutoExternalPooling).values()) {
+        const mine = pool.filter((member) => names.has(member.name));
+        if (mine.length === 0) continue;
+        if (mine.some((member) => actions[member.name].action === "scope")) {
+          mine.forEach((member) => scope(member.name));
+          continue;
         }
+        const asked = gateViews(entry.name, pool);
+        const anchor = anchorFor(entry.name, asked);
+        if (anchor === "witnessed") continue;
+        if (anchor === void 0) {
+          const reason = explainDynamic(entry.name, asked);
+          const closest = reason.closest ? `closest is '${reason.closest}'` : "no committed build serves any of it";
+          config.log.warn(
+            8,
+            `[${shareScope}] '${entry.name}' serves its own family: no committed build offers every entrypoint it imports at a version it accepts \u2014 '${reason.gap}' is the gap, ${closest}. All ${mine.length} members it imports are scoped for it.`
+          );
+          mine.forEach((member) => scope(member.name));
+          continue;
+        }
+        redirect(entry.name, anchor, pool, asked.view, actions, shareScope);
       }
     }
     return Promise.resolve({ entry, actions });
   };
+  function gateViews(remote, pool) {
+    return {
+      pool,
+      view: committedView(pool),
+      wants: consumedMembers(pool).get(remote) ?? [],
+      specifiers: consumedSpecifiers(pool).get(remote) ?? /* @__PURE__ */ new Set(),
+      acceptance: lazy(() => acceptanceTable(pool, ports.versionCheck.isCompatible))
+    };
+  }
+  function anchorFor(remote, { pool, view, wants, specifiers, acceptance }) {
+    const shared = /* @__PURE__ */ new Map();
+    for (const [specifier, source] of view.global) shared.set(specifier, source.tag);
+    if (isWitnessed(specifiers, shared, view.builds)) return "witnessed";
+    const basis = basisPerMember(pool);
+    for (const build of candidateOrder(pool, view)) {
+      if (build === remote) continue;
+      const candidate = view.builds.get(build);
+      if (!servesItsOwnFamily(build, pool, basis)) continue;
+      if (!covers(candidate.coverage, specifiers)) continue;
+      if (!acceptsAll(acceptance(), candidate.instance, remote, wants)) continue;
+      return build;
+    }
+    return void 0;
+  }
+  function candidateOrder(pool, view) {
+    const serving = /* @__PURE__ */ new Set();
+    for (const source of view.global.values()) serving.add(source.remote);
+    const hosts = hostRemotes(pool);
+    const rank = (build) => serving.has(build) ? 0 : hosts.has(build) ? 1 : 2;
+    return [...view.builds.keys()].sort((a, b) => rank(a) - rank(b) || a.localeCompare(b));
+  }
+  function servesItsOwnFamily(build, pool, basis) {
+    let ships2 = 0;
+    let winsAll = true;
+    let allScoped = true;
+    for (const member of pool) {
+      for (const version of member.external.versions) {
+        const meta = version.remotes.find((r) => r.name === build);
+        if (!meta) continue;
+        if (meta.servedBy !== void 0) return false;
+        ships2++;
+        if (version.action !== "scope") allScoped = false;
+        if (basis.get(member.name) !== build) winsAll = false;
+      }
+    }
+    return ships2 > 0 && (winsAll || allScoped);
+  }
+  function explainDynamic(remote, { view, wants, specifiers, acceptance }) {
+    return explainSelfServe(remote, wants, specifiers, {
+      builds: view.builds,
+      acceptance: acceptance()
+    });
+  }
+  function redirect(remote, anchor, pool, view, actions, shareScope) {
+    const files = view.builds.get(anchor).coverage;
+    const scopeUrl = ports.remoteInfoRepo.tryGet(anchor).get()?.scopeUrl;
+    if (!scopeUrl) {
+      config.log.warn(
+        8,
+        `[${shareScope}][${remote}] '${anchor}' is not in the cache, so its files cannot be mapped.`
+      );
+      return;
+    }
+    for (const member of pool) {
+      const action = actions[member.name];
+      if (!action || action.action !== "skip") continue;
+      const own = member.external.versions.flatMap((v) => v.remotes).find((r) => r.name === remote);
+      if (!own) continue;
+      const specifiers = Object.keys(own.entries);
+      if (specifiers.length === 0) continue;
+      const override = {};
+      for (const specifier of specifiers) {
+        if (view.global.get(specifier)?.remote === anchor) continue;
+        const file = files.get(specifier);
+        if (file) override[specifier] = join(scopeUrl, file);
+      }
+      action.covered = specifiers;
+      if (Object.keys(override).length > 0) action.override = override;
+    }
+  }
 }
 
 // src/lib/core/2.app/steps/convert-to-import-map.ts
@@ -2502,22 +3492,25 @@ function createConvertToImportMap(config, ports) {
         return;
       }
       if (actions[external.packageName].action === "skip") {
-        const override = actions[external.packageName].override;
-        if (!external.shareScope) return;
+        const { override, covered, sameVersion } = actions[external.packageName];
         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,
+            sameVersion
+          );
+          return;
+        }
+        if (!external.shareScope) {
+          if (covered) {
+            serveUncovered(remoteEntry, external, covered, remoteEntryScope, importMap, sameVersion);
+          }
           return;
         }
         log.error(
@@ -2584,9 +3577,22 @@ function createConvertToImportMap(config, ports) {
     });
     return importMap;
   }
+  function serveUncovered(remoteEntry, external, covered, remoteEntryScope, importMap, sameVersion = false) {
+    const provided = new Set(covered);
+    Object.entries(external.entries).forEach(([packageName, fileName]) => {
+      if (provided.has(packageName)) return;
+      if (!sameVersion && (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.");
     }
@@ -2607,6 +3613,7 @@ var createInitDrivers = ({
 }) => ({
   getRemoteEntries: createGetRemoteEntries(config, adapters),
   processRemoteEntries: createProcessRemoteEntries(config, adapters),
+  markPoolsForReelection: createMarkPoolsForReelection(config, adapters),
   determineSharedExternals: createDetermineSharedExternals(config, adapters),
   poolSharedExternals: createPoolSharedExternals(config, adapters),
   generateImportMap: createGenerateImportMap(config, adapters),
@@ -2614,7 +3621,7 @@ var createInitDrivers = ({
   exposeModuleLoader: createExposeModuleLoader(config, adapters),
   getRemoteEntry: createGetRemoteEntry(config, adapters),
   updateCache: createUpdateCache(config, adapters),
-  poolDynamicExternals: createPoolDynamicExternals(config),
+  poolDynamicExternals: createPoolDynamicExternals(config, adapters),
   convertToImportMap: createConvertToImportMap(config, adapters)
 });
 var INIT_FLOW_FACTORY = ({
@@ -2725,7 +3732,7 @@ var createManifestProvider = () => {
   };
 };
 
-// node_modules/.pnpm/@softarc+native-federation@4.3.2_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/utils/normalize.js
+// node_modules/.pnpm/@softarc+native-federation@4.4.0_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/utils/normalize.js
 function inferPackageFromSecondary(secondary) {
   const parts = secondary.split("/");
   if (secondary.startsWith("@") && parts.length >= 2) {
@@ -2734,7 +3741,7 @@ function inferPackageFromSecondary(secondary) {
   return parts[0];
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.3.2_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/core/output/densify-externals.js
+// node_modules/.pnpm/@softarc+native-federation@4.4.0_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/core/output/densify-externals.js
 function isDense(entry) {
   return "entries" in entry;
 }
@@ -2835,16 +3842,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) {
@@ -2859,7 +3871,9 @@ var createRemoteInfoRepository = (config) => {
       return _cache;
     },
     commit: function() {
+      if (!_dirty) return this;
       STORAGE.set(_cache);
+      _dirty = false;
       return this;
     }
   };
@@ -2870,14 +3884,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() {
@@ -2887,7 +3906,9 @@ var createScopedExternalsRepository = (config) => {
       return Optional.of(_cache[remoteName]);
     },
     commit: function() {
+      if (!_dirty) return this;
       STORAGE.set(_cache);
+      _dirty = false;
       return this;
     }
   };
@@ -2900,14 +3921,19 @@ var createSharedExternalsRepository = (config) => {
     { [GLOBAL_SCOPE]: {} }
   );
   if (config.clearStorage) STORAGE.clear();
-  const _cache = STORAGE.get();
-  let _sawPoolTag = false;
+  const _cache = STORAGE.get() ?? { [GLOBAL_SCOPE]: {} };
+  let _dirty = false;
   return {
-    markPoolTagPresent: function() {
-      _sawPoolTag = true;
-    },
-    hasPoolTag: function() {
-      return _sawPoolTag;
+    // Read from the cache rather than remembered from this init's entries: a warm init may not refetch
+    // the tagged remote at all, and pooling has to coordinate its pool anyway. Exits on the first hit.
+    // Per share scope, because a pool never spans one: a tag in another scope is no reason to pool here.
+    hasPoolTag: function(shareScope) {
+      const scope = _cache[shareScope ?? GLOBAL_SCOPE];
+      if (!scope) return false;
+      for (const external of Object.values(scope))
+        for (const version of external.versions)
+          for (const remote of version.remotes) if (remote.pool?.trim()) return true;
+      return false;
     },
     getFromScope: function(shareScope) {
       return { ..._cache[shareScope ?? GLOBAL_SCOPE] };
@@ -2915,28 +3941,41 @@ 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 removedCopy = false;
+          for (let i = external.versions.length - 1; i >= 0; i--) {
+            const version = external.versions[i];
+            const remotes = version.remotes;
+            const host = version.host ? remotes[0]?.name : void 0;
+            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;
+              removedCopy = true;
+              _dirty = true;
+              if (host !== void 0 && remoteNames.has(host)) version.host = false;
+            }
+            if (remotes.length === 0) {
+              external.versions.splice(i, 1);
+              _dirty = true;
             }
+          }
+          if (removedCopy) {
             external.dirty = true;
             if (external.versions.length === 0) removeExternals.push(name);
           }
@@ -2960,7 +3999,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;
     }
   };
@@ -2997,17 +4038,29 @@ 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;
+    },
+    // Whole-remote: a build that stops chunking a bundle omits the key, so `addOrReplace` cannot clear it.
+    remove: function(remoteName) {
+      if (remoteName in _cache) {
+        delete _cache[remoteName];
+        _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;
     }
   };
@@ -3213,10 +4266,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);
@@ -3240,6 +4292,7 @@ var createStorageConfig = (override) => ({
 var defaultProfile = {
   latestSharedExternal: false,
   skipInvalidExternalVersions: false,
+  scopeUncoveredEntrypoints: false,
   overrideCachedRemotes: "init-only",
   overrideCachedRemotesIfURLMatches: false
 };