@softarc/native-federation-orchestrator 4.4.1 → 4.5.0

package/fesm2022/node.mjs

@@ -1560,7 +1560,14 @@ var createSharedExternalsRepository = (config) => {
   );
   if (config.clearStorage) STORAGE.clear();
   const _cache = STORAGE.get();
+  let _sawPoolTag = false;
   return {
+    markPoolTagPresent: function() {
+      _sawPoolTag = true;
+    },
+    hasPoolTag: function() {
+      return _sawPoolTag;
+    },
     getFromScope: function(shareScope) {
       return { ..._cache[shareScope ?? GLOBAL_SCOPE] };
     },
@@ -1871,7 +1878,11 @@ var createModeConfig = (override) => {
   };
   return {
     strict: strictnessConfig,
-    profile: { ...defaultProfile, ...override.profile ?? {} }
+    profile: { ...defaultProfile, ...override.profile ?? {} },
+    feature: {
+      convertFlatSharedInfo: override.feature?.convertFlatSharedInfo ?? false,
+      useAutoExternalPooling: override.feature?.useAutoExternalPooling ?? false
+    }
   };
 };
 
@@ -1890,7 +1901,7 @@ var createInitFlow = ({
   adapters,
   config
 }) => {
-  return (remotesOrManifestUrl) => flow.getRemoteEntries(remotesOrManifestUrl).then(flow.processRemoteEntries).then(flow.determineSharedExternals).then(flow.generateImportMap).then((importMap) => flow.commitChanges(importMap, { override: true })).then(flow.exposeModuleLoader).then((loadRemoteModule) => ({
+  return (remotesOrManifestUrl) => flow.getRemoteEntries(remotesOrManifestUrl).then(flow.processRemoteEntries).then(flow.determineSharedExternals).then(flow.poolSharedExternals).then(flow.generateImportMap).then((importMap) => flow.commitChanges(importMap, { override: true })).then(flow.exposeModuleLoader).then((loadRemoteModule) => ({
     config,
     adapters,
     loadRemoteModule
@@ -1901,7 +1912,7 @@ var createInitFlow = ({
 var createInitRemoteEntryFlow = ({
   flow
 }) => {
-  const processDynamicRemoteEntry = (remoteEntry) => flow.updateCache(remoteEntry).then(flow.convertToImportMap).then(flow.commitChanges);
+  const processDynamicRemoteEntry = (remoteEntry) => flow.updateCache(remoteEntry).then(flow.poolDynamicExternals).then(flow.convertToImportMap).then(flow.commitChanges);
   return (remoteEntryUrl, remote) => flow.getRemoteEntry(remoteEntryUrl, remote).then((entry) => entry.map(processDynamicRemoteEntry).orElse(Promise.resolve())).then(() => void 0);
 };
 
@@ -2037,6 +2048,7 @@ function createStoreRemoteEntry(config, ports, logStep) {
       const tag = resolveVersion(remoteEntry, external);
       if (tag === null) return;
       if (external.singleton) {
+        if (external.pool?.trim()) ports.sharedExternalsRepo.markPoolTagPresent();
         onSharedExternal(remoteEntry, external, sharedExternalContext(remoteEntry, external, tag));
       } else {
         addScopedExternal(remoteEntry, external, tag);
@@ -2056,8 +2068,8 @@ function createStoreRemoteEntry(config, ports, logStep) {
   function addScopedExternal(remoteEntry, sharedInfo, tag) {
     ports.scopedExternalsRepo.addExternal(remoteEntry.name, sharedInfo.packageName, {
       tag,
-      file: sharedInfo.outFileName,
-      bundle: sharedInfo.bundle
+      bundle: sharedInfo.bundle,
+      entries: sharedInfo.entries
     });
   }
   function resolveVersion(remoteEntry, external) {
@@ -2079,12 +2091,13 @@ function createStoreRemoteEntry(config, ports, logStep) {
   function sharedExternalContext(remoteEntry, sharedInfo, tag) {
     const scopeType = ports.sharedExternalsRepo.scopeType(sharedInfo.shareScope);
     const remote = {
-      file: sharedInfo.outFileName,
       name: remoteEntry.name,
       bundle: sharedInfo.bundle,
       strictVersion: sharedInfo.strictVersion,
       cached: false,
-      requiredVersion: scopeType === "strict" ? tag : sharedInfo.requiredVersion || tag
+      requiredVersion: scopeType === "strict" ? tag : sharedInfo.requiredVersion || tag,
+      ...sharedInfo.pool?.trim() ? { pool: sharedInfo.pool } : {},
+      entries: sharedInfo.entries
     };
     const cached2 = ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).orElse({ dirty: false, versions: [] });
     return {
@@ -2232,7 +2245,290 @@ function createDetermineSharedExternals(config, ports) {
   }
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.2.1_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
+// src/lib/core/2.app/steps/pooling/pool-graph.ts
+var SCOPED_PACKAGE = /^@([^/]+)\//;
+function createDSU() {
+  const ids = /* @__PURE__ */ new Map();
+  const parent = [];
+  const size = [];
+  const intern = (key) => {
+    let id = ids.get(key);
+    if (id === void 0) {
+      id = parent.length;
+      ids.set(key, id);
+      parent.push(id);
+      size.push(1);
+    }
+    return id;
+  };
+  const findRoot = (x) => {
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  };
+  return {
+    union(a, b) {
+      let rootA = findRoot(intern(a));
+      let rootB = findRoot(intern(b));
+      if (rootA === rootB) return;
+      if (size[rootA] < size[rootB]) [rootA, rootB] = [rootB, rootA];
+      parent[rootB] = rootA;
+      size[rootA] = size[rootA] + size[rootB];
+    },
+    // Interns the key if unseen — an isolated key is its own component.
+    component(key) {
+      return findRoot(intern(key));
+    }
+  };
+}
+var extNode = (name) => `ext\0${name}`;
+var tagNode = (remote, tag) => `tag\0${remote}\0${tag}`;
+var scopeNode = (scope) => `scope\0${scope}`;
+function autoScope(name, useAutoExternalPooling) {
+  return useAutoExternalPooling ? SCOPED_PACKAGE.exec(name)?.[1] : void 0;
+}
+function groupByMembership(candidates, log) {
+  const dsu = createDSU();
+  const tagged = /* @__PURE__ */ new Set();
+  const poolable = [];
+  for (const candidate of candidates) {
+    let joined = false;
+    if (candidate.scope !== void 0) {
+      dsu.union(extNode(candidate.name), scopeNode(candidate.scope));
+      joined = true;
+    }
+    for (const edge of candidate.tags) {
+      dsu.union(extNode(candidate.name), tagNode(edge.remote, edge.tag));
+      tagged.add(candidate.name);
+      joined = true;
+    }
+    if (joined) poolable.push({ name: candidate.name, value: candidate.value });
+  }
+  const byComponent = /* @__PURE__ */ new Map();
+  for (const entry of poolable) {
+    const root = dsu.component(extNode(entry.name));
+    (byComponent.get(root) ?? byComponent.set(root, []).get(root)).push(entry);
+  }
+  const pools = [];
+  for (const members of byComponent.values()) {
+    members.sort((a, b) => a.name.localeCompare(b.name));
+    if (members.length < 2) {
+      const only = members[0];
+      if (tagged.has(only.name)) {
+        log?.warn(
+          3,
+          `[${only.name}] declares a 'pool' tag but no other external joined its pool; likely a typo or a missing sibling.`
+        );
+      }
+      continue;
+    }
+    pools.push(members);
+  }
+  pools.sort((a, b) => a[0].name.localeCompare(b[0].name));
+  return new Map(pools.map((members) => [members[0].name, members.map((m) => m.value)]));
+}
+function buildPools(sharedExternals, useAutoExternalPooling, log) {
+  const candidates = Object.entries(sharedExternals).map(
+    ([name, external]) => ({
+      name,
+      scope: autoScope(name, useAutoExternalPooling),
+      tags: external.versions.flatMap(
+        (v) => v.remotes.flatMap((r) => {
+          const tag = r.pool?.trim();
+          return tag ? [{ remote: r.name, tag }] : [];
+        })
+      ),
+      value: { name, external }
+    })
+  );
+  return groupByMembership(candidates, log);
+}
+
+// src/lib/core/2.app/steps/pooling/pool.util.ts
+function versionForRemote(member, remote) {
+  return member.external.versions.find((v) => v.remotes.some((r) => r.name === remote));
+}
+function remotesInPool(members) {
+  return [
+    ...new Set(members.flatMap((m) => m.external.versions.flatMap((v) => v.remotes.map((r) => r.name))))
+  ];
+}
+
+// src/lib/core/2.app/steps/pooling/pool-shared-externals.ts
+function poolWinners(members) {
+  return members.map((member) => {
+    const share = member.external.versions.find((v) => v.action === "share");
+    return {
+      member,
+      tag: share?.tag ?? "",
+      providers: new Set((share?.remotes ?? []).map((r) => r.name))
+    };
+  });
+}
+function selectCoverageAnchor(winners) {
+  const coverage = /* @__PURE__ */ new Map();
+  for (const winner of winners)
+    for (const remote of winner.providers) coverage.set(remote, (coverage.get(remote) ?? 0) + 1);
+  if (coverage.size === 0) return void 0;
+  const anchorRemote = [...coverage.keys()].sort(
+    (a, b) => coverage.get(b) - coverage.get(a) || a.localeCompare(b)
+  )[0];
+  return {
+    anchorRemote,
+    tagPerMember: Object.fromEntries(
+      winners.filter((w) => w.providers.has(anchorRemote)).map((w) => [w.member.name, w.tag])
+    )
+  };
+}
+function classifyPoolConservative(members, anchor) {
+  const classification = /* @__PURE__ */ new Map();
+  for (const remote of remotesInPool(members)) {
+    let coverageForced = false;
+    let verdict = "follow";
+    for (const member of members) {
+      const version = versionForRemote(member, remote);
+      if (!version) continue;
+      const anchorTag = anchor.tagPerMember[member.name];
+      if (!anchorTag) {
+        coverageForced = true;
+        continue;
+      }
+      if (version.tag === anchorTag) continue;
+      if (version.action === "scope") {
+        verdict = "scope-incompat";
+        break;
+      }
+    }
+    classification.set(
+      remote,
+      verdict === "scope-incompat" ? "scope-incompat" : coverageForced ? "scope-coverage" : "follow"
+    );
+  }
+  classification.set(anchor.anchorRemote, "follow");
+  return classification;
+}
+function createPoolSharedExternals(config, ports) {
+  return () => {
+    const { useAutoExternalPooling } = config.feature;
+    if (!useAutoExternalPooling && !ports.sharedExternalsRepo.hasPoolTag()) {
+      return Promise.resolve();
+    }
+    for (const scope of ports.sharedExternalsRepo.getScopes()) {
+      if (ports.sharedExternalsRepo.scopeType(scope) === "strict") continue;
+      const sharedExternals = ports.sharedExternalsRepo.getFromScope(scope);
+      try {
+        for (const [poolName, members] of buildPools(
+          sharedExternals,
+          useAutoExternalPooling,
+          config.log
+        )) {
+          poolFamily(poolName, members, scope);
+        }
+      } catch (error) {
+        if (error instanceof NFError) return Promise.reject(error);
+        config.log.error(3, `[${scope}] failed to pool shared externals.`, {
+          sharedExternals,
+          error
+        });
+        return Promise.reject(
+          new NFError(`Could not pool shared externals in scope ${scope}.`, error)
+        );
+      }
+    }
+    return Promise.resolve();
+  };
+  function poolFamily(poolName, members, scope) {
+    if (members.length < 2) return;
+    const allRemotes = remotesInPool(members);
+    if (allRemotes.length < 2) return;
+    const anchor = selectCoverageAnchor(poolWinners(members));
+    if (!anchor) return;
+    const classification = classifyPoolConservative(members, anchor);
+    config.log.debug(
+      3,
+      `[${scope}][pool:${poolName}] members=[${members.map((m) => m.name).join(", ")}], anchor=${anchor.anchorRemote}, remotes={${allRemotes.map((r) => `${r}:${classification.get(r)}`).join(", ")}}`
+    );
+    const incompatForced = allRemotes.some((r) => classification.get(r) === "scope-incompat");
+    if (incompatForced && config.strict.strictExternalCompatibility) {
+      config.log.error(
+        3,
+        `[${scope}][pool:${poolName}] A remote is version-incompatible with anchor '${anchor.anchorRemote}'.`
+      );
+      throw new NFError(`Could not pool '${poolName}' in scope ${scope}.`);
+    }
+    for (const member of members) {
+      const rebuilt = rebuildMember(member, anchor, classification);
+      warnIfScopedOnly(poolName, member.name, rebuilt, scope);
+      ports.sharedExternalsRepo.addOrUpdate(member.name, rebuilt, scope);
+    }
+  }
+  function warnIfScopedOnly(poolName, memberName, rebuilt, scope) {
+    if (rebuilt.versions.some((v) => v.action === "share")) return;
+    const copies = rebuilt.versions.reduce((n, v) => n + v.remotes.length, 0);
+    config.log.warn(
+      3,
+      `[${scope}][pool:${poolName}] '${memberName}' is scoped-only \u2014 no coherent shared build provides it; ${copies} remotes download their own copy.`
+    );
+  }
+  function rebuildMember(member, anchor, classification) {
+    const anchorTag = anchor.tagPerMember[member.name];
+    const entries = member.external.versions.flatMap(
+      (v) => v.remotes.map((meta) => ({ remote: meta.name, tag: v.tag, host: v.host, meta }))
+    );
+    if (!anchorTag) {
+      return {
+        dirty: false,
+        versions: entries.length > 0 ? [
+          {
+            tag: entries[0].tag,
+            host: false,
+            action: "scope",
+            remotes: entries.map((e) => e.meta)
+          }
+        ] : []
+      };
+    }
+    const anchorMeta = entries.find(
+      (e) => e.remote === anchor.anchorRemote && e.tag === anchorTag
+    ).meta;
+    const anchorHost = member.external.versions.find((v) => v.tag === anchorTag)?.host ?? false;
+    const scopes = (e) => {
+      const cls = classification.get(e.remote);
+      return cls === "scope-incompat" || cls === "scope-coverage" && e.tag !== anchorTag;
+    };
+    const shareOnAnchor = entries.filter(
+      (e) => e.remote !== anchor.anchorRemote && e.tag === anchorTag && !scopes(e)
+    );
+    const shareVersion = {
+      tag: anchorTag,
+      host: anchorHost,
+      action: "share",
+      remotes: [anchorMeta, ...shareOnAnchor.map((e) => e.meta)]
+    };
+    const skipByTag = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      if (e.tag === anchorTag || scopes(e)) continue;
+      const version = skipByTag.get(e.tag) ?? {
+        tag: e.tag,
+        host: e.host,
+        action: "skip",
+        remotes: []
+      };
+      version.remotes.push(e.meta);
+      skipByTag.set(e.tag, version);
+    }
+    const scoped = entries.filter((e) => scopes(e));
+    const scopeVersion = scoped.length > 0 ? [{ tag: anchorTag, host: false, action: "scope", remotes: scoped.map((e) => e.meta) }] : [];
+    return {
+      dirty: false,
+      versions: [shareVersion, ...skipByTag.values(), ...scopeVersion]
+    };
+  }
+}
+
+// node_modules/.pnpm/@softarc+native-federation@4.3.0_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
 var CHUNK_PREFIX = "@nf-internal";
 function toChunkImport(fileName) {
   if (fileName.startsWith("./")) {
@@ -2267,12 +2563,9 @@ function createGenerateImportMap(config, ports) {
       });
       addToScope(importMap, remote.scopeUrl, createScopeModules(externals, remote.scopeUrl));
       for (const version of Object.values(externals)) {
-        addIntegrity(
-          importMap,
-          join(remote.scopeUrl, version.file),
-          remoteName,
-          version.file
-        );
+        for (const file of Object.values(version.entries)) {
+          addIntegrity(importMap, join(remote.scopeUrl, file), remoteName, file);
+        }
       }
       Object.values(externals).filter((e) => !!e.bundle).forEach((e) => registerBundleChunks(chunkBundles, remoteName, e.bundle));
     }
@@ -2280,8 +2573,10 @@ function createGenerateImportMap(config, ports) {
   }
   function createScopeModules(externals, scope) {
     const modules = {};
-    for (const [external, version] of Object.entries(externals)) {
-      modules[external] = join(scope, version.file);
+    for (const version of Object.values(externals)) {
+      for (const [packageName, file] of Object.entries(version.entries)) {
+        modules[packageName] = join(scope, file);
+      }
     }
     return modules;
   }
@@ -2301,47 +2596,49 @@ function createGenerateImportMap(config, ports) {
         if (version.action === "scope") {
           for (const remote of version.remotes) {
             const remoteScope = getScope2(shareScope, remote.name, externalName);
-            const url = join(remoteScope, remote.file);
-            addToScope(importMap, remoteScope, {
-              [externalName]: url
-            });
-            addIntegrity(importMap, url, remote.name, remote.file);
+            for (const [packageName, file] of Object.entries(remote.entries)) {
+              const url = join(remoteScope, file);
+              addToScope(importMap, remoteScope, { [packageName]: url });
+              addIntegrity(importMap, url, remote.name, file);
+            }
             registerBundleChunks(chunkBundles, remote.name, remote.bundle);
             remote.cached = true;
           }
           continue;
         }
-        const scope = getScope2(shareScope, version.remotes[0].name, externalName);
-        let targetFileUrl = join(scope, version.remotes[0].file);
-        let targetFileSource = {
-          name: version.remotes[0].name,
-          file: version.remotes[0].file
-        };
         version.remotes[0].cached = true;
+        let source = version.remotes[0];
+        let sourceScope = getScope2(shareScope, source.name, externalName);
         if (version.action === "share") {
-          registerBundleChunks(chunkBundles, version.remotes[0].name, version.remotes[0].bundle);
-        }
-        if (version.action === "skip") {
+          registerBundleChunks(chunkBundles, source.name, source.bundle);
+        } else if (version.action === "skip") {
           if (!override) {
             override = findOverride(external, shareScope, externalName) ?? "NOT_AVAILABLE";
           }
           if (override !== "NOT_AVAILABLE") {
             if (!overrideScope)
               overrideScope = getScope2(shareScope, override.remotes[0].name, externalName);
-            targetFileUrl = join(overrideScope, override.remotes[0].file);
-            targetFileSource = {
-              name: override.remotes[0].name,
-              file: override.remotes[0].file
-            };
+            source = override.remotes[0];
+            sourceScope = overrideScope;
             override.remotes[0].cached = true;
             version.remotes[0].cached = false;
           }
         }
+        const mappings = Object.entries(source.entries).map(([packageName, file]) => ({
+          packageName,
+          url: join(sourceScope, file),
+          name: source.name,
+          file
+        }));
         version.remotes.forEach((r) => {
-          const scope2 = getScope2(shareScope, r.name, externalName);
-          addToScope(importMap, scope2, { [externalName]: targetFileUrl });
+          const rScope = getScope2(shareScope, r.name, externalName);
+          for (const m of mappings) {
+            addToScope(importMap, rScope, { [m.packageName]: m.url });
+          }
         });
-        addIntegrity(importMap, targetFileUrl, targetFileSource.name, targetFileSource.file);
+        for (const m of mappings) {
+          addIntegrity(importMap, m.url, m.name, m.file);
+        }
       }
       ports.sharedExternalsRepo.addOrUpdate(externalName, external, shareScope);
     }
@@ -2382,11 +2679,11 @@ function createGenerateImportMap(config, ports) {
         if (version.action === "scope") {
           for (const remote of version.remotes) {
             const remoteScope = getScope2(GLOBAL_SCOPE, remote.name, externalName);
-            const url2 = join(remoteScope, remote.file);
-            addToScope(importMap, remoteScope, {
-              [externalName]: url2
-            });
-            addIntegrity(importMap, url2, remote.name, remote.file);
+            for (const [packageName, file] of Object.entries(remote.entries)) {
+              const url = join(remoteScope, file);
+              addToScope(importMap, remoteScope, { [packageName]: url });
+              addIntegrity(importMap, url, remote.name, file);
+            }
             remote.cached = true;
             registerBundleChunks(chunkBundles, remote.name, remote.bundle);
           }
@@ -2397,9 +2694,11 @@ function createGenerateImportMap(config, ports) {
           continue;
         }
         const scope = getScope2(GLOBAL_SCOPE, version.remotes[0].name, externalName);
-        const url = join(scope, version.remotes[0].file);
-        addToGlobal(importMap, { [externalName]: url });
-        addIntegrity(importMap, url, version.remotes[0].name, version.remotes[0].file);
+        for (const [packageName, file] of Object.entries(version.remotes[0].entries)) {
+          const url = join(scope, file);
+          addToGlobal(importMap, { [packageName]: url });
+          addIntegrity(importMap, url, version.remotes[0].name, file);
+        }
         registerBundleChunks(chunkBundles, version.remotes[0].name, version.remotes[0].bundle);
         version.remotes[0].cached = true;
       }
@@ -2596,8 +2895,8 @@ function createUpdateCache(config, ports) {
       storeRemoteEntry(remoteEntry, (entry, external, ctx) => {
         const { action, sharedVersion } = resolveSharedExternal(entry, external, ctx);
         actions[external.packageName] = { action };
-        if (action === "skip" && external.shareScope && sharedVersion?.remotes[0]?.file) {
-          actions[external.packageName].override = resolveOverrideUrl(
+        if (action === "skip" && external.shareScope && sharedVersion?.remotes[0]?.entries) {
+          actions[external.packageName].override = resolveOverrideEntries(
             entry,
             external,
             sharedVersion
@@ -2641,8 +2940,15 @@ function createUpdateCache(config, ports) {
     commit();
     return { action, sharedVersion };
   }
-  function resolveOverrideUrl(remoteEntry, external, sharedVersion) {
-    return ports.remoteInfoRepo.tryGet(sharedVersion.remotes[0].name).map((remote) => join(remote.scopeUrl, sharedVersion.remotes[0].file)).orThrow(() => {
+  function resolveOverrideEntries(remoteEntry, external, sharedVersion) {
+    return ports.remoteInfoRepo.tryGet(sharedVersion.remotes[0].name).map(
+      (remote) => Object.fromEntries(
+        Object.entries(sharedVersion.remotes[0].entries).map(([packageName, file]) => [
+          packageName,
+          join(remote.scopeUrl, file)
+        ])
+      )
+    ).orThrow(() => {
       config.log.error(
         8,
         `[${external.shareScope ?? GLOBAL_SCOPE}][${remoteEntry.name}][${external.packageName}@${external.version}][override] Remote name not found in cache.`
@@ -2654,14 +2960,56 @@ function createUpdateCache(config, ports) {
   }
 }
 
-// src/lib/core/2.app/steps/convert-to-import-map.ts
-function createConvertToImportMap({ log }, ports) {
+// src/lib/core/2.app/steps/pooling/pool-dynamic-externals.ts
+function createPoolDynamicExternals(config) {
   return ({ entry, actions }) => {
+    const { useAutoExternalPooling } = config.feature;
+    if (!useAutoExternalPooling && !(entry.shared ?? []).some((e) => e.pool?.trim())) {
+      return Promise.resolve({ entry, actions });
+    }
+    const byScope = /* @__PURE__ */ new Map();
+    for (const external of entry.shared ?? []) {
+      const name = external.packageName;
+      if (!external.singleton || !actions[name]) continue;
+      if (external.shareScope === STRICT_SCOPE) continue;
+      const tag = external.pool?.trim();
+      const shareScope = external.shareScope ?? GLOBAL_SCOPE;
+      const candidates = byScope.get(shareScope) ?? [];
+      candidates.push({
+        name,
+        scope: autoScope(name, useAutoExternalPooling),
+        tags: tag ? [{ remote: entry.name, tag }] : [],
+        value: name
+      });
+      byScope.set(shareScope, candidates);
+    }
+    const scope = (name) => {
+      actions[name].action = "scope";
+      delete actions[name].override;
+    };
+    for (const candidates of byScope.values()) {
+      for (const members of groupByMembership(candidates).values()) {
+        const memberActions = members.map((name) => actions[name].action);
+        if (memberActions.includes("scope")) {
+          members.forEach(scope);
+        } else if (memberActions.includes("share") && memberActions.includes("skip")) {
+          members.filter((name) => actions[name].action === "share").forEach(scope);
+        }
+      }
+    }
+    return Promise.resolve({ entry, actions });
+  };
+}
+
+// src/lib/core/2.app/steps/convert-to-import-map.ts
+function createConvertToImportMap(config, ports) {
+  const { log } = config;
+  return async ({ entry, actions }) => {
     const importMap = { imports: {} };
     addExternals(entry, actions, importMap);
     addRemoteInfos(entry, importMap);
     log.debug(9, `[${entry.name}] Processed actions:`, actions);
-    return Promise.resolve(importMap);
+    return importMap;
   };
   function addExternals(remoteEntry, actions, importMap) {
     if (!remoteEntry.shared) {
@@ -2672,9 +3020,11 @@ function createConvertToImportMap({ log }, ports) {
     const chunkBundles = /* @__PURE__ */ new Set(["mapping-or-exposed"]);
     remoteEntry.shared.forEach((external) => {
       if (!external.singleton) {
-        const url2 = join(remoteEntryScope, external.outFileName);
-        addToScopes(remoteEntryScope, external.packageName, url2, importMap);
-        addIntegrity(importMap, url2, integrityMap, external.outFileName);
+        Object.entries(external.entries).forEach(([packageName, fileName]) => {
+          const url = join(remoteEntryScope, fileName);
+          addToScopes(remoteEntryScope, packageName, url, importMap);
+          addIntegrity(importMap, url, integrityMap, fileName);
+        });
         if (external?.bundle) chunkBundles.add(external?.bundle);
         return;
       }
@@ -2686,33 +3036,48 @@ function createConvertToImportMap({ log }, ports) {
         return;
       }
       if (actions[external.packageName].action === "skip") {
+        const override = actions[external.packageName].override;
         if (!external.shareScope) return;
-        if (actions[external.packageName].override) {
-          addToScopes(
-            remoteEntryScope,
-            external.packageName,
-            actions[external.packageName].override,
-            importMap
-          );
+        if (override) {
+          Object.entries(override).forEach(([packageName, url]) => {
+            addToScopes(remoteEntryScope, packageName, url, importMap);
+          });
           return;
         }
+        log.error(
+          9,
+          `[${remoteEntry.name}][${external.packageName}] shareScope skip has no override.`
+        );
+        if (config.strict.strictImportMap) throw new NFError("Could not create ImportMap.");
+        Object.entries(external.entries).forEach(([packageName, fileName]) => {
+          const url = join(remoteEntryScope, fileName);
+          addToScopes(remoteEntryScope, packageName, url, importMap);
+          addIntegrity(importMap, url, integrityMap, fileName);
+        });
+        return;
       }
       if (external?.bundle) chunkBundles.add(external?.bundle);
       if (actions[external.packageName].action === "scope") {
-        const url2 = join(remoteEntryScope, external.outFileName);
-        addToScopes(remoteEntryScope, external.packageName, url2, importMap);
-        addIntegrity(importMap, url2, integrityMap, external.outFileName);
+        Object.entries(external.entries).forEach(([packageName, fileName]) => {
+          const url = join(remoteEntryScope, fileName);
+          addToScopes(remoteEntryScope, packageName, url, importMap);
+          addIntegrity(importMap, url, integrityMap, fileName);
+        });
         return;
       }
       if (external.shareScope) {
-        const url2 = join(remoteEntryScope, external.outFileName);
-        addToScopes(remoteEntryScope, external.packageName, url2, importMap);
-        addIntegrity(importMap, url2, integrityMap, external.outFileName);
+        Object.entries(external.entries).forEach(([packageName, fileName]) => {
+          const url = join(remoteEntryScope, fileName);
+          addToScopes(remoteEntryScope, packageName, url, importMap);
+          addIntegrity(importMap, url, integrityMap, fileName);
+        });
         return;
       }
-      const url = join(remoteEntryScope, external.outFileName);
-      importMap.imports[external.packageName] = url;
-      addIntegrity(importMap, url, integrityMap, external.outFileName);
+      Object.entries(external.entries).forEach(([packageName, fileName]) => {
+        const url = join(remoteEntryScope, fileName);
+        importMap.imports[packageName] = url;
+        addIntegrity(importMap, url, integrityMap, fileName);
+      });
     });
     addChunkImports(importMap, remoteEntry, remoteEntryScope, chunkBundles);
   }
@@ -2759,11 +3124,13 @@ var createInitDrivers = ({
   getRemoteEntries: createGetRemoteEntries(config, adapters),
   processRemoteEntries: createProcessRemoteEntries(config, adapters),
   determineSharedExternals: createDetermineSharedExternals(config, adapters),
+  poolSharedExternals: createPoolSharedExternals(config, adapters),
   generateImportMap: createGenerateImportMap(config, adapters),
   commitChanges: createCommitChanges(config, adapters),
   exposeModuleLoader: createExposeModuleLoader(config, adapters),
   getRemoteEntry: createGetRemoteEntry(config, adapters),
   updateCache: createUpdateCache(config, adapters),
+  poolDynamicExternals: createPoolDynamicExternals(config),
   convertToImportMap: createConvertToImportMap(config, adapters)
 });
 var INIT_FLOW_FACTORY = ({