@softarc/native-federation-orchestrator 4.6.0 → 4.7.0

package/fesm2022/node.mjs

@@ -1430,6 +1430,14 @@ var createNoopSSE = () => ({
   }
 });
 
+// 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/utils/path.ts
 function join(pathA, pathB) {
   pathA = pathA.endsWith("/") ? pathA.slice(0, -1) : pathA;
@@ -1487,7 +1495,7 @@ var Optional = class _Optional {
 
 // 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;
@@ -1529,7 +1537,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;
@@ -1569,7 +1577,7 @@ var STRICT_SCOPE = "strict";
 // 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();
@@ -1579,12 +1587,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) {
@@ -1661,7 +1674,7 @@ var createSharedExternalsRepository = (config) => {
 
 // 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;
@@ -1891,12 +1904,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 = {
@@ -1928,8 +1984,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
     }
   };
 };
@@ -2219,7 +2274,7 @@ function createStoreRemoteEntry(config, ports, logStep) {
       ...sharedInfo.pool?.trim() ? { pool: sharedInfo.pool } : {},
       entries: sharedInfo.entries
     };
-    const cached2 = ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).orElse({ dirty: false, versions: [] });
+    const cached2 = ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).get() ?? { dirty: false, versions: [] };
     return {
       tag,
       remote,
@@ -2240,6 +2295,7 @@ function createStoreRemoteEntry(config, ports, logStep) {
           sharedInfo.packageName,
           {
             dirty: cached2.dirty,
+            ...cached2.poolName !== void 0 && { poolName: cached2.poolName },
             versions: cached2.versions.sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
           },
           sharedInfo.shareScope
@@ -2837,7 +2893,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 = [];
@@ -2876,10 +2931,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;
@@ -2892,23 +2943,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));
@@ -2921,11 +2959,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];
@@ -2940,20 +2978,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 buildPools(sharedExternals, useAutoExternalPooling, log) {
+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, 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 }
     })
   );
@@ -2970,14 +3027,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
@@ -3011,7 +3083,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 [];
@@ -3082,20 +3158,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.`, {
@@ -3110,9 +3184,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);
@@ -3132,7 +3216,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;
@@ -3153,10 +3237,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 (; ; ) {
@@ -3220,7 +3305,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) {
@@ -3240,11 +3325,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 ? [
       {
@@ -3270,6 +3358,7 @@ function createPoolSharedExternals(config, ports) {
     };
     return {
       dirty: false,
+      poolName,
       versions: [
         ...shareVersion,
         ...byTag(
@@ -3295,14 +3384,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) {
@@ -3310,14 +3412,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/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("./")) {
@@ -3922,7 +4034,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;
@@ -3934,18 +4045,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);
@@ -3958,11 +4073,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 });
   };
@@ -4027,8 +4149,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;
@@ -4044,7 +4168,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))
+    };
   }
 }