@softarc/native-federation-orchestrator 4.4.0 → 4.5.0

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

@@ -1283,7 +1283,7 @@ var createInitFlow = ({
   adapters,
   config
 }) => {
-  return (remotesOrManifestUrl) => flow.getRemoteEntries(remotesOrManifestUrl).then(flow.processRemoteEntries).then(flow.determineSharedExternals).then(flow.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
@@ -1294,7 +1294,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);
 };
 
@@ -1335,16 +1335,25 @@ function createGetRemoteEntries(config, ports) {
   };
   function addHostRemoteEntry(manifest) {
     if (!config.hostRemoteEntry) return manifest;
-    const { name, url, cacheTag, integrity } = config.hostRemoteEntry;
-    const urlWithCache = cacheTag ? `${url}?cacheTag=${cacheTag}` : url;
+    const { name, url, integrity } = config.hostRemoteEntry;
     return {
       ...manifest,
-      [name]: integrity ? { url: urlWithCache, integrity } : urlWithCache
+      [name]: integrity ? { url, integrity } : url
     };
   }
   function normalizeEntry(descriptor) {
     return typeof descriptor === "string" ? { url: descriptor } : descriptor;
   }
+  function withCacheTag(url, cacheTag) {
+    if (!cacheTag) return url;
+    return `${url}${url.includes("?") ? "&" : "?"}cacheTag=${cacheTag}`;
+  }
+  function resolveCacheTag(remoteName) {
+    if (config.hostRemoteEntry && remoteName === config.hostRemoteEntry.name && config.hostRemoteEntry.cacheTag) {
+      return config.hostRemoteEntry.cacheTag;
+    }
+    return config.profile.cacheTag;
+  }
   async function fetchRemoteEntries(manifest) {
     const fetchPromises = Object.entries(manifest).map(
       ([remoteName, descriptor]) => fetchRemoteEntry(remoteName, descriptor)
@@ -1365,8 +1374,9 @@ function createGetRemoteEntries(config, ports) {
       }
     });
     if (skip) return false;
+    const fetchUrl = withCacheTag(remoteEntryUrl, resolveCacheTag(remoteName));
     try {
-      const remoteEntry = integrity ? await ports.remoteEntryProvider.provide(remoteEntryUrl, { integrity }) : await ports.remoteEntryProvider.provide(remoteEntryUrl);
+      const remoteEntry = integrity ? await ports.remoteEntryProvider.provide(fetchUrl, { integrity }) : await ports.remoteEntryProvider.provide(fetchUrl);
       config.log.debug(
         1,
         `Fetched '${remoteEntry.name}' from '${remoteEntry.url}', exposing: ${JSON.stringify(remoteEntry.exposes)}`
@@ -1444,6 +1454,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);
@@ -1463,8 +1474,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) {
@@ -1486,12 +1497,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 cached = ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).orElse({ dirty: false, versions: [] });
     return {
@@ -1566,6 +1578,66 @@ function createProcessRemoteEntries(config, ports) {
 var GLOBAL_SCOPE = "__GLOBAL__";
 var STRICT_SCOPE = "strict";
 
+// src/lib/core/1.domain/remote-entry/remote-entry.contract.ts
+var CHUNK_PREFIX = "@nf-internal";
+function toDenseSharedInfoFormat(shared) {
+  return shared.map((external) => {
+    if ("entries" in external) return external;
+    const { outFileName, ...baseSharedInfoProps } = external;
+    return {
+      ...baseSharedInfoProps,
+      entries: { [external.packageName]: outFileName }
+    };
+  });
+}
+function inferPackageFromSecondary(secondary) {
+  const parts = secondary.split("/");
+  if (secondary.startsWith("@") && parts.length >= 2) {
+    return parts[0] + "/" + parts[1];
+  }
+  return parts[0] ?? secondary;
+}
+function densifyExternals(shared) {
+  const result = [];
+  const groupIndex = /* @__PURE__ */ new Map();
+  for (const entry of shared) {
+    const isDense = "entries" in entry;
+    const isChunk = entry.packageName.startsWith(CHUNK_PREFIX + "/");
+    if (isDense || isChunk) {
+      result.push(entry);
+      continue;
+    }
+    const parent = inferPackageFromSecondary(entry.packageName);
+    const sig = JSON.stringify({
+      singleton: entry.singleton,
+      strictVersion: entry.strictVersion,
+      requiredVersion: entry.requiredVersion,
+      version: entry.version,
+      shareScope: entry.shareScope
+    });
+    const key = parent + " " + sig;
+    const existing = groupIndex.get(key);
+    if (existing === void 0) {
+      const dense = {
+        singleton: entry.singleton,
+        strictVersion: entry.strictVersion,
+        requiredVersion: entry.requiredVersion,
+        packageName: parent,
+        entries: { [entry.packageName]: entry.outFileName }
+      };
+      if (entry.version !== void 0) dense.version = entry.version;
+      if (entry.shareScope !== void 0) dense.shareScope = entry.shareScope;
+      if (entry.bundle !== void 0) dense.bundle = entry.bundle;
+      if (entry.dev !== void 0) dense.dev = entry.dev;
+      groupIndex.set(key, result.length);
+      result.push(dense);
+    } else {
+      result[existing].entries[entry.packageName] = entry.outFileName;
+    }
+  }
+  return result;
+}
+
 // src/lib/core/2.app/steps/determine-shared-externals.ts
 function createDetermineSharedExternals(config, ports) {
   return () => {
@@ -1643,7 +1715,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/build-notification-options.contract.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/build-notification-options.contract.js
 var BuildNotificationType = /* @__PURE__ */ ((BuildNotificationType2) => {
   BuildNotificationType2["COMPLETED"] = "federation-rebuild-complete";
   BuildNotificationType2["ERROR"] = "federation-rebuild-error";
@@ -1651,14 +2006,14 @@ var BuildNotificationType = /* @__PURE__ */ ((BuildNotificationType2) => {
   return BuildNotificationType2;
 })(BuildNotificationType || {});
 
-// node_modules/.pnpm/@softarc+native-federation@4.2.1_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
-var CHUNK_PREFIX = "@nf-internal";
+// 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_PREFIX2 = "@nf-internal";
 function toChunkImport(fileName) {
   if (fileName.startsWith("./")) {
     fileName = fileName.slice(2);
   }
   const packageName = fileName.replace(/.(m|c)?js$/, "");
-  return CHUNK_PREFIX + "/" + packageName;
+  return CHUNK_PREFIX2 + "/" + packageName;
 }
 
 // src/lib/core/2.app/steps/generate-import-map.ts
@@ -1686,12 +2041,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));
     }
@@ -1699,8 +2051,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;
   }
@@ -1720,47 +2074,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);
     }
