@softarc/native-federation-orchestrator 4.8.0 → 4.9.0

package/fesm2022/node.mjs

@@ -1406,14 +1406,94 @@ var createFsManifestProvider = () => {
   };
 };
 
+// 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/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(SCRIPT_EXTENSION, "");
+  return CHUNK_PREFIX + "/" + packageName;
+}
+
+// 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) {
+    return parts[0] + "/" + parts[1];
+  }
+  return parts[0];
+}
+
+// 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, declaredPackages) {
+  const result = [];
+  const groupIndex = /* @__PURE__ */ new Map();
+  for (const entry of shared) {
+    if (isDense(entry)) {
+      result.push(entry);
+      continue;
+    }
+    if (isFlatChunk(entry)) {
+      const { outFileName: outFileName2, ...rest } = entry;
+      result.push({ ...rest, entries: { [entry.packageName]: outFileName2 } });
+      continue;
+    }
+    const { outFileName, packageName, dev, ...meta } = entry;
+    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);
+    if (existing === void 0) {
+      const dense = {
+        ...meta,
+        packageName: parent,
+        entries: { [packageName]: outFileName }
+      };
+      if (dev !== void 0) dense.dev = dev;
+      groupIndex.set(key, result.length);
+      result.push(dense);
+    } else {
+      result[existing].entries[packageName] = outFileName;
+    }
+  }
+  return result;
+}
+function toDenseSharedInfoFormat(shared) {
+  return shared.map((external) => {
+    if ("entries" in external) return external;
+    const { outFileName, ...baseSharedInfoProps } = external;
+    return {
+      ...baseSharedInfoProps,
+      entries: { [external.packageName]: outFileName }
+    };
+  });
+}
+
+// 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/node/adapters/fs-remote-entry-provider.ts
-var createFsRemoteEntryProvider = () => {
-  const fillEmptyFields = (remoteEntryUrl) => (remoteEntry) => {
-    if (!remoteEntry.exposes) remoteEntry.exposes = [];
-    if (!remoteEntry.shared) remoteEntry.shared = [];
-    if (!remoteEntry.url) remoteEntry.url = remoteEntryUrl;
-    return remoteEntry;
-  };
+var createFsRemoteEntryProvider = (config) => {
   const formatError = (remoteEntryUrl) => (err) => {
     if (err instanceof NFError) throw err;
     const msg = err instanceof Error ? err.message : String(err);
@@ -1424,8 +1504,8 @@ var createFsRemoteEntryProvider = () => {
       try {
         const bytes = await readSourceBytes(remoteEntryUrl);
         if (opts.integrity) await verifyIntegrity(bytes, opts.integrity);
-        const parsed = JSON.parse(new TextDecoder().decode(bytes));
-        return fillEmptyFields(remoteEntryUrl)(parsed);
+        const raw = JSON.parse(new TextDecoder().decode(bytes));
+        return normalizeRemoteEntry(raw, remoteEntryUrl, config);
       } catch (err) {
         return formatError(remoteEntryUrl)(err);
       }
@@ -1980,7 +2060,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));
@@ -2023,10 +2103,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,
@@ -2045,7 +2164,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
@@ -2073,13 +2193,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/2.app/flows/init.flow.ts
 var createInitFlow = ({
@@ -2105,8 +2228,129 @@ var createInitRemoteEntryFlow = ({
   });
 };
 
+// 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
@@ -2114,7 +2358,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;
@@ -2124,6 +2368,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;
   }
@@ -2148,7 +2412,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 {
@@ -2341,125 +2605,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);
@@ -2623,6 +2768,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();
@@ -2645,16 +2791,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;
         }
       });
@@ -2666,28 +2815,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() {
@@ -2695,10 +2897,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));
@@ -2733,8 +2935,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)
@@ -2776,12 +2978,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)
@@ -2844,7 +3048,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 };
@@ -2901,7 +3105,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) {
@@ -2943,7 +3147,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)
@@ -2959,7 +3163,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);
@@ -3008,24 +3212,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;
@@ -3038,13 +3224,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()) {
@@ -3054,11 +3240,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] }));
@@ -3068,9 +3254,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) ?? [];
@@ -3078,7 +3264,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) {
@@ -3214,14 +3400,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
@@ -3235,7 +3421,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) {
@@ -3270,9 +3456,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),
@@ -3333,12 +3520,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);
@@ -3539,8 +3727,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])
@@ -3586,7 +3774,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;
@@ -3672,7 +3860,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) => {
@@ -3683,16 +3870,6 @@ function versionClaims(version, servingBuild) {
   return claims;
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.8.0/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
-var CHUNK_PREFIX = "@nf-internal";
-function toChunkImport(fileName) {
-  if (fileName.startsWith("./")) {
-    fileName = fileName.slice(2);
-  }
-  const packageName = fileName.replace(/.(m|c)?js$/, "");
-  return CHUNK_PREFIX + "/" + packageName;
-}
-
 // src/lib/core/2.app/steps/generate-import-map.ts
 function createGenerateImportMap(config, ports) {
   return () => {
@@ -4251,18 +4428,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]);
@@ -4280,20 +4458,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;
@@ -4302,15 +4494,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 };
     }
@@ -4331,9 +4524,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)))
@@ -4410,16 +4601,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();
@@ -4462,14 +4662,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) {
@@ -4483,12 +4699,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];
@@ -4566,14 +4782,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);
@@ -4598,13 +4817,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) => {
@@ -4620,7 +4847,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);
@@ -5005,7 +5233,9 @@ var resolveHostInstances = async (option, deps) => {
   const entry = await deps.remoteEntryProvider.provide(url, { integrity });
   const load = auto.load ?? ((specifier) => import(specifier));
   const specifiers = [
-    ...new Set((entry.shared ?? []).filter((s) => s.singleton).map((s) => s.packageName))
+    ...new Set(
+      (entry.shared ?? []).filter((s) => s.singleton).flatMap((s) => Object.keys(s.entries))
+    )
   ].filter((s) => auto.include ? matches(s, auto.include) : true).filter((s) => auto.exclude ? !matches(s, auto.exclude) : true);
   const map = {};
   for (const specifier of specifiers) {
@@ -5041,7 +5271,7 @@ var HOST_INSTANCES_GLOBAL = "__NF_HOST_INSTANCES__";
 var buildNodeAdapters = (config) => ({
   versionCheck: createVersionCheck(),
   manifestProvider: createFsManifestProvider(),
-  remoteEntryProvider: createFsRemoteEntryProvider(),
+  remoteEntryProvider: createFsRemoteEntryProvider(config),
   remoteInfoRepo: createRemoteInfoRepository(config),
   scopedExternalsRepo: createScopedExternalsRepository(config),
   sharedExternalsRepo: createSharedExternalsRepository(config),