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

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+Copyright (c) 2026 BleedingDev contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# @modern-js/plugin-bff-extensions
+
+Fork-owned integration extensions for UltraModern.js BFFs. This package keeps
+Effect adapter lifecycle integration, source and client generation,
+cross-project policy, Hono middleware, and backend federation out of the
+upstream-owned `@modern-js/plugin-bff` implementation.
+
+This package is maintained by the
+[UltraModern.js fork](https://github.com/BleedingDev/ultramodern.js), not the
+upstream Modern.js project.
+
+## Entry points
+
+- `/hono` exposes the peer-independent Hono route binder.
+- `/cross-project-policy`, `/effect-adapter`, `/effect-source-loader`, and
+  `/client-generator` expose Node tooling and server integration.
+- `/cross-project-generation` renders the generated producer client runtime
+  consumed by `@modern-js/plugin-bff`.
+- `/backend-federation` exposes the portable federation runtime, while
+  `/backend-federation/edge` rejects Node evaluators and non-binding remotes.
+- `/backend-federation/node` enables the hardened Node entry evaluator.
+- `/backend-federation-manifest` exposes manifest contracts and resolution,
+  while
+  `/backend-federation-manifest/node` enables its hardened Node evaluator.
+
+Effect and its OpenTelemetry integration are exact-cohort optional peers. A
+Hono-only consumer can import `/hono` without installing Effect.
+
+There is deliberately no adapter-kit or re-export-only compatibility layer.

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

@@ -0,0 +1,230 @@
+"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__, {
+    createBackendFederationLoadEntryPlugin: ()=>createBackendFederationLoadEntryPlugin,
+    createBackendFederationRuntime: ()=>createBackendFederationRuntime,
+    createBackendFederationRuntimeForLoad: ()=>createBackendFederationRuntimeForLoad
+});
+const external_validate_loaded_js_namespaceObject = require("./validate-loaded.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;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function parseRemoteRequest(request) {
+    const separator = request.indexOf('/');
+    if (separator <= 0 || separator === request.length - 1) throw new Error(`[BFF][Effect] Invalid backend federation request ${request}.`);
+    return {
+        expose: `./${request.slice(separator + 1).replace(/^\.\//u, '')}`,
+        remoteName: request.slice(0, separator)
+    };
+}
+function requireEdgeRemote(remotes, remoteName) {
+    const remote = remotes.find((candidate)=>candidate.name === remoteName);
+    if (void 0 === remote) throw new Error(`[BFF][Effect] Missing backend federation remote ${remoteName}.`);
+    if (!/^(?:binding|service|static):/u.test(remote.entry)) throw new Error(`[BFF][Effect] Edge backend federation remote ${remote.name} must use static or service-binding entries.`);
+    return remote;
+}
+async function resolveEdgeEntry(plugins, remote) {
+    for (const plugin of plugins){
+        const entry = await plugin.loadEntry?.({
+            remoteInfo: remote
+        });
+        if (void 0 !== entry) return entry;
+    }
+    if (remote.entry.startsWith('static:') && remote.entryGlobalName) {
+        const globalEntry = globalThis[remote.entryGlobalName];
+        if ('object' == typeof globalEntry && null !== globalEntry) return globalEntry;
+        throw new Error(`[BFF][Effect] Missing static backend federation entry global ${remote.entryGlobalName} for remote ${remote.name}.`);
+    }
+    throw new Error(`[BFF][Effect] Missing static or service-binding entry provider for backend federation remote ${remote.name}.`);
+}
+var _entries = /*#__PURE__*/ new WeakMap(), _expected = /*#__PURE__*/ new WeakMap(), _hostName = /*#__PURE__*/ new WeakMap(), _allowMissingIdentityMetadata = /*#__PURE__*/ new WeakMap(), _modules = /*#__PURE__*/ new WeakMap(), _plugins = /*#__PURE__*/ new WeakMap(), _remotes = /*#__PURE__*/ new WeakMap(), _loadEntry = /*#__PURE__*/ new WeakSet(), _loadModule = /*#__PURE__*/ new WeakSet();
+class EdgeBackendFederationRuntime {
+    async loadRemote(request) {
+        const existing = _class_private_field_get(this, _modules).get(request);
+        if (void 0 !== existing) return existing;
+        const loading = _class_private_method_get(this, _loadModule, loadModule).call(this, request);
+        _class_private_field_get(this, _modules).set(request, loading);
+        loading.catch(()=>{
+            if (_class_private_field_get(this, _modules).get(request) === loading) _class_private_field_get(this, _modules).delete(request);
+        });
+        return loading;
+    }
+    constructor(options){
+        _class_private_method_init(this, _loadEntry);
+        _class_private_method_init(this, _loadModule);
+        _class_private_field_init(this, _entries, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _expected, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _hostName, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _allowMissingIdentityMetadata, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _modules, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _plugins, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _remotes, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _entries, new Map());
+        _class_private_field_set(this, _modules, new Map());
+        if (void 0 !== options.entryPolicy) throw new Error('[BFF][Effect] Edge backend federation does not execute entry evaluators. Register a static or service-binding entry provider.');
+        _class_private_field_set(this, _allowMissingIdentityMetadata, true === options.allowMissingIdentityMetadata);
+        _class_private_field_set(this, _expected, options.expected);
+        _class_private_field_set(this, _hostName, options.hostName);
+        _class_private_field_set(this, _plugins, options.plugins ?? []);
+        _class_private_field_set(this, _remotes, [
+            ...options.remotes ?? []
+        ]);
+        const configuredRemote = options.remote;
+        if (void 0 !== configuredRemote) {
+            const existingIndex = _class_private_field_get(this, _remotes).findIndex((remote)=>remote.name === configuredRemote.name);
+            if (existingIndex >= 0) _class_private_field_get(this, _remotes)[existingIndex] = configuredRemote;
+            else _class_private_field_get(this, _remotes).push(configuredRemote);
+        }
+    }
+}
+function loadEntry(remote) {
+    const existing = _class_private_field_get(this, _entries).get(remote.name);
+    if (void 0 !== existing) return existing;
+    const loading = resolveEdgeEntry(_class_private_field_get(this, _plugins), remote).then(async (entry)=>{
+        await entry.init?.({
+            hostName: _class_private_field_get(this, _hostName)
+        });
+        return entry;
+    });
+    _class_private_field_get(this, _entries).set(remote.name, loading);
+    loading.catch(()=>{
+        if (_class_private_field_get(this, _entries).get(remote.name) === loading) _class_private_field_get(this, _entries).delete(remote.name);
+    });
+    return loading;
+}
+function loadModule(request) {
+    const { expose, remoteName } = parseRemoteRequest(request);
+    const remote = requireEdgeRemote(_class_private_field_get(this, _remotes), remoteName);
+    return _class_private_method_get(this, _loadEntry, loadEntry).call(this, remote).then(async (entry)=>{
+        if ('function' != typeof entry.get) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must expose get().`);
+        const factory = await entry.get(expose);
+        if ('function' != typeof factory) throw new Error(`[BFF][Effect] Backend federation expose ${remote.name}/${expose.replace(/^\.\//u, '')} must load factory function.`);
+        const loaded = await factory();
+        return (0, external_validate_loaded_js_namespaceObject.validateLoadedBackendFederatedEffectApi)(loaded, {
+            allowMissingIdentityMetadata: _class_private_field_get(this, _allowMissingIdentityMetadata),
+            expected: _class_private_field_get(this, _expected),
+            remoteName,
+            remoteRequest: request
+        });
+    });
+}
+function createBackendFederationLoadEntryPlugin(options) {
+    return {
+        name: 'modernjs-backend-federation-load-entry',
+        loadEntry ({ remoteInfo }) {
+            return Promise.resolve(options.resolveEntry(remoteInfo)).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);
+                    }
+                };
+            });
+        }
+    };
+}
+function createBackendFederationRuntime(options) {
+    if (void 0 === options.expected || 'string' != typeof options.expected.unitId || 0 === options.expected.unitId.length || 'string' != typeof options.expected.buildMarker || 0 === options.expected.buildMarker.length) throw new Error('[BFF][Effect] Edge backend federation runtime requires expected.unitId and expected.buildMarker.');
+    return new EdgeBackendFederationRuntime(options);
+}
+function createBackendFederationRuntimeForLoad(options) {
+    return new EdgeBackendFederationRuntime(options);
+}
+exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
+exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
+exports.createBackendFederationRuntimeForLoad = __webpack_exports__.createBackendFederationRuntimeForLoad;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBackendFederationLoadEntryPlugin",
+    "createBackendFederationRuntime",
+    "createBackendFederationRuntimeForLoad"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,80 @@
+"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__, {
+    BACKEND_FEDERATION_CONTRACT_VERSION: ()=>universal_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION,
+    BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE,
+    BACKEND_FEDERATION_MANIFEST_FILE: ()=>universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+    BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>universal_namespaceObject.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+    createBackendFederationLoadEntryPlugin: ()=>external_edge_runtime_js_namespaceObject.createBackendFederationLoadEntryPlugin,
+    createBackendFederationRuntime: ()=>external_edge_runtime_js_namespaceObject.createBackendFederationRuntime,
+    loadBackendFederatedEffectApi: ()=>loadBackendFederatedEffectApi,
+    validateExpectedBackendFederationIdentity: ()=>external_identity_js_namespaceObject.validateExpectedBackendFederationIdentity
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_edge_runtime_js_namespaceObject = require("./edge-runtime.js");
+const external_legacy_warning_js_namespaceObject = require("./legacy-warning.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const external_identity_js_namespaceObject = require("./identity.js");
+function loadBackendFederatedEffectApi(options) {
+    if (void 0 !== options.runtime || void 0 !== options.entryPolicy) return Promise.reject(new Error('[BFF][Effect] Edge backend federation does not execute custom runtimes or entry evaluators. Register a static or service-binding entry provider.'));
+    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) console.warn(external_legacy_warning_js_namespaceObject.LEGACY_LOAD_WARNING);
+    const expose = options.expose ?? options.remote?.expose ?? universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE;
+    const remoteRequest = `${remoteName}/${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)}`;
+    let runtime;
+    try {
+        runtime = (0, external_edge_runtime_js_namespaceObject.createBackendFederationRuntimeForLoad)(options);
+    } catch (error) {
+        return Promise.reject(error);
+    }
+    return runtime.loadRemote(remoteRequest);
+}
+exports.BACKEND_FEDERATION_CONTRACT_VERSION = __webpack_exports__.BACKEND_FEDERATION_CONTRACT_VERSION;
+exports.BACKEND_FEDERATION_EFFECT_EXPOSE = __webpack_exports__.BACKEND_FEDERATION_EFFECT_EXPOSE;
+exports.BACKEND_FEDERATION_MANIFEST_FILE = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_FILE;
+exports.BACKEND_FEDERATION_NODE_ADAPTER_VERSION = __webpack_exports__.BACKEND_FEDERATION_NODE_ADAPTER_VERSION;
+exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
+exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
+exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
+exports.validateExpectedBackendFederationIdentity = __webpack_exports__.validateExpectedBackendFederationIdentity;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BACKEND_FEDERATION_CONTRACT_VERSION",
+    "BACKEND_FEDERATION_EFFECT_EXPOSE",
+    "BACKEND_FEDERATION_MANIFEST_FILE",
+    "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
+    "createBackendFederationLoadEntryPlugin",
+    "createBackendFederationRuntime",
+    "loadBackendFederatedEffectApi",
+    "validateExpectedBackendFederationIdentity"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,94 @@
+"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__, {
+    loadBackendFederationExpose: ()=>loadBackendFederationExpose
+});
+const backend_federation_security_namespaceObject = require("@modern-js/server-runtime-extensions/backend-federation-security");
+const external_utils_js_namespaceObject = require("./utils.js");
+function decodeDataUrl(url) {
+    const commaIndex = url.indexOf(',');
+    if (commaIndex < 0) throw new Error('[BFF][Effect] Invalid backend federation data URL entry.');
+    return decodeURIComponent(url.slice(commaIndex + 1));
+}
+async function readCommonJsEntrySource(remote) {
+    if (remote.entry.startsWith('data:')) return decodeDataUrl(remote.entry);
+    throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} cannot load CommonJS entry ${remote.entry}.`);
+}
+async function importModuleEntry(remote) {
+    const entry = await import(remote.entry);
+    return entry.default ?? entry;
+}
+async function resolvePluginEntry(remote, plugins) {
+    for (const plugin of plugins ?? []){
+        const loadEntry = plugin.loadEntry;
+        if ('function' != typeof loadEntry) continue;
+        const entry = await loadEntry({
+            remoteInfo: remote
+        });
+        if (entry) return entry;
+    }
+}
+async function loadBackendFederationEntry(remote, options) {
+    const requiresVerification = Boolean(remote.verification || options.entryPolicy?.expected);
+    const isNetworkEntry = /^https?:\/\//iu.test(remote.entry);
+    if (isNetworkEntry && !requiresVerification) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} requires verified entry bytes before network execution.`);
+    if (requiresVerification) return (0, backend_federation_security_namespaceObject.loadVerifiedBackendFederationEntry)({
+        ...options.entryPolicy,
+        remote,
+        ...remote.verification ? {
+            verification: remote.verification
+        } : {}
+    });
+    const pluginEntry = await resolvePluginEntry(remote, options.plugins);
+    if (pluginEntry) return pluginEntry;
+    if (remote.entryGlobalName) {
+        const globalEntry = globalThis[remote.entryGlobalName];
+        if ((0, external_utils_js_namespaceObject.isRecord)(globalEntry)) return globalEntry;
+    }
+    if ('module' === remote.type || remote.entry.startsWith('file:')) return importModuleEntry(remote);
+    return (0, backend_federation_security_namespaceObject.evaluateBackendFederationCommonJsEntry)(remote, new TextEncoder().encode(await readCommonJsEntrySource(remote)), options.entryPolicy?.evaluateCommonJs);
+}
+async function loadBackendFederationExpose(remote, expose, options) {
+    const entry = await loadBackendFederationEntry(remote, options);
+    if ('function' == typeof entry.init) await entry.init({
+        hostName: options.hostName
+    });
+    if ('function' != typeof entry.get) throw new Error(`[BFF][Effect] Backend federation remote ${remote.name} entry must expose get().`);
+    const factory = await entry.get(expose);
+    if ('function' != typeof factory) throw new Error(`[BFF][Effect] Backend federation expose ${remote.name}/${(0, external_utils_js_namespaceObject.normalizeExpose)(expose)} must load factory function.`);
+    return factory();
+}
+exports.loadBackendFederationExpose = __webpack_exports__.loadBackendFederationExpose;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "loadBackendFederationExpose"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,82 @@
+"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__, {
+    formatBackendFederationIdentityIssues: ()=>formatBackendFederationIdentityIssues,
+    validateExpectedBackendFederationIdentity: ()=>validateExpectedBackendFederationIdentity
+});
+const external_utils_js_namespaceObject = require("./utils.js");
+function validateExpectedBackendFederationIdentity(loaded, expected, options = {}) {
+    const allowMissing = true === options.allowMissingIdentityMetadata;
+    const issues = [];
+    const contract = (0, external_utils_js_namespaceObject.isRecord)(loaded) ? loaded.backendFederationContract : void 0;
+    const compatibility = (0, external_utils_js_namespaceObject.isRecord)(contract) ? contract.compatibility : void 0;
+    if (!(0, external_utils_js_namespaceObject.isRecord)(compatibility)) {
+        if (allowMissing) return [];
+        return [
+            {
+                path: 'backendFederationContract.compatibility',
+                message: 'loaded module declares no compatibility metadata; delivery-unit identity cannot be validated'
+            }
+        ];
+    }
+    const unitId = compatibility.unitId;
+    if ('string' != typeof unitId || 0 === unitId.length) {
+        if (!allowMissing) issues.push({
+            path: 'backendFederationContract.compatibility.unitId',
+            message: `missing delivery-unit id; expected ${expected.unitId}`
+        });
+    } else if (unitId !== expected.unitId) issues.push({
+        path: 'backendFederationContract.compatibility.unitId',
+        message: `expected ${expected.unitId}, received ${unitId}`
+    });
+    const build = compatibility.build;
+    if ('string' != typeof build || 0 === build.length) {
+        if (!allowMissing) issues.push({
+            path: 'backendFederationContract.compatibility.build',
+            message: `missing build marker; expected ${expected.buildMarker}`
+        });
+    } else if (build !== expected.buildMarker) issues.push({
+        path: 'backendFederationContract.compatibility.build',
+        message: `expected ${expected.buildMarker}, received ${build}`
+    });
+    return issues;
+}
+function formatBackendFederationIdentityIssues(issues) {
+    return issues.map((issue)=>`${issue.path}: ${issue.message}`).join('; ');
+}
+exports.formatBackendFederationIdentityIssues = __webpack_exports__.formatBackendFederationIdentityIssues;
+exports.validateExpectedBackendFederationIdentity = __webpack_exports__.validateExpectedBackendFederationIdentity;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "formatBackendFederationIdentityIssues",
+    "validateExpectedBackendFederationIdentity"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,61 @@
+"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__, {
+    BACKEND_FEDERATION_CONTRACT_VERSION: ()=>universal_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION,
+    BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE,
+    BACKEND_FEDERATION_MANIFEST_FILE: ()=>universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+    BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>universal_namespaceObject.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+    createBackendFederationLoadEntryPlugin: ()=>external_plugin_js_namespaceObject.createBackendFederationLoadEntryPlugin,
+    createBackendFederationRuntime: ()=>external_runtime_js_namespaceObject.createBackendFederationRuntime,
+    validateExpectedBackendFederationIdentity: ()=>external_identity_js_namespaceObject.validateExpectedBackendFederationIdentity
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_identity_js_namespaceObject = require("./identity.js");
+const external_plugin_js_namespaceObject = require("./plugin.js");
+const external_runtime_js_namespaceObject = require("./runtime.js");
+exports.BACKEND_FEDERATION_CONTRACT_VERSION = __webpack_exports__.BACKEND_FEDERATION_CONTRACT_VERSION;
+exports.BACKEND_FEDERATION_EFFECT_EXPOSE = __webpack_exports__.BACKEND_FEDERATION_EFFECT_EXPOSE;
+exports.BACKEND_FEDERATION_MANIFEST_FILE = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_FILE;
+exports.BACKEND_FEDERATION_NODE_ADAPTER_VERSION = __webpack_exports__.BACKEND_FEDERATION_NODE_ADAPTER_VERSION;
+exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
+exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
+exports.validateExpectedBackendFederationIdentity = __webpack_exports__.validateExpectedBackendFederationIdentity;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BACKEND_FEDERATION_CONTRACT_VERSION",
+    "BACKEND_FEDERATION_EFFECT_EXPOSE",
+    "BACKEND_FEDERATION_MANIFEST_FILE",
+    "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
+    "createBackendFederationLoadEntryPlugin",
+    "createBackendFederationRuntime",
+    "validateExpectedBackendFederationIdentity"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/backend-federation/legacy-warning.js

@@ -0,0 +1,40 @@
+"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 LEGACY_LOAD_WARNING = '[BFF][Effect] loadBackendFederatedEffectApi was called without an expected delivery-unit identity (expected.unitId + expected.buildMarker). Identity-less public backend loads are deprecated (ADR-0019/MV-G23) and will be rejected in a future major.';
+__webpack_require__.d(__webpack_exports__, {}, {
+    LEGACY_LOAD_WARNING: LEGACY_LOAD_WARNING
+});
+exports.LEGACY_LOAD_WARNING = __webpack_exports__.LEGACY_LOAD_WARNING;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "LEGACY_LOAD_WARNING"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});