@@ -1801,11 +2157,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);
           }
@@ -1816,9 +2172,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;
       }
@@ -2054,8 +2412,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
@@ -2099,8 +2457,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.`
@@ -2112,14 +2477,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) {
@@ -2130,9 +2537,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;
       }
@@ -2144,33 +2553,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);
   }
@@ -2217,11 +2641,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 = ({
@@ -2333,7 +2759,7 @@ var createManifestProvider = () => {
 };
 
 // src/lib/core/3.adapters/http/remote-entry-provider.ts
-var createRemoteEntryProvider = () => {
+var createRemoteEntryProvider = (config) => {
   const ensureOk = (response) => {
     if (!response.ok)
       return Promise.reject(new Error(`${response.status} - ${response.statusText}`));
@@ -2345,6 +2771,10 @@ var createRemoteEntryProvider = () => {
     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}`);
@@ -2357,7 +2787,7 @@ var createRemoteEntryProvider = () => {
         await verifyIntegrity(bytes, opts.integrity);
         return JSON.parse(new TextDecoder().decode(bytes));
       };
-      return fetch(remoteEntryUrl).then(ensureOk).then(parse).then(fillEmptyFields(remoteEntryUrl)).catch(formatError(remoteEntryUrl));
+      return fetch(remoteEntryUrl).then(ensureOk).then(parse).then(normalizeRemoteEntry).then(fillEmptyFields(remoteEntryUrl)).catch(formatError(remoteEntryUrl));
     }
   };
 };
@@ -2433,7 +2863,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] };
     },
@@ -2543,7 +2980,7 @@ var createDriving = (config) => {
   const adapters = {
     versionCheck: createVersionCheck(),
     manifestProvider: createManifestProvider(),
-    remoteEntryProvider: createRemoteEntryProvider(),
+    remoteEntryProvider: createRemoteEntryProvider(config),
     remoteInfoRepo: createRemoteInfoRepository(config),
     scopedExternalsRepo: createScopedExternalsRepository(config),
     sharedExternalsRepo: createSharedExternalsRepository(config),
@@ -2786,7 +3223,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
+    }
   };
 };