@bleedingdev/modern-js-plugin-bff-extensions 3.8.3-ultramodern.2

package/dist/cjs/backend-federation/load.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    loadBackendFederatedEffectApi: ()=>loadBackendFederatedEffectApi
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const Effect_namespaceObject = require("effect/Effect");
+const Logger_namespaceObject = require("effect/Logger");
+const external_legacy_warning_js_namespaceObject = require("./legacy-warning.js");
+const external_remotes_js_namespaceObject = require("./remotes.js");
+const external_runtime_js_namespaceObject = require("./runtime.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const external_validate_loaded_js_namespaceObject = require("./validate-loaded.js");
+const legacyWarningLogger = Logger_namespaceObject.withLeveledConsole(Logger_namespaceObject.formatLogFmt);
+function warnLegacyLoad() {
+    Effect_namespaceObject.runSync(Effect_namespaceObject.provideService(Effect_namespaceObject.logWarning(external_legacy_warning_js_namespaceObject.LEGACY_LOAD_WARNING), Logger_namespaceObject.CurrentLoggers, new Set([
+        legacyWarningLogger
+    ])));
+}
+function loadBackendFederatedEffectApi(options) {
+    const remoteName = options.remote?.name ?? options.remoteName;
+    if (void 0 === remoteName || 0 === remoteName.length) return Promise.reject(new Error('[BFF][Effect] Missing backend federation remote name.'));
+    if (void 0 === options.expected) warnLegacyLoad();
+    if (void 0 !== options.runtime) {
+        const configuredRemote = (0, external_remotes_js_namespaceObject.collectRemotes)(options).find((remote)=>remote.name === remoteName);
+        if (void 0 === configuredRemote || !/^(?:binding|service|static):/u.test(configuredRemote.entry)) return Promise.reject(new Error('[BFF][Effect] A custom Module Federation runtime requires a caller-pinned static or service-binding remote and cannot execute network backend federation entries.'));
+        if (void 0 !== configuredRemote.verification || options.entryPolicy?.expected !== void 0) return Promise.reject(new Error('[BFF][Effect] A custom Module Federation runtime cannot bypass verified backend entry loading.'));
+    }
+    const runtime = options.runtime ?? (0, external_runtime_js_namespaceObject.createBackendFederationRuntime)(options);
+    const expose = options.expose ?? options.remote?.expose ?? universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
+    const remoteRequest = `${remoteName}/${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)}`;
+    return runtime.loadRemote(remoteRequest).then((loaded)=>(0, external_validate_loaded_js_namespaceObject.validateLoadedBackendFederatedEffectApi)(loaded, {
+            allowMissingIdentityMetadata: options.allowMissingIdentityMetadata,
+            expected: options.expected,
+            remoteName,
+            remoteRequest
+        }));
+}
+exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "loadBackendFederatedEffectApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/backend-federation/node.js

@@ -0,0 +1,50 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    loadBackendFederatedEffectApi: ()=>loadBackendFederatedEffectApi
+});
+const node_namespaceObject = require("@modern-js/server-runtime-extensions/backend-federation-security/node");
+const external_load_js_namespaceObject = require("./load.js");
+function loadBackendFederatedEffectApi(options) {
+    return (0, external_load_js_namespaceObject.loadBackendFederatedEffectApi)({
+        ...options,
+        entryPolicy: {
+            ...options.entryPolicy,
+            evaluateCommonJs: options.entryPolicy?.evaluateCommonJs ?? node_namespaceObject.evaluateNodeBackendFederationCommonJs
+        }
+    });
+}
+exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "loadBackendFederatedEffectApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/backend-federation/plugin.js

@@ -0,0 +1,63 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function createBackendFederationLoadEntryPlugin(options) {
+    return {
+        name: 'modernjs-backend-federation-load-entry',
+        loadEntry ({ remoteInfo }) {
+            return Promise.resolve(options.resolveEntry({
+                name: remoteInfo.name,
+                entry: remoteInfo.entry,
+                type: remoteInfo.type,
+                entryGlobalName: remoteInfo.entryGlobalName,
+                shareScope: remoteInfo.shareScope
+            })).then((entry)=>{
+                if (void 0 === entry) return;
+                return {
+                    get (id) {
+                        return ()=>Promise.resolve(entry.get(id)).then((factory)=>factory());
+                    },
+                    init (...args) {
+                        return entry.init?.(...args);
+                    }
+                };
+            });
+        }
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    createBackendFederationLoadEntryPlugin: ()=>createBackendFederationLoadEntryPlugin
+});
+exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBackendFederationLoadEntryPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/backend-federation/remotes.js

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function collectRemotes(options) {
+    const remotes = [
+        ...options.remotes ?? []
+    ];
+    const configuredRemote = options.remote;
+    if (void 0 !== configuredRemote) {
+        const existingIndex = remotes.findIndex((remote)=>remote.name === configuredRemote.name);
+        if (existingIndex >= 0) remotes[existingIndex] = configuredRemote;
+        else remotes.push(configuredRemote);
+    }
+    return remotes;
+}
+__webpack_require__.d(__webpack_exports__, {
+    collectRemotes: ()=>collectRemotes
+});
+exports.collectRemotes = __webpack_exports__.collectRemotes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "collectRemotes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/backend-federation/runtime.js

