@softarc/native-federation-orchestrator 4.2.2 → 4.3.0

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

@@ -24,9 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/debug.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/debug.js
 var require_debug = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/debug.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/debug.js"(exports, module) {
     "use strict";
     var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
     };
@@ -34,9 +34,9 @@ var require_debug = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/constants.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/constants.js
 var require_constants = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/constants.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/constants.js"(exports, module) {
     "use strict";
     var SEMVER_SPEC_VERSION = "2.0.0";
     var MAX_LENGTH = 256;
@@ -66,9 +66,9 @@ var require_constants = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/re.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/re.js
 var require_re = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/re.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/re.js"(exports, module) {
     "use strict";
     var {
       MAX_SAFE_COMPONENT_LENGTH,
@@ -154,9 +154,9 @@ var require_re = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/parse-options.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/parse-options.js
 var require_parse_options = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/parse-options.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/parse-options.js"(exports, module) {
     "use strict";
     var looseOption = Object.freeze({ loose: true });
     var emptyOpts = Object.freeze({});
@@ -173,9 +173,9 @@ var require_parse_options = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/identifiers.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/identifiers.js
 var require_identifiers = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/identifiers.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/identifiers.js"(exports, module) {
     "use strict";
     var numeric = /^[0-9]+$/;
     var compareIdentifiers = (a, b) => {
@@ -198,15 +198,27 @@ var require_identifiers = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/classes/semver.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/classes/semver.js
 var require_semver = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/classes/semver.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/classes/semver.js"(exports, module) {
     "use strict";
     var debug = require_debug();
     var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
     var { safeRe: re, t } = require_re();
     var parseOptions = require_parse_options();
     var { compareIdentifiers } = require_identifiers();
+    var isPrereleaseIdentifier = (prerelease, identifier) => {
+      const identifiers = identifier.split(".");
+      if (identifiers.length > prerelease.length) {
+        return false;
+      }
+      for (let i = 0; i < identifiers.length; i++) {
+        if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
+          return false;
+        }
+      }
+      return true;
+    };
     var SemVer = class _SemVer {
       constructor(version, options) {
         options = parseOptions(options);
@@ -453,8 +465,9 @@ var require_semver = __commonJS({
               if (identifierBase === false) {
                 prerelease = [identifier];
               }
-              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-                if (isNaN(this.prerelease[1])) {
+              if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+                const prereleaseBase = this.prerelease[identifier.split(".").length];
+                if (isNaN(prereleaseBase)) {
                   this.prerelease = prerelease;
                 }
               } else {
@@ -477,9 +490,9 @@ var require_semver = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/parse.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/parse.js
 var require_parse = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/parse.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/parse.js"(exports, module) {
     "use strict";
     var SemVer = require_semver();
     var parse = (version, options, throwErrors = false) => {
@@ -499,9 +512,9 @@ var require_parse = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/valid.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/valid.js
 var require_valid = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/valid.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/valid.js"(exports, module) {
     "use strict";
     var parse = require_parse();
     var valid = (version, options) => {
@@ -512,9 +525,9 @@ var require_valid = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/lrucache.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/lrucache.js
 var require_lrucache = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/internal/lrucache.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/internal/lrucache.js"(exports, module) {
     "use strict";
     var LRUCache = class {
       constructor() {
@@ -550,9 +563,9 @@ var require_lrucache = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/compare.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/compare.js
 var require_compare = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/compare.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/compare.js"(exports, module) {
     "use strict";
     var SemVer = require_semver();
     var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
@@ -560,9 +573,9 @@ var require_compare = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/eq.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/eq.js
 var require_eq = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/eq.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/eq.js"(exports, module) {
     "use strict";
     var compare = require_compare();
     var eq = (a, b, loose) => compare(a, b, loose) === 0;
@@ -570,9 +583,9 @@ var require_eq = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/neq.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/neq.js
 var require_neq = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/neq.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/neq.js"(exports, module) {
     "use strict";
     var compare = require_compare();
     var neq = (a, b, loose) => compare(a, b, loose) !== 0;
@@ -580,9 +593,9 @@ var require_neq = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/gt.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/gt.js
 var require_gt = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/gt.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/gt.js"(exports, module) {
     "use strict";
     var compare = require_compare();
     var gt = (a, b, loose) => compare(a, b, loose) > 0;
@@ -590,9 +603,9 @@ var require_gt = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/gte.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/gte.js
 var require_gte = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/gte.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/gte.js"(exports, module) {
     "use strict";
     var compare = require_compare();
     var gte = (a, b, loose) => compare(a, b, loose) >= 0;
@@ -600,9 +613,9 @@ var require_gte = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/lt.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/lt.js
 var require_lt = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/lt.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/lt.js"(exports, module) {
     "use strict";
     var compare = require_compare();
     var lt = (a, b, loose) => compare(a, b, loose) < 0;
@@ -610,9 +623,9 @@ var require_lt = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/lte.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/lte.js
 var require_lte = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/lte.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/lte.js"(exports, module) {
     "use strict";
     var compare = require_compare();
     var lte = (a, b, loose) => compare(a, b, loose) <= 0;
@@ -620,9 +633,9 @@ var require_lte = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/cmp.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/cmp.js
 var require_cmp = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/cmp.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/cmp.js"(exports, module) {
     "use strict";
     var eq = require_eq();
     var neq = require_neq();
@@ -670,9 +683,9 @@ var require_cmp = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/classes/comparator.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/classes/comparator.js
 var require_comparator = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/classes/comparator.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/classes/comparator.js"(exports, module) {
     "use strict";
     var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
     var Comparator = class _Comparator {
@@ -783,9 +796,9 @@ var require_comparator = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/classes/range.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/classes/range.js
 var require_range = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/classes/range.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/classes/range.js"(exports, module) {
     "use strict";
     var SPACE_CHARACTERS = /\s+/g;
     var Range = class _Range {
@@ -1031,9 +1044,9 @@ var require_range = __commonJS({
           debug("no pr");
           if (M === "0") {
             if (m === "0") {
-              ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+              ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
             } else {
-              ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+              ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
             }
           } else {
             ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
@@ -1163,9 +1176,9 @@ var require_range = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/satisfies.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/satisfies.js
 var require_satisfies = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/functions/satisfies.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/functions/satisfies.js"(exports, module) {
     "use strict";
     var Range = require_range();
     var satisfies = (version, range, options) => {
@@ -1180,9 +1193,9 @@ var require_satisfies = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/ranges/min-version.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/ranges/min-version.js
 var require_min_version = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/ranges/min-version.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/ranges/min-version.js"(exports, module) {
     "use strict";
     var SemVer = require_semver();
     var Range = require_range();
@@ -1239,9 +1252,9 @@ var require_min_version = __commonJS({
   }
 });
 
-// node_modules/.pnpm/semver@7.8.1/node_modules/semver/ranges/valid.js
+// node_modules/.pnpm/semver@7.8.3/node_modules/semver/ranges/valid.js
 var require_valid2 = __commonJS({
-  "node_modules/.pnpm/semver@7.8.1/node_modules/semver/ranges/valid.js"(exports, module) {
+  "node_modules/.pnpm/semver@7.8.3/node_modules/semver/ranges/valid.js"(exports, module) {
     "use strict";
     var Range = require_range();
     var validRange = (range, options) => {
@@ -1255,7 +1268,28 @@ var require_valid2 = __commonJS({
   }
 });
 
-// src/lib/native-federation.error.ts
+// src/lib/core/2.app/flows/init.flow.ts
+var createInitFlow = ({
+  flow,
+  adapters,
+  config
+}) => {
+  return (remotesOrManifestUrl) => flow.getRemoteEntries(remotesOrManifestUrl).then(flow.processRemoteEntries).then(flow.determineSharedExternals).then(flow.generateImportMap).then(flow.commitChanges).then(flow.exposeModuleLoader).then((loadRemoteModule) => ({
+    config,
+    adapters,
+    loadRemoteModule
+  }));
+};
+
+// src/lib/core/2.app/flows/init-remote-entry.flow.ts
+var createInitRemoteEntryFlow = ({
+  flow
+}) => {
+  const processDynamicRemoteEntry = (remoteEntry) => flow.updateCache(remoteEntry).then(flow.convertToImportMap).then(flow.commitChanges);
+  return (remoteEntryUrl, remote) => flow.getRemoteEntry(remoteEntryUrl, remote).then((entry) => entry.map(processDynamicRemoteEntry).orElse(Promise.resolve())).then(() => void 0);
+};
+
+// src/lib/core/native-federation.error.ts
 var NFError = class extends Error {
   constructor(message, cause) {
     super(message, cause);
@@ -1279,7 +1313,7 @@ function getScope(path) {
   return `${parts.join("/")}/`;
 }
 
-// src/lib/2.app/flows/init/get-remote-entries.ts
+// src/lib/core/2.app/steps/get-remote-entries.ts
 function createGetRemoteEntries(config, ports) {
   return (remotesOrManifestUrl = {}) => {
     const manifestPromise = config.manifestIntegrity ? ports.manifestProvider.provide(remotesOrManifestUrl, {
@@ -1373,20 +1407,13 @@ function createGetRemoteEntries(config, ports) {
   }
 }
 
-// src/lib/2.app/flows/init/process-remote-entries.ts
-function createProcessRemoteEntries(config, ports) {
-  return (remoteEntries) => {
-    try {
-      remoteEntries.forEach((remoteEntry) => {
-        if (remoteEntry?.override) removeCachedRemoteEntry(remoteEntry);
-        addRemoteInfoToStorage(remoteEntry);
-        addExternalsToStorage(remoteEntry);
-        addSharedChunksToStorage(remoteEntry);
-      });
-      return Promise.resolve(remoteEntries);
-    } catch (e) {
-      return Promise.reject(e);
-    }
+// src/lib/core/2.app/steps/store-remote-entry.ts
+function createStoreRemoteEntry(config, ports, logStep) {
+  return (remoteEntry, onSharedExternal) => {
+    if (remoteEntry?.override) removeCachedRemoteEntry(remoteEntry);
+    addRemoteInfoToStorage(remoteEntry);
+    addExternalsToStorage(remoteEntry, onSharedExternal);
+    addSharedChunksToStorage(remoteEntry);
   };
   function removeCachedRemoteEntry(remoteEntry) {
     ports.remoteInfoRepo.remove(remoteEntry.name);
@@ -1403,92 +1430,128 @@ function createProcessRemoteEntries(config, ports) {
       ...integrity ? { integrity } : {}
     });
   }
-  function addExternalsToStorage(remoteEntry) {
+  function addExternalsToStorage(remoteEntry, onSharedExternal) {
     remoteEntry.shared.forEach((external) => {
-      if (!external.version || !ports.versionCheck.isValidSemver(external.version)) {
-        const errorMsg = `[${remoteEntry.name}][${external.packageName}] Version '${external.version}' is not a valid version.`;
-        if (config.strict.strictExternalVersion) {
-          config.log.error(2, errorMsg);
-          throw new NFError(`Could not process remote '${remoteEntry.name}'`);
-        }
-        config.log.warn(2, errorMsg);
-      }
+      validateExternalVersion(remoteEntry, external);
       if (external.singleton) {
-        addSharedExternal(remoteEntry.name, external, remoteEntry);
+        onSharedExternal(remoteEntry, external, sharedExternalContext(remoteEntry, external));
       } else {
-        addScopedExternal(remoteEntry.name, external);
+        addScopedExternal(remoteEntry, external);
       }
     });
   }
   function addSharedChunksToStorage(remoteEntry) {
     if (!remoteEntry.chunks) return;
     config.log.debug(
-      2,
+      logStep,
       `Adding chunks for remote "${remoteEntry.name}", bundles: [${Object.keys(remoteEntry.chunks).join(", ")}]`
     );
     Object.entries(remoteEntry.chunks).forEach(([bundleName, chunks]) => {
       ports.sharedChunksRepo.addOrReplace(remoteEntry.name, bundleName, chunks);
     });
   }
-  function addSharedExternal(remoteName, sharedInfo, remoteEntry) {
-    let action = "skip";
+  function addScopedExternal(remoteEntry, sharedInfo) {
+    ports.scopedExternalsRepo.addExternal(remoteEntry.name, sharedInfo.packageName, {
+      tag: sharedInfo.version ?? ports.versionCheck.smallestVersion(sharedInfo.requiredVersion),
+      file: sharedInfo.outFileName,
+      bundle: sharedInfo.bundle
+    });
+  }
+  function validateExternalVersion(remoteEntry, external) {
+    if (!external.version || !ports.versionCheck.isValidSemver(external.version)) {
+      const errorMsg = `[${remoteEntry.name}][${external.packageName}] Version '${external.version}' is not a valid version.`;
+      if (config.strict.strictExternalVersion) {
+        config.log.error(logStep, errorMsg);
+        throw new NFError(`Could not process remote '${remoteEntry.name}'`);
+      }
+      config.log.warn(logStep, errorMsg);
+    }
+  }
+  function sharedExternalContext(remoteEntry, sharedInfo) {
     const tag = sharedInfo.version ?? ports.versionCheck.smallestVersion(sharedInfo.requiredVersion);
+    const scopeType = ports.sharedExternalsRepo.scopeType(sharedInfo.shareScope);
     const remote = {
       file: sharedInfo.outFileName,
-      name: remoteName,
+      name: remoteEntry.name,
       bundle: sharedInfo.bundle,
       strictVersion: sharedInfo.strictVersion,
       cached: false,
-      requiredVersion: sharedInfo.requiredVersion || tag
+      requiredVersion: scopeType === "strict" ? tag : sharedInfo.requiredVersion || tag
     };
-    const scopeType = ports.sharedExternalsRepo.scopeType(sharedInfo.shareScope);
-    if (scopeType === "strict") {
-      action = "share";
-      remote.requiredVersion = tag;
-    }
     const cached = ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).orElse({ dirty: false, versions: [] });
-    const matchingVersion = cached.versions.find((version) => version.tag === sharedInfo.version);
-    let dirty = cached.dirty;
-    if (!!matchingVersion) {
-      if (remote.strictVersion && matchingVersion.remotes[0].requiredVersion !== remote.requiredVersion) {
-        const errorMsg = `[${remoteName}][${sharedInfo.packageName}@${sharedInfo.version}] Required version-range '${remote.requiredVersion}' does not match cached version-range '${matchingVersion.remotes[0].requiredVersion}'`;
+    return {
+      tag,
+      remote,
+      cached,
+      scopeType,
+      assertSameVersionCompatibility(matchingVersion) {
+        if (!remote.strictVersion) return;
+        if (matchingVersion.remotes[0].requiredVersion === remote.requiredVersion) return;
+        const errorMsg = `[${remoteEntry.name}][${sharedInfo.packageName}@${sharedInfo.version}] Required version-range '${remote.requiredVersion}' does not match cached version-range '${matchingVersion.remotes[0].requiredVersion}'`;
         if (config.strict.strictExternalSameVersionCompatibility) {
-          config.log.error(2, errorMsg);
+          config.log.error(logStep, errorMsg);
           throw new NFError(`Could not process remote '${remoteEntry.name}'`);
         }
-        config.log.warn(2, errorMsg);
+        config.log.warn(logStep, errorMsg);
+      },
+      commit() {
+        ports.sharedExternalsRepo.addOrUpdate(
+          sharedInfo.packageName,
+          {
+            dirty: cached.dirty,
+            versions: cached.versions.sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
+          },
+          sharedInfo.shareScope
+        );
       }
+    };
+  }
+}
+
+// src/lib/core/2.app/steps/process-remote-entries.ts
+function createProcessRemoteEntries(config, ports) {
+  const storeRemoteEntry = createStoreRemoteEntry(config, ports, 2);
+  return (remoteEntries) => {
+    try {
+      remoteEntries.forEach((remoteEntry) => storeRemoteEntry(remoteEntry, addSharedExternal));
+      return Promise.resolve(remoteEntries);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  function addSharedExternal(remoteEntry, _sharedInfo, {
+    tag,
+    remote,
+    cached,
+    scopeType,
+    assertSameVersionCompatibility,
+    commit
+  }) {
+    const matchingVersion = cached.versions.find((version) => version.tag === tag);
+    if (matchingVersion) {
+      assertSameVersionCompatibility(matchingVersion);
       if (!matchingVersion.host && !!remoteEntry?.host) {
         matchingVersion.host = true;
         matchingVersion.remotes.unshift(remote);
       } else matchingVersion.remotes.push(remote);
     } else {
-      if (scopeType !== "strict") dirty = true;
-      cached.versions.push({ tag, action, host: !!remoteEntry?.host, remotes: [remote] });
+      if (scopeType !== "strict") cached.dirty = true;
+      cached.versions.push({
+        tag,
+        action: scopeType === "strict" ? "share" : "skip",
+        host: !!remoteEntry?.host,
+        remotes: [remote]
+      });
     }
-    ports.sharedExternalsRepo.addOrUpdate(
-      sharedInfo.packageName,
-      {
-        dirty,
-        versions: cached.versions.sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
-      },
-      sharedInfo.shareScope
-    );
-  }
-  function addScopedExternal(scope, sharedInfo) {
-    ports.scopedExternalsRepo.addExternal(scope, sharedInfo.packageName, {
-      tag: sharedInfo.version ?? ports.versionCheck.smallestVersion(sharedInfo.requiredVersion),
-      file: sharedInfo.outFileName,
-      bundle: sharedInfo.bundle
-    });
+    commit();
   }
 }
 
-// src/lib/1.domain/externals/external.contract.ts
+// src/lib/core/1.domain/externals/external.contract.ts
 var GLOBAL_SCOPE = "__GLOBAL__";
 var STRICT_SCOPE = "strict";
 
-// src/lib/2.app/flows/init/determine-shared-externals.ts
+// src/lib/core/2.app/steps/determine-shared-externals.ts
 function createDetermineSharedExternals(config, ports) {
   return () => {
     for (const shareScope of ports.sharedExternalsRepo.getScopes()) {
@@ -1565,7 +1628,7 @@ function createDetermineSharedExternals(config, ports) {
   }
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.1.3_typescript@5.9.3/node_modules/@softarc/native-federation/src/lib/domain/core/build-notification-options.contract.js
+// node_modules/.pnpm/@softarc+native-federation@4.1.3_typescript@6.0.3/node_modules/@softarc/native-federation/src/lib/domain/core/build-notification-options.contract.js
 var BuildNotificationType;
 (function(BuildNotificationType2) {
   BuildNotificationType2["COMPLETED"] = "federation-rebuild-complete";
@@ -1573,7 +1636,7 @@ var BuildNotificationType;
   BuildNotificationType2["CANCELLED"] = "federation-rebuild-cancelled";
 })(BuildNotificationType || (BuildNotificationType = {}));
 
-// node_modules/.pnpm/@softarc+native-federation@4.1.3_typescript@5.9.3/node_modules/@softarc/native-federation/src/lib/domain/core/chunk.js
+// node_modules/.pnpm/@softarc+native-federation@4.1.3_typescript@6.0.3/node_modules/@softarc/native-federation/src/lib/domain/core/chunk.js
 var CHUNK_PREFIX = "@nf-internal";
 function toChunkImport(fileName) {
   if (fileName.startsWith("./")) {
@@ -1583,7 +1646,7 @@ function toChunkImport(fileName) {
   return CHUNK_PREFIX + "/" + packageName;
 }
 
-// src/lib/2.app/flows/init/generate-import-map.ts
+// src/lib/core/2.app/steps/generate-import-map.ts
 function createGenerateImportMap(config, ports) {
   return () => {
     const importMap = { imports: {} };
@@ -1608,7 +1671,12 @@ 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);
+        addIntegrity(
+          importMap,
+          join(remote.scopeUrl, version.file),
+          remoteName,
+          version.file
+        );
       }
       Object.values(externals).filter((e) => !!e.bundle).forEach((e) => registerBundleChunks(chunkBundles, remoteName, e.bundle));
     }
@@ -1817,7 +1885,7 @@ function createGenerateImportMap(config, ports) {
   }
 }
 
-// src/lib/2.app/flows/init/commit-changes.ts
+// src/lib/core/2.app/steps/commit-changes.ts
 function createCommitChanges(config, ports) {
   return (importMap) => Promise.resolve(importMap).then(addToBrowser).then(persistRepositoryChanges);
   function addToBrowser(importMap) {
@@ -1834,7 +1902,7 @@ function createCommitChanges(config, ports) {
   }
 }
 
-// src/lib/2.app/flows/init/expose-module-loader.ts
+// src/lib/core/2.app/steps/expose-module-loader.ts
 function createExposeModuleLoader(config, ports) {
   const loadRemoteModule = (remoteName, exposedModule) => {
     try {
@@ -1860,167 +1928,6 @@ function createExposeModuleLoader(config, ports) {
   return () => Promise.resolve(loadRemoteModule);
 }
 
-// src/lib/5.di/flows/init.factory.ts
-var createInitDrivers = ({
-  config,
-  adapters
-}) => ({
-  getRemoteEntries: createGetRemoteEntries(config, adapters),
-  processRemoteEntries: createProcessRemoteEntries(config, adapters),
-  determineSharedExternals: createDetermineSharedExternals(config, adapters),
-  generateImportMap: createGenerateImportMap(config, adapters),
-  commitChanges: createCommitChanges(config, adapters),
-  exposeModuleLoader: createExposeModuleLoader(config, adapters)
-});
-var INIT_FLOW_FACTORY = ({
-  config,
-  adapters
-}) => {
-  const flow = createInitDrivers({ config, adapters });
-  return {
-    flow,
-    adapters,
-    config
-  };
-};
-var createInitFlow = ({
-  flow,
-  adapters,
-  config
-}) => {
-  return (remotesOrManifestUrl) => flow.getRemoteEntries(remotesOrManifestUrl).then(flow.processRemoteEntries).then(flow.determineSharedExternals).then(flow.generateImportMap).then(flow.commitChanges).then(flow.exposeModuleLoader).then((loadRemoteModule) => ({
-    config,
-    adapters,
-    loadRemoteModule
-  }));
-};
-
-// src/lib/3.adapters/browser/browser.ts
-var createBrowser = (config) => {
-  return {
-    setImportMapFn: config.setImportMapFn,
-    importModule: config.loadModuleFn
-  };
-};
-
-// src/lib/3.adapters/checks/version.check.ts
-var import_valid = __toESM(require_valid());
-var import_satisfies = __toESM(require_satisfies());
-var import_compare = __toESM(require_compare());
-var import_min_version = __toESM(require_min_version());
-var import_valid2 = __toESM(require_valid2());
-var createVersionCheck = () => {
-  return {
-    isValidSemver: function(version) {
-      return (0, import_valid.default)(version) !== null;
-    },
-    isCompatible: function(version, range) {
-      return (0, import_satisfies.default)(version, range);
-    },
-    compare: function(versionA, versionB) {
-      return (0, import_compare.default)(versionA, versionB, true);
-    },
-    smallestVersion: function(versionRange) {
-      if (!(0, import_valid2.default)(versionRange)) return "0.0.0";
-      const minVersion = (0, import_min_version.default)(versionRange);
-      return minVersion?.raw ?? "0.0.0";
-    }
-  };
-};
-
-// src/lib/utils/integrity.ts
-var SUPPORTED_ALGORITHMS = {
-  "sha256-": "SHA-256",
-  "sha384-": "SHA-384",
-  "sha512-": "SHA-512"
-};
-var parseIntegrity = (integrity) => {
-  for (const prefix of Object.keys(SUPPORTED_ALGORITHMS)) {
-    if (integrity.startsWith(prefix)) {
-      return { algorithm: SUPPORTED_ALGORITHMS[prefix], expected: integrity };
-    }
-  }
-  return null;
-};
-var toBase64 = (bytes) => {
-  const view = new Uint8Array(bytes);
-  let bin = "";
-  for (let i = 0; i < view.length; i++) bin += String.fromCharCode(view[i]);
-  return btoa(bin);
-};
-var verifyIntegrity = async (bytes, integrity) => {
-  const parsed = parseIntegrity(integrity);
-  if (!parsed) {
-    throw new TypeError(
-      `Unsupported integrity prefix in '${integrity}'. Expected sha256-, sha384-, or sha512-.`
-    );
-  }
-  const subtle = typeof crypto !== "undefined" && crypto.subtle ? crypto.subtle : void 0;
-  if (!subtle) {
-    throw new Error("SubtleCrypto is not available in this environment.");
-  }
-  const digest = await subtle.digest(parsed.algorithm, bytes);
-  const actual = integrity.substring(0, integrity.indexOf("-") + 1) + toBase64(digest);
-  if (actual !== parsed.expected) {
-    throw new Error(`Integrity mismatch: expected ${parsed.expected}, got ${actual}`);
-  }
-};
-
-// src/lib/3.adapters/http/manifest-provider.ts
-var createManifestProvider = () => {
-  const ensureOk = (response) => {
-    if (!response.ok)
-      return Promise.reject(new NFError(`${response.status} - ${response.statusText}`));
-    return response;
-  };
-  const formatError = (manifestUrl) => (err) => {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new NFError(`Fetch of '${manifestUrl}' returned ${msg}`);
-  };
-  return {
-    provide: async function(remotesOrManifestUrl, opts = {}) {
-      if (typeof remotesOrManifestUrl !== "string") return Promise.resolve(remotesOrManifestUrl);
-      const parse = async (response) => {
-        if (!opts.integrity) return response.json();
-        const bytes = await response.arrayBuffer();
-        await verifyIntegrity(bytes, opts.integrity);
-        return JSON.parse(new TextDecoder().decode(bytes));
-      };
-      return fetch(remotesOrManifestUrl).then(ensureOk).then(parse).catch(formatError(remotesOrManifestUrl));
-    }
-  };
-};
-
-// src/lib/3.adapters/http/remote-entry-provider.ts
-var createRemoteEntryProvider = () => {
-  const ensureOk = (response) => {
-    if (!response.ok)
-      return Promise.reject(new Error(`${response.status} - ${response.statusText}`));
-    return response;
-  };
-  const fillEmptyFields = (remoteEntryUrl) => (remoteEntry) => {
-    if (!remoteEntry.exposes) remoteEntry.exposes = [];
-    if (!remoteEntry.shared) remoteEntry.shared = [];
-    if (!remoteEntry.url) remoteEntry.url = remoteEntryUrl;
-    return remoteEntry;
-  };
-  const formatError = (remoteEntryUrl) => (err) => {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new NFError(`Fetch of '${remoteEntryUrl}' returned ${msg}`);
-  };
-  return {
-    provide: async function(remoteEntryUrl, opts = {}) {
-      const parse = async (response) => {
-        if (!opts.integrity) return response.json();
-        const bytes = await response.arrayBuffer();
-        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));
-    }
-  };
-};
-
 // src/lib/utils/optional.ts
 var Optional = class _Optional {
   constructor(item) {
@@ -2060,42 +1967,422 @@ var Optional = class _Optional {
   }
 };
 
-// src/lib/3.adapters/storage/remote-info.repository.ts
-var createRemoteInfoRepository = (config) => {
-  const STORAGE = config.storage("remotes", {});
-  if (config.clearStorage) STORAGE.clear();
-  const _cache = STORAGE.get() ?? {};
-  return {
-    contains: function(remoteName) {
-      return !!_cache[remoteName];
-    },
-    remove: function(remoteName) {
-      delete _cache[remoteName];
-      return this;
-    },
-    addOrUpdate: function(remoteName, remote) {
-      _cache[remoteName] = remote;
-      return this;
-    },
-    tryGet: function(remoteName) {
-      return Optional.of(_cache[remoteName]);
-    },
-    tryGetModule: function(remoteName, exposedModule) {
-      return Optional.of(_cache[remoteName]?.exposes.find((m) => m.moduleName === exposedModule)).map(
-        (m) => join(_cache[remoteName].scopeUrl, m.file)
-      );
-    },
-    getAll: function() {
-      return _cache;
-    },
-    commit: function() {
-      STORAGE.set(_cache);
-      return this;
-    }
-  };
+// src/lib/core/2.app/steps/get-remote-entry.ts
+var normalizeRemoteRef = (remote) => {
+  if (!remote) return {};
+  if (typeof remote === "string") return { name: remote };
+  return remote;
+};
+function createGetRemoteEntry(config, ports) {
+  return async (remoteEntryUrl, remote) => {
+    const { name: remoteName, integrity } = normalizeRemoteRef(remote);
+    if (!!remoteName && shouldSkipCachedRemote(remoteEntryUrl, remoteName)) {
+      config.log.debug(7, `Found remote '${remoteName}' in storage, omitting fetch.`);
+      return Optional.empty();
+    }
+    try {
+      const remoteEntry = integrity ? await ports.remoteEntryProvider.provide(remoteEntryUrl, { integrity }) : await ports.remoteEntryProvider.provide(remoteEntryUrl);
+      config.log.debug(
+        7,
+        `[${remoteEntry.name}] Fetched from '${remoteEntry.url}', exposing: ${JSON.stringify(remoteEntry.exposes)}`
+      );
+      if (!!remoteName && remoteEntry.name !== remoteName) {
+        const errorMsg = `Fetched remote '${remoteEntry.name}' does not match requested '${remoteName}'.`;
+        if (config.strict.strictRemoteEntry) {
+          config.log.error(7, errorMsg);
+          throw new NFError("Could not fetch remote entry");
+        }
+        config.log.warn(7, errorMsg + " Omitting expected name.");
+      }
+      if (ports.remoteInfoRepo.contains(remoteEntry.name)) {
+        remoteEntry.override = true;
+        config.log.debug(7, `Overriding existing remote '${remoteName}' with '${remoteEntryUrl}'.`);
+      }
+      return Optional.of(checkForSSE(remoteEntry));
+    } catch (error) {
+      config.log.error(
+        7,
+        `[${remoteName ?? "unknown"}] Could not fetch remoteEntry from ${remoteEntryUrl}.`,
+        error
+      );
+      return Promise.reject(
+        new NFError(`[${remoteName ?? remoteEntryUrl}] Could not fetch remoteEntry.`)
+      );
+    }
+  };
+  function shouldSkipCachedRemote(remoteEntryUrl, remoteName) {
+    return ports.remoteInfoRepo.tryGet(remoteName).map(
+      (cachedRemoteInfo) => config.profile.overrideCachedRemotes !== "always" || !config.profile.overrideCachedRemotesIfURLMatches && remoteEntryUrl === join(cachedRemoteInfo.scopeUrl, "remoteEntry.json")
+    ).orElse(false);
+  }
+  function checkForSSE(entry) {
+    if (config.sse) {
+      if (entry.buildNotificationsEndpoint) {
+        ports.sse.watchRemoteBuilds(
+          join(getScope(entry.url), entry.buildNotificationsEndpoint)
+        );
+        config.log.debug(7, `Registered SSE endpoint of remote '${entry.name}' `);
+      } else {
+        config.log.debug(7, `Remote ${entry.name} has no defined 'buildNotificationsEndpoint'`);
+      }
+    }
+    return entry;
+  }
+}
+
+// src/lib/core/2.app/steps/update-cache.ts
+function createUpdateCache(config, ports) {
+  const storeRemoteEntry = createStoreRemoteEntry(config, ports, 8);
+  return (remoteEntry) => {
+    try {
+      const actions = {};
+      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(
+            entry,
+            external,
+            sharedVersion
+          );
+        }
+      });
+      return Promise.resolve({ entry: remoteEntry, actions });
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  };
+  function resolveSharedExternal(remoteEntry, sharedInfo, {
+    tag,
+    remote,
+    cached,
+    scopeType,
+    assertSameVersionCompatibility,
+    commit
+  }) {
+    let action = scopeType === "strict" ? "share" : "skip";
+    const sharedVersion = cached.versions.find((c) => c.action === "share");
+    const isCompatible = !sharedVersion || ports.versionCheck.isCompatible(sharedVersion.tag, remote.requiredVersion);
+    if (action === "skip" && !isCompatible && remote.strictVersion) {
+      action = "scope";
+      const errorMsg = `[${sharedInfo.shareScope ?? GLOBAL_SCOPE}][${remoteEntry.name}] ${sharedInfo.packageName}@${sharedInfo.version} Is not compatible with existing ${sharedInfo.packageName}@${sharedVersion.tag} requiredRange '${sharedVersion.remotes[0]?.requiredVersion}'`;
+      if (config.strict.strictExternalCompatibility) {
+        config.log.error(8, errorMsg);
+        throw new NFError(`Could not process remote '${remoteEntry.name}'`);
+      }
+      config.log.warn(8, errorMsg);
+    }
+    const matchingVersion = cached.versions.find((cached2) => cached2.tag === tag);
+    if (matchingVersion) {
+      assertSameVersionCompatibility(matchingVersion);
+      matchingVersion.remotes.push(remote);
+    } else {
+      if (!sharedVersion) action = "share";
+      remote.cached = action !== "skip";
+      cached.versions.push({ tag, action, host: false, remotes: [remote] });
+    }
+    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(() => {
+      config.log.error(
+        8,
+        `[${external.shareScope ?? GLOBAL_SCOPE}][${remoteEntry.name}][${external.packageName}@${external.version}][override] Remote name not found in cache.`
+      );
+      return new NFError(
+        `Could not find override url from remote ${sharedVersion.remotes[0].name}`
+      );
+    });
+  }
+}
+
+// src/lib/core/2.app/steps/convert-to-import-map.ts
+function createConvertToImportMap({ log }, ports) {
+  return ({ entry, actions }) => {
+    const importMap = { imports: {} };
+    addExternals(entry, actions, importMap);
+    addRemoteInfos(entry, importMap);
+    log.debug(9, `[${entry.name}] Processed actions:`, actions);
+    return Promise.resolve(importMap);
+  };
+  function addExternals(remoteEntry, actions, importMap) {
+    if (!remoteEntry.shared) {
+      return;
+    }
+    const remoteEntryScope = getScope(remoteEntry.url);
+    const integrityMap = remoteEntry.integrity;
+    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);
+        if (external?.bundle) chunkBundles.add(external?.bundle);
+        return;
+      }
+      if (!actions[external.packageName]) {
+        log.warn(
+          9,
+          `[${remoteEntry.name}] No action defined for shared external '${external.packageName}', skipping.`
+        );
+        return;
+      }
+      if (actions[external.packageName].action === "skip") {
+        if (!external.shareScope) return;
+        if (actions[external.packageName].override) {
+          addToScopes(
+            remoteEntryScope,
+            external.packageName,
+            actions[external.packageName].override,
+            importMap
+          );
+          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);
+        return;
+      }
+      if (external.shareScope) {
+        const url2 = join(remoteEntryScope, external.outFileName);
+        addToScopes(remoteEntryScope, external.packageName, url2, importMap);
+        addIntegrity(importMap, url2, integrityMap, external.outFileName);
+        return;
+      }
+      const url = join(remoteEntryScope, external.outFileName);
+      importMap.imports[external.packageName] = url;
+      addIntegrity(importMap, url, integrityMap, external.outFileName);
+    });
+    addChunkImports(importMap, remoteEntry, remoteEntryScope, chunkBundles);
+  }
+  function addToScopes(scope, packageName, url, importMap) {
+    if (!importMap.scopes) importMap.scopes = {};
+    if (!importMap.scopes[scope]) importMap.scopes[scope] = {};
+    importMap.scopes[scope][packageName] = url;
+  }
+  function addRemoteInfos(remoteEntry, importMap) {
+    if (!remoteEntry.exposes) return;
+    const scope = getScope(remoteEntry.url);
+    remoteEntry.exposes.forEach((exposed) => {
+      const moduleName = join(remoteEntry.name, exposed.key);
+      const moduleUrl = join(scope, exposed.outFileName);
+      importMap.imports[moduleName] = moduleUrl;
+      addIntegrity(importMap, moduleUrl, remoteEntry.integrity, exposed.outFileName);
+    });
+  }
+  function addChunkImports(importMap, remoteEntry, remoteEntryScope, chunkBundles) {
+    Array.from(chunkBundles).forEach((bundleName) => {
+      ports.sharedChunksRepo.tryGet(remoteEntry.name, bundleName).ifPresent((files) => {
+        files.forEach((file) => {
+          const url = join(remoteEntryScope, file);
+          addToScopes(remoteEntryScope, toChunkImport(file), url, importMap);
+          addIntegrity(importMap, url, remoteEntry.integrity, file);
+        });
+      });
+    });
+    return importMap;
+  }
+  function addIntegrity(importMap, url, integrityMap, file) {
+    const hash = integrityMap?.[file];
+    if (!hash) return;
+    if (!importMap.integrity) importMap.integrity = {};
+    importMap.integrity[url] = hash;
+  }
+}
+
+// src/lib/core/5.di/init.factory.ts
+var createInitDrivers = ({
+  config,
+  adapters
+}) => ({
+  getRemoteEntries: createGetRemoteEntries(config, adapters),
+  processRemoteEntries: createProcessRemoteEntries(config, adapters),
+  determineSharedExternals: createDetermineSharedExternals(config, adapters),
+  generateImportMap: createGenerateImportMap(config, adapters),
+  commitChanges: createCommitChanges(config, adapters),
+  exposeModuleLoader: createExposeModuleLoader(config, adapters),
+  getRemoteEntry: createGetRemoteEntry(config, adapters),
+  updateCache: createUpdateCache(config, adapters),
+  convertToImportMap: createConvertToImportMap(config, adapters)
+});
+var INIT_FLOW_FACTORY = ({
+  config,
+  adapters
+}) => {
+  const flow = createInitDrivers({ config, adapters });
+  return {
+    flow,
+    adapters,
+    config
+  };
+};
+
+// src/lib/core/3.adapters/browser/browser.ts
+var createBrowser = (config) => {
+  return {
+    setImportMapFn: config.setImportMapFn,
+    importModule: config.loadModuleFn
+  };
+};
+
+// src/lib/core/3.adapters/checks/version.check.ts
+var import_valid = __toESM(require_valid());
+var import_satisfies = __toESM(require_satisfies());
+var import_compare = __toESM(require_compare());
+var import_min_version = __toESM(require_min_version());
+var import_valid2 = __toESM(require_valid2());
+var createVersionCheck = () => {
+  return {
+    isValidSemver: function(version) {
+      return (0, import_valid.default)(version) !== null;
+    },
+    isCompatible: function(version, range) {
+      return (0, import_satisfies.default)(version, range);
+    },
+    compare: function(versionA, versionB) {
+      return (0, import_compare.default)(versionA, versionB, true);
+    },
+    smallestVersion: function(versionRange) {
+      if (!(0, import_valid2.default)(versionRange)) return "0.0.0";
+      const minVersion = (0, import_min_version.default)(versionRange);
+      return minVersion?.raw ?? "0.0.0";
+    }
+  };
+};
+
+// src/lib/utils/integrity.ts
+var SUPPORTED_ALGORITHMS = {
+  "sha256-": "SHA-256",
+  "sha384-": "SHA-384",
+  "sha512-": "SHA-512"
+};
+var parseIntegrity = (integrity) => {
+  for (const prefix of Object.keys(SUPPORTED_ALGORITHMS)) {
+    if (integrity.startsWith(prefix)) {
+      return { algorithm: SUPPORTED_ALGORITHMS[prefix], expected: integrity };
+    }
+  }
+  return null;
+};
+var toBase64 = (bytes) => {
+  const view = new Uint8Array(bytes);
+  let bin = "";
+  for (let i = 0; i < view.length; i++) bin += String.fromCharCode(view[i]);
+  return btoa(bin);
+};
+var verifyIntegrity = async (bytes, integrity) => {
+  const parsed = parseIntegrity(integrity);
+  if (!parsed) {
+    throw new TypeError(
+      `Unsupported integrity prefix in '${integrity}'. Expected sha256-, sha384-, or sha512-.`
+    );
+  }
+  const subtle = typeof crypto !== "undefined" && crypto.subtle ? crypto.subtle : void 0;
+  if (!subtle) {
+    throw new Error("SubtleCrypto is not available in this environment.");
+  }
+  const digest = await subtle.digest(parsed.algorithm, bytes);
+  const actual = integrity.substring(0, integrity.indexOf("-") + 1) + toBase64(digest);
+  if (actual !== parsed.expected) {
+    throw new Error(`Integrity mismatch: expected ${parsed.expected}, got ${actual}`);
+  }
+};
+
+// src/lib/core/3.adapters/http/manifest-provider.ts
+var createManifestProvider = () => {
+  const ensureOk = (response) => {
+    if (!response.ok)
+      return Promise.reject(new NFError(`${response.status} - ${response.statusText}`));
+    return response;
+  };
+  const formatError = (manifestUrl) => (err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new NFError(`Fetch of '${manifestUrl}' returned ${msg}`);
+  };
+  return {
+    provide: async function(remotesOrManifestUrl, opts = {}) {
+      if (typeof remotesOrManifestUrl !== "string") return Promise.resolve(remotesOrManifestUrl);
+      const parse = async (response) => {
+        if (!opts.integrity) return response.json();
+        const bytes = await response.arrayBuffer();
+        await verifyIntegrity(bytes, opts.integrity);
+        return JSON.parse(new TextDecoder().decode(bytes));
+      };
+      return fetch(remotesOrManifestUrl).then(ensureOk).then(parse).catch(formatError(remotesOrManifestUrl));
+    }
+  };
+};
+
+// src/lib/core/3.adapters/http/remote-entry-provider.ts
+var createRemoteEntryProvider = () => {
+  const ensureOk = (response) => {
+    if (!response.ok)
+      return Promise.reject(new Error(`${response.status} - ${response.statusText}`));
+    return response;
+  };
+  const fillEmptyFields = (remoteEntryUrl) => (remoteEntry) => {
+    if (!remoteEntry.exposes) remoteEntry.exposes = [];
+    if (!remoteEntry.shared) remoteEntry.shared = [];
+    if (!remoteEntry.url) remoteEntry.url = remoteEntryUrl;
+    return remoteEntry;
+  };
+  const formatError = (remoteEntryUrl) => (err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new NFError(`Fetch of '${remoteEntryUrl}' returned ${msg}`);
+  };
+  return {
+    provide: async function(remoteEntryUrl, opts = {}) {
+      const parse = async (response) => {
+        if (!opts.integrity) return response.json();
+        const bytes = await response.arrayBuffer();
+        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));
+    }
+  };
+};
+
+// src/lib/core/3.adapters/storage/remote-info.repository.ts
+var createRemoteInfoRepository = (config) => {
+  const STORAGE = config.storage("remotes", {});
+  if (config.clearStorage) STORAGE.clear();
+  const _cache = STORAGE.get() ?? {};
+  return {
+    contains: function(remoteName) {
+      return !!_cache[remoteName];
+    },
+    remove: function(remoteName) {
+      delete _cache[remoteName];
+      return this;
+    },
+    addOrUpdate: function(remoteName, remote) {
+      _cache[remoteName] = remote;
+      return this;
+    },
+    tryGet: function(remoteName) {
+      return Optional.of(_cache[remoteName]);
+    },
+    tryGetModule: function(remoteName, exposedModule) {
+      return Optional.of(_cache[remoteName]?.exposes.find((m) => m.moduleName === exposedModule)).map(
+        (m) => join(_cache[remoteName].scopeUrl, m.file)
+      );
+    },
+    getAll: function() {
+      return _cache;
+    },
+    commit: function() {
+      STORAGE.set(_cache);
+      return this;
+    }
+  };
 };
 
-// src/lib/3.adapters/storage/scoped-externals.repository.ts
+// src/lib/core/3.adapters/storage/scoped-externals.repository.ts
 var createScopedExternalsRepository = (config) => {
   const STORAGE = config.storage("scoped-externals", {});
   if (config.clearStorage) STORAGE.clear();
@@ -2123,7 +2410,7 @@ var createScopedExternalsRepository = (config) => {
   };
 };
 
-// src/lib/3.adapters/storage/shared-externals.repository.ts
+// src/lib/core/3.adapters/storage/shared-externals.repository.ts
 var createSharedExternalsRepository = (config) => {
   const STORAGE = config.storage(
     "shared-externals",
@@ -2189,7 +2476,7 @@ var createSharedExternalsRepository = (config) => {
   };
 };
 
-// src/lib/3.adapters/browser/sse-handler.ts
+// src/lib/core/3.adapters/browser/sse-handler.ts
 var createSSEHandler = (config) => {
   const subscribers = [];
   return {
@@ -2215,22 +2502,7 @@ var createSSEHandler = (config) => {
   };
 };
 
-// src/lib/utils/clone-entry.ts
-var cloneEntry = (name, raw) => {
-  try {
-    if (typeof structuredClone === "function") {
-      return structuredClone(raw);
-    }
-  } catch {
-  }
-  try {
-    return JSON.parse(JSON.stringify(raw));
-  } catch {
-  }
-  throw new NFError(`Could not clone entry '${String(name)}'`);
-};
-
-// src/lib/3.adapters/storage/chunk.repository.ts
+// src/lib/core/3.adapters/storage/chunk.repository.ts
 var createChunkRepository = (config) => {
   const STORAGE = config.storage("shared-chunks", {});
   if (config.clearStorage) STORAGE.clear();
@@ -2241,644 +2513,339 @@ var createChunkRepository = (config) => {
       _cache[remoteName][bundleName] = chunks;
       return this;
     },
-    tryGet: function(remoteName, bundleName) {
-      return Optional.of(_cache[remoteName]?.[bundleName]);
-    },
-    commit: function() {
-      STORAGE.set(_cache);
-      return this;
-    }
-  };
-};
-
-// src/lib/5.di/driving.factory.ts
-var createDriving = (config) => {
-  const adapters = {
-    versionCheck: createVersionCheck(),
-    manifestProvider: createManifestProvider(),
-    remoteEntryProvider: createRemoteEntryProvider(),
-    remoteInfoRepo: createRemoteInfoRepository(config),
-    scopedExternalsRepo: createScopedExternalsRepository(config),
-    sharedExternalsRepo: createSharedExternalsRepository(config),
-    sharedChunksRepo: createChunkRepository(config),
-    browser: createBrowser(config),
-    sse: createSSEHandler(config)
-  };
-  return { adapters, config };
-};
-
-// src/lib/4.config/import-map/trusted-types.ts
-var IMPORT_MAP_KEYS = /* @__PURE__ */ new Set(["imports", "scopes", "integrity"]);
-var validateImportMapJSON = (input) => {
-  let parsed;
-  try {
-    parsed = JSON.parse(input);
-  } catch {
-    throw new TypeError("[nf-orchestrator] trusted-types: import map is not valid JSON");
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new TypeError("[nf-orchestrator] trusted-types: import map must be a plain object");
-  }
-  for (const key of Object.keys(parsed)) {
-    if (!IMPORT_MAP_KEYS.has(key)) {
-      throw new TypeError(`[nf-orchestrator] trusted-types: unexpected key "${key}" in import map`);
-    }
-  }
-  return input;
-};
-var validateScriptURL = (input) => {
-  const base = typeof location !== "undefined" ? location.href : "http://localhost/";
-  let url;
-  try {
-    url = new URL(input, base);
-  } catch {
-    throw new TypeError(`[nf-orchestrator] trusted-types: invalid script URL "${input}"`);
-  }
-  if (url.protocol !== "https:" && url.protocol !== "http:") {
-    throw new TypeError(
-      `[nf-orchestrator] trusted-types: disallowed protocol "${url.protocol}" for script URL`
-    );
-  }
-  return input;
-};
-var passThroughPolicy = {
-  createScript: (input) => input,
-  createScriptURL: (input) => input
-};
-var cachedPolicy = null;
-var getTrustedTypesPolicy = (name = "nfo") => {
-  if (name === false) return passThroughPolicy;
-  if (cachedPolicy) return cachedPolicy;
-  const factory = globalThis.trustedTypes;
-  if (!factory) {
-    cachedPolicy = passThroughPolicy;
-    return cachedPolicy;
-  }
-  const native = factory.createPolicy(name, {
-    createScript: validateImportMapJSON,
-    createScriptURL: validateScriptURL
-  });
-  cachedPolicy = {
-    createScript: (input) => native.createScript(input),
-    createScriptURL: (input) => native.createScriptURL(input)
-  };
-  return cachedPolicy;
-};
-
-// src/lib/4.config/import-map/replace-in-dom.ts
-var replaceInDOM = (mapType, trustedTypesPolicyName = "nfo") => (importMap, opts = {}) => {
-  if (opts?.override) {
-    document.head.querySelectorAll(`script[type="${mapType}"]`).forEach((importMap2) => importMap2.remove());
-  }
-  const policy = getTrustedTypesPolicy(trustedTypesPolicyName);
-  document.head.appendChild(
-    Object.assign(document.createElement("script"), {
-      type: mapType,
-      text: policy.createScript(JSON.stringify(importMap))
-    })
-  );
-  return Promise.resolve(importMap);
-};
-
-// src/lib/4.config/import-map/use-default.ts
-var useDefaultImportMap = (trustedTypesPolicyName = "nfo") => ({
-  loadModuleFn: (url) => {
-    const trusted = getTrustedTypesPolicy(trustedTypesPolicyName).createScriptURL(url);
-    return import(
-      /* @vite-ignore */
-      trusted
-    );
-  },
-  setImportMapFn: replaceInDOM("importmap", trustedTypesPolicyName),
-  reloadBrowserFn: () => {
-    window.location.reload();
-  }
-});
-
-// src/lib/4.config/import-map/import-map.config.ts
-var createImportMapConfig = (o) => {
-  const fallback = useDefaultImportMap(o.trustedTypesPolicyName);
-  return {
-    setImportMapFn: o.setImportMapFn ?? fallback.setImportMapFn,
-    loadModuleFn: o.loadModuleFn ?? fallback.loadModuleFn,
-    reloadBrowserFn: o.reloadBrowserFn ?? fallback.reloadBrowserFn
-  };
-};
-
-// src/lib/4.config/host/host.config.ts
-var createHostConfig = (override) => {
-  const extras = override?.manifestIntegrity ? { manifestIntegrity: override.manifestIntegrity } : {};
-  if (!override?.hostRemoteEntry) {
-    return { hostRemoteEntry: false, ...extras };
-  }
-  if (typeof override.hostRemoteEntry === "string") {
-    return {
-      hostRemoteEntry: {
-        name: "__NF-HOST__",
-        url: override.hostRemoteEntry
-      },
-      ...extras
-    };
-  }
-  return {
-    hostRemoteEntry: {
-      name: "__NF-HOST__",
-      ...override.hostRemoteEntry
-    },
-    ...extras
-  };
-};
-
-// src/lib/4.config/logging/noop.logger.ts
-var noopLogger = {
-  debug: () => {
-  },
-  error: () => {
-  },
-  warn: () => {
-  }
-};
-
-// src/lib/2.app/config/log.contract.ts
-var LogLevel = {
-  debug: 0,
-  warn: 1,
-  error: 2
-};
-
-// src/lib/4.config/logging/log.handler.ts
-var createLogHandler = (logger, logLevel) => {
-  const logTypes = Object.keys(LogLevel).filter((key) => isNaN(Number(key)));
-  return logTypes.reduce(
-    (acc, logMessageType) => {
-      return {
-        ...acc,
-        [logMessageType]: (step, message, details) => {
-          if (LogLevel[logMessageType] >= LogLevel[logLevel]) {
-            logger[logMessageType](step, message, details);
-          }
-        }
-      };
-    },
-    { level: logLevel }
-  );
-};
-
-// src/lib/4.config/logging/log.config.ts
-var createLogConfig = ({ logger, logLevel, sse }) => ({
-  log: createLogHandler(logger ?? noopLogger, logLevel ?? "error"),
-  sse: !!sse
-});
-
-// src/lib/4.config/storage/global-this.storage.ts
-var globalThisStorageEntry = (namespace) => (key, initialValue) => {
-  if (!globalThis[namespace]) {
-    globalThis[namespace] = {};
-  }
-  const storage = globalThis[namespace];
-  if (!storage[key]) storage[key] = initialValue;
-  const entry = {
-    get() {
-      return cloneEntry(key, storage[key]);
-    },
-    set(value) {
-      storage[key] = cloneEntry(key, value);
-      return entry;
+    tryGet: function(remoteName, bundleName) {
+      return Optional.of(_cache[remoteName]?.[bundleName]);
     },
-    clear() {
-      storage[key] = cloneEntry(key, initialValue);
+    commit: function() {
+      STORAGE.set(_cache);
       return this;
     }
   };
-  return entry;
-};
-
-// src/lib/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
-});
-
-// src/lib/4.config/mode/default.profile.ts
-var defaultProfile = {
-  latestSharedExternal: false,
-  overrideCachedRemotes: "init-only",
-  overrideCachedRemotesIfURLMatches: false
 };
 
-// src/lib/4.config/mode/mode.config.ts
-var createModeConfig = (override) => {
-  const strictnessConfig = typeof override.strict === "boolean" ? {
-    strictRemoteEntry: override.strict,
-    strictExternalCompatibility: override.strict,
-    strictExternalSameVersionCompatibility: override.strict,
-    strictExternalVersion: override.strict,
-    strictImportMap: override.strict
-  } : {
-    strictRemoteEntry: override.strict?.strictRemoteEntry ?? false,
-    strictExternalCompatibility: override.strict?.strictExternalCompatibility ?? false,
-    strictExternalSameVersionCompatibility: override.strict?.strictExternalSameVersionCompatibility ?? false,
-    strictExternalVersion: override.strict?.strictExternalVersion ?? false,
-    strictImportMap: override.strict?.strictImportMap ?? false
-  };
-  return {
-    strict: strictnessConfig,
-    profile: { ...defaultProfile, ...override.profile ?? {} }
+// src/lib/core/5.di/driving.factory.ts
+var createDriving = (config) => {
+  const adapters = {
+    versionCheck: createVersionCheck(),
+    manifestProvider: createManifestProvider(),
+    remoteEntryProvider: createRemoteEntryProvider(),
+    remoteInfoRepo: createRemoteInfoRepository(config),
+    scopedExternalsRepo: createScopedExternalsRepository(config),
+    sharedExternalsRepo: createSharedExternalsRepository(config),
+    sharedChunksRepo: createChunkRepository(config),
+    browser: createBrowser(config),
+    sse: createSSEHandler(config)
   };
+  return { adapters, config };
 };
 
-// src/lib/5.di/config.factory.ts
-var createConfigHandlers = (overrides) => ({
-  ...createImportMapConfig(overrides),
-  ...createHostConfig(overrides),
-  ...createLogConfig(overrides),
-  ...createStorageConfig(overrides),
-  ...createModeConfig(overrides)
-});
-
-// src/lib/2.app/flows/dynamic-init/convert-to-import-map.ts
-function createConvertToImportMap({ log }, ports) {
-  return ({ entry, actions }) => {
-    const importMap = { imports: {} };
-    addExternals(entry, actions, importMap);
-    addRemoteInfos(entry, importMap);
-    log.debug(9, `[${entry.name}] Processed actions:`, actions);
-    return Promise.resolve(importMap);
-  };
-  function addExternals(remoteEntry, actions, importMap) {
-    if (!remoteEntry.shared) {
-      return;
-    }
-    const remoteEntryScope = getScope(remoteEntry.url);
-    const integrityMap = remoteEntry.integrity;
-    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);
-        if (external?.bundle) chunkBundles.add(external?.bundle);
-        return;
-      }
-      if (!actions[external.packageName]) {
-        log.warn(
-          9,
-          `[${remoteEntry.name}] No action defined for shared external '${external.packageName}', skipping.`
-        );
-        return;
-      }
-      if (actions[external.packageName].action === "skip") {
-        if (!external.shareScope) return;
-        if (actions[external.packageName].override) {
-          addToScopes(
-            remoteEntryScope,
-            external.packageName,
-            actions[external.packageName].override,
-            importMap
-          );
-          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);
-        return;
-      }
-      if (external.shareScope) {
-        const url2 = join(remoteEntryScope, external.outFileName);
-        addToScopes(remoteEntryScope, external.packageName, url2, importMap);
-        addIntegrity(importMap, url2, integrityMap, external.outFileName);
-        return;
-      }
-      const url = join(remoteEntryScope, external.outFileName);
-      importMap.imports[external.packageName] = url;
-      addIntegrity(importMap, url, integrityMap, external.outFileName);
-    });
-    addChunkImports(importMap, remoteEntry, remoteEntryScope, chunkBundles);
+// src/lib/core/4.config/import-map/trusted-types.ts
+var IMPORT_MAP_KEYS = /* @__PURE__ */ new Set(["imports", "scopes", "integrity"]);
+var validateImportMapJSON = (input) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch {
+    throw new TypeError("[nf-orchestrator] trusted-types: import map is not valid JSON");
   }
-  function addToScopes(scope, packageName, url, importMap) {
-    if (!importMap.scopes) importMap.scopes = {};
-    if (!importMap.scopes[scope]) importMap.scopes[scope] = {};
-    importMap.scopes[scope][packageName] = url;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new TypeError("[nf-orchestrator] trusted-types: import map must be a plain object");
   }
-  function addRemoteInfos(remoteEntry, importMap) {
-    if (!remoteEntry.exposes) return;
-    const scope = getScope(remoteEntry.url);
-    remoteEntry.exposes.forEach((exposed) => {
-      const moduleName = join(remoteEntry.name, exposed.key);
-      const moduleUrl = join(scope, exposed.outFileName);
-      importMap.imports[moduleName] = moduleUrl;
-      addIntegrity(importMap, moduleUrl, remoteEntry.integrity, exposed.outFileName);
-    });
+  for (const key of Object.keys(parsed)) {
+    if (!IMPORT_MAP_KEYS.has(key)) {
+      throw new TypeError(`[nf-orchestrator] trusted-types: unexpected key "${key}" in import map`);
+    }
   }
-  function addChunkImports(importMap, remoteEntry, remoteEntryScope, chunkBundles) {
-    Array.from(chunkBundles).forEach((bundleName) => {
-      ports.sharedChunksRepo.tryGet(remoteEntry.name, bundleName).ifPresent((files) => {
-        files.forEach((file) => {
-          const url = join(remoteEntryScope, file);
-          addToScopes(remoteEntryScope, toChunkImport(file), url, importMap);
-          addIntegrity(importMap, url, remoteEntry.integrity, file);
-        });
-      });
-    });
-    return importMap;
+  return input;
+};
+var validateScriptURL = (input) => {
+  const base = typeof location !== "undefined" ? location.href : "http://localhost/";
+  let url;
+  try {
+    url = new URL(input, base);
+  } catch {
+    throw new TypeError(`[nf-orchestrator] trusted-types: invalid script URL "${input}"`);
   }
-  function addIntegrity(importMap, url, integrityMap, file) {
-    const hash = integrityMap?.[file];
-    if (!hash) return;
-    if (!importMap.integrity) importMap.integrity = {};
-    importMap.integrity[url] = hash;
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new TypeError(
+      `[nf-orchestrator] trusted-types: disallowed protocol "${url.protocol}" for script URL`
+    );
   }
-}
-
-// src/lib/2.app/flows/dynamic-init/get-remote-entry.ts
-var normalizeRemoteRef = (remote) => {
-  if (!remote) return {};
-  if (typeof remote === "string") return { name: remote };
-  return remote;
+  return input;
 };
-function createGetRemoteEntry(config, ports) {
-  return async (remoteEntryUrl, remote) => {
-    const { name: remoteName, integrity } = normalizeRemoteRef(remote);
-    if (!!remoteName && shouldSkipCachedRemote(remoteEntryUrl, remoteName)) {
-      config.log.debug(7, `Found remote '${remoteName}' in storage, omitting fetch.`);
-      return Optional.empty();
-    }
-    try {
-      const remoteEntry = integrity ? await ports.remoteEntryProvider.provide(remoteEntryUrl, { integrity }) : await ports.remoteEntryProvider.provide(remoteEntryUrl);
-      config.log.debug(
-        7,
-        `[${remoteEntry.name}] Fetched from '${remoteEntry.url}', exposing: ${JSON.stringify(remoteEntry.exposes)}`
-      );
-      if (!!remoteName && remoteEntry.name !== remoteName) {
-        const errorMsg = `Fetched remote '${remoteEntry.name}' does not match requested '${remoteName}'.`;
-        if (config.strict.strictRemoteEntry) {
-          config.log.error(7, errorMsg);
-          throw new NFError("Could not fetch remote entry");
-        }
-        config.log.warn(7, errorMsg + " Omitting expected name.");
-      }
-      if (ports.remoteInfoRepo.contains(remoteEntry.name)) {
-        remoteEntry.override = true;
-        config.log.debug(7, `Overriding existing remote '${remoteName}' with '${remoteEntryUrl}'.`);
-      }
-      return Optional.of(checkForSSE(remoteEntry));
-    } catch (error) {
-      config.log.error(
-        7,
-        `[${remoteName ?? "unknown"}] Could not fetch remoteEntry from ${remoteEntryUrl}.`,
-        error
-      );
-      return Promise.reject(
-        new NFError(`[${remoteName ?? remoteEntryUrl}] Could not fetch remoteEntry.`)
-      );
-    }
-  };
-  function shouldSkipCachedRemote(remoteEntryUrl, remoteName) {
-    return ports.remoteInfoRepo.tryGet(remoteName).map(
-      (cachedRemoteInfo) => config.profile.overrideCachedRemotes !== "always" || !config.profile.overrideCachedRemotesIfURLMatches && remoteEntryUrl === join(cachedRemoteInfo.scopeUrl, "remoteEntry.json")
-    ).orElse(false);
+var passThroughPolicy = {
+  createScript: (input) => input,
+  createScriptURL: (input) => input
+};
+var cachedPolicy = null;
+var getTrustedTypesPolicy = (name = "nfo") => {
+  if (name === false) return passThroughPolicy;
+  if (cachedPolicy) return cachedPolicy;
+  const factory = globalThis.trustedTypes;
+  if (!factory) {
+    cachedPolicy = passThroughPolicy;
+    return cachedPolicy;
   }
-  function checkForSSE(entry) {
-    if (config.sse) {
-      if (entry.buildNotificationsEndpoint) {
-        ports.sse.watchRemoteBuilds(
-          join(getScope(entry.url), entry.buildNotificationsEndpoint)
-        );
-        config.log.debug(7, `Registered SSE endpoint of remote '${entry.name}' `);
-      } else {
-        config.log.debug(7, `Remote ${entry.name} has no defined 'buildNotificationsEndpoint'`);
-      }
-    }
-    return entry;
+  const native = factory.createPolicy(name, {
+    createScript: validateImportMapJSON,
+    createScriptURL: validateScriptURL
+  });
+  cachedPolicy = {
+    createScript: (input) => native.createScript(input),
+    createScriptURL: (input) => native.createScriptURL(input)
+  };
+  return cachedPolicy;
+};
+
+// src/lib/core/4.config/import-map/replace-in-dom.ts
+var replaceInDOM = (mapType, trustedTypesPolicyName = "nfo") => (importMap, opts = {}) => {
+  if (opts?.override) {
+    document.head.querySelectorAll(`script[type="${mapType}"]`).forEach((importMap2) => importMap2.remove());
   }
-}
+  const policy = getTrustedTypesPolicy(trustedTypesPolicyName);
+  document.head.appendChild(
+    Object.assign(document.createElement("script"), {
+      type: mapType,
+      text: policy.createScript(JSON.stringify(importMap))
+    })
+  );
+  return Promise.resolve(importMap);
+};
 
-// src/lib/2.app/flows/dynamic-init/update-cache.ts
-function createUpdateCache(config, ports) {
-  return (remoteEntry) => {
-    try {
-      if (remoteEntry?.override) removeCachedRemoteEntry(remoteEntry);
-      addRemoteInfoToStorage(remoteEntry);
-      const actions = mergeExternalsIntoStorage(remoteEntry);
-      addSharedChunksToStorage(remoteEntry);
-      return Promise.resolve({ entry: remoteEntry, actions });
-    } catch (error) {
-      return Promise.reject(error);
-    }
-  };
-  function removeCachedRemoteEntry(remoteEntry) {
-    ports.remoteInfoRepo.remove(remoteEntry.name);
-    ports.scopedExternalsRepo.remove(remoteEntry.name);
-    ports.sharedExternalsRepo.removeFromAllScopes(remoteEntry.name);
+// src/lib/core/4.config/import-map/use-default.ts
+var useDefaultImportMap = (trustedTypesPolicyName = "nfo") => ({
+  loadModuleFn: (url) => {
+    const trusted = getTrustedTypesPolicy(trustedTypesPolicyName).createScriptURL(url);
+    return import(
+      /* @vite-ignore */
+      trusted
+    );
+  },
+  setImportMapFn: replaceInDOM("importmap", trustedTypesPolicyName),
+  reloadBrowserFn: () => {
+    window.location.reload();
   }
-  function addRemoteInfoToStorage({ name, url, exposes }) {
-    ports.remoteInfoRepo.addOrUpdate(name, {
-      scopeUrl: getScope(url),
-      exposes: Object.values(exposes ?? []).map((m) => ({
-        moduleName: m.key,
-        file: m.outFileName
-      }))
-    });
+});
+
+// src/lib/core/4.config/import-map/import-map.config.ts
+var createImportMapConfig = (o) => {
+  const fallback = useDefaultImportMap(o.trustedTypesPolicyName);
+  return {
+    setImportMapFn: o.setImportMapFn ?? fallback.setImportMapFn,
+    loadModuleFn: o.loadModuleFn ?? fallback.loadModuleFn,
+    reloadBrowserFn: o.reloadBrowserFn ?? fallback.reloadBrowserFn
+  };
+};
+
+// src/lib/core/4.config/host/host.config.ts
+var createHostConfig = (override) => {
+  const extras = override?.manifestIntegrity ? { manifestIntegrity: override.manifestIntegrity } : {};
+  if (!override?.hostRemoteEntry) {
+    return { hostRemoteEntry: false, ...extras };
   }
-  function mergeExternalsIntoStorage(remoteEntry) {
-    const actions = {};
-    remoteEntry.shared.forEach((external) => {
-      if (!external.version || !ports.versionCheck.isValidSemver(external.version)) {
-        const errorMsg = `[${remoteEntry.name}][${external.packageName}] Version '${external.version}' is not a valid version.`;
-        if (config.strict.strictExternalVersion) {
-          config.log.error(8, errorMsg);
-          throw new NFError(`Could not process remote '${remoteEntry.name}'`);
-        }
-        config.log.warn(8, errorMsg);
-      }
-      if (external.singleton) {
-        const { action, sharedVersion } = addSharedExternal(remoteEntry.name, external);
-        actions[external.packageName] = { action };
-        if (action === "skip" && external.shareScope && sharedVersion?.remotes[0]?.file) {
-          actions[external.packageName].override = ports.remoteInfoRepo.tryGet(sharedVersion.remotes[0].name).map((remote) => join(remote.scopeUrl, sharedVersion.remotes[0].file)).orThrow(() => {
-            config.log.error(
-              8,
-              `[${external.shareScope ?? GLOBAL_SCOPE}][${remoteEntry.name}][${external.packageName}@${external.version}][override] Remote name not found in cache.`
-            );
-            return new NFError(
-              `Could not find override url from remote ${sharedVersion.remotes[0].name}`
-            );
-          });
-        }
-      } else {
-        addScopedExternal(remoteEntry.name, external);
-      }
-    });
-    return actions;
+  if (typeof override.hostRemoteEntry === "string") {
+    return {
+      hostRemoteEntry: {
+        name: "__NF-HOST__",
+        url: override.hostRemoteEntry
+      },
+      ...extras
+    };
   }
-  function addSharedChunksToStorage(remoteEntry) {
-    if (!remoteEntry.chunks) return;
-    config.log.debug(
-      8,
-      `Adding chunks for remote "${remoteEntry.name}", bundles: [${Object.keys(remoteEntry.chunks).join(", ")}]`
-    );
-    Object.entries(remoteEntry.chunks).forEach(([bundleName, chunks]) => {
-      ports.sharedChunksRepo.addOrReplace(remoteEntry.name, bundleName, chunks);
-    });
+  return {
+    hostRemoteEntry: {
+      name: "__NF-HOST__",
+      ...override.hostRemoteEntry
+    },
+    ...extras
+  };
+};
+
+// src/lib/core/4.config/logging/noop.logger.ts
+var noopLogger = {
+  debug: () => {
+  },
+  error: () => {
+  },
+  warn: () => {
   }
-  function addSharedExternal(remoteName, sharedInfo) {
-    const cached = ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).orElse({ dirty: false, versions: [] });
-    let action = "skip";
-    const tag = sharedInfo.version ?? ports.versionCheck.smallestVersion(sharedInfo.requiredVersion);
-    const remote = {
-      file: sharedInfo.outFileName,
-      strictVersion: sharedInfo.strictVersion,
-      requiredVersion: sharedInfo.requiredVersion || tag,
-      name: remoteName,
-      bundle: sharedInfo.bundle,
-      cached: false
-    };
-    const scopeType = ports.sharedExternalsRepo.scopeType(sharedInfo.shareScope);
-    if (scopeType === "strict") {
-      remote.requiredVersion = tag;
-      action = "share";
-    }
-    const sharedVersion = cached.versions.find((c) => c.action === "share");
-    const isCompatible = !sharedVersion || ports.versionCheck.isCompatible(sharedVersion.tag, remote.requiredVersion);
-    if (action === "skip" && !isCompatible && remote.strictVersion) {
-      action = "scope";
-      const errorMsg = `[${sharedInfo.shareScope ?? GLOBAL_SCOPE}][${remoteName}] ${sharedInfo.packageName}@${sharedInfo.version} Is not compatible with existing ${sharedInfo.packageName}@${sharedVersion.tag} requiredRange '${sharedVersion.remotes[0]?.requiredVersion}'`;
-      if (config.strict.strictExternalCompatibility) {
-        config.log.error(8, errorMsg);
-        throw new NFError(`Could not process remote '${remoteName}'`);
-      }
-      config.log.warn(8, errorMsg);
-    }
-    const matchingVersion = cached.versions.find((cached2) => cached2.tag === tag);
-    if (!!matchingVersion) {
-      if (remote.strictVersion && matchingVersion.remotes[0].requiredVersion !== remote.requiredVersion) {
-        const errorMsg = `[${remoteName}][${sharedInfo.packageName}@${sharedInfo.version}] Required version '${remote.requiredVersion}' does not match existing '${matchingVersion.remotes[0].requiredVersion}'`;
-        if (config.strict.strictExternalCompatibility) {
-          config.log.error(8, errorMsg);
-          throw new NFError(`Could not process remote '${remoteName}'`);
+};
+
+// src/lib/core/2.app/config/log.contract.ts
+var LogLevel = {
+  debug: 0,
+  warn: 1,
+  error: 2
+};
+
+// src/lib/core/4.config/logging/log.handler.ts
+var createLogHandler = (logger, logLevel) => {
+  const logTypes = Object.keys(LogLevel).filter((key) => isNaN(Number(key)));
+  return logTypes.reduce(
+    (acc, logMessageType) => {
+      return {
+        ...acc,
+        [logMessageType]: (step, message, details) => {
+          if (LogLevel[logMessageType] >= LogLevel[logLevel]) {
+            logger[logMessageType](step, message, details);
+          }
         }
-        config.log.warn(8, errorMsg);
-      }
-      matchingVersion.remotes.push(remote);
-    } else {
-      if (!sharedVersion) action = "share";
-      remote.cached = action !== "skip";
-      cached.versions.push({ tag, action, host: false, remotes: [remote] });
+      };
+    },
+    { level: logLevel }
+  );
+};
+
+// src/lib/core/4.config/logging/log.config.ts
+var createLogConfig = ({ logger, logLevel, sse }) => ({
+  log: createLogHandler(logger ?? noopLogger, logLevel ?? "error"),
+  sse: !!sse
+});
+
+// src/lib/utils/clone-entry.ts
+var cloneEntry = (name, raw) => {
+  try {
+    if (typeof structuredClone === "function") {
+      return structuredClone(raw);
     }
-    ports.sharedExternalsRepo.addOrUpdate(
-      sharedInfo.packageName,
-      {
-        dirty: cached.dirty,
-        versions: cached.versions.sort((a, b) => ports.versionCheck.compare(b.tag, a.tag))
-      },
-      sharedInfo.shareScope
-    );
-    return { action, sharedVersion };
+  } catch {
   }
-  function addScopedExternal(remoteName, sharedInfo) {
-    ports.scopedExternalsRepo.addExternal(remoteName, sharedInfo.packageName, {
-      tag: sharedInfo.version ?? ports.versionCheck.smallestVersion(sharedInfo.requiredVersion),
-      file: sharedInfo.outFileName,
-      bundle: sharedInfo.bundle
-    });
+  try {
+    return JSON.parse(JSON.stringify(raw));
+  } catch {
   }
-}
+  throw new NFError(`Could not clone entry '${String(name)}'`);
+};
 
-// src/lib/5.di/flows/dynamic-init.factory.ts
-var createDynamicInitDrivers = ({
-  config,
-  adapters
-}) => ({
-  getRemoteEntry: createGetRemoteEntry(config, adapters),
-  updateCache: createUpdateCache(config, adapters),
-  convertToImportMap: createConvertToImportMap(config, adapters),
-  commitChanges: createCommitChanges(config, adapters)
+// src/lib/core/4.config/storage/global-this.storage.ts
+var globalThisStorageEntry = (namespace) => (key, initialValue) => {
+  if (!globalThis[namespace]) {
+    globalThis[namespace] = {};
+  }
+  const storage = globalThis[namespace];
+  if (!storage[key]) storage[key] = initialValue;
+  const entry = {
+    get() {
+      return cloneEntry(key, storage[key]);
+    },
+    set(value) {
+      storage[key] = cloneEntry(key, value);
+      return entry;
+    },
+    clear() {
+      storage[key] = cloneEntry(key, initialValue);
+      return this;
+    }
+  };
+  return entry;
+};
+
+// 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 DYNAMIC_INIT_FLOW_FACTORY = ({
-  config,
-  adapters
-}) => {
-  const flow = createDynamicInitDrivers({ config, adapters });
+
+// src/lib/core/4.config/mode/default.profile.ts
+var defaultProfile = {
+  latestSharedExternal: false,
+  overrideCachedRemotes: "init-only",
+  overrideCachedRemotesIfURLMatches: false
+};
+
+// src/lib/core/4.config/mode/mode.config.ts
+var createModeConfig = (override) => {
+  const strictnessConfig = typeof override.strict === "boolean" ? {
+    strictRemoteEntry: override.strict,
+    strictExternalCompatibility: override.strict,
+    strictExternalSameVersionCompatibility: override.strict,
+    strictExternalVersion: override.strict,
+    strictImportMap: override.strict
+  } : {
+    strictRemoteEntry: override.strict?.strictRemoteEntry ?? false,
+    strictExternalCompatibility: override.strict?.strictExternalCompatibility ?? false,
+    strictExternalSameVersionCompatibility: override.strict?.strictExternalSameVersionCompatibility ?? false,
+    strictExternalVersion: override.strict?.strictExternalVersion ?? false,
+    strictImportMap: override.strict?.strictImportMap ?? false
+  };
   return {
-    flow,
-    adapters,
-    config
+    strict: strictnessConfig,
+    profile: { ...defaultProfile, ...override.profile ?? {} }
   };
 };
-var createDynamicInitFlow = ({
-  flow,
+
+// src/lib/core/5.di/config.factory.ts
+var createConfigHandlers = (overrides) => ({
+  ...createImportMapConfig(overrides),
+  ...createHostConfig(overrides),
+  ...createLogConfig(overrides),
+  ...createStorageConfig(overrides),
+  ...createModeConfig(overrides)
+});
+
+// src/lib/core/5.di/federation-result.factory.ts
+var createStateDump = (config, adapters) => (msg) => config.log.debug(0, msg, {
+  remotes: { ...adapters.remoteInfoRepo.getAll() },
+  "shared-externals": adapters.sharedExternalsRepo.getScopes({ includeGlobal: true }).reduce(
+    (acc, scope) => ({ ...acc, [scope]: adapters.sharedExternalsRepo.getFromScope(scope) }),
+    {}
+  ),
+  "scoped-externals": adapters.scopedExternalsRepo.getAll()
+});
+var createFederationResult = ({
+  config,
   adapters,
-  config
+  loadRemoteModule,
+  initRemoteEntryFlow,
+  afterInitRemoteEntry
 }) => {
-  const processDynamicRemoteEntry = async (remoteEntry) => {
-    return flow.updateCache(remoteEntry).then(flow.convertToImportMap).then(flow.commitChanges);
+  const stateDump = createStateDump(config, adapters);
+  const initRemoteEntry = async (remoteEntryUrl, remote) => {
+    const remoteName = typeof remote === "string" ? remote : remote?.name;
+    return initRemoteEntryFlow(remoteEntryUrl, remote).catch((e) => {
+      stateDump(`[dynamic-init][${remoteName ?? remoteEntryUrl}] STATE DUMP`);
+      if (config.strict.strictRemoteEntry) return Promise.reject(e);
+      else console.warn("Failed to initialize remote entry, continuing anyway.");
+      return Promise.resolve();
+    }).then(() => afterInitRemoteEntry?.()).then(() => result);
   };
-  const initRemoteEntry = (remoteEntryUrl, remote) => flow.getRemoteEntry(remoteEntryUrl, remote).then((entry) => entry.map(processDynamicRemoteEntry).orElse(Promise.resolve())).then(() => ({
+  const result = {
     config,
     adapters,
+    loadRemoteModule,
+    load: loadRemoteModule,
+    as: () => ({
+      loadRemoteModule,
+      load: loadRemoteModule
+    }),
     initRemoteEntry
-  }));
-  return initRemoteEntry;
+  };
+  return result;
 };
 
-// src/lib/init-federation.ts
+// src/lib/core/init-federation.ts
 var initFederation = (remotesOrManifestUrl, options = {}) => {
   const { adapters, config } = createDriving(createConfigHandlers(options));
-  const stateDump = (msg) => config.log.debug(0, msg, {
-    remotes: { ...adapters.remoteInfoRepo.getAll() },
-    "shared-externals": adapters.sharedExternalsRepo.getScopes({ includeGlobal: true }).reduce(
-      (acc, scope) => ({ ...acc, [scope]: adapters.sharedExternalsRepo.getFromScope(scope) }),
-      {}
-    ),
-    "scoped-externals": adapters.scopedExternalsRepo.getAll()
-  });
-  const initFlow = createInitFlow(INIT_FLOW_FACTORY({ adapters, config }));
-  const dynamicInitFlow = createDynamicInitFlow(DYNAMIC_INIT_FLOW_FACTORY({ config, adapters }));
-  return initFlow(remotesOrManifestUrl).then(({ loadRemoteModule }) => {
-    const output = {
-      config,
-      adapters,
-      loadRemoteModule,
-      as: () => ({
-        loadRemoteModule,
-        load: loadRemoteModule
-      }),
-      load: loadRemoteModule
-    };
-    const initRemoteEntry = async (remoteEntryUrl, remote) => {
-      const remoteName = typeof remote === "string" ? remote : remote?.name;
-      return dynamicInitFlow(remoteEntryUrl, remote).catch((e) => {
-        stateDump(`[dynamic-init][${remoteName ?? remoteEntryUrl}] STATE DUMP`);
-        if (config.strict.strictRemoteEntry) return Promise.reject(e);
-        else console.warn("Failed to initialize remote entry, continuing anyway.");
-        return Promise.resolve();
-      }).then(() => ({
-        ...output,
-        initRemoteEntry
-      }));
-    };
-    return {
-      ...output,
-      initRemoteEntry
-    };
-  }).catch((e) => {
-    stateDump(`[init] STATE DUMP`);
+  const factory = INIT_FLOW_FACTORY({ adapters, config });
+  const initFlow = createInitFlow(factory);
+  const initRemoteEntryFlow = createInitRemoteEntryFlow(factory);
+  return initFlow(remotesOrManifestUrl).then(
+    ({ loadRemoteModule }) => createFederationResult({ config, adapters, loadRemoteModule, initRemoteEntryFlow })
+  ).catch((e) => {
+    createStateDump(config, adapters)(`[init] STATE DUMP`);
     return Promise.reject(e);
   });
 };
 export {
-  DYNAMIC_INIT_FLOW_FACTORY,
   INIT_FLOW_FACTORY,
   NFError,
   createConfigHandlers,
   createDriving,
-  createDynamicInitDrivers,
-  createDynamicInitFlow,
+  createFederationResult,
   createInitDrivers,
   createInitFlow,
+  createInitRemoteEntryFlow,
+  createStateDump,
   initFederation
 };
 //# sourceMappingURL=native-federation-orchestrator.mjs.map