@softarc/native-federation-orchestrator 4.7.0 → 4.9.0

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

@@ -223,7 +223,7 @@ var require_semver = __commonJS({
       }
       return true;
     };
-    var SemVer = class _SemVer {
+    var SemVer2 = class _SemVer {
       constructor(version, options) {
         options = parseOptions(options);
         if (version instanceof _SemVer) {
@@ -490,7 +490,7 @@ var require_semver = __commonJS({
         return this;
       }
     };
-    module.exports = SemVer;
+    module.exports = SemVer2;
   }
 });
 
@@ -498,13 +498,13 @@ var require_semver = __commonJS({
 var require_parse = __commonJS({
   "node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js"(exports, module) {
     "use strict";
-    var SemVer = require_semver();
+    var SemVer2 = require_semver();
     var parse = (version, options, throwErrors = false) => {
-      if (version instanceof SemVer) {
+      if (version instanceof SemVer2) {
         return version;
       }
       try {
-        return new SemVer(version, options);
+        return new SemVer2(version, options);
       } catch (er) {
         if (!throwErrors) {
           return null;
@@ -571,8 +571,8 @@ var require_lrucache = __commonJS({
 var require_compare = __commonJS({
   "node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js"(exports, module) {
     "use strict";
-    var SemVer = require_semver();
-    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    var SemVer2 = require_semver();
+    var compare = (a, b, loose) => new SemVer2(a, loose).compare(new SemVer2(b, loose));
     module.exports = compare;
   }
 });
@@ -730,7 +730,7 @@ var require_comparator = __commonJS({
         if (!m[2]) {
           this.semver = ANY;
         } else {
-          this.semver = new SemVer(m[2], this.options.loose);
+          this.semver = new SemVer2(m[2], this.options.loose);
         }
       }
       toString() {
@@ -743,7 +743,7 @@ var require_comparator = __commonJS({
         }
         if (typeof version === "string") {
           try {
-            version = new SemVer(version, this.options);
+            version = new SemVer2(version, this.options);
           } catch (er) {
             return false;
           }
@@ -795,7 +795,7 @@ var require_comparator = __commonJS({
     var { safeRe: re, t } = require_re();
     var cmp = require_cmp();
     var debug = require_debug();
-    var SemVer = require_semver();
+    var SemVer2 = require_semver();
     var Range = require_range();
   }
 });
@@ -931,7 +931,7 @@ var require_range = __commonJS({
         }
         if (typeof version === "string") {
           try {
-            version = new SemVer(version, this.options);
+            version = new SemVer2(version, this.options);
           } catch (er) {
             return false;
           }
@@ -950,7 +950,7 @@ var require_range = __commonJS({
     var parseOptions = require_parse_options();
     var Comparator = require_comparator();
     var debug = require_debug();
-    var SemVer = require_semver();
+    var SemVer2 = require_semver();
     var {
       safeRe: re,
       src,
@@ -1206,16 +1206,16 @@ var require_satisfies = __commonJS({
 var require_min_version = __commonJS({
   "node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-version.js"(exports, module) {
     "use strict";
-    var SemVer = require_semver();
+    var SemVer2 = require_semver();
     var Range = require_range();
     var gt = require_gt();
     var minVersion = (range, loose) => {
       range = new Range(range, loose);
-      let minver = new SemVer("0.0.0");
+      let minver = new SemVer2("0.0.0");
       if (range.test(minver)) {
         return minver;
       }
-      minver = new SemVer("0.0.0-0");
+      minver = new SemVer2("0.0.0-0");
       if (range.test(minver)) {
         return minver;
       }
@@ -1224,7 +1224,7 @@ var require_min_version = __commonJS({
         const comparators = range.set[i];
         let setMin = null;
         comparators.forEach((comparator) => {
-          const compver = new SemVer(comparator.semver.version);
+          const compver = new SemVer2(comparator.semver.version);
           switch (comparator.operator) {
             case ">":
               if (compver.prerelease.length === 0) {
@@ -1283,7 +1283,7 @@ var createInitFlow = ({
   adapters,
   config
 }) => {
-  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) => ({
+  return (remotesOrManifestUrl) => flow.getRemoteEntries(remotesOrManifestUrl).then(flow.processRemoteEntries).then(flow.poolSharedExternals).then(flow.determineSharedExternals).then(flow.decideServingBuilds).then(flow.generateImportMap).then((importMap) => flow.commitChanges(importMap, { override: true })).then(flow.exposeModuleLoader).then((loadRemoteModule) => ({
     config,
     adapters,
     loadRemoteModule
@@ -1294,14 +1294,17 @@ var createInitFlow = ({
 var createInitRemoteEntryFlow = ({
   flow
 }) => {
-  const processDynamicRemoteEntry = (remoteEntry) => flow.updateCache(remoteEntry).then(flow.poolDynamicExternals).then(flow.convertToImportMap).then(flow.commitChanges);
-  return (remoteEntryUrl, remote) => flow.getRemoteEntry(remoteEntryUrl, remote).then((entry) => entry.map(processDynamicRemoteEntry).orElse(Promise.resolve())).then(() => void 0);
+  const processDynamicRemoteEntry = (remoteEntry) => flow.updateCache(remoteEntry).then(flow.poolDynamicExternals).then(flow.convertToImportMap).then((importMap) => flow.commitChanges(importMap, { markUndecided: true }));
+  return (remoteEntryUrl, remote) => flow.getRemoteEntry(remoteEntryUrl, remote).then((entry) => entry.map(processDynamicRemoteEntry).orElse(Promise.resolve())).then(() => void 0).catch((error) => {
+    const remoteName = typeof remote === "string" ? remote : remote?.name;
+    return flow.rollbackChanges(`[dynamic-init][${remoteName ?? remoteEntryUrl}]`).then(() => Promise.reject(error));
+  });
 };
 
 // src/lib/core/native-federation.error.ts
 var NFError = class extends Error {
   constructor(message, cause) {
-    super(message, cause);
+    super(message, cause ? { cause } : void 0);
     this.name = "NFError";
   }
 };
@@ -1322,8 +1325,129 @@ function getScope(path) {
   return `${parts.join("/")}/`;
 }
 
+// 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) => {
+    addRemoteInfoToStorage(remoteEntry);
+    addExternalsToStorage(remoteEntry, onSharedExternal);
+    addSharedChunksToStorage(remoteEntry);
+  };
+  function addRemoteInfoToStorage({ name, url, exposes, integrity }) {
+    ports.remoteInfoRepo.addOrUpdate(name, {
+      scopeUrl: getScope(url),
+      exposes: Object.values(exposes ?? []).map((m) => ({
+        moduleName: m.key,
+        file: m.outFileName
+      })),
+      ...integrity ? { integrity } : {}
+    });
+  }
+  function addExternalsToStorage(remoteEntry, onSharedExternal) {
+    remoteEntry.shared.forEach((external) => {
+      const tag = resolveVersion(remoteEntry, external);
+      if (tag === null) return;
+      if (external.singleton) {
+        if (external.requiredVersion && !ports.versionCheck.isCompatible(tag, external.requiredVersion))
+          config.log.warn(
+            logStep,
+            `[${remoteEntry.name}][${external.packageName}] requiredVersion '${external.requiredVersion}' excludes its own version '${tag}'; '${tag}' is still accepted for it.`
+          );
+        onSharedExternal(remoteEntry, external, sharedExternalContext(remoteEntry, external, tag));
+      } else {
+        addScopedExternal(remoteEntry, external, tag);
+      }
+    });
+  }
+  function addSharedChunksToStorage(remoteEntry) {
+    if (!remoteEntry.chunks) return;
+    config.log.debug(
+      logStep,
+      `Adding chunks for remote "${remoteEntry.name}", bundles: [${Object.keys(remoteEntry.chunks).join(", ")}]`
+    );
+    Object.entries(remoteEntry.chunks).forEach(([bundleName, chunks]) => {
+      ports.sharedChunksRepo.addOrReplace(remoteEntry.name, bundleName, chunks);
+    });
+  }
+  function addScopedExternal(remoteEntry, sharedInfo, tag) {
+    ports.scopedExternalsRepo.addExternal(remoteEntry.name, sharedInfo.packageName, {
+      tag,
+      bundle: sharedInfo.bundle,
+      entries: sharedInfo.entries
+    });
+  }
+  function resolveVersion(remoteEntry, external) {
+    if (external.version && ports.versionCheck.isValidSemver(external.version)) {
+      return external.version;
+    }
+    const errorMsg = `[${remoteEntry.name}][${external.packageName}] Version '${external.version}' is not a valid version.`;
+    if (config.strict.strictExternalVersion) {
+      config.log.error(logStep, errorMsg);
+      throw new NFError(`Could not process remote '${remoteEntry.name}'`);
+    }
+    if (config.profile.skipInvalidExternalVersions) {
+      config.log.warn(logStep, `${errorMsg} Skipping external.`);
+      return null;
+    }
+    config.log.warn(logStep, errorMsg);
+    return ports.versionCheck.smallestVersion(external.requiredVersion);
+  }
+  function sharedExternalContext(remoteEntry, sharedInfo, tag) {
+    const scopeType = ports.sharedExternalsRepo.scopeType(sharedInfo.shareScope);
+    const remote = {
+      name: remoteEntry.name,
+      bundle: sharedInfo.bundle,
+      strictVersion: sharedInfo.strictVersion,
+      cached: false,
+      requiredVersion: scopeType === "strict" ? tag : sharedInfo.requiredVersion || tag,
+      ...sharedInfo.pool?.trim() ? { pool: sharedInfo.pool } : {},
+      ...sharedInfo.dense ? { dense: true } : {},
+      entries: sharedInfo.entries
+    };
+    let stored;
+    const readRecord = () => stored ??= ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).get() ?? { dirty: false, versions: [] };
+    return {
+      tag,
+      remote,
+      readRecord,
+      scopeType,
+      assertSameVersionCompatibility(matchingVersion) {
+        if (!remote.strictVersion) return;
+        if (matchingVersion.remotes[0].requiredVersion === remote.requiredVersion) return;
+        const errorMsg = `[${remoteEntry.name}][${sharedInfo.packageName}@${sharedInfo.version}] Required version-range '${remote.requiredVersion}' does not match cached version-range '${matchingVersion.remotes[0].requiredVersion}'`;
+        if (config.strict.strictExternalSameVersionCompatibility) {
+          config.log.error(logStep, errorMsg);
+          throw new NFError(`Could not process remote '${remoteEntry.name}'`);
+        }
+        config.log.warn(logStep, errorMsg);
+      },
+      write() {
+        ports.sharedExternalsRepo.addOrUpdate(
+          sharedInfo.packageName,
+          {
+            ...readRecord(),
+            versions: readRecord().versions.sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
+          },
+          sharedInfo.shareScope
+        );
+      }
+    };
+  }
+}
+
 // src/lib/core/2.app/steps/get-remote-entries.ts
 function createGetRemoteEntries(config, ports) {
+  const removeCachedRemoteEntries = createRemoveCachedRemoteEntries(ports);
   return (remotesOrManifestUrl = {}) => {
     const manifestPromise = config.manifestIntegrity ? ports.manifestProvider.provide(remotesOrManifestUrl, {
       integrity: config.manifestIntegrity
@@ -1331,7 +1455,7 @@ function createGetRemoteEntries(config, ports) {
     return manifestPromise.catch((e) => {
       config.log.error(1, "Could not fetch manifest.", e);
       return Promise.reject(new NFError("Failed to fetch manifest"));
-    }).then(addHostRemoteEntry).then(fetchRemoteEntries).then(removeSkippedRemotes).then(checkForSSE);
+    }).then(addHostRemoteEntry).then(dropUnlistedRemotes).then(fetchRemoteEntries).then(removeSkippedRemotes).then(checkForSSE);
   };
   function addHostRemoteEntry(manifest) {
     if (!config.hostRemoteEntry) return manifest;
@@ -1341,6 +1465,26 @@ function createGetRemoteEntries(config, ports) {
       [name]: integrity ? { url, integrity } : url
     };
   }
+  function dropUnlistedRemotes(manifest) {
+    if (config.profile.mergeManifests !== false) return manifest;
+    const listedUrls = new Set(
+      Object.values(manifest).map((descriptor) => normalizeEntry(descriptor).url)
+    );
+    const isListed = (remoteName, info) => Object.hasOwn(manifest, remoteName) || listedUrls.has(storedEntryUrl(info));
+    const unlisted = new Set(
+      Object.entries(ports.remoteInfoRepo.getAll()).filter(([remoteName, info]) => !isListed(remoteName, info)).map(([remoteName]) => remoteName)
+    );
+    if (unlisted.size > 0)
+      config.log.debug(
+        1,
+        `Removing stored remotes the manifest doesn't list: ${[...unlisted].join(", ")}.`
+      );
+    removeCachedRemoteEntries(unlisted);
+    return manifest;
+  }
+  function storedEntryUrl(info) {
+    return join(info.scopeUrl, "remoteEntry.json");
+  }
   function normalizeEntry(descriptor) {
     return typeof descriptor === "string" ? { url: descriptor } : descriptor;
   }
@@ -1365,7 +1509,7 @@ function createGetRemoteEntries(config, ports) {
     let isOverride = false;
     let skip = false;
     ports.remoteInfoRepo.tryGet(remoteName).ifPresent((cachedRemoteInfo) => {
-      if (config.profile.overrideCachedRemotes !== "never" && (remoteEntryUrl !== join(cachedRemoteInfo.scopeUrl, "remoteEntry.json") || config.profile.overrideCachedRemotesIfURLMatches)) {
+      if (config.profile.overrideCachedRemotes !== "never" && (remoteEntryUrl !== storedEntryUrl(cachedRemoteInfo) || config.profile.overrideCachedRemotesIfURLMatches)) {
         config.log.debug(1, `Overriding existing remote '${remoteName}' with '${remoteEntryUrl}'.`);
         isOverride = true;
       } else {
@@ -1426,11 +1570,17 @@ function createGetRemoteEntries(config, ports) {
   }
 }
 
+// src/lib/utils/compare-strings.ts
+function compareStrings(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
 // 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);
+  const byCoverage = coverage(candidate) - coverage(basis);
+  return byCoverage === 0 ? compareStrings(candidate.name, basis.name) < 0 : byCoverage > 0;
 }
 function addRemoteToVersion(version, remote, isHost = false) {
   if (isHost) {
@@ -1454,21 +1604,6 @@ function versionDemands(version) {
   }
   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;
@@ -1476,16 +1611,6 @@ function forEachVersionEntry(version, accepts, visit) {
     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) {
@@ -1494,118 +1619,87 @@ function countUncoveredEntrypoints(remote, covered) {
   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);
+// src/lib/core/1.domain/externals/rows.ts
+var byTag = (compare) => (a, b) => compare(b.tag, a.tag);
+var rowAt = (versions, tag, action) => versions.find((v) => v.tag === tag && v.action === action);
+function mergeRows(versions, lead) {
+  const merged = /* @__PURE__ */ new Map();
+  if (lead) merged.set(`${lead.tag}|${lead.action}`, lead);
+  return versions.filter((v) => {
+    const key = `${v.tag}|${v.action}`;
+    const first = merged.get(key);
+    if (first === v) return true;
+    if (!first) {
+      merged.set(key, v);
+      return true;
     }
-    ports.sharedExternalsRepo.removeFromAllScopes(remoteNames);
-  };
+    first.remotes.push(...v.remotes);
+    return false;
+  });
 }
-function createStoreRemoteEntry(config, ports, logStep) {
-  return (remoteEntry, onSharedExternal) => {
-    addRemoteInfoToStorage(remoteEntry);
-    addExternalsToStorage(remoteEntry, onSharedExternal);
-    addSharedChunksToStorage(remoteEntry);
-  };
-  function addRemoteInfoToStorage({ name, url, exposes, integrity }) {
-    ports.remoteInfoRepo.addOrUpdate(name, {
-      scopeUrl: getScope(url),
-      exposes: Object.values(exposes ?? []).map((m) => ({
-        moduleName: m.key,
-        file: m.outFileName
-      })),
-      ...integrity ? { integrity } : {}
-    });
-  }
-  function addExternalsToStorage(remoteEntry, onSharedExternal) {
-    remoteEntry.shared.forEach((external) => {
-      const tag = resolveVersion(remoteEntry, external);
-      if (tag === null) return;
-      if (external.singleton) {
-        onSharedExternal(remoteEntry, external, sharedExternalContext(remoteEntry, external, tag));
-      } else {
-        addScopedExternal(remoteEntry, external, tag);
-      }
-    });
+function findVersionForTag(versions, tag) {
+  let scoped;
+  for (const version of versions) {
+    if (version.tag !== tag) continue;
+    if (version.action !== "scope") return version;
+    scoped ??= version;
   }
-  function addSharedChunksToStorage(remoteEntry) {
-    if (!remoteEntry.chunks) return;
-    config.log.debug(
-      logStep,
-      `Adding chunks for remote "${remoteEntry.name}", bundles: [${Object.keys(remoteEntry.chunks).join(", ")}]`
-    );
-    Object.entries(remoteEntry.chunks).forEach(([bundleName, chunks]) => {
-      ports.sharedChunksRepo.addOrReplace(remoteEntry.name, bundleName, chunks);
-    });
+  return scoped;
+}
+function redirectRow(version, tag, acceptsTag) {
+  const objecting = new Set(
+    version.remotes.filter((r) => r.strictVersion && !acceptsTag(tag, version.tag, r.requiredVersion))
+  );
+  if (objecting.size === 0) {
+    version.action = "skip";
+    return [version];
   }
-  function addScopedExternal(remoteEntry, sharedInfo, tag) {
-    ports.scopedExternalsRepo.addExternal(remoteEntry.name, sharedInfo.packageName, {
-      tag,
-      bundle: sharedInfo.bundle,
-      entries: sharedInfo.entries
-    });
+  if (objecting.size === version.remotes.length) {
+    version.action = "scope";
+    return [version];
   }
-  function resolveVersion(remoteEntry, external) {
-    if (external.version && ports.versionCheck.isValidSemver(external.version)) {
-      return external.version;
-    }
-    const errorMsg = `[${remoteEntry.name}][${external.packageName}] Version '${external.version}' is not a valid version.`;
-    if (config.strict.strictExternalVersion) {
-      config.log.error(logStep, errorMsg);
-      throw new NFError(`Could not process remote '${remoteEntry.name}'`);
+  version.remotes = version.remotes.filter((r) => !objecting.has(r));
+  version.action = "skip";
+  return [version, { tag: version.tag, host: false, action: "scope", remotes: [...objecting] }];
+}
+function scopeRemotes(versions, remotes) {
+  if (remotes.length === 0) return versions;
+  const turn = new Map(remotes.map((remote, i) => [remote, i]));
+  const moves = /* @__PURE__ */ new Map();
+  versions.forEach((source, at) => {
+    if (source.action === "scope") return;
+    const byTurn = /* @__PURE__ */ new Map();
+    for (const copy of source.remotes) {
+      const i = turn.get(copy.name);
+      if (i === void 0) continue;
+      const copies = byTurn.get(i);
+      if (copies) copies.push(copy);
+      else byTurn.set(i, [copy]);
     }
-    if (config.profile.skipInvalidExternalVersions) {
-      config.log.warn(logStep, `${errorMsg} Skipping external.`);
-      return null;
+    if (byTurn.size === 0) return;
+    const hostTurn = source.host ? turn.get(source.remotes[0].name) : void 0;
+    source.remotes = source.remotes.filter((r) => !turn.has(r.name));
+    if (hostTurn !== void 0) source.host = false;
+    const tagMoves = moves.get(source.tag) ?? [];
+    for (const [i, copies] of byTurn)
+      tagMoves.push({ turn: i, at, source, copies, host: i === hostTurn });
+    moves.set(source.tag, tagMoves);
+  });
+  const rows = [...versions];
+  for (const [tag, tagMoves] of moves) {
+    tagMoves.sort((a, b) => a.turn - b.turn || a.at - b.at);
+    let scoped = rowAt(rows, tag, "scope");
+    if (!scoped) {
+      scoped = { tag, host: false, action: "scope", remotes: [] };
+      rows.splice(rows.indexOf(tagMoves[0].source) + 1, 0, scoped);
     }
-    config.log.warn(logStep, errorMsg);
-    return ports.versionCheck.smallestVersion(external.requiredVersion);
-  }
-  function sharedExternalContext(remoteEntry, sharedInfo, tag) {
-    const scopeType = ports.sharedExternalsRepo.scopeType(sharedInfo.shareScope);
-    const remote = {
-      name: remoteEntry.name,
-      bundle: sharedInfo.bundle,
-      strictVersion: sharedInfo.strictVersion,
-      cached: false,
-      requiredVersion: scopeType === "strict" ? tag : sharedInfo.requiredVersion || tag,
-      ...sharedInfo.pool?.trim() ? { pool: sharedInfo.pool } : {},
-      entries: sharedInfo.entries
-    };
-    const cached = ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).get() ?? { dirty: false, versions: [] };
-    return {
-      tag,
-      remote,
-      cached,
-      scopeType,
-      assertSameVersionCompatibility(matchingVersion) {
-        if (!remote.strictVersion) return;
-        if (matchingVersion.remotes[0].requiredVersion === remote.requiredVersion) return;
-        const errorMsg = `[${remoteEntry.name}][${sharedInfo.packageName}@${sharedInfo.version}] Required version-range '${remote.requiredVersion}' does not match cached version-range '${matchingVersion.remotes[0].requiredVersion}'`;
-        if (config.strict.strictExternalSameVersionCompatibility) {
-          config.log.error(logStep, errorMsg);
-          throw new NFError(`Could not process remote '${remoteEntry.name}'`);
-        }
-        config.log.warn(logStep, errorMsg);
-      },
-      commit() {
-        ports.sharedExternalsRepo.addOrUpdate(
-          sharedInfo.packageName,
-          {
-            dirty: cached.dirty,
-            ...cached.poolName !== void 0 && { poolName: cached.poolName },
-            versions: cached.versions.sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
-          },
-          sharedInfo.shareScope
-        );
-      }
-    };
+    for (const { copies, host } of tagMoves)
+      if (host) {
+        scoped.host = true;
+        scoped.remotes.unshift(...copies);
+      } else scoped.remotes.push(...copies);
   }
+  return rows.filter((v) => v.remotes.length > 0);
 }
 
 // src/lib/core/2.app/steps/process-remote-entries.ts
@@ -1643,11 +1737,12 @@ function createProcessRemoteEntries(config, ports) {
   function addSharedExternal(remoteEntry, _sharedInfo, {
     tag,
     remote,
-    cached,
+    readRecord,
     scopeType,
     assertSameVersionCompatibility,
-    commit
+    write
   }) {
+    const cached = readRecord();
     if (scopeType !== "strict") cached.dirty = true;
     const matchingVersion = findVersionForTag(cached.versions, tag);
     if (matchingVersion) {
@@ -1661,7 +1756,7 @@ function createProcessRemoteEntries(config, ports) {
         remotes: [remote]
       });
     }
-    commit();
+    write();
   }
 }
 
@@ -1669,154 +1764,70 @@ 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) {
+// src/lib/core/1.domain/externals/compatibility.ts
+function createAcceptsTag(isCompatible, compare) {
+  return (offered, ownTag, requiredVersion) => isCompatible(offered, requiredVersion) || offered === ownTag || compare(offered, ownTag) === 0;
+}
+function versionAcceptance(external, acceptsTag) {
   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))
+    accepts: (version, tag) => demands.get(version).every((d) => acceptsTag(tag, version.tag, d.requiredVersion)),
+    objector: (version, tag) => demands.get(version).find((d) => d.strictVersion && !acceptsTag(tag, version.tag, d.requiredVersion))
   };
 }
+
+// src/lib/core/2.app/steps/apply-winner.ts
+function rejectIncompatible(config, copy, rejected, servedAt) {
+  config.log.error(
+    3,
+    `[${copy.name}][${rejected}] Is not compatible with requiredRange '${copy.requiredVersion}' of shared ${servedAt}.`
+  );
+  throw new NFError(`External ${rejected} could not be shared.`);
+}
 function createApplyWinner(config) {
-  return function applyWinner(externalName, external, winner, isCompatible, acceptance) {
+  return function applyWinner(externalName, external, winner, acceptsTag, 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}.`
+        const objector = config.strict.strictExternalCompatibility && acceptance.objector(v, winner.tag);
+        if (objector)
+          rejectIncompatible(
+            config,
+            objector,
+            `${externalName}@${v.tag}`,
+            `${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] });
+        rebuilt.push(...redirectRow(v, winner.tag, acceptsTag));
       }
-      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;
-      });
+      external.versions = mergeRows(rebuilt, winner);
     }
     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();
+    const acceptsTag = createAcceptsTag(
+      ports.versionCheck.isCompatible,
+      ports.versionCheck.compare
+    );
     for (const shareScope of ports.sharedExternalsRepo.getScopes()) {
+      if (ports.sharedExternalsRepo.scopeType(shareScope) === "strict") continue;
       const sharedExternals = ports.sharedExternalsRepo.getFromScope(shareScope);
       try {
-        const elected = /* @__PURE__ */ new Set();
         Object.entries(sharedExternals).filter(([_, e]) => e.dirty).forEach(([name, external]) => {
           ports.sharedExternalsRepo.addOrUpdate(
             name,
-            setVersionActions(name, external, isCompatible),
+            setVersionActions(name, external, acceptsTag),
             shareScope
           );
-          elected.add(name);
         });
-        if (elected.size > 0) touched.set(shareScope, elected);
       } catch (error) {
         config.log.error(
           3,
@@ -1834,24 +1845,22 @@ function createDetermineSharedExternals(config, ports) {
         );
       }
     }
-    return Promise.resolve(touched);
+    return Promise.resolve();
   };
   function uncoveredTears(external, winner, accepts) {
-    const basis = versionEntries(winner);
+    const covered = /* @__PURE__ */ new Set();
+    forEachVersionEntry(winner, void 0, (entrypoint) => covered.add(entrypoint));
     return external.versions.reduce((sum, v) => {
       if (v === winner) return sum;
       if (!accepts(v, winner.tag)) return sum;
-      return v.remotes.reduce(
-        (n, r) => r.servedBy ? n : n + countUncoveredEntrypoints(r, basis),
-        sum
-      );
+      return v.remotes.reduce((n, r) => n + countUncoveredEntrypoints(r, covered), sum);
     }, 0);
   }
-  function setVersionActions(externalName, external, isCompatible) {
+  function setVersionActions(externalName, external, acceptsTag) {
+    const acceptance = versionAcceptance(external, acceptsTag);
     if (external.versions.length === 1) {
-      return applyWinner(externalName, external, external.versions[0], isCompatible);
+      return applyWinner(externalName, external, external.versions[0], acceptsTag, acceptance);
     }
-    const acceptance = versionAcceptance(external, isCompatible);
     const { accepts } = acceptance;
     let sharedVersion = external.versions.find((v) => v.host);
     if (!sharedVersion && config.profile.latestSharedExternal) {
@@ -1860,6 +1869,7 @@ function createDetermineSharedExternals(config, ports) {
     if (!sharedVersion) {
       let leastExtraDownloads = Number.MAX_VALUE;
       let leastTears = Number.MAX_VALUE;
+      let leaderShared = false;
       const selfServing = new Map(
         external.versions.map((v) => {
           const groups = /* @__PURE__ */ new Map();
@@ -1876,24 +1886,25 @@ function createDetermineSharedExternals(config, ports) {
           return [v, [...groups.values()]];
         })
       );
-      const costOf = (version, tag) => selfServing.get(version).reduce((n, g) => isCompatible(tag, g.requiredVersion) ? n : n + g.copies, 0);
+      const costOf = (version, tag) => selfServing.get(version).reduce(
+        (n, g) => acceptsTag(tag, version.tag, g.requiredVersion) ? n : n + g.copies,
+        0
+      );
       external.versions.forEach((vA) => {
-        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
-        );
+        const extraDownloads = external.versions.reduce((sum, vB) => sum + costOf(vB, vA.tag), 0);
+        const alreadyShared = vA.action === "share" && !!vA.remotes[0]?.cached;
         if (extraDownloads < leastExtraDownloads) {
           leastExtraDownloads = extraDownloads;
           leastTears = uncoveredTears(external, vA, accepts);
+          leaderShared = alreadyShared;
           sharedVersion = vA;
           return;
         }
-        if (extraDownloads > leastExtraDownloads) return;
+        if (extraDownloads > leastExtraDownloads || leaderShared) return;
         const tears = uncoveredTears(external, vA, accepts);
-        if (tears < leastTears) {
+        if (alreadyShared || tears < leastTears) {
           leastTears = tears;
+          leaderShared = alreadyShared;
           sharedVersion = vA;
         }
       });
@@ -1901,582 +1912,619 @@ function createDetermineSharedExternals(config, ports) {
     if (!sharedVersion) {
       throw new NFError(`[${externalName}] Could not determine shared version!`);
     }
-    return applyWinner(externalName, external, sharedVersion, isCompatible, acceptance);
+    return applyWinner(externalName, external, sharedVersion, acceptsTag, acceptance);
   }
 }
 
-// src/lib/core/2.app/steps/pooling/pool-views.ts
-function liveBuilds(members, islanded) {
-  return walkBuilds(members, islanded, true);
+// src/lib/utils/union-find.ts
+function unionFind() {
+  const parent = /* @__PURE__ */ new Map();
+  const find = (node) => {
+    for (let up = parent.get(node); up !== void 0; up = parent.get(node)) {
+      const grand = parent.get(up);
+      if (grand === void 0) return up;
+      parent.set(node, grand);
+      node = grand;
+    }
+    return node;
+  };
+  const union = (a, b) => {
+    const rootA = find(a);
+    const rootB = find(b);
+    if (rootA !== rootB) parent.set(rootB, rootA);
+  };
+  return { find, union };
 }
-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 };
+
+// src/lib/core/1.domain/externals/specifier.ts
+function npmPackageOf(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 name;
+  }
+  return name.slice(0, cut);
 }
-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);
-        }
-      }
+function packageOfIn(scope, loading = []) {
+  if (!declaresLibrary(scope, loading)) return npmPackageOf;
+  const { find, union } = unionFind();
+  const shortest = /* @__PURE__ */ new Map();
+  for (const [name, copy] of copiesIn(scope, loading)) {
+    const anchor = anchorOf(name, copy);
+    for (const specifier in copy.entries) {
+      const best = shorter(
+        shortest.get(find(anchor)) ?? anchor,
+        shortest.get(find(specifier)) ?? specifier
+      );
+      union(anchor, specifier);
+      shortest.set(find(anchor), best);
     }
   }
-  return builds;
+  return (specifier) => {
+    const npm = npmPackageOf(specifier);
+    return shortest.get(find(specifier)) ?? shortest.get(find(npm)) ?? npm;
+  };
 }
-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 });
-      }
-    }
+var shorter = (a, b) => b.length < a.length || b.length === a.length && compareStrings(b, a) < 0 ? b : a;
+function declaresLibrary(scope, loading) {
+  const isLibrary = (name, copies) => npmPackageOf(name) !== name && copies.some((copy) => copy.dense);
+  return loading.some(([name, copy]) => isLibrary(name, [copy])) || Object.entries(scope).some(
+    ([name, external]) => external.versions.some((version) => isLibrary(name, version.remotes))
+  );
+}
+var anchorOf = (name, copy) => copy.dense ? name : npmPackageOf(name);
+function* copiesIn(scope, loading) {
+  yield* loading;
+  for (const [name, external] of Object.entries(scope))
+    for (const version of external.versions) for (const copy of version.remotes) yield [name, copy];
+}
+var SpecifierTags = class extends Map {
+  constructor(packageOf, entries = []) {
+    super();
+    this.packageOf = packageOf;
+    for (const [specifier, tag] of entries) this.set(specifier, tag);
+  }
+  packageOf;
+  packages = /* @__PURE__ */ new Map();
+  set(specifier, tag) {
+    super.set(specifier, tag);
+    const pkg = this.packageOf(specifier);
+    if (pkg === specifier || !this.packages.has(pkg)) this.packages.set(pkg, tag);
+    return this;
+  }
+  clear() {
+    super.clear();
+    this.packages.clear();
+  }
+  pinnedTag(specifier) {
+    return this.get(specifier) ?? this.packages.get(this.packageOf(specifier));
   }
-  return own;
+};
+function groupByPackage(items, nameOf, packageOf) {
+  const packages = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const pkg = packageOf(nameOf(item));
+    const group = packages.get(pkg);
+    if (group) group.push(item);
+    else packages.set(pkg, [item]);
+  }
+  return packages;
 }
-function consumedMembers(members) {
-  const consumed = /* @__PURE__ */ new Map();
+
+// src/lib/core/1.domain/pooling/builds.ts
+function copiesByRemote(members) {
+  const shipped = /* @__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);
+    const seen = /* @__PURE__ */ new Set();
+    for (const version of member.external.versions)
+      for (const meta of version.remotes) {
+        if (seen.has(meta.name)) continue;
+        seen.add(meta.name);
+        let copies = shipped.get(meta.name);
+        if (!copies) shipped.set(meta.name, copies = []);
+        copies.push({
+          member: member.name,
+          tag: version.tag,
+          requiredVersion: meta.requiredVersion,
+          strict: meta.strictVersion,
+          host: version.host && meta === version.remotes[0],
+          specifiers: Object.keys(meta.entries)
+        });
       }
-    }
   }
-  return consumed;
+  return shipped;
 }
-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);
-      }
+var specifierCount = (copies) => copies.reduce((n, copy) => n + copy.specifiers.length, 0);
+function buildOf(owner, copies, packageOf) {
+  const tags = new SpecifierTags(packageOf);
+  const tagByMember = /* @__PURE__ */ new Map();
+  for (const copy of copies) {
+    for (const specifier of copy.specifiers)
+      if (!tags.has(specifier)) tags.set(specifier, copy.tag);
+    tagByMember.set(copy.member, copy.tag);
+  }
+  return { owner, tags, tagByMember, host: copies.some((c) => c.host) };
+}
+
+// src/lib/core/1.domain/pooling/rules.ts
+function agrees(copies, tags) {
+  for (const copy of copies)
+    for (const s of copy.specifiers) {
+      const tag = tags.pinnedTag(s);
+      if (tag !== void 0 && tag !== copy.tag) return false;
     }
-  }
-  return consumed;
+  return true;
 }
-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);
-      }
+function serves(copies, tags, acceptsTag) {
+  for (const copy of copies)
+    for (const s of copy.specifiers) {
+      const tag = tags.get(s);
+      if (tag === void 0 || !acceptsTag(tag, copy.tag, copy.requiredVersion)) return false;
     }
-  }
-  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 unwitnessedGap(copies, tags, builds) {
+  const specifiers = copies.flatMap((c) => c.specifiers);
+  let gap = 0;
+  for (const build of builds) {
+    const miss = specifiers.findIndex((s) => build.tags.pinnedTag(s) !== tags.get(s));
+    if (miss === -1) return void 0;
+    gap = Math.max(gap, miss);
+  }
+  return specifiers[gap];
 }
-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;
+
+// src/lib/core/1.domain/pooling/election.ts
+function elect(input) {
+  const shipped = copiesByRemote(input.members);
+  const builds = /* @__PURE__ */ new Map();
+  for (const [owner, copies] of shipped) builds.set(owner, buildOf(owner, copies, input.packageOf));
+  const pool = {
+    ...input,
+    shipped,
+    builds,
+    packages: new Map(
+      [...shipped].map(([owner, copies]) => [owner, packageCopies(owner, copies, input.packageOf)])
+    ),
+    remotes: [...shipped.keys()],
+    servesAt: (remote, tags) => serves(shipped.get(remote), tags, input.acceptsTag),
+    agreesAt: (remote, tags) => agrees(shipped.get(remote), tags)
+  };
+  const hostRemote = pool.remotes.find((r) => builds.get(r).host);
+  const state = roundOne(pool, hostRemote);
+  formSubpools(pool, state);
+  addExtensions(pool, state);
+  promote(pool, state);
+  while (settle(pool, state)) formSubpools(pool, state);
+  const firstSeen = new Map(pool.remotes.map((r, i) => [r, i]));
+  const self = state.pending.sort((a, b) => firstSeen.get(a) - firstSeen.get(b));
+  return {
+    winner: state.winner,
+    winnerIsHost: hostRemote !== void 0,
+    globalTags: state.globalTags,
+    ...placeRemotes(state.globalRemotes, state.subpools, self, (r) => missOf(pool, state, r))
+  };
 }
-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 newer(pool, a, b) {
+  for (const { name } of pool.members) {
+    const tagA = a.tagByMember.get(name);
+    const tagB = b.tagByMember.get(name);
+    if (tagA === void 0 || tagB === void 0) continue;
+    const d = pool.compare(tagA, tagB);
+    if (d !== 0) return d;
+  }
+  return 0;
 }
-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);
-      }
+function rank(pool, candidates, keys) {
+  const scored = [...candidates].sort((a, b) => compareStrings(a.build.owner, b.build.owner)).map((c) => ({ c, k: keys.map((key) => key(c)) }));
+  scored.sort((a, b) => {
+    for (let i = 0; i < keys.length; i++) {
+      const d = b.k[i] - a.k[i];
+      if (d !== 0) return d;
     }
-  }
-  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 newer(pool, b.c.build, a.c.build) || compareStrings(a.c.build.owner, b.c.build.owner);
   });
-  return shared;
+  return scored[0]?.c;
 }
-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]);
+function roundOne(pool, hostRemote) {
+  const { remotes } = pool;
+  const scored = /* @__PURE__ */ new Map();
+  const round1 = (hostRemote ? [hostRemote] : remotes).map((owner) => {
+    const build = pool.builds.get(owner);
+    const key = JSON.stringify([[...build.tags], [...build.tagByMember]]);
+    let score = scored.get(key);
+    if (!score) {
+      const served = new Set(remotes.filter((r) => pool.servesAt(r, build.tags)));
+      const agreeing = remotes.filter((r) => !served.has(r) && pool.agreesAt(r, build.tags)).length;
+      scored.set(key, score = { served: [...served], agreeing });
     }
-  }
+    return { build, ...score };
+  });
+  const newerThan = (c) => round1.filter((o) => newer(pool, c.build, o.build) > 0).length;
+  const round1Winner = rank(pool, round1, [
+    ...pool.latestFirst ? [newerThan] : [],
+    (c) => c.served.length,
+    (c) => c.agreeing,
+    (c) => c.build.owner === pool.previousWinner ? 1 : 0
+  ]);
+  const winner = round1Winner.build.owner;
+  const globalTags = new SpecifierTags(pool.packageOf, round1Winner.build.tags);
+  const globalRemotes = /* @__PURE__ */ new Set([winner, ...round1Winner.served]);
+  const pending = remotes.filter((r) => !globalRemotes.has(r));
+  return { winner, globalTags, globalRemotes, extensions: /* @__PURE__ */ new Set(), subpools: [], pending };
 }
-
-// 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);
-      }
-    }
+function formSubpools(pool, state) {
+  const servable = new Map(
+    state.pending.map((owner) => {
+      const build = pool.builds.get(owner);
+      const served = state.pending.filter((r) => pool.servesAt(r, build.tags));
+      return [owner, { build, served }];
+    })
+  );
+  for (; ; ) {
+    const stillPending = new Set(state.pending);
+    const candidates = state.pending.map((owner) => {
+      const { build, served } = servable.get(owner);
+      return { build, served: served.filter((r) => stillPending.has(r)) };
+    }).filter((c) => c.served.includes(c.build.owner) && c.served.length >= 2);
+    const best = rank(pool, candidates, [(c) => c.served.length]);
+    if (!best) break;
+    state.subpools.push({ owner: best.build.owner, remotes: best.served });
+    state.pending = state.pending.filter((r) => !best.served.includes(r));
   }
-  return table;
 }
-function covers(coverage2, consumed) {
-  for (const specifier of consumed) if (!coverage2.has(specifier)) return false;
-  return true;
+function promote(pool, state) {
+  const { globalTags, globalRemotes } = state;
+  const takesGlobal = (remote) => pool.servesAt(remote, globalTags) && unwitnessedGap(pool.shipped.get(remote), globalTags, pool.builds.values()) === void 0;
+  for (const remote of state.pending) if (takesGlobal(remote)) globalRemotes.add(remote);
+  state.pending = state.pending.filter((r) => !globalRemotes.has(r));
+  for (const subpool of state.subpools) {
+    const moved = subpool.remotes.filter((r) => r !== subpool.owner && takesGlobal(r));
+    for (const remote of moved) globalRemotes.add(remote);
+    subpool.remotes = subpool.remotes.filter((r) => !moved.includes(r));
+  }
+  state.subpools = state.subpools.filter((subpool) => {
+    if (subpool.remotes.length >= 2) return true;
+    if (takesGlobal(subpool.owner)) globalRemotes.add(subpool.owner);
+    else state.pending.push(subpool.owner);
+    return false;
+  });
 }
-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;
+function addExtensions(pool, state) {
+  const { globalTags, globalRemotes } = state;
+  const runsOn = (remote) => state.subpools.find((p) => p.remotes.includes(remote))?.owner ?? remote;
+  const agreeing = pool.remotes.filter((r) => !globalRemotes.has(r) && pool.agreesAt(r, globalTags));
+  const runsGlobally = (remote) => pool.agreesAt(runsOn(remote), globalTags);
+  const offered = offers(pool, globalTags, agreeing.filter(runsGlobally));
+  const fill = pool.builds.get(state.winner).host ? agreeing.filter((r) => !runsGlobally(r)) : [];
+  for (const [pkg, offer] of offers(pool, globalTags, fill))
+    if (!offered.has(pkg)) offered.set(pkg, offer);
+  for (const [pkg, offer] of offered) {
+    if (!offer) continue;
+    state.extensions.add(pkg);
+    for (const s of offer.specifiers) globalTags.set(s, offer.tag);
   }
-  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;
-      }
+function packageCopies(owner, copies, packageOf) {
+  const packages = /* @__PURE__ */ new Map();
+  for (const copy of copies)
+    for (const s of copy.specifiers) {
+      const pkg = packageOf(s);
+      const seen = packages.get(pkg);
+      if (seen === void 0) packages.set(pkg, { owner, tag: copy.tag, specifiers: /* @__PURE__ */ new Set([s]) });
+      else if (seen && seen.tag !== copy.tag) packages.set(pkg, null);
+      else seen?.specifiers.add(s);
     }
-    if (matches) return true;
-  }
-  return false;
+  return packages;
 }
-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 offers(pool, globalTags, remotes) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const owner of remotes)
+    for (const [pkg, copy] of pool.packages.get(owner))
+      if (globalTags.pinnedTag(pkg) === void 0)
+        candidates.set(pkg, [...candidates.get(pkg) ?? [], copy]);
+  const offered = /* @__PURE__ */ new Map();
+  for (const [pkg, copies] of candidates)
+    offered.set(pkg, oneTag(copies) ? coveringCopy(copies) : null);
+  return offered;
 }
-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;
+var oneTag = (copies) => copies.every((c) => c !== null && c.tag === copies[0].tag);
+function coveringCopy(candidates) {
+  const scored = candidates.map((c) => ({
+    c,
+    covers: candidates.filter((o) => contains(c.specifiers, o.specifiers)).length
+  }));
+  scored.sort(
+    (a, b) => b.covers - a.covers || b.c.specifiers.size - a.c.specifiers.size || compareStrings(a.c.owner, b.c.owner)
+  );
+  return scored[0].c;
 }
-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);
-  }
+var contains = (a, b) => [...b].every((s) => a.has(s));
+function settle(pool, state) {
+  const { globalTags, globalRemotes, extensions } = state;
+  let demoted = false;
   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;
+    const dropped = new Set([...extensions].filter((pkg) => !publishedWhole(pool, state, pkg)));
+    if (dropped.size === 0) return demoted;
+    for (const pkg of dropped) extensions.delete(pkg);
+    const kept = [...globalTags].filter(([s]) => !dropped.has(pool.packageOf(s)));
+    globalTags.clear();
+    for (const [s, tag] of kept) globalTags.set(s, tag);
+    for (const remote of globalRemotes)
+      if (remote !== state.winner && !pool.servesAt(remote, globalTags)) {
+        globalRemotes.delete(remote);
+        const subpool = state.subpools.find(
+          (p) => pool.servesAt(remote, pool.builds.get(p.owner).tags)
+        );
+        if (subpool) subpool.remotes.push(remote);
+        else state.pending.push(remote);
+        demoted = true;
       }
-    }
-    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
-function createDSU() {
-  const ids = /* @__PURE__ */ new Map();
-  const parent = [];
-  const size = [];
-  const intern = (key) => {
-    let id = ids.get(key);
-    if (id === void 0) {
-      id = parent.length;
-      ids.set(key, id);
-      parent.push(id);
-      size.push(1);
-    }
-    return id;
-  };
-  const findRoot = (x) => {
-    while (parent[x] !== x) {
-      parent[x] = parent[parent[x]];
-      x = parent[x];
-    }
-    return x;
-  };
-  return {
-    union(a, b) {
-      let rootA = findRoot(intern(a));
-      let rootB = findRoot(intern(b));
-      if (rootA === rootB) return;
-      if (size[rootA] < size[rootB]) [rootA, rootB] = [rootB, rootA];
-      parent[rootB] = rootA;
-      size[rootA] = size[rootA] + size[rootB];
-    },
-    // Interns the key if unseen — an isolated key is its own component.
-    component(key) {
-      return findRoot(intern(key));
+function publishedWhole(pool, state, pkg) {
+  const published = new Set([...state.globalTags.keys()].filter((s) => pool.packageOf(s) === pkg));
+  const tag = state.globalTags.pinnedTag(pkg);
+  return [...state.globalRemotes].some((remote) => {
+    const copy = pool.packages.get(remote).get(pkg);
+    return !!copy && copy.tag === tag && copy.specifiers.size === published.size && contains(copy.specifiers, published);
+  });
+}
+function missOf(pool, state, remote) {
+  const { globalTags } = state;
+  const copies = pool.shipped.get(remote);
+  let rejected;
+  for (const copy of copies)
+    for (const s of copy.specifiers) {
+      const tag = globalTags.get(s);
+      if (tag === void 0 || pool.acceptsTag(tag, copy.tag, copy.requiredVersion)) continue;
+      if (copy.strict) return { cause: "incompatible", member: copy.member, tag, strict: true };
+      rejected ??= { cause: "incompatible", member: copy.member, tag, strict: false };
     }
-  };
+  if (rejected) return rejected;
+  for (const copy of copies)
+    for (const s of copy.specifiers) if (!globalTags.has(s)) return { cause: "uncovered", gap: s };
+  const gap = unwitnessedGap(copies, globalTags, pool.builds.values());
+  if (gap) return { cause: "uncovered", gap, unshipped: true };
+  if (state.subpools.some((p) => p.owner === remote)) return void 0;
+  throw new Error(`'${remote}' missed the global map with nothing it rejects or lacks.`);
 }
+function previousWinner(members) {
+  const winners = new Set(members.flatMap((m) => m.external.poolWinner ?? []));
+  const [winner] = winners;
+  if (winners.size !== 1) return void 0;
+  const ships = members.some(
+    (m) => m.external.versions.some((v) => v.remotes.some((r) => r.name === winner))
+  );
+  return ships ? winner : void 0;
+}
+function placeRemotes(globalRemotes, subpools, self, missOf2) {
+  const misses = /* @__PURE__ */ new Map();
+  for (const remote of [...subpools.flatMap((p) => p.remotes), ...self])
+    misses.set(remote, missOf2(remote));
+  const placements = /* @__PURE__ */ new Map();
+  for (const remote of globalRemotes) placements.set(remote, { kind: "global" });
+  for (const { owner, remotes } of subpools)
+    for (const remote of remotes) placements.set(remote, { kind: "subpool", owner });
+  for (const remote of self)
+    placements.set(remote, { kind: "self", cause: misses.get(remote).cause });
+  return { placements, misses };
+}
+
+// src/lib/core/1.domain/pooling/membership.ts
 var extNode = (name) => `ext\0${name}`;
-var tagNode = (remote, tag) => `tag\0${remote}\0${tag}`;
-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);
+var labelNode = (label) => `label\0${label}`;
+var labelOf = (pool) => pool?.trim() || void 0;
+function labelsIn(sharedExternals) {
+  const labelsOf = /* @__PURE__ */ new Map();
+  for (const [name, external] of Object.entries(sharedExternals))
+    labelsOf.set(
+      name,
+      external.versions.flatMap((v) => v.remotes.flatMap((r) => labelOf(r.pool) ?? []))
+    );
+  return labelsOf;
 }
-function groupByMembership(candidates, log) {
-  const dsu = createDSU();
-  const tagged = /* @__PURE__ */ new Set();
-  for (const candidate of candidates) {
-    for (const edge of candidate.tags) {
-      dsu.union(extNode(candidate.name), tagNode(edge.remote, edge.tag));
-      tagged.add(candidate.name);
-    }
-  }
-  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));
+function labelledComponents(labelsOf, packageOf) {
+  const { find, union } = unionFind();
+  for (const [name, labels] of labelsOf)
+    for (const label of labels) union(extNode(name), labelNode(label));
+  for (const name of labelsOf.keys()) {
+    const owner = packageOf(name);
+    if (owner !== name) union(extNode(name), extNode(owner));
   }
   const byComponent = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
-    const root = dsu.component(extNode(candidate.name));
-    const members = byComponent.get(root) ?? byComponent.set(root, []).get(root);
-    members.push(candidate);
-  }
-  const pools = [];
-  for (const members of byComponent.values()) {
-    if (!members.some((m) => tagged.has(m.name))) continue;
-    members.sort((a, b) => a.name.localeCompare(b.name));
-    if (members.length < 2) {
-      const only = members[0];
-      if (tagged.has(only.name)) {
-        log?.warn(
-          3,
-          `[${only.name}] declares a 'pool' tag but no other external joined its pool; likely a typo or a missing sibling.`
-        );
-      }
-      continue;
+  for (const name of labelsOf.keys()) {
+    const root = find(extNode(name));
+    const names = byComponent.get(root) ?? byComponent.set(root, []).get(root);
+    names.push(name);
+  }
+  return [...byComponent.values()].filter((names) => names.some((n) => labelsOf.get(n).length > 0));
+}
+function buildPools(sharedExternals, packageOf = packageOfIn(sharedExternals)) {
+  const labelsOf = labelsIn(sharedExternals);
+  const pools = /* @__PURE__ */ new Map();
+  const labelledAlone = [];
+  for (const names of labelledComponents(labelsOf, packageOf)) {
+    if (names.length < 2) labelledAlone.push(names[0]);
+    else {
+      const members = names.map((name) => ({ name, external: sharedExternals[name] }));
+      pools.set(
+        mostDeclaredLabel(members, labelsOf),
+        members.sort((a, b) => compareStrings(a.name, b.name))
+      );
     }
-    pools.push(members);
-  }
-  pools.sort((a, b) => a[0].name.localeCompare(b[0].name));
-  const named = /* @__PURE__ */ new Map();
-  for (const members of pools) {
-    const label = mostDeclaredTag(members) ?? members[0].name;
-    let name = label;
-    for (let n = 2; named.has(name); n++) name = `${label}~${n}`;
-    named.set(
-      name,
-      members.map((m) => m.value)
-    );
   }
-  return named;
+  return { pools, labelledAlone, packageOf };
 }
-function mostDeclaredTag(members) {
+function pooledPackagesWith(sharedExternals, copies, packageOf) {
+  const labelsOf = labelsIn(sharedExternals);
+  for (const { name, pool } of copies) {
+    const labels = labelsOf.get(name) ?? [];
+    const label = labelOf(pool);
+    labelsOf.set(name, label === void 0 ? labels : [...labels, label]);
+  }
+  return new Set(
+    labelledComponents(labelsOf, packageOf).filter((names) => names.length > 1).flatMap((names) => names.map(packageOf))
+  );
+}
+function mostDeclaredLabel(members, labelsOf) {
   const counts = /* @__PURE__ */ new Map();
   for (const member of members)
-    for (const edge of member.tags) counts.set(edge.tag, (counts.get(edge.tag) ?? 0) + 1);
-  let best;
-  for (const [tag, count] of counts) {
-    const top = best === void 0 ? 0 : counts.get(best);
-    if (count > top || count === top && tag.localeCompare(best) < 0) best = tag;
-  }
+    for (const label of labelsOf.get(member.name)) counts.set(label, (counts.get(label) ?? 0) + 1);
+  let best = "";
+  let top = 0;
+  for (const [label, count] of counts)
+    if (count > top || count === top && compareStrings(label, best) < 0)
+      [best, top] = [label, count];
   return best;
 }
-function buildPools(sharedExternals, log) {
-  const candidates = Object.entries(sharedExternals).map(
-    ([name, external]) => ({
-      name,
-      tags: external.versions.flatMap(
-        (v) => v.remotes.flatMap((r) => {
-          const tag = r.pool?.trim();
-          return tag ? [{ remote: r.name, tag }] : [];
-        })
-      ),
-      value: { name, external }
-    })
+
+// src/lib/core/1.domain/pooling/pool-state.ts
+function hasPoolResults(external) {
+  if (external.poolName !== void 0 || external.poolWinner !== void 0) return true;
+  return external.versions.some(
+    (v) => v.remotes.some((r) => r.servedBy !== void 0 || r.poolCause !== void 0)
   );
-  return groupByMembership(candidates, log);
+}
+function scopeHasPoolState(scope) {
+  for (const name in scope) {
+    const external = scope[name];
+    if (hasPoolResults(external)) return true;
+    for (const version of external.versions)
+      for (const remote of version.remotes) if (remote.pool?.trim()) return true;
+  }
+  return false;
 }
 
-// src/lib/core/2.app/steps/pooling/pool.util.ts
-function lazy(make) {
-  let value;
-  return () => value ??= make();
+// src/lib/core/1.domain/pooling/records.ts
+function memberRecord(member, pool, compare) {
+  const { globalTags, placements } = pool;
+  let sharedTag = globalTags.get(member.name);
+  for (const version of member.external.versions)
+    for (const meta of version.remotes)
+      for (const s in meta.entries) sharedTag ??= globalTags.get(s);
+  const claimsGlobally = (name) => placements.get(name).kind === "global";
+  const placed = [];
+  let winnerRow;
+  const place = (tag, action, meta) => {
+    const row = { tag, host: false, action, remotes: [meta] };
+    placed.push(row);
+    if (meta.name !== pool.winner) return;
+    winnerRow = row;
+    row.host = pool.winnerIsHost;
+  };
+  for (const version of member.external.versions)
+    for (const stored of version.remotes) {
+      const { servedBy: _servedBy, poolCause: _poolCause, ...rest } = stored;
+      const meta = { ...rest, cached: false };
+      const placement = placements.get(meta.name);
+      if (placement.kind === "global")
+        place(version.tag, version.tag === sharedTag ? "share" : "skip", meta);
+      else if (placement.kind === "subpool")
+        place(version.tag, "skip", { ...meta, servedBy: placement.owner });
+      else place(version.tag, "scope", { ...meta, poolCause: placement.cause });
+    }
+  const rows = mergeRows(placed, winnerRow);
+  for (const row of rows)
+    row.remotes.sort((a, b) => Number(!claimsGlobally(a.name)) - Number(!claimsGlobally(b.name)));
+  const order = { share: 0, skip: 1, scope: 2 };
+  const newest = byTag(compare);
+  const versions = rows.sort((a, b) => newest(a, b) || order[a.action] - order[b.action]);
+  return { dirty: false, poolName: pool.poolName, versions };
 }
-function remotesInPool(members) {
-  return [
-    ...new Set(members.flatMap((m) => m.external.versions.flatMap((v) => v.remotes.map((r) => r.name))))
-  ];
+function movedRecord(external, remote, move, compare) {
+  return withoutStaleServingBuild(moveCopy(external, remote, move, compare));
 }
-function poolableScopes(repo) {
-  return repo.getScopes().filter((scope) => repo.scopeType(scope) !== "strict" && repo.hasPoolState(scope));
+function withoutStaleServingBuild(record) {
+  const { servingBuild, ...rest } = record;
+  if (servingBuild === void 0) return record;
+  const shares = record.versions.some(
+    (v) => v.action === "share" && v.remotes.some((r) => r.name === servingBuild)
+  );
+  return shares ? record : rest;
 }
-function syncPoolNames(sharedExternals, pools, repo, scope, skip = /* @__PURE__ */ new Set()) {
-  const named = /* @__PURE__ */ new Map();
-  for (const [name, members] of pools) for (const member of members) named.set(member.name, name);
-  for (const [name, external] of Object.entries(sharedExternals)) {
-    const pool = named.get(name);
-    if (pool !== void 0 && skip.has(pool)) continue;
-    if (external.poolName === pool) continue;
-    const { poolName: _stale, ...rest } = external;
-    repo.addOrUpdate(
-      name,
-      pool !== void 0 ? { ...rest, poolName: pool } : {
-        ...rest,
-        versions: external.versions.map((v) => ({
-          ...v,
-          remotes: v.remotes.map(({ poolCause: _cause, ...meta }) => meta)
-        }))
-      },
-      scope
-    );
-  }
+function moveCopy(external, remote, move, compare) {
+  if ("fromMap" in move) return recordFromMap(external, remote);
+  const moved = [];
+  const versions = external.versions.map((v) => {
+    const copy = v.remotes.find((r) => r.name === remote);
+    if (!copy) return v;
+    const { servedBy: _servedBy, ...rest } = copy;
+    const meta = { ...rest, cached: true, poolCause: move.cause };
+    if (v.action === "scope")
+      return { ...v, remotes: v.remotes.map((r) => r === copy ? meta : r) };
+    moved.push({ tag: v.tag, meta });
+    return { ...v, remotes: v.remotes.filter((r) => r !== copy) };
+  }).filter((v) => v.remotes.length > 0);
+  for (const { tag, meta } of moved) {
+    const scoped = rowAt(versions, tag, "scope");
+    if (!scoped) versions.push({ tag, action: "scope", host: false, remotes: [meta] });
+    else versions[versions.indexOf(scoped)] = { ...scoped, remotes: [...scoped.remotes, meta] };
+  }
+  return { ...external, versions: versions.sort(byTag(compare)) };
 }
-
-// src/lib/core/2.app/steps/pooling/pool-shared-externals.ts
-function islandedRemotes(members) {
-  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)
-          if (!islanded.has(remote.name))
-            islanded.set(remote.name, {
-              kind: "incompatible",
-              member: member.name,
-              tag: version.tag
-            });
-      }
-  return islanded;
+function recordFromMap(external, remote) {
+  const opened = external.versions.find(
+    (v) => v.action !== "skip" && v.remotes.some((r) => r.name === remote)
+  );
+  const meta = { ...opened.remotes.find((r) => r.name === remote), cached: false };
+  const joined = rowAt(external.versions, opened.tag, "skip");
+  const into = joined ? { ...joined, remotes: [...joined.remotes] } : { ...opened, action: "skip", remotes: [] };
+  addRemoteToVersion(into, meta);
+  const versions = external.versions.flatMap((v) => {
+    if (v === joined) return [into];
+    if (v !== opened) return [v];
+    const left = { ...v, remotes: v.remotes.filter((r) => r.name !== remote) };
+    return [...left.remotes.length > 0 ? [left] : [], ...joined ? [] : [into]];
+  });
+  return { ...external, versions };
 }
-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;
+function withoutPoolResults(external) {
+  const { poolName: _poolName, poolWinner: _poolWinner, ...rest } = external;
+  return {
+    ...rest,
+    versions: external.versions.map((v) => ({
+      ...v,
+      remotes: v.remotes.map(({ servedBy: _servedBy, poolCause: _poolCause, ...meta }) => meta)
+    }))
+  };
 }
-var anyVerdictStored = (members) => members.some(
-  (m) => m.external.versions.some(
-    (v) => v.remotes.some((r) => r.servedBy !== void 0 || r.poolCause !== 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;
-      }
-    }
-    if (!witnessed) {
-      torn.push({
-        remote,
-        combination: [...resolved].map(([specifier, tag]) => `${specifier}@${tag}`).join(", ")
-      });
-    }
-  }
-  return torn;
+function renamedRecords(scope, pools) {
+  const renamed = [];
+  for (const [poolName, members] of pools)
+    for (const { name } of members)
+      if (scope[name].poolName !== poolName) renamed.push([name, { ...scope[name], poolName }]);
+  return renamed;
 }
-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 };
+
+// src/lib/core/1.domain/pooling/plan.ts
+function planElection(scope, poolable) {
+  if (!poolable || !Object.values(scope).some((external) => external.dirty) || !scopeHasPoolState(scope))
+    return { pools: /* @__PURE__ */ new Map(), stripped: /* @__PURE__ */ new Map(), labelledAlone: [], packageOf: npmPackageOf };
+  const { pools, labelledAlone, packageOf } = buildPools(scope);
+  const pooled = new Set([...pools.values()].flatMap((members) => members.map((m) => m.name)));
+  const stripped = /* @__PURE__ */ new Map();
+  for (const [name, external] of Object.entries(scope))
+    if (!pooled.has(name) && hasPoolResults(external))
+      stripped.set(name, { ...withoutPoolResults(external), dirty: true });
+  return { pools, stripped, labelledAlone, packageOf };
 }
+
+// src/lib/core/2.app/steps/pooling/pool-shared-externals.ts
 function createPoolSharedExternals(config, ports) {
-  return (touched) => {
-    for (const scope of poolableScopes(ports.sharedExternalsRepo)) {
-      const touchedInScope = touched?.get(scope);
-      if (touched && !touchedInScope) continue;
-      const sharedExternals = ports.sharedExternalsRepo.getFromScope(scope);
+  const { compare } = ports.versionCheck;
+  return () => {
+    const repo = ports.sharedExternalsRepo;
+    for (const scope of repo.getScopes()) {
+      const sharedExternals = repo.getFromScope(scope);
       try {
-        const pools = buildPools(sharedExternals, config.log);
-        const rebuilt = /* @__PURE__ */ new Set();
-        for (const [poolName, members] of pools) {
-          if (touchedInScope && !members.some((m) => touchedInScope.has(m.name))) continue;
-          if (poolFamily(poolName, members, scope)) rebuilt.add(poolName);
-        }
-        syncPoolNames(sharedExternals, pools, ports.sharedExternalsRepo, scope, rebuilt);
+        const plan = planElection(sharedExternals, repo.scopeType(scope) !== "strict");
+        logPlan(plan, sharedExternals, scope);
+        for (const [poolName, members] of plan.pools)
+          for (const [name, record] of poolRecords(poolName, members, plan.packageOf, scope))
+            repo.addOrUpdate(name, record, scope);
+        for (const [name, external] of plan.stripped) repo.addOrUpdate(name, external, scope);
       } catch (error) {
         if (error instanceof NFError) return Promise.reject(error);
         config.log.error(3, `[${scope}] failed to pool shared externals.`, {
@@ -2490,253 +2538,440 @@ function createPoolSharedExternals(config, ports) {
     }
     return Promise.resolve();
   };
-  function poolFamily(poolName, members, scope) {
-    if (members.length < 2) return false;
-    const allRemotes = remotesInPool(members);
-    if (allRemotes.length < 2) {
-      if (!anyVerdictStored(members)) return false;
-      const basis2 = basisFor(members, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
-      for (const member of members)
-        ports.sharedExternalsRepo.addOrUpdate(
-          member.name,
-          rebuildMember(poolName, member, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), basis2.get(member.name)),
-          scope
-        );
-      return true;
-    }
-    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, incompatible={${[...islanded.keys()].join(", ") || "\u2205"}}
-` + members.map((m) => `  - ${m.name}`).join("\n")
-    );
-    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 && !anyVerdictStored(members)) return false;
-    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());
+  function logPlan(plan, sharedExternals, scope) {
+    if (plan.pools.size > 0) {
+      const dirty = Object.values(sharedExternals).filter((external) => external.dirty).length;
+      config.log.debug(
+        3,
+        `[${scope}] re-electing ${plan.pools.size} pool(s): ${dirty} dirty external(s).`
+      );
     }
-    const incompatible = [...islanded].filter(([, cause]) => cause.kind === "incompatible").map(([remote]) => remote);
-    if (config.strict.strictExternalCompatibility && incompatible.length > 0) {
+    if (plan.stripped.size > 0)
+      config.log.debug(
+        3,
+        `[${scope}] ${plan.stripped.size} external(s) left every pool; cleared their pool state for re-election.`
+      );
+    for (const name of plan.labelledAlone)
+      config.log.debug(
+        3,
+        `[${scope}] '${name}' has a 'pool' label that joins no other external; likely a typo or a missing sibling.`
+      );
+  }
+  function poolRecords(poolName, members, packageOf, scope) {
+    const election = elect({
+      members,
+      packageOf,
+      acceptsTag: createAcceptsTag(ports.versionCheck.isCompatible, compare),
+      compare,
+      previousWinner: previousWinner(members),
+      latestFirst: config.profile.latestSharedExternal
+    });
+    const placed = { ...election, poolName };
+    report(poolName, members, placed, scope);
+    return members.map((m) => [
+      m.name,
+      { ...memberRecord(m, placed, compare), poolWinner: placed.winner }
+    ]);
+  }
+  function report(poolName, members, placed, scope) {
+    const { misses } = placed;
+    const rejecting = [...misses].filter(([, miss]) => miss?.cause === "incompatible" && miss.strict).map(([remote]) => remote);
+    if (config.strict.strictExternalCompatibility && rejecting.length > 0) {
       config.log.error(
         3,
-        `[${scope}][pool:${poolName}] version-incompatible remotes cannot be pooled: {${incompatible.join(", ")}}.`
+        `[${scope}][pool:${poolName}] version-incompatible remotes cannot be pooled: {${rejecting.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(poolName, member, islanded, served, basis.get(member.name));
-      warnIfScopedOnly(poolName, member, rebuilt, islanded, scope);
-      ports.sharedExternalsRepo.addOrUpdate(member.name, rebuilt, scope);
-    }
-    return true;
-  }
-  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);
+    const subpoolSizes = /* @__PURE__ */ new Map();
+    for (const placement of placed.placements.values())
+      if (placement.kind === "subpool")
+        subpoolSizes.set(placement.owner, (subpoolSizes.get(placement.owner) ?? 0) + 1);
+    let shipped;
+    for (const [remote, miss] of misses) {
+      if (miss === void 0) {
+        config.log.warn(
+          3,
+          `[${scope}][pool:${poolName}] '${remote}' keeps subpool '${remote}': the elected build would serve it, but ${subpoolSizes.get(remote) - 1} other remote(s) in it need its build.`
+        );
+        continue;
       }
-      if (!scoped) return serving;
+      shipped ??= copiesByRemote(members);
+      const counts = {
+        imports: specifierCount(shipped.get(remote)),
+        subpoolSize: subpoolSizes.get(remote) ?? 0
+      };
+      config.log.warn(
+        3,
+        `[${scope}][pool:${poolName}] ${missWarning(remote, miss, placed, counts)}`
+      );
     }
   }
-  function warnIfScopedOnly(poolName, member, rebuilt, islanded, scope) {
-    if (rebuilt.versions.some((v) => v.action === "share")) return;
-    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}] '${member.name}' is scoped-only \u2014 no coherent shared build provides it; ${consumers} remotes download their own copy.`
-    );
+}
+function missWarning(remote, miss, placed, counts) {
+  const { imports, subpoolSize } = counts;
+  const placement = placed.placements.get(remote);
+  const where = placement.kind === "subpool" && placement.owner !== remote ? `It runs in subpool '${placement.owner}' for all ${imports} of its entrypoints.` : subpoolSize > 1 ? `Its build serves subpool '${remote}': its ${imports} entrypoints and ${subpoolSize - 1} other remote(s).` : `All ${imports} of its entrypoints are scoped for it.`;
+  if (miss.cause === "incompatible")
+    return `'${remote}' is islanded: its range rejects '${miss.member}@${miss.tag}' of the elected build '${placed.winner}'. ${where}`;
+  if (miss.unshipped)
+    return `'${remote}' serves its own family: no build shipped its entrypoints together at the elected versions (gap '${miss.gap}', closest '${placed.winner}'). ${where}`;
+  return `'${remote}' serves its own family: no elected build offers every entrypoint it imports at a version it accepts (gap '${miss.gap}', closest '${placed.winner}'). ${where}`;
+}
+
+// src/lib/core/1.domain/externals/serving.ts
+var byServingRank = (a, b) => Number(b.host) - Number(a.host) || a.downloads - b.downloads || a.fallbacks - b.fallbacks || Number(b.rootBasis) - Number(a.rootBasis) || compareStrings(a.remote, b.remote);
+var packagesOf = (scope) => groupByPackage(Object.keys(scope), (name) => name, packageOfIn(scope));
+var isPooled = (externals) => externals.some(([, e]) => e.poolName !== void 0);
+function servingBuildOf(pkg, externals, accepts) {
+  if (externals.length === 0) return void 0;
+  const rootRows = shareRows(externals.find(([name]) => name === pkg)?.[1]).filter(
+    (row) => row.remotes.some((copy) => pkg in copy.entries)
+  );
+  const rows = rootRows.length > 0 ? rootRows : externals.flatMap(([, e]) => shareRows(e));
+  if (isPooled(externals)) return pooledBuild(externals, rows);
+  const consumers = consumersOf(externals);
+  const builds = buildsOf(rows, rootRows, consumers);
+  const hosts = builds.filter((b) => b.host);
+  const field = hosts.length > 0 ? hosts : builds;
+  if (field.length <= 1) return field[0] && { remote: field[0].remote, tag: field[0].tag };
+  return cheapestBuild(field, costTable(consumers, accepts));
+}
+function cheapestBuild(field, costOf) {
+  let best;
+  for (const b of field) {
+    const { downloads, fallbacks } = costOf(b);
+    const candidate = {
+      remote: b.remote,
+      tag: b.tag,
+      host: b.host,
+      rootBasis: b.rootBasis,
+      downloads,
+      fallbacks
+    };
+    if (!best || byServingRank(candidate, best) < 0) best = candidate;
   }
-  function rebuildMember(poolName, 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);
+  const { remote, tag } = best;
+  return { remote, tag };
+}
+function shareServingCopies(external, serving) {
+  for (const row of external.versions) {
+    const copy = row.remotes.find((c) => c.name === serving.remote);
+    if (row.action !== "skip" || !copy || rowAt(external.versions, row.tag, "share")) continue;
+    row.action = "share";
+    if (row.remotes[0] !== copy) row.host = false;
+    row.remotes = [copy, ...row.remotes.filter((c) => c !== copy)];
+  }
+}
+function followServingBuild(external, serving, accepts) {
+  let objector;
+  const rebuilt = external.versions.flatMap((version) => {
+    if (version.action !== "share" || version.tag === serving.tag || version.remotes[0].name === serving.remote)
+      return [version];
+    const rows = redirectRow(version, serving.tag, accepts);
+    const scoped = rows.find((row) => row.action === "scope");
+    if (scoped && !objector) objector = { copy: scoped.remotes[0], tag: scoped.tag };
+    return rows;
+  });
+  external.versions = mergeRows(rebuilt);
+  return { external, objector };
+}
+var sameTagOnly = (offered, ownTag) => offered === ownTag;
+var servedScopes = (scope, strict) => strict ? strictTagScopes(scope) : [scope];
+function strictTagScopes(scope) {
+  const tagScopes = [];
+  for (const [pkg, names] of packagesOf(scope)) {
+    const byTag2 = /* @__PURE__ */ new Map();
+    for (const name of names)
+      for (const row of scope[name].versions) {
+        let tagScope = byTag2.get(row.tag);
+        if (!tagScope) byTag2.set(row.tag, tagScope = {});
+        const external = tagScope[name] ??= { ...scope[name], versions: [] };
+        external.versions.push({ ...row, remotes: [...row.remotes] });
       }
+    for (const [tag, tagScope] of byTag2) {
+      const lead = [tagScope[pkg], ...Object.values(tagScope)].map((external) => external && rowAt(external.versions, tag, "share")).find((row) => row !== void 0);
+      if (lead) {
+        const serving = { remote: lead.remotes[0].name, tag };
+        for (const external of Object.values(tagScope)) external.servingBuild = serving.remote;
+        scopeFallbacks(Object.entries(tagScope), serving, sameTagOnly);
+      }
+      tagScopes.push(tagScope);
     }
-    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;
-      delete entry.meta.poolCause;
-    }
-    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" }));
+  }
+  return tagScopes;
+}
+function shareRows(external) {
+  return external?.versions.filter((v) => v.action === "share") ?? [];
+}
+function buildsOf(rows, rootRows, consumers) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const row of rows)
+    for (const copy of row.remotes) {
+      const key = `${row.tag}|${copy.name}`;
+      if (copy.servedBy || candidates.has(key) || shipsTwoTags(consumers.get(copy.name))) continue;
+      const basis = copy === row.remotes[0];
+      candidates.set(key, {
+        remote: copy.name,
+        tag: row.tag,
+        host: basis && row.host,
+        rootBasis: basis && rootRows.includes(row)
+      });
     }
-    for (const entry of scoped)
-      entry.meta.poolCause = islanded.get(entry.remote)?.kind ?? "unshared";
-    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,
-        host: shareEntries[0].host,
-        action: "share",
-        remotes: shareEntries.map((e) => e.meta)
-      }
-    ] : [];
-    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 [...candidates.values()];
+}
+function pooledBuild(externals, rows) {
+  const winner = externals.find(([, e]) => e.poolWinner !== void 0)?.[1].poolWinner;
+  const shipped = rows.flatMap(
+    (row) => row.remotes.filter((copy) => !copy.servedBy).map((copy) => ({ remote: copy.name, tag: row.tag }))
+  );
+  const own = shipped.find((c) => c.remote === winner);
+  if (own) return own;
+  const width = ({ remote, tag }) => externals.reduce((n, [, e]) => {
+    const copy = shareRows(e).find((row) => row.tag === tag)?.remotes.find((c) => c.name === remote);
+    return n + Object.keys(copy?.entries ?? {}).length;
+  }, 0);
+  return shipped.map((c) => ({ c, width: width(c) })).sort((a, b) => b.width - a.width || compareStrings(a.c.remote, b.c.remote))[0]?.c;
+}
+function consumersOf(externals) {
+  const consumers = /* @__PURE__ */ new Map();
+  for (const [, external] of externals)
+    for (const row of external.versions)
+      for (const copy of row.remotes) {
+        const placed = consumers.get(copy.name);
+        if (placed) placed.push({ row, copy });
+        else consumers.set(copy.name, [{ row, copy }]);
       }
-      return [...versions.values()];
-    };
+  return consumers;
+}
+function costTable(consumers, accepts) {
+  const scanned = /* @__PURE__ */ new Map();
+  const keyed = /* @__PURE__ */ new Map();
+  const tollFor = (build, surface) => {
+    let atTag = scanned.get(build.tag);
+    if (!atTag) scanned.set(build.tag, atTag = []);
+    const known = atTag.find((t) => sameSurface(t.surface, surface));
+    if (known) return known.toll;
+    if (atTag.length < SCANNED_SURFACES_PER_TAG) {
+      const toll2 = tollOf(consumers, surface, build.tag, accepts);
+      atTag.push({ surface, toll: toll2 });
+      return toll2;
+    }
+    const key = [build.tag, ...[...surface].map(([s, tag]) => `${s}@${tag}`).sort()].join("\n");
+    let toll = keyed.get(key);
+    if (!toll) keyed.set(key, toll = tollOf(consumers, surface, build.tag, accepts));
+    return toll;
+  };
+  return (build) => {
+    const surface = surfaceOf(consumers, build);
+    const toll = tollFor(build, surface);
+    const others = (remotes) => remotes.size - Number(remotes.has(build.remote));
     return {
-      dirty: false,
-      poolName,
-      versions: [
-        ...shareVersion,
-        ...byTag(
-          clean.filter((e) => e.action === "skip"),
-          "skip"
-        ),
-        ...byTag(scoped, "scope")
-      ].sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
+      downloads: others(toll.downloads) + Number(!allCached(consumers.get(build.remote) ?? [])),
+      fallbacks: others(toll.fallbacks)
     };
-  }
+  };
 }
-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.`;
-    }
-  }
+function tollOf(consumers, surface, tag, accepts) {
+  const toll = { fallbacks: /* @__PURE__ */ new Set(), downloads: /* @__PURE__ */ new Set() };
+  for (const [remote, placed] of consumers) {
+    const fallback = fallsBack(placed, surface, tag, accepts);
+    if (fallback) toll.fallbacks.add(remote);
+    if (!allCached(placed) && (fallback || runsOffMap(placed, tag, accepts)))
+      toll.downloads.add(remote);
+  }
+  return toll;
 }
-
-// src/lib/core/2.app/steps/pooling/mark-pools-for-reelection.ts
-function clearPoolState(external) {
-  let cleared = external.poolName !== void 0;
-  delete external.poolName;
-  for (const version of external.versions)
-    for (const meta of version.remotes) {
-      if (meta.servedBy !== void 0 || meta.poolCause !== void 0) cleared = true;
-      delete meta.servedBy;
-      delete meta.poolCause;
+var allCached = (placed) => placed.every(({ copy }) => copy.cached);
+function fallbacksOf(externals, serving, accepts) {
+  const consumers = consumersOf(externals);
+  const surface = serving ? surfaceOf(consumers, serving) : /* @__PURE__ */ new Map();
+  return [...consumers].filter(
+    ([remote, placed]) => remote !== serving?.remote && fallsBack(placed, surface, serving?.tag, accepts)
+  ).map(([remote]) => remote);
+}
+function scopeFallbacks(externals, serving, accepts) {
+  const remotes = fallbacksOf(externals, serving, accepts);
+  for (const [, external] of externals)
+    external.versions = scopeRemotes(external.versions, remotes);
+}
+function strictObjectorOf(externals, serving, accepts) {
+  const consumers = consumersOf(externals);
+  const surface = surfaceOf(consumers, serving);
+  for (const [name, external] of externals)
+    for (const row of external.versions)
+      for (const copy of row.remotes)
+        if (copy.name !== serving.remote && rejectsServingTag({ row, copy }, surface, serving.tag, accepts) && !splitsPackage(consumers.get(copy.name), surface, serving.tag, accepts))
+          return { external: name, copy, tag: row.tag };
+  return void 0;
+}
+var SCANNED_SURFACES_PER_TAG = 8;
+function sameSurface(a, b) {
+  if (a.size !== b.size) return false;
+  for (const [specifier, tag] of a) if (b.get(specifier) !== tag) return false;
+  return true;
+}
+function surfaceOf(consumers, serving) {
+  const surface = /* @__PURE__ */ new Map();
+  for (const p of consumers.get(serving.remote) ?? [])
+    if (p.row.tag === serving.tag && onMap(p) || leadsShareRow(p)) {
+      for (const s in p.copy.entries) if (!surface.has(s)) surface.set(s, p.row.tag);
     }
-  return cleared;
+  return surface;
+}
+var leadsShareRow = ({ row, copy }) => row.action === "share" && row.remotes[0] === copy;
+var onMap = ({ row }) => row.action !== "scope";
+function splitsPackage(placed, surface, tag, accepts) {
+  const uncovered = (p) => Object.keys(p.copy.entries).some((s) => {
+    const servedAt = surface.get(s);
+    return servedAt === void 0 || servedAt !== tag && rejectsTag(p, servedAt, accepts);
+  });
+  return placed.some(onMap) && (shipsTwoTags(placed) || placed.some((p) => !onMap(p) || uncovered(p)));
 }
-function createMarkPoolsForReelection(config, ports) {
+function loadSplitsPackage(pkg, copies, claims, accepts) {
+  const root = claims.find(([specifier]) => specifier === pkg)?.[1];
+  const servingTag = root?.tag ?? claims[0][1].tag;
+  const surface = new Map(
+    claims.map(([specifier, { tag }]) => [specifier, root ? tag : servingTag])
+  );
+  const placed = copies.map(({ tag, copy }) => ({
+    row: { tag, action: "share", host: false, remotes: [copy] },
+    copy
+  }));
+  return splitsPackage(placed, surface, servingTag, accepts);
+}
+function fallsBack(placed, surface, tag, accepts) {
+  return splitsPackage(placed, surface, tag, accepts) || tag !== void 0 && placed.some((p) => rejectsServingTag(p, surface, tag, accepts));
+}
+function rejectsServingTag(p, surface, tag, accepts) {
+  return onMap(p) && rejectsTag(p, tag, accepts) && Object.keys(p.copy.entries).some((s) => surface.get(s) === tag);
+}
+var rejectsTag = ({ row, copy }, tag, accepts) => copy.strictVersion && !accepts(tag, row.tag, copy.requiredVersion);
+var shipsTwoTags = (placed) => !placed.some((p) => p.row.host && p.row.remotes[0] === p.copy) && placed.some((p) => p.row.tag !== placed[0].row.tag);
+function runsOffMap(placed, tag, accepts) {
+  return placed.some((p) => !onMap(p) || rejectsTag(p, tag, accepts));
+}
+
+// src/lib/core/2.app/steps/decide-serving-builds.ts
+function createDecideServingBuilds(config, ports) {
   return () => {
-    for (const scope of poolableScopes(ports.sharedExternalsRepo)) {
-      const sharedExternals = ports.sharedExternalsRepo.getFromScope(scope);
-      if (!Object.values(sharedExternals).some((external) => external.dirty)) continue;
-      let spread = 0;
-      let unpooled = 0;
-      const pooled = /* @__PURE__ */ new Set();
-      for (const [, members] of buildPools(sharedExternals)) {
-        for (const member of members) pooled.add(member.name);
-        if (!members.some((m) => m.external.dirty)) continue;
-        for (const member of members)
-          if (!member.external.dirty) {
-            member.external.dirty = true;
-            spread++;
-          }
-      }
-      for (const [name, external] of Object.entries(sharedExternals)) {
-        if (pooled.has(name) || !clearPoolState(external)) continue;
-        external.dirty = true;
-        unpooled++;
+    const accepts = createAcceptsTag(ports.versionCheck.isCompatible, ports.versionCheck.compare);
+    const repo = ports.sharedExternalsRepo;
+    const written = new Set(repo.uncommittedScopes());
+    const needsDeciding = (shareScope) => written.has(shareScope) || repo.isUndecided(shareScope);
+    try {
+      for (const shareScope of repo.getScopes()) {
+        if (repo.scopeType(shareScope) === "strict" || !needsDeciding(shareScope)) continue;
+        const sharedExternals = repo.getFromScope(shareScope);
+        for (const [pkg, names] of packagesOf(sharedExternals)) {
+          const externals = names.map((name) => [name, sharedExternals[name]]);
+          decidePackage(shareScope, pkg, externals, accepts);
+        }
+        repo.markDecided(shareScope);
       }
-      if (spread > 0)
-        config.log.debug(3, `[${scope}] ${spread} pool member(s) marked dirty for re-election.`);
-      if (unpooled > 0)
-        config.log.debug(
-          3,
-          `[${scope}] ${unpooled} external(s) left every pool; cleared their pool state for re-election.`
+      return Promise.resolve();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  function decidePackage(shareScope, pkg, externals, accepts) {
+    const serving = servingBuildOf(pkg, externals, accepts);
+    const before = externals.map(([, external]) => shapeOf(external));
+    const pooled = isPooled(externals);
+    const toFollow = pooled ? void 0 : serving;
+    if (!pooled) fallBack(pkg, externals, accepts, serving);
+    externals.forEach(([name, external], i) => {
+      const decided = withServingBuild(
+        toFollow ? follow(pkg, name, external, toFollow, accepts) : external,
+        serving?.remote
+      );
+      if (!sameShape(before[i], decided))
+        ports.sharedExternalsRepo.addOrUpdate(name, decided, shareScope);
+    });
+  }
+  function follow(pkg, name, external, serving, accepts) {
+    const { external: followed, objector } = followServingBuild(external, serving, accepts);
+    if (objector && config.strict.strictExternalCompatibility)
+      rejectIncompatible(config, objector.copy, `${name}@${objector.tag}`, `${pkg}@${serving.tag}`);
+    return followed;
+  }
+  function fallBack(pkg, externals, accepts, serving) {
+    if (serving) {
+      for (const [, external] of externals) shareServingCopies(external, serving);
+      const objector = config.strict.strictExternalCompatibility && strictObjectorOf(externals, serving, accepts);
+      if (objector)
+        rejectIncompatible(
+          config,
+          objector.copy,
+          `${objector.external}@${objector.tag}`,
+          `${pkg}@${serving.tag}`
         );
     }
-    return Promise.resolve();
+    scopeFallbacks(externals, serving, accepts);
+  }
+}
+function withServingBuild(external, servingBuild) {
+  if (external.servingBuild === servingBuild) return external;
+  const { servingBuild: _, ...rest } = external;
+  return servingBuild ? { ...rest, servingBuild } : rest;
+}
+var shapeOf = (external) => ({
+  servingBuild: external.servingBuild,
+  rows: external.versions.map(
+    ({ tag, action, host, remotes }) => ({ tag, action, host, remotes: [...remotes] })
+  )
+});
+var sameRow = (was, row) => Object.keys(was).every(
+  (key) => key === "remotes" ? was.remotes.length === row.remotes.length && row.remotes.every((copy, j) => copy === was.remotes[j]) : was[key] === row[key]
+);
+var sameShape = (shape, external) => shape.servingBuild === external.servingBuild && shape.rows.length === external.versions.length && external.versions.every((row, i) => sameRow(shape.rows[i], row));
+
+// src/lib/core/1.domain/externals/claims.ts
+function claimTable(externals, publishes) {
+  const table = { claims: /* @__PURE__ */ new Map(), duplicates: /* @__PURE__ */ new Set(), shareClaims: /* @__PURE__ */ new Map() };
+  const ordered = [...externals];
+  const claim = (into, external, version, accepts = publishes) => forEachVersionEntry(version, accepts, (specifier, copy) => {
+    if (!into.has(specifier)) into.set(specifier, { external, tag: version.tag, copy });
+  });
+  const seedServingBuild = (name, external) => {
+    const isServing = (copy) => copy.name === external.servingBuild && (!publishes || publishes(copy));
+    for (const version of external.versions) {
+      if (version.action !== "share") continue;
+      claim(table.shareClaims, name, version, isServing);
+      claim(table.claims, name, version, isServing);
+    }
+  };
+  const claimShareRow = (name, external, version) => {
+    const prior = table.claims.get(name);
+    const duplicate = prior !== void 0 && prior.tag !== version.tag;
+    if (duplicate && !(version.host && version.remotes[0].name === external.servingBuild))
+      table.duplicates.add(version);
+    if (external.servingBuild) return;
+    claim(table.shareClaims, name, version);
+    if (!duplicate && (!prior || prior.external === name)) claim(table.claims, name, version);
+  };
+  for (const [name, external] of ordered)
+    if (external.servingBuild) seedServingBuild(name, external);
+  for (const [name, external] of ordered)
+    for (const version of external.versions)
+      if (version.action === "share") claimShareRow(name, external, version);
+  return table;
+}
+function committedClaims(externals, { shareScope, without }) {
+  const publishes = (copy) => copy.name !== without && (shareScope !== GLOBAL_SCOPE || copy.cached);
+  return claimTable(externals, publishes).claims;
+}
+function versionClaims(version, servingBuild) {
+  const claims = /* @__PURE__ */ new Map();
+  const claim = (specifier, copy) => {
+    if (!claims.has(specifier)) claims.set(specifier, copy);
   };
+  const accepts = servingBuild ? (copy) => copy.name === servingBuild : void 0;
+  forEachVersionEntry(version, accepts, claim);
+  return claims;
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.7.0/node_modules/@softarc/native-federation/dist/lib/domain/core/build-notification-options.contract.js
+// node_modules/.pnpm/@softarc+native-federation@4.9.0/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";
@@ -2744,13 +2979,14 @@ var BuildNotificationType = /* @__PURE__ */ ((BuildNotificationType2) => {
   return BuildNotificationType2;
 })(BuildNotificationType || {});
 
-// node_modules/.pnpm/@softarc+native-federation@4.7.0/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
+// node_modules/.pnpm/@softarc+native-federation@4.9.0/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
 var CHUNK_PREFIX = "@nf-internal";
+var SCRIPT_EXTENSION = /\.(m|c)?js$/;
 function toChunkImport(fileName) {
   if (fileName.startsWith("./")) {
     fileName = fileName.slice(2);
   }
-  const packageName = fileName.replace(/.(m|c)?js$/, "");
+  const packageName = fileName.replace(SCRIPT_EXTENSION, "");
   return CHUNK_PREFIX + "/" + packageName;
 }
 
@@ -2761,8 +2997,8 @@ function createGenerateImportMap(config, ports) {
     const chunkBundles = {};
     try {
       addScopedExternals(importMap, chunkBundles);
-      addshareScopeExternals(importMap, chunkBundles);
-      addGlobalSharedExternals(importMap, chunkBundles);
+      addNamedShareScopes(importMap, chunkBundles);
+      addGlobalShareScope(importMap, chunkBundles);
       addRemoteInfos(importMap, chunkBundles);
       addChunkImports(importMap, chunkBundles);
       return Promise.resolve(importMap);
@@ -2796,47 +3032,61 @@ function createGenerateImportMap(config, ports) {
     }
     return modules;
   }
-  function addshareScopeExternals(importMap, chunkBundles) {
+  function addNamedShareScopes(importMap, chunkBundles) {
     const shareScopes = ports.sharedExternalsRepo.getScopes({ includeGlobal: false });
     for (const shareScope of shareScopes) {
-      processshareScope(importMap, shareScope, chunkBundles);
+      const sharedExternals = ports.sharedExternalsRepo.getFromScope(shareScope);
+      const cachedBefore = /* @__PURE__ */ new Map();
+      for (const [externalName, external] of Object.entries(sharedExternals))
+        cachedBefore.set(externalName, cachedFingerprint(external));
+      const strict = ports.sharedExternalsRepo.scopeType(shareScope) === "strict";
+      for (const served of servedScopes(sharedExternals, strict))
+        addShareScope(importMap, shareScope, served, chunkBundles);
+      for (const [externalName, external] of Object.entries(sharedExternals)) {
+        if (cachedFingerprint(external) !== cachedBefore.get(externalName)) {
+          ports.sharedExternalsRepo.addOrUpdate(externalName, external, shareScope);
+        }
+      }
     }
     return importMap;
   }
-  function processshareScope(importMap, shareScope, chunkBundles) {
-    const sharedExternals = ports.sharedExternalsRepo.getFromScope(shareScope);
+  function addShareScope(importMap, shareScope, sharedExternals, chunkBundles) {
     const index = buildServedIndex(sharedExternals);
+    const claims = shareRowMappings(sharedExternals, shareScope);
+    const claimedElsewhere = (externalName, specifier) => {
+      const claim = claims.get(specifier);
+      return claim?.external === externalName ? void 0 : claim;
+    };
     for (const [externalName, external] of Object.entries(sharedExternals)) {
       let override = void 0;
-      const cachedBefore = cachedFingerprint(external);
       for (const version of external.versions) {
         if (version.action === "scope") {
-          for (const remote of version.remotes) {
-            const remoteScope = getScope2(shareScope, remote.name, externalName);
-            for (const [packageName, file] of Object.entries(remote.entries)) {
-              const url = join(remoteScope, file);
-              addToScope(importMap, remoteScope, { [packageName]: url });
-              addIntegrity(importMap, url, remote.name, file);
-            }
-            registerBundleChunks(chunkBundles, remote.name, remote.bundle);
-            remote.cached = true;
-          }
+          addScopeRow(importMap, chunkBundles, shareScope, externalName, version);
           continue;
         }
-        version.remotes[0].cached = true;
         let serving = version;
         if (version.action === "skip") {
           if (!override) {
-            override = findOverride(external, shareScope, externalName) ?? "NOT_AVAILABLE";
+            override = findOverride(
+              external,
+              shareScope,
+              externalName,
+              (s) => Boolean(claimedElsewhere(externalName, s))
+            ) ?? "NOT_AVAILABLE";
           }
           if (override !== "NOT_AVAILABLE") {
             serving = override;
             version.remotes[0].cached = false;
           }
         }
-        const provided = versionEntries(serving);
+        const provided = versionClaims(serving, external.servingBuild);
         const mappings = [];
         for (const [packageName, provider] of provided) {
+          const claim = claimedElsewhere(externalName, packageName);
+          if (claim) {
+            mappings.push({ packageName, ...claim });
+            continue;
+          }
           const file = provider.entries[packageName];
           mappings.push({
             packageName,
@@ -2849,56 +3099,60 @@ function createGenerateImportMap(config, ports) {
             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)) {
+        version.remotes.forEach((consumer) => {
+          const consumerScope = getScope2(shareScope, consumer.name, externalName);
+          if (index && consumer.servedBy) {
+            const files = index.get(consumer.servedBy);
+            const servedScope = getScope2(shareScope, consumer.servedBy, externalName);
+            for (const specifier of Object.keys(consumer.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);
+              addToScope(importMap, consumerScope, { [specifier]: url });
+              addIntegrity(importMap, url, consumer.servedBy, source.file);
+              registerBundleChunks(chunkBundles, consumer.servedBy, source.bundle);
               source.meta.cached = true;
             }
             return;
           }
           for (const m of mappings) {
-            addToScope(importMap, rScope, { [m.packageName]: m.url });
+            addToScope(importMap, consumerScope, { [m.packageName]: m.url });
           }
-          for (const [packageName, file] of Object.entries(r.entries)) {
+          for (const packageName of Object.keys(consumer.entries)) {
             if (provided.has(packageName)) 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;
+            const claim = claimedElsewhere(externalName, packageName);
+            if (claim) addToScope(importMap, consumerScope, { [packageName]: claim.url });
           }
         });
         for (const m of mappings) {
           addIntegrity(importMap, m.url, m.name, m.file);
         }
       }
-      if (cachedFingerprint(external) !== cachedBefore) {
-        ports.sharedExternalsRepo.addOrUpdate(externalName, external, shareScope);
+    }
+  }
+  function addScopeRow(importMap, chunkBundles, shareScope, externalName, version) {
+    for (const remote of version.remotes) {
+      const remoteScope = getScope2(shareScope, remote.name, externalName);
+      for (const [packageName, file] of Object.entries(remote.entries)) {
+        const url = join(remoteScope, file);
+        addToScope(importMap, remoteScope, { [packageName]: url });
+        addIntegrity(importMap, url, remote.name, file);
       }
+      registerBundleChunks(chunkBundles, remote.name, remote.bundle);
+      remote.cached = true;
     }
   }
   function cachedFingerprint(external) {
     return external.versions.map((v) => v.remotes.map((r) => r.cached ? 1 : 0).join("")).join("|");
   }
-  function findOverride(external, shareScope, externalName) {
+  function findOverride(external, shareScope, externalName, servedElsewhere) {
     const sharedVersions = external.versions.filter((v) => v.action === "share");
     const scopedExternalName = `${shareScope}.${externalName}`;
     if (sharedVersions.length > 1) {
       handleMultipleSharedVersions(scopedExternalName);
     }
-    if (sharedVersions.length < 1) {
+    const servedByClaims = () => external.versions.filter((v) => v.action === "skip").every((v) => shipsOnly(v, servedElsewhere));
+    if (sharedVersions.length < 1 && !servedByClaims()) {
       if (config.strict.strictImportMap) {
         config.log.error(4, `[${shareScope}][${externalName}] shareScope has no override version.`);
         throw new NFError("Could not create ImportMap.");
@@ -2943,17 +3197,30 @@ function createGenerateImportMap(config, ports) {
     }
     return index;
   }
-  function collectServed(into, index, ctx, externalName, version) {
+  function shareRowMappings(externals, shareScope) {
+    const mappings = /* @__PURE__ */ new Map();
+    for (const [specifier, { external, copy }] of claimTable(Object.entries(externals)).shareClaims) {
+      const file = copy.entries[specifier];
+      mappings.set(specifier, {
+        url: join(getScope2(shareScope, copy.name, external), file),
+        name: copy.name,
+        file,
+        external
+      });
+    }
+    return mappings;
+  }
+  function collectServed(into, index, shareScope, 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);
+      const scope = getScope2(shareScope, 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}'.`
+            `[${shareScope}][${externalName}][${consumer.name}] '${consumer.servedBy}' does not serve '${specifier}'.`
           );
           continue;
         }
@@ -2971,9 +3238,11 @@ function createGenerateImportMap(config, ports) {
       source.meta.cached = true;
     }
   }
-  function addGlobalSharedExternals(importMap, chunkBundles) {
+  function addGlobalShareScope(importMap, chunkBundles) {
     const sharedExternals = ports.sharedExternalsRepo.getFromScope();
     const index = buildServedIndex(sharedExternals);
+    const { claims, duplicates } = claimTable(Object.entries(sharedExternals));
+    const claimed = claimsByCopy(claims);
     const served = [];
     const cachedBefore = /* @__PURE__ */ new Map();
     for (const [externalName, external] of Object.entries(sharedExternals)) {
@@ -2984,27 +3253,14 @@ function createGenerateImportMap(config, ports) {
         }
         if (version.action === "skip") continue;
         if (version.action === "scope") {
-          for (const remote of version.remotes) {
-            const remoteScope = getScope2(GLOBAL_SCOPE, remote.name, externalName);
-            for (const [packageName, file] of Object.entries(remote.entries)) {
-              const url = join(remoteScope, file);
-              addToScope(importMap, remoteScope, { [packageName]: url });
-              addIntegrity(importMap, url, remote.name, file);
-            }
-            remote.cached = true;
-            registerBundleChunks(chunkBundles, remote.name, remote.bundle);
-          }
+          addScopeRow(importMap, chunkBundles, GLOBAL_SCOPE, externalName, version);
           continue;
         }
-        if (importMap.imports[externalName]) {
+        if (duplicates.has(version)) {
           notifyDuplicateGlobalExternal(externalName);
           continue;
         }
-        mergeVersionEntries(importMap, chunkBundles, externalName, version);
-      }
-      for (const version of external.versions) {
-        if (version.action !== "skip") continue;
-        selfFillUncovered(importMap, chunkBundles, externalName, version.remotes);
+        publishClaims(importMap, chunkBundles, externalName, version, claimed);
       }
     }
     flushServed(importMap, chunkBundles, served);
@@ -3015,54 +3271,30 @@ function createGenerateImportMap(config, ports) {
     }
     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 claimsByCopy(claims) {
+    const claimed = /* @__PURE__ */ new Map();
+    for (const [specifier, { copy }] of claims) {
+      const specifiers = claimed.get(copy);
+      if (specifiers) specifiers.push(specifier);
+      else claimed.set(copy, [specifier]);
     }
-  }
-  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);
+    return claimed;
+  }
+  function publishClaims(importMap, chunkBundles, externalName, version, claimed) {
+    for (const copy of version.remotes) {
+      const specifiers = claimed.get(copy);
+      if (!specifiers) continue;
+      const scope = getScope2(GLOBAL_SCOPE, copy.name, externalName);
+      registerBundleChunks(chunkBundles, copy.name, copy.bundle);
+      copy.cached = true;
+      for (const specifier of specifiers) {
+        const file = copy.entries[specifier];
         const url = join(scope, file);
-        addToGlobal(importMap, { [packageName]: url });
-        addIntegrity(importMap, url, remote.name, file);
-        registerBundleChunks(chunkBundles, remote.name, remote.bundle);
-        remote.cached = true;
+        addToGlobal(importMap, { [specifier]: url });
+        addIntegrity(importMap, url, copy.name, file);
       }
     }
   }
-  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.`);
@@ -3136,15 +3368,30 @@ function createGenerateImportMap(config, ports) {
     });
   }
 }
+function shipsOnly(version, served) {
+  let only = true;
+  forEachVersionEntry(version, void 0, (specifier) => {
+    only &&= served(specifier);
+  });
+  return only;
+}
 
 // src/lib/core/2.app/steps/commit-changes.ts
 function createCommitChanges(config, ports) {
-  return (importMap, opts = {}) => Promise.resolve(importMap).then((map) => addToBrowser(map, opts)).then(persistRepositoryChanges);
+  return (importMap, { markUndecided = false, ...browserOpts } = {}) => Promise.resolve(importMap).then((map) => addToBrowser(map, browserOpts)).then(() => {
+    if (markUndecided) markUndecidedScopes();
+    persistRepositoryChanges();
+  });
   function addToBrowser(importMap, opts) {
     ports.browser.setImportMapFn(importMap, opts);
     config.log.debug(5, "Added import map to browser.", importMap);
     return importMap;
   }
+  function markUndecidedScopes() {
+    const repo = ports.sharedExternalsRepo;
+    for (const shareScope of repo.uncommittedScopes())
+      if (repo.scopeType(shareScope) !== "strict") repo.markUndecided(shareScope);
+  }
   function persistRepositoryChanges() {
     ports.remoteInfoRepo.commit();
     ports.scopedExternalsRepo.commit();
@@ -3154,6 +3401,29 @@ function createCommitChanges(config, ports) {
   }
 }
 
+// src/lib/core/2.app/steps/rollback-changes.ts
+var createStateDump = (config, ports) => (msg) => config.log.debug(0, msg, {
+  remotes: { ...ports.remoteInfoRepo.getAll() },
+  "shared-externals": ports.sharedExternalsRepo.getScopes({ includeGlobal: true }).reduce(
+    (acc, scope) => ({ ...acc, [scope]: ports.sharedExternalsRepo.getFromScope(scope) }),
+    {}
+  ),
+  "scoped-externals": ports.scopedExternalsRepo.getAll()
+});
+function createRollbackChanges(config, ports) {
+  const stateDump = createStateDump(config, ports);
+  return (label) => Promise.resolve().then(() => {
+    try {
+      stateDump(`${label} STATE DUMP`);
+    } finally {
+      ports.remoteInfoRepo.rollback();
+      ports.scopedExternalsRepo.rollback();
+      ports.sharedExternalsRepo.rollback();
+      ports.sharedChunksRepo.rollback();
+    }
+  });
+}
+
 // src/lib/core/2.app/steps/expose-module-loader.ts
 function createExposeModuleLoader(config, ports) {
   const loadRemoteModule = (remoteName, exposedModule) => {
@@ -3228,10 +3498,16 @@ var normalizeRemoteRef = (remote) => {
 function createGetRemoteEntry(config, ports) {
   return async (remoteEntryUrl, remote) => {
     const { name: remoteName, integrity } = normalizeRemoteRef(remote);
-    if (!!remoteName && shouldSkipCachedRemote(remoteEntryUrl, remoteName)) {
-      config.log.debug(7, `Found remote '${remoteName}' in storage, omitting fetch.`);
+    const knownAtUrl = findCachedRemoteAt(remoteEntryUrl);
+    if (knownAtUrl) {
+      config.log.debug(
+        7,
+        `Found remote '${knownAtUrl}' at '${remoteEntryUrl}' in storage, omitting fetch.`
+      );
       return Optional.empty();
     }
+    if (!!remoteName && ports.remoteInfoRepo.contains(remoteName))
+      return warnInitialized(remoteName, remoteEntryUrl);
     try {
       const remoteEntry = integrity ? await ports.remoteEntryProvider.provide(remoteEntryUrl, { integrity }) : await ports.remoteEntryProvider.provide(remoteEntryUrl);
       config.log.debug(
@@ -3246,10 +3522,8 @@ function createGetRemoteEntry(config, ports) {
         }
         config.log.warn(7, errorMsg + " Omitting expected name.");
       }
-      if (ports.remoteInfoRepo.contains(remoteEntry.name)) {
-        remoteEntry.override = true;
-        config.log.debug(7, `Overriding existing remote '${remoteName}' with '${remoteEntryUrl}'.`);
-      }
+      if (ports.remoteInfoRepo.contains(remoteEntry.name))
+        return warnInitialized(remoteEntry.name, remoteEntryUrl);
       return Optional.of(checkForSSE(remoteEntry));
     } catch (error) {
       config.log.error(
@@ -3262,10 +3536,18 @@ function createGetRemoteEntry(config, ports) {
       );
     }
   };
-  function shouldSkipCachedRemote(remoteEntryUrl, remoteName) {
-    return ports.remoteInfoRepo.tryGet(remoteName).map(
-      (cachedRemoteInfo) => config.profile.overrideCachedRemotes !== "always" || !config.profile.overrideCachedRemotesIfURLMatches && remoteEntryUrl === join(cachedRemoteInfo.scopeUrl, "remoteEntry.json")
-    ).orElse(false);
+  function warnInitialized(name, remoteEntryUrl) {
+    const initializedFrom = ports.remoteInfoRepo.tryGet(name).map((info) => join(info.scopeUrl, "remoteEntry.json")).get();
+    config.log.warn(
+      7,
+      `[${name}] Already initialized from '${initializedFrom}', ignoring '${remoteEntryUrl}'.`
+    );
+    return Optional.empty();
+  }
+  function findCachedRemoteAt(remoteEntryUrl) {
+    return Object.entries(ports.remoteInfoRepo.getAll()).find(
+      ([, info]) => join(info.scopeUrl, "remoteEntry.json") === remoteEntryUrl
+    )?.[0];
   }
   function checkForSSE(entry) {
     if (config.sse) {
@@ -3285,92 +3567,184 @@ 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);
+  const accepts = createAcceptsTag(
+    (tag, range) => ports.versionCheck.isCompatible(tag, range),
+    (a, b) => ports.versionCheck.compare(a, b)
+  );
   return (remoteEntry) => {
     try {
+      const pending = [];
+      storeRemoteEntry(remoteEntry, (_, external, ctx) => pending.push({ external, ctx }));
+      const decisions = decidePackages(remoteEntry, pending);
       const actions = {};
-      if (remoteEntry?.override) removeCachedRemoteEntries(/* @__PURE__ */ new Set([remoteEntry.name]));
-      storeRemoteEntry(remoteEntry, (entry, external, ctx) => {
-        const { action, provided, sameVersion } = resolveSharedExternal(entry, external, ctx);
-        actions[external.packageName] = { action };
-        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
-            );
-          }
-        }
-      });
+      for (const item of pending)
+        actions[item.external.packageName] = applyDecision(remoteEntry, item, decisions.get(item));
       return Promise.resolve({ entry: remoteEntry, actions });
     } catch (error) {
       return Promise.reject(error);
     }
   };
-  function resolveSharedExternal(remoteEntry, sharedInfo, {
-    tag,
-    remote,
-    cached,
-    scopeType,
-    assertSameVersionCompatibility,
-    commit
-  }) {
-    let action = scopeType === "strict" ? "share" : "skip";
-    const sharedVersion = cached.versions.find((c) => c.action === "share");
-    const isCompatible = !sharedVersion || ports.versionCheck.isCompatible(sharedVersion.tag, remote.requiredVersion);
-    if (action === "skip" && !isCompatible && remote.strictVersion) {
-      action = "scope";
-      const errorMsg = `[${sharedInfo.shareScope ?? GLOBAL_SCOPE}][${remoteEntry.name}] ${sharedInfo.packageName}@${sharedInfo.version} Is not compatible with existing ${sharedInfo.packageName}@${sharedVersion.tag} requiredRange '${sharedVersion.remotes[0]?.requiredVersion}'`;
-      if (config.strict.strictExternalCompatibility) {
-        config.log.error(8, errorMsg);
-        throw new NFError(`Could not process remote '${remoteEntry.name}'`);
-      }
-      config.log.warn(8, errorMsg);
+  function decidePackages(remoteEntry, pending) {
+    const decisions = /* @__PURE__ */ new Map();
+    const viewOf = loadViewOf(remoteEntry, pending);
+    for (const group of pendingPerPackage(pending, viewOf)) {
+      const decision = group[0].ctx.scopeType === "strict" ? { action: "share" } : decidePackage(remoteEntry, group, viewOf(group[0].external.shareScope));
+      for (const item of group) decisions.set(item, decision);
     }
-    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";
-        }
+    scopeOpenedPackages(decisions);
+    return decisions;
+  }
+  function pendingPerPackage(pending, viewOf) {
+    const packages = /* @__PURE__ */ new Map();
+    for (const item of pending) {
+      const { shareScope, packageName } = item.external;
+      const pkg = item.ctx.scopeType === "strict" ? packageName : viewOf(shareScope).packageOf(packageName);
+      const key = `${shareScope ?? GLOBAL_SCOPE}\0${pkg}`;
+      const group = packages.get(key);
+      if (group) group.push(item);
+      else packages.set(key, [item]);
+    }
+    return [...packages.values()];
+  }
+  function loadViewOf(remoteEntry, pending) {
+    const views = /* @__PURE__ */ new Map();
+    return (shareScope) => {
+      const scope = shareScope ?? GLOBAL_SCOPE;
+      let view = views.get(scope);
+      if (!view) {
+        const record = ports.sharedExternalsRepo.getFromScope(shareScope);
+        const claims = committedClaims(Object.entries(record), {
+          shareScope: scope,
+          without: remoteEntry.name
+        });
+        const packageOf = packageOfIn(record, loadingIn(pending, scope));
+        const claimsIn = groupByPackage(claims, ([specifier]) => specifier, packageOf);
+        let pooled;
+        view = {
+          packageOf,
+          claims,
+          claimsOf: (pkg) => claimsIn.get(pkg) ?? [],
+          inPool: (pkg) => {
+            pooled ??= pooledPackagesWith(record, labelledCopiesIn(pending, scope), packageOf);
+            return pooled.has(pkg);
+          }
+        };
+        views.set(scope, view);
       }
+      return view;
+    };
+  }
+  function inScope(pending, scope) {
+    return pending.filter(({ external }) => (external.shareScope ?? GLOBAL_SCOPE) === scope);
+  }
+  function loadingIn(pending, scope) {
+    return inScope(pending, scope).map(({ external, ctx }) => [external.packageName, ctx.remote]);
+  }
+  function labelledCopiesIn(pending, scope) {
+    return inScope(pending, scope).map(({ external, ctx }) => ({
+      name: external.packageName,
+      pool: ctx.remote.pool
+    }));
+  }
+  function scopeOpenedPackages(decisions) {
+    if (![...decisions.values()].some((d) => d.action === "scope" && d.partlyServed)) return;
+    for (const [item, decision] of decisions)
+      if (decision.action === "share" && item.ctx.scopeType !== "strict")
+        decisions.set(item, { action: "scope", partlyServed: false });
+  }
+  function decidePackage(remoteEntry, group, view) {
+    const pkg = view.packageOf(group[0].external.packageName);
+    const claims = view.claimsOf(pkg);
+    if (claims.length === 0) return { action: "share" };
+    const specifiers = group.flatMap(({ external }) => Object.keys(external.entries));
+    const builds = specifiers.every((specifier) => view.claims.has(specifier)) ? new Set(specifiers.map((specifier) => view.claims.get(specifier).copy.name)) : void 0;
+    const rejections = group.flatMap((item) => rejectionsOf(item, view.claims));
+    if (rejections.length > 0) {
+      const copies = group.map(({ ctx }) => ({ tag: ctx.tag, copy: ctx.remote }));
+      const splits = builds !== void 0 && builds.size > 1 || loadSplitsPackage(pkg, copies, claims, accepts);
+      for (const rejection of refused(rejections, splits, view.inPool(pkg)))
+        reportIncompatible(remoteEntry, rejection);
+      return { action: "scope", partlyServed: false };
     }
-    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);
-      addRemoteToVersion(matchingVersion, remote);
-    } else {
-      if (!sharedVersion) action = "share";
-      remote.cached = action !== "skip";
-      cached.versions.push({ tag, action, host: false, remotes: [remote] });
+    if (!builds || builds.size > 1) return { action: "scope", partlyServed: true };
+    return { action: "skip", files: servingFiles(claims, builds) };
+  }
+  function servingFiles(claims, builds) {
+    const files = /* @__PURE__ */ new Map();
+    for (const [specifier, { copy }] of claims)
+      if (builds.has(copy.name)) files.set(specifier, copy);
+    return files;
+  }
+  function rejectionsOf(item, claims) {
+    const { external, ctx } = item;
+    if (!ctx.remote.strictVersion) return [];
+    return Object.keys(external.entries).flatMap((specifier) => {
+      const claim = claims.get(specifier);
+      return claim && !accepts(claim.tag, ctx.tag, ctx.remote.requiredVersion) ? [{ item, specifier, claim }] : [];
+    });
+  }
+  function refused(rejections, splits, pooled) {
+    const first = /* @__PURE__ */ new Map();
+    for (const rejection of rejections)
+      if (!first.has(rejection.item) && (pooled || !splits || electionKeeps(rejection)))
+        first.set(rejection.item, rejection);
+    return [...first.values()];
+  }
+  function electionKeeps({ item: { external, ctx }, claim }) {
+    if (claim.external !== external.packageName) return false;
+    const versions = ports.sharedExternalsRepo.tryGet(claim.external, external.shareScope).get()?.versions ?? [];
+    const strict = [
+      { tag: ctx.tag, copy: ctx.remote },
+      ...versions.flatMap(
+        (v) => v.remotes.filter((r) => r.strictVersion).map((copy) => ({ tag: v.tag, copy }))
+      )
+    ];
+    const tags = [ctx.tag, ...versions.map((v) => v.tag)];
+    if (!tags.some((tag) => strict.every((s) => accepts(tag, s.tag, s.copy.requiredVersion))))
+      return true;
+    const host = versions.find((v) => v.host);
+    if (host) return host.tag === claim.tag;
+    if (!config.profile.latestSharedExternal) return false;
+    return tags.every((tag) => ports.versionCheck.compare(claim.tag, tag) >= 0);
+  }
+  function reportIncompatible(remoteEntry, { item: { external, ctx }, specifier, claim }) {
+    const errorMsg = `[${external.shareScope ?? GLOBAL_SCOPE}][${remoteEntry.name}] ${specifier}@${ctx.tag} Is not compatible with existing ${specifier}@${claim.tag} requiredRange '${ctx.remote.requiredVersion}'`;
+    if (config.strict.strictExternalCompatibility) {
+      config.log.error(8, errorMsg);
+      throw new NFError(`Could not process remote '${remoteEntry.name}'`);
     }
-    commit();
-    return { action, provided, sameVersion };
+    config.log.warn(8, errorMsg);
+  }
+  function applyDecision(remoteEntry, { external, ctx }, decision) {
+    storeCopy(ctx, decision.action);
+    if (decision.action !== "skip") return { action: decision.action };
+    const covered = Object.keys(external.entries);
+    if (!external.shareScope) return { action: "skip", covered };
+    return {
+      action: "skip",
+      covered,
+      override: overrideFrom(remoteEntry, external, decision.files)
+    };
   }
-  function resolveOverrideEntries(remoteEntry, external, provided) {
+  function storeCopy(ctx, action) {
+    const { tag, remote } = ctx;
+    const cached = ctx.readRecord();
+    const shared = cached.versions.find((v) => v.tag === tag && v.action === "share");
+    if (shared && action !== "scope") ctx.assertSameVersionCompatibility(shared);
+    remote.cached = action !== "skip";
+    const row = action === "share" ? shared : cached.versions.find((v) => v.tag === tag && v.action === action);
+    const loaderServes = action === "share" && ctx.scopeType !== "strict";
+    if (!row) cached.versions.push({ tag, action, host: false, remotes: [remote] });
+    else if (loaderServes) addRemoteToVersion(row, remote);
+    else row.remotes.push(remote);
+    if (loaderServes) cached.servingBuild = remote.name;
+    ctx.write();
+  }
+  function overrideFrom(remoteEntry, external, files) {
     return Object.fromEntries(
-      Array.from(provided, ([packageName, provider]) => [
-        packageName,
-        join(
-          providerScopeUrl(remoteEntry, external, provider.name),
-          provider.entries[packageName]
-        )
+      Array.from(files, ([specifier, copy]) => [
+        specifier,
+        join(providerScopeUrl(remoteEntry, external, copy.name), copy.entries[specifier])
       ])
     );
   }
@@ -3385,181 +3759,335 @@ function createUpdateCache(config, ports) {
   }
 }
 
-// src/lib/core/2.app/steps/pooling/pool-dynamic-externals.ts
-function createPoolDynamicExternals(config, ports) {
-  return ({ entry, actions }) => {
-    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 shareScope = external.shareScope ?? GLOBAL_SCOPE;
-      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 });
-    let verdicts = /* @__PURE__ */ new Map();
-    const scope = (name, cause) => {
-      actions[name].action = "scope";
-      delete actions[name].override;
-      verdicts.set(name, { cause });
-    };
-    for (const [shareScope, names] of declared) {
-      if (!ports.sharedExternalsRepo.hasPoolState(shareScope)) continue;
-      const committed = ports.sharedExternalsRepo.getFromScope(shareScope);
-      const pools = buildPools(committed);
-      verdicts = /* @__PURE__ */ new Map();
-      for (const pool of pools.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, "incompatible"));
-          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.`
+// src/lib/core/1.domain/pooling/gate.ts
+function committedView(members, shipped, recordOrder, {
+  shareScope,
+  without,
+  packageOf
+}) {
+  const global = /* @__PURE__ */ new Map();
+  const claims = committedClaims(inRecordOrder(members, recordOrder), { shareScope, without });
+  for (const [specifier, { tag, copy }] of claims)
+    global.set(specifier, { tag, remote: copy.name, file: copy.entries[specifier] });
+  const builds = /* @__PURE__ */ new Map();
+  for (const [owner, copies] of shipped)
+    if (owner !== without) builds.set(owner, buildOf(owner, copies, packageOf));
+  const fileOf = subpoolFilesOf(members);
+  return {
+    packageOf,
+    builds,
+    global,
+    runsOffMap: runsOffMapOf(members, global, builds, fileOf)
+  };
+}
+function subpoolFilesOf(members) {
+  const subpoolOwners = /* @__PURE__ */ new Set();
+  for (const member of members)
+    for (const version of member.external.versions)
+      for (const { servedBy } of version.remotes) if (servedBy) subpoolOwners.add(servedBy);
+  const fileOf = /* @__PURE__ */ new Map();
+  for (const member of members)
+    for (const version of member.external.versions)
+      for (const { name, entries } of version.remotes) {
+        if (!subpoolOwners.has(name)) continue;
+        let files = fileOf.get(name);
+        if (!files) fileOf.set(name, files = /* @__PURE__ */ new Map());
+        for (const specifier in entries)
+          if (!files.has(specifier)) files.set(specifier, entries[specifier]);
+      }
+  return fileOf;
+}
+function runsOffMapOf(members, global, builds, fileOf) {
+  const runsOffMap2 = /* @__PURE__ */ new Map();
+  for (const member of members)
+    for (const version of member.external.versions)
+      for (const meta of version.remotes) {
+        const { servedBy } = meta;
+        if (version.action === "share" && !servedBy) continue;
+        let runs = runsOffMap2.get(meta.name);
+        if (!runs) runsOffMap2.set(meta.name, runs = /* @__PURE__ */ new Map());
+        for (const specifier in meta.entries) {
+          if (version.action === "skip" && !servedBy && global.has(specifier)) continue;
+          const tag = (servedBy ? builds.get(servedBy)?.tags.pinnedTag(specifier) : void 0) ?? version.tag;
+          const file = servedBy && fileOf.get(servedBy)?.get(specifier);
+          runs.set(
+            specifier,
+            file ? { tag, remote: servedBy, file } : { tag, remote: meta.name, file: meta.entries[specifier] }
           );
-          mine.forEach((member) => scope(member.name, "uncovered"));
-          continue;
         }
-        for (const name of redirect(entry.name, anchor, pool, asked.view, actions, shareScope))
-          verdicts.set(name, { servedBy: anchor });
       }
-      const written = {};
-      for (const [name, verdict] of verdicts) {
-        written[name] = recordVerdict(committed[name], entry.name, verdict);
-        ports.sharedExternalsRepo.addOrUpdate(name, written[name], shareScope);
+  return runsOffMap2;
+}
+function judgeRemote(copies, view, accepts) {
+  const { rejected, missing } = scan(copies, view, accepts);
+  if (rejected) return { cause: "incompatible", ...rejected };
+  const globalTags = new SpecifierTags(
+    view.packageOf,
+    [...view.global].map(([s, { tag }]) => [s, tag])
+  );
+  const binding = offMapBinding(copies, view, globalTags);
+  if (binding) return { cause: "uncovered", ...binding };
+  if (servedSplit(copies, view)) return { cause: "uncovered", unshipped: true };
+  if (agrees(copies, globalTags)) return "global";
+  if (missing !== void 0) return { cause: "uncovered", specifier: missing };
+  if (unwitnessedGap(copies, globalTags, view.builds.values()) === void 0) return "global";
+  return { cause: "uncovered", unshipped: true };
+}
+function servedSplit(copies, view) {
+  const loaded = new Set(copies.flatMap((copy) => copy.specifiers.map(view.packageOf)));
+  const servedBy = /* @__PURE__ */ new Map();
+  for (const [specifier, { remote }] of view.global) {
+    const pkg = view.packageOf(specifier);
+    if (!loaded.has(pkg)) continue;
+    const first = servedBy.get(pkg);
+    if (first === void 0) servedBy.set(pkg, remote);
+    else if (first !== remote) return true;
+  }
+  return false;
+}
+function coverFromMap(remote, mine, view, actions, policy) {
+  const files = [];
+  for (const member of mine) {
+    const action = actions[member.name];
+    const copy = member.external.versions.flatMap((v) => v.remotes).find((r) => r.name === remote);
+    if (!copy) continue;
+    const mapped = mapFiles(copy, view, policy, action);
+    if ("unmapped" in mapped) return mapped;
+    files.push({ member, action, copy, ...mapped });
+  }
+  const reaches = reachesOf(remote, files, view);
+  const bound = boundByFile(reaches, view);
+  if (bound !== void 0) return { bound };
+  const servedPackages = new Set([...view.global.keys()].map(view.packageOf));
+  const gap = files.map((file) => gapOf(file, servedPackages, view.packageOf)).find((specifier) => specifier !== void 0);
+  if (gap !== void 0) return { gap };
+  return { covers: files.filter(covering).map(coverOf) };
+}
+function gapOf({ copy, covered }, servedPackages, packageOf) {
+  const entrypoints = Object.keys(copy.entries);
+  const missing = entrypoints.filter((specifier) => !covered.has(specifier));
+  if (missing.length < entrypoints.length) return missing[0];
+  return missing.find((specifier) => servedPackages.has(packageOf(specifier)));
+}
+function covering({ action, copy, covered }) {
+  if (action.action === "skip") return true;
+  const entrypoints = Object.keys(copy.entries);
+  return entrypoints.length > 0 && entrypoints.every((specifier) => covered.has(specifier));
+}
+function coverOf({ member, action, copy, covered, override }) {
+  const toSkip = action.action !== "skip" || covered.size > action.covered.length && member.external.versions.some((v) => v.action === "share" && v.remotes.includes(copy));
+  return { name: member.name, toSkip, override };
+}
+function reachesOf(remote, files, view) {
+  const reaches = /* @__PURE__ */ new Map();
+  const fromMap = (specifier) => {
+    const served = view.global.get(specifier);
+    return served && { remote: served.remote, file: served.file };
+  };
+  for (const file of files) {
+    const takesMap = covering(file);
+    for (const [specifier, own] of Object.entries(file.copy.entries)) {
+      if (!takesMap || !file.covered.has(specifier)) reaches.set(specifier, { remote, file: own });
+      else {
+        const reach = fromMap(specifier);
+        if (reach) reaches.set(specifier, reach);
       }
-      syncPoolNames({ ...committed, ...written }, pools, ports.sharedExternalsRepo, 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 reaches;
+}
+function boundByFile(reaches, view) {
+  const servers = /* @__PURE__ */ new Set();
+  for (const { remote } of reaches.values()) if (view.builds.has(remote)) servers.add(remote);
+  const firstRun = /* @__PURE__ */ new Map();
+  for (const build of servers)
+    for (const specifier of view.builds.get(build).tags.keys()) {
+      const served = view.runsOffMap.get(build)?.get(specifier) ?? view.global.get(specifier);
+      if (served === void 0) continue;
+      const reached = reaches.get(specifier) ?? firstRun.get(specifier);
+      if (reached === void 0) {
+        firstRun.set(specifier, served);
+        if (view.builds.has(served.remote)) servers.add(served.remote);
+      } else if (reached.remote !== served.remote || reached.file !== served.file)
+        return { owner: build, specifier, tag: served.tag };
     }
-    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 void 0;
+}
+function mapFiles(copy, view, policy, action) {
+  const covered = new Set(action.covered);
+  const override = { ...action.override };
+  for (const specifier in copy.entries) {
+    const source = view.global.get(specifier);
+    if (!source) continue;
+    if (policy.shareScope !== GLOBAL_SCOPE) {
+      const scopeUrl = policy.scopeUrlOf(source.remote);
+      if (!scopeUrl) return { unmapped: source.remote };
+      override[specifier] = join(scopeUrl, source.file);
     }
-    return ships2 > 0 && (winsAll || allScoped);
-  }
-  function explainDynamic(remote, { view, wants, specifiers, acceptance }) {
-    return explainSelfServe(remote, wants, specifiers, {
-      builds: view.builds,
-      acceptance: acceptance()
-    });
+    covered.add(specifier);
   }
-  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 [];
+  return { covered, override };
+}
+function scan(copies, view, accepts) {
+  let rejected;
+  let missing;
+  for (const copy of copies)
+    for (const s of copy.specifiers) {
+      const global = view.global.get(s);
+      if (global === void 0) missing ??= s;
+      else if (!accepts(global.tag, copy.tag, copy.requiredVersion))
+        rejected ??= { specifier: s, tag: global.tag };
     }
-    const basis = basisPerMember(pool);
-    const served = [];
-    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;
-      if (basis.get(member.name) !== anchor) served.push(member.name);
+  return { rejected, missing };
+}
+function offMapBinding(copies, view, globalTags) {
+  const own = new SpecifierTags(
+    view.packageOf,
+    copies.flatMap((c) => c.specifiers.map((s) => [s, c.tag]))
+  );
+  const servers = /* @__PURE__ */ new Set();
+  for (const copy of copies)
+    for (const specifier of copy.specifiers) {
+      const build = view.global.get(specifier)?.remote;
+      if (build !== void 0) servers.add(build);
     }
-    return served;
-  }
-  function recordVerdict(external, remote, verdict) {
-    if ("servedBy" in verdict) {
-      return {
-        ...external,
-        versions: external.versions.map((v) => ({
-          ...v,
-          remotes: v.remotes.map(
-            (r) => r.name === remote ? { ...r, servedBy: verdict.servedBy } : r
-          )
-        }))
-      };
+  const firstRun = new SpecifierTags(view.packageOf);
+  for (const build of servers)
+    for (const [specifier, { tag }] of view.runsOffMap.get(build) ?? []) {
+      const reached = globalTags.pinnedTag(specifier) ?? own.pinnedTag(specifier) ?? firstRun.pinnedTag(specifier);
+      if (reached === void 0) firstRun.set(specifier, tag);
+      else if (reached !== tag) return { owner: build, specifier, tag };
     }
-    const moved = [];
-    const versions = external.versions.map((v) => {
-      const own = v.remotes.find((r) => r.name === remote);
-      if (!own) return v;
-      const { servedBy: _anchor, ...rest } = own;
-      const meta = { ...rest, cached: true, poolCause: verdict.cause };
-      if (v.action === "scope")
-        return { ...v, remotes: v.remotes.map((r) => r === own ? meta : r) };
-      moved.push({ tag: v.tag, meta });
-      return { ...v, remotes: v.remotes.filter((r) => r !== own) };
-    }).filter((v) => v.remotes.length > 0);
-    for (const { tag, meta } of moved) {
-      const at = versions.findIndex((v) => v.tag === tag && v.action === "scope");
-      if (at >= 0) versions[at] = { ...versions[at], remotes: [...versions[at].remotes, meta] };
-      else versions.push({ tag, action: "scope", host: false, remotes: [meta] });
+  return void 0;
+}
+function inRecordOrder(members, recordOrder) {
+  const rank2 = new Map(recordOrder.map((name, i) => [name, i]));
+  return [...members].sort((a, b) => rank2.get(a.name) - rank2.get(b.name)).map((m) => [m.name, m.external]);
+}
+
+// src/lib/core/2.app/steps/pooling/pool-dynamic-externals.ts
+function createPoolDynamicExternals(config, ports) {
+  const accepts = createAcceptsTag(
+    (tag, range) => ports.versionCheck.isCompatible(tag, range),
+    (a, b) => ports.versionCheck.compare(a, b)
+  );
+  const scopeUrlOf = (remote) => ports.remoteInfoRepo.tryGet(remote).get()?.scopeUrl;
+  return ({ entry, actions }) => {
+    for (const [scope, names] of poolableNames(entry, actions)) {
+      const committed = ports.sharedExternalsRepo.getFromScope(scope);
+      if (!scopeHasPoolState(committed)) continue;
+      const { pools, packageOf } = buildPools(committed);
+      const moves = judgeScope(
+        entry.name,
+        names,
+        actions,
+        pools,
+        packageOf,
+        Object.keys(committed),
+        scope
+      );
+      writeMoves(entry.name, names, moves, committed, pools, scope);
     }
-    return {
-      ...external,
-      versions: versions.sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
+    return Promise.resolve({ entry, actions: publicActions(actions) });
+  };
+  function judgeScope(remote, names, actions, pools, packageOf, recordOrder, scope) {
+    const policy = { shareScope: scope, scopeUrlOf };
+    const moves = /* @__PURE__ */ new Map();
+    const selfServe = (members, cause) => {
+      for (const { name } of members) {
+        actions[name].action = "scope";
+        delete actions[name].override;
+        moves.set(name, { cause });
+      }
     };
+    for (const pool of pools.values()) {
+      const mine = pool.filter((member) => names.has(member.name));
+      if (mine.length === 0) continue;
+      const shipped = copiesByRemote(pool);
+      const view = committedView(pool, shipped, recordOrder, {
+        shareScope: scope,
+        without: remote,
+        packageOf
+      });
+      const own = shipped.get(remote) ?? [];
+      const verdict = judgeRemote(own, view, accepts);
+      if (verdict !== "global") {
+        config.log.warn(8, `[${scope}] ${selfServeWarning(remote, verdict, specifierCount(own))}`);
+        selfServe(mine, verdict.cause);
+        continue;
+      }
+      const cover = coverFromMap(remote, mine, view, actions, policy);
+      if (!("covers" in cover)) {
+        if ("unmapped" in cover) warnUnmapped(scope, remote, cover.unmapped);
+        else
+          config.log.warn(
+            8,
+            `[${scope}] ${selfServeWarning(remote, coverMiss(cover), specifierCount(own))}`
+          );
+        selfServe(mine, "uncovered");
+        continue;
+      }
+      for (const { name, toSkip, override } of cover.covers) {
+        const action = actions[name];
+        if (toSkip) {
+          action.action = "skip";
+          moves.set(name, { fromMap: true });
+        }
+        if (Object.keys(override).length > 0) action.override = override;
+      }
+    }
+    return moves;
+  }
+  function writeMoves(remote, names, moves, committed, pools, scope) {
+    const written = {};
+    for (const [name, move] of moves)
+      written[name] = movedRecord(committed[name], remote, move, ports.versionCheck.compare);
+    for (const [name, record] of renamedRecords({ ...committed, ...written }, pools))
+      written[name] = record;
+    if (!config.strict.strictExternalCompatibility)
+      for (const { name } of [...pools.values()].flat().filter((m) => names.has(m.name)))
+        written[name] = { ...written[name] ?? committed[name], dirty: true };
+    for (const [name, record] of Object.entries(written))
+      ports.sharedExternalsRepo.addOrUpdate(name, record, scope);
+  }
+  function warnUnmapped(scope, remote, build) {
+    config.log.warn(
+      8,
+      `[${scope}][${remote}] '${build}' is not in the cache, so its files cannot be mapped.`
+    );
   }
 }
+function publicActions(actions) {
+  for (const action of Object.values(actions)) delete action.covered;
+  return actions;
+}
+function poolableNames(entry, actions) {
+  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 scope = external.shareScope ?? GLOBAL_SCOPE;
+    let names = declared.get(scope);
+    if (!names) declared.set(scope, names = /* @__PURE__ */ new Set());
+    names.add(name);
+  }
+  return declared;
+}
+function coverMiss(cover) {
+  if ("gap" in cover) return { cause: "uncovered", specifier: cover.gap };
+  return { cause: "uncovered", ...cover.bound };
+}
+function selfServeWarning(remote, miss, imports) {
+  const where = `All ${imports} of its entrypoints are scoped for it.`;
+  if (miss.cause === "incompatible")
+    return `'${remote}' is islanded: its range rejects '${miss.specifier}@${miss.tag}' of the committed map. ${where}`;
+  if ("owner" in miss)
+    return `'${remote}' serves its own family: committed build '${miss.owner}', whose files it would reach, resolves '${miss.specifier}' to another file than it would. ${where}`;
+  if ("unshipped" in miss)
+    return `'${remote}' serves its own family: no committed build shipped the map's combination for it. ${where}`;
+  return `'${remote}' serves its own family: no committed build offers every entrypoint it imports at a version it accepts (gap '${miss.specifier}'). ${where}`;
+}
 
 // src/lib/core/2.app/steps/convert-to-import-map.ts
 function createConvertToImportMap(config, ports) {
@@ -3596,27 +4124,14 @@ function createConvertToImportMap(config, ports) {
         return;
       }
       if (actions[external.packageName].action === "skip") {
-        const { override, covered, sameVersion } = actions[external.packageName];
+        const { override } = actions[external.packageName];
         if (override) {
           Object.entries(override).forEach(([packageName, url]) => {
             addToScopes(remoteEntryScope, packageName, url, importMap);
           });
-          serveUncovered(
-            remoteEntry,
-            external,
-            covered ?? Object.keys(override),
-            remoteEntryScope,
-            importMap,
-            sameVersion
-          );
-          return;
-        }
-        if (!external.shareScope) {
-          if (covered) {
-            serveUncovered(remoteEntry, external, covered, remoteEntryScope, importMap, sameVersion);
-          }
           return;
         }
+        if (!external.shareScope) return;
         log.error(
           9,
           `[${remoteEntry.name}][${external.packageName}] shareScope skip has no override.`
@@ -3681,27 +4196,6 @@ 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.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;
@@ -3717,11 +4211,12 @@ var createInitDrivers = ({
 }) => ({
   getRemoteEntries: createGetRemoteEntries(config, adapters),
   processRemoteEntries: createProcessRemoteEntries(config, adapters),
-  markPoolsForReelection: createMarkPoolsForReelection(config, adapters),
   determineSharedExternals: createDetermineSharedExternals(config, adapters),
   poolSharedExternals: createPoolSharedExternals(config, adapters),
+  decideServingBuilds: createDecideServingBuilds(config, adapters),
   generateImportMap: createGenerateImportMap(config, adapters),
   commitChanges: createCommitChanges(config, adapters),
+  rollbackChanges: createRollbackChanges(config, adapters),
   exposeModuleLoader: createExposeModuleLoader(config, adapters),
   getRemoteEntry: createGetRemoteEntry(config, adapters),
   updateCache: createUpdateCache(config, adapters),
@@ -3751,19 +4246,30 @@ var createBrowser = (config) => {
 // src/lib/core/3.adapters/checks/version.check.ts
 var import_valid = __toESM(require_valid());
 var import_satisfies = __toESM(require_satisfies());
-var import_compare = __toESM(require_compare());
+var import_semver = __toESM(require_semver());
 var import_min_version = __toESM(require_min_version());
 var import_valid2 = __toESM(require_valid2());
 var createVersionCheck = () => {
+  const parsed = /* @__PURE__ */ new Map();
+  const parse = (v) => {
+    let hit = parsed.get(v);
+    if (!hit) parsed.set(v, hit = new import_semver.default(v, true));
+    return hit;
+  };
+  const satisfied = /* @__PURE__ */ new Map();
   return {
     isValidSemver: function(version) {
       return (0, import_valid.default)(version) !== null;
     },
     isCompatible: function(version, range) {
-      return (0, import_satisfies.default)(version, range);
+      let byVersion = satisfied.get(range);
+      if (!byVersion) satisfied.set(range, byVersion = /* @__PURE__ */ new Map());
+      let hit = byVersion.get(version);
+      if (hit === void 0) byVersion.set(version, hit = (0, import_satisfies.default)(version, range));
+      return hit;
     },
     compare: function(versionA, versionB) {
-      return (0, import_compare.default)(versionA, versionB, true);
+      return parse(versionA).compare(parse(versionB));
     },
     smallestVersion: function(versionRange) {
       if (!(0, import_valid2.default)(versionRange)) return "0.0.0";
@@ -3836,7 +4342,12 @@ var createManifestProvider = () => {
   };
 };
 
-// node_modules/.pnpm/@softarc+native-federation@4.7.0/node_modules/@softarc/native-federation/dist/lib/utils/normalize.js
+// src/lib/core/1.domain/remote-entry/mark-dense.ts
+function markDense(shared) {
+  return shared.map((entry) => "entries" in entry ? { ...entry, dense: true } : entry);
+}
+
+// node_modules/.pnpm/@softarc+native-federation@4.9.0/node_modules/@softarc/native-federation/dist/lib/utils/normalize.js
 function inferPackageFromSecondary(secondary) {
   const parts = secondary.split("/");
   if (secondary.startsWith("@") && parts.length >= 2) {
@@ -3845,14 +4356,14 @@ function inferPackageFromSecondary(secondary) {
   return parts[0];
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.7.0/node_modules/@softarc/native-federation/dist/lib/core/output/densify-externals.js
+// node_modules/.pnpm/@softarc+native-federation@4.9.0/node_modules/@softarc/native-federation/dist/lib/core/output/densify-externals.js
 function isDense(entry) {
   return "entries" in entry;
 }
 function isFlatChunk(entry) {
   return entry.packageName.startsWith(CHUNK_PREFIX);
 }
-function densifyExternals(shared) {
+function densifyExternals(shared, declaredPackages) {
   const result = [];
   const groupIndex = /* @__PURE__ */ new Map();
   for (const entry of shared) {
@@ -3866,7 +4377,7 @@ function densifyExternals(shared) {
       continue;
     }
     const { outFileName, packageName, dev, ...meta } = entry;
-    const parent = inferPackageFromSecondary(packageName);
+    const parent = declaredPackages.get(packageName) ?? inferPackageFromSecondary(packageName);
     const sig = JSON.stringify(meta, Object.keys(meta).sort());
     const key = parent + " " + sig;
     const existing = groupIndex.get(key);
@@ -3896,6 +4407,16 @@ function toDenseSharedInfoFormat(shared) {
   });
 }
 
+// src/lib/core/3.adapters/remote-entry/normalize-remote-entry.ts
+var normalizeRemoteEntry = (raw, remoteEntryUrl, config) => {
+  const marked = markDense(raw.shared ?? []);
+  const shared = config.feature.convertFlatSharedInfo ? densifyExternals(marked, /* @__PURE__ */ new Map()) : toDenseSharedInfoFormat(marked);
+  const remoteEntry = { ...raw, shared };
+  if (!remoteEntry.exposes) remoteEntry.exposes = [];
+  if (!remoteEntry.url) remoteEntry.url = remoteEntryUrl;
+  return remoteEntry;
+};
+
 // src/lib/core/3.adapters/http/remote-entry-provider.ts
 var createRemoteEntryProvider = (config) => {
   const ensureOk = (response) => {
@@ -3903,16 +4424,6 @@ var createRemoteEntryProvider = (config) => {
       return Promise.reject(new Error(`${response.status} - ${response.statusText}`));
     return response;
   };
-  const fillEmptyFields = (remoteEntryUrl) => (remoteEntry) => {
-    if (!remoteEntry.exposes) remoteEntry.exposes = [];
-    if (!remoteEntry.shared) remoteEntry.shared = [];
-    if (!remoteEntry.url) remoteEntry.url = remoteEntryUrl;
-    return remoteEntry;
-  };
-  const normalizeRemoteEntry = (raw) => {
-    const shared = config.feature.convertFlatSharedInfo ? densifyExternals(raw.shared ?? []) : toDenseSharedInfoFormat(raw.shared ?? []);
-    return { ...raw, shared };
-  };
   const formatError = (remoteEntryUrl) => (err) => {
     const msg = err instanceof Error ? err.message : String(err);
     throw new NFError(`Fetch of '${remoteEntryUrl}' returned ${msg}`);
@@ -3925,7 +4436,7 @@ var createRemoteEntryProvider = (config) => {
         await verifyIntegrity(bytes, opts.integrity);
         return JSON.parse(new TextDecoder().decode(bytes));
       };
-      return fetch(remoteEntryUrl).then(ensureOk).then(parse).then(normalizeRemoteEntry).then(fillEmptyFields(remoteEntryUrl)).catch(formatError(remoteEntryUrl));
+      return fetch(remoteEntryUrl).then(ensureOk).then(parse).then((raw) => normalizeRemoteEntry(raw, remoteEntryUrl, config)).catch(formatError(remoteEntryUrl));
     }
   };
 };
@@ -3935,14 +4446,15 @@ var STORAGE_KEYS = {
   remotes: "remotes",
   sharedExternals: "shared-externals",
   scopedExternals: "scoped-externals",
-  sharedChunks: "shared-chunks"
+  sharedChunks: "shared-chunks",
+  cacheState: "cache-state"
 };
 
 // src/lib/core/3.adapters/storage/remote-info.repository.ts
 var createRemoteInfoRepository = (config) => {
   const STORAGE = config.storage(STORAGE_KEYS.remotes, {});
   if (config.clearStorage) STORAGE.clear();
-  const _cache = STORAGE.get() ?? {};
+  let _cache = STORAGE.get() ?? {};
   let _dirty = false;
   return {
     contains: function(remoteName) {
@@ -3976,6 +4488,11 @@ var createRemoteInfoRepository = (config) => {
       STORAGE.set(_cache);
       _dirty = false;
       return this;
+    },
+    rollback: function() {
+      _cache = STORAGE.get() ?? {};
+      _dirty = false;
+      return this;
     }
   };
 };
@@ -3984,7 +4501,7 @@ var createRemoteInfoRepository = (config) => {
 var createScopedExternalsRepository = (config) => {
   const STORAGE = config.storage(STORAGE_KEYS.scopedExternals, {});
   if (config.clearStorage) STORAGE.clear();
-  const _cache = STORAGE.get() ?? {};
+  let _cache = STORAGE.get() ?? {};
   let _dirty = false;
   return {
     addExternal: function(remoteName, external, version) {
@@ -4011,43 +4528,57 @@ var createScopedExternalsRepository = (config) => {
       STORAGE.set(_cache);
       _dirty = false;
       return this;
+    },
+    rollback: function() {
+      _cache = STORAGE.get() ?? {};
+      _dirty = false;
+      return this;
     }
   };
 };
 
+// src/lib/core/3.adapters/storage/cache-state.ts
+var createCacheState = (storage) => {
+  const entry = storage(STORAGE_KEYS.cacheState, null);
+  const read = () => {
+    const stored = entry.get();
+    if (typeof stored !== "object" || stored === null) return {};
+    const { version, undecidedScopes } = stored;
+    return {
+      ...typeof version === "string" ? { version } : {},
+      ...Array.isArray(undecidedScopes) ? { undecidedScopes: undecidedScopes.filter((s) => typeof s === "string") } : {}
+    };
+  };
+  return {
+    read,
+    update: (fields) => void entry.set({ ...read(), ...fields })
+  };
+};
+
 // src/lib/core/3.adapters/storage/shared-externals.repository.ts
 var createSharedExternalsRepository = (config) => {
   const STORAGE = config.storage(
     STORAGE_KEYS.sharedExternals,
     { [GLOBAL_SCOPE]: {} }
   );
-  if (config.clearStorage) STORAGE.clear();
-  const _cache = STORAGE.get() ?? { [GLOBAL_SCOPE]: {} };
-  let _dirty = false;
+  const cacheState = createCacheState(config.storage);
+  const storedUndecided = () => new Set(cacheState.read().undecidedScopes);
+  if (config.clearStorage) {
+    STORAGE.clear();
+    cacheState.update({ undecidedScopes: [] });
+  }
+  let _cache = STORAGE.get() ?? { [GLOBAL_SCOPE]: {} };
+  const _uncommitted = /* @__PURE__ */ new Set();
+  let _undecided = storedUndecided();
+  let _undecidedChanged = false;
   return {
-    // 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.
-    // Stored pool results count too, since a scope whose last tag left still has pool state to clear.
-    hasPoolState: function(shareScope) {
-      const scope = _cache[shareScope ?? GLOBAL_SCOPE];
-      if (!scope) return false;
-      for (const external of Object.values(scope)) {
-        if (external.poolName !== void 0) return true;
-        for (const version of external.versions)
-          for (const remote of version.remotes)
-            if (remote.pool?.trim() || remote.servedBy !== void 0 || remote.poolCause !== void 0)
-              return true;
-      }
-      return false;
-    },
     getFromScope: function(shareScope) {
       return { ..._cache[shareScope ?? GLOBAL_SCOPE] };
     },
     addOrUpdate: function(externalName, external, shareScope) {
       if (!_cache[shareScope ?? GLOBAL_SCOPE]) _cache[shareScope ?? GLOBAL_SCOPE] = {};
       _cache[shareScope ?? GLOBAL_SCOPE][externalName] = external;
-      _dirty = true;
+      _uncommitted.add(shareScope ?? GLOBAL_SCOPE);
       return this;
     },
     getScopes: function(o = { includeGlobal: true }) {
@@ -4057,7 +4588,7 @@ var createSharedExternalsRepository = (config) => {
     // 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) => {
+      Object.entries(_cache).forEach(([scopeName, scope]) => {
         const removeExternals = [];
         Object.entries(scope).forEach(([name, external]) => {
           let removedCopy = false;
@@ -4073,12 +4604,12 @@ var createSharedExternalsRepository = (config) => {
             if (keep !== remotes.length) {
               remotes.length = keep;
               removedCopy = true;
-              _dirty = true;
+              _uncommitted.add(scopeName);
               if (host !== void 0 && remoteNames.has(host)) version.host = false;
             }
             if (remotes.length === 0) {
               external.versions.splice(i, 1);
-              _dirty = true;
+              _uncommitted.add(scopeName);
             }
           }
           if (removedCopy) {
@@ -4086,7 +4617,17 @@ var createSharedExternalsRepository = (config) => {
             if (external.versions.length === 0) removeExternals.push(name);
           }
         });
-        removeExternals.forEach((name) => delete scope[name]);
+        const lostPools = /* @__PURE__ */ new Set();
+        for (const name of removeExternals) {
+          const poolName = scope[name].poolName;
+          if (poolName !== void 0) lostPools.add(poolName);
+          delete scope[name];
+        }
+        if (lostPools.size > 0) {
+          for (const external of Object.values(scope))
+            if (external.poolName !== void 0 && lostPools.has(external.poolName))
+              external.dirty = true;
+        }
       });
     },
     scopeType: function(shareScope) {
@@ -4104,10 +4645,36 @@ var createSharedExternalsRepository = (config) => {
     tryGet: function(external, shareScope) {
       return Optional.of(_cache[shareScope ?? GLOBAL_SCOPE]?.[external]);
     },
+    uncommittedScopes: function() {
+      return [..._uncommitted];
+    },
+    markUndecided: function(shareScope) {
+      if (_undecided.has(shareScope)) return;
+      _undecided.add(shareScope);
+      _undecidedChanged = true;
+    },
+    isUndecided: function(shareScope) {
+      return _undecided.has(shareScope);
+    },
+    markDecided: function(shareScope) {
+      if (_undecided.delete(shareScope)) _undecidedChanged = true;
+    },
+    // Records before marks: should their write throw, the stored marks still send the next init to decide them. A
+    // failed cache-state write after the records loses only this load's marks.
     commit: function() {
-      if (!_dirty) return this;
-      STORAGE.set(_cache);
-      _dirty = false;
+      if (_uncommitted.size > 0) {
+        STORAGE.set(_cache);
+        _uncommitted.clear();
+      }
+      if (_undecidedChanged) cacheState.update({ undecidedScopes: [..._undecided] });
+      _undecidedChanged = false;
+      return this;
+    },
+    rollback: function() {
+      _cache = STORAGE.get() ?? { [GLOBAL_SCOPE]: {} };
+      _uncommitted.clear();
+      _undecided = storedUndecided();
+      _undecidedChanged = false;
       return this;
     }
   };
@@ -4224,7 +4791,7 @@ var createSSEHandler = (config) => {
 var createChunkRepository = (config) => {
   const STORAGE = config.storage(STORAGE_KEYS.sharedChunks, {});
   if (config.clearStorage) STORAGE.clear();
-  const _cache = STORAGE.get() ?? {};
+  let _cache = STORAGE.get() ?? {};
   let _dirty = false;
   return {
     addOrReplace: function(remoteName, bundleName, chunks) {
@@ -4249,6 +4816,11 @@ var createChunkRepository = (config) => {
       STORAGE.set(_cache);
       _dirty = false;
       return this;
+    },
+    rollback: function() {
+      _cache = STORAGE.get() ?? {};
+      _dirty = false;
+      return this;
     }
   };
 };
@@ -4471,8 +5043,10 @@ var globalThisStorageEntry = (namespace) => (key, initialValue) => {
 globalThisStorageEntry.type = "globalThis";
 Object.freeze(globalThisStorageEntry);
 
+// src/lib/core/4.config/orchestrator-version.ts
+var ORCHESTRATOR_VERSION = true ? "4.9.0" : "dev";
+
 // src/lib/core/4.config/storage/publish-storage-info.ts
-var VERSION = true ? "4.7.0" : "dev";
 var KEYS = Object.freeze(Object.values(STORAGE_KEYS));
 var isStorageKey = (key) => KEYS.includes(key);
 var createStorageInfo = ({
@@ -4481,7 +5055,12 @@ var createStorageInfo = ({
   storage,
   exposeGetter
 }) => {
-  const info = { version: VERSION, type, namespace, keys: KEYS };
+  const info = {
+    version: ORCHESTRATOR_VERSION,
+    type,
+    namespace,
+    keys: KEYS
+  };
   if (!exposeGetter) return Object.freeze(info);
   return Object.freeze({
     ...info,
@@ -4502,19 +5081,65 @@ var publishStorageInfo = (options) => {
 };
 
 // src/lib/core/4.config/storage/storage.config.ts
-var createStorageConfig = (override) => {
+var isOutdatedCache = (storage) => {
+  const cacheState = createCacheState(storage);
+  if (cacheState.read().version === ORCHESTRATOR_VERSION) return false;
+  cacheState.update({ version: ORCHESTRATOR_VERSION, undecidedScopes: [] });
+  return Object.values(STORAGE_KEYS).filter((key) => key !== STORAGE_KEYS.cacheState).some((key) => storage(key, null).get() !== null);
+};
+var guardWrites = (storage, log) => {
+  let failed = false;
+  const memory = /* @__PURE__ */ new Map();
+  const write = (key, value, persist) => {
+    if (!failed) {
+      try {
+        persist();
+        return;
+      } catch (error) {
+        failed = true;
+        try {
+          storage(STORAGE_KEYS.cacheState, null).set(null);
+        } catch {
+        }
+        log.warn(
+          5,
+          `Could not save '${key}' to storage; this page runs from memory and the next page starts without a cache.`,
+          error
+        );
+      }
+    }
+    memory.set(key, cloneEntry(key, value));
+  };
+  return (key, initialValue) => {
+    const inner = storage(key, initialValue);
+    const entry = {
+      get: () => memory.has(key) ? cloneEntry(key, memory.get(key)) : inner.get(),
+      set: (value) => {
+        write(key, value, () => void inner.set(value));
+        return entry;
+      },
+      clear: () => {
+        write(key, initialValue, () => void inner.clear());
+        return entry;
+      }
+    };
+    return entry;
+  };
+};
+var createStorageConfig = (override, log) => {
   const creator = override.storage ?? globalThisStorageEntry;
   const namespace = override.storageNamespace ?? "__NATIVE_FEDERATION__";
-  const storage = creator(namespace);
+  const storage = guardWrites(creator(namespace), log);
   publishStorageInfo({
     type: creator.type ?? "custom",
     namespace,
     storage,
     exposeGetter: override.exposeStorageGetter ?? true
   });
+  const outdated = isOutdatedCache(storage);
   return {
     storage,
-    clearStorage: override.clearStorage ?? false
+    clearStorage: (override.clearStorage ?? false) || outdated
   };
 };
 
@@ -4522,9 +5147,9 @@ var createStorageConfig = (override) => {
 var defaultProfile = {
   latestSharedExternal: false,
   skipInvalidExternalVersions: false,
-  scopeUncoveredEntrypoints: false,
   overrideCachedRemotes: "init-only",
-  overrideCachedRemotesIfURLMatches: false
+  overrideCachedRemotesIfURLMatches: false,
+  mergeManifests: true
 };
 
 // src/lib/core/4.config/mode/mode.config.ts
@@ -4534,15 +5159,13 @@ var createModeConfig = (override) => {
     strictExternalCompatibility: override.strict,
     strictExternalSameVersionCompatibility: override.strict,
     strictExternalVersion: override.strict,
-    strictImportMap: override.strict,
-    strictEntryPointCoverage: override.strict
+    strictImportMap: 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,
-    strictEntryPointCoverage: override.strict?.strictEntryPointCoverage ?? false
+    strictImportMap: override.strict?.strictImportMap ?? false
   };
   return {
     strict: strictnessConfig,
@@ -4554,23 +5177,18 @@ var createModeConfig = (override) => {
 };
 
 // src/lib/core/5.di/config.factory.ts
-var createConfigHandlers = (overrides) => ({
-  ...createImportMapConfig(overrides),
-  ...createHostConfig(overrides),
-  ...createLogConfig(overrides),
-  ...createStorageConfig(overrides),
-  ...createModeConfig(overrides)
-});
+var createConfigHandlers = (overrides) => {
+  const logConfig = createLogConfig(overrides);
+  return {
+    ...createImportMapConfig(overrides),
+    ...createHostConfig(overrides),
+    ...logConfig,
+    ...createStorageConfig(overrides, logConfig.log),
+    ...createModeConfig(overrides)
+  };
+};
 
 // src/lib/core/5.di/federation-result.factory.ts
-var createStateDump = (config, adapters) => (msg) => config.log.debug(0, msg, {
-  remotes: { ...adapters.remoteInfoRepo.getAll() },
-  "shared-externals": adapters.sharedExternalsRepo.getScopes({ includeGlobal: true }).reduce(
-    (acc, scope) => ({ ...acc, [scope]: adapters.sharedExternalsRepo.getFromScope(scope) }),
-    {}
-  ),
-  "scoped-externals": adapters.scopedExternalsRepo.getAll()
-});
 var createFederationResult = ({
   config,
   adapters,
@@ -4578,11 +5196,8 @@ var createFederationResult = ({
   initRemoteEntryFlow,
   afterInitRemoteEntry
 }) => {
-  const stateDump = createStateDump(config, adapters);
   const initRemoteEntry = async (remoteEntryUrl, remote) => {
-    const remoteName = typeof remote === "string" ? remote : remote?.name;
     return initRemoteEntryFlow(remoteEntryUrl, remote).catch((e) => {
-      stateDump(`[dynamic-init][${remoteName ?? remoteEntryUrl}] STATE DUMP`);
       if (config.strict.strictRemoteEntry) return Promise.reject(e);
       else console.warn("Failed to initialize remote entry, continuing anyway.");
       return Promise.resolve();