@softarc/native-federation-orchestrator 4.6.0 → 4.7.0

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

@@ -1577,7 +1577,7 @@ function createStoreRemoteEntry(config, ports, logStep) {
       ...sharedInfo.pool?.trim() ? { pool: sharedInfo.pool } : {},
       entries: sharedInfo.entries
     };
-    const cached = ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).orElse({ dirty: false, versions: [] });
+    const cached = ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).get() ?? { dirty: false, versions: [] };
     return {
       tag,
       remote,
@@ -1598,6 +1598,7 @@ function createStoreRemoteEntry(config, ports, logStep) {
           sharedInfo.packageName,
           {
             dirty: cached.dirty,
+            ...cached.poolName !== void 0 && { poolName: cached.poolName },
             versions: cached.versions.sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
           },
           sharedInfo.shareScope
@@ -2199,7 +2200,6 @@ function assignAnchors(input) {
 }
 
 // src/lib/core/2.app/steps/pooling/pool-graph.ts
-var SCOPED_PACKAGE = /^@([^/]+)\//;
 function createDSU() {
   const ids = /* @__PURE__ */ new Map();
   const parent = [];
@@ -2238,10 +2238,6 @@ function createDSU() {
 }
 var extNode = (name) => `ext\0${name}`;
 var tagNode = (remote, tag) => `tag\0${remote}\0${tag}`;
-var scopeNode = (remote, scope) => `scope\0${remote}\0${scope}`;
-function autoScope(name, useAutoExternalPooling) {
-  return useAutoExternalPooling ? SCOPED_PACKAGE.exec(name)?.[1] : void 0;
-}
 function owningPackage(name) {
   const depth = name.startsWith("@") ? 2 : 1;
   let cut = -1;
@@ -2254,23 +2250,10 @@ function owningPackage(name) {
 function groupByMembership(candidates, log) {
   const dsu = createDSU();
   const tagged = /* @__PURE__ */ new Set();
-  const joined = /* @__PURE__ */ new Set();
-  const tagRules = /* @__PURE__ */ new Set();
-  for (const candidate of candidates) {
-    if (candidate.scope === void 0) continue;
-    for (const edge of candidate.tags) tagRules.add(`${edge.remote}\0${candidate.scope}`);
-  }
   for (const candidate of candidates) {
     for (const edge of candidate.tags) {
       dsu.union(extNode(candidate.name), tagNode(edge.remote, edge.tag));
       tagged.add(candidate.name);
-      joined.add(candidate.name);
-    }
-    if (candidate.scope === void 0) continue;
-    for (const remote of candidate.remotes) {
-      if (tagRules.has(`${remote}\0${candidate.scope}`)) continue;
-      dsu.union(extNode(candidate.name), scopeNode(remote, candidate.scope));
-      joined.add(candidate.name);
     }
   }
   const declared = new Set(candidates.map((c) => c.name));
@@ -2283,11 +2266,11 @@ function groupByMembership(candidates, log) {
   for (const candidate of candidates) {
     const root = dsu.component(extNode(candidate.name));
     const members = byComponent.get(root) ?? byComponent.set(root, []).get(root);
-    members.push({ name: candidate.name, value: candidate.value });
+    members.push(candidate);
   }
   const pools = [];
   for (const members of byComponent.values()) {
-    if (!members.some((m) => joined.has(m.name))) continue;
+    if (!members.some((m) => tagged.has(m.name))) continue;
     members.sort((a, b) => a.name.localeCompare(b.name));
     if (members.length < 2) {
       const only = members[0];
@@ -2302,20 +2285,39 @@ function groupByMembership(candidates, log) {
     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)]));
+  const named = /* @__PURE__ */ new Map();
+  for (const members of pools) {
+    const label = mostDeclaredTag(members) ?? members[0].name;
+    let name = label;
+    for (let n = 2; named.has(name); n++) name = `${label}~${n}`;
+    named.set(
+      name,
+      members.map((m) => m.value)
+    );
+  }
+  return named;
+}
+function mostDeclaredTag(members) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const member of members)
+    for (const edge of member.tags) counts.set(edge.tag, (counts.get(edge.tag) ?? 0) + 1);
+  let best;
+  for (const [tag, count] of counts) {
+    const top = best === void 0 ? 0 : counts.get(best);
+    if (count > top || count === top && tag.localeCompare(best) < 0) best = tag;
+  }
+  return best;
 }
-function buildPools(sharedExternals, useAutoExternalPooling, log) {
+function buildPools(sharedExternals, 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 }] : [];
         })
       ),