@@ -0,0 +1,128 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createBackendFederationRuntime: ()=>createBackendFederationRuntime
+});
+const runtime_namespaceObject = require("@module-federation/runtime");
+const external_entry_js_namespaceObject = require("./entry.js");
+const external_plugin_js_namespaceObject = require("./plugin.js");
+const external_remotes_js_namespaceObject = require("./remotes.js");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+let nextRuntimeId = 0;
+function parseRemoteRequest(request) {
+    const [remoteName, ...exposeParts] = request.split('/');
+    if (void 0 === remoteName || 0 === remoteName.length || 0 === exposeParts.length) return;
+    return remoteName;
+}
+function createLocalEntryPlugin(options, remotes) {
+    return (0, external_plugin_js_namespaceObject.createBackendFederationLoadEntryPlugin)({
+        resolveEntry (resolvedRemote) {
+            const remote = remotes.find((candidate)=>candidate.name === resolvedRemote.name);
+            if (void 0 === remote) return;
+            return {
+                get (expose) {
+                    return ()=>(0, external_entry_js_namespaceObject.loadBackendFederationExpose)(remote, expose, options);
+                }
+            };
+        }
+    });
+}
+function isolateRegisteredRemoteEntries(remotes) {
+    const runtimeId = nextRuntimeId;
+    nextRuntimeId += 1;
+    return remotes.map((remote)=>({
+            ...remote,
+            entry: `${remote.entry}#modernjs-backend-runtime-${runtimeId}`
+        }));
+}
+var _remoteNames = /*#__PURE__*/ new WeakMap();
+class BackendFederationRuntime extends runtime_namespaceObject.ModuleFederation {
+    loadRemote(request, loadOptions) {
+        const remoteName = parseRemoteRequest(request);
+        if (void 0 === remoteName) return Promise.reject(new Error(`[BFF][Effect] Invalid backend federation request ${request}.`));
+        if (!_class_private_field_get(this, _remoteNames).has(remoteName)) return Promise.reject(new Error(`[BFF][Effect] Missing backend federation remote ${remoteName}.`));
+        return super.loadRemote(request, loadOptions);
+    }
+    constructor(options, remotes){
+        super({
+            name: options.hostName,
+            remotes: isolateRegisteredRemoteEntries(remotes),
+            shared: {},
+            plugins: [
+                createLocalEntryPlugin(options, remotes)
+            ]
+        }), _class_private_field_init(this, _remoteNames, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _remoteNames, new Set(remotes.map((remote)=>remote.name)));
+    }
+}
+function createBackendFederationRuntime(options) {
+    const remotes = (0, external_remotes_js_namespaceObject.collectRemotes)(options);
+    return new BackendFederationRuntime(options, remotes);
+}
+exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBackendFederationRuntime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/backend-federation/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/backend-federation/utils.js

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function normalizeExpose(expose) {
+    return expose.replace(/^\.\//u, '');
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+__webpack_require__.d(__webpack_exports__, {
+    isRecord: ()=>isRecord,
+    normalizeExpose: ()=>normalizeExpose
+});
+exports.isRecord = __webpack_exports__.isRecord;
+exports.normalizeExpose = __webpack_exports__.normalizeExpose;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isRecord",
+    "normalizeExpose"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/backend-federation/validate-loaded.js

@@ -0,0 +1,56 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    validateLoadedBackendFederatedEffectApi: ()=>validateLoadedBackendFederatedEffectApi
+});
+const external_identity_js_namespaceObject = require("./identity.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+function validateLoadedBackendFederatedEffectApi(loaded, options) {
+    if (!(0, external_utils_js_namespaceObject.isRecord)(loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} must load an object module.`);
+    const backendContract = loaded.backendFederationContract;
+    if (!(0, external_utils_js_namespaceObject.isRecord)(backendContract) || true !== backendContract.strictEffectApproach) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} must expose strict Effect metadata (strictEffectApproach: true).`);
+    if ('effect' !== backendContract.runtimeFramework) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} must expose strict Effect metadata (runtimeFramework: "effect").`);
+    if ('string' == typeof backendContract.name && backendContract.name !== options.remoteName) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} metadata name mismatch: expected ${options.remoteName}, received ${backendContract.name}.`);
+    if (!('runtime' in loaded)) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} must expose runtime.`);
+    if (void 0 !== options.expected) {
+        const issues = (0, external_identity_js_namespaceObject.validateExpectedBackendFederationIdentity)(loaded, options.expected, {
+            allowMissingIdentityMetadata: true === options.allowMissingIdentityMetadata
+        });
+        if (issues.length > 0) throw new Error(`[BFF][Effect] Backend federation expose ${options.remoteRequest} delivery-unit identity mismatch: ${(0, external_identity_js_namespaceObject.formatBackendFederationIdentityIssues)(issues)}.`);
+    }
+    return loaded;
+}
+exports.validateLoadedBackendFederatedEffectApi = __webpack_exports__.validateLoadedBackendFederatedEffectApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "validateLoadedBackendFederatedEffectApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/backend-federation-manifest/errors.js

@@ -0,0 +1,83 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT = 'modernjs:microvertical-server-fallback';
+class BackendFederationManifestAdapterError extends Error {
+    constructor(code, message, cause, details){
+        super(message), this.failureEvent = BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT;
+        this.name = 'BackendFederationManifestAdapterError';
+        this.code = code;
+        if (details) this.details = details;
+        if (void 0 !== cause) this.cause = cause;
+    }
+}
+function assertManifestAdapter(condition, code, message) {
+    if (!condition) throw new BackendFederationManifestAdapterError(code, message);
+}
+function assertVersionValue(actual, expected, label, details) {
+    if (void 0 === expected) return;
+    if (actual !== expected) throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation ${label} mismatch: expected ${expected}, received ${actual ?? 'undefined'}.`, void 0, {
+        label,
+        expected,
+        received: actual,
+        ...details
+    });
+}
+function assertConsistentValue(left, right, label, details) {
+    if (void 0 === left || void 0 === right || left === right) return;
+    throw new BackendFederationManifestAdapterError('version_mismatch', `[BFF][Effect] Backend federation ${label} mismatch: expected ${left}, received ${right}.`, void 0, {
+        label,
+        expected: left,
+        received: right,
+        ...details
+    });
+}
+__webpack_require__.d(__webpack_exports__, {
+    BackendFederationManifestAdapterError: ()=>BackendFederationManifestAdapterError,
+    assertConsistentValue: ()=>assertConsistentValue,
+    assertManifestAdapter: ()=>assertManifestAdapter,
+    assertVersionValue: ()=>assertVersionValue
+}, {
+    BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT: BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT
+});
+exports.BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT;
+exports.BackendFederationManifestAdapterError = __webpack_exports__.BackendFederationManifestAdapterError;
+exports.assertConsistentValue = __webpack_exports__.assertConsistentValue;
+exports.assertManifestAdapter = __webpack_exports__.assertManifestAdapter;
+exports.assertVersionValue = __webpack_exports__.assertVersionValue;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT",
+    "BackendFederationManifestAdapterError",
+    "assertConsistentValue",
+    "assertManifestAdapter",
+    "assertVersionValue"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/backend-federation-manifest/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    BackendFederationManifestAdapterError: ()=>external_errors_js_namespaceObject.BackendFederationManifestAdapterError,
+    loadBackendFederationManifest: ()=>external_reference_js_namespaceObject.loadBackendFederationManifest,
+    resolveBackendFederationRemoteFromManifest: ()=>external_remote_js_namespaceObject.resolveBackendFederationRemoteFromManifest
+});
+const external_errors_js_namespaceObject = require("./errors.js");
+const external_reference_js_namespaceObject = require("./reference.js");
+const external_remote_js_namespaceObject = require("./remote.js");
+exports.BackendFederationManifestAdapterError = __webpack_exports__.BackendFederationManifestAdapterError;
+exports.loadBackendFederationManifest = __webpack_exports__.loadBackendFederationManifest;
+exports.resolveBackendFederationRemoteFromManifest = __webpack_exports__.resolveBackendFederationRemoteFromManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BackendFederationManifestAdapterError",
+    "loadBackendFederationManifest",
+    "resolveBackendFederationRemoteFromManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});