@softarc/native-federation-orchestrator 4.8.0 → 4.9.0

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

@@ -1325,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
@@ -1334,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;
@@ -1344,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;
   }
@@ -1368,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 {
@@ -1561,125 +1702,6 @@ function scopeRemotes(versions, remotes) {
   return rows.filter((v) => v.remotes.length > 0);
 }
 
-// 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 } : {},
-      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/process-remote-entries.ts
 function createProcessRemoteEntries(config, ports) {
   const storeRemoteEntry = createStoreRemoteEntry(config, ports, 2);
@@ -1847,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();
@@ -1869,16 +1892,19 @@ function createDetermineSharedExternals(config, ports) {
       );
       external.versions.forEach((vA) => {
         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;
         }
       });
@@ -1890,28 +1916,81 @@ function createDetermineSharedExternals(config, ports) {
   }
 }
 
+// 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 };
+}
+
 // src/lib/core/1.domain/externals/specifier.ts
-function owningPackage(name) {
+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 void 0;
+    if (cut === -1) return name;
   }
   return name.slice(0, cut);
 }
-var packageOf = (name) => owningPackage(name) ?? name;
+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 (specifier) => {
+    const npm = npmPackageOf(specifier);
+    return shortest.get(find(specifier)) ?? shortest.get(find(npm)) ?? npm;
+  };
+}
+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 {
-  packages = /* @__PURE__ */ new Map();
-  constructor(entries = []) {
+  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 = owningPackage(specifier);
-    if (pkg === void 0) this.packages.set(specifier, tag);
-    else if (!this.packages.has(pkg)) this.packages.set(pkg, tag);
+    const pkg = this.packageOf(specifier);
+    if (pkg === specifier || !this.packages.has(pkg)) this.packages.set(pkg, tag);
     return this;
   }
   clear() {
@@ -1919,10 +1998,10 @@ var SpecifierTags = class extends Map {
     this.packages.clear();
   }
   pinnedTag(specifier) {
-    return this.get(specifier) ?? this.packages.get(owningPackage(specifier) ?? specifier);
+    return this.get(specifier) ?? this.packages.get(this.packageOf(specifier));
   }
 };
-function groupByPackage(items, nameOf) {
+function groupByPackage(items, nameOf, packageOf) {
   const packages = /* @__PURE__ */ new Map();
   for (const item of items) {
     const pkg = packageOf(nameOf(item));
@@ -1957,8 +2036,8 @@ function copiesByRemote(members) {
   return shipped;
 }
 var specifierCount = (copies) => copies.reduce((n, copy) => n + copy.specifiers.length, 0);
-function buildOf(owner, copies) {
-  const tags = new SpecifierTags();
+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)
@@ -2000,12 +2079,14 @@ function unwitnessedGap(copies, tags, builds) {
 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));
+  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)])),
+    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)
@@ -2068,7 +2149,7 @@ function roundOne(pool, hostRemote) {
     (c) => c.build.owner === pool.previousWinner ? 1 : 0
   ]);
   const winner = round1Winner.build.owner;
-  const globalTags = new SpecifierTags(round1Winner.build.tags);
+  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 };
@@ -2125,7 +2206,7 @@ function addExtensions(pool, state) {
     for (const s of offer.specifiers) globalTags.set(s, offer.tag);
   }
 }