-      remotes: external.versions.flatMap((v) => v.remotes.map((r) => r.name)),
       value: { name, external }
     })
   );
@@ -2332,14 +2334,29 @@ function remotesInPool(members) {
     ...new Set(members.flatMap((m) => m.external.versions.flatMap((v) => v.remotes.map((r) => r.name))))
   ];
 }
-function poolableScopes(config, repo) {
-  const { useAutoExternalPooling } = config.feature;
-  return {
-    useAutoExternalPooling,
-    scopes: repo.getScopes().filter(
-      (scope) => repo.scopeType(scope) !== "strict" && (useAutoExternalPooling || repo.hasPoolTag(scope))
-    )
-  };
+function poolableScopes(repo) {
+  return repo.getScopes().filter((scope) => repo.scopeType(scope) !== "strict" && repo.hasPoolState(scope));
+}
+function syncPoolNames(sharedExternals, pools, repo, scope, skip = /* @__PURE__ */ new Set()) {
+  const named = /* @__PURE__ */ new Map();
+  for (const [name, members] of pools) for (const member of members) named.set(member.name, name);
+  for (const [name, external] of Object.entries(sharedExternals)) {
+    const pool = named.get(name);
+    if (pool !== void 0 && skip.has(pool)) continue;
+    if (external.poolName === pool) continue;
+    const { poolName: _stale, ...rest } = external;
+    repo.addOrUpdate(
+      name,
+      pool !== void 0 ? { ...rest, poolName: pool } : {
+        ...rest,
+        versions: external.versions.map((v) => ({
+          ...v,
+          remotes: v.remotes.map(({ poolCause: _cause, ...meta }) => meta)
+        }))
+      },
+      scope
+    );
+  }
 }
 
 // src/lib/core/2.app/steps/pooling/pool-shared-externals.ts
@@ -2373,7 +2390,11 @@ function servedPerRemote(consumed, serving, basis) {
   }
   return served;
 }