-function packageCopies(owner, copies) {
+function packageCopies(owner, copies, packageOf) {
   const packages = /* @__PURE__ */ new Map();
   for (const copy of copies)
     for (const s of copy.specifiers) {
@@ -2167,7 +2248,7 @@ function settle(pool, state) {
     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(packageOf(s)));
+    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)
@@ -2183,7 +2264,7 @@ function settle(pool, state) {
   }
 }
 function publishedWhole(pool, state, pkg) {
-  const published = new Set([...state.globalTags.keys()].filter((s) => packageOf(s) === 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);
@@ -2232,24 +2313,6 @@ function placeRemotes(globalRemotes, subpools, self, missOf2) {
 }
 
 // src/lib/core/1.domain/pooling/membership.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 };
-}
 var extNode = (name) => `ext\0${name}`;
 var labelNode = (label) => `label\0${label}`;
 var labelOf = (pool) => pool?.trim() || void 0;
@@ -2262,13 +2325,13 @@ function labelsIn(sharedExternals) {
     );
   return labelsOf;
 }
-function labelledComponents(labelsOf) {
+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 = owningPackage(name);
-    if (owner !== void 0) union(extNode(name), extNode(owner));
+    const owner = packageOf(name);
+    if (owner !== name) union(extNode(name), extNode(owner));
   }
   const byComponent = /* @__PURE__ */ new Map();
   for (const name of labelsOf.keys()) {
@@ -2278,11 +2341,11 @@ function labelledComponents(labelsOf) {
   }
   return [...byComponent.values()].filter((names) => names.some((n) => labelsOf.get(n).length > 0));
 }
-function buildPools(sharedExternals) {
+function buildPools(sharedExternals, packageOf = packageOfIn(sharedExternals)) {
   const labelsOf = labelsIn(sharedExternals);
   const pools = /* @__PURE__ */ new Map();
   const labelledAlone = [];
-  for (const names of labelledComponents(labelsOf)) {
+  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] }));
@@ -2292,9 +2355,9 @@ function buildPools(sharedExternals) {
       );
     }
   }
-  return { pools, labelledAlone };
+  return { pools, labelledAlone, packageOf };
 }
-function pooledPackagesWith(sharedExternals, copies) {
+function pooledPackagesWith(sharedExternals, copies, packageOf) {
   const labelsOf = labelsIn(sharedExternals);
   for (const { name, pool } of copies) {
     const labels = labelsOf.get(name) ?? [];
@@ -2302,7 +2365,7 @@ function pooledPackagesWith(sharedExternals, copies) {
     labelsOf.set(name, label === void 0 ? labels : [...labels, label]);
   }
   return new Set(
-    labelledComponents(labelsOf).filter((names) => names.length > 1).flatMap((names) => names.map(packageOf))
+    labelledComponents(labelsOf, packageOf).filter((names) => names.length > 1).flatMap((names) => names.map(packageOf))
   );
 }
 function mostDeclaredLabel(members, labelsOf) {
@@ -2438,14 +2501,14 @@ function renamedRecords(scope, pools) {
 // 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: [] };
-  const { pools, labelledAlone } = buildPools(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 };
+  return { pools, stripped, labelledAlone, packageOf };
 }
 
 // src/lib/core/2.app/steps/pooling/pool-shared-externals.ts
@@ -2459,7 +2522,7 @@ function createPoolSharedExternals(config, ports) {
         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, scope))
+          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) {
@@ -2494,9 +2557,10 @@ function createPoolSharedExternals(config, ports) {
         `[${scope}] '${name}' has a 'pool' label that joins no other external; likely a typo or a missing sibling.`
       );
   }
-  function poolRecords(poolName, members, scope) {
+  function poolRecords(poolName, members, packageOf, scope) {
     const election = elect({
       members,
+      packageOf,
       acceptsTag: createAcceptsTag(ports.versionCheck.isCompatible, compare),
       compare,
       previousWinner: previousWinner(members),
@@ -2557,12 +2621,13 @@ function missWarning(remote, miss, placed, counts) {
 
 // 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);
+var packagesOf = (scope) => groupByPackage(Object.keys(scope), (name) => name, packageOfIn(scope));
 var isPooled = (externals) => externals.some(([, e]) => e.poolName !== void 0);
-function servingBuildOf(externals, accepts) {
+function servingBuildOf(pkg, externals, accepts) {
   if (externals.length === 0) return void 0;
-  const pkg = packageOf(externals[0][0]);
-  const rootRows = shareRows(externals.find(([name]) => name === pkg)?.[1]);
+  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);
@@ -2763,8 +2828,8 @@ function splitsPackage(placed, surface, tag, accepts) {
   });
   return placed.some(onMap) && (shipsTwoTags(placed) || placed.some((p) => !onMap(p) || uncovered(p)));
 }
-function loadSplitsPackage(copies, claims, accepts) {
-  const root = claims.find(([specifier]) => specifier === packageOf(specifier))?.[1];
+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])
@@ -2810,7 +2875,7 @@ function createDecideServingBuilds(config, ports) {
     }
   };
   function decidePackage(shareScope, pkg, externals, accepts) {
-    const serving = servingBuildOf(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;
@@ -2896,7 +2961,6 @@ function committedClaims(externals, { shareScope, without }) {
   const publishes = (copy) => copy.name !== without && (shareScope !== GLOBAL_SCOPE || copy.cached);
   return claimTable(externals, publishes).claims;
 }
-var claimsByPackage = (claims) => groupByPackage(claims, ([specifier]) => specifier);
 function versionClaims(version, servingBuild) {
   const claims = /* @__PURE__ */ new Map();
   const claim = (specifier, copy) => {
@@ -2907,7 +2971,7 @@ function versionClaims(version, servingBuild) {
   return claims;
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.8.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";
@@ -2915,13 +2979,14 @@ var BuildNotificationType = /* @__PURE__ */ ((BuildNotificationType2) => {
   return BuildNotificationType2;
 })(BuildNotificationType || {});
 
-// node_modules/.pnpm/@softarc+native-federation@4.8.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;
 }
 
@@ -3522,18 +3587,19 @@ function createUpdateCache(config, ports) {
   function decidePackages(remoteEntry, pending) {
     const decisions = /* @__PURE__ */ new Map();
     const viewOf = loadViewOf(remoteEntry, pending);
-    for (const group of pendingPerPackage(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);
     }
     scopeOpenedPackages(decisions);
     return decisions;
   }
-  function pendingPerPackage(pending) {
+  function pendingPerPackage(pending, viewOf) {
     const packages = /* @__PURE__ */ new Map();
     for (const item of pending) {
       const { shareScope, packageName } = item.external;
-      const key = `${shareScope ?? GLOBAL_SCOPE}\0${packageOf(packageName)}`;
+      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]);
@@ -3551,20 +3617,34 @@ function createUpdateCache(config, ports) {
           shareScope: scope,
           without: remoteEntry.name
         });
-        const claimsIn = claimsByPackage(claims);
+        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, copiesIn(pending, scope))).has(pkg)
+          inPool: (pkg) => {
+            pooled ??= pooledPackagesWith(record, labelledCopiesIn(pending, scope), packageOf);
+            return pooled.has(pkg);
+          }
         };
         views.set(scope, view);
       }
       return view;
     };
   }
-  function copiesIn(pending, scope) {
-    return pending.filter(({ external }) => (external.shareScope ?? GLOBAL_SCOPE) === scope).map(({ external, ctx }) => ({ name: external.packageName, pool: ctx.remote.pool }));
+  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;
@@ -3573,15 +3653,16 @@ function createUpdateCache(config, ports) {
         decisions.set(item, { action: "scope", partlyServed: false });
   }
   function decidePackage(remoteEntry, group, view) {
-    const pkg = packageOf(group[0].external.packageName);
+    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 fromTwoBuilds = builds !== void 0 && builds.size > 1;
-      for (const rejection of refused(group, rejections, fromTwoBuilds, claims, view.inPool(pkg)))
+      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 };
     }
@@ -3602,9 +3683,7 @@ function createUpdateCache(config, ports) {
       return claim && !accepts(claim.tag, ctx.tag, ctx.remote.requiredVersion) ? [{ item, specifier, claim }] : [];
     });
   }