-var anyAnchorStored = (members) => members.some((m) => m.external.versions.some((v) => v.remotes.some((r) => r.servedBy !== void 0)));
+var anyVerdictStored = (members) => members.some(
+  (m) => m.external.versions.some(
+    (v) => v.remotes.some((r) => r.servedBy !== void 0 || r.poolCause !== void 0)
+  )
+);
 function findTornRemotes(members, islanded, basis, served, hosts) {
   const { suspect, selfServed } = movedRemotes(members, islanded, basis, served, hosts);
   if (suspect.size === 0) return [];
@@ -2444,20 +2465,18 @@ function movedRemotes(members, islanded, basis, served, hosts) {
 }
 function createPoolSharedExternals(config, ports) {
   return (touched) => {
-    const { useAutoExternalPooling, scopes } = poolableScopes(config, ports.sharedExternalsRepo);
-    for (const scope of scopes) {
+    for (const scope of poolableScopes(ports.sharedExternalsRepo)) {
       const touchedInScope = touched?.get(scope);
       if (touched && !touchedInScope) continue;
       const sharedExternals = ports.sharedExternalsRepo.getFromScope(scope);
       try {
-        for (const [poolName, members] of buildPools(
-          sharedExternals,
-          useAutoExternalPooling,
-          config.log
-        )) {
+        const pools = buildPools(sharedExternals, config.log);
+        const rebuilt = /* @__PURE__ */ new Set();
+        for (const [poolName, members] of pools) {
           if (touchedInScope && !members.some((m) => touchedInScope.has(m.name))) continue;
-          poolFamily(poolName, members, scope);
+          if (poolFamily(poolName, members, scope)) rebuilt.add(poolName);
         }
+        syncPoolNames(sharedExternals, pools, ports.sharedExternalsRepo, scope, rebuilt);
       } catch (error) {
         if (error instanceof NFError) return Promise.reject(error);
         config.log.error(3, `[${scope}] failed to pool shared externals.`, {
@@ -2472,9 +2491,19 @@ function createPoolSharedExternals(config, ports) {
     return Promise.resolve();
   };
   function poolFamily(poolName, members, scope) {
-    if (members.length < 2) return;
+    if (members.length < 2) return false;
     const allRemotes = remotesInPool(members);
-    if (allRemotes.length < 2) return;
+    if (allRemotes.length < 2) {
+      if (!anyVerdictStored(members)) return false;
+      const basis2 = basisFor(members, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
+      for (const member of members)
+        ports.sharedExternalsRepo.addOrUpdate(
+          member.name,
+          rebuildMember(poolName, member, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), basis2.get(member.name)),
+          scope
+        );
+      return true;
+    }
     const islanded = islandedRemotes(members);
     const consumed = consumedMembers(members);
     const hosts = hostRemotes(members);
@@ -2494,7 +2523,7 @@ function createPoolSharedExternals(config, ports) {
       return { serving: serving2, basis: basis2, served: servedPerRemote(consumed, serving2, basis2) };
     };
     let { serving, basis, served } = assign();
-    if (islanded.size === 0 && serving.size === 0 && !anyAnchorStored(members)) return;
+    if (islanded.size === 0 && serving.size === 0 && !anyVerdictStored(members)) return false;
     for (; ; ) {
       const torn = findTornRemotes(members, islanded, basis, served, hosts);
       if (torn.length === 0) break;
@@ -2515,10 +2544,11 @@ function createPoolSharedExternals(config, ports) {
       config.log.warn(3, `[${scope}][pool:${poolName}] ${islandWarning(remote, cause, scoped)}`);
     }
     for (const member of members) {
-      const rebuilt = rebuildMember(member, islanded, served, basis.get(member.name));
+      const rebuilt = rebuildMember(poolName, member, islanded, served, basis.get(member.name));
       warnIfScopedOnly(poolName, member, rebuilt, islanded, scope);
       ports.sharedExternalsRepo.addOrUpdate(member.name, rebuilt, scope);
     }
+    return true;
   }
   function assignServingBuilds(members, islanded, consumed, hosts, views) {
     for (; ; ) {
@@ -2582,7 +2612,7 @@ function createPoolSharedExternals(config, ports) {
       `[${scope}][pool:${poolName}] '${member.name}' is scoped-only \u2014 no coherent shared build provides it; ${consumers} remotes download their own copy.`
     );
   }
-  function rebuildMember(member, islanded, served, basis) {
+  function rebuildMember(poolName, member, islanded, served, basis) {
     let scoped = [];
     let clean = [];
     for (const version of member.external.versions) {
@@ -2602,11 +2632,14 @@ function createPoolSharedExternals(config, ports) {
       const build = served.get(entry.remote)?.get(member.name);
       if (build !== void 0) entry.meta.servedBy = build;
       else delete entry.meta.servedBy;
+      delete entry.meta.poolCause;
     }
     if (basis === void 0) {
       scoped = [...scoped, ...clean.filter((e) => e.meta.servedBy === void 0)];
       clean = clean.filter((e) => e.meta.servedBy !== void 0).map((e) => ({ ...e, action: "skip" }));
     }
+    for (const entry of scoped)
+      entry.meta.poolCause = islanded.get(entry.remote)?.kind ?? "unshared";
     const shareEntries = clean.filter((e) => e.action === "share").sort((a, b) => Number(b.remote === basis) - Number(a.remote === basis));
     const shareVersion = shareEntries.length > 0 ? [
       {
@@ -2632,6 +2665,7 @@ function createPoolSharedExternals(config, ports) {
     };
     return {
       dirty: false,
+      poolName,
       versions: [
         ...shareVersion,
         ...byTag(
@@ -2657,14 +2691,27 @@ function islandWarning(remote, cause, scoped) {
 }
 
 // src/lib/core/2.app/steps/pooling/mark-pools-for-reelection.ts
+function clearPoolState(external) {
+  let cleared = external.poolName !== void 0;
+  delete external.poolName;
+  for (const version of external.versions)
+    for (const meta of version.remotes) {
+      if (meta.servedBy !== void 0 || meta.poolCause !== void 0) cleared = true;
+      delete meta.servedBy;
+      delete meta.poolCause;
+    }
+  return cleared;
+}
 function createMarkPoolsForReelection(config, ports) {
   return () => {
-    const { useAutoExternalPooling, scopes } = poolableScopes(config, ports.sharedExternalsRepo);
-    for (const scope of scopes) {
+    for (const scope of poolableScopes(ports.sharedExternalsRepo)) {
       const sharedExternals = ports.sharedExternalsRepo.getFromScope(scope);
       if (!Object.values(sharedExternals).some((external) => external.dirty)) continue;
       let spread = 0;
-      for (const [, members] of buildPools(sharedExternals, useAutoExternalPooling)) {
+      let unpooled = 0;
+      const pooled = /* @__PURE__ */ new Set();
+      for (const [, members] of buildPools(sharedExternals)) {
+        for (const member of members) pooled.add(member.name);
         if (!members.some((m) => m.external.dirty)) continue;
         for (const member of members)
           if (!member.external.dirty) {
@@ -2672,14 +2719,24 @@ function createMarkPoolsForReelection(config, ports) {
             spread++;
           }
       }
+      for (const [name, external] of Object.entries(sharedExternals)) {
+        if (pooled.has(name) || !clearPoolState(external)) continue;
+        external.dirty = true;
+        unpooled++;
+      }
       if (spread > 0)
         config.log.debug(3, `[${scope}] ${spread} pool member(s) marked dirty for re-election.`);
+      if (unpooled > 0)
+        config.log.debug(
+          3,
+          `[${scope}] ${unpooled} external(s) left every pool; cleared their pool state for re-election.`
+        );
     }
     return Promise.resolve();
   };
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.4.0_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/build-notification-options.contract.js
+// node_modules/.pnpm/@softarc+native-federation@4.7.0/node_modules/@softarc/native-federation/dist/lib/domain/core/build-notification-options.contract.js
 var BuildNotificationType = /* @__PURE__ */ ((BuildNotificationType2) => {
   BuildNotificationType2["COMPLETED"] = "federation-rebuild-complete";
   BuildNotificationType2["ERROR"] = "federation-rebuild-error";
@@ -2687,7 +2744,7 @@ var BuildNotificationType = /* @__PURE__ */ ((BuildNotificationType2) => {
   return BuildNotificationType2;
 })(BuildNotificationType || {});
 
-// node_modules/.pnpm/@softarc+native-federation@4.4.0_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
+// node_modules/.pnpm/@softarc+native-federation@4.7.0/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
 var CHUNK_PREFIX = "@nf-internal";
 function toChunkImport(fileName) {
   if (fileName.startsWith("./")) {
@@ -3331,7 +3388,6 @@ function createUpdateCache(config, ports) {
 // src/lib/core/2.app/steps/pooling/pool-dynamic-externals.ts
 function createPoolDynamicExternals(config, ports) {
   return ({ entry, actions }) => {
-    const { useAutoExternalPooling } = config.feature;
     const declared = /* @__PURE__ */ new Map();
     for (const external of entry.shared ?? []) {
       const name = external.packageName;
@@ -3343,18 +3399,22 @@ function createPoolDynamicExternals(config, ports) {
       names.add(name);
     }
     if (declared.size === 0) return Promise.resolve({ entry, actions });
-    const scope = (name) => {
+    let verdicts = /* @__PURE__ */ new Map();
+    const scope = (name, cause) => {
       actions[name].action = "scope";
       delete actions[name].override;
+      verdicts.set(name, { cause });
     };
     for (const [shareScope, names] of declared) {
-      if (!useAutoExternalPooling && !ports.sharedExternalsRepo.hasPoolTag(shareScope)) continue;
+      if (!ports.sharedExternalsRepo.hasPoolState(shareScope)) continue;
       const committed = ports.sharedExternalsRepo.getFromScope(shareScope);
-      for (const pool of buildPools(committed, useAutoExternalPooling).values()) {
+      const pools = buildPools(committed);
+      verdicts = /* @__PURE__ */ new Map();
+      for (const pool of pools.values()) {
         const mine = pool.filter((member) => names.has(member.name));
         if (mine.length === 0) continue;
         if (mine.some((member) => actions[member.name].action === "scope")) {
-          mine.forEach((member) => scope(member.name));
+          mine.forEach((member) => scope(member.name, "incompatible"));
           continue;
         }
         const asked = gateViews(entry.name, pool);
@@ -3367,11 +3427,18 @@ function createPoolDynamicExternals(config, ports) {
             8,
             `[${shareScope}] '${entry.name}' serves its own family: no committed build offers every entrypoint it imports at a version it accepts \u2014 '${reason.gap}' is the gap, ${closest}. All ${mine.length} members it imports are scoped for it.`
           );
-          mine.forEach((member) => scope(member.name));
+          mine.forEach((member) => scope(member.name, "uncovered"));
           continue;
         }
-        redirect(entry.name, anchor, pool, asked.view, actions, shareScope);
+        for (const name of redirect(entry.name, anchor, pool, asked.view, actions, shareScope))
+          verdicts.set(name, { servedBy: anchor });
       }
+      const written = {};
+      for (const [name, verdict] of verdicts) {
+        written[name] = recordVerdict(committed[name], entry.name, verdict);
+        ports.sharedExternalsRepo.addOrUpdate(name, written[name], shareScope);
+      }
+      syncPoolNames({ ...committed, ...written }, pools, ports.sharedExternalsRepo, shareScope);
     }
     return Promise.resolve({ entry, actions });
   };
@@ -3436,8 +3503,10 @@ function createPoolDynamicExternals(config, ports) {
         8,
         `[${shareScope}][${remote}] '${anchor}' is not in the cache, so its files cannot be mapped.`
       );
-      return;
+      return [];
     }
+    const basis = basisPerMember(pool);
+    const served = [];
     for (const member of pool) {
       const action = actions[member.name];
       if (!action || action.action !== "skip") continue;
@@ -3453,7 +3522,42 @@ function createPoolDynamicExternals(config, ports) {
       }
       action.covered = specifiers;
       if (Object.keys(override).length > 0) action.override = override;
+      if (basis.get(member.name) !== anchor) served.push(member.name);
+    }
+    return served;
+  }
+  function recordVerdict(external, remote, verdict) {
+    if ("servedBy" in verdict) {
+      return {
+        ...external,
+        versions: external.versions.map((v) => ({
+          ...v,
+          remotes: v.remotes.map(
+            (r) => r.name === remote ? { ...r, servedBy: verdict.servedBy } : r
+          )
+        }))
+      };
+    }
+    const moved = [];
+    const versions = external.versions.map((v) => {
+      const own = v.remotes.find((r) => r.name === remote);
+      if (!own) return v;
+      const { servedBy: _anchor, ...rest } = own;
+      const meta = { ...rest, cached: true, poolCause: verdict.cause };
+      if (v.action === "scope")
+        return { ...v, remotes: v.remotes.map((r) => r === own ? meta : r) };
+      moved.push({ tag: v.tag, meta });
+      return { ...v, remotes: v.remotes.filter((r) => r !== own) };
+    }).filter((v) => v.remotes.length > 0);
+    for (const { tag, meta } of moved) {
+      const at = versions.findIndex((v) => v.tag === tag && v.action === "scope");
+      if (at >= 0) versions[at] = { ...versions[at], remotes: [...versions[at].remotes, meta] };
+      else versions.push({ tag, action: "scope", host: false, remotes: [meta] });
     }
+    return {
+      ...external,
+      versions: versions.sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
+    };
   }
 }
 
@@ -3732,7 +3836,7 @@ var createManifestProvider = () => {
   };
 };
 
-// node_modules/.pnpm/@softarc+native-federation@4.4.0_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/utils/normalize.js
+// node_modules/.pnpm/@softarc+native-federation@4.7.0/node_modules/@softarc/native-federation/dist/lib/utils/normalize.js
 function inferPackageFromSecondary(secondary) {
   const parts = secondary.split("/");
   if (secondary.startsWith("@") && parts.length >= 2) {
@@ -3741,7 +3845,7 @@ function inferPackageFromSecondary(secondary) {
   return parts[0];
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.4.0_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/core/output/densify-externals.js
+// node_modules/.pnpm/@softarc+native-federation@4.7.0/node_modules/@softarc/native-federation/dist/lib/core/output/densify-externals.js
 function isDense(entry) {
   return "entries" in entry;
 }
@@ -3757,37 +3861,26 @@ function densifyExternals(shared) {
       continue;
     }
     if (isFlatChunk(entry)) {
-      const { outFileName, ...rest } = entry;
-      result.push({ ...rest, entries: { [entry.packageName]: outFileName } });
+      const { outFileName: outFileName2, ...rest } = entry;
+      result.push({ ...rest, entries: { [entry.packageName]: outFileName2 } });
       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 { outFileName, packageName, dev, ...meta } = entry;
+    const parent = 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 = {
-        singleton: entry.singleton,
-        strictVersion: entry.strictVersion,
-        requiredVersion: entry.requiredVersion,
+        ...meta,
         packageName: parent,
-        entries: { [entry.packageName]: entry.outFileName }
+        entries: { [packageName]: 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.pool !== void 0) dense.pool = entry.pool;
-      if (entry.dev !== void 0) dense.dev = entry.dev;
+      if (dev !== void 0) dense.dev = dev;
       groupIndex.set(key, result.length);
       result.push(dense);
     } else {
-      result[existing].entries[entry.packageName] = entry.outFileName;
+      result[existing].entries[packageName] = outFileName;
     }
   }
   return result;
@@ -3837,9 +3930,17 @@ var createRemoteEntryProvider = (config) => {
   };
 };
 
+// src/lib/core/2.app/config/storage.contract.ts
+var STORAGE_KEYS = {
+  remotes: "remotes",
+  sharedExternals: "shared-externals",
+  scopedExternals: "scoped-externals",
+  sharedChunks: "shared-chunks"
+};
+
 // src/lib/core/3.adapters/storage/remote-info.repository.ts
 var createRemoteInfoRepository = (config) => {
-  const STORAGE = config.storage("remotes", {});
+  const STORAGE = config.storage(STORAGE_KEYS.remotes, {});
   if (config.clearStorage) STORAGE.clear();
   const _cache = STORAGE.get() ?? {};
   let _dirty = false;
@@ -3881,7 +3982,7 @@ var createRemoteInfoRepository = (config) => {
 
 // src/lib/core/3.adapters/storage/scoped-externals.repository.ts
 var createScopedExternalsRepository = (config) => {
-  const STORAGE = config.storage("scoped-externals", {});
+  const STORAGE = config.storage(STORAGE_KEYS.scopedExternals, {});
   if (config.clearStorage) STORAGE.clear();
   const _cache = STORAGE.get() ?? {};
   let _dirty = false;
@@ -3917,7 +4018,7 @@ var createScopedExternalsRepository = (config) => {
 // src/lib/core/3.adapters/storage/shared-externals.repository.ts
 var createSharedExternalsRepository = (config) => {
   const STORAGE = config.storage(
-    "shared-externals",
+    STORAGE_KEYS.sharedExternals,
     { [GLOBAL_SCOPE]: {} }
   );
   if (config.clearStorage) STORAGE.clear();
@@ -3927,12 +4028,17 @@ var createSharedExternalsRepository = (config) => {
     // Read from the cache rather than remembered from this init's entries: a warm init may not refetch
     // the tagged remote at all, and pooling has to coordinate its pool anyway. Exits on the first hit.
     // Per share scope, because a pool never spans one: a tag in another scope is no reason to pool here.
-    hasPoolTag: function(shareScope) {
+    // Stored pool results count too, since a scope whose last tag left still has pool state to clear.
+    hasPoolState: function(shareScope) {
       const scope = _cache[shareScope ?? GLOBAL_SCOPE];
       if (!scope) return false;
-      for (const external of Object.values(scope))
+      for (const external of Object.values(scope)) {
+        if (external.poolName !== void 0) return true;
         for (const version of external.versions)
-          for (const remote of version.remotes) if (remote.pool?.trim()) return true;
+          for (const remote of version.remotes)
+            if (remote.pool?.trim() || remote.servedBy !== void 0 || remote.poolCause !== void 0)
+              return true;
+      }
       return false;
     },
     getFromScope: function(shareScope) {
@@ -4008,34 +4114,115 @@ var createSharedExternalsRepository = (config) => {
 };
 
 // src/lib/core/3.adapters/browser/sse-handler.ts
+var RELAY_CHANNEL = "native-federation-sse";
+var LOCK_PREFIX = "native-federation-sse:";
 var createSSEHandler = (config) => {
-  const subscribers = [];
+  const subscriptions = /* @__PURE__ */ new Map();
+  const locks = typeof navigator !== "undefined" ? navigator.locks : void 0;
+  const canRelay = !!locks && typeof BroadcastChannel !== "undefined";
+  let relay;
+  let bound = false;
+  function reload(reason) {
+    config.log.debug(0, `[SSE] ${reason}, reloading...`);
+    config.reloadBrowserFn();
+  }
+  function openEventSource(endpoint, subscription) {
+    const eventSource = new EventSource(endpoint);
+    eventSource.onmessage = function(event) {
+      const data = JSON.parse(event.data);
+      if (data.type === BuildNotificationType.COMPLETED) {
+        relay?.postMessage({ endpoint });
+        reload("Rebuild completed");
+      }
+    };
+    eventSource.onerror = function(event) {
+      config.log.error(0, "[SSE] Connection error:", event);
+      if (eventSource.readyState !== eventSource.CLOSED) return;
+      config.log.debug(0, `[SSE] Stream for '${endpoint}' will not reopen, releasing the lock`);
+      disconnect(subscription);
+    };
+    return eventSource;
+  }
+  function connect(endpoint, subscription) {
+    if (!locks) {
+      subscription.source = openEventSource(endpoint, subscription);
+      return;
+    }
+    const abort = new AbortController();
+    const held = new Promise((resolve) => {
+      subscription.releaseLock = resolve;
+    });
+    subscription.abort = abort;
+    locks.request(`${LOCK_PREFIX}${endpoint}`, { signal: abort.signal }, () => {
+      if (abort.signal.aborted) return;
+      config.log.debug(0, `[SSE] Holding the connection for '${endpoint}'`);
+      subscription.source = openEventSource(endpoint, subscription);
+      return held;
+    }).catch(() => {
+      config.log.debug(0, `[SSE] Released the connection for '${endpoint}'`);
+    });
+  }
+  function disconnect(subscription) {
+    subscription.source?.close();
+    subscription.abort?.abort();
+    subscription.releaseLock?.();
+    subscription.source = void 0;
+    subscription.abort = void 0;
+    subscription.releaseLock = void 0;
+  }
+  function onPageHide(event) {
+    if (event.persisted) subscriptions.forEach(disconnect);
+  }
+  function onPageShow(event) {
+    if (event.persisted)
+      subscriptions.forEach((subscription, endpoint) => connect(endpoint, subscription));
+  }
+  function bind() {
+    if (bound) return;
+    bound = true;
+    if (canRelay) {
+      relay = new BroadcastChannel(RELAY_CHANNEL);
+      relay.onmessage = (event) => {
+        if (subscriptions.has(event.data?.endpoint)) reload("Rebuild completed in another tab");
+      };
+    }
+    if (typeof window !== "undefined") {
+      window.addEventListener("pagehide", onPageHide);
+      window.addEventListener("pageshow", onPageShow);
+    }
+  }
+  function unbind() {
+    if (!bound) return;
+    bound = false;
+    relay?.close();
+    relay = void 0;
+    if (typeof window !== "undefined") {
+      window.removeEventListener("pagehide", onPageHide);
+      window.removeEventListener("pageshow", onPageShow);
+    }
+  }
   return {
     watchRemoteBuilds: function(endpoint) {
-      const eventSource = new EventSource(endpoint);
-      eventSource.onmessage = function(event) {
-        const data = JSON.parse(event.data);
-        if (data.type === BuildNotificationType.COMPLETED) {
-          subscribers.forEach((sub) => sub.close());
-          config.log.debug(0, "[SSE] Rebuild completed, reloading...");
-          config.reloadBrowserFn();
-        }
-      };
-      eventSource.onerror = function(event) {
-        config.log.error(0, "[SSE] Connection error:", event);
-      };
-      subscribers.push(eventSource);
+      if (subscriptions.has(endpoint)) {
+        config.log.debug(0, `[SSE] Already watching '${endpoint}'`);
+        return;
+      }
+      bind();
+      const subscription = {};
+      subscriptions.set(endpoint, subscription);
+      connect(endpoint, subscription);
     },
     closeAll: function() {
-      subscribers.forEach((sub) => sub.close());
-      subscribers.length = 0;
+      subscriptions.forEach(disconnect);
+      subscriptions.clear();
+      unbind();
     }
   };
 };
 
 // src/lib/core/3.adapters/storage/chunk.repository.ts
 var createChunkRepository = (config) => {
-  const STORAGE = config.storage("shared-chunks", {});
+  const STORAGE = config.storage(STORAGE_KEYS.sharedChunks, {});
   if (config.clearStorage) STORAGE.clear();
   const _cache = STORAGE.get() ?? {};
   let _dirty = false;
@@ -4281,12 +4468,55 @@ var globalThisStorageEntry = (namespace) => (key, initialValue) => {
   };
   return entry;
 };
+globalThisStorageEntry.type = "globalThis";
+Object.freeze(globalThisStorageEntry);
+
+// src/lib/core/4.config/storage/publish-storage-info.ts
+var VERSION = true ? "4.7.0" : "dev";
+var KEYS = Object.freeze(Object.values(STORAGE_KEYS));
+var isStorageKey = (key) => KEYS.includes(key);
+var createStorageInfo = ({
+  type,
+  namespace,
+  storage,
+  exposeGetter
+}) => {
+  const info = { version: VERSION, type, namespace, keys: KEYS };
+  if (!exposeGetter) return Object.freeze(info);
+  return Object.freeze({
+    ...info,
+    // Cloned again because custom storages may hand out live references.
+    get: (key) => isStorageKey(key) ? cloneEntry(key, storage(key, void 0).get()) : void 0
+  });
+};
+var publishStorageInfo = (options) => {
+  try {
+    globalThis.__NF_ORCHESTRATOR__ = Object.freeze({
+      storage: Object.freeze({
+        ...globalThis.__NF_ORCHESTRATOR__?.storage,
+        [options.namespace]: createStorageInfo(options)
+      })
+    });
+  } catch {
+  }
+};
 
 // src/lib/core/4.config/storage/storage.config.ts
-var createStorageConfig = (override) => ({
-  storage: override.storage ? override.storage(override.storageNamespace ?? "__NATIVE_FEDERATION__") : globalThisStorageEntry(override.storageNamespace ?? "__NATIVE_FEDERATION__"),
-  clearStorage: override.clearStorage ?? false
-});
+var createStorageConfig = (override) => {
+  const creator = override.storage ?? globalThisStorageEntry;
+  const namespace = override.storageNamespace ?? "__NATIVE_FEDERATION__";
+  const storage = creator(namespace);
+  publishStorageInfo({
+    type: creator.type ?? "custom",
+    namespace,
+    storage,
+    exposeGetter: override.exposeStorageGetter ?? true
+  });
+  return {
+    storage,
+    clearStorage: override.clearStorage ?? false
+  };
+};
 
 // src/lib/core/4.config/mode/default.profile.ts
 var defaultProfile = {
@@ -4318,8 +4548,7 @@ var createModeConfig = (override) => {
     strict: strictnessConfig,
     profile: { ...defaultProfile, ...override.profile ?? {} },
     feature: {
-      convertFlatSharedInfo: override.feature?.convertFlatSharedInfo ?? false,
-      useAutoExternalPooling: override.feature?.useAutoExternalPooling ?? false
+      convertFlatSharedInfo: override.feature?.convertFlatSharedInfo ?? false
     }
   };
 };