-  function refused(group, rejections, fromTwoBuilds, claims, pooled) {
-    const copies = group.map(({ ctx }) => ({ tag: ctx.tag, copy: ctx.remote }));
-    const splits = fromTwoBuilds || loadSplitsPackage(copies, claims, accepts);
+  function refused(rejections, splits, pooled) {
     const first = /* @__PURE__ */ new Map();
     for (const rejection of rejections)
       if (!first.has(rejection.item) && (pooled || !splits || electionKeeps(rejection)))
@@ -3681,16 +3760,25 @@ function createUpdateCache(config, ports) {
 }
 
 // src/lib/core/1.domain/pooling/gate.ts
-function committedView(members, shipped, recordOrder, { shareScope, without }) {
+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));
+    if (owner !== without) builds.set(owner, buildOf(owner, copies, packageOf));
   const fileOf = subpoolFilesOf(members);
-  return { builds, global, runsOffMap: runsOffMapOf(members, global, builds, fileOf) };
+  return {
+    packageOf,
+    builds,
+    global,
+    runsOffMap: runsOffMapOf(members, global, builds, fileOf)
+  };
 }
 function subpoolFilesOf(members) {
   const subpoolOwners = /* @__PURE__ */ new Set();
@@ -3733,14 +3821,30 @@ function runsOffMapOf(members, global, builds, fileOf) {
 function judgeRemote(copies, view, accepts) {
   const { rejected, missing } = scan(copies, view, accepts);
   if (rejected) return { cause: "incompatible", ...rejected };
-  const globalTags = new SpecifierTags([...view.global].map(([s, { tag }]) => [s, tag]));
+  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) {
@@ -3754,12 +3858,12 @@ function coverFromMap(remote, mine, view, actions, policy) {
   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(packageOf));
-  const gap = files.map((file) => gapOf(file, servedPackages)).find((specifier) => specifier !== void 0);
+  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) {
+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];
@@ -3837,14 +3941,17 @@ function scan(copies, view, accepts) {
   return { rejected, missing };
 }
 function offMapBinding(copies, view, globalTags) {
-  const own = new SpecifierTags(copies.flatMap((c) => c.specifiers.map((s) => [s, c.tag])));
+  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);
     }
-  const firstRun = new SpecifierTags();
+  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);
@@ -3869,13 +3976,21 @@ function createPoolDynamicExternals(config, ports) {
     for (const [scope, names] of poolableNames(entry, actions)) {
       const committed = ports.sharedExternalsRepo.getFromScope(scope);
       if (!scopeHasPoolState(committed)) continue;
-      const { pools } = buildPools(committed);
-      const moves = judgeScope(entry.name, names, actions, pools, Object.keys(committed), scope);
+      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 Promise.resolve({ entry, actions: publicActions(actions) });
   };
-  function judgeScope(remote, names, actions, pools, recordOrder, scope) {
+  function judgeScope(remote, names, actions, pools, packageOf, recordOrder, scope) {
     const policy = { shareScope: scope, scopeUrlOf };
     const moves = /* @__PURE__ */ new Map();
     const selfServe = (members, cause) => {
@@ -3891,7 +4006,8 @@ function createPoolDynamicExternals(config, ports) {
       const shipped = copiesByRemote(pool);
       const view = committedView(pool, shipped, recordOrder, {
         shareScope: scope,
-        without: remote
+        without: remote,
+        packageOf
       });
       const own = shipped.get(remote) ?? [];
       const verdict = judgeRemote(own, view, accepts);
@@ -4226,7 +4342,12 @@ var createManifestProvider = () => {
   };
 };
 
-// node_modules/.pnpm/@softarc+native-federation@4.8.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) {
@@ -4235,14 +4356,14 @@ function inferPackageFromSecondary(secondary) {
   return parts[0];
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.8.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) {
@@ -4256,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);
@@ -4286,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) => {
@@ -4293,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}`);
@@ -4315,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));
     }
   };
 };
@@ -4923,7 +5044,7 @@ globalThisStorageEntry.type = "globalThis";
 Object.freeze(globalThisStorageEntry);
 
 // src/lib/core/4.config/orchestrator-version.ts
-var ORCHESTRATOR_VERSION = true ? "4.8.0" : "dev";
+var ORCHESTRATOR_VERSION = true ? "4.9.0" : "dev";
 
 // src/lib/core/4.config/storage/publish-storage-info.ts
 var KEYS = Object.freeze(Object.values(STORAGE_KEYS));
@@ -4966,10 +5087,49 @@ var isOutdatedCache = (storage) => {
   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 createStorageConfig = (override) => {
+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,
@@ -4988,7 +5148,8 @@ var defaultProfile = {
   latestSharedExternal: false,
   skipInvalidExternalVersions: false,
   overrideCachedRemotes: "init-only",
-  overrideCachedRemotesIfURLMatches: false
+  overrideCachedRemotesIfURLMatches: false,
+  mergeManifests: true
 };
 
 // src/lib/core/4.config/mode/mode.config.ts
@@ -5016,13 +5177,16 @@ 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 createFederationResult = ({